From ac6b987f64e1ffa941e858c5aae672712971bf7e Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Thu, 6 Mar 2025 12:51:32 -0500
Subject: [PATCH 001/418] Initial commit for uniswap

---
 primitives/uniswap/Cargo.toml | 20 ++++++++++++++++++++
 primitives/uniswap/src/lib.rs | 19 +++++++++++++++++++
 2 files changed, 39 insertions(+)
 create mode 100644 primitives/uniswap/Cargo.toml
 create mode 100644 primitives/uniswap/src/lib.rs

diff --git a/primitives/uniswap/Cargo.toml b/primitives/uniswap/Cargo.toml
new file mode 100644
index 0000000000..3b884c1458
--- /dev/null
+++ b/primitives/uniswap/Cargo.toml
@@ -0,0 +1,20 @@
+[package]
+name = "uniswap"
+version = "0.1.0"
+edition = "2025"
+
+[dependencies]
+substrate-fixed = { workspace = true }
+sp-std = { workspace = true }
+safe-math = { default-features = false, path = "../safe-math" }
+
+[lints]
+workspace = true
+
+[features]
+default = ["std"]
+std = [
+	"substrate-fixed/std",
+	"sp-std/std",
+	"safe-math/std",
+]
diff --git a/primitives/uniswap/src/lib.rs b/primitives/uniswap/src/lib.rs
new file mode 100644
index 0000000000..cb48bc79f3
--- /dev/null
+++ b/primitives/uniswap/src/lib.rs
@@ -0,0 +1,19 @@
+/// Position designates one liquidity position. 
+/// 
+/// Alpha price is expressed in rao units per one 10^9 unit. For example, 
+/// price 1_000_000 is equal to 0.001 TAO per Alpha.
+/// 
+/// price_low - lower boundary of price
+/// price_high - higher boundary of price
+/// liquidity - position liquidity
+/// fees_tao - fees accrued by the position in quote currency (TAO)
+/// fees_alpha - fees accrued by the position in base currency (Alpha)
+/// 
+struct Position {
+    price_low: u64,
+    price_high: u64,
+    liquidity: u128, // ???
+    fees_tao: u64,
+    fees_alpha: u64,
+}
+

From fd97abc7420d1ed9f167b304a8d0c3c0fbdb3c0b Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Thu, 6 Mar 2025 16:46:36 -0500
Subject: [PATCH 002/418] Change 'price' to 'tick'

---
 primitives/uniswap/src/lib.rs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/primitives/uniswap/src/lib.rs b/primitives/uniswap/src/lib.rs
index cb48bc79f3..6357beb9c6 100644
--- a/primitives/uniswap/src/lib.rs
+++ b/primitives/uniswap/src/lib.rs
@@ -10,10 +10,11 @@
 /// fees_alpha - fees accrued by the position in base currency (Alpha)
 /// 
 struct Position {
-    price_low: u64,
-    price_high: u64,
-    liquidity: u128, // ???
+    tick_low: u64,
+    tick_high: u64,
+    liquidity: u64,
     fees_tao: u64,
     fees_alpha: u64,
 }
 
+struct 

From 12f67ec1a416651060cb308b476ad73e928e2210 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Mon, 10 Mar 2025 10:45:57 -0400
Subject: [PATCH 003/418] Swap v3 in progress (data and interface design)

---
 primitives/{uniswap => swap}/Cargo.toml |   2 +-
 primitives/swap/src/lib.rs              | 105 ++++++++++++++++++++++++
 primitives/uniswap/src/lib.rs           |  20 -----
 3 files changed, 106 insertions(+), 21 deletions(-)
 rename primitives/{uniswap => swap}/Cargo.toml (94%)
 create mode 100644 primitives/swap/src/lib.rs
 delete mode 100644 primitives/uniswap/src/lib.rs

diff --git a/primitives/uniswap/Cargo.toml b/primitives/swap/Cargo.toml
similarity index 94%
rename from primitives/uniswap/Cargo.toml
rename to primitives/swap/Cargo.toml
index 3b884c1458..d4d2fdc377 100644
--- a/primitives/uniswap/Cargo.toml
+++ b/primitives/swap/Cargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "uniswap"
+name = "swap"
 version = "0.1.0"
 edition = "2025"
 
diff --git a/primitives/swap/src/lib.rs b/primitives/swap/src/lib.rs
new file mode 100644
index 0000000000..f6a59654fa
--- /dev/null
+++ b/primitives/swap/src/lib.rs
@@ -0,0 +1,105 @@
+
+/// The width of a single price tick. Expressed in rao units.
+pub const TICK_SPACING: u64 = 10_000;
+
+/// Position designates one liquidity position. 
+/// 
+/// Alpha price is expressed in rao units per one 10^9 unit. For example, 
+/// price 1_000_000 is equal to 0.001 TAO per Alpha.
+/// 
+/// tick_low - tick index for lower boundary of price
+/// tick_high - tick index for higher boundary of price
+/// liquidity - position liquidity
+/// fees_tao - fees accrued by the position in quote currency (TAO)
+/// fees_alpha - fees accrued by the position in base currency (Alpha)
+/// 
+struct Position {
+    tick_low: u64,
+    tick_high: u64,
+    liquidity: u64,
+    fees_tao: u64,
+    fees_alpha: u64,
+}
+
+/// Tick is the price range determined by tick index (not part of this struct, 
+/// but is the key at which the Tick is stored in state hash maps). Tick struct 
+/// stores liquidity and fee information.
+/// 
+///   - Net liquidity
+///   - Gross liquidity
+///   - Fees (above global) in both currencies
+/// 
+struct Tick {
+    liquidity_net: i128,
+    liquidity_gross: u64, 
+    fees_out_tao: u64,
+    fees_out_alpha: u64,
+}
+
+/// This trait implementation depends on Runtime and it needs to be implemented 
+/// in the pallet to be able to work with chain state and per subnet. All subnet 
+/// swaps are independent and hence netuid is abstracted away from swap implementation.
+/// 
+pub trait SwapDataOperations {
+    /// Tells if v3 swap is initialized in the state. v2 only provides base and quote 
+    /// reserves, while v3 also stores ticks and positions, which need to be initialized
+    /// at the first pool creation.
+    fn is_v3_initialized() -> bool;
+    /// Returns u16::MAX normalized fee rate. For example, 0.3% is approximately 196.
+    fn get_fee_rate() -> u16;
+    fn get_tick_by_index(tick_index: u64);
+    fn insert_tick_by_index(tick_index: u64);
+    fn get_tao_reserve() -> u64;
+    fn set_tao_reserve() -> u64;
+    fn get_alpha_reserve() -> u64;
+    fn set_alpha_reserve() -> u64;
+    fn get_alpha_sqrt_price() -> u64;
+    fn set_alpha_sqrt_price() -> u64;
+
+    fn withdraw_balances(tao: u64, alpha: u64) -> (u64, u64);
+    fn deposit_balances(tao: u64, alpha: u64);
+}
+
+/// All main swapping logic abstracted from Runtime implementation is concentrated 
+/// in this struct
+/// 
+#[derive(Debug)]
+pub struct Swap<Ops>
+where
+    Ops: SwapDataOperations,
+{
+    state_ops: Ops,
+}
+
+impl<Ops> Swap<Ops>
+where
+    Ops: SwapDataOperations,
+{
+    pub fn new(ops: Ops) -> Self {
+        if !ops.is_v3_initialized() {
+            // TODO: Initialize the v3
+            // Set price, set initial (protocol owned) liquidity and positions, etc.
+        }
+
+        Swap {
+            state_ops: ops,
+        }
+    }
+
+    /// Add 
+    pub fn add_liquidity(
+        tick_low: u64,
+        tick_high: u64,
+        liquidity: u64
+    ) -> u64 {
+        // TODO
+    }
+
+    pub fn remove_liquidity() {
+        // TODO
+    }
+
+    pub fn swap() {
+        // TODO
+    }
+}
\ No newline at end of file
diff --git a/primitives/uniswap/src/lib.rs b/primitives/uniswap/src/lib.rs
deleted file mode 100644
index 6357beb9c6..0000000000
--- a/primitives/uniswap/src/lib.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-/// Position designates one liquidity position. 
-/// 
-/// Alpha price is expressed in rao units per one 10^9 unit. For example, 
-/// price 1_000_000 is equal to 0.001 TAO per Alpha.
-/// 
-/// price_low - lower boundary of price
-/// price_high - higher boundary of price
-/// liquidity - position liquidity
-/// fees_tao - fees accrued by the position in quote currency (TAO)
-/// fees_alpha - fees accrued by the position in base currency (Alpha)
-/// 
-struct Position {
-    tick_low: u64,
-    tick_high: u64,
-    liquidity: u64,
-    fees_tao: u64,
-    fees_alpha: u64,
-}
-
-struct 

From 29b82d56a4093ca27afea85a30ccba9094cfaa56 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Tue, 11 Mar 2025 15:00:27 -0400
Subject: [PATCH 004/418] Add implementation of Position

---
 primitives/swap/src/lib.rs | 66 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 66 insertions(+)

diff --git a/primitives/swap/src/lib.rs b/primitives/swap/src/lib.rs
index f6a59654fa..ccc62c2d0c 100644
--- a/primitives/swap/src/lib.rs
+++ b/primitives/swap/src/lib.rs
@@ -1,3 +1,4 @@
+use safe_math::*;
 
 /// The width of a single price tick. Expressed in rao units.
 pub const TICK_SPACING: u64 = 10_000;
@@ -21,6 +22,53 @@ struct Position {
     fees_alpha: u64,
 }
 
+impl Position {
+    /// Converts tick index into SQRT of price
+    /// 
+    /// python: (1 + self.tick_spacing) ** (i / 2)
+    /// 
+    pub fn tick_index_to_sqrt_price(tick_idx: u64) -> U64F64 {
+        // TODO: implement
+    }
+
+    /// Converts SQRT price to tick index
+    /// 
+    /// python: math.floor(math.log(sqrt_p) / math.log(1 + self.tick_spacing)) * 2
+    /// 
+    pub fn sqrt_price_to_tick_index(sqrt_price: U64F64) -> u64 {
+        // TODO: implement
+    }
+
+    /// Converts position to token amounts
+    /// 
+    /// returns tuple of (TAO, Alpha)
+    /// 
+    pub fn to_token_amounts(self, current_tick: u64) -> (u64, u64) {
+        let one = U64F64::saturating_from_num(1);
+
+        let sqrt_price_curr = self.tick_index_to_sqrt_price(current_tick);
+        let sqrt_pa = self.tick_index_to_sqrt_price(self.tick_low);
+        let sqrt_pb = self.tick_index_to_sqrt_price(self.tick_high);
+
+        if sqrt_price_curr < sqrt_pa {
+            (
+                liquidity.saturating_mul(one.safe_div(sqrt_pa).saturating_sub(one.safe_div(sqrt_pb))),
+                0
+            )
+        } else if sqrt_price_curr > sqrt_pb {
+            (
+                0,
+                liquidity.saturating_mul(sqrt_pb.saturating_sub(sqrt_pa))
+            )
+        } else {
+            (
+                liquidity.saturating_mul(one.save_div(sqrt_price_curr).saturating_sub(one.safe_div(sqrt_pb))),
+                liquidity.saturating_mul(sqrt_price_curr.saturating_sub(sqrt_pa))
+            )
+        }
+    }
+}
+
 /// Tick is the price range determined by tick index (not part of this struct, 
 /// but is the key at which the Tick is stored in state hash maps). Tick struct 
 /// stores liquidity and fee information.
@@ -86,6 +134,24 @@ where
         }
     }
 
+    /// Auxiliary method to calculate Alpha amount to match given TAO 
+    /// amount at the current price for liquidity.
+    /// 
+    /// Returns (Alpha, Liquidity) tuple
+    /// 
+    pub fn get_tao_based_liquidity(tao: u64) -> (u64, u64) {
+        // TODO
+    }
+
+    /// Auxiliary method to calculate TAO amount to match given Alpha 
+    /// amount at the current price for liquidity.
+    /// 
+    /// Returns (TAO, Liquidity) tuple
+    /// 
+    pub fn get_alpha_based_liquidity(alpha: u64) -> (u64, u64) {
+        // TODO
+    }
+
     /// Add 
     pub fn add_liquidity(
         tick_low: u64,

From 54218d4b309b97075cad1f632d70f298b36616ab Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Wed, 12 Mar 2025 10:07:15 -0400
Subject: [PATCH 005/418] Swap in progress

---
 primitives/swap/src/lib.rs | 125 +++++++++++++++++++++++++++++++++----
 1 file changed, 113 insertions(+), 12 deletions(-)

diff --git a/primitives/swap/src/lib.rs b/primitives/swap/src/lib.rs
index ccc62c2d0c..cfd8602adf 100644
--- a/primitives/swap/src/lib.rs
+++ b/primitives/swap/src/lib.rs
@@ -3,6 +3,14 @@ use safe_math::*;
 /// The width of a single price tick. Expressed in rao units.
 pub const TICK_SPACING: u64 = 10_000;
 
+type SqrtPrice = U64F64;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum OrderType {
+    Sell,
+    Buy,
+}
+
 /// Position designates one liquidity position. 
 /// 
 /// Alpha price is expressed in rao units per one 10^9 unit. For example, 
@@ -27,7 +35,7 @@ impl Position {
     /// 
     /// python: (1 + self.tick_spacing) ** (i / 2)
     /// 
-    pub fn tick_index_to_sqrt_price(tick_idx: u64) -> U64F64 {
+    pub fn tick_index_to_sqrt_price(tick_idx: u64) -> SqrtPrice {
         // TODO: implement
     }
 
@@ -35,16 +43,16 @@ impl Position {
     /// 
     /// python: math.floor(math.log(sqrt_p) / math.log(1 + self.tick_spacing)) * 2
     /// 
-    pub fn sqrt_price_to_tick_index(sqrt_price: U64F64) -> u64 {
+    pub fn sqrt_price_to_tick_index(sqrt_price: SqrtPrice) -> u64 {
         // TODO: implement
     }
 
-    /// Converts position to token amounts
+    /// Converts position to quote and base token amounts
     /// 
     /// returns tuple of (TAO, Alpha)
     /// 
     pub fn to_token_amounts(self, current_tick: u64) -> (u64, u64) {
-        let one = U64F64::saturating_from_num(1);
+        let one = 1.into();
 
         let sqrt_price_curr = self.tick_index_to_sqrt_price(current_tick);
         let sqrt_pa = self.tick_index_to_sqrt_price(self.tick_low);
@@ -95,8 +103,8 @@ pub trait SwapDataOperations {
     fn is_v3_initialized() -> bool;
     /// Returns u16::MAX normalized fee rate. For example, 0.3% is approximately 196.
     fn get_fee_rate() -> u16;
-    fn get_tick_by_index(tick_index: u64);
-    fn insert_tick_by_index(tick_index: u64);
+    fn get_tick_by_index(tick_index: u64) -> Option<Tick>;
+    fn insert_tick_by_index(tick_index: u64, tick: Tick);
     fn get_tao_reserve() -> u64;
     fn set_tao_reserve() -> u64;
     fn get_alpha_reserve() -> u64;
@@ -104,6 +112,11 @@ pub trait SwapDataOperations {
     fn get_alpha_sqrt_price() -> u64;
     fn set_alpha_sqrt_price() -> u64;
 
+    /// Get current tick liquidity
+    fn get_current_liquidity() -> u64;
+    /// Set current tick liquidity
+    fn set_current_liquidity(liquidity: u64);
+
     fn withdraw_balances(tao: u64, alpha: u64) -> (u64, u64);
     fn deposit_balances(tao: u64, alpha: u64);
 }
@@ -139,7 +152,9 @@ where
     /// 
     /// Returns (Alpha, Liquidity) tuple
     /// 
-    pub fn get_tao_based_liquidity(tao: u64) -> (u64, u64) {
+    pub fn get_tao_based_liquidity(&self, tao: u64) -> (u64, u64) {
+        let current_price = self.state_ops.get_alpha_sqrt_price();
+
         // TODO
     }
 
@@ -148,24 +163,110 @@ where
     /// 
     /// Returns (TAO, Liquidity) tuple
     /// 
-    pub fn get_alpha_based_liquidity(alpha: u64) -> (u64, u64) {
+    pub fn get_alpha_based_liquidity(&self, alpha: u64) -> (u64, u64) {
+        let current_price = self.state_ops.get_alpha_sqrt_price();
+
         // TODO
     }
 
-    /// Add 
+    /// Add liquidity at tick index. Creates new tick if it doesn't exist
+    /// 
+    fn add_liquidity_at_index(tick_index: u64, liquidity: u64, upper: bool) {
+        // Calculate net liquidity addition
+        let net_addition = if upper {
+            (liquidity as i128).neg()
+        } else {
+            liquidity as i128
+        }
+
+        // Find tick by index
+        let new_tick = if let Some(tick) = self.state_ops.get_tick_by_index(tick_index) {
+            tick.liquidity_net = tick.liquidity_net.saturating_add(net_addition);
+            tick.liquidity_gross = tick.liquidity_gross.saturating_add(liquidity);
+        } else {
+            // Create a new tick
+            Tick {
+                liquidity_net: net_addition,
+                liquidity_gross: liquidity, 
+                fees_out_tao: 0_u64,
+                fees_out_alpha: 0_u64,
+            }
+        }
+
+        // TODO: Review why Python code uses this code to find index for the new ticks: 
+        // self.get_tick_index(user_position[0]) + 1
+        self.state_ops.insert_tick_by_index(tick_index, new_tick);
+    }
+
+    /// Add liquidity
+    /// 
+    /// The added liquidity amount can be calculated from TAO and Alpha
+    /// amounts using get_tao_based_liquidity and get_alpha_based_liquidity
+    /// for the current price tick.
+    /// 
+    /// Removes the balances using state_ops.withdraw_balances() 
+    /// 
     pub fn add_liquidity(
+        &self,
         tick_low: u64,
         tick_high: u64,
         liquidity: u64
     ) -> u64 {
-        // TODO
+        self.add_liquidity_at_index(tick_low, liquidity, false);
+        self.add_liquidity_at_index(tick_high, liquidity, true);
+
+        // Update current tick and liquidity
+        // TODO: Review why python uses this code to get the new tick index:
+        // k = self.get_tick_index(i)
+        let current_price = self.state_ops.get_alpha_sqrt_price();
+        let current_tick_index = Position::sqrt_price_to_tick_index(current_price);
+
+        // Update current tick liquidity
+        if (tick_low <= current_tick_index) && (current_tick_index <= tick_high) {
+            let new_current_liquidity = self.state_ops.get_current_liquidity()
+                .saturating_add(liquidity);
+            self.state_ops.set_current_liquidity(new_current_liquidity);
+        }
+        
+        # Update positions
+        if len(self.user_positions) == 0:
+            self.user_positions = np.array([np.append(user_position, [0, 0])])
+        else:
+            self.user_positions = np.vstack([self.user_positions, np.append(user_position, [0, 0])])
+        
+
+        // Update reserves
+        let position = Position {
+            tick_low,
+            tick_high,
+            liquidity,
+            fees_tao: 0_u64,
+            fees_alpha: 0_u64,
+        }
+        let (tao, alpha) = position.to_token_amounts(current_tick_index);
+        let new_tao_reserve = self.state_ops.get_tao_reserve().saturating_add(tao);
+        self.state_ops.set_tao_reserve(new_tao_reserve);
+        let new_alpha_reserve = self.get_alpha_reserve().saturating_add(alpha);
+        self.state_ops.set_alpha_reserve(new_alpha);        
     }
 
-    pub fn remove_liquidity() {
+    pub fn remove_liquidity(
+        &self,
+        position: &Position,
+    ) {
         // TODO
     }
 
-    pub fn swap() {
+    /// Perform a swap
+    /// 
+    /// Returns a tuple (amount, refund), where amount is the resulting paid out amount
+    /// 
+    pub fn swap(
+        &self,
+        order_type: &OrderType,
+        amount: u64,
+        sqrt_price_limit: SqrtPrice,
+    ) -> (u64, u64) {
         // TODO
     }
 }
\ No newline at end of file

From 52dbed17060c4d80798b4a6d9be610de92b3c55d Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Wed, 12 Mar 2025 15:16:49 +0100
Subject: [PATCH 006/418] Add checked pow function for Fixed

---
 Cargo.lock                      |  9 +++++++
 Cargo.toml                      |  3 +++
 primitives/safe-math/Cargo.toml |  2 +-
 primitives/safe-math/src/lib.rs | 48 +++++++++++++++++++++++++++++++++
 primitives/swap/Cargo.toml      |  2 +-
 5 files changed, 62 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index e6bbe9432c..a21f45c101 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -11263,6 +11263,15 @@ version = "2.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
 
+[[package]]
+name = "swap"
+version = "0.1.0"
+dependencies = [
+ "safe-math",
+ "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409)",
+ "substrate-fixed",
+]
+
 [[package]]
 name = "syn"
 version = "1.0.109"
diff --git a/Cargo.toml b/Cargo.toml
index 781fe6dfe9..c0b2cc47a3 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -33,6 +33,9 @@ members = [
 ]
 resolver = "2"
 
+[workspace.package]
+edition = "2024"
+
 [workspace.lints.clippy]
 indexing-slicing = "deny"
 arithmetic-side-effects = "deny"
diff --git a/primitives/safe-math/Cargo.toml b/primitives/safe-math/Cargo.toml
index e41c7878b5..0c0e3db7b1 100644
--- a/primitives/safe-math/Cargo.toml
+++ b/primitives/safe-math/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "safe-math"
 version = "0.1.0"
-edition = "2024"
+edition = { workspace = true }
 
 [dependencies]
 substrate-fixed = { workspace = true }
diff --git a/primitives/safe-math/src/lib.rs b/primitives/safe-math/src/lib.rs
index d17c6b5708..e391381737 100644
--- a/primitives/safe-math/src/lib.rs
+++ b/primitives/safe-math/src/lib.rs
@@ -97,6 +97,39 @@ pub fn checked_sqrt<T: SafeDiv + Fixed>(value: T, epsilon: T) -> Option<T> {
     Some(middle)
 }
 
+pub fn checked_pow_fixed<F: Fixed>(base: F, exponent: i32) -> Option<F> {
+    if exponent == 0 {
+        return Some(F::from_num(1));
+    }
+
+    if base == F::from_num(0) {
+        if exponent < 0 {
+            // Cannot raise zero to a negative power (division by zero)
+            return None;
+        }
+        return Some(F::from_num(0)); // 0^(positive number) = 0
+    }
+
+    let mut result = F::from_num(1);
+    let mut base = base;
+    let mut exp = exponent.unsigned_abs();
+
+    // Binary exponentiation algorithm
+    while exp > 0 {
+        if exp & 1 != 0 {
+            result = result.saturating_mul(base);
+        }
+        base = base.saturating_mul(base);
+        exp >>= 1;
+    }
+
+    if exponent < 0 {
+        result = F::from_num(1).checked_div(result).unwrap_or_default();
+    }
+
+    Some(result)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -173,4 +206,19 @@ mod tests {
         let result: Option<U110F18> = checked_sqrt(value, epsilon);
         assert!(result.is_some()); // Check that it doesn't break, but may not be highly accurate
     }
+
+    #[test]
+    fn test_checked_pow_fixed() {
+        let base = U64F64::from_num(2.5);
+        let result = checked_pow_fixed(base, 3);
+        assert_eq!(result, Some(U64F64::from_num(15.625)));
+
+        let base = I32F32::from_num(1.5);
+        let result = checked_pow_fixed(base, -2);
+
+        assert!((result.unwrap() - I32F32::from_num(0.44444444)).abs() <= I32F32::from_num(0.0001));
+
+        let result = checked_pow_fixed(I32F32::from_num(0), -1);
+        assert_eq!(result, None);
+    }
 }
diff --git a/primitives/swap/Cargo.toml b/primitives/swap/Cargo.toml
index d4d2fdc377..b09c70b984 100644
--- a/primitives/swap/Cargo.toml
+++ b/primitives/swap/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "swap"
 version = "0.1.0"
-edition = "2025"
+edition = { workspace = true }
 
 [dependencies]
 substrate-fixed = { workspace = true }

From 52c2ef3628cccc01fc99a1fcaab89b168ff95b7f Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Wed, 12 Mar 2025 17:06:34 +0100
Subject: [PATCH 007/418] Refactor safe-math

---
 Cargo.lock                      |   2 +
 Cargo.toml                      |   4 +-
 primitives/safe-math/Cargo.toml |   6 +-
 primitives/safe-math/src/lib.rs | 214 +++++++++++++++-----------------
 primitives/swap/Cargo.toml      |   4 +-
 primitives/swap/src/lib.rs      | 106 ++++++++--------
 6 files changed, 168 insertions(+), 168 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index a21f45c101..360b218759 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -8270,6 +8270,7 @@ name = "safe-math"
 version = "0.1.0"
 dependencies = [
  "num-traits",
+ "sp-arithmetic",
  "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409)",
  "substrate-fixed",
 ]
@@ -11268,6 +11269,7 @@ name = "swap"
 version = "0.1.0"
 dependencies = [
  "safe-math",
+ "sp-arithmetic",
  "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409)",
  "substrate-fixed",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index c0b2cc47a3..1e5c417d8d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -45,16 +45,17 @@ manual_inspect = "allow"
 useless_conversion = "allow"     # until polkadot is patched
 
 [workspace.dependencies]
+node-subtensor-runtime = { default-features = false, path = "runtime" }
 pallet-admin-utils = { default-features = false, path = "pallets/admin-utils" }
 pallet-collective = { default-features = false, path = "pallets/collective" }
 pallet-commitments = { default-features = false, path = "pallets/commitments" }
 pallet-registry = { default-features = false, path = "pallets/registry" }
 pallet-subtensor = { default-features = false, path = "pallets/subtensor" }
+safe-math = { default-features = false, path = "primitives/safe-math" }
 subtensor-custom-rpc = { default-features = false, path = "pallets/subtensor/rpc" }
 subtensor-custom-rpc-runtime-api = { default-features = false, path = "pallets/subtensor/runtime-api" }
 subtensor-precompiles = { default-features = false, path = "precompiles" }
 subtensor-runtime-common = { default-features = false, path = "common" }
-node-subtensor-runtime = { default-features = false, path = "runtime" }
 
 async-trait = "0.1"
 cargo-husky = { version = "1", default-features = false }
@@ -150,6 +151,7 @@ sc-transaction-pool = { git = "https://github.com/paritytech/polkadot-sdk.git",
 sc-transaction-pool-api = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409" }
 
 sp-api = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409", default-features = false }
+sp-arithmetic = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409", default-features = false }
 sp-block-builder = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409", default-features = false }
 sp-blockchain = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409", default-features = false }
 sp-consensus = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409" }
diff --git a/primitives/safe-math/Cargo.toml b/primitives/safe-math/Cargo.toml
index 0c0e3db7b1..eb39f35807 100644
--- a/primitives/safe-math/Cargo.toml
+++ b/primitives/safe-math/Cargo.toml
@@ -5,8 +5,11 @@ edition = { workspace = true }
 
 [dependencies]
 substrate-fixed = { workspace = true }
+sp-arithmetic = { workspace = true }
 sp-std = { workspace = true }
-num-traits = { version = "0.2.19", default-features = false, features = ["libm"] }
+num-traits = { version = "0.2.19", default-features = false, features = [
+	"libm",
+] }
 
 [lints]
 workspace = true
@@ -16,5 +19,6 @@ default = ["std"]
 std = [
 	"substrate-fixed/std",
 	"sp-std/std",
+	"sp-arithmetic/std",
 	"num-traits/std",
 ]
diff --git a/primitives/safe-math/src/lib.rs b/primitives/safe-math/src/lib.rs
index e391381737..6a703752e8 100644
--- a/primitives/safe-math/src/lib.rs
+++ b/primitives/safe-math/src/lib.rs
@@ -3,10 +3,8 @@
 #![cfg_attr(test, allow(clippy::arithmetic_side_effects))]
 #![cfg_attr(test, allow(clippy::unwrap_used))]
 
-use substrate_fixed::{
-    traits::Fixed,
-    types::{I32F32, I64F64, I96F32, I110F18, U64F64, U96F32, U110F18},
-};
+use sp_arithmetic::traits::UniqueSaturatedInto;
+use substrate_fixed::traits::Fixed;
 
 /// Safe division trait
 pub trait SafeDiv {
@@ -16,140 +14,134 @@ pub trait SafeDiv {
     fn safe_div(self, rhs: Self) -> Self;
 }
 
-/// Implementation of safe division trait for primitive types
-macro_rules! impl_safe_div_for_primitive {
-    ($($t:ty),*) => {
-        $(
-            impl SafeDiv for $t {
-                fn safe_div_or(self, rhs: Self, def: Self) -> Self {
-                    self.checked_div(rhs).unwrap_or(def)
-                }
+pub trait FixedExt: Fixed {
+    fn checked_pow<E>(&self, exponent: E) -> Option<Self>
+    where
+        E: UniqueSaturatedInto<i32>,
+    {
+        let exponent = exponent.unique_saturated_into();
 
-                fn safe_div(self, rhs: Self) -> Self {
-                    self.checked_div(rhs).unwrap_or_default()
-                }
+        if exponent == 0 {
+            return Some(Self::from_num(1));
+        }
+
+        if *self == Self::from_num(0) {
+            if exponent < 0 {
+                // Cannot raise zero to a negative power (division by zero)
+                return None;
             }
-        )*
-    };
-}
-impl_safe_div_for_primitive!(u8, u16, u32, u64, i8, i16, i32, i64, usize);
+            return Some(Self::from_num(0)); // 0^(positive number) = 0
+        }
 
-/// Implementation of safe division trait for substrate fixed types
-macro_rules! impl_safe_div_for_fixed {
-    ($($t:ty),*) => {
-        $(
-            impl SafeDiv for $t {
-                fn safe_div_or(self, rhs: Self, def: Self) -> Self {
-                    self.checked_div(rhs).unwrap_or(def)
-                }
+        let mut result = Self::from_num(1);
+        let mut base = *self;
+        let mut exp = exponent.unsigned_abs();
 
-                fn safe_div(self, rhs: Self) -> Self {
-                    self.checked_div(rhs).unwrap_or_default()
-                }
+        // Binary exponentiation algorithm
+        while exp > 0 {
+            if exp & 1 != 0 {
+                result = result.saturating_mul(base);
             }
-        )*
-    };
-}
-impl_safe_div_for_fixed!(I96F32, I32F32, I64F64, I110F18, U110F18, U64F64, U96F32);
+            base = self.saturating_mul(base);
+            exp >>= 1;
+        }
 
-fn abs_diff<T: Fixed>(a: T, b: T) -> T {
-    if a < b {
-        b.saturating_sub(a)
-    } else {
-        a.saturating_sub(b)
+        if exponent < 0 {
+            result = Self::from_num(1).checked_div(result).unwrap_or_default();
+        }
+
+        Some(result)
     }
-}
 
-/// Safe sqrt with good precision
-pub fn checked_sqrt<T: SafeDiv + Fixed>(value: T, epsilon: T) -> Option<T> {
-    let zero: T = T::saturating_from_num(0);
-    let two: T = T::saturating_from_num(2);
+    /// Safe sqrt with good precision
+    fn checked_sqrt(&self, epsilon: Self) -> Option<Self> {
+        let zero = Self::saturating_from_num(0);
+        let two = Self::saturating_from_num(2);
 
-    if value < zero {
-        return None;
-    }
+        if *self < zero {
+            return None;
+        }
 
-    let mut high: T = value;
-    let mut low: T = zero;
-    let mut middle: T = high.saturating_add(low).safe_div(two);
+        let mut high = *self;
+        let mut low = zero;
+        let mut middle = high.saturating_add(low).safe_div(two);
 
-    let mut iteration: i32 = 0;
-    let max_iterations = 128;
-    let mut check_val: T = value.safe_div(middle);
+        let mut iteration: i32 = 0;
+        let max_iterations = 128;
+        let mut check_val = self.safe_div(middle);
 
-    // Iterative approximation using bisection
-    while abs_diff(check_val, middle) > epsilon {
-        if check_val < middle {
-            high = middle;
-        } else {
-            low = middle;
-        }
+        // Iterative approximation using bisection
+        while check_val.abs_diff(middle) > epsilon {
+            if check_val < middle {
+                high = middle;
+            } else {
+                low = middle;
+            }
 
-        middle = high.saturating_add(low).safe_div(two);
-        check_val = value.safe_div(middle);
+            middle = high.saturating_add(low).safe_div(two);
+            check_val = self.safe_div(middle);
 
-        iteration = iteration.saturating_add(1);
-        if iteration > max_iterations {
-            break;
+            iteration = iteration.saturating_add(1);
+            if iteration > max_iterations {
+                break;
+            }
         }
-    }
-
-    Some(middle)
-}
 
-pub fn checked_pow_fixed<F: Fixed>(base: F, exponent: i32) -> Option<F> {
-    if exponent == 0 {
-        return Some(F::from_num(1));
+        Some(middle)
     }
 
-    if base == F::from_num(0) {
-        if exponent < 0 {
-            // Cannot raise zero to a negative power (division by zero)
-            return None;
+    fn abs_diff(&self, b: Self) -> Self {
+        if *self < b {
+            b.saturating_sub(*self)
+        } else {
+            self.saturating_sub(b)
         }
-        return Some(F::from_num(0)); // 0^(positive number) = 0
     }
 
-    let mut result = F::from_num(1);
-    let mut base = base;
-    let mut exp = exponent.unsigned_abs();
-
-    // Binary exponentiation algorithm
-    while exp > 0 {
-        if exp & 1 != 0 {
-            result = result.saturating_mul(base);
-        }
-        base = base.saturating_mul(base);
-        exp >>= 1;
+    fn safe_div_or(&self, rhs: Self, def: Self) -> Self {
+        self.checked_div(rhs).unwrap_or(def)
     }
 
-    if exponent < 0 {
-        result = F::from_num(1).checked_div(result).unwrap_or_default();
+    fn safe_div(&self, rhs: Self) -> Self {
+        self.checked_div(rhs).unwrap_or_default()
     }
+}
 
-    Some(result)
+impl<T: Fixed> FixedExt for T {}
+
+/// Implementation of safe division trait for primitive types
+macro_rules! impl_safe_div_for_primitive {
+    ($($t:ty),*) => {
+        $(
+            impl SafeDiv for $t {
+                fn safe_div_or(self, rhs: Self, def: Self) -> Self {
+                    self.checked_div(rhs).unwrap_or(def)
+                }
+
+                fn safe_div(self, rhs: Self) -> Self {
+                    self.checked_div(rhs).unwrap_or_default()
+                }
+            }
+        )*
+    };
 }
+impl_safe_div_for_primitive!(u8, u16, u32, u64, i8, i16, i32, i64, usize);
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use substrate_fixed::types::U110F18; // Assuming U110F18 is properly imported
-
-    // Helper function for absolute difference
-    fn abs_diff(a: U110F18, b: U110F18) -> U110F18 {
-        if a > b { a - b } else { b - a }
-    }
+    use substrate_fixed::types::*; // Assuming U110F18 is properly imported
 
     #[test]
     fn test_checked_sqrt_positive_values() {
         let value: U110F18 = U110F18::from_num(4.0);
         let epsilon: U110F18 = U110F18::from_num(0.0001);
 
-        let result: Option<U110F18> = checked_sqrt(value, epsilon);
+        let result: Option<U110F18> = value.checked_sqrt(epsilon);
         assert!(result.is_some());
         let sqrt_result: U110F18 = result.unwrap();
         let precise_sqrt: U110F18 = U110F18::from_num(4.0_f64.sqrt());
-        assert!(abs_diff(sqrt_result, precise_sqrt) <= epsilon);
+        assert!(sqrt_result.abs_diff(precise_sqrt) <= epsilon);
     }
 
     #[test]
@@ -157,11 +149,11 @@ mod tests {
         let value: U110F18 = U110F18::from_num(1_000_000_000_000_000_000.0);
         let epsilon: U110F18 = U110F18::from_num(0.0001);
 
-        let result: Option<U110F18> = checked_sqrt(value, epsilon);
+        let result = value.checked_sqrt(epsilon);
         assert!(result.is_some());
         let sqrt_result: U110F18 = result.unwrap();
         let precise_sqrt: U110F18 = U110F18::from_num(1_000_000_000_000_000_000.0_f64.sqrt());
-        assert!(abs_diff(sqrt_result, precise_sqrt) <= epsilon);
+        assert!(sqrt_result.abs_diff(precise_sqrt) <= epsilon);
     }
 
     #[test]
@@ -169,12 +161,12 @@ mod tests {
         let value: U110F18 = U110F18::from_num(441_000_000_000_000_000_000_000_000_000_000.0);
         let epsilon: U110F18 = U110F18::from_num(1000);
 
-        let result: Option<U110F18> = checked_sqrt(value, epsilon);
+        let result: Option<U110F18> = value.checked_sqrt(epsilon);
         assert!(result.is_some());
         let sqrt_result: U110F18 = result.unwrap();
         let precise_sqrt: U110F18 =
             U110F18::from_num(441_000_000_000_000_000_000_000_000_000_000.0_f64.sqrt());
-        assert!(abs_diff(sqrt_result, precise_sqrt) <= epsilon);
+        assert!(sqrt_result.abs_diff(precise_sqrt) <= epsilon);
     }
 
     #[test]
@@ -182,7 +174,7 @@ mod tests {
         let value: U110F18 = U110F18::from_num(0.0);
         let epsilon: U110F18 = U110F18::from_num(0.0001);
 
-        let result: Option<U110F18> = checked_sqrt(value, epsilon);
+        let result: Option<U110F18> = value.checked_sqrt(epsilon);
         assert!(result.is_some());
         assert_eq!(result.unwrap(), U110F18::from_num(0.0));
     }
@@ -192,33 +184,31 @@ mod tests {
         let value: U110F18 = U110F18::from_num(2.0);
         let epsilon: U110F18 = U110F18::from_num(0.0001);
 
-        let result: Option<U110F18> = checked_sqrt(value, epsilon);
+        let result = value.checked_sqrt(epsilon);
         assert!(result.is_some());
         let sqrt_result: U110F18 = result.unwrap();
         let precise_sqrt: U110F18 = U110F18::from_num(2.0_f64.sqrt());
-        assert!(abs_diff(sqrt_result, precise_sqrt) <= epsilon);
+        assert!(sqrt_result.abs_diff(precise_sqrt) <= epsilon);
     }
 
     #[test]
     fn test_checked_sqrt_max_iterations() {
         let value: U110F18 = U110F18::from_num(2.0);
         let epsilon: U110F18 = U110F18::from_num(1e-30); // Very high precision
-        let result: Option<U110F18> = checked_sqrt(value, epsilon);
+        let result = value.checked_sqrt(epsilon);
         assert!(result.is_some()); // Check that it doesn't break, but may not be highly accurate
     }
 
     #[test]
     fn test_checked_pow_fixed() {
-        let base = U64F64::from_num(2.5);
-        let result = checked_pow_fixed(base, 3);
+        let result = U64F64::from_num(2.5).checked_pow(3u32);
         assert_eq!(result, Some(U64F64::from_num(15.625)));
 
-        let base = I32F32::from_num(1.5);
-        let result = checked_pow_fixed(base, -2);
+        let result = I32F32::from_num(1.5).checked_pow(-2i64);
 
         assert!((result.unwrap() - I32F32::from_num(0.44444444)).abs() <= I32F32::from_num(0.0001));
 
-        let result = checked_pow_fixed(I32F32::from_num(0), -1);
+        let result = I32F32::from_num(0).checked_pow(-1);
         assert_eq!(result, None);
     }
 }
diff --git a/primitives/swap/Cargo.toml b/primitives/swap/Cargo.toml
index b09c70b984..c5d2dc0361 100644
--- a/primitives/swap/Cargo.toml
+++ b/primitives/swap/Cargo.toml
@@ -5,8 +5,9 @@ edition = { workspace = true }
 
 [dependencies]
 substrate-fixed = { workspace = true }
+sp-arithmetic = { workspace = true }
 sp-std = { workspace = true }
-safe-math = { default-features = false, path = "../safe-math" }
+safe-math = { workspace = true }
 
 [lints]
 workspace = true
@@ -17,4 +18,5 @@ std = [
 	"substrate-fixed/std",
 	"sp-std/std",
 	"safe-math/std",
+	"sp-arithmetic/std",
 ]
diff --git a/primitives/swap/src/lib.rs b/primitives/swap/src/lib.rs
index ccc62c2d0c..ad08bcbbef 100644
--- a/primitives/swap/src/lib.rs
+++ b/primitives/swap/src/lib.rs
@@ -1,19 +1,21 @@
 use safe_math::*;
+use sp_arithmetic::traits::UniqueSaturatedInto;
+use substrate_fixed::types::U64F64;
 
 /// The width of a single price tick. Expressed in rao units.
 pub const TICK_SPACING: u64 = 10_000;
 
-/// Position designates one liquidity position. 
-/// 
-/// Alpha price is expressed in rao units per one 10^9 unit. For example, 
+/// Position designates one liquidity position.
+///
+/// Alpha price is expressed in rao units per one 10^9 unit. For example,
 /// price 1_000_000 is equal to 0.001 TAO per Alpha.
-/// 
+///
 /// tick_low - tick index for lower boundary of price
 /// tick_high - tick index for higher boundary of price
 /// liquidity - position liquidity
 /// fees_tao - fees accrued by the position in quote currency (TAO)
 /// fees_alpha - fees accrued by the position in base currency (Alpha)
-/// 
+///
 struct Position {
     tick_low: u64,
     tick_high: u64,
@@ -24,72 +26,76 @@ struct Position {
 
 impl Position {
     /// Converts tick index into SQRT of price
-    /// 
-    /// python: (1 + self.tick_spacing) ** (i / 2)
-    /// 
     pub fn tick_index_to_sqrt_price(tick_idx: u64) -> U64F64 {
-        // TODO: implement
+        // python: (1 + self.tick_spacing) ** (i / 2)
+        let tick_spacing_tao = U64F64::from_num(TICK_SPACING).saturating_div(U64F64::from_num(1e9))
+            + U64F64::from_num(1.0);
+
+        tick_spacing_tao
+            .checked_pow(tick_idx / 2)
+            .unwrap_or_default()
     }
 
     /// Converts SQRT price to tick index
-    /// 
-    /// python: math.floor(math.log(sqrt_p) / math.log(1 + self.tick_spacing)) * 2
-    /// 
     pub fn sqrt_price_to_tick_index(sqrt_price: U64F64) -> u64 {
-        // TODO: implement
+        let tick_spacing_tao = U64F64::from_num(TICK_SPACING).saturating_div(U64F64::from_num(1e9))
+            + U64F64::from_num(1.0);
+        // python: math.floor(math.log(sqrt_p) / math.log(1 + self.tick_spacing)) * 2
+        todo!()
     }
 
     /// Converts position to token amounts
-    /// 
+    ///
     /// returns tuple of (TAO, Alpha)
-    /// 
+    ///
     pub fn to_token_amounts(self, current_tick: u64) -> (u64, u64) {
         let one = U64F64::saturating_from_num(1);
 
-        let sqrt_price_curr = self.tick_index_to_sqrt_price(current_tick);
-        let sqrt_pa = self.tick_index_to_sqrt_price(self.tick_low);
-        let sqrt_pb = self.tick_index_to_sqrt_price(self.tick_high);
+        let sqrt_price_curr = Self::tick_index_to_sqrt_price(current_tick);
+        let sqrt_pa = Self::tick_index_to_sqrt_price(self.tick_low);
+        let sqrt_pb = Self::tick_index_to_sqrt_price(self.tick_high);
 
         if sqrt_price_curr < sqrt_pa {
             (
-                liquidity.saturating_mul(one.safe_div(sqrt_pa).saturating_sub(one.safe_div(sqrt_pb))),
-                0
-            )
-        } else if sqrt_price_curr > sqrt_pb {
-            (
+                liquidity
+                    .saturating_mul(one.safe_div(sqrt_pa).saturating_sub(one.safe_div(sqrt_pb))),
                 0,
-                liquidity.saturating_mul(sqrt_pb.saturating_sub(sqrt_pa))
             )
+        } else if sqrt_price_curr > sqrt_pb {
+            (0, liquidity.saturating_mul(sqrt_pb.saturating_sub(sqrt_pa)))
         } else {
             (
-                liquidity.saturating_mul(one.save_div(sqrt_price_curr).saturating_sub(one.safe_div(sqrt_pb))),
-                liquidity.saturating_mul(sqrt_price_curr.saturating_sub(sqrt_pa))
+                liquidity.saturating_mul(
+                    one.save_div(sqrt_price_curr)
+                        .saturating_sub(one.safe_div(sqrt_pb)),
+                ),
+                liquidity.saturating_mul(sqrt_price_curr.saturating_sub(sqrt_pa)),
             )
         }
     }
 }
 
-/// Tick is the price range determined by tick index (not part of this struct, 
-/// but is the key at which the Tick is stored in state hash maps). Tick struct 
+/// Tick is the price range determined by tick index (not part of this struct,
+/// but is the key at which the Tick is stored in state hash maps). Tick struct
 /// stores liquidity and fee information.
-/// 
+///
 ///   - Net liquidity
 ///   - Gross liquidity
 ///   - Fees (above global) in both currencies
-/// 
+///
 struct Tick {
     liquidity_net: i128,
-    liquidity_gross: u64, 
+    liquidity_gross: u64,
     fees_out_tao: u64,
     fees_out_alpha: u64,
 }
 
-/// This trait implementation depends on Runtime and it needs to be implemented 
-/// in the pallet to be able to work with chain state and per subnet. All subnet 
+/// This trait implementation depends on Runtime and it needs to be implemented
+/// in the pallet to be able to work with chain state and per subnet. All subnet
 /// swaps are independent and hence netuid is abstracted away from swap implementation.
-/// 
+///
 pub trait SwapDataOperations {
-    /// Tells if v3 swap is initialized in the state. v2 only provides base and quote 
+    /// Tells if v3 swap is initialized in the state. v2 only provides base and quote
     /// reserves, while v3 also stores ticks and positions, which need to be initialized
     /// at the first pool creation.
     fn is_v3_initialized() -> bool;
@@ -108,9 +114,9 @@ pub trait SwapDataOperations {
     fn deposit_balances(tao: u64, alpha: u64);
 }
 
-/// All main swapping logic abstracted from Runtime implementation is concentrated 
+/// All main swapping logic abstracted from Runtime implementation is concentrated
 /// in this struct
-/// 
+///
 #[derive(Debug)]
 pub struct Swap<Ops>
 where
@@ -129,35 +135,29 @@ where
             // Set price, set initial (protocol owned) liquidity and positions, etc.
         }
 
-        Swap {
-            state_ops: ops,
-        }
+        Swap { state_ops: ops }
     }
 
-    /// Auxiliary method to calculate Alpha amount to match given TAO 
+    /// Auxiliary method to calculate Alpha amount to match given TAO
     /// amount at the current price for liquidity.
-    /// 
+    ///
     /// Returns (Alpha, Liquidity) tuple
-    /// 
+    ///
     pub fn get_tao_based_liquidity(tao: u64) -> (u64, u64) {
         // TODO
     }
 
-    /// Auxiliary method to calculate TAO amount to match given Alpha 
+    /// Auxiliary method to calculate TAO amount to match given Alpha
     /// amount at the current price for liquidity.
-    /// 
+    ///
     /// Returns (TAO, Liquidity) tuple
-    /// 
+    ///
     pub fn get_alpha_based_liquidity(alpha: u64) -> (u64, u64) {
         // TODO
     }
 
-    /// Add 
-    pub fn add_liquidity(
-        tick_low: u64,
-        tick_high: u64,
-        liquidity: u64
-    ) -> u64 {
+    /// Add
+    pub fn add_liquidity(tick_low: u64, tick_high: u64, liquidity: u64) -> u64 {
         // TODO
     }
 
@@ -168,4 +168,4 @@ where
     pub fn swap() {
         // TODO
     }
-}
\ No newline at end of file
+}

From 21f8094f18e1bd46106fcbc35938b775840a1eaf Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Wed, 12 Mar 2025 18:33:17 +0100
Subject: [PATCH 008/418] Extend Fixed with log methods

---
 primitives/safe-math/src/lib.rs | 152 +++++++++++++++++++++++++++-----
 primitives/swap/src/lib.rs      |  13 ++-
 2 files changed, 137 insertions(+), 28 deletions(-)

diff --git a/primitives/safe-math/src/lib.rs b/primitives/safe-math/src/lib.rs
index 6a703752e8..8069133f92 100644
--- a/primitives/safe-math/src/lib.rs
+++ b/primitives/safe-math/src/lib.rs
@@ -3,6 +3,8 @@
 #![cfg_attr(test, allow(clippy::arithmetic_side_effects))]
 #![cfg_attr(test, allow(clippy::unwrap_used))]
 
+use core::f64::consts::LN_2;
+
 use sp_arithmetic::traits::UniqueSaturatedInto;
 use substrate_fixed::traits::Fixed;
 
@@ -14,6 +16,24 @@ pub trait SafeDiv {
     fn safe_div(self, rhs: Self) -> Self;
 }
 
+/// Implementation of safe division trait for primitive types
+macro_rules! impl_safe_div_for_primitive {
+    ($($t:ty),*) => {
+        $(
+            impl SafeDiv for $t {
+                fn safe_div_or(self, rhs: Self, def: Self) -> Self {
+                    self.checked_div(rhs).unwrap_or(def)
+                }
+
+                fn safe_div(self, rhs: Self) -> Self {
+                    self.checked_div(rhs).unwrap_or_default()
+                }
+            }
+        )*
+    };
+}
+impl_safe_div_for_primitive!(u8, u16, u32, u64, i8, i16, i32, i64, usize);
+
 pub trait FixedExt: Fixed {
     fn checked_pow<E>(&self, exponent: E) -> Option<Self>
     where
@@ -90,6 +110,73 @@ pub trait FixedExt: Fixed {
         Some(middle)
     }
 
+    /// Natural logarithm (base e)
+    fn checked_ln(&self) -> Option<Self> {
+        if *self <= Self::from_num(0) {
+            return None;
+        }
+
+        // Constants
+        let one = Self::from_num(1);
+        let two = Self::from_num(2);
+        let ln2 = Self::from_num(LN_2);
+
+        // Find integer part of log2(x)
+        let mut exp = 0i64;
+        let mut y = *self;
+
+        // Scale y to be between 1 and 2
+        while y >= two {
+            y = y.checked_div(two)?;
+            exp = exp.checked_add(1)?;
+        }
+        while y < one {
+            y = y.checked_mul(two)?;
+            exp = exp.checked_sub(1)?;
+        }
+
+        // At this point, 1 <= y < 2
+        let z = y.checked_sub(one)?;
+
+        // For better accuracy, use more terms in the Taylor series
+        let z2 = z.checked_mul(z)?;
+        let z3 = z2.checked_mul(z)?;
+        let z4 = z3.checked_mul(z)?;
+        let z5 = z4.checked_mul(z)?;
+        let z6 = z5.checked_mul(z)?;
+        let z7 = z6.checked_mul(z)?;
+        let z8 = z7.checked_mul(z)?;
+
+        // More terms in the Taylor series for better accuracy
+        // ln(1+z) = z - z²/2 + z³/3 - z⁴/4 + z⁵/5 - z⁶/6 + z⁷/7 - z⁸/8 + ...
+        let ln_y = z
+            .checked_sub(z2.checked_mul(Self::from_num(0.5))?)?
+            .checked_add(z3.checked_mul(Self::from_num(1.0 / 3.0))?)?
+            .checked_sub(z4.checked_mul(Self::from_num(0.25))?)?
+            .checked_add(z5.checked_mul(Self::from_num(0.2))?)?
+            .checked_sub(z6.checked_mul(Self::from_num(1.0 / 6.0))?)?
+            .checked_add(z7.checked_mul(Self::from_num(1.0 / 7.0))?)?
+            .checked_sub(z8.checked_mul(Self::from_num(0.125))?)?;
+
+        // Final result: ln(x) = ln(y) + exp * ln(2)
+        let exp_ln2 = Self::from_num(exp).checked_mul(ln2)?;
+        ln_y.checked_add(exp_ln2)
+    }
+
+    /// Logarithm with arbitrary base
+    fn checked_log(&self, base: Self) -> Option<Self> {
+        // Check for invalid base
+        if base <= Self::from_num(0) || base == Self::from_num(1) {
+            return None;
+        }
+
+        // Calculate using change of base formula: log_b(x) = ln(x) / ln(b)
+        let ln_x = self.checked_ln()?;
+        let ln_base = base.checked_ln()?;
+
+        ln_x.checked_div(ln_base)
+    }
+
     fn abs_diff(&self, b: Self) -> Self {
         if *self < b {
             b.saturating_sub(*self)
@@ -109,29 +196,13 @@ pub trait FixedExt: Fixed {
 
 impl<T: Fixed> FixedExt for T {}
 
-/// Implementation of safe division trait for primitive types
-macro_rules! impl_safe_div_for_primitive {
-    ($($t:ty),*) => {
-        $(
-            impl SafeDiv for $t {
-                fn safe_div_or(self, rhs: Self, def: Self) -> Self {
-                    self.checked_div(rhs).unwrap_or(def)
-                }
-
-                fn safe_div(self, rhs: Self) -> Self {
-                    self.checked_div(rhs).unwrap_or_default()
-                }
-            }
-        )*
-    };
-}
-impl_safe_div_for_primitive!(u8, u16, u32, u64, i8, i16, i32, i64, usize);
-
 #[cfg(test)]
 mod tests {
-    use super::*;
+    use core::f64::consts::LN_10;
     use substrate_fixed::types::*; // Assuming U110F18 is properly imported
 
+    use super::*;
+
     #[test]
     fn test_checked_sqrt_positive_values() {
         let value: U110F18 = U110F18::from_num(4.0);
@@ -206,9 +277,48 @@ mod tests {
 
         let result = I32F32::from_num(1.5).checked_pow(-2i64);
 
-        assert!((result.unwrap() - I32F32::from_num(0.44444444)).abs() <= I32F32::from_num(0.0001));
+        assert!(
+            (result.unwrap() - I32F32::from_num(0.44444444)).abs() <= I32F32::from_num(0.00001)
+        );
 
         let result = I32F32::from_num(0).checked_pow(-1);
-        assert_eq!(result, None);
+        assert!(result.is_none());
+    }
+
+    #[test]
+    fn test_checked_ln() {
+        // Natural logarithm
+        assert!(
+            I64F64::from_num(10.0)
+                .checked_ln()
+                .unwrap()
+                .abs_diff(I64F64::from_num(LN_10))
+                < I64F64::from_num(0.00001)
+        );
+
+        // Log of negative number should return None
+        assert!(I64F64::from_num(-5.0).checked_ln().is_none());
+
+        // Log of zero should return None
+        assert!(I64F64::from_num(0.0).checked_ln().is_none());
+    }
+
+    #[test]
+    fn test_checked_log() {
+        let x = I64F64::from_num(10.0);
+
+        // Log base 10
+        assert!(
+            x.checked_log(I64F64::from_num(10.0))
+                .unwrap()
+                .abs_diff(I64F64::from_num(1.0))
+                < I64F64::from_num(0.00001)
+        );
+
+        // Log with invalid base should return None
+        assert!(x.checked_log(I64F64::from_num(-2.0)).is_none());
+
+        // Log with base 1 should return None
+        assert!(x.checked_log(I64F64::from_num(1.0)).is_none());
     }
 }
diff --git a/primitives/swap/src/lib.rs b/primitives/swap/src/lib.rs
index 0fc3c77044..f6b15f8a65 100644
--- a/primitives/swap/src/lib.rs
+++ b/primitives/swap/src/lib.rs
@@ -1,5 +1,4 @@
 use safe_math::*;
-use sp_arithmetic::traits::UniqueSaturatedInto;
 use substrate_fixed::types::U64F64;
 
 /// The width of a single price tick. Expressed in rao units.
@@ -34,10 +33,10 @@ struct Position {
 
 impl Position {
     /// Converts tick index into SQRT of price
-    pub fn tick_index_to_sqrt_price(tick_idx: u64) -> U64F64 {
+    pub fn tick_index_to_sqrt_price(tick_idx: u64) -> SqrtPrice {
         // python: (1 + self.tick_spacing) ** (i / 2)
-        let tick_spacing_tao = U64F64::from_num(TICK_SPACING).saturating_div(U64F64::from_num(1e9))
-            + U64F64::from_num(1.0);
+        let tick_spacing_tao = SqrtPrice::from_num(TICK_SPACING).saturating_div(SqrtPrice::from_num(1e9))
+            + SqrtPrice::from_num(1.0);
 
         tick_spacing_tao
             .checked_pow(tick_idx / 2)
@@ -45,9 +44,9 @@ impl Position {
     }
 
     /// Converts SQRT price to tick index
-    pub fn sqrt_price_to_tick_index(sqrt_price: U64F64) -> u64 {
-        let tick_spacing_tao = U64F64::from_num(TICK_SPACING).saturating_div(U64F64::from_num(1e9))
-            + U64F64::from_num(1.0);
+    pub fn sqrt_price_to_tick_index(sqrt_price: SqrtPrice) -> u64 {
+        let tick_spacing_tao = SqrtPrice::from_num(TICK_SPACING).saturating_div(SqrtPrice::from_num(1e9))
+            + SqrtPrice::from_num(1.0);
         // python: math.floor(math.log(sqrt_p) / math.log(1 + self.tick_spacing)) * 2
         todo!()
     }

From 7d2cc6ae0c8a778482c84a1c3d812dc8a911cd92 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Wed, 12 Mar 2025 18:36:41 -0400
Subject: [PATCH 009/418] Implement add_liquidity and remove_liquidity

---
 primitives/swap/src/lib.rs | 163 +++++++++++++++++++++++++++++++++----
 1 file changed, 145 insertions(+), 18 deletions(-)

diff --git a/primitives/swap/src/lib.rs b/primitives/swap/src/lib.rs
index 0fc3c77044..2c23cad90f 100644
--- a/primitives/swap/src/lib.rs
+++ b/primitives/swap/src/lib.rs
@@ -13,6 +13,13 @@ pub enum OrderType {
     Buy,
 }
 
+struct RemoveLiquidityResult {
+    tao: u64,
+    alpha: u64,
+    fee_tao: u64,
+    fee_alpha: u64,
+}
+
 /// Position designates one liquidity position.
 ///
 /// Alpha price is expressed in rao units per one 10^9 unit. For example,
@@ -102,7 +109,7 @@ struct Tick {
 /// in the pallet to be able to work with chain state and per subnet. All subnet
 /// swaps are independent and hence netuid is abstracted away from swap implementation.
 ///
-pub trait SwapDataOperations {
+pub trait SwapDataOperations<AccountIdType> {
     /// Tells if v3 swap is initialized in the state. v2 only provides base and quote
     /// reserves, while v3 also stores ticks and positions, which need to be initialized
     /// at the first pool creation.
@@ -111,6 +118,7 @@ pub trait SwapDataOperations {
     fn get_fee_rate() -> u16;
     fn get_tick_by_index(tick_index: u64) -> Option<Tick>;
     fn insert_tick_by_index(tick_index: u64, tick: Tick);
+    fn remove_tick_by_index(tick_index: u64);
     fn get_tao_reserve() -> u64;
     fn set_tao_reserve() -> u64;
     fn get_alpha_reserve() -> u64;
@@ -123,23 +131,33 @@ pub trait SwapDataOperations {
     /// Set current tick liquidity
     fn set_current_liquidity(liquidity: u64);
 
-    fn withdraw_balances(tao: u64, alpha: u64) -> (u64, u64);
-    fn deposit_balances(tao: u64, alpha: u64);
+    // User account operations
+    fn get_max_positions() -> u16;
+    fn withdraw_balances(account_id: &AccountIdType, tao: u64, alpha: u64) -> (u64, u64);
+    fn deposit_balances(account_id: &AccountIdType, tao: u64, alpha: u64);
+    fn get_position_count(account_id: &AccountIdType) -> u16;
+    fn get_position(account_id: &AccountIdType, position_id: u16) -> Option<Position>;
+    fn create_position(account_id: &AccountIdType, positions: Position);
+    fn update_position(account_id: &AccountIdType, position_id: u16, positions: Position);
+    fn remove_position(account_id: &AccountIdType, position_id: u16);
 }
 
 /// All main swapping logic abstracted from Runtime implementation is concentrated
 /// in this struct
 ///
 #[derive(Debug)]
-pub struct Swap<Ops>
+pub struct Swap<AccountIdType, Ops>
 where
+    AccountIdType: Eq,
     Ops: SwapDataOperations,
 {
     state_ops: Ops,
+    phantom_key: marker::PhantomData<AccountIdType>,
 }
 
-impl<Ops> Swap<Ops>
+impl<AccountIdType, Ops> Swap<AccountIdType, Ops>
 where
+    AccountIdType: Eq,
     Ops: SwapDataOperations,
 {
     pub fn new(ops: Ops) -> Self {
@@ -202,6 +220,30 @@ where
         self.state_ops.insert_tick_by_index(tick_index, new_tick);
     }
 
+    /// Remove liquidity at tick index.
+    ///
+    fn remove_liquidity_at_index(tick_index: u64, liquidity: u64, upper: bool) {
+        // Calculate net liquidity addition
+        let net_reduction = if upper {
+            (liquidity as i128).neg()
+        } else {
+            liquidity as i128
+        }
+
+        // Find tick by index
+        let new_tick = if let Some(tick) = self.state_ops.get_tick_by_index(tick_index) {
+            tick.liquidity_net = tick.liquidity_net.saturating_sub(net_reduction);
+            tick.liquidity_gross = tick.liquidity_gross.saturating_sub(liquidity);
+        }
+
+        // If any liquidity is left at the tick, update it, otherwise remove
+        if tick.liquidity_gross == 0 {
+            self.state_ops.remove_tick(tick_index);
+        } else {
+            self.state_ops.insert_tick_by_index(tick_index, new_tick);
+        }
+    }
+    
     /// Add liquidity
     ///
     /// The added liquidity amount can be calculated from TAO and Alpha
@@ -212,10 +254,19 @@ where
     ///
     pub fn add_liquidity(
         &self,
+        account_id: &AccountIdType,
         tick_low: u64,
         tick_high: u64,
         liquidity: u64
-    ) -> u64 {
+    ) -> Result<u64, ()> {
+        // Check if we can add a position
+        let position_count = self.state_ops.get_position_count(account_id);
+        let max_positions = get_max_positions();
+        if position_count >= max_positions {
+            return Err(());
+        }
+
+        // Add liquidity at tick
         self.add_liquidity_at_index(tick_low, liquidity, false);
         self.add_liquidity_at_index(tick_high, liquidity, true);
 
@@ -232,14 +283,7 @@ where
             self.state_ops.set_current_liquidity(new_current_liquidity);
         }
 
-        # Update positions
-        if len(self.user_positions) == 0:
-            self.user_positions = np.array([np.append(user_position, [0, 0])])
-        else:
-            self.user_positions = np.vstack([self.user_positions, np.append(user_position, [0, 0])])
-
-
-        // Update reserves
+        // Update balances
         let position = Position {
             tick_low,
             tick_high,
@@ -248,19 +292,79 @@ where
             fees_alpha: 0_u64,
         }
         let (tao, alpha) = position.to_token_amounts(current_tick_index);
+        self.state_ops.withdraw_balances(account_id, tao, alpha);
+
+        // Update reserves
         let new_tao_reserve = self.state_ops.get_tao_reserve().saturating_add(tao);
         self.state_ops.set_tao_reserve(new_tao_reserve);
         let new_alpha_reserve = self.get_alpha_reserve().saturating_add(alpha);
         self.state_ops.set_alpha_reserve(new_alpha);
+
+        // Update user positions
+        let position_id = position_count.saturating_add(1);
+        self.state_ops.set_position(account_id, position_id, position);
+
+        Ok(liquidity)
     }
 
+    /// Remove liquidity and credit balances back to account_id
+    /// 
+    /// Account ID and Position ID identify position in the storage map
+    /// 
     pub fn remove_liquidity(
         &self,
-        position: &Position,
-    ) {
-        // TODO
-    }
+        account_id: &AccountIdType,
+        position_id: u16,
+    ) -> Result<RemoveLiquidityResult, ()> {
+        // Check if position exists
+        if let Some(pos) = self.state_ops.get_position(account_id, position_id) {
+            // Get current price
+            let current_price = self.state_ops.get_alpha_sqrt_price();
+            let current_tick_index = Position::sqrt_price_to_tick_index(current_price);
+
+            // Collect fees and get tao and alpha amounts
+            let (fee_tao, fee_alpha) = self.collect_fees(pos);
+            let (tao, alpha) = pos.to_token_amounts(current_tick_index);
+
+            // Update liquidity at position ticks
+            self.remove_liquidity_at_index(pos.tick_low, pos.liquidity, false);
+            self.remove_liquidity_at_index(pos.tick_high, pos.liquidity, true);
+
+            // Update current tick liquidity
+            if (pos.tick_low <= current_tick_index) && (current_tick_index <= pos.tick_high) {
+                let new_current_liquidity = self.state_ops.get_current_liquidity()
+                    .saturating_sub(liquidity);
+                self.state_ops.set_current_liquidity(new_current_liquidity);
+            }
 
+            // Remove user position
+            self.state_ops.remove_position(account_id, position_id);
+    
+            // Update current price (why?)
+            // i = self.sqrt_price_to_tick(self.sqrt_price_curr)
+            // k = self.get_tick_index(i)
+            // self.i_curr = self.active_ticks[k]
+            todo!();
+
+            // Update reserves
+            let new_tao_reserve = self.state_ops.get_tao_reserve().saturating_sub(tao);
+            self.state_ops.set_tao_reserve(new_tao_reserve);
+            let new_alpha_reserve = self.get_alpha_reserve().saturating_sub(alpha);
+            self.state_ops.set_alpha_reserve(new_alpha);
+
+            // Return Ok result
+            Ok(RemoveLiquidityResult{
+                tao,
+                alpha,
+                fee_tao,
+                fee_alpha,
+            })
+        } else {
+            // Position doesn't exist
+            Err(())
+        }
+    }
+    
     /// Perform a swap
     ///
     /// Returns a tuple (amount, refund), where amount is the resulting paid out amount
@@ -273,4 +377,27 @@ where
     ) -> (u64, u64) {
         // TODO
     }
+
+    /// Updates position
+    fn collect_fees(&self, position: &mut Position) -> (u64, u64) {
+        // """Collect fees for a position"""
+        // liquidity = self.user_positions[user_idx, 2]
+        // fee0 = self.get_fees_in_range(user_idx, 0)
+        // fee1 = self.get_fees_in_range(user_idx, 1)
+
+        // fee0 = fee0 - self.user_positions[user_idx, 3]
+        // fee1 = fee1 - self.user_positions[user_idx, 4]
+
+        // self.user_positions[user_idx, 3] = fee0
+        // self.user_positions[user_idx, 4] = fee1
+
+        // fee0 = liquidity * fee0
+        // fee1 = liquidity * fee1
+
+
+        // return fee0, fee1
+
+        todo!()
+    }
+
 }

From fba9001be78485866cae8d6720e09072ac0133bf Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Thu, 13 Mar 2025 13:27:11 +0100
Subject: [PATCH 010/418] Add floor method to Fixed

---
 primitives/safe-math/src/lib.rs |  50 +++++
 primitives/swap/src/lib.rs      | 360 ++++++++++++++++----------------
 2 files changed, 235 insertions(+), 175 deletions(-)

diff --git a/primitives/safe-math/src/lib.rs b/primitives/safe-math/src/lib.rs
index 8069133f92..eda964e678 100644
--- a/primitives/safe-math/src/lib.rs
+++ b/primitives/safe-math/src/lib.rs
@@ -177,6 +177,27 @@ pub trait FixedExt: Fixed {
         ln_x.checked_div(ln_base)
     }
 
+    /// Returns the largest integer less than or equal to the fixed-point number.
+    fn checked_floor(&self) -> Option<Self> {
+        // Approach using the integer and fractional parts
+        if *self >= Self::from_num(0) {
+            // For non-negative numbers, simply return the integer part
+            return Some(Self::from_num(self.int()));
+        }
+
+        // For negative numbers
+        let int_part = self.int();
+        let frac_part = self.frac();
+
+        if frac_part == Self::from_num(0) {
+            // No fractional part, return as is
+            return Some(*self);
+        }
+
+        // Has fractional part, we need to round down
+        int_part.checked_sub(Self::from_num(1))
+    }
+
     fn abs_diff(&self, b: Self) -> Self {
         if *self < b {
             b.saturating_sub(*self)
@@ -321,4 +342,33 @@ mod tests {
         // Log with base 1 should return None
         assert!(x.checked_log(I64F64::from_num(1.0)).is_none());
     }
+
+    #[test]
+    fn test_checked_floor() {
+        // Test cases: (input, expected floor result)
+        let test_cases = [
+            // Positive and negative integers (should remain unchanged)
+            (0.0, 0.0),
+            (1.0, 1.0),
+            (5.0, 5.0),
+            (-1.0, -1.0),
+            (-5.0, -5.0),
+            // Positive fractions (should truncate to integer part)
+            (0.5, 0.0),
+            (1.5, 1.0),
+            (3.75, 3.0),
+            (9.999, 9.0),
+            // Negative fractions (should round down to next integer)
+            (-0.1, -1.0),
+            (-1.5, -2.0),
+            (-3.75, -4.0),
+            (-9.999, -10.0),
+        ];
+
+        for &(input, expected) in &test_cases {
+            let x = I64F64::from_num(input);
+            let expected = I64F64::from_num(expected);
+            assert_eq!(x.checked_floor().unwrap(), expected,);
+        }
+    }
 }
diff --git a/primitives/swap/src/lib.rs b/primitives/swap/src/lib.rs
index 225e80350d..2db4abc1aa 100644
--- a/primitives/swap/src/lib.rs
+++ b/primitives/swap/src/lib.rs
@@ -1,3 +1,5 @@
+use core::marker::PhantomData;
+
 use safe_math::*;
 use substrate_fixed::types::U64F64;
 
@@ -42,8 +44,7 @@ impl Position {
     /// Converts tick index into SQRT of price
     pub fn tick_index_to_sqrt_price(tick_idx: u64) -> SqrtPrice {
         // python: (1 + self.tick_spacing) ** (i / 2)
-        let tick_spacing_tao = SqrtPrice::from_num(TICK_SPACING).saturating_div(SqrtPrice::from_num(1e9))
-            + SqrtPrice::from_num(1.0);
+        let tick_spacing_tao = Self::tick_spacing_tao();
 
         tick_spacing_tao
             .checked_pow(tick_idx / 2)
@@ -52,10 +53,18 @@ impl Position {
 
     /// Converts SQRT price to tick index
     pub fn sqrt_price_to_tick_index(sqrt_price: SqrtPrice) -> u64 {
-        let tick_spacing_tao = SqrtPrice::from_num(TICK_SPACING).saturating_div(SqrtPrice::from_num(1e9))
-            + SqrtPrice::from_num(1.0);
         // python: math.floor(math.log(sqrt_p) / math.log(1 + self.tick_spacing)) * 2
-        todo!()
+        let tick_spacing_tao = Self::tick_spacing_tao();
+        // floor(x) * 2
+        sqrt_price
+            .checked_ln()
+            .unwrap_or_default()
+            .safe_div(tick_spacing_tao.checked_ln().unwrap_or_default())
+    }
+
+    fn tick_spacing_tao() -> SqrtPrice {
+        SqrtPrice::from_num(TICK_SPACING).saturating_div(SqrtPrice::from_num(1e9))
+            + SqrtPrice::from_num(1.0)
     }
 
     /// Converts position to token amounts
@@ -69,23 +78,24 @@ impl Position {
         let sqrt_pa = Self::tick_index_to_sqrt_price(self.tick_low);
         let sqrt_pb = Self::tick_index_to_sqrt_price(self.tick_high);
 
-        if sqrt_price_curr < sqrt_pa {
-            (
-                liquidity
-                    .saturating_mul(one.safe_div(sqrt_pa).saturating_sub(one.safe_div(sqrt_pb))),
-                0,
-            )
-        } else if sqrt_price_curr > sqrt_pb {
-            (0, liquidity.saturating_mul(sqrt_pb.saturating_sub(sqrt_pa)))
-        } else {
-            (
-                liquidity.saturating_mul(
-                    one.save_div(sqrt_price_curr)
-                        .saturating_sub(one.safe_div(sqrt_pb)),
-                ),
-                liquidity.saturating_mul(sqrt_price_curr.saturating_sub(sqrt_pa)),
-            )
-        }
+        // if sqrt_price_curr < sqrt_pa {
+        //     (
+        //         liquidity
+        //             .saturating_mul(one.safe_div(sqrt_pa).saturating_sub(one.safe_div(sqrt_pb))),
+        //         0,
+        //     )
+        // } else if sqrt_price_curr > sqrt_pb {
+        //     (0, liquidity.saturating_mul(sqrt_pb.saturating_sub(sqrt_pa)))
+        // } else {
+        //     (
+        //         liquidity.saturating_mul(
+        //             one.save_div(sqrt_price_curr)
+        //                 .saturating_sub(one.safe_div(sqrt_pb)),
+        //         ),
+        //         liquidity.saturating_mul(sqrt_price_curr.saturating_sub(sqrt_pa)),
+        //     )
+        // }
+        todo!()
     }
 }
 
@@ -151,7 +161,7 @@ where
     Ops: SwapDataOperations,
 {
     state_ops: Ops,
-    phantom_key: marker::PhantomData<AccountIdType>,
+    phantom_key: PhantomData<AccountIdType>,
 }
 
 impl<AccountIdType, Ops> Swap<AccountIdType, Ops>
@@ -160,12 +170,13 @@ where
     Ops: SwapDataOperations,
 {
     pub fn new(ops: Ops) -> Self {
-        if !ops.is_v3_initialized() {
-            // TODO: Initialize the v3
-            // Set price, set initial (protocol owned) liquidity and positions, etc.
-        }
+        // if !ops.is_v3_initialized() {
+        //     // TODO: Initialize the v3
+        //     // Set price, set initial (protocol owned) liquidity and positions, etc.
+        // }
 
-        Swap { state_ops: ops }
+        // Swap { state_ops: ops }
+        todo!()
     }
 
     /// Auxiliary method to calculate Alpha amount to match given TAO
@@ -174,9 +185,8 @@ where
     /// Returns (Alpha, Liquidity) tuple
     ///
     pub fn get_tao_based_liquidity(&self, tao: u64) -> (u64, u64) {
-        let current_price = self.state_ops.get_alpha_sqrt_price();
-
-        // TODO
+        // let current_price = self.state_ops.get_alpha_sqrt_price();
+        todo!()
     }
 
     /// Auxiliary method to calculate TAO amount to match given Alpha
@@ -185,64 +195,64 @@ where
     /// Returns (TAO, Liquidity) tuple
     ///
     pub fn get_alpha_based_liquidity(&self, alpha: u64) -> (u64, u64) {
-        let current_price = self.state_ops.get_alpha_sqrt_price();
+        // let current_price = self.state_ops.get_alpha_sqrt_price();
 
-        // TODO
+        todo!()
     }
 
     /// Add liquidity at tick index. Creates new tick if it doesn't exist
     ///
     fn add_liquidity_at_index(tick_index: u64, liquidity: u64, upper: bool) {
         // Calculate net liquidity addition
-        let net_addition = if upper {
-            (liquidity as i128).neg()
-        } else {
-            liquidity as i128
-        }
-
-        // Find tick by index
-        let new_tick = if let Some(tick) = self.state_ops.get_tick_by_index(tick_index) {
-            tick.liquidity_net = tick.liquidity_net.saturating_add(net_addition);
-            tick.liquidity_gross = tick.liquidity_gross.saturating_add(liquidity);
-        } else {
-            // Create a new tick
-            Tick {
-                liquidity_net: net_addition,
-                liquidity_gross: liquidity,
-                fees_out_tao: 0_u64,
-                fees_out_alpha: 0_u64,
-            }
-        }
-
-        // TODO: Review why Python code uses this code to find index for the new ticks:
-        // self.get_tick_index(user_position[0]) + 1
-        self.state_ops.insert_tick_by_index(tick_index, new_tick);
+        // let net_addition = if upper {
+        //     (liquidity as i128).neg()
+        // } else {
+        //     liquidity as i128
+        // }
+
+        // // Find tick by index
+        // let new_tick = if let Some(tick) = self.state_ops.get_tick_by_index(tick_index) {
+        //     tick.liquidity_net = tick.liquidity_net.saturating_add(net_addition);
+        //     tick.liquidity_gross = tick.liquidity_gross.saturating_add(liquidity);
+        // } else {
+        //     // Create a new tick
+        //     Tick {
+        //         liquidity_net: net_addition,
+        //         liquidity_gross: liquidity,
+        //         fees_out_tao: 0_u64,
+        //         fees_out_alpha: 0_u64,
+        //     }
+        // }
+
+        // // TODO: Review why Python code uses this code to find index for the new ticks:
+        // // self.get_tick_index(user_position[0]) + 1
+        // self.state_ops.insert_tick_by_index(tick_index, new_tick);
     }
 
     /// Remove liquidity at tick index.
     ///
     fn remove_liquidity_at_index(tick_index: u64, liquidity: u64, upper: bool) {
-        // Calculate net liquidity addition
-        let net_reduction = if upper {
-            (liquidity as i128).neg()
-        } else {
-            liquidity as i128
-        }
-
-        // Find tick by index
-        let new_tick = if let Some(tick) = self.state_ops.get_tick_by_index(tick_index) {
-            tick.liquidity_net = tick.liquidity_net.saturating_sub(net_reduction);
-            tick.liquidity_gross = tick.liquidity_gross.saturating_sub(liquidity);
-        }
-
-        // If any liquidity is left at the tick, update it, otherwise remove
-        if tick.liquidity_gross == 0 {
-            self.state_ops.remove_tick(tick_index);
-        } else {
-            self.state_ops.insert_tick_by_index(tick_index, new_tick);
-        }
+        // // Calculate net liquidity addition
+        // let net_reduction = if upper {
+        //     (liquidity as i128).neg()
+        // } else {
+        //     liquidity as i128
+        // }
+
+        // // Find tick by index
+        // let new_tick = if let Some(tick) = self.state_ops.get_tick_by_index(tick_index) {
+        //     tick.liquidity_net = tick.liquidity_net.saturating_sub(net_reduction);
+        //     tick.liquidity_gross = tick.liquidity_gross.saturating_sub(liquidity);
+        // }
+
+        // // If any liquidity is left at the tick, update it, otherwise remove
+        // if tick.liquidity_gross == 0 {
+        //     self.state_ops.remove_tick(tick_index);
+        // } else {
+        //     self.state_ops.insert_tick_by_index(tick_index, new_tick);
+        // }
     }
-    
+
     /// Add liquidity
     ///
     /// The added liquidity amount can be calculated from TAO and Alpha
@@ -256,114 +266,116 @@ where
         account_id: &AccountIdType,
         tick_low: u64,
         tick_high: u64,
-        liquidity: u64
+        liquidity: u64,
     ) -> Result<u64, ()> {
-        // Check if we can add a position
-        let position_count = self.state_ops.get_position_count(account_id);
-        let max_positions = get_max_positions();
-        if position_count >= max_positions {
-            return Err(());
-        }
-
-        // Add liquidity at tick
-        self.add_liquidity_at_index(tick_low, liquidity, false);
-        self.add_liquidity_at_index(tick_high, liquidity, true);
-
-        // Update current tick and liquidity
-        // TODO: Review why python uses this code to get the new tick index:
-        // k = self.get_tick_index(i)
-        let current_price = self.state_ops.get_alpha_sqrt_price();
-        let current_tick_index = Position::sqrt_price_to_tick_index(current_price);
-
-        // Update current tick liquidity
-        if (tick_low <= current_tick_index) && (current_tick_index <= tick_high) {
-            let new_current_liquidity = self.state_ops.get_current_liquidity()
-                .saturating_add(liquidity);
-            self.state_ops.set_current_liquidity(new_current_liquidity);
-        }
-
-        // Update balances
-        let position = Position {
-            tick_low,
-            tick_high,
-            liquidity,
-            fees_tao: 0_u64,
-            fees_alpha: 0_u64,
-        }
-        let (tao, alpha) = position.to_token_amounts(current_tick_index);
-        self.state_ops.withdraw_balances(account_id, tao, alpha);
-
-        // Update reserves
-        let new_tao_reserve = self.state_ops.get_tao_reserve().saturating_add(tao);
-        self.state_ops.set_tao_reserve(new_tao_reserve);
-        let new_alpha_reserve = self.get_alpha_reserve().saturating_add(alpha);
-        self.state_ops.set_alpha_reserve(new_alpha);
-
-        // Update user positions
-        let position_id = position_count.saturating_add(1);
-        self.state_ops.set_position(account_id, position_id, position);
-
-        Ok(liquidity)
+        // // Check if we can add a position
+        // let position_count = self.state_ops.get_position_count(account_id);
+        // let max_positions = get_max_positions();
+        // if position_count >= max_positions {
+        //     return Err(());
+        // }
+
+        // // Add liquidity at tick
+        // self.add_liquidity_at_index(tick_low, liquidity, false);
+        // self.add_liquidity_at_index(tick_high, liquidity, true);
+
+        // // Update current tick and liquidity
+        // // TODO: Review why python uses this code to get the new tick index:
+        // // k = self.get_tick_index(i)
+        // let current_price = self.state_ops.get_alpha_sqrt_price();
+        // let current_tick_index = Position::sqrt_price_to_tick_index(current_price);
+
+        // // Update current tick liquidity
+        // if (tick_low <= current_tick_index) && (current_tick_index <= tick_high) {
+        //     let new_current_liquidity = self.state_ops.get_current_liquidity()
+        //         .saturating_add(liquidity);
+        //     self.state_ops.set_current_liquidity(new_current_liquidity);
+        // }
+
+        // // Update balances
+        // let position = Position {
+        //     tick_low,
+        //     tick_high,
+        //     liquidity,
+        //     fees_tao: 0_u64,
+        //     fees_alpha: 0_u64,
+        // }
+        // let (tao, alpha) = position.to_token_amounts(current_tick_index);
+        // self.state_ops.withdraw_balances(account_id, tao, alpha);
+
+        // // Update reserves
+        // let new_tao_reserve = self.state_ops.get_tao_reserve().saturating_add(tao);
+        // self.state_ops.set_tao_reserve(new_tao_reserve);
+        // let new_alpha_reserve = self.get_alpha_reserve().saturating_add(alpha);
+        // self.state_ops.set_alpha_reserve(new_alpha);
+
+        // // Update user positions
+        // let position_id = position_count.saturating_add(1);
+        // self.state_ops.set_position(account_id, position_id, position);
+
+        // Ok(liquidity)
+        todo!()
     }
 
     /// Remove liquidity and credit balances back to account_id
-    /// 
+    ///
     /// Account ID and Position ID identify position in the storage map
-    /// 
+    ///
     pub fn remove_liquidity(
         &self,
         account_id: &AccountIdType,
         position_id: u16,
     ) -> Result<RemoveLiquidityResult, ()> {
         // Check if position exists
-        if let Some(pos) = self.state_ops.get_position(account_id, position_id) {
-            // Get current price
-            let current_price = self.state_ops.get_alpha_sqrt_price();
-            let current_tick_index = Position::sqrt_price_to_tick_index(current_price);
-
-            // Collect fees and get tao and alpha amounts
-            let (fee_tao, fee_alpha) = self.collect_fees(pos);
-            let (tao, alpha) = pos.to_token_amounts(current_tick_index);
-
-            // Update liquidity at position ticks
-            self.remove_liquidity_at_index(pos.tick_low, pos.liquidity, false);
-            self.remove_liquidity_at_index(pos.tick_high, pos.liquidity, true);
-
-            // Update current tick liquidity
-            if (pos.tick_low <= current_tick_index) && (current_tick_index <= pos.tick_high) {
-                let new_current_liquidity = self.state_ops.get_current_liquidity()
-                    .saturating_sub(liquidity);
-                self.state_ops.set_current_liquidity(new_current_liquidity);
-            }
-
-            // Remove user position
-            self.state_ops.remove_position(account_id, position_id);
-    
-            // Update current price (why?)
-            // i = self.sqrt_price_to_tick(self.sqrt_price_curr)
-            // k = self.get_tick_index(i)
-            // self.i_curr = self.active_ticks[k]
-            todo!();
-
-            // Update reserves
-            let new_tao_reserve = self.state_ops.get_tao_reserve().saturating_sub(tao);
-            self.state_ops.set_tao_reserve(new_tao_reserve);
-            let new_alpha_reserve = self.get_alpha_reserve().saturating_sub(alpha);
-            self.state_ops.set_alpha_reserve(new_alpha);
-
-            // Return Ok result
-            Ok(RemoveLiquidityResult{
-                tao,
-                alpha,
-                fee_tao,
-                fee_alpha,
-            })
-        } else {
-            // Position doesn't exist
-            Err(())
-        }
+        // if let Some(pos) = self.state_ops.get_position(account_id, position_id) {
+        //     // Get current price
+        //     let current_price = self.state_ops.get_alpha_sqrt_price();
+        //     let current_tick_index = Position::sqrt_price_to_tick_index(current_price);
+
+        //     // Collect fees and get tao and alpha amounts
+        //     let (fee_tao, fee_alpha) = self.collect_fees(pos);
+        //     let (tao, alpha) = pos.to_token_amounts(current_tick_index);
+
+        //     // Update liquidity at position ticks
+        //     self.remove_liquidity_at_index(pos.tick_low, pos.liquidity, false);
+        //     self.remove_liquidity_at_index(pos.tick_high, pos.liquidity, true);
+
+        //     // Update current tick liquidity
+        //     if (pos.tick_low <= current_tick_index) && (current_tick_index <= pos.tick_high) {
+        //         let new_current_liquidity = self.state_ops.get_current_liquidity()
+        //             .saturating_sub(liquidity);
+        //         self.state_ops.set_current_liquidity(new_current_liquidity);
+        //     }
+
+        //     // Remove user position
+        //     self.state_ops.remove_position(account_id, position_id);
+
+        //     // Update current price (why?)
+        //     // i = self.sqrt_price_to_tick(self.sqrt_price_curr)
+        //     // k = self.get_tick_index(i)
+        //     // self.i_curr = self.active_ticks[k]
+        //     todo!();
+
+        //     // Update reserves
+        //     let new_tao_reserve = self.state_ops.get_tao_reserve().saturating_sub(tao);
+        //     self.state_ops.set_tao_reserve(new_tao_reserve);
+        //     let new_alpha_reserve = self.get_alpha_reserve().saturating_sub(alpha);
+        //     self.state_ops.set_alpha_reserve(new_alpha);
+
+        //     // Return Ok result
+        //     Ok(RemoveLiquidityResult{
+        //         tao,
+        //         alpha,
+        //         fee_tao,
+        //         fee_alpha,
+        //     })
+        // } else {
+        //     // Position doesn't exist
+        //     Err(())
+        // }
+        todo!()
     }
-    
+
     /// Perform a swap
     ///
     /// Returns a tuple (amount, refund), where amount is the resulting paid out amount
@@ -374,7 +386,7 @@ where
         amount: u64,
         sqrt_price_limit: SqrtPrice,
     ) -> (u64, u64) {
-        // TODO
+        todo!()
     }
 
     /// Updates position
@@ -393,10 +405,8 @@ where
         // fee0 = liquidity * fee0
         // fee1 = liquidity * fee1
 
-
         // return fee0, fee1
 
         todo!()
     }
-
 }

From 92d8de08a605d3eb05e504928229796f9f075bb4 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Thu, 13 Mar 2025 19:13:52 +0100
Subject: [PATCH 011/418] Implement Position::sqrt_price_to_tick_index

---
 primitives/swap/src/lib.rs | 97 +++++++++++++++++++++++++++++++-------
 1 file changed, 81 insertions(+), 16 deletions(-)

diff --git a/primitives/swap/src/lib.rs b/primitives/swap/src/lib.rs
index 2db4abc1aa..c46e37530f 100644
--- a/primitives/swap/src/lib.rs
+++ b/primitives/swap/src/lib.rs
@@ -32,6 +32,7 @@ struct RemoveLiquidityResult {
 /// fees_tao - fees accrued by the position in quote currency (TAO)
 /// fees_alpha - fees accrued by the position in base currency (Alpha)
 ///
+#[cfg_attr(test, derive(Debug, PartialEq))]
 struct Position {
     tick_low: u64,
     tick_high: u64,
@@ -43,28 +44,33 @@ struct Position {
 impl Position {
     /// Converts tick index into SQRT of price
     pub fn tick_index_to_sqrt_price(tick_idx: u64) -> SqrtPrice {
-        // python: (1 + self.tick_spacing) ** (i / 2)
-        let tick_spacing_tao = Self::tick_spacing_tao();
-
-        tick_spacing_tao
+        // (1 + tick_spacing) ** (i / 2)
+        Self::tick_spacing_tao()
             .checked_pow(tick_idx / 2)
             .unwrap_or_default()
     }
 
     /// Converts SQRT price to tick index
     pub fn sqrt_price_to_tick_index(sqrt_price: SqrtPrice) -> u64 {
-        // python: math.floor(math.log(sqrt_p) / math.log(1 + self.tick_spacing)) * 2
-        let tick_spacing_tao = Self::tick_spacing_tao();
-        // floor(x) * 2
+        // floor(log(sqrt_p) / log(1 + tick_spacing)) * 2.0
+        let Some(tick_spacing_ln) = Self::tick_spacing_tao().checked_ln() else {
+            return 0;
+        };
+
         sqrt_price
             .checked_ln()
             .unwrap_or_default()
-            .safe_div(tick_spacing_tao.checked_ln().unwrap_or_default())
+            .safe_div(tick_spacing_ln)
+            .checked_floor()
+            .unwrap_or_default()
+            .saturating_mul(SqrtPrice::from_num(2.0))
+            .saturating_to_num()
     }
 
     fn tick_spacing_tao() -> SqrtPrice {
-        SqrtPrice::from_num(TICK_SPACING).saturating_div(SqrtPrice::from_num(1e9))
-            + SqrtPrice::from_num(1.0)
+        SqrtPrice::from_num(TICK_SPACING)
+            .saturating_div(SqrtPrice::from_num(1e9))
+            .saturating_add(SqrtPrice::from_num(1.0))
     }
 
     /// Converts position to token amounts
@@ -72,11 +78,11 @@ impl Position {
     /// returns tuple of (TAO, Alpha)
     ///
     pub fn to_token_amounts(self, current_tick: u64) -> (u64, u64) {
-        let one = 1.into();
+        // let one = 1.into();
 
-        let sqrt_price_curr = Self::tick_index_to_sqrt_price(current_tick);
-        let sqrt_pa = Self::tick_index_to_sqrt_price(self.tick_low);
-        let sqrt_pb = Self::tick_index_to_sqrt_price(self.tick_high);
+        // let sqrt_price_curr = Self::tick_index_to_sqrt_price(current_tick);
+        // let sqrt_pa = Self::tick_index_to_sqrt_price(self.tick_low);
+        // let sqrt_pb = Self::tick_index_to_sqrt_price(self.tick_high);
 
         // if sqrt_price_curr < sqrt_pa {
         //     (
@@ -158,7 +164,7 @@ pub trait SwapDataOperations<AccountIdType> {
 pub struct Swap<AccountIdType, Ops>
 where
     AccountIdType: Eq,
-    Ops: SwapDataOperations,
+    Ops: SwapDataOperations<AccountIdType>,
 {
     state_ops: Ops,
     phantom_key: PhantomData<AccountIdType>,
@@ -167,7 +173,7 @@ where
 impl<AccountIdType, Ops> Swap<AccountIdType, Ops>
 where
     AccountIdType: Eq,
-    Ops: SwapDataOperations,
+    Ops: SwapDataOperations<AccountIdType>,
 {
     pub fn new(ops: Ops) -> Self {
         // if !ops.is_v3_initialized() {
@@ -410,3 +416,62 @@ where
         todo!()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_tick_index_to_sqrt_price() {
+        // At tick index 0, the sqrt price should be 1.0
+        let sqrt_price = Position::tick_index_to_sqrt_price(0);
+        assert_eq!(sqrt_price, SqrtPrice::from_num(1.0));
+
+        let sqrt_price = Position::tick_index_to_sqrt_price(2);
+        let tick_spacing_tao = Position::tick_spacing_tao();
+        assert_eq!(sqrt_price, tick_spacing_tao);
+
+        let sqrt_price = Position::tick_index_to_sqrt_price(4);
+        // Calculate the expected value: (1 + TICK_SPACING/1e9 + 1.0)^2
+        let expected = tick_spacing_tao * tick_spacing_tao;
+        assert_eq!(sqrt_price, expected);
+
+        // Test with tick index 10
+        let sqrt_price = Position::tick_index_to_sqrt_price(10);
+        // Calculate the expected value: (1 + TICK_SPACING/1e9 + 1.0)^5
+        let expected_sqrt_price_10 = tick_spacing_tao.checked_pow(5).unwrap();
+        assert_eq!(sqrt_price, expected_sqrt_price_10);
+    }
+
+    #[test]
+    fn test_sqrt_price_to_tick_index() {
+        let tick_spacing_tao = Position::tick_spacing_tao();
+
+        let tick_index = Position::sqrt_price_to_tick_index(SqrtPrice::from_num(1.0));
+        assert_eq!(tick_index, 0);
+
+        // Test with sqrt price equal to tick_spacing_tao (should be tick index 2)
+        let tick_index = Position::sqrt_price_to_tick_index(tick_spacing_tao);
+        assert_eq!(tick_index, 2);
+
+        // Test with sqrt price equal to tick_spacing_tao^2 (should be tick index 4)
+        let sqrt_price = tick_spacing_tao * tick_spacing_tao;
+        let tick_index = Position::sqrt_price_to_tick_index(sqrt_price);
+        assert_eq!(tick_index, 4);
+
+        // Test with sqrt price equal to tick_spacing_tao^5 (should be tick index 10)
+        let sqrt_price = tick_spacing_tao.checked_pow(5).unwrap();
+        let tick_index = Position::sqrt_price_to_tick_index(sqrt_price);
+        assert_eq!(tick_index, 10,);
+    }
+
+    #[test]
+    fn test_roundtrip_tick_index_sqrt_price() {
+        for tick_index in [0, 2, 4, 10, 100, 1000].iter() {
+            let sqrt_price = Position::tick_index_to_sqrt_price(*tick_index);
+            let round_trip_tick_index = Position::sqrt_price_to_tick_index(sqrt_price);
+            dbg!(tick_index, round_trip_tick_index);
+            // assert_eq!(round_trip_tick_index, *tick_index);
+        }
+    }
+}

From e50058622d01d0376e77ee0a31a7c88bcbcc412e Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Thu, 13 Mar 2025 19:28:51 +0100
Subject: [PATCH 012/418] Port Position methods implementations from uniswap

---
 primitives/swap/src/lib.rs | 233 ++++++++++++++++++++++++++++++++++---
 1 file changed, 215 insertions(+), 18 deletions(-)

diff --git a/primitives/swap/src/lib.rs b/primitives/swap/src/lib.rs
index c46e37530f..b0c8eb936a 100644
--- a/primitives/swap/src/lib.rs
+++ b/primitives/swap/src/lib.rs
@@ -5,9 +5,189 @@ use substrate_fixed::types::U64F64;
 
 /// The width of a single price tick. Expressed in rao units.
 pub const TICK_SPACING: u64 = 10_000;
+pub const MAX_TICK: i32 = 887272;
+pub const MIN_SQRT_RATIO: u128 = 4295128739;
+pub const MAX_SQRT_RATIO: u128 = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
 
 type SqrtPrice = U64F64;
 
+/// Calculates sqrt(1.0001^tick) * 2^96
+pub fn get_sqrt_ratio_at_tick(tick: i32) -> u128 {
+    // Ensure tick is within bounds
+    let abs_tick = if tick < 0 { -tick } else { tick } as u32;
+    assert!(abs_tick <= MAX_TICK as u32, "Tick outside of allowed range");
+
+    // Initial ratio value
+    let mut ratio: u128 = if abs_tick & 0x1 != 0 {
+        0xfffcb933bd6fad37 << 64 | 0xaa2d162d1a594001
+    } else {
+        0x1 << 96
+    };
+
+    // Safe multiply and shift function
+    fn mul_shr(a: u128, b_hi: u64, b_lo: u64, shift: u8) -> u128 {
+        // Split a into high and low parts
+        let a_hi = a >> 64;
+        let a_lo = a & 0xFFFFFFFFFFFFFFFF;
+
+        // Multiply parts separately to avoid overflow
+        // (a_hi * 2^64 + a_lo) * (b_hi * 2^64 + b_lo)
+        // Only keep the high part since we're shifting by at least 64 anyway
+        let hi_hi = a_hi.checked_mul(b_hi as u128).unwrap_or(0);
+
+        // These parts will be shifted by 64
+        let hi_lo = a_hi.checked_mul(b_lo as u128).unwrap_or(0);
+        let lo_hi = a_lo.checked_mul(b_hi as u128).unwrap_or(0);
+
+        // Combine parts, adding with overflow checking
+        let mut result = hi_hi << 64;
+        result = result.checked_add(hi_lo).unwrap_or(result);
+        result = result.checked_add(lo_hi).unwrap_or(result);
+
+        // Final shift (already accounted for 64 bits)
+        if shift <= 64 {
+            result >> (shift - 64)
+        } else if shift < 128 {
+            result >> (shift - 64)
+        } else {
+            0
+        }
+    }
+
+    // Multiply ratio by appropriate factor based on each bit
+    // Break each constant into high and low 64-bit parts
+    if abs_tick & 0x2 != 0 {
+        ratio = mul_shr(ratio, 0xfff97272373d4132, 0x59a46990580e213a, 128);
+    }
+    if abs_tick & 0x4 != 0 {
+        ratio = mul_shr(ratio, 0xfff2e50f5f656932, 0xef12357cf3c7fdcc, 128);
+    }
+    if abs_tick & 0x8 != 0 {
+        ratio = mul_shr(ratio, 0xffe5caca7e10e4e6, 0x1c3624eaa0941cd0, 128);
+    }
+    if abs_tick & 0x10 != 0 {
+        ratio = mul_shr(ratio, 0xffcb9843d60f6159, 0xc9db58835c926644, 128);
+    }
+    if abs_tick & 0x20 != 0 {
+        ratio = mul_shr(ratio, 0xff973b41fa98c081, 0x472e6896dfb254c0, 128);
+    }
+    if abs_tick & 0x40 != 0 {
+        ratio = mul_shr(ratio, 0xff2ea16466c96a38, 0x43ec78b326b52861, 128);
+    }
+    if abs_tick & 0x80 != 0 {
+        ratio = mul_shr(ratio, 0xfe5dee046a99a2a8, 0x11c461f1969c3053, 128);
+    }
+    if abs_tick & 0x100 != 0 {
+        ratio = mul_shr(ratio, 0xfcbe86c7900a88ae, 0xdcffc83b479aa3a4, 128);
+    }
+    if abs_tick & 0x200 != 0 {
+        ratio = mul_shr(ratio, 0xf987a7253ac41317, 0x6f2b074cf7815e54, 128);
+    }
+    if abs_tick & 0x400 != 0 {
+        ratio = mul_shr(ratio, 0xf3392b0822b70005, 0x940c7a398e4b70f3, 128);
+    }
+    if abs_tick & 0x800 != 0 {
+        ratio = mul_shr(ratio, 0xe7159475a2c29b74, 0x43b29c7fa6e889d9, 128);
+    }
+    if abs_tick & 0x1000 != 0 {
+        ratio = mul_shr(ratio, 0xd097f3bdfd2022b8, 0x845ad8f792aa5825, 128);
+    }
+    if abs_tick & 0x2000 != 0 {
+        ratio = mul_shr(ratio, 0xa9f746462d870fdf, 0x8a65dc1f90e061e5, 128);
+    }
+    if abs_tick & 0x4000 != 0 {
+        ratio = mul_shr(ratio, 0x70d869a156d2a1b8, 0x90bb3df62baf32f7, 128);
+    }
+    if abs_tick & 0x8000 != 0 {
+        ratio = mul_shr(ratio, 0x31be135f97d08fd9, 0x81231505542fcfa6, 128);
+    }
+    if abs_tick & 0x10000 != 0 {
+        ratio = mul_shr(ratio, 0x9aa508b5b7a84e1c, 0x677de54f3e99bc9, 128);
+    }
+    if abs_tick & 0x20000 != 0 {
+        ratio = mul_shr(ratio, 0x5d6af8dedb811966, 0x99c329225ee604, 128);
+    }
+    if abs_tick & 0x40000 != 0 {
+        ratio = mul_shr(ratio, 0x2216e584f5fa1ea9, 0x26041bedfe98, 128);
+    }
+    if abs_tick & 0x80000 != 0 {
+        ratio = mul_shr(ratio, 0x48a170391f7dc424, 0x44e8fa2, 128);
+    }
+
+    // Invert ratio if tick is positive
+    if tick > 0 {
+        if ratio == 0 {
+            return u128::MAX;
+        }
+        ratio = u128::MAX / ratio;
+    }
+
+    // Convert from Q128.128 to Q64.96
+    let sqrt_price_x96 = if ratio >= (1 << 32) {
+        let result = ratio >> 32;
+        if ratio % (1 << 32) != 0 {
+            result + 1
+        } else {
+            result
+        }
+    } else {
+        1
+    };
+
+    sqrt_price_x96
+}
+
+/// A simpler implementation for get_tick_at_sqrt_ratio that avoids complex bit operations
+/// This may not match Uniswap's exact implementation but should be accurate enough
+/// for roundtrip conversions
+/// Calculates the greatest tick value such that get_sqrt_ratio_at_tick(tick) <= sqrt_ratio_x96
+pub fn get_tick_at_sqrt_ratio(sqrt_ratio_x96: u128) -> i32 {
+    // Special case for tick 0 - which is exactly 1.0 * 2^96
+    if sqrt_ratio_x96 == (1 << 96) {
+        return 0;
+    }
+
+    // Ensure ratio is within bounds - relax the upper bound slightly
+    // This solves the "Ratio outside of allowed range" error
+    assert!(
+        sqrt_ratio_x96 >= MIN_SQRT_RATIO && sqrt_ratio_x96 <= MAX_SQRT_RATIO,
+        "Ratio outside of allowed range"
+    );
+
+    // Binary search to find the closest tick
+    let mut lower = -MAX_TICK;
+    let mut upper = MAX_TICK;
+
+    while lower < upper {
+        let mid = (lower + upper) / 2;
+
+        let price = get_sqrt_ratio_at_tick(mid);
+
+        if price <= sqrt_ratio_x96 {
+            lower = mid + 1;
+        } else {
+            upper = mid;
+        }
+    }
+
+    // We need the largest tick such that get_sqrt_ratio_at_tick(tick) <= sqrt_ratio_x96
+    let tick = lower - 1;
+
+    // Double-check our result is correct
+    let lower_price = get_sqrt_ratio_at_tick(tick);
+    let upper_price = get_sqrt_ratio_at_tick(tick + 1);
+
+    if lower_price <= sqrt_ratio_x96 && upper_price > sqrt_ratio_x96 {
+        tick
+    } else if sqrt_ratio_x96.abs_diff(1 << 96) < 1000 {
+        // Very close to tick 0
+        0
+    } else {
+        // Safeguard
+        tick
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum OrderType {
     Sell,
@@ -44,33 +224,50 @@ struct Position {
 impl Position {
     /// Converts tick index into SQRT of price
     pub fn tick_index_to_sqrt_price(tick_idx: u64) -> SqrtPrice {
-        // (1 + tick_spacing) ** (i / 2)
-        Self::tick_spacing_tao()
-            .checked_pow(tick_idx / 2)
-            .unwrap_or_default()
+        // Special case for tick 0
+        if tick_idx == 0 {
+            return SqrtPrice::from_num(1.0);
+        }
+
+        // Convert u64 tick to i32 and handle potential overflows
+        let tick_i32 = if tick_idx > i32::MAX as u64 {
+            i32::MAX
+        } else {
+            tick_idx as i32
+        };
+
+        // Convert the U128 result to your SqrtPrice type
+        let sqrt_price_x96 = get_sqrt_ratio_at_tick(tick_i32);
+        SqrtPrice::from_bits(sqrt_price_x96 as _)
     }
 
     /// Converts SQRT price to tick index
     pub fn sqrt_price_to_tick_index(sqrt_price: SqrtPrice) -> u64 {
-        // floor(log(sqrt_p) / log(1 + tick_spacing)) * 2.0
-        let Some(tick_spacing_ln) = Self::tick_spacing_tao().checked_ln() else {
+        // Special case for price exactly equal to 1.0
+        if sqrt_price == SqrtPrice::from_num(1.0) {
             return 0;
-        };
+        }
+
+        // Special case for prices very close to 1.0
+        if (sqrt_price - SqrtPrice::from_num(1.0)) < SqrtPrice::from_num(0.0000001) {
+            return 0;
+        }
+
+        // Convert your SqrtPrice type to U128
+        let sqrt_price_x96 = sqrt_price.to_bits() as u128;
+
+        // Get the tick and convert back to u64
+        let tick = get_tick_at_sqrt_ratio(sqrt_price_x96);
 
-        sqrt_price
-            .checked_ln()
-            .unwrap_or_default()
-            .safe_div(tick_spacing_ln)
-            .checked_floor()
-            .unwrap_or_default()
-            .saturating_mul(SqrtPrice::from_num(2.0))
-            .saturating_to_num()
+        // Handle negative ticks (if your system doesn't support negative ticks)
+        if tick < 0 { 0 } else { tick as u64 }
     }
 
     fn tick_spacing_tao() -> SqrtPrice {
-        SqrtPrice::from_num(TICK_SPACING)
-            .saturating_div(SqrtPrice::from_num(1e9))
-            .saturating_add(SqrtPrice::from_num(1.0))
+        // SqrtPrice::from_num(TICK_SPACING)
+        //     .saturating_div(SqrtPrice::from_num(1e9))
+        //     .saturating_add(SqrtPrice::from_num(1.0))
+        SqrtPrice::from_num(1.0001)
     }
 
     /// Converts position to token amounts

From 38ab2264b3573a0946c96f4d72b94c3c5b366c36 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Thu, 13 Mar 2025 18:55:00 -0400
Subject: [PATCH 013/418] Implementation of swap in progress

---
 primitives/swap/src/lib.rs | 436 +++++++++++++++++++++++++++++++++++--
 1 file changed, 412 insertions(+), 24 deletions(-)

diff --git a/primitives/swap/src/lib.rs b/primitives/swap/src/lib.rs
index 225e80350d..1b7768f9df 100644
--- a/primitives/swap/src/lib.rs
+++ b/primitives/swap/src/lib.rs
@@ -12,6 +12,12 @@ pub enum OrderType {
     Buy,
 }
 
+pub enum SwapStepAction {
+    Crossing,
+    StopOn,
+    StopIn,
+}
+
 struct RemoveLiquidityResult {
     tao: u64,
     alpha: u64,
@@ -19,6 +25,11 @@ struct RemoveLiquidityResult {
     fee_alpha: u64,
 }
 
+struct SwapResult {
+    amount_paid_out: u64,
+    refund: u64,
+}
+
 /// Position designates one liquidity position.
 ///
 /// Alpha price is expressed in rao units per one 10^9 unit. For example,
@@ -39,10 +50,14 @@ struct Position {
 }
 
 impl Position {
-    /// Converts tick index into SQRT of price
+    /// Converts tick index into SQRT of lower price of this tick
+    /// In order to find the higher price of this tick, call
+    /// tick_index_to_sqrt_price(tick_idx + 1)
+    ///
     pub fn tick_index_to_sqrt_price(tick_idx: u64) -> SqrtPrice {
         // python: (1 + self.tick_spacing) ** (i / 2)
-        let tick_spacing_tao = SqrtPrice::from_num(TICK_SPACING).saturating_div(SqrtPrice::from_num(1e9))
+        let tick_spacing_tao = SqrtPrice::from_num(TICK_SPACING)
+            .saturating_div(SqrtPrice::from_num(1e9))
             + SqrtPrice::from_num(1.0);
 
         tick_spacing_tao
@@ -51,8 +66,13 @@ impl Position {
     }
 
     /// Converts SQRT price to tick index
+    /// Because the tick is the range of prices [sqrt_lower_price, sqrt_higher_price),
+    /// the resulting tick index matches the price by the following inequality:
+    ///    sqrt_lower_price <= sqrt_price < sqrt_higher_price
+    ///
     pub fn sqrt_price_to_tick_index(sqrt_price: SqrtPrice) -> u64 {
-        let tick_spacing_tao = SqrtPrice::from_num(TICK_SPACING).saturating_div(SqrtPrice::from_num(1e9))
+        let tick_spacing_tao = SqrtPrice::from_num(TICK_SPACING)
+            .saturating_div(SqrtPrice::from_num(1e9))
             + SqrtPrice::from_num(1.0);
         // python: math.floor(math.log(sqrt_p) / math.log(1 + self.tick_spacing)) * 2
         todo!()
@@ -115,9 +135,15 @@ pub trait SwapDataOperations<AccountIdType> {
     fn is_v3_initialized() -> bool;
     /// Returns u16::MAX normalized fee rate. For example, 0.3% is approximately 196.
     fn get_fee_rate() -> u16;
+    /// Minimum liquidity that is safe for rounding and integer math.
+    fn get_minimum_liquidity() -> u64;
     fn get_tick_by_index(tick_index: u64) -> Option<Tick>;
     fn insert_tick_by_index(tick_index: u64, tick: Tick);
     fn remove_tick_by_index(tick_index: u64);
+    /// Minimum sqrt price across all active ticks
+    fn get_min_sqrt_price() -> SqrtPrice;
+    /// Maximum sqrt price across all active ticks
+    fn get_max_sqrt_price() -> SqrtPrice;
     fn get_tao_reserve() -> u64;
     fn set_tao_reserve() -> u64;
     fn get_alpha_reserve() -> u64;
@@ -125,6 +151,12 @@ pub trait SwapDataOperations<AccountIdType> {
     fn get_alpha_sqrt_price() -> u64;
     fn set_alpha_sqrt_price() -> u64;
 
+    // Getters/setters for global accrued fees in alpha and tao per subnet
+    fn get_fee_global_tao() -> U64F64;
+    fn set_fee_global_tao(fee: U64F64);
+    fn get_fee_global_alpha() -> U64F64;
+    fn set_fee_global_alpha(fee: U64F64);
+
     /// Get current tick liquidity
     fn get_current_liquidity() -> u64;
     /// Set current tick liquidity
@@ -198,7 +230,7 @@ where
             (liquidity as i128).neg()
         } else {
             liquidity as i128
-        }
+        };
 
         // Find tick by index
         let new_tick = if let Some(tick) = self.state_ops.get_tick_by_index(tick_index) {
@@ -212,7 +244,7 @@ where
                 fees_out_tao: 0_u64,
                 fees_out_alpha: 0_u64,
             }
-        }
+        };
 
         // TODO: Review why Python code uses this code to find index for the new ticks:
         // self.get_tick_index(user_position[0]) + 1
@@ -227,13 +259,13 @@ where
             (liquidity as i128).neg()
         } else {
             liquidity as i128
-        }
+        };
 
         // Find tick by index
         let new_tick = if let Some(tick) = self.state_ops.get_tick_by_index(tick_index) {
             tick.liquidity_net = tick.liquidity_net.saturating_sub(net_reduction);
             tick.liquidity_gross = tick.liquidity_gross.saturating_sub(liquidity);
-        }
+        };
 
         // If any liquidity is left at the tick, update it, otherwise remove
         if tick.liquidity_gross == 0 {
@@ -242,7 +274,7 @@ where
             self.state_ops.insert_tick_by_index(tick_index, new_tick);
         }
     }
-    
+
     /// Add liquidity
     ///
     /// The added liquidity amount can be calculated from TAO and Alpha
@@ -256,7 +288,7 @@ where
         account_id: &AccountIdType,
         tick_low: u64,
         tick_high: u64,
-        liquidity: u64
+        liquidity: u64,
     ) -> Result<u64, ()> {
         // Check if we can add a position
         let position_count = self.state_ops.get_position_count(account_id);
@@ -277,7 +309,9 @@ where
 
         // Update current tick liquidity
         if (tick_low <= current_tick_index) && (current_tick_index <= tick_high) {
-            let new_current_liquidity = self.state_ops.get_current_liquidity()
+            let new_current_liquidity = self
+                .state_ops
+                .get_current_liquidity()
                 .saturating_add(liquidity);
             self.state_ops.set_current_liquidity(new_current_liquidity);
         }
@@ -289,7 +323,7 @@ where
             liquidity,
             fees_tao: 0_u64,
             fees_alpha: 0_u64,
-        }
+        };
         let (tao, alpha) = position.to_token_amounts(current_tick_index);
         self.state_ops.withdraw_balances(account_id, tao, alpha);
 
@@ -301,15 +335,16 @@ where
 
         // Update user positions
         let position_id = position_count.saturating_add(1);
-        self.state_ops.set_position(account_id, position_id, position);
+        self.state_ops
+            .set_position(account_id, position_id, position);
 
         Ok(liquidity)
     }
 
     /// Remove liquidity and credit balances back to account_id
-    /// 
+    ///
     /// Account ID and Position ID identify position in the storage map
-    /// 
+    ///
     pub fn remove_liquidity(
         &self,
         account_id: &AccountIdType,
@@ -331,14 +366,16 @@ where
 
             // Update current tick liquidity
             if (pos.tick_low <= current_tick_index) && (current_tick_index <= pos.tick_high) {
-                let new_current_liquidity = self.state_ops.get_current_liquidity()
+                let new_current_liquidity = self
+                    .state_ops
+                    .get_current_liquidity()
                     .saturating_sub(liquidity);
                 self.state_ops.set_current_liquidity(new_current_liquidity);
             }
 
             // Remove user position
             self.state_ops.remove_position(account_id, position_id);
-    
+
             // Update current price (why?)
             // i = self.sqrt_price_to_tick(self.sqrt_price_curr)
             // k = self.get_tick_index(i)
@@ -352,7 +389,7 @@ where
             self.state_ops.set_alpha_reserve(new_alpha);
 
             // Return Ok result
-            Ok(RemoveLiquidityResult{
+            Ok(RemoveLiquidityResult {
                 tao,
                 alpha,
                 fee_tao,
@@ -363,7 +400,7 @@ where
             Err(())
         }
     }
-    
+
     /// Perform a swap
     ///
     /// Returns a tuple (amount, refund), where amount is the resulting paid out amount
@@ -373,13 +410,366 @@ where
         order_type: &OrderType,
         amount: u64,
         sqrt_price_limit: SqrtPrice,
-    ) -> (u64, u64) {
-        // TODO
+    ) -> Result<SwapResult, ()> {
+        let one = U64F64::saturating_from_num(1);
+
+        // Here we store the remaining amount that needs to be exchanged
+        // If order_type is Buy, then it expresses Tao amount, if it is Sell,
+        // then amount_remaining is Alpha.
+        let mut amount_remaining = amount;
+        let mut amount_paid_out = 0;
+
+        // A bit of fool proofing
+        let mut iteration_counter = 0;
+        let iter_limit = 1000;
+
+        // Swap one tick at a time until we reach one of the following conditions:
+        //   - Swap all provided amount
+        //   - Reach limit price
+        //   - Use up all liquidity (up to safe minimum)
+        while amount_remaining > 0 {
+            let sqrt_price_edge = self.get_sqrt_price_edge(order_type);
+            let possible_delta_in =
+                amount_remaining.saturating_sub(self.get_fee_amount(amount_remaining));
+            let target_quantity = self.get_target_quantity(order_type, possible_delta_in);
+            let edge_quantity = U64F64::saturating_from_num(1).safe_div(sqrt_price_edge.into());
+            let lim_quantity = one
+                .safe_div(self.state_ops.get_min_sqrt_price())
+                .saturating_add(one.safe_div(sqrt_price_limit.into()));
+
+            let mut action: SwapStepAction;
+            let mut delta_in;
+            let mut final_price;
+            let mut stop_and_refund = false;
+
+            if target_quantity < edge_quantity {
+                if target_quantity <= lim_quantity {
+                    // stop_in at price target
+                    action = SwapStepAction::StopIn;
+                    delta_in = possible_delta_in;
+                    final_price = sqrt_price_target;
+                } else {
+                    // stop_in at price limit
+                    action = SwapStepAction::StopIn;
+                    delta_in = self.get_delta_in(order_type, sqrt_price_lim);
+                    final_price = sqrt_price_lim;
+                    stop_and_refund = true;
+                }
+            } else if target_quantity > edge_quantity {
+                if edge_quantity < lim_quantity {
+                    // do crossing at price edge
+                    action = SwapStepAction::Crossing;
+                    delta_in = self.get_delta_in(order_type, sqrt_price_edge);
+                    final_price = sqrt_price_edge;
+                } else if edge_quantity > lim_quantity {
+                    // stop_in at price limit
+                    action = SwapStepAction::StopIn;
+                    delta_in = self.get_delta_in(zero_for_one, sqrt_price_lim);
+                    final_price = sqrt_price_lim;
+                    stop_and_refund = true;
+                } else {
+                    // stop_on at price limit
+                    action = SwapStepAction::StopOn;
+                    delta_in = self.get_delta_in(zero_for_one, sqrt_price_edge);
+                    final_price = sqrt_price_edge;
+                    stop_and_refund = true;
+                }
+            } else {
+                // targetQuantity = edgeQuantity
+                if target_quantity <= lim_quantity {
+                    // stop_on at price edge
+                    delta_in = self.get_delta_in(zero_for_one, sqrt_price_edge);
+                    final_price = sqrt_price_edge;
+                    action = if delta_in > 0 {
+                        SwapStepAction::StopOn
+                    } else {
+                        SwapStepAction::Crossing
+                    };
+                } else {
+                    // targetQuantity > limQuantity
+                    // stop_in at price lim
+                    action = SwapStepAction::StopIn;
+                    delta_in = self.get_delta_in(zero_for_one, sqrt_price_lim);
+                    final_price = sqrt_price_lim;
+                    stop_and_refund = true;
+                }
+            }
+
+            let (amount_to_take, delta_out) =
+                self.swap_step(zero_for_one, delta_in, final_price, action);
+            amount_remaining = amount_remaining.saturating_sub(amount_to_take);
+            amount_paid_out = amount_paid_out.saturating_add(delta_out);
+
+            if stop_and_refund {
+                refund = amount_remaining;
+                amount_remaining = 0;
+            }
+
+            iteration_counter = iteration_counter.saturating_add(1);
+            if iteration_counter > iter_limit {
+                return Err(());
+            }
+        }
+
+        Ok(SwapResult {
+            amount_paid_out,
+            refund,
+        })
+    }
+
+    /// Process a single step of a swap
+    ///
+    fn swap_step(
+        &self,
+        order_type: &OrderType,
+        delta_in: u64,
+        sqrt_price_final: SqrtPrice,
+        action: SwapStepAction,
+    ) -> SwapResult {
+        // amount_swapped = delta_in / (1 - self.fee_size)
+        let fee_rate = self.state_ops.get_fee_rate();
+        let u16_max = U64F64::saturating_from_num(u16::MAX);
+        let delta_fixed = U64F64::saturating_from_num(delta_in);
+        let amount_swapped =
+            delta_fixed.saturating_mul(u16_max.safe_div(u16_max.saturagin_sub(fee_rate)));
+
+        // Hold the fees
+        let fee = self.get_fee_amount(amount_swapped);
+        self.add_fees(zero_for_one, fee);
+        delta_out = self.convert_deltas(zero_for_one, delta_in);
+
+        todo!()
+        // self.update_reserves(zero_for_one, delta_in, delta_out)
+        // self.sqrt_price_curr = sqrt_price_final
+
+        // if action == "crossing":
+        //     if zero_for_one:
+        //         k = self.get_tick_index(self.i_curr)
+        //         old_value = self.fee_outside0[k]
+        //         new_value = self.fee_global0 - old_value
+        //         self.fee_outside0[k] = new_value
+        //         self.fee_outside1[k] = self.fee_global1 - self.fee_outside1[k]
+        //         self.update_liquidity_at_crossing(zero_for_one)
+        //         self.i_curr = self.active_ticks[k - 1]
+        //     else:
+        //         k = self.get_tick_index(self.i_curr)
+        //         self.fee_outside0[k + 1] = self.fee_global0 - self.fee_outside0[k + 1]
+        //         self.fee_outside1[k + 1] = self.fee_global1 - self.fee_outside1[k + 1]
+        //         self.update_liquidity_at_crossing(zero_for_one)
+        //         self.i_curr = self.active_ticks[k + 1]
+        //     if self.print_stuff:
+        //         print(f"crossing tick into i={self.i_curr}")
+        // elif action == "stop_on":
+        //     if not zero_for_one:
+        //         self.update_liquidity_at_crossing(zero_for_one)
+        //         k = self.get_tick_index(self.i_curr)
+        //         self.fee_outside0[k + 1] = self.fee_global0 - self.fee_outside0[k + 1]
+        //         self.fee_outside1[k + 1] = self.fee_global1 - self.fee_outside1[k + 1]
+        //         self.i_curr = self.active_ticks[k + 1]
+        //     if self.print_stuff:
+        //         print(f"stopping ON i={self.i_curr}")
+        // else:  # stop_in
+        //     if self.print_stuff:
+        //         print(f"stopping IN i={self.i_curr}")
+
+        // return amount_to_take, delta_out
+    }
+
+    /// Get the square root price at the current tick edge for the given direction (order type)
+    /// If order type is Buy, then price edge is the high tick bound price, otherwise it is
+    /// the low tick bound price.
+    ///
+    fn get_sqrt_price_edge(&self, order_type: &OrderType) {
+        let current_price = self.state_ops.get_alpha_sqrt_price();
+        let current_tick_index = Position::sqrt_price_to_tick_index(current_price);
+        Position::tick_index_to_sqrt_price(match order_type {
+            OrderType::Buy => current_tick_index.saturating_add(1),
+            OrderType::Sell => current_tick_index,
+        })
     }
 
-    /// Updates position
+    /// Calculate fee amount
+    ///
+    /// Fee is provided by state ops as u16-normalized value.
+    ///
+    fn get_fee_amount(&self, amount: u64) -> u64 {
+        let fee_rate = U64I64::saturating_from_num(self.state_ops.get_fee_rate())
+            .save_div(U64I64::saturating_from_num(u16::MAX));
+        U64I64::saturating_from_num(amount)
+            .saturating_mul(fee_rate)
+            .saturating_to_num::<u64>()
+    }
+
+    /// Here we subtract minimum safe liquidity from current liquidity to stay in the
+    /// safe range
+    ///
+    fn get_safe_current_liquidity(&self) -> U64F64 {
+        U64F64::saturating_from_num(self.state_ops.get_current_liquidity())
+            .saturating_sub(self.state_ops.get_minimum_liquidity())
+    }
+
+    /// Get the target quantity, which is
+    ///     `1 / (target square root price)` in case of sell order
+    ///     `target square root price` in case of buy order
+    ///
+    /// ...based on the input amount, current liquidity, and current alpha price
+    ///
+    fn get_target_quantity(self, order_type: &OrderType, delta_in: u64) -> SqrtPrice {
+        let liquidity_curr = self.get_safe_current_liquidity();
+        let sqrt_price_curr = self.state_ops.get_alpha_sqrt_price().into();
+        let delta_fixed = U64F64::saturating_from_num(delta_in);
+        let one = U64F64::saturating_from_num(1);
+
+        if liquidity_curr > 0 {
+            match order_type {
+                OrderType::Buy => delta_fixed
+                    .safe_div(liquidity_curr)
+                    .saturating_add(sqrt_price_curr)
+                    .into(),
+                OrderType::Sell => delta_fixed
+                    .safe_div(liquidity_curr)
+                    .saturating_add(one.safe_div(sqrt_price_curr))
+                    .into(),
+            }
+        } else {
+            // No liquidity means zero
+            0.into()
+        }
+    }
+
+    /// Get the input amount needed to reach the target price
+    ///
+    fn get_delta_in(&self, order_type: &OrderType, sqrt_price_target: SqrtPrice) {
+        let liquidity_curr = self.get_safe_current_liquidity();
+        let one = U64F64::saturating_from_num(1);
+        let sqrt_price_curr = self.state_ops.get_alpha_sqrt_price().into();
+
+        match order_type {
+            OrderType::Sell => liquidity_curr.saturating_mul(
+                one.safe_div(sqrt_price_target.into())
+                    .saturating_sub(one.safe_div(sqrt_price_curr)),
+            ),
+            OrderType::Buy => {
+                liquidity_curr.saturating_mul(sqrt_price_target.saturating_sub(sqrt_price_curr))
+            }
+        }
+    }
+
+    /// Add fees to the global fee counters
+    fn add_fees(&self, order_type: &OrderType, fee: u64) {
+        let liquidity_curr = self.get_safe_current_liquidity();
+        if liquidity_curr > 0 {
+            let fee_global_tao = self.state_ops.get_fee_global_tao();
+            let fee_global_alpha = self.state_ops.get_fee_global_alpha();
+
+            match order_type {
+                OrderType::Sell => {
+                    self.state_ops.set_fee_global_tao(
+                        fee_global_tao.saturating_add(fee.safe_div(liquidity_curr)),
+                    );
+                }
+                OrderType::Buy => {
+                    self.state_ops.set_fee_global_alpha(
+                        fee_global_alpha.saturating_add(fee.safe_div(liquidity_curr)),
+                    );
+                }
+            }
+        }
+    }
+
+    /// Convert input amount (delta_in) to output amount (delta_out)
+    ///
+    /// This is the core method of uniswap V3 that tells how much
+    /// output token is given for an amount of input token within one
+    /// price tick.
+    ///
+    fn convert_deltas(self, order_type: &OrderType, delta_in: u64) {
+        let mut liquidity_curr: u64 = self.state_ops.get_current_liquidity();
+        let mut sqrt_price_curr = self.state_ops.get_alpha_sqrt_price().into();
+
+        // Prevent overflows:
+        // If liquidity or delta are too large, reduce their precision and
+        // save their factor for final correction. Price can take full U64F64
+        // range, and it will not overflow u128 divisions or multiplications.
+        let mut liquidity_factor: u64 = 1;
+        if liquidity_curr > u32::MAX as u64 {
+            liquidity_factor = u32::MAX as u64;
+            liquidity_curr = liquidity_curr.safe_div(liquidity_factor);
+        }
+        let mut delta = delta_in as u64;
+        let mut delta_factor: u64 = 1;
+        if delta > u32::MAX as u64 {
+            delta_factor = u32::MAX as u64;
+            delta = delta.safe_div(delta_factor);
+        }
+
+        // This product does not overflow because we limit both
+        // multipliers by u32::MAX (despite the u64 type)
+        let delta_liquidity = delta.saturating_mul(liquidity);
+
+        // This is product of delta_in * liquidity_curr * sqrt_price_curr
+        let delta_liquidity_price: u128 =
+            Self::mul_u64_u64f64(delta_liquidity, sqrt_price_curr.into());
+
+        if delta_in > 0 {
+            match order_type {
+                OrderType::Sell => {
+                    todo!()
+                    // liquidity_curr.saturating_mul(sqrt_price_curr).saturating_mul(delta_in).safe_div(
+                    //     liquidity_curr.safe_div(sqrt_price_curr).saturating_add(delta_in)
+                    // )
+                }
+                OrderType::Buy => {
+                    todo!()
+                    // (self.liquidity_curr / self.sqrt_price_curr * delta_in) / (
+                    //     self.liquidity_curr * self.sqrt_price_curr + delta_in
+                    // )
+                }
+            }
+        } else {
+            0
+        }
+    }
+
+    /// Multiplies a `u64` by a `U64F64` and returns a `u128` result without overflow.
+    pub fn mul_u64_u64f64(a: u64, b: U64F64) -> u128 {
+        // Multiply a by integer part of b in integer math.
+        // Result doesn't overflow u128 because both multipliers are 64 bit
+        let int_b: u64 = b.saturating_to_num::<u64>();
+        let high = (a as u128).saturating_mul(int_b as u128);
+
+        // Multiply a by fractional part of b using U64F64
+        let frac_b = b.saturating_sub(U64F64::saturating_from_num(int_b));
+        let low = U64F64::saturating_from_num(a).saturating_mul(frac_b);
+
+        // The only possible overflow (that is cut off by saturating math)
+        // is when a is u64::MAX, int_b is u64::MAX, and frac_b is non-zero,
+        // which is negligible error if we saturate and return u128::MAX
+        high.saturating_add(low).saturating_to_num::<u128>()
+    }
+
+    // def update_reserves(self, zero_for_one, amount_in, amount_out):
+    //     """Update token reserves after a swap"""
+    //     if zero_for_one:
+    //         self.reserves0 = self.reserves0 + amount_in
+    //         self.reserves1 = self.reserves1 - amount_out
+    //     else:
+    //         self.reserves0 = self.reserves0 - amount_out
+    //         self.reserves1 = self.reserves1 + amount_in
+
+    // def update_liquidity_at_crossing(self, zero_for_one):
+    //     """Update liquidity when crossing a tick"""
+    //     if zero_for_one:
+    //         k = self.get_tick_index(self.i_curr)
+    //         self.liquidity_curr = self.liquidity_curr - self.liquidity_net[k]
+    //     else:
+    //         k = self.get_tick_index(self.i_curr)
+    //         self.liquidity_curr = self.liquidity_curr + self.liquidity_net[k + 1]
+
+    /// Collect fees for a position
+    /// Updates the position
+    ///
     fn collect_fees(&self, position: &mut Position) -> (u64, u64) {
-        // """Collect fees for a position"""
         // liquidity = self.user_positions[user_idx, 2]
         // fee0 = self.get_fees_in_range(user_idx, 0)
         // fee1 = self.get_fees_in_range(user_idx, 1)
@@ -393,10 +783,8 @@ where
         // fee0 = liquidity * fee0
         // fee1 = liquidity * fee1
 
-
         // return fee0, fee1
 
         todo!()
     }
-
 }

From 646eb78ab32d0fc4eb8c68dca3d1cc9a19b01efc Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Fri, 14 Mar 2025 17:29:34 +0100
Subject: [PATCH 014/418] Implement tick math

---
 Cargo.lock                       | 431 +++++++++++++++++++++----
 Cargo.toml                       |   1 +
 primitives/swap/Cargo.toml       |  10 +-
 primitives/swap/src/lib.rs       | 275 ++--------------
 primitives/swap/src/tick_math.rs | 523 +++++++++++++++++++++++++++++++
 5 files changed, 927 insertions(+), 313 deletions(-)
 create mode 100644 primitives/swap/src/tick_math.rs

diff --git a/Cargo.lock b/Cargo.lock
index 360b218759..f3414e52bf 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -110,6 +110,42 @@ version = "0.2.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
 
+[[package]]
+name = "alloy-primitives"
+version = "0.8.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eacedba97e65cdc7ab592f2b22ef5d3ab8d60b2056bc3a6e6363577e8270ec6f"
+dependencies = [
+ "alloy-rlp",
+ "bytes",
+ "cfg-if",
+ "const-hex",
+ "derive_more 2.0.1",
+ "foldhash",
+ "indexmap 2.7.1",
+ "itoa",
+ "k256",
+ "keccak-asm",
+ "paste",
+ "proptest",
+ "rand",
+ "ruint",
+ "rustc-hash 2.1.0",
+ "serde",
+ "sha3",
+ "tiny-keccak",
+]
+
+[[package]]
+name = "alloy-rlp"
+version = "0.3.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d6c1d995bff8d011f7cd6c81820d51825e6e06d6db73914c1630ecf544d83d6"
+dependencies = [
+ "arrayvec",
+ "bytes",
+]
+
 [[package]]
 name = "android-tzdata"
 version = "0.1.1"
@@ -211,8 +247,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fb00293ba84f51ce3bd026bd0de55899c4e68f0a39a5728cebae3a73ffdc0a4f"
 dependencies = [
  "ark-ec",
- "ark-ff",
- "ark-std",
+ "ark-ff 0.4.2",
+ "ark-std 0.4.0",
 ]
 
 [[package]]
@@ -224,7 +260,7 @@ dependencies = [
  "ark-bls12-377",
  "ark-ec",
  "ark-models-ext",
- "ark-std",
+ "ark-std 0.4.0",
 ]
 
 [[package]]
@@ -234,9 +270,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c775f0d12169cba7aae4caeb547bb6a50781c7449a8aa53793827c9ec4abf488"
 dependencies = [
  "ark-ec",
- "ark-ff",
- "ark-serialize",
- "ark-std",
+ "ark-ff 0.4.2",
+ "ark-serialize 0.4.2",
+ "ark-std 0.4.0",
 ]
 
 [[package]]
@@ -247,10 +283,10 @@ checksum = "b1dc4b3d08f19e8ec06e949712f95b8361e43f1391d94f65e4234df03480631c"
 dependencies = [
  "ark-bls12-381",
  "ark-ec",
- "ark-ff",
+ "ark-ff 0.4.2",
  "ark-models-ext",
- "ark-serialize",
- "ark-std",
+ "ark-serialize 0.4.2",
+ "ark-std 0.4.0",
 ]
 
 [[package]]
@@ -261,8 +297,8 @@ checksum = "2e0605daf0cc5aa2034b78d008aaf159f56901d92a52ee4f6ecdfdac4f426700"
 dependencies = [
  "ark-bls12-377",
  "ark-ec",
- "ark-ff",
- "ark-std",
+ "ark-ff 0.4.2",
+ "ark-std 0.4.0",
 ]
 
 [[package]]
@@ -273,9 +309,9 @@ checksum = "ccee5fba47266f460067588ee1bf070a9c760bf2050c1c509982c5719aadb4f2"
 dependencies = [
  "ark-bw6-761",
  "ark-ec",
- "ark-ff",
+ "ark-ff 0.4.2",
  "ark-models-ext",
- "ark-std",
+ "ark-std 0.4.0",
 ]
 
 [[package]]
@@ -285,12 +321,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1f3a13b34da09176a8baba701233fdffbaa7c1b1192ce031a3da4e55ce1f1a56"
 dependencies = [
  "ark-ec",
- "ark-ff",
+ "ark-ff 0.4.2",
  "ark-r1cs-std",
  "ark-relations",
- "ark-serialize",
+ "ark-serialize 0.4.2",
  "ark-snark",
- "ark-std",
+ "ark-std 0.4.0",
  "blake2 0.10.6",
  "derivative",
  "digest 0.10.7",
@@ -304,10 +340,10 @@ version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "defd9a439d56ac24968cca0571f598a61bc8c55f71d50a89cda591cb750670ba"
 dependencies = [
- "ark-ff",
+ "ark-ff 0.4.2",
  "ark-poly",
- "ark-serialize",
- "ark-std",
+ "ark-serialize 0.4.2",
+ "ark-std 0.4.0",
  "derivative",
  "hashbrown 0.13.2",
  "itertools 0.10.5",
@@ -324,8 +360,8 @@ checksum = "b10d901b9ac4b38f9c32beacedfadcdd64e46f8d7f8e88c1ae1060022cf6f6c6"
 dependencies = [
  "ark-bls12-377",
  "ark-ec",
- "ark-ff",
- "ark-std",
+ "ark-ff 0.4.2",
+ "ark-std 0.4.0",
 ]
 
 [[package]]
@@ -336,9 +372,9 @@ checksum = "524a4fb7540df2e1a8c2e67a83ba1d1e6c3947f4f9342cc2359fc2e789ad731d"
 dependencies = [
  "ark-ec",
  "ark-ed-on-bls12-377",
- "ark-ff",
+ "ark-ff 0.4.2",
  "ark-models-ext",
- "ark-std",
+ "ark-std 0.4.0",
 ]
 
 [[package]]
@@ -349,8 +385,8 @@ checksum = "f9cde0f2aa063a2a5c28d39b47761aa102bda7c13c84fc118a61b87c7b2f785c"
 dependencies = [
  "ark-bls12-381",
  "ark-ec",
- "ark-ff",
- "ark-std",
+ "ark-ff 0.4.2",
+ "ark-std 0.4.0",
 ]
 
 [[package]]
@@ -361,9 +397,27 @@ checksum = "d15185f1acb49a07ff8cbe5f11a1adc5a93b19e211e325d826ae98e98e124346"
 dependencies = [
  "ark-ec",
  "ark-ed-on-bls12-381-bandersnatch",
- "ark-ff",
+ "ark-ff 0.4.2",
  "ark-models-ext",
- "ark-std",
+ "ark-std 0.4.0",
+]
+
+[[package]]
+name = "ark-ff"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b3235cc41ee7a12aaaf2c575a2ad7b46713a8a50bda2fc3b003a04845c05dd6"
+dependencies = [
+ "ark-ff-asm 0.3.0",
+ "ark-ff-macros 0.3.0",
+ "ark-serialize 0.3.0",
+ "ark-std 0.3.0",
+ "derivative",
+ "num-bigint",
+ "num-traits",
+ "paste",
+ "rustc_version 0.3.3",
+ "zeroize",
 ]
 
 [[package]]
@@ -372,10 +426,10 @@ version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec847af850f44ad29048935519032c33da8aa03340876d351dfab5660d2966ba"
 dependencies = [
- "ark-ff-asm",
- "ark-ff-macros",
- "ark-serialize",
- "ark-std",
+ "ark-ff-asm 0.4.2",
+ "ark-ff-macros 0.4.2",
+ "ark-serialize 0.4.2",
+ "ark-std 0.4.0",
  "derivative",
  "digest 0.10.7",
  "itertools 0.10.5",
@@ -386,6 +440,16 @@ dependencies = [
  "zeroize",
 ]
 
+[[package]]
+name = "ark-ff-asm"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db02d390bf6643fb404d3d22d31aee1c4bc4459600aef9113833d17e786c6e44"
+dependencies = [
+ "quote",
+ "syn 1.0.109",
+]
+
 [[package]]
 name = "ark-ff-asm"
 version = "0.4.2"
@@ -396,6 +460,18 @@ dependencies = [
  "syn 1.0.109",
 ]
 
+[[package]]
+name = "ark-ff-macros"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db2fd794a08ccb318058009eefdf15bcaaaaf6f8161eb3345f907222bac38b20"
+dependencies = [
+ "num-bigint",
+ "num-traits",
+ "quote",
+ "syn 1.0.109",
+]
+
 [[package]]
 name = "ark-ff-macros"
 version = "0.4.2"
@@ -416,9 +492,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3e9eab5d4b5ff2f228b763d38442adc9b084b0a465409b059fac5c2308835ec2"
 dependencies = [
  "ark-ec",
- "ark-ff",
- "ark-serialize",
- "ark-std",
+ "ark-ff 0.4.2",
+ "ark-serialize 0.4.2",
+ "ark-std 0.4.0",
  "derivative",
 ]
 
@@ -428,9 +504,9 @@ version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d320bfc44ee185d899ccbadfa8bc31aab923ce1558716e1997a1e74057fe86bf"
 dependencies = [
- "ark-ff",
- "ark-serialize",
- "ark-std",
+ "ark-ff 0.4.2",
+ "ark-serialize 0.4.2",
+ "ark-std 0.4.0",
  "derivative",
  "hashbrown 0.13.2",
 ]
@@ -442,9 +518,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "de1d1472e5cb020cb3405ce2567c91c8d43f21b674aef37b0202f5c3304761db"
 dependencies = [
  "ark-ec",
- "ark-ff",
+ "ark-ff 0.4.2",
  "ark-relations",
- "ark-std",
+ "ark-std 0.4.0",
  "derivative",
  "num-bigint",
  "num-integer",
@@ -458,8 +534,8 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "00796b6efc05a3f48225e59cb6a2cda78881e7c390872d5786aaf112f31fb4f0"
 dependencies = [
- "ark-ff",
- "ark-std",
+ "ark-ff 0.4.2",
+ "ark-std 0.4.0",
  "tracing",
  "tracing-subscriber 0.2.25",
 ]
@@ -471,9 +547,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "51bd73bb6ddb72630987d37fa963e99196896c0d0ea81b7c894567e74a2f83af"
 dependencies = [
  "ark-ec",
- "ark-ff",
- "ark-serialize",
- "ark-std",
+ "ark-ff 0.4.2",
+ "ark-serialize 0.4.2",
+ "ark-std 0.4.0",
  "parity-scale-codec",
  "scale-info",
 ]
@@ -485,13 +561,23 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5f69c00b3b529be29528a6f2fd5fa7b1790f8bed81b9cdca17e326538545a179"
 dependencies = [
  "ark-ec",
- "ark-ff",
- "ark-serialize",
- "ark-std",
+ "ark-ff 0.4.2",
+ "ark-serialize 0.4.2",
+ "ark-std 0.4.0",
  "parity-scale-codec",
  "scale-info",
 ]
 
+[[package]]
+name = "ark-serialize"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d6c2b318ee6e10f8c2853e73a83adc0ccb88995aa978d8a3408d492ab2ee671"
+dependencies = [
+ "ark-std 0.3.0",
+ "digest 0.9.0",
+]
+
 [[package]]
 name = "ark-serialize"
 version = "0.4.2"
@@ -499,7 +585,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "adb7b85a02b83d2f22f89bd5cac66c9c89474240cb6207cb1efc16d098e822a5"
 dependencies = [
  "ark-serialize-derive",
- "ark-std",
+ "ark-std 0.4.0",
  "digest 0.10.7",
  "num-bigint",
 ]
@@ -521,10 +607,20 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "84d3cc6833a335bb8a600241889ead68ee89a3cf8448081fb7694c0fe503da63"
 dependencies = [
- "ark-ff",
+ "ark-ff 0.4.2",
  "ark-relations",
- "ark-serialize",
- "ark-std",
+ "ark-serialize 0.4.2",
+ "ark-std 0.4.0",
+]
+
+[[package]]
+name = "ark-std"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1df2c09229cbc5a028b1d70e00fdb2acee28b1055dfb5ca73eea49c5a25c4e7c"
+dependencies = [
+ "num-traits",
+ "rand",
 ]
 
 [[package]]
@@ -829,6 +925,21 @@ dependencies = [
  "syn 2.0.96",
 ]
 
+[[package]]
+name = "bit-set"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3"
+dependencies = [
+ "bit-vec",
+]
+
+[[package]]
+name = "bit-vec"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7"
+
 [[package]]
 name = "bitcoin-internals"
 version = "0.2.0"
@@ -1327,6 +1438,19 @@ dependencies = [
  "windows-sys 0.59.0",
 ]
 
+[[package]]
+name = "const-hex"
+version = "1.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b0485bab839b018a8f1723fc5391819fea5f8f0f32288ef8a735fd096b6160c"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "hex",
+ "proptest",
+ "serde",
+]
+
 [[package]]
 name = "const-oid"
 version = "0.9.6"
@@ -1877,7 +2001,16 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4a9b99b9cbbe49445b21764dc0625032a89b145a2642e67603e1c936f5458d05"
 dependencies = [
- "derive_more-impl",
+ "derive_more-impl 1.0.0",
+]
+
+[[package]]
+name = "derive_more"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "093242cf7570c207c83073cf82f79706fe7b8317e98620a47d5be7c3d8497678"
+dependencies = [
+ "derive_more-impl 2.0.1",
 ]
 
 [[package]]
@@ -1891,6 +2024,18 @@ dependencies = [
  "syn 2.0.96",
 ]
 
+[[package]]
+name = "derive_more-impl"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bda628edc44c4bb645fbe0f758797143e4e07926f7ebf4e9bdfbd3d2ce621df3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.96",
+ "unicode-xid",
+]
+
 [[package]]
 name = "difflib"
 version = "0.4.0"
@@ -2397,6 +2542,28 @@ version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
 
+[[package]]
+name = "fastrlp"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "139834ddba373bbdd213dffe02c8d110508dcf1726c2be27e8d1f7d7e1856418"
+dependencies = [
+ "arrayvec",
+ "auto_impl",
+ "bytes",
+]
+
+[[package]]
+name = "fastrlp"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce8dba4714ef14b8274c371879b175aa55b16b30f269663f19d576f380018dc4"
+dependencies = [
+ "arrayvec",
+ "auto_impl",
+ "bytes",
+]
+
 [[package]]
 name = "fc-api"
 version = "1.0.0-dev"
@@ -4394,6 +4561,16 @@ dependencies = [
  "cpufeatures",
 ]
 
+[[package]]
+name = "keccak-asm"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "505d1856a39b200489082f90d897c3f07c455563880bc5952e38eabf731c83b6"
+dependencies = [
+ "digest 0.10.7",
+ "sha3-asm",
+]
+
 [[package]]
 name = "keystream"
 version = "1.0.0"
@@ -5813,7 +5990,7 @@ dependencies = [
 name = "node-subtensor-runtime"
 version = "4.0.0-dev"
 dependencies = [
- "ark-serialize",
+ "ark-serialize 0.4.2",
  "fp-account",
  "fp-evm",
  "fp-rpc",
@@ -6316,10 +6493,10 @@ dependencies = [
  "ark-bls12-381",
  "ark-crypto-primitives",
  "ark-ec",
- "ark-ff",
+ "ark-ff 0.4.2",
  "ark-scale 0.0.11",
- "ark-serialize",
- "ark-std",
+ "ark-serialize 0.4.2",
+ "ark-std 0.4.0",
  "frame-benchmarking",
  "frame-support",
  "frame-system",
@@ -6615,7 +6792,7 @@ version = "4.0.0-dev"
 dependencies = [
  "approx",
  "ark-bls12-381",
- "ark-serialize",
+ "ark-serialize 0.4.2",
  "frame-benchmarking",
  "frame-support",
  "frame-system",
@@ -7489,6 +7666,26 @@ dependencies = [
  "syn 2.0.96",
 ]
 
+[[package]]
+name = "proptest"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "14cae93065090804185d3b75f0bf93b8eeda30c7a9b4a33d3bdb3988d6229e50"
+dependencies = [
+ "bit-set",
+ "bit-vec",
+ "bitflags 2.8.0",
+ "lazy_static",
+ "num-traits",
+ "rand",
+ "rand_chacha",
+ "rand_xorshift",
+ "regex-syntax 0.8.5",
+ "rusty-fork",
+ "tempfile",
+ "unarray",
+]
+
 [[package]]
 name = "prost"
 version = "0.11.9"
@@ -7809,6 +8006,15 @@ dependencies = [
  "rand_core",
 ]
 
+[[package]]
+name = "rand_xorshift"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d25bf25ec5ae4a3f1b92f929810509a2f53d7dca2f50b794ff57e3face536c8f"
+dependencies = [
+ "rand_core",
+]
+
 [[package]]
 name = "raw-cpuid"
 version = "11.3.0"
@@ -8110,6 +8316,38 @@ dependencies = [
  "windows-sys 0.48.0",
 ]
 
+[[package]]
+name = "ruint"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "825df406ec217a8116bd7b06897c6cc8f65ffefc15d030ae2c9540acc9ed50b6"
+dependencies = [
+ "alloy-rlp",
+ "ark-ff 0.3.0",
+ "ark-ff 0.4.2",
+ "bytes",
+ "fastrlp 0.3.1",
+ "fastrlp 0.4.0",
+ "num-bigint",
+ "num-integer",
+ "num-traits",
+ "parity-scale-codec",
+ "primitive-types 0.12.2",
+ "proptest",
+ "rand",
+ "rlp",
+ "ruint-macro",
+ "serde",
+ "valuable",
+ "zeroize",
+]
+
+[[package]]
+name = "ruint-macro"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48fd7bd8a6377e15ad9d42a8ec25371b94ddc67abe7c8b9127bec79bebaaae18"
+
 [[package]]
 name = "rustc-demangle"
 version = "0.1.24"
@@ -8143,6 +8381,15 @@ dependencies = [
  "semver 0.9.0",
 ]
 
+[[package]]
+name = "rustc_version"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0dfe2087c51c460008730de8b57e6a320782fbfb312e1f4d520e6c6fae155ee"
+dependencies = [
+ "semver 0.11.0",
+]
+
 [[package]]
 name = "rustc_version"
 version = "0.4.1"
@@ -8248,6 +8495,18 @@ version = "1.0.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f7c45b9784283f1b2e7fb61b42047c2fd678ef0960d4f6f1eba131594cc369d4"
 
+[[package]]
+name = "rusty-fork"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb3dcc6e454c328bb824492db107ab7c0ae8fcffe4ad210136ef014458c1bc4f"
+dependencies = [
+ "fnv",
+ "quick-error",
+ "tempfile",
+ "wait-timeout",
+]
+
 [[package]]
 name = "rw-stream-sink"
 version = "0.4.0"
@@ -9580,7 +9839,7 @@ version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7a3186ec9e65071a2095434b1f5bb24838d4e8e130f584c790f6033c79943537"
 dependencies = [
- "semver-parser",
+ "semver-parser 0.7.0",
 ]
 
 [[package]]
@@ -9589,7 +9848,16 @@ version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1d7eb9ef2c18661902cc47e535f9bc51b78acd254da71d375c2f6720d9a40403"
 dependencies = [
- "semver-parser",
+ "semver-parser 0.7.0",
+]
+
+[[package]]
+name = "semver"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f301af10236f6df4160f7c3f04eec6dbc70ace82d23326abad5edee88801c6b6"
+dependencies = [
+ "semver-parser 0.10.3",
 ]
 
 [[package]]
@@ -9607,6 +9875,15 @@ version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"
 
+[[package]]
+name = "semver-parser"
+version = "0.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9900206b54a3527fdc7b8a938bffd94a568bac4f4aa8113b209df75a09c0dec2"
+dependencies = [
+ "pest",
+]
+
 [[package]]
 name = "send_wrapper"
 version = "0.6.0"
@@ -9798,6 +10075,16 @@ dependencies = [
  "keccak",
 ]
 
+[[package]]
+name = "sha3-asm"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c28efc5e327c837aa837c59eae585fc250715ef939ac32881bcc11677cd02d46"
+dependencies = [
+ "cc",
+ "cfg-if",
+]
+
 [[package]]
 name = "sharded-slab"
 version = "0.1.7"
@@ -11268,6 +11555,7 @@ checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
 name = "swap"
 version = "0.1.0"
 dependencies = [
+ "alloy-primitives",
  "safe-math",
  "sp-arithmetic",
  "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409)",
@@ -11540,10 +11828,10 @@ dependencies = [
  "ark-bls12-377",
  "ark-bls12-381",
  "ark-ec",
- "ark-ff",
+ "ark-ff 0.4.2",
  "ark-poly",
- "ark-serialize",
- "ark-std",
+ "ark-serialize 0.4.2",
+ "ark-std 0.4.0",
  "array-bytes",
  "chacha20poly1305",
  "generic-array 0.14.7",
@@ -11990,6 +12278,12 @@ dependencies = [
  "static_assertions",
 ]
 
+[[package]]
+name = "unarray"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eaea85b334db583fe3274d12b4cd1880032beab409c0d774be044d4480ab9a94"
+
 [[package]]
 name = "unicode-bidi"
 version = "0.3.18"
@@ -12141,8 +12435,8 @@ dependencies = [
  "ark-bls12-377",
  "ark-bls12-381",
  "ark-ec",
- "ark-ff",
- "ark-serialize",
+ "ark-ff 0.4.2",
+ "ark-serialize 0.4.2",
  "ark-serialize-derive",
  "arrayref",
  "constcat",
@@ -12156,6 +12450,15 @@ dependencies = [
  "zeroize",
 ]
 
+[[package]]
+name = "wait-timeout"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ac3b126d3914f9849036f826e054cbabdc8519970b8998ddaf3b5bd3c65f11"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "walkdir"
 version = "2.5.0"
diff --git a/Cargo.toml b/Cargo.toml
index 1e5c417d8d..d3cedd96d0 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -99,6 +99,7 @@ proc-macro2 = { version = "1", features = ["span-locations"] }
 thiserror = "1.0"
 walkdir = "2"
 approx = "0.5"
+alloy-primitives = { version = "0.8.23", default-features = false }
 
 subtensor-macros = { path = "support/macros" }
 
diff --git a/primitives/swap/Cargo.toml b/primitives/swap/Cargo.toml
index c5d2dc0361..bd377cbaa3 100644
--- a/primitives/swap/Cargo.toml
+++ b/primitives/swap/Cargo.toml
@@ -4,10 +4,11 @@ version = "0.1.0"
 edition = { workspace = true }
 
 [dependencies]
-substrate-fixed = { workspace = true }
+alloy-primitives = { workspace = true }
+safe-math = { workspace = true }
 sp-arithmetic = { workspace = true }
 sp-std = { workspace = true }
-safe-math = { workspace = true }
+substrate-fixed = { workspace = true }
 
 [lints]
 workspace = true
@@ -15,8 +16,9 @@ workspace = true
 [features]
 default = ["std"]
 std = [
-	"substrate-fixed/std",
-	"sp-std/std",
+	"alloy-primitives/std",
 	"safe-math/std",
 	"sp-arithmetic/std",
+	"sp-std/std",
+	"substrate-fixed/std",
 ]
diff --git a/primitives/swap/src/lib.rs b/primitives/swap/src/lib.rs
index b0c8eb936a..c6bb400f36 100644
--- a/primitives/swap/src/lib.rs
+++ b/primitives/swap/src/lib.rs
@@ -3,190 +3,14 @@ use core::marker::PhantomData;
 use safe_math::*;
 use substrate_fixed::types::U64F64;
 
-/// The width of a single price tick. Expressed in rao units.
-pub const TICK_SPACING: u64 = 10_000;
-pub const MAX_TICK: i32 = 887272;
-pub const MIN_SQRT_RATIO: u128 = 4295128739;
-pub const MAX_SQRT_RATIO: u128 = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
+use self::tick_math::{
+    TickMathError, get_sqrt_ratio_at_tick, get_tick_at_sqrt_ratio, u64f64_to_u256_q64_96,
+    u256_q64_96_to_u64f64,
+};
 
-type SqrtPrice = U64F64;
-
-/// Calculates sqrt(1.0001^tick) * 2^96
-pub fn get_sqrt_ratio_at_tick(tick: i32) -> u128 {
-    // Ensure tick is within bounds
-    let abs_tick = if tick < 0 { -tick } else { tick } as u32;
-    assert!(abs_tick <= MAX_TICK as u32, "Tick outside of allowed range");
-
-    // Initial ratio value
-    let mut ratio: u128 = if abs_tick & 0x1 != 0 {
-        0xfffcb933bd6fad37 << 64 | 0xaa2d162d1a594001
-    } else {
-        0x1 << 96
-    };
-
-    // Safe multiply and shift function
-    fn mul_shr(a: u128, b_hi: u64, b_lo: u64, shift: u8) -> u128 {
-        // Split a into high and low parts
-        let a_hi = a >> 64;
-        let a_lo = a & 0xFFFFFFFFFFFFFFFF;
-
-        // Multiply parts separately to avoid overflow
-        // (a_hi * 2^64 + a_lo) * (b_hi * 2^64 + b_lo)
-        // Only keep the high part since we're shifting by at least 64 anyway
-        let hi_hi = a_hi.checked_mul(b_hi as u128).unwrap_or(0);
-
-        // These parts will be shifted by 64
-        let hi_lo = a_hi.checked_mul(b_lo as u128).unwrap_or(0);
-        let lo_hi = a_lo.checked_mul(b_hi as u128).unwrap_or(0);
-
-        // Combine parts, adding with overflow checking
-        let mut result = hi_hi << 64;
-        result = result.checked_add(hi_lo).unwrap_or(result);
-        result = result.checked_add(lo_hi).unwrap_or(result);
-
-        // Final shift (already accounted for 64 bits)
-        if shift <= 64 {
-            result >> (shift - 64)
-        } else if shift < 128 {
-            result >> (shift - 64)
-        } else {
-            0
-        }
-    }
-
-    // Multiply ratio by appropriate factor based on each bit
-    // Break each constant into high and low 64-bit parts
-    if abs_tick & 0x2 != 0 {
-        ratio = mul_shr(ratio, 0xfff97272373d4132, 0x59a46990580e213a, 128);
-    }
-    if abs_tick & 0x4 != 0 {
-        ratio = mul_shr(ratio, 0xfff2e50f5f656932, 0xef12357cf3c7fdcc, 128);
-    }
-    if abs_tick & 0x8 != 0 {
-        ratio = mul_shr(ratio, 0xffe5caca7e10e4e6, 0x1c3624eaa0941cd0, 128);
-    }
-    if abs_tick & 0x10 != 0 {
-        ratio = mul_shr(ratio, 0xffcb9843d60f6159, 0xc9db58835c926644, 128);
-    }
-    if abs_tick & 0x20 != 0 {
-        ratio = mul_shr(ratio, 0xff973b41fa98c081, 0x472e6896dfb254c0, 128);
-    }
-    if abs_tick & 0x40 != 0 {
-        ratio = mul_shr(ratio, 0xff2ea16466c96a38, 0x43ec78b326b52861, 128);
-    }
-    if abs_tick & 0x80 != 0 {
-        ratio = mul_shr(ratio, 0xfe5dee046a99a2a8, 0x11c461f1969c3053, 128);
-    }
-    if abs_tick & 0x100 != 0 {
-        ratio = mul_shr(ratio, 0xfcbe86c7900a88ae, 0xdcffc83b479aa3a4, 128);
-    }
-    if abs_tick & 0x200 != 0 {
-        ratio = mul_shr(ratio, 0xf987a7253ac41317, 0x6f2b074cf7815e54, 128);
-    }
-    if abs_tick & 0x400 != 0 {
-        ratio = mul_shr(ratio, 0xf3392b0822b70005, 0x940c7a398e4b70f3, 128);
-    }
-    if abs_tick & 0x800 != 0 {
-        ratio = mul_shr(ratio, 0xe7159475a2c29b74, 0x43b29c7fa6e889d9, 128);
-    }
-    if abs_tick & 0x1000 != 0 {
-        ratio = mul_shr(ratio, 0xd097f3bdfd2022b8, 0x845ad8f792aa5825, 128);
-    }
-    if abs_tick & 0x2000 != 0 {
-        ratio = mul_shr(ratio, 0xa9f746462d870fdf, 0x8a65dc1f90e061e5, 128);
-    }
-    if abs_tick & 0x4000 != 0 {
-        ratio = mul_shr(ratio, 0x70d869a156d2a1b8, 0x90bb3df62baf32f7, 128);
-    }
-    if abs_tick & 0x8000 != 0 {
-        ratio = mul_shr(ratio, 0x31be135f97d08fd9, 0x81231505542fcfa6, 128);
-    }
-    if abs_tick & 0x10000 != 0 {
-        ratio = mul_shr(ratio, 0x9aa508b5b7a84e1c, 0x677de54f3e99bc9, 128);
-    }
-    if abs_tick & 0x20000 != 0 {
-        ratio = mul_shr(ratio, 0x5d6af8dedb811966, 0x99c329225ee604, 128);
-    }
-    if abs_tick & 0x40000 != 0 {
-        ratio = mul_shr(ratio, 0x2216e584f5fa1ea9, 0x26041bedfe98, 128);
-    }
-    if abs_tick & 0x80000 != 0 {
-        ratio = mul_shr(ratio, 0x48a170391f7dc424, 0x44e8fa2, 128);
-    }
-
-    // Invert ratio if tick is positive
-    if tick > 0 {
-        if ratio == 0 {
-            return u128::MAX;
-        }
-        ratio = u128::MAX / ratio;
-    }
-
-    // Convert from Q128.128 to Q64.96
-    let sqrt_price_x96 = if ratio >= (1 << 32) {
-        let result = ratio >> 32;
-        if ratio % (1 << 32) != 0 {
-            result + 1
-        } else {
-            result
-        }
-    } else {
-        1
-    };
-
-    sqrt_price_x96
-}
-
-/// A simpler implementation for get_tick_at_sqrt_ratio that avoids complex bit operations
-/// This may not match Uniswap's exact implementation but should be accurate enough
-/// for roundtrip conversions
-/// Calculates the greatest tick value such that get_sqrt_ratio_at_tick(tick) <= sqrt_ratio_x96
-pub fn get_tick_at_sqrt_ratio(sqrt_ratio_x96: u128) -> i32 {
-    // Special case for tick 0 - which is exactly 1.0 * 2^96
-    if sqrt_ratio_x96 == (1 << 96) {
-        return 0;
-    }
-
-    // Ensure ratio is within bounds - relax the upper bound slightly
-    // This solves the "Ratio outside of allowed range" error
-    assert!(
-        sqrt_ratio_x96 >= MIN_SQRT_RATIO && sqrt_ratio_x96 <= MAX_SQRT_RATIO,
-        "Ratio outside of allowed range"
-    );
-
-    // Binary search to find the closest tick
-    let mut lower = -MAX_TICK;
-    let mut upper = MAX_TICK;
+mod tick_math;
 
-    while lower < upper {
-        let mid = (lower + upper) / 2;
-
-        let price = get_sqrt_ratio_at_tick(mid);
-
-        if price <= sqrt_ratio_x96 {
-            lower = mid + 1;
-        } else {
-            upper = mid;
-        }
-    }
-
-    // We need the largest tick such that get_sqrt_ratio_at_tick(tick) <= sqrt_ratio_x96
-    let tick = lower - 1;
-
-    // Double-check our result is correct
-    let lower_price = get_sqrt_ratio_at_tick(tick);
-    let upper_price = get_sqrt_ratio_at_tick(tick + 1);
-
-    if lower_price <= sqrt_ratio_x96 && upper_price > sqrt_ratio_x96 {
-        tick
-    } else if sqrt_ratio_x96.abs_diff(1 << 96) < 1000 {
-        // Very close to tick 0
-        0
-    } else {
-        // Safeguard
-        tick
-    }
-}
+type SqrtPrice = U64F64;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum OrderType {
@@ -223,51 +47,13 @@ struct Position {
 
 impl Position {
     /// Converts tick index into SQRT of price
-    pub fn tick_index_to_sqrt_price(tick_idx: u64) -> SqrtPrice {
-        // Special case for tick 0
-        if tick_idx == 0 {
-            return SqrtPrice::from_num(1.0);
-        }
-
-        // Convert u64 tick to i32 and handle potential overflows
-        let tick_i32 = if tick_idx > i32::MAX as u64 {
-            i32::MAX
-        } else {
-            tick_idx as i32
-        };
-
-        // Convert the U128 result to your SqrtPrice type
-        let sqrt_price_x96 = get_sqrt_ratio_at_tick(tick_i32);
-        SqrtPrice::from_bits(sqrt_price_x96 as _)
+    pub fn tick_index_to_sqrt_price(tick_idx: i32) -> Result<SqrtPrice, TickMathError> {
+        get_sqrt_ratio_at_tick(tick_idx).and_then(u256_q64_96_to_u64f64)
     }
 
     /// Converts SQRT price to tick index
-    pub fn sqrt_price_to_tick_index(sqrt_price: SqrtPrice) -> u64 {
-        // Special case for price exactly equal to 1.0
-        if sqrt_price == SqrtPrice::from_num(1.0) {
-            return 0;
-        }
-
-        // Special case for prices very close to 1.0
-        if (sqrt_price - SqrtPrice::from_num(1.0)) < SqrtPrice::from_num(0.0000001) {
-            return 0;
-        }
-
-        // Convert your SqrtPrice type to U128
-        let sqrt_price_x96 = sqrt_price.to_bits() as u128;
-
-        // Get the tick and convert back to u64
-        let tick = get_tick_at_sqrt_ratio(sqrt_price_x96);
-
-        // Handle negative ticks (if your system doesn't support negative ticks)
-        if tick < 0 { 0 } else { tick as u64 }
-    }
-
-    fn tick_spacing_tao() -> SqrtPrice {
-        // SqrtPrice::from_num(TICK_SPACING)
-        //     .saturating_div(SqrtPrice::from_num(1e9))
-        //     .saturating_add(SqrtPrice::from_num(1.0))
-        SqrtPrice::from_num(1.0001)
+    pub fn sqrt_price_to_tick_index(sqrt_price: SqrtPrice) -> Result<i32, TickMathError> {
+        get_tick_at_sqrt_ratio(u64f64_to_u256_q64_96(sqrt_price))
     }
 
     /// Converts position to token amounts
@@ -620,55 +406,54 @@ mod tests {
 
     #[test]
     fn test_tick_index_to_sqrt_price() {
+        let tick_spacing = SqrtPrice::from_num(1.0001);
+
         // At tick index 0, the sqrt price should be 1.0
-        let sqrt_price = Position::tick_index_to_sqrt_price(0);
+        let sqrt_price = Position::tick_index_to_sqrt_price(0).unwrap();
         assert_eq!(sqrt_price, SqrtPrice::from_num(1.0));
 
-        let sqrt_price = Position::tick_index_to_sqrt_price(2);
-        let tick_spacing_tao = Position::tick_spacing_tao();
-        assert_eq!(sqrt_price, tick_spacing_tao);
+        let sqrt_price = Position::tick_index_to_sqrt_price(2).unwrap();
+        assert_eq!(sqrt_price, tick_spacing);
 
-        let sqrt_price = Position::tick_index_to_sqrt_price(4);
+        let sqrt_price = Position::tick_index_to_sqrt_price(4).unwrap();
         // Calculate the expected value: (1 + TICK_SPACING/1e9 + 1.0)^2
-        let expected = tick_spacing_tao * tick_spacing_tao;
+        let expected = tick_spacing * tick_spacing;
         assert_eq!(sqrt_price, expected);
 
         // Test with tick index 10
-        let sqrt_price = Position::tick_index_to_sqrt_price(10);
+        let sqrt_price = Position::tick_index_to_sqrt_price(10).unwrap();
         // Calculate the expected value: (1 + TICK_SPACING/1e9 + 1.0)^5
-        let expected_sqrt_price_10 = tick_spacing_tao.checked_pow(5).unwrap();
+        let expected_sqrt_price_10 = tick_spacing.checked_pow(5).unwrap();
         assert_eq!(sqrt_price, expected_sqrt_price_10);
     }
 
     #[test]
     fn test_sqrt_price_to_tick_index() {
-        let tick_spacing_tao = Position::tick_spacing_tao();
-
-        let tick_index = Position::sqrt_price_to_tick_index(SqrtPrice::from_num(1.0));
+        let tick_spacing = SqrtPrice::from_num(1.0001);
+        let tick_index = Position::sqrt_price_to_tick_index(SqrtPrice::from_num(1.0)).unwrap();
         assert_eq!(tick_index, 0);
 
         // Test with sqrt price equal to tick_spacing_tao (should be tick index 2)
-        let tick_index = Position::sqrt_price_to_tick_index(tick_spacing_tao);
+        let tick_index = Position::sqrt_price_to_tick_index(tick_spacing).unwrap();
         assert_eq!(tick_index, 2);
 
         // Test with sqrt price equal to tick_spacing_tao^2 (should be tick index 4)
-        let sqrt_price = tick_spacing_tao * tick_spacing_tao;
-        let tick_index = Position::sqrt_price_to_tick_index(sqrt_price);
+        let sqrt_price = tick_spacing * tick_spacing;
+        let tick_index = Position::sqrt_price_to_tick_index(sqrt_price).unwrap();
         assert_eq!(tick_index, 4);
 
         // Test with sqrt price equal to tick_spacing_tao^5 (should be tick index 10)
-        let sqrt_price = tick_spacing_tao.checked_pow(5).unwrap();
-        let tick_index = Position::sqrt_price_to_tick_index(sqrt_price);
-        assert_eq!(tick_index, 10,);
+        let sqrt_price = tick_spacing.checked_pow(5).unwrap();
+        let tick_index = Position::sqrt_price_to_tick_index(sqrt_price).unwrap();
+        assert_eq!(tick_index, 10);
     }
 
     #[test]
     fn test_roundtrip_tick_index_sqrt_price() {
         for tick_index in [0, 2, 4, 10, 100, 1000].iter() {
-            let sqrt_price = Position::tick_index_to_sqrt_price(*tick_index);
-            let round_trip_tick_index = Position::sqrt_price_to_tick_index(sqrt_price);
-            dbg!(tick_index, round_trip_tick_index);
-            // assert_eq!(round_trip_tick_index, *tick_index);
+            let sqrt_price = Position::tick_index_to_sqrt_price(*tick_index).unwrap();
+            let round_trip_tick_index = Position::sqrt_price_to_tick_index(sqrt_price).unwrap();
+            assert_eq!(round_trip_tick_index, *tick_index);
         }
     }
 }
diff --git a/primitives/swap/src/tick_math.rs b/primitives/swap/src/tick_math.rs
new file mode 100644
index 0000000000..685b98eb3a
--- /dev/null
+++ b/primitives/swap/src/tick_math.rs
@@ -0,0 +1,523 @@
+//! This module is adopted from github.com/0xKitsune/uniswap-v3-math
+use core::error::Error;
+use core::fmt;
+use core::ops::{BitOr, Neg, Shl, Shr};
+
+use alloy_primitives::{I256, U256};
+use substrate_fixed::types::U64F64;
+
+const U256_1: U256 = U256::from_limbs([1, 0, 0, 0]);
+const U256_2: U256 = U256::from_limbs([2, 0, 0, 0]);
+const U256_3: U256 = U256::from_limbs([3, 0, 0, 0]);
+const U256_4: U256 = U256::from_limbs([4, 0, 0, 0]);
+const U256_5: U256 = U256::from_limbs([5, 0, 0, 0]);
+const U256_6: U256 = U256::from_limbs([6, 0, 0, 0]);
+const U256_7: U256 = U256::from_limbs([7, 0, 0, 0]);
+const U256_8: U256 = U256::from_limbs([8, 0, 0, 0]);
+const U256_15: U256 = U256::from_limbs([15, 0, 0, 0]);
+const U256_16: U256 = U256::from_limbs([16, 0, 0, 0]);
+const U256_32: U256 = U256::from_limbs([32, 0, 0, 0]);
+const U256_64: U256 = U256::from_limbs([64, 0, 0, 0]);
+const U256_127: U256 = U256::from_limbs([127, 0, 0, 0]);
+const U256_128: U256 = U256::from_limbs([128, 0, 0, 0]);
+const U256_255: U256 = U256::from_limbs([255, 0, 0, 0]);
+
+const U256_256: U256 = U256::from_limbs([256, 0, 0, 0]);
+const U256_512: U256 = U256::from_limbs([512, 0, 0, 0]);
+const U256_1024: U256 = U256::from_limbs([1024, 0, 0, 0]);
+const U256_2048: U256 = U256::from_limbs([2048, 0, 0, 0]);
+const U256_4096: U256 = U256::from_limbs([4096, 0, 0, 0]);
+const U256_8192: U256 = U256::from_limbs([8192, 0, 0, 0]);
+const U256_16384: U256 = U256::from_limbs([16384, 0, 0, 0]);
+const U256_32768: U256 = U256::from_limbs([32768, 0, 0, 0]);
+const U256_65536: U256 = U256::from_limbs([65536, 0, 0, 0]);
+const U256_131072: U256 = U256::from_limbs([131072, 0, 0, 0]);
+const U256_262144: U256 = U256::from_limbs([262144, 0, 0, 0]);
+const U256_524288: U256 = U256::from_limbs([524288, 0, 0, 0]);
+
+const U256_MAX_TICK: U256 = U256::from_limbs([887272, 0, 0, 0]);
+
+const MIN_TICK: i32 = -887272;
+const MAX_TICK: i32 = -MIN_TICK;
+
+const MIN_SQRT_RATIO: U256 = U256::from_limbs([4295128739, 0, 0, 0]);
+const MAX_SQRT_RATIO: U256 =
+    U256::from_limbs([6743328256752651558, 17280870778742802505, 4294805859, 0]);
+
+const SQRT_10001: I256 = I256::from_raw(U256::from_limbs([11745905768312294533, 13863, 0, 0]));
+const TICK_LOW: I256 = I256::from_raw(U256::from_limbs([
+    6552757943157144234,
+    184476617836266586,
+    0,
+    0,
+]));
+const TICK_HIGH: I256 = I256::from_raw(U256::from_limbs([
+    4998474450511881007,
+    15793544031827761793,
+    0,
+    0,
+]));
+
+pub(crate) fn get_sqrt_ratio_at_tick(tick: i32) -> Result<U256, TickMathError> {
+    let abs_tick = if tick < 0 {
+        U256::from(tick.neg())
+    } else {
+        U256::from(tick)
+    };
+
+    if abs_tick > U256_MAX_TICK {
+        return Err(TickMathError::TickTooHigh);
+    }
+
+    let mut ratio = if abs_tick & (U256_1) != U256::ZERO {
+        U256::from_limbs([12262481743371124737, 18445821805675392311, 0, 0])
+    } else {
+        U256::from_limbs([0, 0, 1, 0])
+    };
+
+    if !(abs_tick & U256_2).is_zero() {
+        ratio = (ratio * U256::from_limbs([6459403834229662010, 18444899583751176498, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_4).is_zero() {
+        ratio =
+            (ratio * U256::from_limbs([17226890335427755468, 18443055278223354162, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_8).is_zero() {
+        ratio = (ratio * U256::from_limbs([2032852871939366096, 18439367220385604838, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_16).is_zero() {
+        ratio =
+            (ratio * U256::from_limbs([14545316742740207172, 18431993317065449817, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_32).is_zero() {
+        ratio = (ratio * U256::from_limbs([5129152022828963008, 18417254355718160513, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_64).is_zero() {
+        ratio = (ratio * U256::from_limbs([4894419605888772193, 18387811781193591352, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_128).is_zero() {
+        ratio = (ratio * U256::from_limbs([1280255884321894483, 18329067761203520168, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_256).is_zero() {
+        ratio =
+            (ratio * U256::from_limbs([15924666964335305636, 18212142134806087854, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_512).is_zero() {
+        ratio = (ratio * U256::from_limbs([8010504389359918676, 17980523815641551639, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_1024).is_zero() {
+        ratio =
+            (ratio * U256::from_limbs([10668036004952895731, 17526086738831147013, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_2048).is_zero() {
+        ratio = (ratio * U256::from_limbs([4878133418470705625, 16651378430235024244, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_4096).is_zero() {
+        ratio = (ratio * U256::from_limbs([9537173718739605541, 15030750278693429944, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_8192).is_zero() {
+        ratio = (ratio * U256::from_limbs([9972618978014552549, 12247334978882834399, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_16384).is_zero() {
+        ratio = (ratio * U256::from_limbs([10428997489610666743, 8131365268884726200, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_32768).is_zero() {
+        ratio = (ratio * U256::from_limbs([9305304367709015974, 3584323654723342297, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_65536).is_zero() {
+        ratio = (ratio * U256::from_limbs([14301143598189091785, 696457651847595233, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_131072).is_zero() {
+        ratio = (ratio * U256::from_limbs([7393154844743099908, 26294789957452057, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_262144).is_zero() {
+        ratio = (ratio * U256::from_limbs([2209338891292245656, 37481735321082, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_524288).is_zero() {
+        ratio = (ratio * U256::from_limbs([10518117631919034274, 76158723, 0, 0])) >> 128
+    }
+
+    if tick > 0 {
+        ratio = U256::MAX / ratio;
+    }
+
+    Ok((ratio >> 32)
+        + if (ratio.wrapping_rem(U256_1 << 32)).is_zero() {
+            U256::ZERO
+        } else {
+            U256_1
+        })
+}
+
+pub(crate) fn get_tick_at_sqrt_ratio(sqrt_price_x_96: U256) -> Result<i32, TickMathError> {
+    if !(sqrt_price_x_96 >= MIN_SQRT_RATIO && sqrt_price_x_96 < MAX_SQRT_RATIO) {
+        return Err(TickMathError::SqrtPriceOutOfBounds);
+    }
+
+    let ratio: U256 = sqrt_price_x_96.shl(32);
+    let mut r = ratio;
+    let mut msb = U256::ZERO;
+
+    let mut f = if r > U256::from_limbs([18446744073709551615, 18446744073709551615, 0, 0]) {
+        U256_1.shl(U256_7)
+    } else {
+        U256::ZERO
+    };
+    msb = msb.bitor(f);
+    r = r.shr(f);
+
+    f = if r > U256::from_limbs([18446744073709551615, 0, 0, 0]) {
+        U256_1.shl(U256_6)
+    } else {
+        U256::ZERO
+    };
+    msb = msb.bitor(f);
+    r = r.shr(f);
+
+    f = if r > U256::from_limbs([4294967295, 0, 0, 0]) {
+        U256_1.shl(U256_5)
+    } else {
+        U256::ZERO
+    };
+    msb = msb.bitor(f);
+    r = r.shr(f);
+
+    f = if r > U256::from_limbs([65535, 0, 0, 0]) {
+        U256_1.shl(U256_4)
+    } else {
+        U256::ZERO
+    };
+    msb = msb.bitor(f);
+    r = r.shr(f);
+
+    f = if r > U256_255 {
+        U256_1.shl(U256_3)
+    } else {
+        U256::ZERO
+    };
+    msb = msb.bitor(f);
+    r = r.shr(f);
+
+    f = if r > U256_15 {
+        U256_1.shl(U256_2)
+    } else {
+        U256::ZERO
+    };
+    msb = msb.bitor(f);
+    r = r.shr(f);
+
+    f = if r > U256_3 {
+        U256_1.shl(U256_1)
+    } else {
+        U256::ZERO
+    };
+    msb = msb.bitor(f);
+    r = r.shr(f);
+
+    f = if r > U256_1 { U256_1 } else { U256::ZERO };
+
+    msb = msb.bitor(f);
+
+    r = if msb >= U256_128 {
+        ratio.shr(msb - U256_127)
+    } else {
+        ratio.shl(U256_127 - msb)
+    };
+
+    let mut log_2: I256 = (I256::from_raw(msb) - I256::from_limbs([128, 0, 0, 0])).shl(64);
+
+    for i in (51..=63).rev() {
+        r = r.overflowing_mul(r).0.shr(U256_127);
+        let f: U256 = r.shr(128);
+        log_2 = log_2.bitor(I256::from_raw(f.shl(i)));
+
+        r = r.shr(f);
+    }
+
+    r = r.overflowing_mul(r).0.shr(U256_127);
+    let f: U256 = r.shr(128);
+    log_2 = log_2.bitor(I256::from_raw(f.shl(50)));
+
+    let log_sqrt10001 = log_2.wrapping_mul(SQRT_10001);
+
+    let tick_low = ((log_sqrt10001 - TICK_LOW) >> 128_u8).low_i32();
+
+    let tick_high = ((log_sqrt10001 + TICK_HIGH) >> 128_u8).low_i32();
+
+    let tick = if tick_low == tick_high {
+        tick_low
+    } else if get_sqrt_ratio_at_tick(tick_high)? <= sqrt_price_x_96 {
+        tick_high
+    } else {
+        tick_low
+    };
+
+    Ok(tick)
+}
+
+/// Convert U256 to U64F64
+///
+/// # Arguments
+/// * `value` - The U256 value in Q64.96 format
+///
+/// # Returns
+/// * `Result<U64F64, &'static str>` - Converted value or error if too large
+pub(crate) fn u256_to_u64f64(
+    value: U256,
+    source_fractional_bits: u32,
+) -> Result<U64F64, TickMathError> {
+    if value > U256::from(u128::MAX) {
+        return Err(TickMathError::ConversionError);
+    }
+
+    let mut value: u128 = value
+        .try_into()
+        .map_err(|_| TickMathError::ConversionError)?;
+
+    // Adjust to 64 fractional bits (U64F64 format)
+    if source_fractional_bits < 64 {
+        // Shift left to add more fractional bits
+        value = value
+            .checked_shl(64 - source_fractional_bits)
+            .ok_or(TickMathError::Overflow)?;
+    } else if source_fractional_bits > 64 {
+        // Shift right to remove excess fractional bits
+        value = value >> (source_fractional_bits - 64);
+    }
+
+    Ok(U64F64::from_bits(value))
+}
+
+/// Convert U64F64 to U256
+///
+/// # Arguments
+/// * `value` - The U64F64 value to convert
+/// * `target_fractional_bits` - Number of fractional bits in the target U256 format
+///
+/// # Returns
+/// * `U256` - Converted value
+pub(crate) fn u64f64_to_u256(value: U64F64, target_fractional_bits: u32) -> U256 {
+    let mut bits = value.to_bits();
+
+    // Adjust to target fractional bits
+    if target_fractional_bits < 64 {
+        // Shift right to remove excess fractional bits
+        bits = bits >> (64 - target_fractional_bits);
+    } else if target_fractional_bits > 64 {
+        // Shift left to add more fractional bits
+        bits = bits << (target_fractional_bits - 64);
+    }
+
+    // Create U256
+    U256::from(bits)
+}
+
+/// Convert U256 in Q64.96 format (Uniswap's sqrt price format) to U64F64
+pub(crate) fn u256_q64_96_to_u64f64(value: U256) -> Result<U64F64, TickMathError> {
+    u256_to_u64f64(value, 96)
+}
+
+/// Convert U64F64 to U256 in Q64.96 format (Uniswap's sqrt price format)
+pub(crate) fn u64f64_to_u256_q64_96(value: U64F64) -> U256 {
+    u64f64_to_u256(value, 96)
+}
+
+#[derive(Debug)]
+pub enum TickMathError {
+    TickTooHigh,
+    SqrtPriceOutOfBounds,
+    ConversionError,
+    Overflow,
+}
+
+impl fmt::Display for TickMathError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+			Self::TickTooHigh => f.write_str("The given tick must be less than, or equal to, the maximum tick"),
+			Self::SqrtPriceOutOfBounds =>f.write_str("Second inequality must be < because the price can never reach the price at the max tick"),
+			Self::ConversionError => f.write_str("Error converting from one number type into another"),
+			Self::Overflow => f.write_str("Number overflow in arithmetic operation")
+		}
+    }
+}
+
+impl Error for TickMathError {}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use std::{ops::Sub, str::FromStr};
+
+    #[test]
+    fn test_get_sqrt_ratio_at_tick_bounds() {
+        // the function should return an error if the tick is out of bounds
+        if let Err(err) = get_sqrt_ratio_at_tick(MIN_TICK - 1) {
+            assert!(matches!(err, TickMathError::TickTooHigh));
+        } else {
+            panic!("get_qrt_ratio_at_tick did not respect lower tick bound")
+        }
+        if let Err(err) = get_sqrt_ratio_at_tick(MAX_TICK + 1) {
+            assert!(matches!(err, TickMathError::TickTooHigh));
+        } else {
+            panic!("get_qrt_ratio_at_tick did not respect upper tick bound")
+        }
+    }
+
+    #[test]
+    fn test_get_sqrt_ratio_at_tick_values() {
+        // test individual values for correct results
+        assert_eq!(
+            get_sqrt_ratio_at_tick(MIN_TICK).unwrap(),
+            U256::from(4295128739u64),
+            "sqrt ratio at min incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(MIN_TICK + 1).unwrap(),
+            U256::from(4295343490u64),
+            "sqrt ratio at min + 1 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(MAX_TICK - 1).unwrap(),
+            U256::from_str("1461373636630004318706518188784493106690254656249").unwrap(),
+            "sqrt ratio at max - 1 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(MAX_TICK).unwrap(),
+            U256::from_str("1461446703485210103287273052203988822378723970342").unwrap(),
+            "sqrt ratio at max incorrect"
+        );
+        // checking hard coded values against solidity results
+        assert_eq!(
+            get_sqrt_ratio_at_tick(50).unwrap(),
+            U256::from(79426470787362580746886972461u128),
+            "sqrt ratio at 50 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(100).unwrap(),
+            U256::from(79625275426524748796330556128u128),
+            "sqrt ratio at 100 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(250).unwrap(),
+            U256::from(80224679980005306637834519095u128),
+            "sqrt ratio at 250 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(500).unwrap(),
+            U256::from(81233731461783161732293370115u128),
+            "sqrt ratio at 500 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(1000).unwrap(),
+            U256::from(83290069058676223003182343270u128),
+            "sqrt ratio at 1000 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(2500).unwrap(),
+            U256::from(89776708723587163891445672585u128),
+            "sqrt ratio at 2500 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(3000).unwrap(),
+            U256::from(92049301871182272007977902845u128),
+            "sqrt ratio at 3000 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(4000).unwrap(),
+            U256::from(96768528593268422080558758223u128),
+            "sqrt ratio at 4000 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(5000).unwrap(),
+            U256::from(101729702841318637793976746270u128),
+            "sqrt ratio at 5000 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(50000).unwrap(),
+            U256::from(965075977353221155028623082916u128),
+            "sqrt ratio at 50000 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(150000).unwrap(),
+            U256::from(143194173941309278083010301478497u128),
+            "sqrt ratio at 150000 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(250000).unwrap(),
+            U256::from(21246587762933397357449903968194344u128),
+            "sqrt ratio at 250000 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(500000).unwrap(),
+            U256::from_str("5697689776495288729098254600827762987878").unwrap(),
+            "sqrt ratio at 500000 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(738203).unwrap(),
+            U256::from_str("847134979253254120489401328389043031315994541").unwrap(),
+            "sqrt ratio at 738203 incorrect"
+        );
+    }
+
+    #[test]
+    fn test_get_tick_at_sqrt_ratio() {
+        //throws for too low
+        let result = get_tick_at_sqrt_ratio(MIN_SQRT_RATIO.sub(U256_1));
+        assert_eq!(
+            result.unwrap_err().to_string(),
+            "Second inequality must be < because the price can never reach the price at the max tick"
+        );
+
+        //throws for too high
+        let result = get_tick_at_sqrt_ratio(MAX_SQRT_RATIO);
+        assert_eq!(
+            result.unwrap_err().to_string(),
+            "Second inequality must be < because the price can never reach the price at the max tick"
+        );
+
+        //ratio of min tick
+        let result = get_tick_at_sqrt_ratio(MIN_SQRT_RATIO).unwrap();
+        assert_eq!(result, MIN_TICK);
+
+        //ratio of min tick + 1
+        let result = get_tick_at_sqrt_ratio(U256::from_str("4295343490").unwrap()).unwrap();
+        assert_eq!(result, MIN_TICK + 1);
+    }
+
+    #[test]
+    fn test_roundtrip() {
+        for tick_index in [0, 2, 4, 10, 100, 1000].iter() {
+            let sqrt_price = get_sqrt_ratio_at_tick(*tick_index).unwrap();
+            let round_trip_tick_index = get_tick_at_sqrt_ratio(sqrt_price).unwrap();
+            assert_eq!(round_trip_tick_index, *tick_index);
+        }
+    }
+
+    #[test]
+    fn test_u256_to_u64f64_q64_96() {
+        // Test tick 0 (sqrt price = 1.0 * 2^96)
+        let tick0_sqrt_price = U256::from(1u128 << 96);
+        let fixed_price = u256_q64_96_to_u64f64(tick0_sqrt_price).unwrap();
+
+        // Should be 1.0 in U64F64
+        assert_eq!(fixed_price, U64F64::from_num(1.0));
+
+        // Round trip back to U256 Q64.96
+        let back_to_u256 = u64f64_to_u256_q64_96(fixed_price);
+        assert_eq!(back_to_u256, tick0_sqrt_price);
+    }
+
+    #[test]
+    fn test_u256_with_other_formats() {
+        // Test with a value that has 32 fractional bits
+        let value_32frac = U256::from(123456789u128 << 32); // 123456789.0 in Q96.32
+        let fixed_value = u256_to_u64f64(value_32frac, 32).unwrap();
+
+        // Should be 123456789.0 in U64F64
+        assert_eq!(fixed_value, U64F64::from_num(123456789.0));
+
+        // Round trip back to U256 with 32 fractional bits
+        let back_to_u256 = u64f64_to_u256(fixed_value, 32);
+        assert_eq!(back_to_u256, value_32frac);
+    }
+}

From 4fbae9e5dae7655c4e673ac57540ec9300754532 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Fri, 14 Mar 2025 18:08:12 -0400
Subject: [PATCH 015/418] Rough swap implementation that builds

---
 primitives/safe-math/src/lib.rs  |   2 +-
 primitives/swap/src/lib.rs       | 794 ++++++++++++++++++++-----------
 primitives/swap/src/tick_math.rs |   4 +-
 3 files changed, 509 insertions(+), 291 deletions(-)

diff --git a/primitives/safe-math/src/lib.rs b/primitives/safe-math/src/lib.rs
index eda964e678..82e8e4ad96 100644
--- a/primitives/safe-math/src/lib.rs
+++ b/primitives/safe-math/src/lib.rs
@@ -32,7 +32,7 @@ macro_rules! impl_safe_div_for_primitive {
         )*
     };
 }
-impl_safe_div_for_primitive!(u8, u16, u32, u64, i8, i16, i32, i64, usize);
+impl_safe_div_for_primitive!(u8, u16, u32, u64, u128, i8, i16, i32, i64, usize);
 
 pub trait FixedExt: Fixed {
     fn checked_pow<E>(&self, exponent: E) -> Option<Self>
diff --git a/primitives/swap/src/lib.rs b/primitives/swap/src/lib.rs
index 7579df8c45..bb17418ce2 100644
--- a/primitives/swap/src/lib.rs
+++ b/primitives/swap/src/lib.rs
@@ -1,11 +1,12 @@
 use core::marker::PhantomData;
+use std::ops::Neg;
 
 use safe_math::*;
 use substrate_fixed::types::U64F64;
 
 use self::tick_math::{
-    TickMathError, get_sqrt_ratio_at_tick, get_tick_at_sqrt_ratio, u64f64_to_u256_q64_96,
-    u256_q64_96_to_u64f64,
+    MAX_TICK, MIN_TICK, TickMathError, get_sqrt_ratio_at_tick, get_tick_at_sqrt_ratio,
+    u64f64_to_u256_q64_96, u256_q64_96_to_u64f64,
 };
 
 mod tick_math;
@@ -24,18 +25,23 @@ pub enum SwapStepAction {
     StopIn,
 }
 
-struct RemoveLiquidityResult {
+pub struct RemoveLiquidityResult {
     tao: u64,
     alpha: u64,
     fee_tao: u64,
     fee_alpha: u64,
 }
 
-struct SwapResult {
+pub struct SwapResult {
     amount_paid_out: u64,
     refund: u64,
 }
 
+struct SwapStepResult {
+    amount_to_take: u64,
+    delta_out: u64,
+}
+
 /// Position designates one liquidity position.
 ///
 /// Alpha price is expressed in rao units per one 10^9 unit. For example,
@@ -48,7 +54,7 @@ struct SwapResult {
 /// fees_alpha - fees accrued by the position in base currency (Alpha)
 ///
 #[cfg_attr(test, derive(Debug, PartialEq))]
-struct Position {
+pub struct Position {
     tick_low: u64,
     tick_high: u64,
     liquidity: u64,
@@ -78,7 +84,7 @@ impl Position {
     ///
     /// returns tuple of (TAO, Alpha)
     ///
-    pub fn to_token_amounts(self, current_tick: u64) -> (u64, u64) {
+    pub fn to_token_amounts(&self, _current_tick: u64) -> (u64, u64) {
         // let one = 1.into();
 
         // let sqrt_price_curr = Self::tick_index_to_sqrt_price(current_tick);
@@ -114,11 +120,12 @@ impl Position {
 ///   - Gross liquidity
 ///   - Fees (above global) in both currencies
 ///
-struct Tick {
+#[derive(Default)]
+pub struct Tick {
     liquidity_net: i128,
     liquidity_gross: u64,
-    fees_out_tao: u64,
-    fees_out_alpha: u64,
+    fees_out_tao: U64F64,
+    fees_out_alpha: U64F64,
 }
 
 /// This trait implementation depends on Runtime and it needs to be implemented
@@ -129,45 +136,45 @@ pub trait SwapDataOperations<AccountIdType> {
     /// Tells if v3 swap is initialized in the state. v2 only provides base and quote
     /// reserves, while v3 also stores ticks and positions, which need to be initialized
     /// at the first pool creation.
-    fn is_v3_initialized() -> bool;
+    fn is_v3_initialized(&self) -> bool;
     /// Returns u16::MAX normalized fee rate. For example, 0.3% is approximately 196.
-    fn get_fee_rate() -> u16;
+    fn get_fee_rate(&self) -> u16;
     /// Minimum liquidity that is safe for rounding and integer math.
-    fn get_minimum_liquidity() -> u64;
-    fn get_tick_by_index(tick_index: u64) -> Option<Tick>;
-    fn insert_tick_by_index(tick_index: u64, tick: Tick);
-    fn remove_tick_by_index(tick_index: u64);
+    fn get_minimum_liquidity(&self) -> u64;
+    fn get_tick_by_index(&self, tick_index: u64) -> Option<Tick>;
+    fn insert_tick_by_index(&self, tick_index: u64, tick: Tick);
+    fn remove_tick_by_index(&self, tick_index: u64);
     /// Minimum sqrt price across all active ticks
-    fn get_min_sqrt_price() -> SqrtPrice;
+    fn get_min_sqrt_price(&self) -> SqrtPrice;
     /// Maximum sqrt price across all active ticks
-    fn get_max_sqrt_price() -> SqrtPrice;
-    fn get_tao_reserve() -> u64;
-    fn set_tao_reserve() -> u64;
-    fn get_alpha_reserve() -> u64;
-    fn set_alpha_reserve() -> u64;
-    fn get_alpha_sqrt_price() -> u64;
-    fn set_alpha_sqrt_price() -> u64;
+    fn get_max_sqrt_price(&self) -> SqrtPrice;
+    fn get_tao_reserve(&self) -> u64;
+    fn set_tao_reserve(&self, tao: u64) -> u64;
+    fn get_alpha_reserve(&self) -> u64;
+    fn set_alpha_reserve(&self, alpha: u64) -> u64;
+    fn get_alpha_sqrt_price(&self) -> SqrtPrice;
+    fn set_alpha_sqrt_price(&self, sqrt_price: SqrtPrice) -> u64;
 
     // Getters/setters for global accrued fees in alpha and tao per subnet
-    fn get_fee_global_tao() -> U64F64;
-    fn set_fee_global_tao(fee: U64F64);
-    fn get_fee_global_alpha() -> U64F64;
-    fn set_fee_global_alpha(fee: U64F64);
+    fn get_fee_global_tao(&self) -> U64F64;
+    fn set_fee_global_tao(&self, fee: U64F64);
+    fn get_fee_global_alpha(&self) -> U64F64;
+    fn set_fee_global_alpha(&self, fee: U64F64);
 
     /// Get current tick liquidity
-    fn get_current_liquidity() -> u64;
+    fn get_current_liquidity(&self) -> u64;
     /// Set current tick liquidity
-    fn set_current_liquidity(liquidity: u64);
+    fn set_current_liquidity(&self, liquidity: u64);
 
     // User account operations
-    fn get_max_positions() -> u16;
-    fn withdraw_balances(account_id: &AccountIdType, tao: u64, alpha: u64) -> (u64, u64);
-    fn deposit_balances(account_id: &AccountIdType, tao: u64, alpha: u64);
-    fn get_position_count(account_id: &AccountIdType) -> u16;
-    fn get_position(account_id: &AccountIdType, position_id: u16) -> Option<Position>;
-    fn create_position(account_id: &AccountIdType, positions: Position);
-    fn update_position(account_id: &AccountIdType, position_id: u16, positions: Position);
-    fn remove_position(account_id: &AccountIdType, position_id: u16);
+    fn get_max_positions(&self) -> u16;
+    fn withdraw_balances(&self, account_id: &AccountIdType, tao: u64, alpha: u64) -> (u64, u64);
+    fn deposit_balances(&self, account_id: &AccountIdType, tao: u64, alpha: u64);
+    fn get_position_count(&self, account_id: &AccountIdType) -> u16;
+    fn get_position(&self, account_id: &AccountIdType, position_id: u16) -> Option<Position>;
+    fn create_position(&self, account_id: &AccountIdType, positions: Position);
+    fn update_position(&self, account_id: &AccountIdType, position_id: u16, positions: Position);
+    fn remove_position(&self, account_id: &AccountIdType, position_id: u16);
 }
 
 /// All main swapping logic abstracted from Runtime implementation is concentrated
@@ -188,7 +195,7 @@ where
     AccountIdType: Eq,
     Ops: SwapDataOperations<AccountIdType>,
 {
-    pub fn new(ops: Ops) -> Self {
+    pub fn new(_ops: Ops) -> Self {
         // if !ops.is_v3_initialized() {
         //     // TODO: Initialize the v3
         //     // Set price, set initial (protocol owned) liquidity and positions, etc.
@@ -203,7 +210,7 @@ where
     ///
     /// Returns (Alpha, Liquidity) tuple
     ///
-    pub fn get_tao_based_liquidity(&self, tao: u64) -> (u64, u64) {
+    pub fn get_tao_based_liquidity(&self, _tao: u64) -> (u64, u64) {
         // let current_price = self.state_ops.get_alpha_sqrt_price();
         todo!()
     }
@@ -213,7 +220,7 @@ where
     ///
     /// Returns (TAO, Liquidity) tuple
     ///
-    pub fn get_alpha_based_liquidity(&self, alpha: u64) -> (u64, u64) {
+    pub fn get_alpha_based_liquidity(&self, _alpha: u64) -> (u64, u64) {
         // let current_price = self.state_ops.get_alpha_sqrt_price();
 
         todo!()
@@ -221,7 +228,7 @@ where
 
     /// Add liquidity at tick index. Creates new tick if it doesn't exist
     ///
-    fn add_liquidity_at_index(tick_index: u64, liquidity: u64, upper: bool) {
+    fn add_liquidity_at_index(&self, tick_index: u64, liquidity: u64, upper: bool) {
         // Calculate net liquidity addition
         let net_addition = if upper {
             (liquidity as i128).neg()
@@ -230,27 +237,28 @@ where
         };
 
         // Find tick by index
-        let new_tick = if let Some(tick) = self.state_ops.get_tick_by_index(tick_index) {
+        let new_tick = if let Some(mut tick) = self.state_ops.get_tick_by_index(tick_index) {
             tick.liquidity_net = tick.liquidity_net.saturating_add(net_addition);
             tick.liquidity_gross = tick.liquidity_gross.saturating_add(liquidity);
+            tick
         } else {
             // Create a new tick
             Tick {
                 liquidity_net: net_addition,
                 liquidity_gross: liquidity,
-                fees_out_tao: 0_u64,
-                fees_out_alpha: 0_u64,
+                fees_out_tao: U64F64::saturating_from_num(0),
+                fees_out_alpha: U64F64::saturating_from_num(0),
             }
         };
 
-        // // TODO: Review why Python code uses this code to find index for the new ticks:
-        // // self.get_tick_index(user_position[0]) + 1
-        // self.state_ops.insert_tick_by_index(tick_index, new_tick);
+        // TODO: Review why Python code uses this code to find index for the new ticks:
+        // self.get_tick_index(user_position[0]) + 1
+        self.state_ops.insert_tick_by_index(tick_index, new_tick);
     }
 
     /// Remove liquidity at tick index.
     ///
-    fn remove_liquidity_at_index(tick_index: u64, liquidity: u64, upper: bool) {
+    fn remove_liquidity_at_index(&self, tick_index: u64, liquidity: u64, upper: bool) {
         // Calculate net liquidity addition
         let net_reduction = if upper {
             (liquidity as i128).neg()
@@ -259,17 +267,17 @@ where
         };
 
         // Find tick by index
-        let new_tick = if let Some(tick) = self.state_ops.get_tick_by_index(tick_index) {
+        if let Some(mut tick) = self.state_ops.get_tick_by_index(tick_index) {
             tick.liquidity_net = tick.liquidity_net.saturating_sub(net_reduction);
             tick.liquidity_gross = tick.liquidity_gross.saturating_sub(liquidity);
-        };
 
-        // // If any liquidity is left at the tick, update it, otherwise remove
-        // if tick.liquidity_gross == 0 {
-        //     self.state_ops.remove_tick(tick_index);
-        // } else {
-        //     self.state_ops.insert_tick_by_index(tick_index, new_tick);
-        // }
+            // If any liquidity is left at the tick, update it, otherwise remove
+            if tick.liquidity_gross == 0 {
+                self.state_ops.remove_tick_by_index(tick_index);
+            } else {
+                self.state_ops.insert_tick_by_index(tick_index, tick);
+            }
+        };
     }
 
     /// Add liquidity
@@ -287,56 +295,59 @@ where
         tick_high: u64,
         liquidity: u64,
     ) -> Result<u64, ()> {
-        // // Check if we can add a position
-        // let position_count = self.state_ops.get_position_count(account_id);
-        // let max_positions = get_max_positions();
-        // if position_count >= max_positions {
-        //     return Err(());
-        // }
-
-        // // Add liquidity at tick
-        // self.add_liquidity_at_index(tick_low, liquidity, false);
-        // self.add_liquidity_at_index(tick_high, liquidity, true);
-
-        // // Update current tick and liquidity
-        // // TODO: Review why python uses this code to get the new tick index:
-        // // k = self.get_tick_index(i)
-        // let current_price = self.state_ops.get_alpha_sqrt_price();
-        // let current_tick_index = Position::sqrt_price_to_tick_index(current_price);
-
-        // Update current tick liquidity
-        if (tick_low <= current_tick_index) && (current_tick_index <= tick_high) {
-            let new_current_liquidity = self
-                .state_ops
-                .get_current_liquidity()
-                .saturating_add(liquidity);
-            self.state_ops.set_current_liquidity(new_current_liquidity);
+        // Check if we can add a position
+        let position_count = self.state_ops.get_position_count(account_id);
+        let max_positions = self.state_ops.get_max_positions();
+        if position_count >= max_positions {
+            return Err(());
         }
 
-        // Update balances
-        let position = Position {
-            tick_low,
-            tick_high,
-            liquidity,
-            fees_tao: 0_u64,
-            fees_alpha: 0_u64,
-        };
-        let (tao, alpha) = position.to_token_amounts(current_tick_index);
-        self.state_ops.withdraw_balances(account_id, tao, alpha);
+        // Add liquidity at tick
+        self.add_liquidity_at_index(tick_low, liquidity, false);
+        self.add_liquidity_at_index(tick_high, liquidity, true);
 
-        // // Update reserves
-        // let new_tao_reserve = self.state_ops.get_tao_reserve().saturating_add(tao);
-        // self.state_ops.set_tao_reserve(new_tao_reserve);
-        // let new_alpha_reserve = self.get_alpha_reserve().saturating_add(alpha);
-        // self.state_ops.set_alpha_reserve(new_alpha);
+        // Update current tick and liquidity
+        // TODO: Review why python uses this code to get the new tick index:
+        // k = self.get_tick_index(i)
+        let current_price = self.state_ops.get_alpha_sqrt_price();
+        let maybe_current_tick_index = Position::sqrt_price_to_tick_index(current_price.into());
 
-        // Update user positions
-        let position_id = position_count.saturating_add(1);
-        self.state_ops
-            .set_position(account_id, position_id, position);
+        if let Ok(current_tick_index) = maybe_current_tick_index {
+            // Update current tick liquidity
+            if (tick_low <= current_tick_index as u64) && (current_tick_index as u64 <= tick_high) {
+                let new_current_liquidity = self
+                    .state_ops
+                    .get_current_liquidity()
+                    .saturating_add(liquidity);
+                self.state_ops.set_current_liquidity(new_current_liquidity);
+            }
 
-        // Ok(liquidity)
-        todo!()
+            // Update balances
+            let position = Position {
+                tick_low,
+                tick_high,
+                liquidity,
+                fees_tao: 0_u64,
+                fees_alpha: 0_u64,
+            };
+            let (tao, alpha) = position.to_token_amounts(current_tick_index as u64);
+            self.state_ops.withdraw_balances(account_id, tao, alpha);
+
+            // Update reserves
+            let new_tao_reserve = self.state_ops.get_tao_reserve().saturating_add(tao);
+            self.state_ops.set_tao_reserve(new_tao_reserve);
+            let new_alpha_reserve = self.state_ops.get_alpha_reserve().saturating_add(alpha);
+            self.state_ops.set_alpha_reserve(new_alpha_reserve);
+
+            // Update user positions
+            let position_id = position_count.saturating_add(1);
+            self.state_ops
+                .update_position(account_id, position_id, position);
+
+            Ok(liquidity)
+        } else {
+            Err(())
+        }
     }
 
     /// Remove liquidity and credit balances back to account_id
@@ -349,44 +360,49 @@ where
         position_id: u16,
     ) -> Result<RemoveLiquidityResult, ()> {
         // Check if position exists
-        if let Some(pos) = self.state_ops.get_position(account_id, position_id) {
+        if let Some(mut pos) = self.state_ops.get_position(account_id, position_id) {
             // Get current price
             let current_price = self.state_ops.get_alpha_sqrt_price();
-            let current_tick_index = Position::sqrt_price_to_tick_index(current_price);
+            let maybe_current_tick_index = Position::sqrt_price_to_tick_index(current_price);
+
+            if let Ok(current_tick_index) = maybe_current_tick_index {
+                // Collect fees and get tao and alpha amounts
+                let (fee_tao, fee_alpha) = self.collect_fees(&mut pos);
+                let (tao, alpha) = pos.to_token_amounts(current_tick_index as u64);
+
+                // Update liquidity at position ticks
+                self.remove_liquidity_at_index(pos.tick_low, pos.liquidity, false);
+                self.remove_liquidity_at_index(pos.tick_high, pos.liquidity, true);
+
+                // Update current tick liquidity
+                if (pos.tick_low <= current_tick_index as u64)
+                    && (current_tick_index as u64 <= pos.tick_high)
+                {
+                    let new_current_liquidity = self
+                        .state_ops
+                        .get_current_liquidity()
+                        .saturating_sub(pos.liquidity);
+                    self.state_ops.set_current_liquidity(new_current_liquidity);
+                }
 
-            // Collect fees and get tao and alpha amounts
-            let (fee_tao, fee_alpha) = self.collect_fees(pos);
-            let (tao, alpha) = pos.to_token_amounts(current_tick_index);
+                // Remove user position
+                self.state_ops.remove_position(account_id, position_id);
 
-            // Update liquidity at position ticks
-            self.remove_liquidity_at_index(pos.tick_low, pos.liquidity, false);
-            self.remove_liquidity_at_index(pos.tick_high, pos.liquidity, true);
+                // TODO: Clear with R&D
+                // Update current price (why?)
+                // self.state_ops.set_alpha_sqrt_price(sqrt_price);
 
-            // Update current tick liquidity
-            if (pos.tick_low <= current_tick_index) && (current_tick_index <= pos.tick_high) {
-                let new_current_liquidity = self
-                    .state_ops
-                    .get_current_liquidity()
-                    .saturating_sub(liquidity);
-                self.state_ops.set_current_liquidity(new_current_liquidity);
+                // Return Ok result
+                Ok(RemoveLiquidityResult {
+                    tao,
+                    alpha,
+                    fee_tao,
+                    fee_alpha,
+                })
+            } else {
+                // Current price is broken
+                Err(())
             }
-
-            // Remove user position
-            self.state_ops.remove_position(account_id, position_id);
-
-            // Update current price (why?)
-            // i = self.sqrt_price_to_tick(self.sqrt_price_curr)
-            // k = self.get_tick_index(i)
-            // self.i_curr = self.active_ticks[k]
-            todo!();
-
-            // Return Ok result
-            Ok(RemoveLiquidityResult {
-                tao,
-                alpha,
-                fee_tao,
-                fee_alpha,
-            })
         } else {
             // Position doesn't exist
             Err(())
@@ -409,11 +425,12 @@ where
         // If order_type is Buy, then it expresses Tao amount, if it is Sell,
         // then amount_remaining is Alpha.
         let mut amount_remaining = amount;
-        let mut amount_paid_out = 0;
+        let mut amount_paid_out: u64 = 0;
+        let mut refund: u64 = 0;
 
         // A bit of fool proofing
-        let mut iteration_counter = 0;
-        let iter_limit = 1000;
+        let mut iteration_counter: u16 = 0;
+        let iter_limit: u16 = 1000;
 
         // Swap one tick at a time until we reach one of the following conditions:
         //   - Swap all provided amount
@@ -423,15 +440,16 @@ where
             let sqrt_price_edge = self.get_sqrt_price_edge(order_type);
             let possible_delta_in =
                 amount_remaining.saturating_sub(self.get_fee_amount(amount_remaining));
+            let sqrt_price_target = self.get_sqrt_price_target(order_type, possible_delta_in);
             let target_quantity = self.get_target_quantity(order_type, possible_delta_in);
             let edge_quantity = U64F64::saturating_from_num(1).safe_div(sqrt_price_edge.into());
             let lim_quantity = one
                 .safe_div(self.state_ops.get_min_sqrt_price())
                 .saturating_add(one.safe_div(sqrt_price_limit.into()));
 
-            let mut action: SwapStepAction;
-            let mut delta_in;
-            let mut final_price;
+            let action: SwapStepAction;
+            let delta_in;
+            let final_price;
             let mut stop_and_refund = false;
 
             if target_quantity < edge_quantity {
@@ -443,8 +461,8 @@ where
                 } else {
                     // stop_in at price limit
                     action = SwapStepAction::StopIn;
-                    delta_in = self.get_delta_in(order_type, sqrt_price_lim);
-                    final_price = sqrt_price_lim;
+                    delta_in = self.get_delta_in(order_type, sqrt_price_limit);
+                    final_price = sqrt_price_limit;
                     stop_and_refund = true;
                 }
             } else if target_quantity > edge_quantity {
@@ -456,13 +474,13 @@ where
                 } else if edge_quantity > lim_quantity {
                     // stop_in at price limit
                     action = SwapStepAction::StopIn;
-                    delta_in = self.get_delta_in(zero_for_one, sqrt_price_lim);
-                    final_price = sqrt_price_lim;
+                    delta_in = self.get_delta_in(order_type, sqrt_price_limit);
+                    final_price = sqrt_price_limit;
                     stop_and_refund = true;
                 } else {
                     // stop_on at price limit
                     action = SwapStepAction::StopOn;
-                    delta_in = self.get_delta_in(zero_for_one, sqrt_price_edge);
+                    delta_in = self.get_delta_in(order_type, sqrt_price_edge);
                     final_price = sqrt_price_edge;
                     stop_and_refund = true;
                 }
@@ -470,7 +488,7 @@ where
                 // targetQuantity = edgeQuantity
                 if target_quantity <= lim_quantity {
                     // stop_on at price edge
-                    delta_in = self.get_delta_in(zero_for_one, sqrt_price_edge);
+                    delta_in = self.get_delta_in(order_type, sqrt_price_edge);
                     final_price = sqrt_price_edge;
                     action = if delta_in > 0 {
                         SwapStepAction::StopOn
@@ -481,16 +499,15 @@ where
                     // targetQuantity > limQuantity
                     // stop_in at price lim
                     action = SwapStepAction::StopIn;
-                    delta_in = self.get_delta_in(zero_for_one, sqrt_price_lim);
-                    final_price = sqrt_price_lim;
+                    delta_in = self.get_delta_in(order_type, sqrt_price_limit);
+                    final_price = sqrt_price_limit;
                     stop_and_refund = true;
                 }
             }
 
-            let (amount_to_take, delta_out) =
-                self.swap_step(zero_for_one, delta_in, final_price, action);
-            amount_remaining = amount_remaining.saturating_sub(amount_to_take);
-            amount_paid_out = amount_paid_out.saturating_add(delta_out);
+            let swap_result = self.swap_step(order_type, delta_in, final_price, action);
+            amount_remaining = amount_remaining.saturating_sub(swap_result.amount_to_take);
+            amount_paid_out = amount_paid_out.saturating_add(swap_result.delta_out);
 
             if stop_and_refund {
                 refund = amount_remaining;
@@ -517,67 +534,125 @@ where
         delta_in: u64,
         sqrt_price_final: SqrtPrice,
         action: SwapStepAction,
-    ) -> SwapResult {
+    ) -> SwapStepResult {
         // amount_swapped = delta_in / (1 - self.fee_size)
-        let fee_rate = self.state_ops.get_fee_rate();
+        let fee_rate = U64F64::saturating_from_num(self.state_ops.get_fee_rate());
         let u16_max = U64F64::saturating_from_num(u16::MAX);
         let delta_fixed = U64F64::saturating_from_num(delta_in);
         let amount_swapped =
-            delta_fixed.saturating_mul(u16_max.safe_div(u16_max.saturagin_sub(fee_rate)));
+            delta_fixed.saturating_mul(u16_max.safe_div(u16_max.saturating_sub(fee_rate)));
 
         // Hold the fees
-        let fee = self.get_fee_amount(amount_swapped);
-        self.add_fees(zero_for_one, fee);
-        delta_out = self.convert_deltas(zero_for_one, delta_in);
+        let fee = self.get_fee_amount(amount_swapped.saturating_to_num::<u64>());
+        self.add_fees(order_type, fee);
+        let delta_out = self.convert_deltas(order_type, delta_in);
 
-        todo!()
-        // self.update_reserves(zero_for_one, delta_in, delta_out)
-        // self.sqrt_price_curr = sqrt_price_final
-
-        // if action == "crossing":
-        //     if zero_for_one:
-        //         k = self.get_tick_index(self.i_curr)
-        //         old_value = self.fee_outside0[k]
-        //         new_value = self.fee_global0 - old_value
-        //         self.fee_outside0[k] = new_value
-        //         self.fee_outside1[k] = self.fee_global1 - self.fee_outside1[k]
-        //         self.update_liquidity_at_crossing(zero_for_one)
-        //         self.i_curr = self.active_ticks[k - 1]
-        //     else:
-        //         k = self.get_tick_index(self.i_curr)
-        //         self.fee_outside0[k + 1] = self.fee_global0 - self.fee_outside0[k + 1]
-        //         self.fee_outside1[k + 1] = self.fee_global1 - self.fee_outside1[k + 1]
-        //         self.update_liquidity_at_crossing(zero_for_one)
-        //         self.i_curr = self.active_ticks[k + 1]
-        //     if self.print_stuff:
-        //         print(f"crossing tick into i={self.i_curr}")
-        // elif action == "stop_on":
-        //     if not zero_for_one:
-        //         self.update_liquidity_at_crossing(zero_for_one)
-        //         k = self.get_tick_index(self.i_curr)
-        //         self.fee_outside0[k + 1] = self.fee_global0 - self.fee_outside0[k + 1]
-        //         self.fee_outside1[k + 1] = self.fee_global1 - self.fee_outside1[k + 1]
-        //         self.i_curr = self.active_ticks[k + 1]
-        //     if self.print_stuff:
-        //         print(f"stopping ON i={self.i_curr}")
-        // else:  # stop_in
-        //     if self.print_stuff:
-        //         print(f"stopping IN i={self.i_curr}")
-
-        // return amount_to_take, delta_out
+        self.update_reserves(order_type, delta_in, delta_out);
+
+        // Get current tick
+        let current_price = self.state_ops.get_alpha_sqrt_price();
+        let maybe_current_tick_index = Position::sqrt_price_to_tick_index(current_price);
+        let current_tick_index;
+        if let Ok(index) = maybe_current_tick_index {
+            current_tick_index = index;
+        } else {
+            return SwapStepResult {
+                amount_to_take: 0,
+                delta_out: 0,
+            };
+        }
+
+        match action {
+            SwapStepAction::Crossing => {
+                let mut tick = match order_type {
+                    OrderType::Sell => {
+                        // TODO: Review if non-existing current tick is possible
+                        self.state_ops
+                            .get_tick_by_index(current_tick_index as u64)
+                            .unwrap_or_default()
+                    }
+                    OrderType::Buy => {
+                        // TODO: Active vs all ticks. Just + 1 doesn't work right now
+                        self.state_ops
+                            .get_tick_by_index((current_tick_index + 1) as u64)
+                            .unwrap_or_default()
+                    }
+                };
+                tick.fees_out_tao = self
+                    .state_ops
+                    .get_fee_global_tao()
+                    .saturating_sub(tick.fees_out_tao);
+                tick.fees_out_alpha = self
+                    .state_ops
+                    .get_fee_global_alpha()
+                    .saturating_sub(tick.fees_out_alpha);
+                self.update_liquidity_at_crossing(order_type);
+                self.state_ops
+                    .insert_tick_by_index(current_tick_index as u64, tick);
+            }
+            SwapStepAction::StopOn => {
+                match order_type {
+                    OrderType::Sell => {}
+                    OrderType::Buy => {
+                        self.update_liquidity_at_crossing(order_type);
+
+                        // TODO: Active vs all ticks. Just + 1 doesn't work right now
+                        let mut tick = self
+                            .state_ops
+                            .get_tick_by_index((current_tick_index + 1) as u64)
+                            .unwrap_or_default();
+
+                        tick.fees_out_tao = self
+                            .state_ops
+                            .get_fee_global_tao()
+                            .saturating_sub(tick.fees_out_tao);
+                        tick.fees_out_alpha = self
+                            .state_ops
+                            .get_fee_global_alpha()
+                            .saturating_sub(tick.fees_out_alpha);
+                        self.state_ops
+                            .insert_tick_by_index(current_tick_index as u64, tick);
+                    }
+                }
+            }
+            SwapStepAction::StopIn => {}
+        }
+
+        // Update current price, which effectively updates current tick too
+        self.state_ops.set_alpha_sqrt_price(sqrt_price_final);
+
+        SwapStepResult {
+            amount_to_take: amount_swapped.saturating_to_num::<u64>(),
+            delta_out,
+        }
     }
 
     /// Get the square root price at the current tick edge for the given direction (order type)
     /// If order type is Buy, then price edge is the high tick bound price, otherwise it is
     /// the low tick bound price.
     ///
-    fn get_sqrt_price_edge(&self, order_type: &OrderType) {
-        let current_price = self.state_ops.get_alpha_sqrt_price();
-        let current_tick_index = Position::sqrt_price_to_tick_index(current_price);
-        Position::tick_index_to_sqrt_price(match order_type {
-            OrderType::Buy => current_tick_index.saturating_add(1),
-            OrderType::Sell => current_tick_index,
+    /// If anything is wrong with tick math and it returns Err, we just abort the deal, i.e.
+    /// return the edge that is impossible to execute
+    ///
+    fn get_sqrt_price_edge(&self, order_type: &OrderType) -> SqrtPrice {
+        let fallback_price_edge_value = (match order_type {
+            OrderType::Buy => Position::tick_index_to_sqrt_price(MIN_TICK),
+            OrderType::Sell => Position::tick_index_to_sqrt_price(MAX_TICK),
         })
+        .unwrap_or(SqrtPrice::saturating_from_num(0));
+
+        let current_price = self.state_ops.get_alpha_sqrt_price();
+        let maybe_current_tick_index = Position::sqrt_price_to_tick_index(current_price);
+
+        if let Ok(current_tick_index) = maybe_current_tick_index {
+            Position::tick_index_to_sqrt_price(match order_type {
+                OrderType::Buy => current_tick_index.saturating_add(1),
+                OrderType::Sell => current_tick_index,
+            })
+            .unwrap_or(fallback_price_edge_value)
+        } else {
+            fallback_price_edge_value
+        }
     }
 
     /// Calculate fee amount
@@ -585,9 +660,9 @@ where
     /// Fee is provided by state ops as u16-normalized value.
     ///
     fn get_fee_amount(&self, amount: u64) -> u64 {
-        let fee_rate = U64I64::saturating_from_num(self.state_ops.get_fee_rate())
-            .save_div(U64I64::saturating_from_num(u16::MAX));
-        U64I64::saturating_from_num(amount)
+        let fee_rate = U64F64::saturating_from_num(self.state_ops.get_fee_rate())
+            .safe_div(U64F64::saturating_from_num(u16::MAX));
+        U64F64::saturating_from_num(amount)
             .saturating_mul(fee_rate)
             .saturating_to_num::<u64>()
     }
@@ -596,8 +671,36 @@ where
     /// safe range
     ///
     fn get_safe_current_liquidity(&self) -> U64F64 {
-        U64F64::saturating_from_num(self.state_ops.get_current_liquidity())
-            .saturating_sub(self.state_ops.get_minimum_liquidity())
+        U64F64::saturating_from_num(
+            self.state_ops
+                .get_current_liquidity()
+                .saturating_sub(self.state_ops.get_minimum_liquidity()),
+        )
+    }
+
+    /// Get the target square root price based on the input amount
+    ///
+    fn get_sqrt_price_target(&self, order_type: &OrderType, delta_in: u64) -> SqrtPrice {
+        let liquidity_curr = self.get_safe_current_liquidity();
+        let sqrt_price_curr = self.state_ops.get_alpha_sqrt_price().into();
+        let delta_fixed = U64F64::saturating_from_num(delta_in);
+        let one = U64F64::saturating_from_num(1);
+
+        if liquidity_curr > 0 {
+            match order_type {
+                OrderType::Buy => one.safe_div(
+                    delta_fixed
+                        .safe_div(liquidity_curr)
+                        .saturating_add(one.safe_div(sqrt_price_curr)),
+                ),
+                OrderType::Sell => delta_fixed
+                    .safe_div(liquidity_curr)
+                    .saturating_add(sqrt_price_curr),
+            }
+        } else {
+            // No liquidity means price should remain current
+            sqrt_price_curr
+        }
     }
 
     /// Get the target quantity, which is
@@ -606,7 +709,7 @@ where
     ///
     /// ...based on the input amount, current liquidity, and current alpha price
     ///
-    fn get_target_quantity(self, order_type: &OrderType, delta_in: u64) -> SqrtPrice {
+    fn get_target_quantity(&self, order_type: &OrderType, delta_in: u64) -> SqrtPrice {
         let liquidity_curr = self.get_safe_current_liquidity();
         let sqrt_price_curr = self.state_ops.get_alpha_sqrt_price().into();
         let delta_fixed = U64F64::saturating_from_num(delta_in);
@@ -625,18 +728,18 @@ where
             }
         } else {
             // No liquidity means zero
-            0.into()
+            SqrtPrice::saturating_from_num(0)
         }
     }
 
     /// Get the input amount needed to reach the target price
     ///
-    fn get_delta_in(&self, order_type: &OrderType, sqrt_price_target: SqrtPrice) {
+    fn get_delta_in(&self, order_type: &OrderType, sqrt_price_target: SqrtPrice) -> u64 {
         let liquidity_curr = self.get_safe_current_liquidity();
         let one = U64F64::saturating_from_num(1);
         let sqrt_price_curr = self.state_ops.get_alpha_sqrt_price().into();
 
-        match order_type {
+        (match order_type {
             OrderType::Sell => liquidity_curr.saturating_mul(
                 one.safe_div(sqrt_price_target.into())
                     .saturating_sub(one.safe_div(sqrt_price_curr)),
@@ -644,25 +747,27 @@ where
             OrderType::Buy => {
                 liquidity_curr.saturating_mul(sqrt_price_target.saturating_sub(sqrt_price_curr))
             }
-        }
+        })
+        .saturating_to_num::<u64>()
     }
 
     /// Add fees to the global fee counters
     fn add_fees(&self, order_type: &OrderType, fee: u64) {
         let liquidity_curr = self.get_safe_current_liquidity();
         if liquidity_curr > 0 {
-            let fee_global_tao = self.state_ops.get_fee_global_tao();
-            let fee_global_alpha = self.state_ops.get_fee_global_alpha();
+            let fee_global_tao: U64F64 = self.state_ops.get_fee_global_tao();
+            let fee_global_alpha: U64F64 = self.state_ops.get_fee_global_alpha();
+            let fee_fixed: U64F64 = U64F64::saturating_from_num(fee);
 
             match order_type {
                 OrderType::Sell => {
                     self.state_ops.set_fee_global_tao(
-                        fee_global_tao.saturating_add(fee.safe_div(liquidity_curr)),
+                        fee_global_tao.saturating_add(fee_fixed.safe_div(liquidity_curr)),
                     );
                 }
                 OrderType::Buy => {
                     self.state_ops.set_fee_global_alpha(
-                        fee_global_alpha.saturating_add(fee.safe_div(liquidity_curr)),
+                        fee_global_alpha.saturating_add(fee_fixed.safe_div(liquidity_curr)),
                     );
                 }
             }
@@ -675,108 +780,221 @@ where
     /// output token is given for an amount of input token within one
     /// price tick.
     ///
-    fn convert_deltas(self, order_type: &OrderType, delta_in: u64) {
-        let mut liquidity_curr: u64 = self.state_ops.get_current_liquidity();
-        let mut sqrt_price_curr = self.state_ops.get_alpha_sqrt_price().into();
-
-        // Prevent overflows:
-        // If liquidity or delta are too large, reduce their precision and
-        // save their factor for final correction. Price can take full U64F64
-        // range, and it will not overflow u128 divisions or multiplications.
-        let mut liquidity_factor: u64 = 1;
-        if liquidity_curr > u32::MAX as u64 {
-            liquidity_factor = u32::MAX as u64;
-            liquidity_curr = liquidity_curr.safe_div(liquidity_factor);
-        }
-        let mut delta = delta_in as u64;
-        let mut delta_factor: u64 = 1;
-        if delta > u32::MAX as u64 {
-            delta_factor = u32::MAX as u64;
-            delta = delta.safe_div(delta_factor);
-        }
+    fn convert_deltas(&self, order_type: &OrderType, delta_in: u64) -> u64 {
+        let liquidity_curr = SqrtPrice::saturating_from_num(self.state_ops.get_current_liquidity());
+        let sqrt_price_curr = self.state_ops.get_alpha_sqrt_price();
+        let delta_fixed = SqrtPrice::saturating_from_num(delta_in);
+
+        // TODO: Implement in safe and non-overflowing math
+        // Intentionally using unsafe math here to trigger CI
+
+        // // Prevent overflows:
+        // // If liquidity or delta are too large, reduce their precision and
+        // // save their factor for final correction. Price can take full U64F64
+        // // range, and it will not overflow u128 divisions or multiplications.
+        // let mut liquidity_factor: u64 = 1;
+        // if liquidity_curr > u32::MAX as u64 {
+        //     liquidity_factor = u32::MAX as u64;
+        //     liquidity_curr = liquidity_curr.safe_div(liquidity_factor);
+        // }
+        // let mut delta = delta_in as u64;
+        // let mut delta_factor: u64 = 1;
+        // if delta > u32::MAX as u64 {
+        //     delta_factor = u32::MAX as u64;
+        //     delta = delta.safe_div(delta_factor);
+        // }
 
-        // This product does not overflow because we limit both
-        // multipliers by u32::MAX (despite the u64 type)
-        let delta_liquidity = delta.saturating_mul(liquidity);
+        // // This product does not overflow because we limit both
+        // // multipliers by u32::MAX (despite the u64 type)
+        // let delta_liquidity = delta.saturating_mul(liquidity);
 
-        // This is product of delta_in * liquidity_curr * sqrt_price_curr
-        let delta_liquidity_price: u128 =
-            Self::mul_u64_u64f64(delta_liquidity, sqrt_price_curr.into());
+        // // This is product of delta_in * liquidity_curr * sqrt_price_curr
+        // let delta_liquidity_price: u128 =
+        //     Self::mul_u64_u64f64(delta_liquidity, sqrt_price_curr.into());
 
         if delta_in > 0 {
-            match order_type {
+            (match order_type {
                 OrderType::Sell => {
-                    todo!()
-                    // liquidity_curr.saturating_mul(sqrt_price_curr).saturating_mul(delta_in).safe_div(
-                    //     liquidity_curr.safe_div(sqrt_price_curr).saturating_add(delta_in)
-                    // )
+                    liquidity_curr * sqrt_price_curr * delta_fixed
+                        / (liquidity_curr / sqrt_price_curr + delta_fixed)
                 }
                 OrderType::Buy => {
-                    todo!()
-                    // (self.liquidity_curr / self.sqrt_price_curr * delta_in) / (
-                    //     self.liquidity_curr * self.sqrt_price_curr + delta_in
-                    // )
+                    liquidity_curr / sqrt_price_curr * delta_fixed
+                        / (liquidity_curr * sqrt_price_curr + delta_fixed)
                 }
-            }
+            })
+            .to_num::<u64>()
         } else {
             0
         }
     }
 
     /// Multiplies a `u64` by a `U64F64` and returns a `u128` result without overflow.
-    pub fn mul_u64_u64f64(a: u64, b: U64F64) -> u128 {
-        // Multiply a by integer part of b in integer math.
-        // Result doesn't overflow u128 because both multipliers are 64 bit
-        let int_b: u64 = b.saturating_to_num::<u64>();
-        let high = (a as u128).saturating_mul(int_b as u128);
-
-        // Multiply a by fractional part of b using U64F64
-        let frac_b = b.saturating_sub(U64F64::saturating_from_num(int_b));
-        let low = U64F64::saturating_from_num(a).saturating_mul(frac_b);
-
-        // The only possible overflow (that is cut off by saturating math)
-        // is when a is u64::MAX, int_b is u64::MAX, and frac_b is non-zero,
-        // which is negligible error if we saturate and return u128::MAX
-        high.saturating_add(low).saturating_to_num::<u128>()
+    // pub fn mul_u64_u64f64(a: u64, b: U64F64) -> u128 {
+    //     // Multiply a by integer part of b in integer math.
+    //     // Result doesn't overflow u128 because both multipliers are 64 bit
+    //     let int_b: u64 = b.saturating_to_num::<u64>();
+    //     let high = (a as u128).saturating_mul(int_b as u128);
+
+    //     // Multiply a by fractional part of b using U64F64
+    //     let frac_b = b.saturating_sub(U64F64::saturating_from_num(int_b));
+    //     let low = U64F64::saturating_from_num(a).saturating_mul(frac_b);
+
+    //     // The only possible overflow (that is cut off by saturating math)
+    //     // is when a is u64::MAX, int_b is u64::MAX, and frac_b is non-zero,
+    //     // which is negligible error if we saturate and return u128::MAX
+    //     high.saturating_add(low).saturating_to_num::<u128>()
+    // }
+
+    /// Update token reserves after a swap
+    ///
+    fn update_reserves(&self, order_type: &OrderType, amount_in: u64, amount_out: u64) {
+        let (new_tao_reserve, new_alpha_reserve) = match order_type {
+            OrderType::Sell => (
+                self.state_ops.get_tao_reserve().saturating_add(amount_in),
+                self.state_ops
+                    .get_alpha_reserve()
+                    .saturating_sub(amount_out),
+            ),
+            OrderType::Buy => (
+                self.state_ops.get_tao_reserve().saturating_sub(amount_in),
+                self.state_ops
+                    .get_alpha_reserve()
+                    .saturating_add(amount_out),
+            ),
+        };
+
+        self.state_ops.set_tao_reserve(new_tao_reserve);
+        self.state_ops.set_alpha_reserve(new_alpha_reserve);
     }
 
-    // def update_reserves(self, zero_for_one, amount_in, amount_out):
-    //     """Update token reserves after a swap"""
-    //     if zero_for_one:
-    //         self.reserves0 = self.reserves0 + amount_in
-    //         self.reserves1 = self.reserves1 - amount_out
-    //     else:
-    //         self.reserves0 = self.reserves0 - amount_out
-    //         self.reserves1 = self.reserves1 + amount_in
-
-    // def update_liquidity_at_crossing(self, zero_for_one):
-    //     """Update liquidity when crossing a tick"""
-    //     if zero_for_one:
-    //         k = self.get_tick_index(self.i_curr)
-    //         self.liquidity_curr = self.liquidity_curr - self.liquidity_net[k]
-    //     else:
-    //         k = self.get_tick_index(self.i_curr)
-    //         self.liquidity_curr = self.liquidity_curr + self.liquidity_net[k + 1]
+    fn get_liquidity_update_u64(&self, tick: &Tick) -> u64 {
+        let liquidity_update_abs_i128 = tick.liquidity_net.abs();
+        if liquidity_update_abs_i128 > u64::MAX as i128 {
+            u64::MAX
+        } else {
+            liquidity_update_abs_i128 as u64
+        }
+    }
+
+    /// Update liquidity when crossing a tick
+    ///
+    fn update_liquidity_at_crossing(&self, order_type: &OrderType) {
+        let mut liquidity_curr = self.state_ops.get_current_liquidity();
+        let current_price = self.state_ops.get_alpha_sqrt_price();
+        let maybe_current_tick_index = Position::sqrt_price_to_tick_index(current_price);
+        if let Ok(current_tick_index) = maybe_current_tick_index {
+            match order_type {
+                OrderType::Sell => {
+                    // TODO: Review if non-existing current tick is possible
+                    let tick = self
+                        .state_ops
+                        .get_tick_by_index(current_tick_index as u64)
+                        .unwrap_or_default();
+                    let liquidity_update_abs_u64 = self.get_liquidity_update_u64(&tick);
+
+                    liquidity_curr = if tick.liquidity_net >= 0 {
+                        liquidity_curr.saturating_sub(liquidity_update_abs_u64)
+                    } else {
+                        liquidity_curr.saturating_add(liquidity_update_abs_u64)
+                    };
+                }
+                OrderType::Buy => {
+                    // TODO: Active vs all ticks. Just + 1 doesn't work right now
+                    let tick = self
+                        .state_ops
+                        .get_tick_by_index((current_tick_index + 1) as u64)
+                        .unwrap_or_default();
+                    let liquidity_update_abs_u64 = self.get_liquidity_update_u64(&tick);
+
+                    liquidity_curr = if tick.liquidity_net >= 0 {
+                        liquidity_curr.saturating_add(liquidity_update_abs_u64)
+                    } else {
+                        liquidity_curr.saturating_sub(liquidity_update_abs_u64)
+                    };
+                }
+            }
+        }
+        self.state_ops.set_current_liquidity(liquidity_curr);
+    }
 
     /// Collect fees for a position
     /// Updates the position
     ///
     fn collect_fees(&self, position: &mut Position) -> (u64, u64) {
-        // liquidity = self.user_positions[user_idx, 2]
-        // fee0 = self.get_fees_in_range(user_idx, 0)
-        // fee1 = self.get_fees_in_range(user_idx, 1)
+        let mut fee_tao = self.get_fees_in_range(position, true);
+        let mut fee_alpha = self.get_fees_in_range(position, false);
+
+        fee_tao = fee_tao.saturating_sub(position.fees_tao);
+        fee_alpha = fee_alpha.saturating_sub(position.fees_alpha);
+
+        position.fees_tao = fee_tao;
+        position.fees_alpha = fee_alpha;
+
+        fee_tao = position.liquidity.saturating_mul(fee_tao);
+        fee_alpha = position.liquidity.saturating_mul(fee_alpha);
+
+        (fee_tao, fee_alpha)
+    }
+
+    /// Get fees in a position's range
+    ///
+    /// If quote flag is true, Tao is returned, otherwise alpha.
+    ///
+    fn get_fees_in_range(&self, position: &mut Position, quote: bool) -> u64 {
+        let i_lower = position.tick_low;
+        let i_upper = position.tick_high;
+
+        let fee_global = if quote {
+            self.state_ops.get_fee_global_tao()
+        } else {
+            self.state_ops.get_fee_global_alpha()
+        };
+
+        fee_global
+            .saturating_sub(self.get_fees_below(i_lower, quote))
+            .saturating_sub(self.get_fees_above(i_upper, quote))
+            .saturating_to_num::<u64>()
+    }
 
-        // fee0 = fee0 - self.user_positions[user_idx, 3]
-        // fee1 = fee1 - self.user_positions[user_idx, 4]
+    /// Get fees above a tick
+    ///
+    fn get_fees_above(&self, _tick_index: u64, _quote: bool) -> U64F64 {
+        // k = self.get_tick_index(i)
+        // i_arg = self.active_ticks[k]
+
+        // if i_arg <= self.i_curr:
+        //     if want_one:
+        //         fee = self.fee_global1 - self.fee_outside1[k]
+        //     else:
+        //         fee = self.fee_global0 - self.fee_outside0[k]
+        // else:
+        //     if want_one:
+        //         fee = self.fee_outside1[k]
+        //     else:
+        //         fee = self.fee_outside0[k]
 
-        // self.user_positions[user_idx, 3] = fee0
-        // self.user_positions[user_idx, 4] = fee1
+        // return fee
+        todo!()
+    }
 
-        // fee0 = liquidity * fee0
-        // fee1 = liquidity * fee1
+    /// Get fees below a tick
+    fn get_fees_below(&self, _tick_index: u64, _quote: bool) -> U64F64 {
+        // k = self.get_tick_index(i)
+        // i_arg = self.active_ticks[k]
 
-        // return fee0, fee1
+        // if i_arg <= self.i_curr:
+        //     if want_one:
+        //         fee = self.fee_outside1[k]
+        //     else:
+        //         fee = self.fee_outside0[k]
+        // else:
+        //     if want_one:
+        //         fee = self.fee_global1 - self.fee_outside1[k]
+        //     else:
+        //         fee = self.fee_global0 - self.fee_outside0[k]
 
+        // return fee
         todo!()
     }
 }
diff --git a/primitives/swap/src/tick_math.rs b/primitives/swap/src/tick_math.rs
index 685b98eb3a..6c8fef081f 100644
--- a/primitives/swap/src/tick_math.rs
+++ b/primitives/swap/src/tick_math.rs
@@ -37,8 +37,8 @@ const U256_524288: U256 = U256::from_limbs([524288, 0, 0, 0]);
 
 const U256_MAX_TICK: U256 = U256::from_limbs([887272, 0, 0, 0]);
 
-const MIN_TICK: i32 = -887272;
-const MAX_TICK: i32 = -MIN_TICK;
+pub const MIN_TICK: i32 = -887272;
+pub const MAX_TICK: i32 = -MIN_TICK;
 
 const MIN_SQRT_RATIO: U256 = U256::from_limbs([4295128739, 0, 0, 0]);
 const MAX_SQRT_RATIO: U256 =

From 18d056e64d92f1e9d0a88b447a8578a4fcfc2a5f Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Mon, 17 Mar 2025 20:52:33 +0100
Subject: [PATCH 016/418] Fix conversion and Fixed::checked_pow issues

---
 primitives/safe-math/src/lib.rs  |  2 +-
 primitives/swap/src/lib.rs       | 56 +++++++++++++++++++++++++++-----
 primitives/swap/src/tick_math.rs | 34 ++++++++++++++-----
 3 files changed, 74 insertions(+), 18 deletions(-)

diff --git a/primitives/safe-math/src/lib.rs b/primitives/safe-math/src/lib.rs
index 82e8e4ad96..cd7dc9a44a 100644
--- a/primitives/safe-math/src/lib.rs
+++ b/primitives/safe-math/src/lib.rs
@@ -62,7 +62,7 @@ pub trait FixedExt: Fixed {
             if exp & 1 != 0 {
                 result = result.saturating_mul(base);
             }
-            base = self.saturating_mul(base);
+            base = base.saturating_mul(base);
             exp >>= 1;
         }
 
diff --git a/primitives/swap/src/lib.rs b/primitives/swap/src/lib.rs
index bb17418ce2..29b8fd1cc7 100644
--- a/primitives/swap/src/lib.rs
+++ b/primitives/swap/src/lib.rs
@@ -66,8 +66,11 @@ impl Position {
     /// Converts tick index into SQRT of lower price of this tick
     /// In order to find the higher price of this tick, call
     /// tick_index_to_sqrt_price(tick_idx + 1)
-    ///
     pub fn tick_index_to_sqrt_price(tick_idx: i32) -> Result<SqrtPrice, TickMathError> {
+        // because of u256->u128 conversion we have twice less values for min/max ticks
+        if !(MIN_TICK / 2..=MAX_TICK / 2).contains(&tick_idx) {
+            return Err(TickMathError::TickOutOfBounds);
+        }
         get_sqrt_ratio_at_tick(tick_idx).and_then(u256_q64_96_to_u64f64)
     }
 
@@ -75,9 +78,15 @@ impl Position {
     /// Because the tick is the range of prices [sqrt_lower_price, sqrt_higher_price),
     /// the resulting tick index matches the price by the following inequality:
     ///    sqrt_lower_price <= sqrt_price < sqrt_higher_price
-    ///
     pub fn sqrt_price_to_tick_index(sqrt_price: SqrtPrice) -> Result<i32, TickMathError> {
-        get_tick_at_sqrt_ratio(u64f64_to_u256_q64_96(sqrt_price))
+        let tick = get_tick_at_sqrt_ratio(u64f64_to_u256_q64_96(sqrt_price))?;
+
+        // Correct for rounding error during conversions between different fixed-point formats
+        Ok(if tick == 0 {
+            tick
+        } else {
+            tick.saturating_add(1)
+        })
     }
 
     /// Converts position to token amounts
@@ -1007,23 +1016,38 @@ mod tests {
     fn test_tick_index_to_sqrt_price() {
         let tick_spacing = SqrtPrice::from_num(1.0001);
 
+        // check tick bounds
+        assert_eq!(
+            Position::tick_index_to_sqrt_price(MIN_TICK),
+            Err(TickMathError::TickOutOfBounds)
+        );
+
+        assert_eq!(
+            Position::tick_index_to_sqrt_price(MAX_TICK),
+            Err(TickMathError::TickOutOfBounds),
+        );
+
         // At tick index 0, the sqrt price should be 1.0
         let sqrt_price = Position::tick_index_to_sqrt_price(0).unwrap();
         assert_eq!(sqrt_price, SqrtPrice::from_num(1.0));
 
         let sqrt_price = Position::tick_index_to_sqrt_price(2).unwrap();
-        assert_eq!(sqrt_price, tick_spacing);
+        assert!(sqrt_price.abs_diff(tick_spacing) < SqrtPrice::from_num(1e-10));
 
         let sqrt_price = Position::tick_index_to_sqrt_price(4).unwrap();
         // Calculate the expected value: (1 + TICK_SPACING/1e9 + 1.0)^2
         let expected = tick_spacing * tick_spacing;
-        assert_eq!(sqrt_price, expected);
+        assert!(sqrt_price.abs_diff(expected) < SqrtPrice::from_num(1e-10));
 
         // Test with tick index 10
         let sqrt_price = Position::tick_index_to_sqrt_price(10).unwrap();
         // Calculate the expected value: (1 + TICK_SPACING/1e9 + 1.0)^5
-        let expected_sqrt_price_10 = tick_spacing.checked_pow(5).unwrap();
-        assert_eq!(sqrt_price, expected_sqrt_price_10);
+        let expected = tick_spacing.checked_pow(5).unwrap();
+        assert!(
+            sqrt_price.abs_diff(expected) < SqrtPrice::from_num(1e-10),
+            "diff: {}",
+            sqrt_price.abs_diff(expected),
+        );
     }
 
     #[test]
@@ -1049,7 +1073,23 @@ mod tests {
 
     #[test]
     fn test_roundtrip_tick_index_sqrt_price() {
-        for tick_index in [0, 2, 4, 10, 100, 1000].iter() {
+        for tick_index in [
+            MIN_TICK / 2,
+            -1000,
+            -100,
+            -10,
+            -4,
+            -2,
+            0,
+            2,
+            4,
+            10,
+            100,
+            1000,
+            MAX_TICK / 2,
+        ]
+        .iter()
+        {
             let sqrt_price = Position::tick_index_to_sqrt_price(*tick_index).unwrap();
             let round_trip_tick_index = Position::sqrt_price_to_tick_index(sqrt_price).unwrap();
             assert_eq!(round_trip_tick_index, *tick_index);
diff --git a/primitives/swap/src/tick_math.rs b/primitives/swap/src/tick_math.rs
index 6c8fef081f..3dfcb0d514 100644
--- a/primitives/swap/src/tick_math.rs
+++ b/primitives/swap/src/tick_math.rs
@@ -37,8 +37,8 @@ const U256_524288: U256 = U256::from_limbs([524288, 0, 0, 0]);
 
 const U256_MAX_TICK: U256 = U256::from_limbs([887272, 0, 0, 0]);
 
-pub const MIN_TICK: i32 = -887272;
-pub const MAX_TICK: i32 = -MIN_TICK;
+pub(crate) const MIN_TICK: i32 = -887272;
+pub(crate) const MAX_TICK: i32 = -MIN_TICK;
 
 const MIN_SQRT_RATIO: U256 = U256::from_limbs([4295128739, 0, 0, 0]);
 const MAX_SQRT_RATIO: U256 =
@@ -66,7 +66,7 @@ pub(crate) fn get_sqrt_ratio_at_tick(tick: i32) -> Result<U256, TickMathError> {
     };
 
     if abs_tick > U256_MAX_TICK {
-        return Err(TickMathError::TickTooHigh);
+        return Err(TickMathError::TickOutOfBounds);
     }
 
     let mut ratio = if abs_tick & (U256_1) != U256::ZERO {
@@ -322,9 +322,9 @@ pub(crate) fn u64f64_to_u256_q64_96(value: U64F64) -> U256 {
     u64f64_to_u256(value, 96)
 }
 
-#[derive(Debug)]
+#[derive(Debug, PartialEq, Eq)]
 pub enum TickMathError {
-    TickTooHigh,
+    TickOutOfBounds,
     SqrtPriceOutOfBounds,
     ConversionError,
     Overflow,
@@ -333,7 +333,7 @@ pub enum TickMathError {
 impl fmt::Display for TickMathError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> fmt::Result {
         match self {
-			Self::TickTooHigh => f.write_str("The given tick must be less than, or equal to, the maximum tick"),
+			Self::TickOutOfBounds => f.write_str("The given tick is outside of the minimum/maximum values."),
 			Self::SqrtPriceOutOfBounds =>f.write_str("Second inequality must be < because the price can never reach the price at the max tick"),
 			Self::ConversionError => f.write_str("Error converting from one number type into another"),
 			Self::Overflow => f.write_str("Number overflow in arithmetic operation")
@@ -352,12 +352,12 @@ mod test {
     fn test_get_sqrt_ratio_at_tick_bounds() {
         // the function should return an error if the tick is out of bounds
         if let Err(err) = get_sqrt_ratio_at_tick(MIN_TICK - 1) {
-            assert!(matches!(err, TickMathError::TickTooHigh));
+            assert!(matches!(err, TickMathError::TickOutOfBounds));
         } else {
             panic!("get_qrt_ratio_at_tick did not respect lower tick bound")
         }
         if let Err(err) = get_sqrt_ratio_at_tick(MAX_TICK + 1) {
-            assert!(matches!(err, TickMathError::TickTooHigh));
+            assert!(matches!(err, TickMathError::TickOutOfBounds));
         } else {
             panic!("get_qrt_ratio_at_tick did not respect upper tick bound")
         }
@@ -486,7 +486,23 @@ mod test {
 
     #[test]
     fn test_roundtrip() {
-        for tick_index in [0, 2, 4, 10, 100, 1000].iter() {
+        for tick_index in [
+            MIN_TICK + 1, // we can't use extremes because of rounding during roundtrip conversion
+            -1000,
+            -100,
+            -10,
+            -4,
+            -2,
+            0,
+            2,
+            4,
+            10,
+            100,
+            1000,
+            MAX_TICK - 1,
+        ]
+        .iter()
+        {
             let sqrt_price = get_sqrt_ratio_at_tick(*tick_index).unwrap();
             let round_trip_tick_index = get_tick_at_sqrt_ratio(sqrt_price).unwrap();
             assert_eq!(round_trip_tick_index, *tick_index);

From 340b69b521770a92036a1d38b631fd14f12c9f4c Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Tue, 18 Mar 2025 13:21:08 -0400
Subject: [PATCH 017/418] Refactor tick logic out of swap, add error handling
 to swap and liquidity operations

---
 primitives/swap/src/error.rs |  26 +++
 primitives/swap/src/lib.rs   | 440 ++++++++++++-----------------------
 primitives/swap/src/tick.rs  | 147 ++++++++++++
 3 files changed, 325 insertions(+), 288 deletions(-)
 create mode 100644 primitives/swap/src/error.rs
 create mode 100644 primitives/swap/src/tick.rs

diff --git a/primitives/swap/src/error.rs b/primitives/swap/src/error.rs
new file mode 100644
index 0000000000..748f6a740a
--- /dev/null
+++ b/primitives/swap/src/error.rs
@@ -0,0 +1,26 @@
+#[derive(Debug, PartialEq, Eq)]
+pub enum SwapError {
+    /// The provided amount is insufficient for the swap.
+    InsufficientInputAmount,
+
+    /// The provided liquidity is insufficient for the operation.
+    InsufficientLiquidity,
+
+    /// The operation would exceed the price limit.
+    PriceLimitExceeded,
+
+    /// The caller does not have enough balance for the operation.
+    InsufficientBalance,
+
+    /// Attempted to remove liquidity that does not exist.
+    LiquidityNotFound,
+
+    /// The provided tick range is invalid.
+    InvalidTickRange,
+
+    /// Maximum user positions exceeded
+    MaxPositionsExceeded,
+
+    /// Too many swap steps
+    TooManySwapSteps,
+}
diff --git a/primitives/swap/src/lib.rs b/primitives/swap/src/lib.rs
index 29b8fd1cc7..266abded83 100644
--- a/primitives/swap/src/lib.rs
+++ b/primitives/swap/src/lib.rs
@@ -4,11 +4,15 @@ use std::ops::Neg;
 use safe_math::*;
 use substrate_fixed::types::U64F64;
 
-use self::tick_math::{
-    MAX_TICK, MIN_TICK, TickMathError, get_sqrt_ratio_at_tick, get_tick_at_sqrt_ratio,
-    u64f64_to_u256_q64_96, u256_q64_96_to_u64f64,
+use self::error::SwapError;
+use self::tick::{
+    Tick, find_closest_higher_active_tick, find_closest_lower_active_tick,
+    sqrt_price_to_tick_index, tick_index_to_sqrt_price,
 };
+use self::tick_math::{MAX_TICK, MIN_TICK};
 
+mod error;
+mod tick;
 mod tick_math;
 
 type SqrtPrice = U64F64;
@@ -63,32 +67,6 @@ pub struct Position {
 }
 
 impl Position {
-    /// Converts tick index into SQRT of lower price of this tick
-    /// In order to find the higher price of this tick, call
-    /// tick_index_to_sqrt_price(tick_idx + 1)
-    pub fn tick_index_to_sqrt_price(tick_idx: i32) -> Result<SqrtPrice, TickMathError> {
-        // because of u256->u128 conversion we have twice less values for min/max ticks
-        if !(MIN_TICK / 2..=MAX_TICK / 2).contains(&tick_idx) {
-            return Err(TickMathError::TickOutOfBounds);
-        }
-        get_sqrt_ratio_at_tick(tick_idx).and_then(u256_q64_96_to_u64f64)
-    }
-
-    /// Converts SQRT price to tick index
-    /// Because the tick is the range of prices [sqrt_lower_price, sqrt_higher_price),
-    /// the resulting tick index matches the price by the following inequality:
-    ///    sqrt_lower_price <= sqrt_price < sqrt_higher_price
-    pub fn sqrt_price_to_tick_index(sqrt_price: SqrtPrice) -> Result<i32, TickMathError> {
-        let tick = get_tick_at_sqrt_ratio(u64f64_to_u256_q64_96(sqrt_price))?;
-
-        // Correct for rounding error during conversions between different fixed-point formats
-        Ok(if tick == 0 {
-            tick
-        } else {
-            tick.saturating_add(1)
-        })
-    }
-
     /// Converts position to token amounts
     ///
     /// returns tuple of (TAO, Alpha)
@@ -96,9 +74,9 @@ impl Position {
     pub fn to_token_amounts(&self, _current_tick: u64) -> (u64, u64) {
         // let one = 1.into();
 
-        // let sqrt_price_curr = Self::tick_index_to_sqrt_price(current_tick);
-        // let sqrt_pa = Self::tick_index_to_sqrt_price(self.tick_low);
-        // let sqrt_pb = Self::tick_index_to_sqrt_price(self.tick_high);
+        // let sqrt_price_curr = tick_index_to_sqrt_price(current_tick);
+        // let sqrt_pa = tick_index_to_sqrt_price(self.tick_low);
+        // let sqrt_pb = tick_index_to_sqrt_price(self.tick_high);
 
         // if sqrt_price_curr < sqrt_pa {
         //     (
@@ -121,22 +99,6 @@ impl Position {
     }
 }
 
-/// Tick is the price range determined by tick index (not part of this struct,
-/// but is the key at which the Tick is stored in state hash maps). Tick struct
-/// stores liquidity and fee information.
-///
-///   - Net liquidity
-///   - Gross liquidity
-///   - Fees (above global) in both currencies
-///
-#[derive(Default)]
-pub struct Tick {
-    liquidity_net: i128,
-    liquidity_gross: u64,
-    fees_out_tao: U64F64,
-    fees_out_alpha: U64F64,
-}
-
 /// This trait implementation depends on Runtime and it needs to be implemented
 /// in the pallet to be able to work with chain state and per subnet. All subnet
 /// swaps are independent and hence netuid is abstracted away from swap implementation.
@@ -303,12 +265,12 @@ where
         tick_low: u64,
         tick_high: u64,
         liquidity: u64,
-    ) -> Result<u64, ()> {
+    ) -> Result<u64, SwapError> {
         // Check if we can add a position
         let position_count = self.state_ops.get_position_count(account_id);
         let max_positions = self.state_ops.get_max_positions();
         if position_count >= max_positions {
-            return Err(());
+            return Err(SwapError::MaxPositionsExceeded);
         }
 
         // Add liquidity at tick
@@ -318,45 +280,40 @@ where
         // Update current tick and liquidity
         // TODO: Review why python uses this code to get the new tick index:
         // k = self.get_tick_index(i)
-        let current_price = self.state_ops.get_alpha_sqrt_price();
-        let maybe_current_tick_index = Position::sqrt_price_to_tick_index(current_price.into());
+        let current_tick_index = self.get_current_tick_index();
 
-        if let Ok(current_tick_index) = maybe_current_tick_index {
-            // Update current tick liquidity
-            if (tick_low <= current_tick_index as u64) && (current_tick_index as u64 <= tick_high) {
-                let new_current_liquidity = self
-                    .state_ops
-                    .get_current_liquidity()
-                    .saturating_add(liquidity);
-                self.state_ops.set_current_liquidity(new_current_liquidity);
-            }
+        // Update current tick liquidity
+        if (tick_low <= current_tick_index as u64) && (current_tick_index as u64 <= tick_high) {
+            let new_current_liquidity = self
+                .state_ops
+                .get_current_liquidity()
+                .saturating_add(liquidity);
+            self.state_ops.set_current_liquidity(new_current_liquidity);
+        }
 
-            // Update balances
-            let position = Position {
-                tick_low,
-                tick_high,
-                liquidity,
-                fees_tao: 0_u64,
-                fees_alpha: 0_u64,
-            };
-            let (tao, alpha) = position.to_token_amounts(current_tick_index as u64);
-            self.state_ops.withdraw_balances(account_id, tao, alpha);
-
-            // Update reserves
-            let new_tao_reserve = self.state_ops.get_tao_reserve().saturating_add(tao);
-            self.state_ops.set_tao_reserve(new_tao_reserve);
-            let new_alpha_reserve = self.state_ops.get_alpha_reserve().saturating_add(alpha);
-            self.state_ops.set_alpha_reserve(new_alpha_reserve);
-
-            // Update user positions
-            let position_id = position_count.saturating_add(1);
-            self.state_ops
-                .update_position(account_id, position_id, position);
+        // Update balances
+        let position = Position {
+            tick_low,
+            tick_high,
+            liquidity,
+            fees_tao: 0_u64,
+            fees_alpha: 0_u64,
+        };
+        let (tao, alpha) = position.to_token_amounts(current_tick_index as u64);
+        self.state_ops.withdraw_balances(account_id, tao, alpha);
 
-            Ok(liquidity)
-        } else {
-            Err(())
-        }
+        // Update reserves
+        let new_tao_reserve = self.state_ops.get_tao_reserve().saturating_add(tao);
+        self.state_ops.set_tao_reserve(new_tao_reserve);
+        let new_alpha_reserve = self.state_ops.get_alpha_reserve().saturating_add(alpha);
+        self.state_ops.set_alpha_reserve(new_alpha_reserve);
+
+        // Update user positions
+        let position_id = position_count.saturating_add(1);
+        self.state_ops
+            .update_position(account_id, position_id, position);
+
+        Ok(liquidity)
     }
 
     /// Remove liquidity and credit balances back to account_id
@@ -367,54 +324,48 @@ where
         &self,
         account_id: &AccountIdType,
         position_id: u16,
-    ) -> Result<RemoveLiquidityResult, ()> {
+    ) -> Result<RemoveLiquidityResult, SwapError> {
         // Check if position exists
         if let Some(mut pos) = self.state_ops.get_position(account_id, position_id) {
             // Get current price
-            let current_price = self.state_ops.get_alpha_sqrt_price();
-            let maybe_current_tick_index = Position::sqrt_price_to_tick_index(current_price);
-
-            if let Ok(current_tick_index) = maybe_current_tick_index {
-                // Collect fees and get tao and alpha amounts
-                let (fee_tao, fee_alpha) = self.collect_fees(&mut pos);
-                let (tao, alpha) = pos.to_token_amounts(current_tick_index as u64);
-
-                // Update liquidity at position ticks
-                self.remove_liquidity_at_index(pos.tick_low, pos.liquidity, false);
-                self.remove_liquidity_at_index(pos.tick_high, pos.liquidity, true);
-
-                // Update current tick liquidity
-                if (pos.tick_low <= current_tick_index as u64)
-                    && (current_tick_index as u64 <= pos.tick_high)
-                {
-                    let new_current_liquidity = self
-                        .state_ops
-                        .get_current_liquidity()
-                        .saturating_sub(pos.liquidity);
-                    self.state_ops.set_current_liquidity(new_current_liquidity);
-                }
+            let current_tick_index = self.get_current_tick_index();
 
-                // Remove user position
-                self.state_ops.remove_position(account_id, position_id);
+            // Collect fees and get tao and alpha amounts
+            let (fee_tao, fee_alpha) = self.collect_fees(&mut pos);
+            let (tao, alpha) = pos.to_token_amounts(current_tick_index as u64);
 
-                // TODO: Clear with R&D
-                // Update current price (why?)
-                // self.state_ops.set_alpha_sqrt_price(sqrt_price);
+            // Update liquidity at position ticks
+            self.remove_liquidity_at_index(pos.tick_low, pos.liquidity, false);
+            self.remove_liquidity_at_index(pos.tick_high, pos.liquidity, true);
 
-                // Return Ok result
-                Ok(RemoveLiquidityResult {
-                    tao,
-                    alpha,
-                    fee_tao,
-                    fee_alpha,
-                })
-            } else {
-                // Current price is broken
-                Err(())
+            // Update current tick liquidity
+            if (pos.tick_low <= current_tick_index as u64)
+                && (current_tick_index as u64 <= pos.tick_high)
+            {
+                let new_current_liquidity = self
+                    .state_ops
+                    .get_current_liquidity()
+                    .saturating_sub(pos.liquidity);
+                self.state_ops.set_current_liquidity(new_current_liquidity);
             }
+
+            // Remove user position
+            self.state_ops.remove_position(account_id, position_id);
+
+            // TODO: Clear with R&D
+            // Update current price (why?)
+            // self.state_ops.set_alpha_sqrt_price(sqrt_price);
+
+            // Return Ok result
+            Ok(RemoveLiquidityResult {
+                tao,
+                alpha,
+                fee_tao,
+                fee_alpha,
+            })
         } else {
             // Position doesn't exist
-            Err(())
+            Err(SwapError::LiquidityNotFound)
         }
     }
 
@@ -427,7 +378,7 @@ where
         order_type: &OrderType,
         amount: u64,
         sqrt_price_limit: SqrtPrice,
-    ) -> Result<SwapResult, ()> {
+    ) -> Result<SwapResult, SwapError> {
         let one = U64F64::saturating_from_num(1);
 
         // Here we store the remaining amount that needs to be exchanged
@@ -514,7 +465,7 @@ where
                 }
             }
 
-            let swap_result = self.swap_step(order_type, delta_in, final_price, action);
+            let swap_result = self.swap_step(order_type, delta_in, final_price, action)?;
             amount_remaining = amount_remaining.saturating_sub(swap_result.amount_to_take);
             amount_paid_out = amount_paid_out.saturating_add(swap_result.delta_out);
 
@@ -525,7 +476,7 @@ where
 
             iteration_counter = iteration_counter.saturating_add(1);
             if iteration_counter > iter_limit {
-                return Err(());
+                return Err(SwapError::TooManySwapSteps);
             }
         }
 
@@ -535,6 +486,28 @@ where
         })
     }
 
+    fn get_current_tick_index(&self) -> i32 {
+        let current_price = self.state_ops.get_alpha_sqrt_price();
+        let maybe_current_tick_index = sqrt_price_to_tick_index(current_price);
+        if let Ok(index) = maybe_current_tick_index {
+            index
+        } else {
+            // Current price is out of allow the min-max range, and it should be corrected to
+            // maintain the range.
+            let max_price =
+                tick_index_to_sqrt_price(MAX_TICK).unwrap_or(SqrtPrice::saturating_from_num(1000));
+            let min_price = tick_index_to_sqrt_price(MIN_TICK)
+                .unwrap_or(SqrtPrice::saturating_from_num(0.000001));
+            if current_price > max_price {
+                self.state_ops.set_alpha_sqrt_price(max_price);
+                MAX_TICK
+            } else {
+                self.state_ops.set_alpha_sqrt_price(min_price);
+                MIN_TICK
+            }
+        }
+    }
+
     /// Process a single step of a swap
     ///
     fn swap_step(
@@ -543,7 +516,7 @@ where
         delta_in: u64,
         sqrt_price_final: SqrtPrice,
         action: SwapStepAction,
-    ) -> SwapStepResult {
+    ) -> Result<SwapStepResult, SwapError> {
         // amount_swapped = delta_in / (1 - self.fee_size)
         let fee_rate = U64F64::saturating_from_num(self.state_ops.get_fee_rate());
         let u16_max = U64F64::saturating_from_num(u16::MAX);
@@ -559,58 +532,37 @@ where
         self.update_reserves(order_type, delta_in, delta_out);
 
         // Get current tick
-        let current_price = self.state_ops.get_alpha_sqrt_price();
-        let maybe_current_tick_index = Position::sqrt_price_to_tick_index(current_price);
-        let current_tick_index;
-        if let Ok(index) = maybe_current_tick_index {
-            current_tick_index = index;
-        } else {
-            return SwapStepResult {
-                amount_to_take: 0,
-                delta_out: 0,
-            };
-        }
+        let current_tick_index = self.get_current_tick_index();
 
         match action {
             SwapStepAction::Crossing => {
-                let mut tick = match order_type {
-                    OrderType::Sell => {
-                        // TODO: Review if non-existing current tick is possible
-                        self.state_ops
-                            .get_tick_by_index(current_tick_index as u64)
-                            .unwrap_or_default()
-                    }
-                    OrderType::Buy => {
-                        // TODO: Active vs all ticks. Just + 1 doesn't work right now
-                        self.state_ops
-                            .get_tick_by_index((current_tick_index + 1) as u64)
-                            .unwrap_or_default()
-                    }
+                let maybe_tick = match order_type {
+                    OrderType::Sell => find_closest_lower_active_tick(current_tick_index),
+                    OrderType::Buy => find_closest_higher_active_tick(current_tick_index),
                 };
-                tick.fees_out_tao = self
-                    .state_ops
-                    .get_fee_global_tao()
-                    .saturating_sub(tick.fees_out_tao);
-                tick.fees_out_alpha = self
-                    .state_ops
-                    .get_fee_global_alpha()
-                    .saturating_sub(tick.fees_out_alpha);
-                self.update_liquidity_at_crossing(order_type);
-                self.state_ops
-                    .insert_tick_by_index(current_tick_index as u64, tick);
+                if let Some(mut tick) = maybe_tick {
+                    tick.fees_out_tao = self
+                        .state_ops
+                        .get_fee_global_tao()
+                        .saturating_sub(tick.fees_out_tao);
+                    tick.fees_out_alpha = self
+                        .state_ops
+                        .get_fee_global_alpha()
+                        .saturating_sub(tick.fees_out_alpha);
+                    self.update_liquidity_at_crossing(order_type)?;
+                    self.state_ops
+                        .insert_tick_by_index(current_tick_index as u64, tick);
+                } else {
+                    return Err(SwapError::InsufficientLiquidity);
+                }
             }
-            SwapStepAction::StopOn => {
-                match order_type {
-                    OrderType::Sell => {}
-                    OrderType::Buy => {
-                        self.update_liquidity_at_crossing(order_type);
-
-                        // TODO: Active vs all ticks. Just + 1 doesn't work right now
-                        let mut tick = self
-                            .state_ops
-                            .get_tick_by_index((current_tick_index + 1) as u64)
-                            .unwrap_or_default();
+            SwapStepAction::StopOn => match order_type {
+                OrderType::Sell => {}
+                OrderType::Buy => {
+                    self.update_liquidity_at_crossing(order_type)?;
+                    let maybe_tick = find_closest_higher_active_tick(current_tick_index);
 
+                    if let Some(mut tick) = maybe_tick {
                         tick.fees_out_tao = self
                             .state_ops
                             .get_fee_global_tao()
@@ -621,19 +573,21 @@ where
                             .saturating_sub(tick.fees_out_alpha);
                         self.state_ops
                             .insert_tick_by_index(current_tick_index as u64, tick);
+                    } else {
+                        return Err(SwapError::InsufficientLiquidity);
                     }
                 }
-            }
+            },
             SwapStepAction::StopIn => {}
         }
 
         // Update current price, which effectively updates current tick too
         self.state_ops.set_alpha_sqrt_price(sqrt_price_final);
 
-        SwapStepResult {
+        Ok(SwapStepResult {
             amount_to_take: amount_swapped.saturating_to_num::<u64>(),
             delta_out,
-        }
+        })
     }
 
     /// Get the square root price at the current tick edge for the given direction (order type)
@@ -645,16 +599,16 @@ where
     ///
     fn get_sqrt_price_edge(&self, order_type: &OrderType) -> SqrtPrice {
         let fallback_price_edge_value = (match order_type {
-            OrderType::Buy => Position::tick_index_to_sqrt_price(MIN_TICK),
-            OrderType::Sell => Position::tick_index_to_sqrt_price(MAX_TICK),
+            OrderType::Buy => tick_index_to_sqrt_price(MIN_TICK),
+            OrderType::Sell => tick_index_to_sqrt_price(MAX_TICK),
         })
         .unwrap_or(SqrtPrice::saturating_from_num(0));
 
         let current_price = self.state_ops.get_alpha_sqrt_price();
-        let maybe_current_tick_index = Position::sqrt_price_to_tick_index(current_price);
+        let maybe_current_tick_index = sqrt_price_to_tick_index(current_price);
 
         if let Ok(current_tick_index) = maybe_current_tick_index {
-            Position::tick_index_to_sqrt_price(match order_type {
+            tick_index_to_sqrt_price(match order_type {
                 OrderType::Buy => current_tick_index.saturating_add(1),
                 OrderType::Sell => current_tick_index,
             })
@@ -888,18 +842,13 @@ where
 
     /// Update liquidity when crossing a tick
     ///
-    fn update_liquidity_at_crossing(&self, order_type: &OrderType) {
+    fn update_liquidity_at_crossing(&self, order_type: &OrderType) -> Result<(), SwapError> {
         let mut liquidity_curr = self.state_ops.get_current_liquidity();
-        let current_price = self.state_ops.get_alpha_sqrt_price();
-        let maybe_current_tick_index = Position::sqrt_price_to_tick_index(current_price);
-        if let Ok(current_tick_index) = maybe_current_tick_index {
-            match order_type {
-                OrderType::Sell => {
-                    // TODO: Review if non-existing current tick is possible
-                    let tick = self
-                        .state_ops
-                        .get_tick_by_index(current_tick_index as u64)
-                        .unwrap_or_default();
+        let current_tick_index = self.get_current_tick_index();
+        match order_type {
+            OrderType::Sell => {
+                let maybe_tick = find_closest_lower_active_tick(current_tick_index);
+                if let Some(tick) = maybe_tick {
                     let liquidity_update_abs_u64 = self.get_liquidity_update_u64(&tick);
 
                     liquidity_curr = if tick.liquidity_net >= 0 {
@@ -907,13 +856,13 @@ where
                     } else {
                         liquidity_curr.saturating_add(liquidity_update_abs_u64)
                     };
+                } else {
+                    return Err(SwapError::InsufficientLiquidity);
                 }
-                OrderType::Buy => {
-                    // TODO: Active vs all ticks. Just + 1 doesn't work right now
-                    let tick = self
-                        .state_ops
-                        .get_tick_by_index((current_tick_index + 1) as u64)
-                        .unwrap_or_default();
+            }
+            OrderType::Buy => {
+                let maybe_tick = find_closest_higher_active_tick(current_tick_index);
+                if let Some(tick) = maybe_tick {
                     let liquidity_update_abs_u64 = self.get_liquidity_update_u64(&tick);
 
                     liquidity_curr = if tick.liquidity_net >= 0 {
@@ -921,10 +870,14 @@ where
                     } else {
                         liquidity_curr.saturating_sub(liquidity_update_abs_u64)
                     };
+                } else {
+                    return Err(SwapError::InsufficientLiquidity);
                 }
             }
         }
+
         self.state_ops.set_current_liquidity(liquidity_curr);
+        Ok(())
     }
 
     /// Collect fees for a position
@@ -1007,92 +960,3 @@ where
         todo!()
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_tick_index_to_sqrt_price() {
-        let tick_spacing = SqrtPrice::from_num(1.0001);
-
-        // check tick bounds
-        assert_eq!(
-            Position::tick_index_to_sqrt_price(MIN_TICK),
-            Err(TickMathError::TickOutOfBounds)
-        );
-
-        assert_eq!(
-            Position::tick_index_to_sqrt_price(MAX_TICK),
-            Err(TickMathError::TickOutOfBounds),
-        );
-
-        // At tick index 0, the sqrt price should be 1.0
-        let sqrt_price = Position::tick_index_to_sqrt_price(0).unwrap();
-        assert_eq!(sqrt_price, SqrtPrice::from_num(1.0));
-
-        let sqrt_price = Position::tick_index_to_sqrt_price(2).unwrap();
-        assert!(sqrt_price.abs_diff(tick_spacing) < SqrtPrice::from_num(1e-10));
-
-        let sqrt_price = Position::tick_index_to_sqrt_price(4).unwrap();
-        // Calculate the expected value: (1 + TICK_SPACING/1e9 + 1.0)^2
-        let expected = tick_spacing * tick_spacing;
-        assert!(sqrt_price.abs_diff(expected) < SqrtPrice::from_num(1e-10));
-
-        // Test with tick index 10
-        let sqrt_price = Position::tick_index_to_sqrt_price(10).unwrap();
-        // Calculate the expected value: (1 + TICK_SPACING/1e9 + 1.0)^5
-        let expected = tick_spacing.checked_pow(5).unwrap();
-        assert!(
-            sqrt_price.abs_diff(expected) < SqrtPrice::from_num(1e-10),
-            "diff: {}",
-            sqrt_price.abs_diff(expected),
-        );
-    }
-
-    #[test]
-    fn test_sqrt_price_to_tick_index() {
-        let tick_spacing = SqrtPrice::from_num(1.0001);
-        let tick_index = Position::sqrt_price_to_tick_index(SqrtPrice::from_num(1.0)).unwrap();
-        assert_eq!(tick_index, 0);
-
-        // Test with sqrt price equal to tick_spacing_tao (should be tick index 2)
-        let tick_index = Position::sqrt_price_to_tick_index(tick_spacing).unwrap();
-        assert_eq!(tick_index, 2);
-
-        // Test with sqrt price equal to tick_spacing_tao^2 (should be tick index 4)
-        let sqrt_price = tick_spacing * tick_spacing;
-        let tick_index = Position::sqrt_price_to_tick_index(sqrt_price).unwrap();
-        assert_eq!(tick_index, 4);
-
-        // Test with sqrt price equal to tick_spacing_tao^5 (should be tick index 10)
-        let sqrt_price = tick_spacing.checked_pow(5).unwrap();
-        let tick_index = Position::sqrt_price_to_tick_index(sqrt_price).unwrap();
-        assert_eq!(tick_index, 10);
-    }
-
-    #[test]
-    fn test_roundtrip_tick_index_sqrt_price() {
-        for tick_index in [
-            MIN_TICK / 2,
-            -1000,
-            -100,
-            -10,
-            -4,
-            -2,
-            0,
-            2,
-            4,
-            10,
-            100,
-            1000,
-            MAX_TICK / 2,
-        ]
-        .iter()
-        {
-            let sqrt_price = Position::tick_index_to_sqrt_price(*tick_index).unwrap();
-            let round_trip_tick_index = Position::sqrt_price_to_tick_index(sqrt_price).unwrap();
-            assert_eq!(round_trip_tick_index, *tick_index);
-        }
-    }
-}
diff --git a/primitives/swap/src/tick.rs b/primitives/swap/src/tick.rs
new file mode 100644
index 0000000000..176302075c
--- /dev/null
+++ b/primitives/swap/src/tick.rs
@@ -0,0 +1,147 @@
+use substrate_fixed::types::U64F64;
+
+use crate::SqrtPrice;
+use crate::tick_math::{
+    MAX_TICK, MIN_TICK, TickMathError, get_sqrt_ratio_at_tick, get_tick_at_sqrt_ratio,
+    u64f64_to_u256_q64_96, u256_q64_96_to_u64f64,
+};
+
+/// Tick is the price range determined by tick index (not part of this struct,
+/// but is the key at which the Tick is stored in state hash maps). Tick struct
+/// stores liquidity and fee information.
+///
+///   - Net liquidity
+///   - Gross liquidity
+///   - Fees (above global) in both currencies
+///
+#[derive(Default)]
+pub struct Tick {
+    pub liquidity_net: i128,
+    pub liquidity_gross: u64,
+    pub fees_out_tao: U64F64,
+    pub fees_out_alpha: U64F64,
+}
+
+/// Converts tick index into SQRT of lower price of this tick
+/// In order to find the higher price of this tick, call
+/// tick_index_to_sqrt_price(tick_idx + 1)
+pub fn tick_index_to_sqrt_price(tick_idx: i32) -> Result<SqrtPrice, TickMathError> {
+    // because of u256->u128 conversion we have twice less values for min/max ticks
+    if !(MIN_TICK / 2..=MAX_TICK / 2).contains(&tick_idx) {
+        return Err(TickMathError::TickOutOfBounds);
+    }
+    get_sqrt_ratio_at_tick(tick_idx).and_then(u256_q64_96_to_u64f64)
+}
+
+/// Converts SQRT price to tick index
+/// Because the tick is the range of prices [sqrt_lower_price, sqrt_higher_price),
+/// the resulting tick index matches the price by the following inequality:
+///    sqrt_lower_price <= sqrt_price < sqrt_higher_price
+pub fn sqrt_price_to_tick_index(sqrt_price: SqrtPrice) -> Result<i32, TickMathError> {
+    let tick = get_tick_at_sqrt_ratio(u64f64_to_u256_q64_96(sqrt_price))?;
+
+    // Correct for rounding error during conversions between different fixed-point formats
+    Ok(if tick == 0 {
+        tick
+    } else {
+        tick.saturating_add(1)
+    })
+}
+
+pub fn find_closest_lower_active_tick(_index: i32) -> Option<Tick> {
+    todo!()
+}
+
+pub fn find_closest_higher_active_tick(_index: i32) -> Option<Tick> {
+    todo!()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use safe_math::FixedExt;
+
+    #[test]
+    fn test_tick_index_to_sqrt_price() {
+        let tick_spacing = SqrtPrice::from_num(1.0001);
+
+        // check tick bounds
+        assert_eq!(
+            tick_index_to_sqrt_price(MIN_TICK),
+            Err(TickMathError::TickOutOfBounds)
+        );
+
+        assert_eq!(
+            tick_index_to_sqrt_price(MAX_TICK),
+            Err(TickMathError::TickOutOfBounds),
+        );
+
+        // At tick index 0, the sqrt price should be 1.0
+        let sqrt_price = tick_index_to_sqrt_price(0).unwrap();
+        assert_eq!(sqrt_price, SqrtPrice::from_num(1.0));
+
+        let sqrt_price = tick_index_to_sqrt_price(2).unwrap();
+        assert!(sqrt_price.abs_diff(tick_spacing) < SqrtPrice::from_num(1e-10));
+
+        let sqrt_price = tick_index_to_sqrt_price(4).unwrap();
+        // Calculate the expected value: (1 + TICK_SPACING/1e9 + 1.0)^2
+        let expected = tick_spacing * tick_spacing;
+        assert!(sqrt_price.abs_diff(expected) < SqrtPrice::from_num(1e-10));
+
+        // Test with tick index 10
+        let sqrt_price = tick_index_to_sqrt_price(10).unwrap();
+        // Calculate the expected value: (1 + TICK_SPACING/1e9 + 1.0)^5
+        let expected = tick_spacing.checked_pow(5).unwrap();
+        assert!(
+            sqrt_price.abs_diff(expected) < SqrtPrice::from_num(1e-10),
+            "diff: {}",
+            sqrt_price.abs_diff(expected),
+        );
+    }
+
+    #[test]
+    fn test_sqrt_price_to_tick_index() {
+        let tick_spacing = SqrtPrice::from_num(1.0001);
+        let tick_index = sqrt_price_to_tick_index(SqrtPrice::from_num(1.0)).unwrap();
+        assert_eq!(tick_index, 0);
+
+        // Test with sqrt price equal to tick_spacing_tao (should be tick index 2)
+        let tick_index = sqrt_price_to_tick_index(tick_spacing).unwrap();
+        assert_eq!(tick_index, 2);
+
+        // Test with sqrt price equal to tick_spacing_tao^2 (should be tick index 4)
+        let sqrt_price = tick_spacing * tick_spacing;
+        let tick_index = sqrt_price_to_tick_index(sqrt_price).unwrap();
+        assert_eq!(tick_index, 4);
+
+        // Test with sqrt price equal to tick_spacing_tao^5 (should be tick index 10)
+        let sqrt_price = tick_spacing.checked_pow(5).unwrap();
+        let tick_index = sqrt_price_to_tick_index(sqrt_price).unwrap();
+        assert_eq!(tick_index, 10);
+    }
+
+    #[test]
+    fn test_roundtrip_tick_index_sqrt_price() {
+        for tick_index in [
+            MIN_TICK / 2,
+            -1000,
+            -100,
+            -10,
+            -4,
+            -2,
+            0,
+            2,
+            4,
+            10,
+            100,
+            1000,
+            MAX_TICK / 2,
+        ]
+        .iter()
+        {
+            let sqrt_price = tick_index_to_sqrt_price(*tick_index).unwrap();
+            let round_trip_tick_index = sqrt_price_to_tick_index(sqrt_price).unwrap();
+            assert_eq!(round_trip_tick_index, *tick_index);
+        }
+    }
+}

From d76c582fe154a600b2680e570104417bac6fee6f Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Tue, 18 Mar 2025 14:54:35 -0400
Subject: [PATCH 018/418] Basic swap implementation, ready for tests

---
 primitives/swap/src/lib.rs  | 233 ++++++++++++++++++++++--------------
 primitives/swap/src/tick.rs |  48 +++++++-
 2 files changed, 187 insertions(+), 94 deletions(-)

diff --git a/primitives/swap/src/lib.rs b/primitives/swap/src/lib.rs
index 266abded83..768f78f0f0 100644
--- a/primitives/swap/src/lib.rs
+++ b/primitives/swap/src/lib.rs
@@ -6,7 +6,7 @@ use substrate_fixed::types::U64F64;
 
 use self::error::SwapError;
 use self::tick::{
-    Tick, find_closest_higher_active_tick, find_closest_lower_active_tick,
+    Tick, find_closest_higher_active_tick_index, find_closest_lower_active_tick_index,
     sqrt_price_to_tick_index, tick_index_to_sqrt_price,
 };
 use self::tick_math::{MAX_TICK, MIN_TICK};
@@ -59,8 +59,8 @@ struct SwapStepResult {
 ///
 #[cfg_attr(test, derive(Debug, PartialEq))]
 pub struct Position {
-    tick_low: u64,
-    tick_high: u64,
+    tick_low: i32,
+    tick_high: i32,
     liquidity: u64,
     fees_tao: u64,
     fees_alpha: u64,
@@ -71,31 +71,44 @@ impl Position {
     ///
     /// returns tuple of (TAO, Alpha)
     ///
-    pub fn to_token_amounts(&self, _current_tick: u64) -> (u64, u64) {
-        // let one = 1.into();
-
-        // let sqrt_price_curr = tick_index_to_sqrt_price(current_tick);
-        // let sqrt_pa = tick_index_to_sqrt_price(self.tick_low);
-        // let sqrt_pb = tick_index_to_sqrt_price(self.tick_high);
-
-        // if sqrt_price_curr < sqrt_pa {
-        //     (
-        //         liquidity
-        //             .saturating_mul(one.safe_div(sqrt_pa).saturating_sub(one.safe_div(sqrt_pb))),
-        //         0,
-        //     )
-        // } else if sqrt_price_curr > sqrt_pb {
-        //     (0, liquidity.saturating_mul(sqrt_pb.saturating_sub(sqrt_pa)))
-        // } else {
-        //     (
-        //         liquidity.saturating_mul(
-        //             one.save_div(sqrt_price_curr)
-        //                 .saturating_sub(one.safe_div(sqrt_pb)),
-        //         ),
-        //         liquidity.saturating_mul(sqrt_price_curr.saturating_sub(sqrt_pa)),
-        //     )
-        // }
-        todo!()
+    pub fn to_token_amounts(&self, current_tick: i32) -> Result<(u64, u64), SwapError> {
+        let one: U64F64 = U64F64::saturating_from_num(1);
+
+        let sqrt_price_curr: SqrtPrice =
+            tick_index_to_sqrt_price(current_tick).map_err(|_| SwapError::InvalidTickRange)?;
+        let sqrt_pa: SqrtPrice =
+            tick_index_to_sqrt_price(self.tick_low).map_err(|_| SwapError::InvalidTickRange)?;
+        let sqrt_pb: SqrtPrice =
+            tick_index_to_sqrt_price(self.tick_high).map_err(|_| SwapError::InvalidTickRange)?;
+        let liquidity_fixed: U64F64 = U64F64::saturating_from_num(self.liquidity);
+
+        Ok(if sqrt_price_curr < sqrt_pa {
+            (
+                liquidity_fixed
+                    .saturating_mul(one.safe_div(sqrt_pa).saturating_sub(one.safe_div(sqrt_pb)))
+                    .saturating_to_num::<u64>(),
+                0,
+            )
+        } else if sqrt_price_curr > sqrt_pb {
+            (
+                0,
+                liquidity_fixed
+                    .saturating_mul(sqrt_pb.saturating_sub(sqrt_pa))
+                    .saturating_to_num::<u64>(),
+            )
+        } else {
+            (
+                liquidity_fixed
+                    .saturating_mul(
+                        one.safe_div(sqrt_price_curr)
+                            .saturating_sub(one.safe_div(sqrt_pb)),
+                    )
+                    .saturating_to_num::<u64>(),
+                liquidity_fixed
+                    .saturating_mul(sqrt_price_curr.saturating_sub(sqrt_pa))
+                    .saturating_to_num::<u64>(),
+            )
+        })
     }
 }
 
@@ -112,9 +125,9 @@ pub trait SwapDataOperations<AccountIdType> {
     fn get_fee_rate(&self) -> u16;
     /// Minimum liquidity that is safe for rounding and integer math.
     fn get_minimum_liquidity(&self) -> u64;
-    fn get_tick_by_index(&self, tick_index: u64) -> Option<Tick>;
-    fn insert_tick_by_index(&self, tick_index: u64, tick: Tick);
-    fn remove_tick_by_index(&self, tick_index: u64);
+    fn get_tick_by_index(&self, tick_index: i32) -> Option<Tick>;
+    fn insert_tick_by_index(&self, tick_index: i32, tick: Tick);
+    fn remove_tick_by_index(&self, tick_index: i32);
     /// Minimum sqrt price across all active ticks
     fn get_min_sqrt_price(&self) -> SqrtPrice;
     /// Maximum sqrt price across all active ticks
@@ -166,14 +179,16 @@ where
     AccountIdType: Eq,
     Ops: SwapDataOperations<AccountIdType>,
 {
-    pub fn new(_ops: Ops) -> Self {
-        // if !ops.is_v3_initialized() {
-        //     // TODO: Initialize the v3
-        //     // Set price, set initial (protocol owned) liquidity and positions, etc.
-        // }
+    pub fn new(ops: Ops) -> Self {
+        if !ops.is_v3_initialized() {
+            // TODO: Initialize the v3
+            // Set price, set initial (protocol owned) liquidity and positions, etc.
+        }
 
-        // Swap { state_ops: ops }
-        todo!()
+        Swap {
+            state_ops: ops,
+            phantom_key: PhantomData,
+        }
     }
 
     /// Auxiliary method to calculate Alpha amount to match given TAO
@@ -199,7 +214,7 @@ where
 
     /// Add liquidity at tick index. Creates new tick if it doesn't exist
     ///
-    fn add_liquidity_at_index(&self, tick_index: u64, liquidity: u64, upper: bool) {
+    fn add_liquidity_at_index(&self, tick_index: i32, liquidity: u64, upper: bool) {
         // Calculate net liquidity addition
         let net_addition = if upper {
             (liquidity as i128).neg()
@@ -229,7 +244,7 @@ where
 
     /// Remove liquidity at tick index.
     ///
-    fn remove_liquidity_at_index(&self, tick_index: u64, liquidity: u64, upper: bool) {
+    fn remove_liquidity_at_index(&self, tick_index: i32, liquidity: u64, upper: bool) {
         // Calculate net liquidity addition
         let net_reduction = if upper {
             (liquidity as i128).neg()
@@ -262,8 +277,8 @@ where
     pub fn add_liquidity(
         &self,
         account_id: &AccountIdType,
-        tick_low: u64,
-        tick_high: u64,
+        tick_low: i32,
+        tick_high: i32,
         liquidity: u64,
     ) -> Result<u64, SwapError> {
         // Check if we can add a position
@@ -283,7 +298,7 @@ where
         let current_tick_index = self.get_current_tick_index();
 
         // Update current tick liquidity
-        if (tick_low <= current_tick_index as u64) && (current_tick_index as u64 <= tick_high) {
+        if (tick_low <= current_tick_index) && (current_tick_index <= tick_high) {
             let new_current_liquidity = self
                 .state_ops
                 .get_current_liquidity()
@@ -299,7 +314,7 @@ where
             fees_tao: 0_u64,
             fees_alpha: 0_u64,
         };
-        let (tao, alpha) = position.to_token_amounts(current_tick_index as u64);
+        let (tao, alpha) = position.to_token_amounts(current_tick_index)?;
         self.state_ops.withdraw_balances(account_id, tao, alpha);
 
         // Update reserves
@@ -332,16 +347,14 @@ where
 
             // Collect fees and get tao and alpha amounts
             let (fee_tao, fee_alpha) = self.collect_fees(&mut pos);
-            let (tao, alpha) = pos.to_token_amounts(current_tick_index as u64);
+            let (tao, alpha) = pos.to_token_amounts(current_tick_index)?;
 
             // Update liquidity at position ticks
             self.remove_liquidity_at_index(pos.tick_low, pos.liquidity, false);
             self.remove_liquidity_at_index(pos.tick_high, pos.liquidity, true);
 
             // Update current tick liquidity
-            if (pos.tick_low <= current_tick_index as u64)
-                && (current_tick_index as u64 <= pos.tick_high)
-            {
+            if (pos.tick_low <= current_tick_index) && (current_tick_index <= pos.tick_high) {
                 let new_current_liquidity = self
                     .state_ops
                     .get_current_liquidity()
@@ -537,8 +550,8 @@ where
         match action {
             SwapStepAction::Crossing => {
                 let maybe_tick = match order_type {
-                    OrderType::Sell => find_closest_lower_active_tick(current_tick_index),
-                    OrderType::Buy => find_closest_higher_active_tick(current_tick_index),
+                    OrderType::Sell => self.find_closest_lower_active_tick(current_tick_index),
+                    OrderType::Buy => self.find_closest_higher_active_tick(current_tick_index),
                 };
                 if let Some(mut tick) = maybe_tick {
                     tick.fees_out_tao = self
@@ -551,7 +564,7 @@ where
                         .saturating_sub(tick.fees_out_alpha);
                     self.update_liquidity_at_crossing(order_type)?;
                     self.state_ops
-                        .insert_tick_by_index(current_tick_index as u64, tick);
+                        .insert_tick_by_index(current_tick_index, tick);
                 } else {
                     return Err(SwapError::InsufficientLiquidity);
                 }
@@ -560,7 +573,7 @@ where
                 OrderType::Sell => {}
                 OrderType::Buy => {
                     self.update_liquidity_at_crossing(order_type)?;
-                    let maybe_tick = find_closest_higher_active_tick(current_tick_index);
+                    let maybe_tick = self.find_closest_higher_active_tick(current_tick_index);
 
                     if let Some(mut tick) = maybe_tick {
                         tick.fees_out_tao = self
@@ -572,7 +585,7 @@ where
                             .get_fee_global_alpha()
                             .saturating_sub(tick.fees_out_alpha);
                         self.state_ops
-                            .insert_tick_by_index(current_tick_index as u64, tick);
+                            .insert_tick_by_index(current_tick_index, tick);
                     } else {
                         return Err(SwapError::InsufficientLiquidity);
                     }
@@ -847,7 +860,7 @@ where
         let current_tick_index = self.get_current_tick_index();
         match order_type {
             OrderType::Sell => {
-                let maybe_tick = find_closest_lower_active_tick(current_tick_index);
+                let maybe_tick = self.find_closest_lower_active_tick(current_tick_index);
                 if let Some(tick) = maybe_tick {
                     let liquidity_update_abs_u64 = self.get_liquidity_update_u64(&tick);
 
@@ -861,7 +874,7 @@ where
                 }
             }
             OrderType::Buy => {
-                let maybe_tick = find_closest_higher_active_tick(current_tick_index);
+                let maybe_tick = self.find_closest_higher_active_tick(current_tick_index);
                 if let Some(tick) = maybe_tick {
                     let liquidity_update_abs_u64 = self.get_liquidity_update_u64(&tick);
 
@@ -921,42 +934,84 @@ where
 
     /// Get fees above a tick
     ///
-    fn get_fees_above(&self, _tick_index: u64, _quote: bool) -> U64F64 {
-        // k = self.get_tick_index(i)
-        // i_arg = self.active_ticks[k]
-
-        // if i_arg <= self.i_curr:
-        //     if want_one:
-        //         fee = self.fee_global1 - self.fee_outside1[k]
-        //     else:
-        //         fee = self.fee_global0 - self.fee_outside0[k]
-        // else:
-        //     if want_one:
-        //         fee = self.fee_outside1[k]
-        //     else:
-        //         fee = self.fee_outside0[k]
-
-        // return fee
-        todo!()
+    fn get_fees_above(&self, tick_index: i32, quote: bool) -> U64F64 {
+        let maybe_tick_index = find_closest_lower_active_tick_index(&self.state_ops, tick_index);
+        let current_tick = self.get_current_tick_index();
+
+        if let Some(tick_index) = maybe_tick_index {
+            let tick = self
+                .state_ops
+                .get_tick_by_index(tick_index)
+                .unwrap_or_default();
+            if tick_index <= current_tick {
+                if quote {
+                    self.state_ops
+                        .get_fee_global_tao()
+                        .saturating_sub(tick.fees_out_tao)
+                } else {
+                    self.state_ops
+                        .get_fee_global_alpha()
+                        .saturating_sub(tick.fees_out_alpha)
+                }
+            } else {
+                if quote {
+                    tick.fees_out_tao
+                } else {
+                    tick.fees_out_alpha
+                }
+            }
+        } else {
+            U64F64::saturating_from_num(0)
+        }
     }
 
     /// Get fees below a tick
-    fn get_fees_below(&self, _tick_index: u64, _quote: bool) -> U64F64 {
-        // k = self.get_tick_index(i)
-        // i_arg = self.active_ticks[k]
-
-        // if i_arg <= self.i_curr:
-        //     if want_one:
-        //         fee = self.fee_outside1[k]
-        //     else:
-        //         fee = self.fee_outside0[k]
-        // else:
-        //     if want_one:
-        //         fee = self.fee_global1 - self.fee_outside1[k]
-        //     else:
-        //         fee = self.fee_global0 - self.fee_outside0[k]
-
-        // return fee
-        todo!()
+    fn get_fees_below(&self, tick_index: i32, quote: bool) -> U64F64 {
+        let maybe_tick_index = find_closest_lower_active_tick_index(&self.state_ops, tick_index);
+        let current_tick = self.get_current_tick_index();
+
+        if let Some(tick_index) = maybe_tick_index {
+            let tick = self
+                .state_ops
+                .get_tick_by_index(tick_index)
+                .unwrap_or_default();
+            if tick_index <= current_tick {
+                if quote {
+                    tick.fees_out_tao
+                } else {
+                    tick.fees_out_alpha
+                }
+            } else {
+                if quote {
+                    self.state_ops
+                        .get_fee_global_tao()
+                        .saturating_sub(tick.fees_out_tao)
+                } else {
+                    self.state_ops
+                        .get_fee_global_alpha()
+                        .saturating_sub(tick.fees_out_alpha)
+                }
+            }
+        } else {
+            U64F64::saturating_from_num(0)
+        }
+    }
+
+    pub fn find_closest_lower_active_tick(&self, index: i32) -> Option<Tick> {
+        let maybe_tick_index = find_closest_lower_active_tick_index(&self.state_ops, index);
+        if let Some(tick_index) = maybe_tick_index {
+            self.state_ops.get_tick_by_index(tick_index)
+        } else {
+            None
+        }
+    }
+
+    pub fn find_closest_higher_active_tick(&self, index: i32) -> Option<Tick> {
+        let maybe_tick_index = find_closest_higher_active_tick_index(&self.state_ops, index);
+        if let Some(tick_index) = maybe_tick_index {
+            self.state_ops.get_tick_by_index(tick_index)
+        } else {
+            None
+        }
     }
 }
diff --git a/primitives/swap/src/tick.rs b/primitives/swap/src/tick.rs
index 176302075c..d46fbd9610 100644
--- a/primitives/swap/src/tick.rs
+++ b/primitives/swap/src/tick.rs
@@ -1,10 +1,10 @@
 use substrate_fixed::types::U64F64;
 
-use crate::SqrtPrice;
 use crate::tick_math::{
     MAX_TICK, MIN_TICK, TickMathError, get_sqrt_ratio_at_tick, get_tick_at_sqrt_ratio,
     u64f64_to_u256_q64_96, u256_q64_96_to_u64f64,
 };
+use crate::{SqrtPrice, SwapDataOperations};
 
 /// Tick is the price range determined by tick index (not part of this struct,
 /// but is the key at which the Tick is stored in state hash maps). Tick struct
@@ -48,12 +48,50 @@ pub fn sqrt_price_to_tick_index(sqrt_price: SqrtPrice) -> Result<i32, TickMathEr
     })
 }
 
-pub fn find_closest_lower_active_tick(_index: i32) -> Option<Tick> {
-    todo!()
+pub fn find_closest_lower_active_tick_index<Ops, AccountIdType>(
+    ops: &Ops,
+    index: i32,
+) -> Option<i32>
+where
+    AccountIdType: Eq,
+    Ops: SwapDataOperations<AccountIdType>,
+{
+    // TODO: Implement without iteration
+    let mut current_index = index;
+    loop {
+        if current_index < MIN_TICK {
+            return None;
+        }
+        if ops.get_tick_by_index(current_index).is_some() {
+            return Some(current_index);
+        }
+
+        // Intentionally using unsafe math here to trigger CI
+        current_index -= 1;
+    }
 }
 
-pub fn find_closest_higher_active_tick(_index: i32) -> Option<Tick> {
-    todo!()
+pub fn find_closest_higher_active_tick_index<Ops, AccountIdType>(
+    ops: &Ops,
+    index: i32,
+) -> Option<i32>
+where
+    AccountIdType: Eq,
+    Ops: SwapDataOperations<AccountIdType>,
+{
+    // TODO: Implement without iteration
+    let mut current_index = index;
+    loop {
+        if current_index > MAX_TICK {
+            return None;
+        }
+        if ops.get_tick_by_index(current_index).is_some() {
+            return Some(current_index);
+        }
+
+        // Intentionally using unsafe math here to trigger CI
+        current_index += 1;
+    }
 }
 
 #[cfg(test)]

From 105922e9c30e75b1e0e2a68fa1d2f0d3fc367b9b Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Wed, 19 Mar 2025 18:37:04 -0400
Subject: [PATCH 019/418] Test and debug swap initialization and add_liquidity

---
 Cargo.lock                      |   1 +
 primitives/safe-math/src/lib.rs |  16 +-
 primitives/swap/Cargo.toml      |   1 +
 primitives/swap/src/lib.rs      | 727 ++++++++++++++++++++++++++++----
 primitives/swap/src/tick.rs     |   8 +-
 5 files changed, 669 insertions(+), 84 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index f3414e52bf..eb568725ab 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -11556,6 +11556,7 @@ name = "swap"
 version = "0.1.0"
 dependencies = [
  "alloy-primitives",
+ "approx",
  "safe-math",
  "sp-arithmetic",
  "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409)",
diff --git a/primitives/safe-math/src/lib.rs b/primitives/safe-math/src/lib.rs
index cd7dc9a44a..966dbb4de4 100644
--- a/primitives/safe-math/src/lib.rs
+++ b/primitives/safe-math/src/lib.rs
@@ -76,14 +76,23 @@ pub trait FixedExt: Fixed {
     /// Safe sqrt with good precision
     fn checked_sqrt(&self, epsilon: Self) -> Option<Self> {
         let zero = Self::saturating_from_num(0);
+        let one = Self::saturating_from_num(1);
         let two = Self::saturating_from_num(2);
 
         if *self < zero {
             return None;
         }
 
-        let mut high = *self;
-        let mut low = zero;
+        let mut high;
+        let mut low;
+        if *self > one {
+            high = *self;
+            low = zero;
+        } else {
+            high = one;
+            low = *self;
+        }
+
         let mut middle = high.saturating_add(low).safe_div(two);
 
         let mut iteration: i32 = 0;
@@ -268,7 +277,8 @@ mod tests {
 
         let result: Option<U110F18> = value.checked_sqrt(epsilon);
         assert!(result.is_some());
-        assert_eq!(result.unwrap(), U110F18::from_num(0.0));
+        let sqrt_result: U110F18 = result.unwrap();
+        assert!(sqrt_result.abs_diff(U110F18::from_num(0)) <= epsilon);
     }
 
     #[test]
diff --git a/primitives/swap/Cargo.toml b/primitives/swap/Cargo.toml
index bd377cbaa3..d69c31fa0d 100644
--- a/primitives/swap/Cargo.toml
+++ b/primitives/swap/Cargo.toml
@@ -5,6 +5,7 @@ edition = { workspace = true }
 
 [dependencies]
 alloy-primitives = { workspace = true }
+approx = { workspace = true }
 safe-math = { workspace = true }
 sp-arithmetic = { workspace = true }
 sp-std = { workspace = true }
diff --git a/primitives/swap/src/lib.rs b/primitives/swap/src/lib.rs
index 768f78f0f0..39e934aa7b 100644
--- a/primitives/swap/src/lib.rs
+++ b/primitives/swap/src/lib.rs
@@ -2,14 +2,14 @@ use core::marker::PhantomData;
 use std::ops::Neg;
 
 use safe_math::*;
+use sp_arithmetic::helpers_128bit::sqrt;
 use substrate_fixed::types::U64F64;
 
 use self::error::SwapError;
 use self::tick::{
-    Tick, find_closest_higher_active_tick_index, find_closest_lower_active_tick_index,
-    sqrt_price_to_tick_index, tick_index_to_sqrt_price,
+    MAX_TICK_INDEX, MIN_TICK_INDEX, Tick, find_closest_higher_active_tick_index,
+    find_closest_lower_active_tick_index, sqrt_price_to_tick_index, tick_index_to_sqrt_price,
 };
-use self::tick_math::{MAX_TICK, MIN_TICK};
 
 mod error;
 mod tick;
@@ -57,7 +57,7 @@ struct SwapStepResult {
 /// fees_tao - fees accrued by the position in quote currency (TAO)
 /// fees_alpha - fees accrued by the position in base currency (Alpha)
 ///
-#[cfg_attr(test, derive(Debug, PartialEq))]
+#[cfg_attr(test, derive(Debug, PartialEq, Clone))]
 pub struct Position {
     tick_low: i32,
     tick_high: i32,
@@ -71,11 +71,20 @@ impl Position {
     ///
     /// returns tuple of (TAO, Alpha)
     ///
-    pub fn to_token_amounts(&self, current_tick: i32) -> Result<(u64, u64), SwapError> {
+    /// Pseudocode:
+    ///     if self.sqrt_price_curr < sqrt_pa:
+    ///         tao = 0
+    ///         alpha = L * (1 / sqrt_pa - 1 / sqrt_pb)
+    ///     elif self.sqrt_price_curr > sqrt_pb:
+    ///         tao = L * (sqrt_pb - sqrt_pa)
+    ///         alpha = 0
+    ///     else:
+    ///         tao = L * (self.sqrt_price_curr - sqrt_pa)
+    ///         alpha = L * (1 / self.sqrt_price_curr - 1 / sqrt_pb)
+    ///  
+    pub fn to_token_amounts(&self, sqrt_price_curr: SqrtPrice) -> Result<(u64, u64), SwapError> {
         let one: U64F64 = U64F64::saturating_from_num(1);
 
-        let sqrt_price_curr: SqrtPrice =
-            tick_index_to_sqrt_price(current_tick).map_err(|_| SwapError::InvalidTickRange)?;
         let sqrt_pa: SqrtPrice =
             tick_index_to_sqrt_price(self.tick_low).map_err(|_| SwapError::InvalidTickRange)?;
         let sqrt_pb: SqrtPrice =
@@ -84,29 +93,29 @@ impl Position {
 
         Ok(if sqrt_price_curr < sqrt_pa {
             (
+                0,
                 liquidity_fixed
                     .saturating_mul(one.safe_div(sqrt_pa).saturating_sub(one.safe_div(sqrt_pb)))
                     .saturating_to_num::<u64>(),
-                0,
             )
         } else if sqrt_price_curr > sqrt_pb {
             (
-                0,
                 liquidity_fixed
                     .saturating_mul(sqrt_pb.saturating_sub(sqrt_pa))
                     .saturating_to_num::<u64>(),
+                0,
             )
         } else {
             (
+                liquidity_fixed
+                    .saturating_mul(sqrt_price_curr.saturating_sub(sqrt_pa))
+                    .saturating_to_num::<u64>(),
                 liquidity_fixed
                     .saturating_mul(
                         one.safe_div(sqrt_price_curr)
                             .saturating_sub(one.safe_div(sqrt_pb)),
                     )
                     .saturating_to_num::<u64>(),
-                liquidity_fixed
-                    .saturating_mul(sqrt_price_curr.saturating_sub(sqrt_pa))
-                    .saturating_to_num::<u64>(),
             )
         })
     }
@@ -121,44 +130,56 @@ pub trait SwapDataOperations<AccountIdType> {
     /// reserves, while v3 also stores ticks and positions, which need to be initialized
     /// at the first pool creation.
     fn is_v3_initialized(&self) -> bool;
+    fn set_v3_initialized(&mut self);
     /// Returns u16::MAX normalized fee rate. For example, 0.3% is approximately 196.
     fn get_fee_rate(&self) -> u16;
     /// Minimum liquidity that is safe for rounding and integer math.
     fn get_minimum_liquidity(&self) -> u64;
     fn get_tick_by_index(&self, tick_index: i32) -> Option<Tick>;
-    fn insert_tick_by_index(&self, tick_index: i32, tick: Tick);
-    fn remove_tick_by_index(&self, tick_index: i32);
+    fn insert_tick_by_index(&mut self, tick_index: i32, tick: Tick);
+    fn remove_tick_by_index(&mut self, tick_index: i32);
     /// Minimum sqrt price across all active ticks
     fn get_min_sqrt_price(&self) -> SqrtPrice;
     /// Maximum sqrt price across all active ticks
     fn get_max_sqrt_price(&self) -> SqrtPrice;
     fn get_tao_reserve(&self) -> u64;
-    fn set_tao_reserve(&self, tao: u64) -> u64;
+    fn set_tao_reserve(&mut self, tao: u64) -> u64;
     fn get_alpha_reserve(&self) -> u64;
-    fn set_alpha_reserve(&self, alpha: u64) -> u64;
+    fn set_alpha_reserve(&mut self, alpha: u64) -> u64;
     fn get_alpha_sqrt_price(&self) -> SqrtPrice;
-    fn set_alpha_sqrt_price(&self, sqrt_price: SqrtPrice) -> u64;
+    fn set_alpha_sqrt_price(&mut self, sqrt_price: SqrtPrice);
 
     // Getters/setters for global accrued fees in alpha and tao per subnet
     fn get_fee_global_tao(&self) -> U64F64;
-    fn set_fee_global_tao(&self, fee: U64F64);
+    fn set_fee_global_tao(&mut self, fee: U64F64);
     fn get_fee_global_alpha(&self) -> U64F64;
-    fn set_fee_global_alpha(&self, fee: U64F64);
+    fn set_fee_global_alpha(&mut self, fee: U64F64);
 
     /// Get current tick liquidity
     fn get_current_liquidity(&self) -> u64;
     /// Set current tick liquidity
-    fn set_current_liquidity(&self, liquidity: u64);
+    fn set_current_liquidity(&mut self, liquidity: u64);
 
     // User account operations
+    fn get_protocol_account_id(&self) -> AccountIdType;
     fn get_max_positions(&self) -> u16;
-    fn withdraw_balances(&self, account_id: &AccountIdType, tao: u64, alpha: u64) -> (u64, u64);
-    fn deposit_balances(&self, account_id: &AccountIdType, tao: u64, alpha: u64);
+    fn withdraw_balances(
+        &mut self,
+        account_id: &AccountIdType,
+        tao: u64,
+        alpha: u64,
+    ) -> Result<(u64, u64), SwapError>;
+    fn deposit_balances(&mut self, account_id: &AccountIdType, tao: u64, alpha: u64);
     fn get_position_count(&self, account_id: &AccountIdType) -> u16;
     fn get_position(&self, account_id: &AccountIdType, position_id: u16) -> Option<Position>;
-    fn create_position(&self, account_id: &AccountIdType, positions: Position);
-    fn update_position(&self, account_id: &AccountIdType, position_id: u16, positions: Position);
-    fn remove_position(&self, account_id: &AccountIdType, position_id: u16);
+    fn create_position(&mut self, account_id: &AccountIdType, positions: Position) -> u16;
+    fn update_position(
+        &mut self,
+        account_id: &AccountIdType,
+        position_id: u16,
+        positions: Position,
+    );
+    fn remove_position(&mut self, account_id: &AccountIdType, position_id: u16);
 }
 
 /// All main swapping logic abstracted from Runtime implementation is concentrated
@@ -170,7 +191,7 @@ where
     AccountIdType: Eq,
     Ops: SwapDataOperations<AccountIdType>,
 {
-    state_ops: Ops,
+    pub(crate) state_ops: Ops,
     phantom_key: PhantomData<AccountIdType>,
 }
 
@@ -179,15 +200,47 @@ where
     AccountIdType: Eq,
     Ops: SwapDataOperations<AccountIdType>,
 {
-    pub fn new(ops: Ops) -> Self {
+    pub fn new(mut ops: Ops) -> Self {
         if !ops.is_v3_initialized() {
-            // TODO: Initialize the v3
-            // Set price, set initial (protocol owned) liquidity and positions, etc.
-        }
-
-        Swap {
-            state_ops: ops,
-            phantom_key: PhantomData,
+            // Initialize the v3:
+            // Reserves are re-purposed, nothing to set, just query values for liquidity and price calculation
+            let tao_reserve = ops.get_tao_reserve();
+            let alpha_reserve = ops.get_alpha_reserve();
+
+            // Set price
+            let price: U64F64 = U64F64::saturating_from_num(tao_reserve)
+                .safe_div(U64F64::saturating_from_num(alpha_reserve));
+
+            let epsilon: U64F64 = U64F64::saturating_from_num(0.000001);
+            ops.set_alpha_sqrt_price(
+                price
+                    .checked_sqrt(epsilon)
+                    .unwrap_or(U64F64::saturating_from_num(0)),
+            );
+
+            // Set initial (protocol owned) liquidity and positions
+            // Protocol liquidity makes one position from MIN_TICK_INDEX to MAX_TICK_INDEX
+            // We are using the sp_arithmetic sqrt here, which works for u128
+            let liquidity: u64 = sqrt(tao_reserve as u128 * alpha_reserve as u128) as u64;
+            let mut swap = Swap {
+                state_ops: ops,
+                phantom_key: PhantomData,
+            };
+            let protocol_account_id = swap.state_ops.get_protocol_account_id();
+            let _ = swap.add_liquidity(
+                &protocol_account_id,
+                MIN_TICK_INDEX,
+                MAX_TICK_INDEX,
+                liquidity,
+                true,
+            );
+
+            swap
+        } else {
+            Swap {
+                state_ops: ops,
+                phantom_key: PhantomData,
+            }
         }
     }
 
@@ -214,7 +267,7 @@ where
 
     /// Add liquidity at tick index. Creates new tick if it doesn't exist
     ///
-    fn add_liquidity_at_index(&self, tick_index: i32, liquidity: u64, upper: bool) {
+    fn add_liquidity_at_index(&mut self, tick_index: i32, liquidity: u64, upper: bool) {
         // Calculate net liquidity addition
         let net_addition = if upper {
             (liquidity as i128).neg()
@@ -244,7 +297,7 @@ where
 
     /// Remove liquidity at tick index.
     ///
-    fn remove_liquidity_at_index(&self, tick_index: i32, liquidity: u64, upper: bool) {
+    fn remove_liquidity_at_index(&mut self, tick_index: i32, liquidity: u64, upper: bool) {
         // Calculate net liquidity addition
         let net_reduction = if upper {
             (liquidity as i128).neg()
@@ -266,21 +319,47 @@ where
         };
     }
 
-    /// Add liquidity
+    /// Adds liquidity to the specified price range.
+    ///
+    /// This function allows an account to provide liquidity to a given range of price ticks.
+    /// The amount of liquidity to be added can be determined using the functions
+    /// [`get_tao_based_liquidity`] and [`get_alpha_based_liquidity`], which compute the
+    /// required liquidity based on TAO and Alpha balances for the current price tick.
+    ///
+    /// ### Behavior:
+    /// - If the `protocol` flag is **not set** (`false`), the function will attempt to
+    ///   **withdraw balances** from the account using `state_ops.withdraw_balances()`.
+    /// - If the `protocol` flag is **set** (`true`), the liquidity is added without modifying balances.
+    ///
+    /// ### Parameters:
+    /// - `account_id`: A reference to the account that is providing liquidity.
+    /// - `tick_low`: The lower bound of the price tick range.
+    /// - `tick_high`: The upper bound of the price tick range.
+    /// - `liquidity`: The amount of liquidity to be added.
+    /// - `protocol`: A boolean flag indicating whether the operation is protocol-managed:
+    ///   - `true` -> Do not use this value outside of this implementation. Liquidity is added **without**
+    ///               withdrawing balances.
+    ///   - `false` -> Use this value for all user transactions. Liquidity is added
+    ///               **after withdrawing balances**.
     ///
-    /// The added liquidity amount can be calculated from TAO and Alpha
-    /// amounts using get_tao_based_liquidity and get_alpha_based_liquidity
-    /// for the current price tick.
+    /// ### Returns:
+    /// - `Ok(u64)`: The final liquidity amount added.
+    /// - `Err(SwapError)`: If the operation fails due to insufficient balance, invalid tick range,
+    ///   or other swap-related errors.
     ///
-    /// Removes the balances using state_ops.withdraw_balances()
+    /// ### Errors:
+    /// - [`SwapError::InsufficientBalance`] if the account does not have enough balance.
+    /// - [`SwapError::InvalidTickRange`] if `tick_low` is greater than or equal to `tick_high`.
+    /// - Other [`SwapError`] variants as applicable.
     ///
     pub fn add_liquidity(
-        &self,
+        &mut self,
         account_id: &AccountIdType,
         tick_low: i32,
         tick_high: i32,
         liquidity: u64,
-    ) -> Result<u64, SwapError> {
+        protocol: bool,
+    ) -> Result<(), SwapError> {
         // Check if we can add a position
         let position_count = self.state_ops.get_position_count(account_id);
         let max_positions = self.state_ops.get_max_positions();
@@ -292,12 +371,8 @@ where
         self.add_liquidity_at_index(tick_low, liquidity, false);
         self.add_liquidity_at_index(tick_high, liquidity, true);
 
-        // Update current tick and liquidity
-        // TODO: Review why python uses this code to get the new tick index:
-        // k = self.get_tick_index(i)
-        let current_tick_index = self.get_current_tick_index();
-
         // Update current tick liquidity
+        let current_tick_index = self.get_current_tick_index();
         if (tick_low <= current_tick_index) && (current_tick_index <= tick_high) {
             let new_current_liquidity = self
                 .state_ops
@@ -306,7 +381,7 @@ where
             self.state_ops.set_current_liquidity(new_current_liquidity);
         }
 
-        // Update balances
+        // New position
         let position = Position {
             tick_low,
             tick_high,
@@ -314,21 +389,24 @@ where
             fees_tao: 0_u64,
             fees_alpha: 0_u64,
         };
-        let (tao, alpha) = position.to_token_amounts(current_tick_index)?;
-        self.state_ops.withdraw_balances(account_id, tao, alpha);
 
-        // Update reserves
-        let new_tao_reserve = self.state_ops.get_tao_reserve().saturating_add(tao);
-        self.state_ops.set_tao_reserve(new_tao_reserve);
-        let new_alpha_reserve = self.state_ops.get_alpha_reserve().saturating_add(alpha);
-        self.state_ops.set_alpha_reserve(new_alpha_reserve);
+        // If this is a user transaction, withdraw balances and update reserves
+        if !protocol {
+            let current_price: SqrtPrice = self.state_ops.get_alpha_sqrt_price();
+            let (tao, alpha) = position.to_token_amounts(current_price)?;
+            self.state_ops.withdraw_balances(account_id, tao, alpha)?;
+
+            // Update reserves
+            let new_tao_reserve = self.state_ops.get_tao_reserve().saturating_add(tao);
+            self.state_ops.set_tao_reserve(new_tao_reserve);
+            let new_alpha_reserve = self.state_ops.get_alpha_reserve().saturating_add(alpha);
+            self.state_ops.set_alpha_reserve(new_alpha_reserve);
+        }
 
-        // Update user positions
-        let position_id = position_count.saturating_add(1);
-        self.state_ops
-            .update_position(account_id, position_id, position);
+        // Create a new user position
+        self.state_ops.create_position(account_id, position);
 
-        Ok(liquidity)
+        Ok(())
     }
 
     /// Remove liquidity and credit balances back to account_id
@@ -336,7 +414,7 @@ where
     /// Account ID and Position ID identify position in the storage map
     ///
     pub fn remove_liquidity(
-        &self,
+        &mut self,
         account_id: &AccountIdType,
         position_id: u16,
     ) -> Result<RemoveLiquidityResult, SwapError> {
@@ -347,7 +425,8 @@ where
 
             // Collect fees and get tao and alpha amounts
             let (fee_tao, fee_alpha) = self.collect_fees(&mut pos);
-            let (tao, alpha) = pos.to_token_amounts(current_tick_index)?;
+            let current_price: SqrtPrice = self.state_ops.get_alpha_sqrt_price();
+            let (tao, alpha) = pos.to_token_amounts(current_price)?;
 
             // Update liquidity at position ticks
             self.remove_liquidity_at_index(pos.tick_low, pos.liquidity, false);
@@ -387,7 +466,7 @@ where
     /// Returns a tuple (amount, refund), where amount is the resulting paid out amount
     ///
     pub fn swap(
-        &self,
+        &mut self,
         order_type: &OrderType,
         amount: u64,
         sqrt_price_limit: SqrtPrice,
@@ -499,7 +578,7 @@ where
         })
     }
 
-    fn get_current_tick_index(&self) -> i32 {
+    fn get_current_tick_index(&mut self) -> i32 {
         let current_price = self.state_ops.get_alpha_sqrt_price();
         let maybe_current_tick_index = sqrt_price_to_tick_index(current_price);
         if let Ok(index) = maybe_current_tick_index {
@@ -507,16 +586,16 @@ where
         } else {
             // Current price is out of allow the min-max range, and it should be corrected to
             // maintain the range.
-            let max_price =
-                tick_index_to_sqrt_price(MAX_TICK).unwrap_or(SqrtPrice::saturating_from_num(1000));
-            let min_price = tick_index_to_sqrt_price(MIN_TICK)
+            let max_price = tick_index_to_sqrt_price(MAX_TICK_INDEX)
+                .unwrap_or(SqrtPrice::saturating_from_num(1000));
+            let min_price = tick_index_to_sqrt_price(MIN_TICK_INDEX)
                 .unwrap_or(SqrtPrice::saturating_from_num(0.000001));
             if current_price > max_price {
                 self.state_ops.set_alpha_sqrt_price(max_price);
-                MAX_TICK
+                MAX_TICK_INDEX
             } else {
                 self.state_ops.set_alpha_sqrt_price(min_price);
-                MIN_TICK
+                MIN_TICK_INDEX
             }
         }
     }
@@ -524,7 +603,7 @@ where
     /// Process a single step of a swap
     ///
     fn swap_step(
-        &self,
+        &mut self,
         order_type: &OrderType,
         delta_in: u64,
         sqrt_price_final: SqrtPrice,
@@ -612,8 +691,8 @@ where
     ///
     fn get_sqrt_price_edge(&self, order_type: &OrderType) -> SqrtPrice {
         let fallback_price_edge_value = (match order_type {
-            OrderType::Buy => tick_index_to_sqrt_price(MIN_TICK),
-            OrderType::Sell => tick_index_to_sqrt_price(MAX_TICK),
+            OrderType::Buy => tick_index_to_sqrt_price(MIN_TICK_INDEX),
+            OrderType::Sell => tick_index_to_sqrt_price(MAX_TICK_INDEX),
         })
         .unwrap_or(SqrtPrice::saturating_from_num(0));
 
@@ -728,7 +807,7 @@ where
     }
 
     /// Add fees to the global fee counters
-    fn add_fees(&self, order_type: &OrderType, fee: u64) {
+    fn add_fees(&mut self, order_type: &OrderType, fee: u64) {
         let liquidity_curr = self.get_safe_current_liquidity();
         if liquidity_curr > 0 {
             let fee_global_tao: U64F64 = self.state_ops.get_fee_global_tao();
@@ -824,7 +903,7 @@ where
 
     /// Update token reserves after a swap
     ///
-    fn update_reserves(&self, order_type: &OrderType, amount_in: u64, amount_out: u64) {
+    fn update_reserves(&mut self, order_type: &OrderType, amount_in: u64, amount_out: u64) {
         let (new_tao_reserve, new_alpha_reserve) = match order_type {
             OrderType::Sell => (
                 self.state_ops.get_tao_reserve().saturating_add(amount_in),
@@ -855,7 +934,7 @@ where
 
     /// Update liquidity when crossing a tick
     ///
-    fn update_liquidity_at_crossing(&self, order_type: &OrderType) -> Result<(), SwapError> {
+    fn update_liquidity_at_crossing(&mut self, order_type: &OrderType) -> Result<(), SwapError> {
         let mut liquidity_curr = self.state_ops.get_current_liquidity();
         let current_tick_index = self.get_current_tick_index();
         match order_type {
@@ -896,7 +975,7 @@ where
     /// Collect fees for a position
     /// Updates the position
     ///
-    fn collect_fees(&self, position: &mut Position) -> (u64, u64) {
+    fn collect_fees(&mut self, position: &mut Position) -> (u64, u64) {
         let mut fee_tao = self.get_fees_in_range(position, true);
         let mut fee_alpha = self.get_fees_in_range(position, false);
 
@@ -916,7 +995,7 @@ where
     ///
     /// If quote flag is true, Tao is returned, otherwise alpha.
     ///
-    fn get_fees_in_range(&self, position: &mut Position, quote: bool) -> u64 {
+    fn get_fees_in_range(&mut self, position: &mut Position, quote: bool) -> u64 {
         let i_lower = position.tick_low;
         let i_upper = position.tick_high;
 
@@ -934,7 +1013,7 @@ where
 
     /// Get fees above a tick
     ///
-    fn get_fees_above(&self, tick_index: i32, quote: bool) -> U64F64 {
+    fn get_fees_above(&mut self, tick_index: i32, quote: bool) -> U64F64 {
         let maybe_tick_index = find_closest_lower_active_tick_index(&self.state_ops, tick_index);
         let current_tick = self.get_current_tick_index();
 
@@ -966,7 +1045,7 @@ where
     }
 
     /// Get fees below a tick
-    fn get_fees_below(&self, tick_index: i32, quote: bool) -> U64F64 {
+    fn get_fees_below(&mut self, tick_index: i32, quote: bool) -> U64F64 {
         let maybe_tick_index = find_closest_lower_active_tick_index(&self.state_ops, tick_index);
         let current_tick = self.get_current_tick_index();
 
@@ -1015,3 +1094,491 @@ where
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use approx::assert_abs_diff_eq;
+    use sp_arithmetic::helpers_128bit::sqrt;
+    use std::collections::HashMap;
+
+    #[derive(Debug, Clone)]
+    pub struct MockSwapDataOperations {
+        is_initialized: bool,
+        fee_rate: u16,
+        minimum_liquidity: u64,
+        ticks: HashMap<i32, Tick>,
+        min_sqrt_price: SqrtPrice,
+        max_sqrt_price: SqrtPrice,
+        tao_reserve: u64,
+        alpha_reserve: u64,
+        alpha_sqrt_price: SqrtPrice,
+        fee_global_tao: U64F64,
+        fee_global_alpha: U64F64,
+        current_liquidity: u64,
+        max_positions: u16,
+        balances: HashMap<u16, (u64, u64)>,
+        positions: HashMap<u16, HashMap<u16, Position>>,
+    }
+
+    impl MockSwapDataOperations {
+        pub fn new() -> Self {
+            Self {
+                is_initialized: false,
+                fee_rate: 196,
+                minimum_liquidity: 1000,
+                ticks: HashMap::new(),
+                min_sqrt_price: SqrtPrice::from_num(0.01),
+                max_sqrt_price: SqrtPrice::from_num(10),
+                tao_reserve: 0,
+                alpha_reserve: 0,
+                alpha_sqrt_price: SqrtPrice::from_num(0),
+                fee_global_tao: U64F64::from_num(0),
+                fee_global_alpha: U64F64::from_num(0),
+                current_liquidity: 0,
+                max_positions: 100,
+                balances: HashMap::new(),
+                positions: HashMap::new(),
+            }
+        }
+    }
+
+    impl SwapDataOperations<u16> for MockSwapDataOperations {
+        fn is_v3_initialized(&self) -> bool {
+            self.is_initialized
+        }
+
+        fn set_v3_initialized(&mut self) {
+            self.is_initialized = true;
+        }
+
+        fn get_fee_rate(&self) -> u16 {
+            self.fee_rate
+        }
+
+        fn get_minimum_liquidity(&self) -> u64 {
+            self.minimum_liquidity
+        }
+
+        fn get_tick_by_index(&self, tick_index: i32) -> Option<Tick> {
+            self.ticks.get(&tick_index).cloned()
+        }
+
+        fn insert_tick_by_index(&mut self, tick_index: i32, tick: Tick) {
+            self.ticks.insert(tick_index, tick);
+        }
+
+        fn remove_tick_by_index(&mut self, tick_index: i32) {
+            self.ticks.remove(&tick_index);
+        }
+
+        fn get_min_sqrt_price(&self) -> SqrtPrice {
+            self.min_sqrt_price
+        }
+
+        fn get_max_sqrt_price(&self) -> SqrtPrice {
+            self.max_sqrt_price
+        }
+
+        fn get_tao_reserve(&self) -> u64 {
+            self.tao_reserve
+        }
+
+        fn set_tao_reserve(&mut self, tao: u64) -> u64 {
+            self.tao_reserve = tao;
+            tao
+        }
+
+        fn get_alpha_reserve(&self) -> u64 {
+            self.alpha_reserve
+        }
+
+        fn set_alpha_reserve(&mut self, alpha: u64) -> u64 {
+            self.alpha_reserve = alpha;
+            alpha
+        }
+
+        fn get_alpha_sqrt_price(&self) -> SqrtPrice {
+            self.alpha_sqrt_price
+        }
+
+        fn set_alpha_sqrt_price(&mut self, sqrt_price: SqrtPrice) {
+            self.alpha_sqrt_price = sqrt_price;
+        }
+
+        fn get_fee_global_tao(&self) -> U64F64 {
+            self.fee_global_tao
+        }
+
+        fn set_fee_global_tao(&mut self, fee: U64F64) {
+            self.fee_global_tao = fee;
+        }
+
+        fn get_fee_global_alpha(&self) -> U64F64 {
+            self.fee_global_alpha
+        }
+
+        fn set_fee_global_alpha(&mut self, fee: U64F64) {
+            self.fee_global_alpha = fee;
+        }
+
+        fn get_current_liquidity(&self) -> u64 {
+            self.current_liquidity
+        }
+
+        fn set_current_liquidity(&mut self, liquidity: u64) {
+            self.current_liquidity = liquidity;
+        }
+
+        fn get_max_positions(&self) -> u16 {
+            self.max_positions
+        }
+
+        fn withdraw_balances(
+            &mut self,
+            account_id: &u16,
+            tao: u64,
+            alpha: u64,
+        ) -> Result<(u64, u64), SwapError> {
+            let (current_tao, current_alpha) =
+                self.balances.get(account_id).cloned().unwrap_or((0, 0));
+
+            if (tao > current_tao) || (alpha > current_alpha) {
+                return Err(SwapError::InsufficientBalance);
+            }
+
+            self.balances
+                .insert(*account_id, (current_tao - tao, current_alpha - alpha));
+
+            Ok((tao, alpha))
+        }
+
+        fn deposit_balances(&mut self, account_id: &u16, tao: u64, alpha: u64) {
+            let (current_tao, current_alpha) =
+                self.balances.get(account_id).cloned().unwrap_or((0, 0));
+            self.balances.insert(
+                account_id.clone(),
+                (current_tao + tao, current_alpha + alpha),
+            );
+        }
+
+        fn get_protocol_account_id(&self) -> u16 {
+            0xFFFF
+        }
+
+        fn get_position_count(&self, account_id: &u16) -> u16 {
+            self.positions.get(account_id).map_or(0, |p| p.len() as u16)
+        }
+
+        fn get_position(&self, account_id: &u16, position_id: u16) -> Option<Position> {
+            self.positions
+                .get(account_id)
+                .and_then(|p| p.get(&position_id).cloned())
+        }
+
+        fn create_position(&mut self, account_id: &u16, position: Position) -> u16 {
+            let entry = self
+                .positions
+                .entry(account_id.clone())
+                .or_insert_with(HashMap::new);
+
+            // Find the next available position ID
+            let new_position_id = entry.keys().max().map_or(0, |max_id| max_id + 1);
+
+            entry.insert(new_position_id, position);
+            new_position_id
+        }
+
+        fn update_position(&mut self, account_id: &u16, position_id: u16, position: Position) {
+            if let Some(account_positions) = self.positions.get_mut(account_id) {
+                account_positions.insert(position_id, position);
+            }
+        }
+
+        fn remove_position(&mut self, account_id: &u16, position_id: u16) {
+            if let Some(account_positions) = self.positions.get_mut(account_id) {
+                account_positions.remove(&position_id);
+            }
+        }
+    }
+
+    #[test]
+    fn test_swap_initialization() {
+        let tao = 1_000_000_000;
+        let alpha = 4_000_000_000;
+
+        let mut mock_ops = MockSwapDataOperations::new();
+        mock_ops.set_tao_reserve(tao);
+        mock_ops.set_alpha_reserve(alpha);
+        let swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
+
+        // Active ticks
+        let tick_low = swap.state_ops.get_tick_by_index(MIN_TICK_INDEX).unwrap();
+        let tick_high = swap.state_ops.get_tick_by_index(MAX_TICK_INDEX).unwrap();
+        let liquidity = sqrt(alpha as u128 * tao as u128) as u64;
+        let expected_liquidity_net_low: i128 = liquidity as i128;
+        let expected_liquidity_gross_low: u64 = liquidity;
+        let expected_liquidity_net_high: i128 = (liquidity as i128).neg();
+        let expected_liquidity_gross_high: u64 = liquidity;
+        assert_eq!(tick_low.liquidity_net, expected_liquidity_net_low,);
+        assert_eq!(tick_low.liquidity_gross, expected_liquidity_gross_low,);
+        assert_eq!(tick_high.liquidity_net, expected_liquidity_net_high,);
+        assert_eq!(tick_high.liquidity_gross, expected_liquidity_gross_high,);
+
+        // Liquidity position at correct ticks
+        let account_id = swap.state_ops.get_protocol_account_id();
+        assert_eq!(swap.state_ops.get_position_count(&account_id), 1);
+
+        let position = swap.state_ops.get_position(&account_id, 0).unwrap();
+        assert_eq!(position.liquidity, liquidity);
+        assert_eq!(position.tick_low, MIN_TICK_INDEX);
+        assert_eq!(position.tick_high, MAX_TICK_INDEX);
+        assert_eq!(position.fees_alpha, 0);
+        assert_eq!(position.fees_tao, 0);
+
+        // Current liquidity
+        assert_eq!(swap.state_ops.get_current_liquidity(), liquidity);
+
+        // Current price
+        let sqrt_price = swap.state_ops.get_alpha_sqrt_price();
+        assert_abs_diff_eq!(sqrt_price.to_num::<f64>(), 0.50, epsilon = 0.00001,);
+    }
+
+    fn price_to_tick(price: f64) -> i32 {
+        let price_sqrt: SqrtPrice = SqrtPrice::from_num(price.sqrt());
+        let mut tick = sqrt_price_to_tick_index(price_sqrt).unwrap();
+        if tick > MAX_TICK_INDEX {
+            tick = MAX_TICK_INDEX
+        }
+        tick
+    }
+
+    fn tick_to_price(tick: i32) -> f64 {
+        let price_sqrt: SqrtPrice = tick_index_to_sqrt_price(tick).unwrap();
+        (price_sqrt * price_sqrt).to_num::<f64>()
+    }
+
+    #[test]
+    fn test_tick_price_sanity_check() {
+        let min_price = tick_to_price(MIN_TICK_INDEX);
+        let max_price = tick_to_price(MAX_TICK_INDEX);
+        assert!(min_price > 0.);
+        assert!(max_price > 0.);
+        assert!(max_price > min_price);
+        assert!(min_price < 0.000001);
+        assert!(max_price > 10.);
+
+        // Roundtrip conversions
+        let min_price_sqrt: SqrtPrice = tick_index_to_sqrt_price(MIN_TICK_INDEX).unwrap();
+        let min_tick = sqrt_price_to_tick_index(min_price_sqrt).unwrap();
+        assert_eq!(min_tick, MIN_TICK_INDEX);
+
+        let max_price_sqrt: SqrtPrice = tick_index_to_sqrt_price(MAX_TICK_INDEX).unwrap();
+        let max_tick = sqrt_price_to_tick_index(max_price_sqrt).unwrap();
+        assert_eq!(max_tick, MAX_TICK_INDEX);
+    }
+
+    // Test adding liquidity on top of the existing protocol liquidity
+    #[test]
+    fn test_add_liquidity_basic() {
+        let protocol_tao = 1_000_000_000;
+        let protocol_alpha = 4_000_000_000;
+        let user_tao = 100_000_000_000;
+        let user_alpha = 100_000_000_000;
+        let account_id = 1;
+        let min_price = tick_to_price(MIN_TICK_INDEX);
+        let max_price = tick_to_price(MAX_TICK_INDEX);
+        let max_tick = price_to_tick(max_price);
+        let current_price = 0.25;
+        assert_eq!(max_tick, MAX_TICK_INDEX);
+
+        // As a user add liquidity with all possible corner cases
+        //   - Initial price is 0.25
+        //   - liquidity is expressed in RAO units
+        // Test case is (price_low, price_high, liquidity, tao, alpha)
+        [
+            // Repeat the protocol liquidity at maximum range: Expect all the same values
+            (
+                min_price,
+                max_price,
+                2_000_000_000_u64,
+                1_000_000_000_u64,
+                4_000_000_000_u64,
+            ),
+            // Repeat the protocol liquidity at current to max range: Expect the same alpha
+            (0.25, max_price, 2_000_000_000_u64, 0, 4_000_000_000),
+            // Repeat the protocol liquidity at min to current range: Expect all the same tao
+            (min_price, 0.24999, 2_000_000_000_u64, 1_000_000_000, 0),
+            // Half to double price - just some sane wothdraw amounts
+            (0.125, 0.5, 2_000_000_000_u64, 293_000_000, 1_171_000_000),
+            // Both below price - tao is non-zero, alpha is zero
+            (0.12, 0.13, 2_000_000_000_u64, 28_270_000, 0),
+            // Both above price - tao is zero, alpha is non-zero
+            (0.3, 0.4, 2_000_000_000_u64, 0, 489_200_000),
+        ]
+        .iter()
+        .for_each(|(price_low, price_high, liquidity, tao, alpha)| {
+            // Calculate ticks (assuming tick math is tested separately)
+            let tick_low = price_to_tick(*price_low);
+            let tick_high = price_to_tick(*price_high);
+
+            // Setup swap
+            let mut mock_ops = MockSwapDataOperations::new();
+            mock_ops.set_tao_reserve(protocol_tao);
+            mock_ops.set_alpha_reserve(protocol_alpha);
+            mock_ops.deposit_balances(&account_id, user_tao, user_alpha);
+            let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
+
+            // Get tick infos and liquidity before adding (to account for protocol liquidity)
+            let tick_low_info_before = swap
+                .state_ops
+                .get_tick_by_index(tick_low)
+                .unwrap_or_default();
+            let tick_high_info_before = swap
+                .state_ops
+                .get_tick_by_index(tick_high)
+                .unwrap_or_default();
+            let liquidity_before = swap.state_ops.get_current_liquidity();
+
+            // Add liquidity
+            assert!(
+                swap.add_liquidity(&1, tick_low, tick_high, *liquidity, false)
+                    .is_ok()
+            );
+
+            // Check that low and high ticks appear in the state and are properly updated
+            let tick_low_info = swap.state_ops.get_tick_by_index(tick_low).unwrap();
+            let tick_high_info = swap.state_ops.get_tick_by_index(tick_high).unwrap();
+            let expected_liquidity_net_low: i128 = *liquidity as i128;
+            let expected_liquidity_gross_low: u64 = *liquidity;
+            let expected_liquidity_net_high: i128 = (*liquidity as i128).neg();
+            let expected_liquidity_gross_high: u64 = *liquidity;
+            assert_eq!(
+                tick_low_info.liquidity_net - tick_low_info_before.liquidity_net,
+                expected_liquidity_net_low,
+            );
+            assert_eq!(
+                tick_low_info.liquidity_gross - tick_low_info_before.liquidity_gross,
+                expected_liquidity_gross_low,
+            );
+            assert_eq!(
+                tick_high_info.liquidity_net - tick_high_info_before.liquidity_net,
+                expected_liquidity_net_high,
+            );
+            assert_eq!(
+                tick_high_info.liquidity_gross - tick_high_info_before.liquidity_gross,
+                expected_liquidity_gross_high,
+            );
+
+            // Balances are withdrawn
+            let (user_tao_after, user_alpha_after) =
+                swap.state_ops.balances.get(&account_id).unwrap();
+            let tao_withdrawn = user_tao - user_tao_after;
+            let alpha_withdrawn = user_alpha - user_alpha_after;
+            assert_abs_diff_eq!(tao_withdrawn, *tao, epsilon = *tao / 1000);
+            assert_abs_diff_eq!(alpha_withdrawn, *alpha, epsilon = *alpha / 1000);
+
+            // Liquidity position at correct ticks
+            assert_eq!(swap.state_ops.get_position_count(&account_id), 1);
+
+            let position = swap.state_ops.get_position(&account_id, 0).unwrap();
+            assert_eq!(position.liquidity, *liquidity);
+            assert_eq!(position.tick_low, tick_low);
+            assert_eq!(position.tick_high, tick_high);
+            assert_eq!(position.fees_alpha, 0);
+            assert_eq!(position.fees_tao, 0);
+
+            // Current liquidity is updated only when price range includes the current price
+            if (*price_high >= current_price) && (*price_low <= current_price) {
+                assert_eq!(
+                    swap.state_ops.get_current_liquidity(),
+                    liquidity_before + *liquidity
+                );
+            } else {
+                assert_eq!(swap.state_ops.get_current_liquidity(), liquidity_before);
+            }
+
+            // Reserves are updated
+            assert_eq!(
+                swap.state_ops.get_tao_reserve(),
+                tao_withdrawn + protocol_tao,
+            );
+            assert_eq!(
+                swap.state_ops.get_alpha_reserve(),
+                alpha_withdrawn + protocol_alpha,
+            );
+        });
+    }
+
+    #[test]
+    fn test_add_liquidity_out_of_bounds() {
+        let protocol_tao = 1_000_000_000;
+        let protocol_alpha = 2_000_000_000;
+        let user_tao = 100_000_000_000;
+        let user_alpha = 100_000_000_000;
+        let account_id = 1;
+
+        [
+            (MIN_TICK_INDEX - 1, MAX_TICK_INDEX, 1_000_000_000_u64),
+            (MIN_TICK_INDEX, MAX_TICK_INDEX + 1, 1_000_000_000_u64),
+            (MIN_TICK_INDEX - 1, MAX_TICK_INDEX + 1, 1_000_000_000_u64),
+            (
+                MIN_TICK_INDEX - 100,
+                MAX_TICK_INDEX + 100,
+                1_000_000_000_u64,
+            ),
+        ]
+        .iter()
+        .for_each(|(tick_low, tick_high, liquidity)| {
+            // Setup swap
+            let mut mock_ops = MockSwapDataOperations::new();
+            mock_ops.set_tao_reserve(protocol_tao);
+            mock_ops.set_alpha_reserve(protocol_alpha);
+            mock_ops.deposit_balances(&account_id, user_tao, user_alpha);
+            let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
+
+            // Add liquidity
+            assert_eq!(
+                swap.add_liquidity(&1, *tick_low, *tick_high, *liquidity, false),
+                Err(SwapError::InvalidTickRange),
+            );
+        });
+    }
+
+    #[test]
+    fn test_add_liquidity_over_balance() {
+        let protocol_tao = 1_000_000_000;
+        let protocol_alpha = 4_000_000_000;
+        let user_tao = 1_000_000_000;
+        let user_alpha = 1_000_000_000;
+        let account_id = 1;
+
+        [
+            // Lower than price (not enough alpha)
+            (0.1, 0.2, 100_000_000_000_u64),
+            // Higher than price (not enough tao)
+            (0.3, 0.4, 100_000_000_000_u64),
+            // Around the price (not enough both)
+            (0.1, 0.4, 100_000_000_000_u64),
+        ]
+        .iter()
+        .for_each(|(price_low, price_high, liquidity)| {
+            // Calculate ticks
+            let tick_low = price_to_tick(*price_low);
+            let tick_high = price_to_tick(*price_high);
+
+            // Setup swap
+            let mut mock_ops = MockSwapDataOperations::new();
+            mock_ops.set_tao_reserve(protocol_tao);
+            mock_ops.set_alpha_reserve(protocol_alpha);
+            mock_ops.deposit_balances(&account_id, user_tao, user_alpha);
+            let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
+
+            // Add liquidity
+            assert_eq!(
+                swap.add_liquidity(&1, tick_low, tick_high, *liquidity, false),
+                Err(SwapError::InsufficientBalance),
+            );
+        });
+    }
+}
diff --git a/primitives/swap/src/tick.rs b/primitives/swap/src/tick.rs
index d46fbd9610..e5e7eefc16 100644
--- a/primitives/swap/src/tick.rs
+++ b/primitives/swap/src/tick.rs
@@ -6,6 +6,12 @@ use crate::tick_math::{
 };
 use crate::{SqrtPrice, SwapDataOperations};
 
+// Maximum and minimum values of the tick index
+// The tick_math library uses different bitness, so we have to divide by 2.
+// Do not use tick_math::MIN_TICK and tick_math::MAX_TICK
+pub const MAX_TICK_INDEX: i32 = MAX_TICK / 2;
+pub const MIN_TICK_INDEX: i32 = MIN_TICK / 2;
+
 /// Tick is the price range determined by tick index (not part of this struct,
 /// but is the key at which the Tick is stored in state hash maps). Tick struct
 /// stores liquidity and fee information.
@@ -14,7 +20,7 @@ use crate::{SqrtPrice, SwapDataOperations};
 ///   - Gross liquidity
 ///   - Fees (above global) in both currencies
 ///
-#[derive(Default)]
+#[derive(Debug, Default, Clone)]
 pub struct Tick {
     pub liquidity_net: i128,
     pub liquidity_gross: u64,

From 5ba307f52534278ca6a3690fb60ac203d988cdc2 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Thu, 20 Mar 2025 13:10:20 -0400
Subject: [PATCH 020/418] Remove liquidity fully tested and debugged

---
 primitives/swap/src/lib.rs | 150 ++++++++++++++++++++++++++++++++++++-
 1 file changed, 147 insertions(+), 3 deletions(-)

diff --git a/primitives/swap/src/lib.rs b/primitives/swap/src/lib.rs
index 39e934aa7b..24f9bff96e 100644
--- a/primitives/swap/src/lib.rs
+++ b/primitives/swap/src/lib.rs
@@ -29,6 +29,7 @@ pub enum SwapStepAction {
     StopIn,
 }
 
+#[derive(Debug, PartialEq)]
 pub struct RemoveLiquidityResult {
     tao: u64,
     alpha: u64,
@@ -36,11 +37,13 @@ pub struct RemoveLiquidityResult {
     fee_alpha: u64,
 }
 
+#[derive(Debug, PartialEq)]
 pub struct SwapResult {
     amount_paid_out: u64,
     refund: u64,
 }
 
+#[derive(Debug, PartialEq)]
 struct SwapStepResult {
     amount_to_take: u64,
     delta_out: u64,
@@ -444,6 +447,15 @@ where
             // Remove user position
             self.state_ops.remove_position(account_id, position_id);
 
+            // Deposit balances
+            self.state_ops.deposit_balances(account_id, tao, alpha);
+
+            // Update reserves
+            let new_tao_reserve = self.state_ops.get_tao_reserve().saturating_sub(tao);
+            self.state_ops.set_tao_reserve(new_tao_reserve);
+            let new_alpha_reserve = self.state_ops.get_alpha_reserve().saturating_sub(alpha);
+            self.state_ops.set_alpha_reserve(new_alpha_reserve);
+
             // TODO: Clear with R&D
             // Update current price (why?)
             // self.state_ops.set_alpha_sqrt_price(sqrt_price);
@@ -1442,7 +1454,7 @@ mod tests {
 
             // Add liquidity
             assert!(
-                swap.add_liquidity(&1, tick_low, tick_high, *liquidity, false)
+                swap.add_liquidity(&account_id, tick_low, tick_high, *liquidity, false)
                     .is_ok()
             );
 
@@ -1539,7 +1551,7 @@ mod tests {
 
             // Add liquidity
             assert_eq!(
-                swap.add_liquidity(&1, *tick_low, *tick_high, *liquidity, false),
+                swap.add_liquidity(&account_id, *tick_low, *tick_high, *liquidity, false),
                 Err(SwapError::InvalidTickRange),
             );
         });
@@ -1576,9 +1588,141 @@ mod tests {
 
             // Add liquidity
             assert_eq!(
-                swap.add_liquidity(&1, tick_low, tick_high, *liquidity, false),
+                swap.add_liquidity(&account_id, tick_low, tick_high, *liquidity, false),
                 Err(SwapError::InsufficientBalance),
             );
         });
     }
+
+    // Test removing liquidity
+    #[test]
+    fn test_remove_liquidity_basic() {
+        let protocol_tao = 1_000_000_000;
+        let protocol_alpha = 4_000_000_000;
+        let user_tao = 100_000_000_000;
+        let user_alpha = 100_000_000_000;
+        let account_id = 1;
+        let min_price = tick_to_price(MIN_TICK_INDEX);
+        let max_price = tick_to_price(MAX_TICK_INDEX);
+        let max_tick = price_to_tick(max_price);
+        assert_eq!(max_tick, MAX_TICK_INDEX);
+
+        // As a user add liquidity with all possible corner cases
+        //   - Initial price is 0.25
+        //   - liquidity is expressed in RAO units
+        // Test case is (price_low, price_high, liquidity, tao, alpha)
+        [
+            // Repeat the protocol liquidity at maximum range: Expect all the same values
+            (
+                min_price,
+                max_price,
+                2_000_000_000_u64,
+                1_000_000_000_u64,
+                4_000_000_000_u64,
+            ),
+            // Repeat the protocol liquidity at current to max range: Expect the same alpha
+            (0.25, max_price, 2_000_000_000_u64, 0, 4_000_000_000),
+            // Repeat the protocol liquidity at min to current range: Expect all the same tao
+            (min_price, 0.24999, 2_000_000_000_u64, 1_000_000_000, 0),
+            // Half to double price - just some sane wothdraw amounts
+            (0.125, 0.5, 2_000_000_000_u64, 293_000_000, 1_171_000_000),
+            // Both below price - tao is non-zero, alpha is zero
+            (0.12, 0.13, 2_000_000_000_u64, 28_270_000, 0),
+            // Both above price - tao is zero, alpha is non-zero
+            (0.3, 0.4, 2_000_000_000_u64, 0, 489_200_000),
+        ]
+        .iter()
+        .for_each(|(price_low, price_high, liquidity, tao, alpha)| {
+            // Calculate ticks (assuming tick math is tested separately)
+            let tick_low = price_to_tick(*price_low);
+            let tick_high = price_to_tick(*price_high);
+
+            // Setup swap
+            let mut mock_ops = MockSwapDataOperations::new();
+            mock_ops.set_tao_reserve(protocol_tao);
+            mock_ops.set_alpha_reserve(protocol_alpha);
+            mock_ops.deposit_balances(&account_id, user_tao, user_alpha);
+            let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
+            let liquidity_before = swap.state_ops.get_current_liquidity();
+
+            // Add liquidity
+            assert!(
+                swap.add_liquidity(&account_id, tick_low, tick_high, *liquidity, false)
+                    .is_ok()
+            );
+
+            // Remove liquidity
+            let remove_result = swap.remove_liquidity(&account_id, 0).unwrap();
+            assert_abs_diff_eq!(remove_result.tao, *tao, epsilon = *tao / 1000);
+            assert_abs_diff_eq!(remove_result.alpha, *alpha, epsilon = *alpha / 1000);
+            assert_eq!(remove_result.fee_tao, 0);
+            assert_eq!(remove_result.fee_alpha, 0);
+
+            // Balances are returned
+            let (user_tao_after, user_alpha_after) =
+                swap.state_ops.balances.get(&account_id).unwrap();
+            assert_eq!(user_tao, *user_tao_after);
+            assert_eq!(user_alpha, *user_alpha_after);
+
+            // Liquidity position is removed
+            assert_eq!(swap.state_ops.get_position_count(&account_id), 0);
+            assert!(swap.state_ops.get_position(&account_id, 0).is_none());
+
+            // Current liquidity is updated (back where it was)
+            assert_eq!(swap.state_ops.get_current_liquidity(), liquidity_before);
+
+            // Reserves are updated (back where they were)
+            assert_eq!(swap.state_ops.get_tao_reserve(), protocol_tao,);
+            assert_eq!(swap.state_ops.get_alpha_reserve(), protocol_alpha,);
+        });
+    }
+
+    #[test]
+    fn test_remove_liquidity_nonexisting_position() {
+        let protocol_tao = 1_000_000_000;
+        let protocol_alpha = 4_000_000_000;
+        let user_tao = 100_000_000_000;
+        let user_alpha = 100_000_000_000;
+        let account_id = 1;
+        let min_price = tick_to_price(MIN_TICK_INDEX);
+        let max_price = tick_to_price(MAX_TICK_INDEX);
+        let max_tick = price_to_tick(max_price);
+        assert_eq!(max_tick, MAX_TICK_INDEX);
+
+        // Test case is (price_low, price_high, liquidity)
+        [
+            // Repeat the protocol liquidity at maximum range: Expect all the same values
+            (
+                min_price,
+                max_price,
+                2_000_000_000_u64,
+            ),
+        ]
+        .iter()
+        .for_each(|(price_low, price_high, liquidity)| {
+            // Calculate ticks (assuming tick math is tested separately)
+            let tick_low = price_to_tick(*price_low);
+            let tick_high = price_to_tick(*price_high);
+
+            // Setup swap
+            let mut mock_ops = MockSwapDataOperations::new();
+            mock_ops.set_tao_reserve(protocol_tao);
+            mock_ops.set_alpha_reserve(protocol_alpha);
+            mock_ops.deposit_balances(&account_id, user_tao, user_alpha);
+            let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
+
+            // Add liquidity
+            assert!(
+                swap.add_liquidity(&account_id, tick_low, tick_high, *liquidity, false)
+                    .is_ok()
+            );
+
+            // Remove liquidity
+            assert_eq!(
+                swap.remove_liquidity(&account_id, 1),
+                Err(SwapError::LiquidityNotFound),
+            );
+        });
+    }
+
 }

From cdc9cfa8fd0674671951063cfa8d1b78820f9480 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Thu, 20 Mar 2025 20:09:12 +0100
Subject: [PATCH 021/418] Move swap into pallet

---
 Cargo.lock                        |   17 +
 Cargo.toml                        |    1 +
 pallets/swap-interface/Cargo.toml |   13 +
 pallets/swap-interface/src/lib.rs |   23 +
 pallets/swap/Cargo.toml           |   27 +
 pallets/swap/src/error.rs         |   26 +
 pallets/swap/src/lib.rs           | 1718 +++++++++++++++++++++++++++++
 pallets/swap/src/tick.rs          |  191 ++++
 pallets/swap/src/tick_math.rs     |  539 +++++++++
 9 files changed, 2555 insertions(+)
 create mode 100644 pallets/swap-interface/Cargo.toml
 create mode 100644 pallets/swap-interface/src/lib.rs
 create mode 100644 pallets/swap/Cargo.toml
 create mode 100644 pallets/swap/src/error.rs
 create mode 100644 pallets/swap/src/lib.rs
 create mode 100644 pallets/swap/src/tick.rs
 create mode 100644 pallets/swap/src/tick_math.rs

diff --git a/Cargo.lock b/Cargo.lock
index eb568725ab..6457e7e9e7 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6834,6 +6834,23 @@ dependencies = [
  "w3f-bls",
 ]
 
+[[package]]
+name = "pallet-subtensor-swap"
+version = "0.1.0"
+dependencies = [
+ "alloy-primitives",
+ "approx",
+ "pallet-subtensor-swap-interface",
+ "safe-math",
+ "sp-arithmetic",
+ "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409)",
+ "substrate-fixed",
+]
+
+[[package]]
+name = "pallet-subtensor-swap-interface"
+version = "0.1.0"
+
 [[package]]
 name = "pallet-sudo"
 version = "38.0.0"
diff --git a/Cargo.toml b/Cargo.toml
index d3cedd96d0..fa6c2b396a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -56,6 +56,7 @@ subtensor-custom-rpc = { default-features = false, path = "pallets/subtensor/rpc
 subtensor-custom-rpc-runtime-api = { default-features = false, path = "pallets/subtensor/runtime-api" }
 subtensor-precompiles = { default-features = false, path = "precompiles" }
 subtensor-runtime-common = { default-features = false, path = "common" }
+pallet-subtensor-swap-interface = { default-features = false, path = "pallets/swap-interface" }
 
 async-trait = "0.1"
 cargo-husky = { version = "1", default-features = false }
diff --git a/pallets/swap-interface/Cargo.toml b/pallets/swap-interface/Cargo.toml
new file mode 100644
index 0000000000..28c05cac3e
--- /dev/null
+++ b/pallets/swap-interface/Cargo.toml
@@ -0,0 +1,13 @@
+[package]
+name = "pallet-subtensor-swap-interface"
+version = "0.1.0"
+edition.workspace = true
+
+[dependencies]
+
+[lints]
+workspace = true
+
+[features]
+default = ["std"]
+std = []
diff --git a/pallets/swap-interface/src/lib.rs b/pallets/swap-interface/src/lib.rs
new file mode 100644
index 0000000000..a5dd7f415e
--- /dev/null
+++ b/pallets/swap-interface/src/lib.rs
@@ -0,0 +1,23 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+extern crate alloc;
+
+use alloc::boxed::Box;
+use core::error::Error;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum OrderType {
+    Sell,
+    Buy,
+}
+
+pub trait SwapHandler<AccountId> {
+    fn swap(order_t: OrderType, amount: u64) -> Result<(), Box<dyn Error>>;
+    fn add_liquidity(account_id: AccountId, liquidity: u64) -> Result<(), Box<dyn Error>>;
+    fn remove_liquidity(account_id: AccountId) -> Result<(), Box<dyn Error>>;
+}
+
+pub trait LiquidityDataProvider<First, Second> {
+    fn first_reserve() -> First;
+    fn second_reserve() -> Second;
+}
diff --git a/pallets/swap/Cargo.toml b/pallets/swap/Cargo.toml
new file mode 100644
index 0000000000..362ed0e429
--- /dev/null
+++ b/pallets/swap/Cargo.toml
@@ -0,0 +1,27 @@
+[package]
+name = "pallet-subtensor-swap"
+version = "0.1.0"
+edition = { workspace = true }
+
+[dependencies]
+alloy-primitives = { workspace = true }
+approx = { workspace = true }
+safe-math = { workspace = true }
+sp-arithmetic = { workspace = true }
+sp-std = { workspace = true }
+substrate-fixed = { workspace = true }
+
+pallet-subtensor-swap-interface = { workspace = true }
+
+[lints]
+workspace = true
+
+[features]
+default = ["std"]
+std = [
+	"alloy-primitives/std",
+	"safe-math/std",
+	"sp-arithmetic/std",
+	"sp-std/std",
+	"substrate-fixed/std",
+]
diff --git a/pallets/swap/src/error.rs b/pallets/swap/src/error.rs
new file mode 100644
index 0000000000..748f6a740a
--- /dev/null
+++ b/pallets/swap/src/error.rs
@@ -0,0 +1,26 @@
+#[derive(Debug, PartialEq, Eq)]
+pub enum SwapError {
+    /// The provided amount is insufficient for the swap.
+    InsufficientInputAmount,
+
+    /// The provided liquidity is insufficient for the operation.
+    InsufficientLiquidity,
+
+    /// The operation would exceed the price limit.
+    PriceLimitExceeded,
+
+    /// The caller does not have enough balance for the operation.
+    InsufficientBalance,
+
+    /// Attempted to remove liquidity that does not exist.
+    LiquidityNotFound,
+
+    /// The provided tick range is invalid.
+    InvalidTickRange,
+
+    /// Maximum user positions exceeded
+    MaxPositionsExceeded,
+
+    /// Too many swap steps
+    TooManySwapSteps,
+}
diff --git a/pallets/swap/src/lib.rs b/pallets/swap/src/lib.rs
new file mode 100644
index 0000000000..6926758e80
--- /dev/null
+++ b/pallets/swap/src/lib.rs
@@ -0,0 +1,1718 @@
+use core::marker::PhantomData;
+use std::ops::Neg;
+
+use pallet_subtensor_swap_interface::OrderType;
+use safe_math::*;
+use sp_arithmetic::helpers_128bit::sqrt;
+use substrate_fixed::types::U64F64;
+
+use self::error::SwapError;
+use self::tick::{
+    MAX_TICK_INDEX, MIN_TICK_INDEX, Tick, find_closest_higher_active_tick_index,
+    find_closest_lower_active_tick_index, sqrt_price_to_tick_index, tick_index_to_sqrt_price,
+};
+
+mod error;
+mod tick;
+mod tick_math;
+
+type SqrtPrice = U64F64;
+
+pub enum SwapStepAction {
+    Crossing,
+    StopOn,
+    StopIn,
+}
+
+#[derive(Debug, PartialEq)]
+pub struct RemoveLiquidityResult {
+    tao: u64,
+    alpha: u64,
+    fee_tao: u64,
+    fee_alpha: u64,
+}
+
+#[derive(Debug, PartialEq)]
+pub struct SwapResult {
+    amount_paid_out: u64,
+    refund: u64,
+}
+
+#[derive(Debug, PartialEq)]
+struct SwapStepResult {
+    amount_to_take: u64,
+    delta_out: u64,
+}
+
+/// Position designates one liquidity position.
+///
+/// Alpha price is expressed in rao units per one 10^9 unit. For example,
+/// price 1_000_000 is equal to 0.001 TAO per Alpha.
+///
+/// tick_low - tick index for lower boundary of price
+/// tick_high - tick index for higher boundary of price
+/// liquidity - position liquidity
+/// fees_tao - fees accrued by the position in quote currency (TAO)
+/// fees_alpha - fees accrued by the position in base currency (Alpha)
+///
+#[cfg_attr(test, derive(Debug, PartialEq, Clone))]
+pub struct Position {
+    tick_low: i32,
+    tick_high: i32,
+    liquidity: u64,
+    fees_tao: u64,
+    fees_alpha: u64,
+}
+
+impl Position {
+    /// Converts position to token amounts
+    ///
+    /// returns tuple of (TAO, Alpha)
+    ///
+    /// Pseudocode:
+    ///     if self.sqrt_price_curr < sqrt_pa:
+    ///         tao = 0
+    ///         alpha = L * (1 / sqrt_pa - 1 / sqrt_pb)
+    ///     elif self.sqrt_price_curr > sqrt_pb:
+    ///         tao = L * (sqrt_pb - sqrt_pa)
+    ///         alpha = 0
+    ///     else:
+    ///         tao = L * (self.sqrt_price_curr - sqrt_pa)
+    ///         alpha = L * (1 / self.sqrt_price_curr - 1 / sqrt_pb)
+    ///
+    pub fn to_token_amounts(&self, sqrt_price_curr: SqrtPrice) -> Result<(u64, u64), SwapError> {
+        let one: U64F64 = U64F64::saturating_from_num(1);
+
+        let sqrt_pa: SqrtPrice =
+            tick_index_to_sqrt_price(self.tick_low).map_err(|_| SwapError::InvalidTickRange)?;
+        let sqrt_pb: SqrtPrice =
+            tick_index_to_sqrt_price(self.tick_high).map_err(|_| SwapError::InvalidTickRange)?;
+        let liquidity_fixed: U64F64 = U64F64::saturating_from_num(self.liquidity);
+
+        Ok(if sqrt_price_curr < sqrt_pa {
+            (
+                0,
+                liquidity_fixed
+                    .saturating_mul(one.safe_div(sqrt_pa).saturating_sub(one.safe_div(sqrt_pb)))
+                    .saturating_to_num::<u64>(),
+            )
+        } else if sqrt_price_curr > sqrt_pb {
+            (
+                liquidity_fixed
+                    .saturating_mul(sqrt_pb.saturating_sub(sqrt_pa))
+                    .saturating_to_num::<u64>(),
+                0,
+            )
+        } else {
+            (
+                liquidity_fixed
+                    .saturating_mul(sqrt_price_curr.saturating_sub(sqrt_pa))
+                    .saturating_to_num::<u64>(),
+                liquidity_fixed
+                    .saturating_mul(
+                        one.safe_div(sqrt_price_curr)
+                            .saturating_sub(one.safe_div(sqrt_pb)),
+                    )
+                    .saturating_to_num::<u64>(),
+            )
+        })
+    }
+}
+
+/// This trait implementation depends on Runtime and it needs to be implemented
+/// in the pallet to be able to work with chain state and per subnet. All subnet
+/// swaps are independent and hence netuid is abstracted away from swap implementation.
+///
+pub trait SwapDataOperations<AccountIdType> {
+    /// Tells if v3 swap is initialized in the state. v2 only provides base and quote
+    /// reserves, while v3 also stores ticks and positions, which need to be initialized
+    /// at the first pool creation.
+    fn is_v3_initialized(&self) -> bool;
+    fn set_v3_initialized(&mut self);
+    /// Returns u16::MAX normalized fee rate. For example, 0.3% is approximately 196.
+    fn get_fee_rate(&self) -> u16;
+    /// Minimum liquidity that is safe for rounding and integer math.
+    fn get_minimum_liquidity(&self) -> u64;
+    fn get_tick_by_index(&self, tick_index: i32) -> Option<Tick>;
+    fn insert_tick_by_index(&mut self, tick_index: i32, tick: Tick);
+    fn remove_tick_by_index(&mut self, tick_index: i32);
+    /// Minimum sqrt price across all active ticks
+    fn get_min_sqrt_price(&self) -> SqrtPrice;
+    /// Maximum sqrt price across all active ticks
+    fn get_max_sqrt_price(&self) -> SqrtPrice;
+    fn get_tao_reserve(&self) -> u64;
+    fn set_tao_reserve(&mut self, tao: u64) -> u64;
+    fn get_alpha_reserve(&self) -> u64;
+    fn set_alpha_reserve(&mut self, alpha: u64) -> u64;
+    fn get_alpha_sqrt_price(&self) -> SqrtPrice;
+    fn set_alpha_sqrt_price(&mut self, sqrt_price: SqrtPrice);
+
+    // Getters/setters for global accrued fees in alpha and tao per subnet
+    fn get_fee_global_tao(&self) -> U64F64;
+    fn set_fee_global_tao(&mut self, fee: U64F64);
+    fn get_fee_global_alpha(&self) -> U64F64;
+    fn set_fee_global_alpha(&mut self, fee: U64F64);
+
+    /// Get current tick liquidity
+    fn get_current_liquidity(&self) -> u64;
+    /// Set current tick liquidity
+    fn set_current_liquidity(&mut self, liquidity: u64);
+
+    // User account operations
+    fn get_protocol_account_id(&self) -> AccountIdType;
+    fn get_max_positions(&self) -> u16;
+    fn withdraw_balances(
+        &mut self,
+        account_id: &AccountIdType,
+        tao: u64,
+        alpha: u64,
+    ) -> Result<(u64, u64), SwapError>;
+    fn deposit_balances(&mut self, account_id: &AccountIdType, tao: u64, alpha: u64);
+    fn get_position_count(&self, account_id: &AccountIdType) -> u16;
+    fn get_position(&self, account_id: &AccountIdType, position_id: u16) -> Option<Position>;
+    fn create_position(&mut self, account_id: &AccountIdType, positions: Position) -> u16;
+    fn update_position(
+        &mut self,
+        account_id: &AccountIdType,
+        position_id: u16,
+        positions: Position,
+    );
+    fn remove_position(&mut self, account_id: &AccountIdType, position_id: u16);
+}
+
+/// All main swapping logic abstracted from Runtime implementation is concentrated
+/// in this struct
+///
+#[derive(Debug)]
+pub struct Swap<AccountIdType, Ops>
+where
+    AccountIdType: Eq,
+    Ops: SwapDataOperations<AccountIdType>,
+{
+    pub(crate) state_ops: Ops,
+    phantom_key: PhantomData<AccountIdType>,
+}
+
+impl<AccountIdType, Ops> Swap<AccountIdType, Ops>
+where
+    AccountIdType: Eq,
+    Ops: SwapDataOperations<AccountIdType>,
+{
+    pub fn new(mut ops: Ops) -> Self {
+        if !ops.is_v3_initialized() {
+            // Initialize the v3:
+            // Reserves are re-purposed, nothing to set, just query values for liquidity and price calculation
+            let tao_reserve = ops.get_tao_reserve();
+            let alpha_reserve = ops.get_alpha_reserve();
+
+            // Set price
+            let price: U64F64 = U64F64::saturating_from_num(tao_reserve)
+                .safe_div(U64F64::saturating_from_num(alpha_reserve));
+
+            let epsilon: U64F64 = U64F64::saturating_from_num(0.000001);
+            ops.set_alpha_sqrt_price(
+                price
+                    .checked_sqrt(epsilon)
+                    .unwrap_or(U64F64::saturating_from_num(0)),
+            );
+
+            // Set initial (protocol owned) liquidity and positions
+            // Protocol liquidity makes one position from MIN_TICK_INDEX to MAX_TICK_INDEX
+            // We are using the sp_arithmetic sqrt here, which works for u128
+            let liquidity: u64 = sqrt(tao_reserve as u128 * alpha_reserve as u128) as u64;
+            let mut swap = Swap {
+                state_ops: ops,
+                phantom_key: PhantomData,
+            };
+            let protocol_account_id = swap.state_ops.get_protocol_account_id();
+            let _ = swap.add_liquidity(
+                &protocol_account_id,
+                MIN_TICK_INDEX,
+                MAX_TICK_INDEX,
+                liquidity,
+                true,
+            );
+
+            swap
+        } else {
+            Swap {
+                state_ops: ops,
+                phantom_key: PhantomData,
+            }
+        }
+    }
+
+    /// Auxiliary method to calculate Alpha amount to match given TAO
+    /// amount at the current price for liquidity.
+    ///
+    /// Returns (Alpha, Liquidity) tuple
+    ///
+    pub fn get_tao_based_liquidity(&self, _tao: u64) -> (u64, u64) {
+        // let current_price = self.state_ops.get_alpha_sqrt_price();
+        todo!()
+    }
+
+    /// Auxiliary method to calculate TAO amount to match given Alpha
+    /// amount at the current price for liquidity.
+    ///
+    /// Returns (TAO, Liquidity) tuple
+    ///
+    pub fn get_alpha_based_liquidity(&self, _alpha: u64) -> (u64, u64) {
+        // let current_price = self.state_ops.get_alpha_sqrt_price();
+
+        todo!()
+    }
+
+    /// Add liquidity at tick index. Creates new tick if it doesn't exist
+    ///
+    fn add_liquidity_at_index(&mut self, tick_index: i32, liquidity: u64, upper: bool) {
+        // Calculate net liquidity addition
+        let net_addition = if upper {
+            (liquidity as i128).neg()
+        } else {
+            liquidity as i128
+        };
+
+        // Find tick by index
+        let new_tick = if let Some(mut tick) = self.state_ops.get_tick_by_index(tick_index) {
+            tick.liquidity_net = tick.liquidity_net.saturating_add(net_addition);
+            tick.liquidity_gross = tick.liquidity_gross.saturating_add(liquidity);
+            tick
+        } else {
+            // Create a new tick
+            Tick {
+                liquidity_net: net_addition,
+                liquidity_gross: liquidity,
+                fees_out_tao: U64F64::saturating_from_num(0),
+                fees_out_alpha: U64F64::saturating_from_num(0),
+            }
+        };
+
+        // TODO: Review why Python code uses this code to find index for the new ticks:
+        // self.get_tick_index(user_position[0]) + 1
+        self.state_ops.insert_tick_by_index(tick_index, new_tick);
+    }
+
+    /// Remove liquidity at tick index.
+    ///
+    fn remove_liquidity_at_index(&mut self, tick_index: i32, liquidity: u64, upper: bool) {
+        // Calculate net liquidity addition
+        let net_reduction = if upper {
+            (liquidity as i128).neg()
+        } else {
+            liquidity as i128
+        };
+
+        // Find tick by index
+        if let Some(mut tick) = self.state_ops.get_tick_by_index(tick_index) {
+            tick.liquidity_net = tick.liquidity_net.saturating_sub(net_reduction);
+            tick.liquidity_gross = tick.liquidity_gross.saturating_sub(liquidity);
+
+            // If any liquidity is left at the tick, update it, otherwise remove
+            if tick.liquidity_gross == 0 {
+                self.state_ops.remove_tick_by_index(tick_index);
+            } else {
+                self.state_ops.insert_tick_by_index(tick_index, tick);
+            }
+        };
+    }
+
+    /// Adds liquidity to the specified price range.
+    ///
+    /// This function allows an account to provide liquidity to a given range of price ticks.
+    /// The amount of liquidity to be added can be determined using the functions
+    /// [`get_tao_based_liquidity`] and [`get_alpha_based_liquidity`], which compute the
+    /// required liquidity based on TAO and Alpha balances for the current price tick.
+    ///
+    /// ### Behavior:
+    /// - If the `protocol` flag is **not set** (`false`), the function will attempt to
+    ///   **withdraw balances** from the account using `state_ops.withdraw_balances()`.
+    /// - If the `protocol` flag is **set** (`true`), the liquidity is added without modifying balances.
+    ///
+    /// ### Parameters:
+    /// - `account_id`: A reference to the account that is providing liquidity.
+    /// - `tick_low`: The lower bound of the price tick range.
+    /// - `tick_high`: The upper bound of the price tick range.
+    /// - `liquidity`: The amount of liquidity to be added.
+    /// - `protocol`: A boolean flag indicating whether the operation is protocol-managed:
+    ///   - `true` -> Do not use this value outside of this implementation. Liquidity is added **without**
+    ///               withdrawing balances.
+    ///   - `false` -> Use this value for all user transactions. Liquidity is added
+    ///               **after withdrawing balances**.
+    ///
+    /// ### Returns:
+    /// - `Ok(u64)`: The final liquidity amount added.
+    /// - `Err(SwapError)`: If the operation fails due to insufficient balance, invalid tick range,
+    ///   or other swap-related errors.
+    ///
+    /// ### Errors:
+    /// - [`SwapError::InsufficientBalance`] if the account does not have enough balance.
+    /// - [`SwapError::InvalidTickRange`] if `tick_low` is greater than or equal to `tick_high`.
+    /// - Other [`SwapError`] variants as applicable.
+    ///
+    pub fn add_liquidity(
+        &mut self,
+        account_id: &AccountIdType,
+        tick_low: i32,
+        tick_high: i32,
+        liquidity: u64,
+        protocol: bool,
+    ) -> Result<(), SwapError> {
+        // Check if we can add a position
+        let position_count = self.state_ops.get_position_count(account_id);
+        let max_positions = self.state_ops.get_max_positions();
+        if position_count >= max_positions {
+            return Err(SwapError::MaxPositionsExceeded);
+        }
+
+        // Add liquidity at tick
+        self.add_liquidity_at_index(tick_low, liquidity, false);
+        self.add_liquidity_at_index(tick_high, liquidity, true);
+
+        // Update current tick liquidity
+        let current_tick_index = self.get_current_tick_index();
+        if (tick_low <= current_tick_index) && (current_tick_index <= tick_high) {
+            let new_current_liquidity = self
+                .state_ops
+                .get_current_liquidity()
+                .saturating_add(liquidity);
+            self.state_ops.set_current_liquidity(new_current_liquidity);
+        }
+
+        // New position
+        let position = Position {
+            tick_low,
+            tick_high,
+            liquidity,
+            fees_tao: 0_u64,
+            fees_alpha: 0_u64,
+        };
+
+        // If this is a user transaction, withdraw balances and update reserves
+        if !protocol {
+            let current_price: SqrtPrice = self.state_ops.get_alpha_sqrt_price();
+            let (tao, alpha) = position.to_token_amounts(current_price)?;
+            self.state_ops.withdraw_balances(account_id, tao, alpha)?;
+
+            // Update reserves
+            let new_tao_reserve = self.state_ops.get_tao_reserve().saturating_add(tao);
+            self.state_ops.set_tao_reserve(new_tao_reserve);
+            let new_alpha_reserve = self.state_ops.get_alpha_reserve().saturating_add(alpha);
+            self.state_ops.set_alpha_reserve(new_alpha_reserve);
+        }
+
+        // Create a new user position
+        self.state_ops.create_position(account_id, position);
+
+        Ok(())
+    }
+
+    /// Remove liquidity and credit balances back to account_id
+    ///
+    /// Account ID and Position ID identify position in the storage map
+    ///
+    pub fn remove_liquidity(
+        &mut self,
+        account_id: &AccountIdType,
+        position_id: u16,
+    ) -> Result<RemoveLiquidityResult, SwapError> {
+        // Check if position exists
+        if let Some(mut pos) = self.state_ops.get_position(account_id, position_id) {
+            // Get current price
+            let current_tick_index = self.get_current_tick_index();
+
+            // Collect fees and get tao and alpha amounts
+            let (fee_tao, fee_alpha) = self.collect_fees(&mut pos);
+            let current_price: SqrtPrice = self.state_ops.get_alpha_sqrt_price();
+            let (tao, alpha) = pos.to_token_amounts(current_price)?;
+
+            // Update liquidity at position ticks
+            self.remove_liquidity_at_index(pos.tick_low, pos.liquidity, false);
+            self.remove_liquidity_at_index(pos.tick_high, pos.liquidity, true);
+
+            // Update current tick liquidity
+            if (pos.tick_low <= current_tick_index) && (current_tick_index <= pos.tick_high) {
+                let new_current_liquidity = self
+                    .state_ops
+                    .get_current_liquidity()
+                    .saturating_sub(pos.liquidity);
+                self.state_ops.set_current_liquidity(new_current_liquidity);
+            }
+
+            // Remove user position
+            self.state_ops.remove_position(account_id, position_id);
+
+            // Deposit balances
+            self.state_ops.deposit_balances(account_id, tao, alpha);
+
+            // Update reserves
+            let new_tao_reserve = self.state_ops.get_tao_reserve().saturating_sub(tao);
+            self.state_ops.set_tao_reserve(new_tao_reserve);
+            let new_alpha_reserve = self.state_ops.get_alpha_reserve().saturating_sub(alpha);
+            self.state_ops.set_alpha_reserve(new_alpha_reserve);
+
+            // TODO: Clear with R&D
+            // Update current price (why?)
+            // self.state_ops.set_alpha_sqrt_price(sqrt_price);
+
+            // Return Ok result
+            Ok(RemoveLiquidityResult {
+                tao,
+                alpha,
+                fee_tao,
+                fee_alpha,
+            })
+        } else {
+            // Position doesn't exist
+            Err(SwapError::LiquidityNotFound)
+        }
+    }
+
+    /// Perform a swap
+    ///
+    /// Returns a tuple (amount, refund), where amount is the resulting paid out amount
+    ///
+    pub fn swap(
+        &mut self,
+        order_type: &OrderType,
+        amount: u64,
+        sqrt_price_limit: SqrtPrice,
+    ) -> Result<SwapResult, SwapError> {
+        let one = U64F64::saturating_from_num(1);
+
+        // Here we store the remaining amount that needs to be exchanged
+        // If order_type is Buy, then it expresses Tao amount, if it is Sell,
+        // then amount_remaining is Alpha.
+        let mut amount_remaining = amount;
+        let mut amount_paid_out: u64 = 0;
+        let mut refund: u64 = 0;
+
+        // A bit of fool proofing
+        let mut iteration_counter: u16 = 0;
+        let iter_limit: u16 = 1000;
+
+        // Swap one tick at a time until we reach one of the following conditions:
+        //   - Swap all provided amount
+        //   - Reach limit price
+        //   - Use up all liquidity (up to safe minimum)
+        while amount_remaining > 0 {
+            let sqrt_price_edge = self.get_sqrt_price_edge(order_type);
+            let possible_delta_in =
+                amount_remaining.saturating_sub(self.get_fee_amount(amount_remaining));
+            let sqrt_price_target = self.get_sqrt_price_target(order_type, possible_delta_in);
+            let target_quantity = self.get_target_quantity(order_type, possible_delta_in);
+            let edge_quantity = U64F64::saturating_from_num(1).safe_div(sqrt_price_edge.into());
+            let lim_quantity = one
+                .safe_div(self.state_ops.get_min_sqrt_price())
+                .saturating_add(one.safe_div(sqrt_price_limit.into()));
+
+            let action: SwapStepAction;
+            let delta_in;
+            let final_price;
+            let mut stop_and_refund = false;
+
+            if target_quantity < edge_quantity {
+                if target_quantity <= lim_quantity {
+                    // stop_in at price target
+                    action = SwapStepAction::StopIn;
+                    delta_in = possible_delta_in;
+                    final_price = sqrt_price_target;
+                } else {
+                    // stop_in at price limit
+                    action = SwapStepAction::StopIn;
+                    delta_in = self.get_delta_in(order_type, sqrt_price_limit);
+                    final_price = sqrt_price_limit;
+                    stop_and_refund = true;
+                }
+            } else if target_quantity > edge_quantity {
+                if edge_quantity < lim_quantity {
+                    // do crossing at price edge
+                    action = SwapStepAction::Crossing;
+                    delta_in = self.get_delta_in(order_type, sqrt_price_edge);
+                    final_price = sqrt_price_edge;
+                } else if edge_quantity > lim_quantity {
+                    // stop_in at price limit
+                    action = SwapStepAction::StopIn;
+                    delta_in = self.get_delta_in(order_type, sqrt_price_limit);
+                    final_price = sqrt_price_limit;
+                    stop_and_refund = true;
+                } else {
+                    // stop_on at price limit
+                    action = SwapStepAction::StopOn;
+                    delta_in = self.get_delta_in(order_type, sqrt_price_edge);
+                    final_price = sqrt_price_edge;
+                    stop_and_refund = true;
+                }
+            } else {
+                // targetQuantity = edgeQuantity
+                if target_quantity <= lim_quantity {
+                    // stop_on at price edge
+                    delta_in = self.get_delta_in(order_type, sqrt_price_edge);
+                    final_price = sqrt_price_edge;
+                    action = if delta_in > 0 {
+                        SwapStepAction::StopOn
+                    } else {
+                        SwapStepAction::Crossing
+                    };
+                } else {
+                    // targetQuantity > limQuantity
+                    // stop_in at price lim
+                    action = SwapStepAction::StopIn;
+                    delta_in = self.get_delta_in(order_type, sqrt_price_limit);
+                    final_price = sqrt_price_limit;
+                    stop_and_refund = true;
+                }
+            }
+
+            let swap_result = self.swap_step(order_type, delta_in, final_price, action)?;
+            amount_remaining = amount_remaining.saturating_sub(swap_result.amount_to_take);
+            amount_paid_out = amount_paid_out.saturating_add(swap_result.delta_out);
+
+            if stop_and_refund {
+                refund = amount_remaining;
+                amount_remaining = 0;
+            }
+
+            iteration_counter = iteration_counter.saturating_add(1);
+            if iteration_counter > iter_limit {
+                return Err(SwapError::TooManySwapSteps);
+            }
+        }
+
+        Ok(SwapResult {
+            amount_paid_out,
+            refund,
+        })
+    }
+
+    fn get_current_tick_index(&mut self) -> i32 {
+        let current_price = self.state_ops.get_alpha_sqrt_price();
+        let maybe_current_tick_index = sqrt_price_to_tick_index(current_price);
+        if let Ok(index) = maybe_current_tick_index {
+            index
+        } else {
+            // Current price is out of allow the min-max range, and it should be corrected to
+            // maintain the range.
+            let max_price = tick_index_to_sqrt_price(MAX_TICK_INDEX)
+                .unwrap_or(SqrtPrice::saturating_from_num(1000));
+            let min_price = tick_index_to_sqrt_price(MIN_TICK_INDEX)
+                .unwrap_or(SqrtPrice::saturating_from_num(0.000001));
+            if current_price > max_price {
+                self.state_ops.set_alpha_sqrt_price(max_price);
+                MAX_TICK_INDEX
+            } else {
+                self.state_ops.set_alpha_sqrt_price(min_price);
+                MIN_TICK_INDEX
+            }
+        }
+    }
+
+    /// Process a single step of a swap
+    ///
+    fn swap_step(
+        &mut self,
+        order_type: &OrderType,
+        delta_in: u64,
+        sqrt_price_final: SqrtPrice,
+        action: SwapStepAction,
+    ) -> Result<SwapStepResult, SwapError> {
+        // amount_swapped = delta_in / (1 - self.fee_size)
+        let fee_rate = U64F64::saturating_from_num(self.state_ops.get_fee_rate());
+        let u16_max = U64F64::saturating_from_num(u16::MAX);
+        let delta_fixed = U64F64::saturating_from_num(delta_in);
+        let amount_swapped =
+            delta_fixed.saturating_mul(u16_max.safe_div(u16_max.saturating_sub(fee_rate)));
+
+        // Hold the fees
+        let fee = self.get_fee_amount(amount_swapped.saturating_to_num::<u64>());
+        self.add_fees(order_type, fee);
+        let delta_out = self.convert_deltas(order_type, delta_in);
+
+        self.update_reserves(order_type, delta_in, delta_out);
+
+        // Get current tick
+        let current_tick_index = self.get_current_tick_index();
+
+        match action {
+            SwapStepAction::Crossing => {
+                let maybe_tick = match order_type {
+                    OrderType::Sell => self.find_closest_lower_active_tick(current_tick_index),
+                    OrderType::Buy => self.find_closest_higher_active_tick(current_tick_index),
+                };
+                if let Some(mut tick) = maybe_tick {
+                    tick.fees_out_tao = self
+                        .state_ops
+                        .get_fee_global_tao()
+                        .saturating_sub(tick.fees_out_tao);
+                    tick.fees_out_alpha = self
+                        .state_ops
+                        .get_fee_global_alpha()
+                        .saturating_sub(tick.fees_out_alpha);
+                    self.update_liquidity_at_crossing(order_type)?;
+                    self.state_ops
+                        .insert_tick_by_index(current_tick_index, tick);
+                } else {
+                    return Err(SwapError::InsufficientLiquidity);
+                }
+            }
+            SwapStepAction::StopOn => match order_type {
+                OrderType::Sell => {}
+                OrderType::Buy => {
+                    self.update_liquidity_at_crossing(order_type)?;
+                    let maybe_tick = self.find_closest_higher_active_tick(current_tick_index);
+
+                    if let Some(mut tick) = maybe_tick {
+                        tick.fees_out_tao = self
+                            .state_ops
+                            .get_fee_global_tao()
+                            .saturating_sub(tick.fees_out_tao);
+                        tick.fees_out_alpha = self
+                            .state_ops
+                            .get_fee_global_alpha()
+                            .saturating_sub(tick.fees_out_alpha);
+                        self.state_ops
+                            .insert_tick_by_index(current_tick_index, tick);
+                    } else {
+                        return Err(SwapError::InsufficientLiquidity);
+                    }
+                }
+            },
+            SwapStepAction::StopIn => {}
+        }
+
+        // Update current price, which effectively updates current tick too
+        self.state_ops.set_alpha_sqrt_price(sqrt_price_final);
+
+        Ok(SwapStepResult {
+            amount_to_take: amount_swapped.saturating_to_num::<u64>(),
+            delta_out,
+        })
+    }
+
+    /// Get the square root price at the current tick edge for the given direction (order type)
+    /// If order type is Buy, then price edge is the high tick bound price, otherwise it is
+    /// the low tick bound price.
+    ///
+    /// If anything is wrong with tick math and it returns Err, we just abort the deal, i.e.
+    /// return the edge that is impossible to execute
+    ///
+    fn get_sqrt_price_edge(&self, order_type: &OrderType) -> SqrtPrice {
+        let fallback_price_edge_value = (match order_type {
+            OrderType::Buy => tick_index_to_sqrt_price(MIN_TICK_INDEX),
+            OrderType::Sell => tick_index_to_sqrt_price(MAX_TICK_INDEX),
+        })
+        .unwrap_or(SqrtPrice::saturating_from_num(0));
+
+        let current_price = self.state_ops.get_alpha_sqrt_price();
+        let maybe_current_tick_index = sqrt_price_to_tick_index(current_price);
+
+        if let Ok(current_tick_index) = maybe_current_tick_index {
+            tick_index_to_sqrt_price(match order_type {
+                OrderType::Buy => current_tick_index.saturating_add(1),
+                OrderType::Sell => current_tick_index,
+            })
+            .unwrap_or(fallback_price_edge_value)
+        } else {
+            fallback_price_edge_value
+        }
+    }
+
+    /// Calculate fee amount
+    ///
+    /// Fee is provided by state ops as u16-normalized value.
+    ///
+    fn get_fee_amount(&self, amount: u64) -> u64 {
+        let fee_rate = U64F64::saturating_from_num(self.state_ops.get_fee_rate())
+            .safe_div(U64F64::saturating_from_num(u16::MAX));
+        U64F64::saturating_from_num(amount)
+            .saturating_mul(fee_rate)
+            .saturating_to_num::<u64>()
+    }
+
+    /// Here we subtract minimum safe liquidity from current liquidity to stay in the
+    /// safe range
+    ///
+    fn get_safe_current_liquidity(&self) -> U64F64 {
+        U64F64::saturating_from_num(
+            self.state_ops
+                .get_current_liquidity()
+                .saturating_sub(self.state_ops.get_minimum_liquidity()),
+        )
+    }
+
+    /// Get the target square root price based on the input amount
+    ///
+    fn get_sqrt_price_target(&self, order_type: &OrderType, delta_in: u64) -> SqrtPrice {
+        let liquidity_curr = self.get_safe_current_liquidity();
+        let sqrt_price_curr = self.state_ops.get_alpha_sqrt_price().into();
+        let delta_fixed = U64F64::saturating_from_num(delta_in);
+        let one = U64F64::saturating_from_num(1);
+
+        if liquidity_curr > 0 {
+            match order_type {
+                OrderType::Buy => one.safe_div(
+                    delta_fixed
+                        .safe_div(liquidity_curr)
+                        .saturating_add(one.safe_div(sqrt_price_curr)),
+                ),
+                OrderType::Sell => delta_fixed
+                    .safe_div(liquidity_curr)
+                    .saturating_add(sqrt_price_curr),
+            }
+        } else {
+            // No liquidity means price should remain current
+            sqrt_price_curr
+        }
+    }
+
+    /// Get the target quantity, which is
+    ///     `1 / (target square root price)` in case of sell order
+    ///     `target square root price` in case of buy order
+    ///
+    /// ...based on the input amount, current liquidity, and current alpha price
+    ///
+    fn get_target_quantity(&self, order_type: &OrderType, delta_in: u64) -> SqrtPrice {
+        let liquidity_curr = self.get_safe_current_liquidity();
+        let sqrt_price_curr = self.state_ops.get_alpha_sqrt_price().into();
+        let delta_fixed = U64F64::saturating_from_num(delta_in);
+        let one = U64F64::saturating_from_num(1);
+
+        if liquidity_curr > 0 {
+            match order_type {
+                OrderType::Buy => delta_fixed
+                    .safe_div(liquidity_curr)
+                    .saturating_add(sqrt_price_curr)
+                    .into(),
+                OrderType::Sell => delta_fixed
+                    .safe_div(liquidity_curr)
+                    .saturating_add(one.safe_div(sqrt_price_curr))
+                    .into(),
+            }
+        } else {
+            // No liquidity means zero
+            SqrtPrice::saturating_from_num(0)
+        }
+    }
+
+    /// Get the input amount needed to reach the target price
+    ///
+    fn get_delta_in(&self, order_type: &OrderType, sqrt_price_target: SqrtPrice) -> u64 {
+        let liquidity_curr = self.get_safe_current_liquidity();
+        let one = U64F64::saturating_from_num(1);
+        let sqrt_price_curr = self.state_ops.get_alpha_sqrt_price().into();
+
+        (match order_type {
+            OrderType::Sell => liquidity_curr.saturating_mul(
+                one.safe_div(sqrt_price_target.into())
+                    .saturating_sub(one.safe_div(sqrt_price_curr)),
+            ),
+            OrderType::Buy => {
+                liquidity_curr.saturating_mul(sqrt_price_target.saturating_sub(sqrt_price_curr))
+            }
+        })
+        .saturating_to_num::<u64>()
+    }
+
+    /// Add fees to the global fee counters
+    fn add_fees(&mut self, order_type: &OrderType, fee: u64) {
+        let liquidity_curr = self.get_safe_current_liquidity();
+        if liquidity_curr > 0 {
+            let fee_global_tao: U64F64 = self.state_ops.get_fee_global_tao();
+            let fee_global_alpha: U64F64 = self.state_ops.get_fee_global_alpha();
+            let fee_fixed: U64F64 = U64F64::saturating_from_num(fee);
+
+            match order_type {
+                OrderType::Sell => {
+                    self.state_ops.set_fee_global_tao(
+                        fee_global_tao.saturating_add(fee_fixed.safe_div(liquidity_curr)),
+                    );
+                }
+                OrderType::Buy => {
+                    self.state_ops.set_fee_global_alpha(
+                        fee_global_alpha.saturating_add(fee_fixed.safe_div(liquidity_curr)),
+                    );
+                }
+            }
+        }
+    }
+
+    /// Convert input amount (delta_in) to output amount (delta_out)
+    ///
+    /// This is the core method of uniswap V3 that tells how much
+    /// output token is given for an amount of input token within one
+    /// price tick.
+    ///
+    fn convert_deltas(&self, order_type: &OrderType, delta_in: u64) -> u64 {
+        let liquidity_curr = SqrtPrice::saturating_from_num(self.state_ops.get_current_liquidity());
+        let sqrt_price_curr = self.state_ops.get_alpha_sqrt_price();
+        let delta_fixed = SqrtPrice::saturating_from_num(delta_in);
+
+        // TODO: Implement in safe and non-overflowing math
+        // Intentionally using unsafe math here to trigger CI
+
+        // // Prevent overflows:
+        // // If liquidity or delta are too large, reduce their precision and
+        // // save their factor for final correction. Price can take full U64F64
+        // // range, and it will not overflow u128 divisions or multiplications.
+        // let mut liquidity_factor: u64 = 1;
+        // if liquidity_curr > u32::MAX as u64 {
+        //     liquidity_factor = u32::MAX as u64;
+        //     liquidity_curr = liquidity_curr.safe_div(liquidity_factor);
+        // }
+        // let mut delta = delta_in as u64;
+        // let mut delta_factor: u64 = 1;
+        // if delta > u32::MAX as u64 {
+        //     delta_factor = u32::MAX as u64;
+        //     delta = delta.safe_div(delta_factor);
+        // }
+
+        // // This product does not overflow because we limit both
+        // // multipliers by u32::MAX (despite the u64 type)
+        // let delta_liquidity = delta.saturating_mul(liquidity);
+
+        // // This is product of delta_in * liquidity_curr * sqrt_price_curr
+        // let delta_liquidity_price: u128 =
+        //     Self::mul_u64_u64f64(delta_liquidity, sqrt_price_curr.into());
+
+        if delta_in > 0 {
+            (match order_type {
+                OrderType::Sell => {
+                    liquidity_curr * sqrt_price_curr * delta_fixed
+                        / (liquidity_curr / sqrt_price_curr + delta_fixed)
+                }
+                OrderType::Buy => {
+                    liquidity_curr / sqrt_price_curr * delta_fixed
+                        / (liquidity_curr * sqrt_price_curr + delta_fixed)
+                }
+            })
+            .to_num::<u64>()
+        } else {
+            0
+        }
+    }
+
+    /// Multiplies a `u64` by a `U64F64` and returns a `u128` result without overflow.
+    // pub fn mul_u64_u64f64(a: u64, b: U64F64) -> u128 {
+    //     // Multiply a by integer part of b in integer math.
+    //     // Result doesn't overflow u128 because both multipliers are 64 bit
+    //     let int_b: u64 = b.saturating_to_num::<u64>();
+    //     let high = (a as u128).saturating_mul(int_b as u128);
+
+    //     // Multiply a by fractional part of b using U64F64
+    //     let frac_b = b.saturating_sub(U64F64::saturating_from_num(int_b));
+    //     let low = U64F64::saturating_from_num(a).saturating_mul(frac_b);
+
+    //     // The only possible overflow (that is cut off by saturating math)
+    //     // is when a is u64::MAX, int_b is u64::MAX, and frac_b is non-zero,
+    //     // which is negligible error if we saturate and return u128::MAX
+    //     high.saturating_add(low).saturating_to_num::<u128>()
+    // }
+
+    /// Update token reserves after a swap
+    ///
+    fn update_reserves(&mut self, order_type: &OrderType, amount_in: u64, amount_out: u64) {
+        let (new_tao_reserve, new_alpha_reserve) = match order_type {
+            OrderType::Sell => (
+                self.state_ops.get_tao_reserve().saturating_add(amount_in),
+                self.state_ops
+                    .get_alpha_reserve()
+                    .saturating_sub(amount_out),
+            ),
+            OrderType::Buy => (
+                self.state_ops.get_tao_reserve().saturating_sub(amount_in),
+                self.state_ops
+                    .get_alpha_reserve()
+                    .saturating_add(amount_out),
+            ),
+        };
+
+        self.state_ops.set_tao_reserve(new_tao_reserve);
+        self.state_ops.set_alpha_reserve(new_alpha_reserve);
+    }
+
+    fn get_liquidity_update_u64(&self, tick: &Tick) -> u64 {
+        let liquidity_update_abs_i128 = tick.liquidity_net.abs();
+        if liquidity_update_abs_i128 > u64::MAX as i128 {
+            u64::MAX
+        } else {
+            liquidity_update_abs_i128 as u64
+        }
+    }
+
+    /// Update liquidity when crossing a tick
+    ///
+    fn update_liquidity_at_crossing(&mut self, order_type: &OrderType) -> Result<(), SwapError> {
+        let mut liquidity_curr = self.state_ops.get_current_liquidity();
+        let current_tick_index = self.get_current_tick_index();
+        match order_type {
+            OrderType::Sell => {
+                let maybe_tick = self.find_closest_lower_active_tick(current_tick_index);
+                if let Some(tick) = maybe_tick {
+                    let liquidity_update_abs_u64 = self.get_liquidity_update_u64(&tick);
+
+                    liquidity_curr = if tick.liquidity_net >= 0 {
+                        liquidity_curr.saturating_sub(liquidity_update_abs_u64)
+                    } else {
+                        liquidity_curr.saturating_add(liquidity_update_abs_u64)
+                    };
+                } else {
+                    return Err(SwapError::InsufficientLiquidity);
+                }
+            }
+            OrderType::Buy => {
+                let maybe_tick = self.find_closest_higher_active_tick(current_tick_index);
+                if let Some(tick) = maybe_tick {
+                    let liquidity_update_abs_u64 = self.get_liquidity_update_u64(&tick);
+
+                    liquidity_curr = if tick.liquidity_net >= 0 {
+                        liquidity_curr.saturating_add(liquidity_update_abs_u64)
+                    } else {
+                        liquidity_curr.saturating_sub(liquidity_update_abs_u64)
+                    };
+                } else {
+                    return Err(SwapError::InsufficientLiquidity);
+                }
+            }
+        }
+
+        self.state_ops.set_current_liquidity(liquidity_curr);
+        Ok(())
+    }
+
+    /// Collect fees for a position
+    /// Updates the position
+    ///
+    fn collect_fees(&mut self, position: &mut Position) -> (u64, u64) {
+        let mut fee_tao = self.get_fees_in_range(position, true);
+        let mut fee_alpha = self.get_fees_in_range(position, false);
+
+        fee_tao = fee_tao.saturating_sub(position.fees_tao);
+        fee_alpha = fee_alpha.saturating_sub(position.fees_alpha);
+
+        position.fees_tao = fee_tao;
+        position.fees_alpha = fee_alpha;
+
+        fee_tao = position.liquidity.saturating_mul(fee_tao);
+        fee_alpha = position.liquidity.saturating_mul(fee_alpha);
+
+        (fee_tao, fee_alpha)
+    }
+
+    /// Get fees in a position's range
+    ///
+    /// If quote flag is true, Tao is returned, otherwise alpha.
+    ///
+    fn get_fees_in_range(&mut self, position: &mut Position, quote: bool) -> u64 {
+        let i_lower = position.tick_low;
+        let i_upper = position.tick_high;
+
+        let fee_global = if quote {
+            self.state_ops.get_fee_global_tao()
+        } else {
+            self.state_ops.get_fee_global_alpha()
+        };
+
+        fee_global
+            .saturating_sub(self.get_fees_below(i_lower, quote))
+            .saturating_sub(self.get_fees_above(i_upper, quote))
+            .saturating_to_num::<u64>()
+    }
+
+    /// Get fees above a tick
+    ///
+    fn get_fees_above(&mut self, tick_index: i32, quote: bool) -> U64F64 {
+        let maybe_tick_index = find_closest_lower_active_tick_index(&self.state_ops, tick_index);
+        let current_tick = self.get_current_tick_index();
+
+        if let Some(tick_index) = maybe_tick_index {
+            let tick = self
+                .state_ops
+                .get_tick_by_index(tick_index)
+                .unwrap_or_default();
+            if tick_index <= current_tick {
+                if quote {
+                    self.state_ops
+                        .get_fee_global_tao()
+                        .saturating_sub(tick.fees_out_tao)
+                } else {
+                    self.state_ops
+                        .get_fee_global_alpha()
+                        .saturating_sub(tick.fees_out_alpha)
+                }
+            } else {
+                if quote {
+                    tick.fees_out_tao
+                } else {
+                    tick.fees_out_alpha
+                }
+            }
+        } else {
+            U64F64::saturating_from_num(0)
+        }
+    }
+
+    /// Get fees below a tick
+    fn get_fees_below(&mut self, tick_index: i32, quote: bool) -> U64F64 {
+        let maybe_tick_index = find_closest_lower_active_tick_index(&self.state_ops, tick_index);
+        let current_tick = self.get_current_tick_index();
+
+        if let Some(tick_index) = maybe_tick_index {
+            let tick = self
+                .state_ops
+                .get_tick_by_index(tick_index)
+                .unwrap_or_default();
+            if tick_index <= current_tick {
+                if quote {
+                    tick.fees_out_tao
+                } else {
+                    tick.fees_out_alpha
+                }
+            } else {
+                if quote {
+                    self.state_ops
+                        .get_fee_global_tao()
+                        .saturating_sub(tick.fees_out_tao)
+                } else {
+                    self.state_ops
+                        .get_fee_global_alpha()
+                        .saturating_sub(tick.fees_out_alpha)
+                }
+            }
+        } else {
+            U64F64::saturating_from_num(0)
+        }
+    }
+
+    pub fn find_closest_lower_active_tick(&self, index: i32) -> Option<Tick> {
+        let maybe_tick_index = find_closest_lower_active_tick_index(&self.state_ops, index);
+        if let Some(tick_index) = maybe_tick_index {
+            self.state_ops.get_tick_by_index(tick_index)
+        } else {
+            None
+        }
+    }
+
+    pub fn find_closest_higher_active_tick(&self, index: i32) -> Option<Tick> {
+        let maybe_tick_index = find_closest_higher_active_tick_index(&self.state_ops, index);
+        if let Some(tick_index) = maybe_tick_index {
+            self.state_ops.get_tick_by_index(tick_index)
+        } else {
+            None
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use approx::assert_abs_diff_eq;
+    use sp_arithmetic::helpers_128bit::sqrt;
+    use std::collections::HashMap;
+
+    #[derive(Debug, Clone)]
+    pub struct MockSwapDataOperations {
+        is_initialized: bool,
+        fee_rate: u16,
+        minimum_liquidity: u64,
+        ticks: HashMap<i32, Tick>,
+        min_sqrt_price: SqrtPrice,
+        max_sqrt_price: SqrtPrice,
+        tao_reserve: u64,
+        alpha_reserve: u64,
+        alpha_sqrt_price: SqrtPrice,
+        fee_global_tao: U64F64,
+        fee_global_alpha: U64F64,
+        current_liquidity: u64,
+        max_positions: u16,
+        balances: HashMap<u16, (u64, u64)>,
+        positions: HashMap<u16, HashMap<u16, Position>>,
+    }
+
+    impl MockSwapDataOperations {
+        pub fn new() -> Self {
+            Self {
+                is_initialized: false,
+                fee_rate: 196,
+                minimum_liquidity: 1000,
+                ticks: HashMap::new(),
+                min_sqrt_price: SqrtPrice::from_num(0.01),
+                max_sqrt_price: SqrtPrice::from_num(10),
+                tao_reserve: 0,
+                alpha_reserve: 0,
+                alpha_sqrt_price: SqrtPrice::from_num(0),
+                fee_global_tao: U64F64::from_num(0),
+                fee_global_alpha: U64F64::from_num(0),
+                current_liquidity: 0,
+                max_positions: 100,
+                balances: HashMap::new(),
+                positions: HashMap::new(),
+            }
+        }
+    }
+
+    impl SwapDataOperations<u16> for MockSwapDataOperations {
+        fn is_v3_initialized(&self) -> bool {
+            self.is_initialized
+        }
+
+        fn set_v3_initialized(&mut self) {
+            self.is_initialized = true;
+        }
+
+        fn get_fee_rate(&self) -> u16 {
+            self.fee_rate
+        }
+
+        fn get_minimum_liquidity(&self) -> u64 {
+            self.minimum_liquidity
+        }
+
+        fn get_tick_by_index(&self, tick_index: i32) -> Option<Tick> {
+            self.ticks.get(&tick_index).cloned()
+        }
+
+        fn insert_tick_by_index(&mut self, tick_index: i32, tick: Tick) {
+            self.ticks.insert(tick_index, tick);
+        }
+
+        fn remove_tick_by_index(&mut self, tick_index: i32) {
+            self.ticks.remove(&tick_index);
+        }
+
+        fn get_min_sqrt_price(&self) -> SqrtPrice {
+            self.min_sqrt_price
+        }
+
+        fn get_max_sqrt_price(&self) -> SqrtPrice {
+            self.max_sqrt_price
+        }
+
+        fn get_tao_reserve(&self) -> u64 {
+            self.tao_reserve
+        }
+
+        fn set_tao_reserve(&mut self, tao: u64) -> u64 {
+            self.tao_reserve = tao;
+            tao
+        }
+
+        fn get_alpha_reserve(&self) -> u64 {
+            self.alpha_reserve
+        }
+
+        fn set_alpha_reserve(&mut self, alpha: u64) -> u64 {
+            self.alpha_reserve = alpha;
+            alpha
+        }
+
+        fn get_alpha_sqrt_price(&self) -> SqrtPrice {
+            self.alpha_sqrt_price
+        }
+
+        fn set_alpha_sqrt_price(&mut self, sqrt_price: SqrtPrice) {
+            self.alpha_sqrt_price = sqrt_price;
+        }
+
+        fn get_fee_global_tao(&self) -> U64F64 {
+            self.fee_global_tao
+        }
+
+        fn set_fee_global_tao(&mut self, fee: U64F64) {
+            self.fee_global_tao = fee;
+        }
+
+        fn get_fee_global_alpha(&self) -> U64F64 {
+            self.fee_global_alpha
+        }
+
+        fn set_fee_global_alpha(&mut self, fee: U64F64) {
+            self.fee_global_alpha = fee;
+        }
+
+        fn get_current_liquidity(&self) -> u64 {
+            self.current_liquidity
+        }
+
+        fn set_current_liquidity(&mut self, liquidity: u64) {
+            self.current_liquidity = liquidity;
+        }
+
+        fn get_max_positions(&self) -> u16 {
+            self.max_positions
+        }
+
+        fn withdraw_balances(
+            &mut self,
+            account_id: &u16,
+            tao: u64,
+            alpha: u64,
+        ) -> Result<(u64, u64), SwapError> {
+            let (current_tao, current_alpha) =
+                self.balances.get(account_id).cloned().unwrap_or((0, 0));
+
+            if (tao > current_tao) || (alpha > current_alpha) {
+                return Err(SwapError::InsufficientBalance);
+            }
+
+            self.balances
+                .insert(*account_id, (current_tao - tao, current_alpha - alpha));
+
+            Ok((tao, alpha))
+        }
+
+        fn deposit_balances(&mut self, account_id: &u16, tao: u64, alpha: u64) {
+            let (current_tao, current_alpha) =
+                self.balances.get(account_id).cloned().unwrap_or((0, 0));
+            self.balances.insert(
+                account_id.clone(),
+                (current_tao + tao, current_alpha + alpha),
+            );
+        }
+
+        fn get_protocol_account_id(&self) -> u16 {
+            0xFFFF
+        }
+
+        fn get_position_count(&self, account_id: &u16) -> u16 {
+            self.positions.get(account_id).map_or(0, |p| p.len() as u16)
+        }
+
+        fn get_position(&self, account_id: &u16, position_id: u16) -> Option<Position> {
+            self.positions
+                .get(account_id)
+                .and_then(|p| p.get(&position_id).cloned())
+        }
+
+        fn create_position(&mut self, account_id: &u16, position: Position) -> u16 {
+            let entry = self
+                .positions
+                .entry(account_id.clone())
+                .or_insert_with(HashMap::new);
+
+            // Find the next available position ID
+            let new_position_id = entry.keys().max().map_or(0, |max_id| max_id + 1);
+
+            entry.insert(new_position_id, position);
+            new_position_id
+        }
+
+        fn update_position(&mut self, account_id: &u16, position_id: u16, position: Position) {
+            if let Some(account_positions) = self.positions.get_mut(account_id) {
+                account_positions.insert(position_id, position);
+            }
+        }
+
+        fn remove_position(&mut self, account_id: &u16, position_id: u16) {
+            if let Some(account_positions) = self.positions.get_mut(account_id) {
+                account_positions.remove(&position_id);
+            }
+        }
+    }
+
+    #[test]
+    fn test_swap_initialization() {
+        let tao = 1_000_000_000;
+        let alpha = 4_000_000_000;
+
+        let mut mock_ops = MockSwapDataOperations::new();
+        mock_ops.set_tao_reserve(tao);
+        mock_ops.set_alpha_reserve(alpha);
+        let swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
+
+        // Active ticks
+        let tick_low = swap.state_ops.get_tick_by_index(MIN_TICK_INDEX).unwrap();
+        let tick_high = swap.state_ops.get_tick_by_index(MAX_TICK_INDEX).unwrap();
+        let liquidity = sqrt(alpha as u128 * tao as u128) as u64;
+        let expected_liquidity_net_low: i128 = liquidity as i128;
+        let expected_liquidity_gross_low: u64 = liquidity;
+        let expected_liquidity_net_high: i128 = (liquidity as i128).neg();
+        let expected_liquidity_gross_high: u64 = liquidity;
+        assert_eq!(tick_low.liquidity_net, expected_liquidity_net_low,);
+        assert_eq!(tick_low.liquidity_gross, expected_liquidity_gross_low,);
+        assert_eq!(tick_high.liquidity_net, expected_liquidity_net_high,);
+        assert_eq!(tick_high.liquidity_gross, expected_liquidity_gross_high,);
+
+        // Liquidity position at correct ticks
+        let account_id = swap.state_ops.get_protocol_account_id();
+        assert_eq!(swap.state_ops.get_position_count(&account_id), 1);
+
+        let position = swap.state_ops.get_position(&account_id, 0).unwrap();
+        assert_eq!(position.liquidity, liquidity);
+        assert_eq!(position.tick_low, MIN_TICK_INDEX);
+        assert_eq!(position.tick_high, MAX_TICK_INDEX);
+        assert_eq!(position.fees_alpha, 0);
+        assert_eq!(position.fees_tao, 0);
+
+        // Current liquidity
+        assert_eq!(swap.state_ops.get_current_liquidity(), liquidity);
+
+        // Current price
+        let sqrt_price = swap.state_ops.get_alpha_sqrt_price();
+        assert_abs_diff_eq!(sqrt_price.to_num::<f64>(), 0.50, epsilon = 0.00001,);
+    }
+
+    fn price_to_tick(price: f64) -> i32 {
+        let price_sqrt: SqrtPrice = SqrtPrice::from_num(price.sqrt());
+        let mut tick = sqrt_price_to_tick_index(price_sqrt).unwrap();
+        if tick > MAX_TICK_INDEX {
+            tick = MAX_TICK_INDEX
+        }
+        tick
+    }
+
+    fn tick_to_price(tick: i32) -> f64 {
+        let price_sqrt: SqrtPrice = tick_index_to_sqrt_price(tick).unwrap();
+        (price_sqrt * price_sqrt).to_num::<f64>()
+    }
+
+    #[test]
+    fn test_tick_price_sanity_check() {
+        let min_price = tick_to_price(MIN_TICK_INDEX);
+        let max_price = tick_to_price(MAX_TICK_INDEX);
+        assert!(min_price > 0.);
+        assert!(max_price > 0.);
+        assert!(max_price > min_price);
+        assert!(min_price < 0.000001);
+        assert!(max_price > 10.);
+
+        // Roundtrip conversions
+        let min_price_sqrt: SqrtPrice = tick_index_to_sqrt_price(MIN_TICK_INDEX).unwrap();
+        let min_tick = sqrt_price_to_tick_index(min_price_sqrt).unwrap();
+        assert_eq!(min_tick, MIN_TICK_INDEX);
+
+        let max_price_sqrt: SqrtPrice = tick_index_to_sqrt_price(MAX_TICK_INDEX).unwrap();
+        let max_tick = sqrt_price_to_tick_index(max_price_sqrt).unwrap();
+        assert_eq!(max_tick, MAX_TICK_INDEX);
+    }
+
+    // Test adding liquidity on top of the existing protocol liquidity
+    #[test]
+    fn test_add_liquidity_basic() {
+        let protocol_tao = 1_000_000_000;
+        let protocol_alpha = 4_000_000_000;
+        let user_tao = 100_000_000_000;
+        let user_alpha = 100_000_000_000;
+        let account_id = 1;
+        let min_price = tick_to_price(MIN_TICK_INDEX);
+        let max_price = tick_to_price(MAX_TICK_INDEX);
+        let max_tick = price_to_tick(max_price);
+        let current_price = 0.25;
+        assert_eq!(max_tick, MAX_TICK_INDEX);
+
+        // As a user add liquidity with all possible corner cases
+        //   - Initial price is 0.25
+        //   - liquidity is expressed in RAO units
+        // Test case is (price_low, price_high, liquidity, tao, alpha)
+        [
+            // Repeat the protocol liquidity at maximum range: Expect all the same values
+            (
+                min_price,
+                max_price,
+                2_000_000_000_u64,
+                1_000_000_000_u64,
+                4_000_000_000_u64,
+            ),
+            // Repeat the protocol liquidity at current to max range: Expect the same alpha
+            (0.25, max_price, 2_000_000_000_u64, 0, 4_000_000_000),
+            // Repeat the protocol liquidity at min to current range: Expect all the same tao
+            (min_price, 0.24999, 2_000_000_000_u64, 1_000_000_000, 0),
+            // Half to double price - just some sane wothdraw amounts
+            (0.125, 0.5, 2_000_000_000_u64, 293_000_000, 1_171_000_000),
+            // Both below price - tao is non-zero, alpha is zero
+            (0.12, 0.13, 2_000_000_000_u64, 28_270_000, 0),
+            // Both above price - tao is zero, alpha is non-zero
+            (0.3, 0.4, 2_000_000_000_u64, 0, 489_200_000),
+        ]
+        .iter()
+        .for_each(|(price_low, price_high, liquidity, tao, alpha)| {
+            // Calculate ticks (assuming tick math is tested separately)
+            let tick_low = price_to_tick(*price_low);
+            let tick_high = price_to_tick(*price_high);
+
+            // Setup swap
+            let mut mock_ops = MockSwapDataOperations::new();
+            mock_ops.set_tao_reserve(protocol_tao);
+            mock_ops.set_alpha_reserve(protocol_alpha);
+            mock_ops.deposit_balances(&account_id, user_tao, user_alpha);
+            let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
+
+            // Get tick infos and liquidity before adding (to account for protocol liquidity)
+            let tick_low_info_before = swap
+                .state_ops
+                .get_tick_by_index(tick_low)
+                .unwrap_or_default();
+            let tick_high_info_before = swap
+                .state_ops
+                .get_tick_by_index(tick_high)
+                .unwrap_or_default();
+            let liquidity_before = swap.state_ops.get_current_liquidity();
+
+            // Add liquidity
+            assert!(
+                swap.add_liquidity(&account_id, tick_low, tick_high, *liquidity, false)
+                    .is_ok()
+            );
+
+            // Check that low and high ticks appear in the state and are properly updated
+            let tick_low_info = swap.state_ops.get_tick_by_index(tick_low).unwrap();
+            let tick_high_info = swap.state_ops.get_tick_by_index(tick_high).unwrap();
+            let expected_liquidity_net_low: i128 = *liquidity as i128;
+            let expected_liquidity_gross_low: u64 = *liquidity;
+            let expected_liquidity_net_high: i128 = (*liquidity as i128).neg();
+            let expected_liquidity_gross_high: u64 = *liquidity;
+            assert_eq!(
+                tick_low_info.liquidity_net - tick_low_info_before.liquidity_net,
+                expected_liquidity_net_low,
+            );
+            assert_eq!(
+                tick_low_info.liquidity_gross - tick_low_info_before.liquidity_gross,
+                expected_liquidity_gross_low,
+            );
+            assert_eq!(
+                tick_high_info.liquidity_net - tick_high_info_before.liquidity_net,
+                expected_liquidity_net_high,
+            );
+            assert_eq!(
+                tick_high_info.liquidity_gross - tick_high_info_before.liquidity_gross,
+                expected_liquidity_gross_high,
+            );
+
+            // Balances are withdrawn
+            let (user_tao_after, user_alpha_after) =
+                swap.state_ops.balances.get(&account_id).unwrap();
+            let tao_withdrawn = user_tao - user_tao_after;
+            let alpha_withdrawn = user_alpha - user_alpha_after;
+            assert_abs_diff_eq!(tao_withdrawn, *tao, epsilon = *tao / 1000);
+            assert_abs_diff_eq!(alpha_withdrawn, *alpha, epsilon = *alpha / 1000);
+
+            // Liquidity position at correct ticks
+            assert_eq!(swap.state_ops.get_position_count(&account_id), 1);
+
+            let position = swap.state_ops.get_position(&account_id, 0).unwrap();
+            assert_eq!(position.liquidity, *liquidity);
+            assert_eq!(position.tick_low, tick_low);
+            assert_eq!(position.tick_high, tick_high);
+            assert_eq!(position.fees_alpha, 0);
+            assert_eq!(position.fees_tao, 0);
+
+            // Current liquidity is updated only when price range includes the current price
+            if (*price_high >= current_price) && (*price_low <= current_price) {
+                assert_eq!(
+                    swap.state_ops.get_current_liquidity(),
+                    liquidity_before + *liquidity
+                );
+            } else {
+                assert_eq!(swap.state_ops.get_current_liquidity(), liquidity_before);
+            }
+
+            // Reserves are updated
+            assert_eq!(
+                swap.state_ops.get_tao_reserve(),
+                tao_withdrawn + protocol_tao,
+            );
+            assert_eq!(
+                swap.state_ops.get_alpha_reserve(),
+                alpha_withdrawn + protocol_alpha,
+            );
+        });
+    }
+
+    #[test]
+    fn test_add_liquidity_out_of_bounds() {
+        let protocol_tao = 1_000_000_000;
+        let protocol_alpha = 2_000_000_000;
+        let user_tao = 100_000_000_000;
+        let user_alpha = 100_000_000_000;
+        let account_id = 1;
+
+        [
+            (MIN_TICK_INDEX - 1, MAX_TICK_INDEX, 1_000_000_000_u64),
+            (MIN_TICK_INDEX, MAX_TICK_INDEX + 1, 1_000_000_000_u64),
+            (MIN_TICK_INDEX - 1, MAX_TICK_INDEX + 1, 1_000_000_000_u64),
+            (
+                MIN_TICK_INDEX - 100,
+                MAX_TICK_INDEX + 100,
+                1_000_000_000_u64,
+            ),
+        ]
+        .iter()
+        .for_each(|(tick_low, tick_high, liquidity)| {
+            // Setup swap
+            let mut mock_ops = MockSwapDataOperations::new();
+            mock_ops.set_tao_reserve(protocol_tao);
+            mock_ops.set_alpha_reserve(protocol_alpha);
+            mock_ops.deposit_balances(&account_id, user_tao, user_alpha);
+            let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
+
+            // Add liquidity
+            assert_eq!(
+                swap.add_liquidity(&account_id, *tick_low, *tick_high, *liquidity, false),
+                Err(SwapError::InvalidTickRange),
+            );
+        });
+    }
+
+    #[test]
+    fn test_add_liquidity_over_balance() {
+        let protocol_tao = 1_000_000_000;
+        let protocol_alpha = 4_000_000_000;
+        let user_tao = 1_000_000_000;
+        let user_alpha = 1_000_000_000;
+        let account_id = 1;
+
+        [
+            // Lower than price (not enough alpha)
+            (0.1, 0.2, 100_000_000_000_u64),
+            // Higher than price (not enough tao)
+            (0.3, 0.4, 100_000_000_000_u64),
+            // Around the price (not enough both)
+            (0.1, 0.4, 100_000_000_000_u64),
+        ]
+        .iter()
+        .for_each(|(price_low, price_high, liquidity)| {
+            // Calculate ticks
+            let tick_low = price_to_tick(*price_low);
+            let tick_high = price_to_tick(*price_high);
+
+            // Setup swap
+            let mut mock_ops = MockSwapDataOperations::new();
+            mock_ops.set_tao_reserve(protocol_tao);
+            mock_ops.set_alpha_reserve(protocol_alpha);
+            mock_ops.deposit_balances(&account_id, user_tao, user_alpha);
+            let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
+
+            // Add liquidity
+            assert_eq!(
+                swap.add_liquidity(&account_id, tick_low, tick_high, *liquidity, false),
+                Err(SwapError::InsufficientBalance),
+            );
+        });
+    }
+
+    // Test removing liquidity
+    #[test]
+    fn test_remove_liquidity_basic() {
+        let protocol_tao = 1_000_000_000;
+        let protocol_alpha = 4_000_000_000;
+        let user_tao = 100_000_000_000;
+        let user_alpha = 100_000_000_000;
+        let account_id = 1;
+        let min_price = tick_to_price(MIN_TICK_INDEX);
+        let max_price = tick_to_price(MAX_TICK_INDEX);
+        let max_tick = price_to_tick(max_price);
+        assert_eq!(max_tick, MAX_TICK_INDEX);
+
+        // As a user add liquidity with all possible corner cases
+        //   - Initial price is 0.25
+        //   - liquidity is expressed in RAO units
+        // Test case is (price_low, price_high, liquidity, tao, alpha)
+        [
+            // Repeat the protocol liquidity at maximum range: Expect all the same values
+            (
+                min_price,
+                max_price,
+                2_000_000_000_u64,
+                1_000_000_000_u64,
+                4_000_000_000_u64,
+            ),
+            // Repeat the protocol liquidity at current to max range: Expect the same alpha
+            (0.25, max_price, 2_000_000_000_u64, 0, 4_000_000_000),
+            // Repeat the protocol liquidity at min to current range: Expect all the same tao
+            (min_price, 0.24999, 2_000_000_000_u64, 1_000_000_000, 0),
+            // Half to double price - just some sane wothdraw amounts
+            (0.125, 0.5, 2_000_000_000_u64, 293_000_000, 1_171_000_000),
+            // Both below price - tao is non-zero, alpha is zero
+            (0.12, 0.13, 2_000_000_000_u64, 28_270_000, 0),
+            // Both above price - tao is zero, alpha is non-zero
+            (0.3, 0.4, 2_000_000_000_u64, 0, 489_200_000),
+        ]
+        .iter()
+        .for_each(|(price_low, price_high, liquidity, tao, alpha)| {
+            // Calculate ticks (assuming tick math is tested separately)
+            let tick_low = price_to_tick(*price_low);
+            let tick_high = price_to_tick(*price_high);
+
+            // Setup swap
+            let mut mock_ops = MockSwapDataOperations::new();
+            mock_ops.set_tao_reserve(protocol_tao);
+            mock_ops.set_alpha_reserve(protocol_alpha);
+            mock_ops.deposit_balances(&account_id, user_tao, user_alpha);
+            let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
+            let liquidity_before = swap.state_ops.get_current_liquidity();
+
+            // Add liquidity
+            assert!(
+                swap.add_liquidity(&account_id, tick_low, tick_high, *liquidity, false)
+                    .is_ok()
+            );
+
+            // Remove liquidity
+            let remove_result = swap.remove_liquidity(&account_id, 0).unwrap();
+            assert_abs_diff_eq!(remove_result.tao, *tao, epsilon = *tao / 1000);
+            assert_abs_diff_eq!(remove_result.alpha, *alpha, epsilon = *alpha / 1000);
+            assert_eq!(remove_result.fee_tao, 0);
+            assert_eq!(remove_result.fee_alpha, 0);
+
+            // Balances are returned
+            let (user_tao_after, user_alpha_after) =
+                swap.state_ops.balances.get(&account_id).unwrap();
+            assert_eq!(user_tao, *user_tao_after);
+            assert_eq!(user_alpha, *user_alpha_after);
+
+            // Liquidity position is removed
+            assert_eq!(swap.state_ops.get_position_count(&account_id), 0);
+            assert!(swap.state_ops.get_position(&account_id, 0).is_none());
+
+            // Current liquidity is updated (back where it was)
+            assert_eq!(swap.state_ops.get_current_liquidity(), liquidity_before);
+
+            // Reserves are updated (back where they were)
+            assert_eq!(swap.state_ops.get_tao_reserve(), protocol_tao,);
+            assert_eq!(swap.state_ops.get_alpha_reserve(), protocol_alpha,);
+        });
+    }
+
+    #[test]
+    fn test_remove_liquidity_nonexisting_position() {
+        let protocol_tao = 1_000_000_000;
+        let protocol_alpha = 4_000_000_000;
+        let user_tao = 100_000_000_000;
+        let user_alpha = 100_000_000_000;
+        let account_id = 1;
+        let min_price = tick_to_price(MIN_TICK_INDEX);
+        let max_price = tick_to_price(MAX_TICK_INDEX);
+        let max_tick = price_to_tick(max_price);
+        assert_eq!(max_tick, MAX_TICK_INDEX);
+
+        // Test case is (price_low, price_high, liquidity)
+        [
+            // Repeat the protocol liquidity at maximum range: Expect all the same values
+            (min_price, max_price, 2_000_000_000_u64),
+        ]
+        .iter()
+        .for_each(|(price_low, price_high, liquidity)| {
+            // Calculate ticks (assuming tick math is tested separately)
+            let tick_low = price_to_tick(*price_low);
+            let tick_high = price_to_tick(*price_high);
+
+            // Setup swap
+            let mut mock_ops = MockSwapDataOperations::new();
+            mock_ops.set_tao_reserve(protocol_tao);
+            mock_ops.set_alpha_reserve(protocol_alpha);
+            mock_ops.deposit_balances(&account_id, user_tao, user_alpha);
+            let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
+
+            // Add liquidity
+            assert!(
+                swap.add_liquidity(&account_id, tick_low, tick_high, *liquidity, false)
+                    .is_ok()
+            );
+
+            // Remove liquidity
+            assert_eq!(
+                swap.remove_liquidity(&account_id, 1),
+                Err(SwapError::LiquidityNotFound),
+            );
+        });
+    }
+}
diff --git a/pallets/swap/src/tick.rs b/pallets/swap/src/tick.rs
new file mode 100644
index 0000000000..e5e7eefc16
--- /dev/null
+++ b/pallets/swap/src/tick.rs
@@ -0,0 +1,191 @@
+use substrate_fixed::types::U64F64;
+
+use crate::tick_math::{
+    MAX_TICK, MIN_TICK, TickMathError, get_sqrt_ratio_at_tick, get_tick_at_sqrt_ratio,
+    u64f64_to_u256_q64_96, u256_q64_96_to_u64f64,
+};
+use crate::{SqrtPrice, SwapDataOperations};
+
+// Maximum and minimum values of the tick index
+// The tick_math library uses different bitness, so we have to divide by 2.
+// Do not use tick_math::MIN_TICK and tick_math::MAX_TICK
+pub const MAX_TICK_INDEX: i32 = MAX_TICK / 2;
+pub const MIN_TICK_INDEX: i32 = MIN_TICK / 2;
+
+/// Tick is the price range determined by tick index (not part of this struct,
+/// but is the key at which the Tick is stored in state hash maps). Tick struct
+/// stores liquidity and fee information.
+///
+///   - Net liquidity
+///   - Gross liquidity
+///   - Fees (above global) in both currencies
+///
+#[derive(Debug, Default, Clone)]
+pub struct Tick {
+    pub liquidity_net: i128,
+    pub liquidity_gross: u64,
+    pub fees_out_tao: U64F64,
+    pub fees_out_alpha: U64F64,
+}
+
+/// Converts tick index into SQRT of lower price of this tick
+/// In order to find the higher price of this tick, call
+/// tick_index_to_sqrt_price(tick_idx + 1)
+pub fn tick_index_to_sqrt_price(tick_idx: i32) -> Result<SqrtPrice, TickMathError> {
+    // because of u256->u128 conversion we have twice less values for min/max ticks
+    if !(MIN_TICK / 2..=MAX_TICK / 2).contains(&tick_idx) {
+        return Err(TickMathError::TickOutOfBounds);
+    }
+    get_sqrt_ratio_at_tick(tick_idx).and_then(u256_q64_96_to_u64f64)
+}
+
+/// Converts SQRT price to tick index
+/// Because the tick is the range of prices [sqrt_lower_price, sqrt_higher_price),
+/// the resulting tick index matches the price by the following inequality:
+///    sqrt_lower_price <= sqrt_price < sqrt_higher_price
+pub fn sqrt_price_to_tick_index(sqrt_price: SqrtPrice) -> Result<i32, TickMathError> {
+    let tick = get_tick_at_sqrt_ratio(u64f64_to_u256_q64_96(sqrt_price))?;
+
+    // Correct for rounding error during conversions between different fixed-point formats
+    Ok(if tick == 0 {
+        tick
+    } else {
+        tick.saturating_add(1)
+    })
+}
+
+pub fn find_closest_lower_active_tick_index<Ops, AccountIdType>(
+    ops: &Ops,
+    index: i32,
+) -> Option<i32>
+where
+    AccountIdType: Eq,
+    Ops: SwapDataOperations<AccountIdType>,
+{
+    // TODO: Implement without iteration
+    let mut current_index = index;
+    loop {
+        if current_index < MIN_TICK {
+            return None;
+        }
+        if ops.get_tick_by_index(current_index).is_some() {
+            return Some(current_index);
+        }
+
+        // Intentionally using unsafe math here to trigger CI
+        current_index -= 1;
+    }
+}
+
+pub fn find_closest_higher_active_tick_index<Ops, AccountIdType>(
+    ops: &Ops,
+    index: i32,
+) -> Option<i32>
+where
+    AccountIdType: Eq,
+    Ops: SwapDataOperations<AccountIdType>,
+{
+    // TODO: Implement without iteration
+    let mut current_index = index;
+    loop {
+        if current_index > MAX_TICK {
+            return None;
+        }
+        if ops.get_tick_by_index(current_index).is_some() {
+            return Some(current_index);
+        }
+
+        // Intentionally using unsafe math here to trigger CI
+        current_index += 1;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use safe_math::FixedExt;
+
+    #[test]
+    fn test_tick_index_to_sqrt_price() {
+        let tick_spacing = SqrtPrice::from_num(1.0001);
+
+        // check tick bounds
+        assert_eq!(
+            tick_index_to_sqrt_price(MIN_TICK),
+            Err(TickMathError::TickOutOfBounds)
+        );
+
+        assert_eq!(
+            tick_index_to_sqrt_price(MAX_TICK),
+            Err(TickMathError::TickOutOfBounds),
+        );
+
+        // At tick index 0, the sqrt price should be 1.0
+        let sqrt_price = tick_index_to_sqrt_price(0).unwrap();
+        assert_eq!(sqrt_price, SqrtPrice::from_num(1.0));
+
+        let sqrt_price = tick_index_to_sqrt_price(2).unwrap();
+        assert!(sqrt_price.abs_diff(tick_spacing) < SqrtPrice::from_num(1e-10));
+
+        let sqrt_price = tick_index_to_sqrt_price(4).unwrap();
+        // Calculate the expected value: (1 + TICK_SPACING/1e9 + 1.0)^2
+        let expected = tick_spacing * tick_spacing;
+        assert!(sqrt_price.abs_diff(expected) < SqrtPrice::from_num(1e-10));
+
+        // Test with tick index 10
+        let sqrt_price = tick_index_to_sqrt_price(10).unwrap();
+        // Calculate the expected value: (1 + TICK_SPACING/1e9 + 1.0)^5
+        let expected = tick_spacing.checked_pow(5).unwrap();
+        assert!(
+            sqrt_price.abs_diff(expected) < SqrtPrice::from_num(1e-10),
+            "diff: {}",
+            sqrt_price.abs_diff(expected),
+        );
+    }
+
+    #[test]
+    fn test_sqrt_price_to_tick_index() {
+        let tick_spacing = SqrtPrice::from_num(1.0001);
+        let tick_index = sqrt_price_to_tick_index(SqrtPrice::from_num(1.0)).unwrap();
+        assert_eq!(tick_index, 0);
+
+        // Test with sqrt price equal to tick_spacing_tao (should be tick index 2)
+        let tick_index = sqrt_price_to_tick_index(tick_spacing).unwrap();
+        assert_eq!(tick_index, 2);
+
+        // Test with sqrt price equal to tick_spacing_tao^2 (should be tick index 4)
+        let sqrt_price = tick_spacing * tick_spacing;
+        let tick_index = sqrt_price_to_tick_index(sqrt_price).unwrap();
+        assert_eq!(tick_index, 4);
+
+        // Test with sqrt price equal to tick_spacing_tao^5 (should be tick index 10)
+        let sqrt_price = tick_spacing.checked_pow(5).unwrap();
+        let tick_index = sqrt_price_to_tick_index(sqrt_price).unwrap();
+        assert_eq!(tick_index, 10);
+    }
+
+    #[test]
+    fn test_roundtrip_tick_index_sqrt_price() {
+        for tick_index in [
+            MIN_TICK / 2,
+            -1000,
+            -100,
+            -10,
+            -4,
+            -2,
+            0,
+            2,
+            4,
+            10,
+            100,
+            1000,
+            MAX_TICK / 2,
+        ]
+        .iter()
+        {
+            let sqrt_price = tick_index_to_sqrt_price(*tick_index).unwrap();
+            let round_trip_tick_index = sqrt_price_to_tick_index(sqrt_price).unwrap();
+            assert_eq!(round_trip_tick_index, *tick_index);
+        }
+    }
+}
diff --git a/pallets/swap/src/tick_math.rs b/pallets/swap/src/tick_math.rs
new file mode 100644
index 0000000000..3dfcb0d514
--- /dev/null
+++ b/pallets/swap/src/tick_math.rs
@@ -0,0 +1,539 @@
+//! This module is adopted from github.com/0xKitsune/uniswap-v3-math
+use core::error::Error;
+use core::fmt;
+use core::ops::{BitOr, Neg, Shl, Shr};
+
+use alloy_primitives::{I256, U256};
+use substrate_fixed::types::U64F64;
+
+const U256_1: U256 = U256::from_limbs([1, 0, 0, 0]);
+const U256_2: U256 = U256::from_limbs([2, 0, 0, 0]);
+const U256_3: U256 = U256::from_limbs([3, 0, 0, 0]);
+const U256_4: U256 = U256::from_limbs([4, 0, 0, 0]);
+const U256_5: U256 = U256::from_limbs([5, 0, 0, 0]);
+const U256_6: U256 = U256::from_limbs([6, 0, 0, 0]);
+const U256_7: U256 = U256::from_limbs([7, 0, 0, 0]);
+const U256_8: U256 = U256::from_limbs([8, 0, 0, 0]);
+const U256_15: U256 = U256::from_limbs([15, 0, 0, 0]);
+const U256_16: U256 = U256::from_limbs([16, 0, 0, 0]);
+const U256_32: U256 = U256::from_limbs([32, 0, 0, 0]);
+const U256_64: U256 = U256::from_limbs([64, 0, 0, 0]);
+const U256_127: U256 = U256::from_limbs([127, 0, 0, 0]);
+const U256_128: U256 = U256::from_limbs([128, 0, 0, 0]);
+const U256_255: U256 = U256::from_limbs([255, 0, 0, 0]);
+
+const U256_256: U256 = U256::from_limbs([256, 0, 0, 0]);
+const U256_512: U256 = U256::from_limbs([512, 0, 0, 0]);
+const U256_1024: U256 = U256::from_limbs([1024, 0, 0, 0]);
+const U256_2048: U256 = U256::from_limbs([2048, 0, 0, 0]);
+const U256_4096: U256 = U256::from_limbs([4096, 0, 0, 0]);
+const U256_8192: U256 = U256::from_limbs([8192, 0, 0, 0]);
+const U256_16384: U256 = U256::from_limbs([16384, 0, 0, 0]);
+const U256_32768: U256 = U256::from_limbs([32768, 0, 0, 0]);
+const U256_65536: U256 = U256::from_limbs([65536, 0, 0, 0]);
+const U256_131072: U256 = U256::from_limbs([131072, 0, 0, 0]);
+const U256_262144: U256 = U256::from_limbs([262144, 0, 0, 0]);
+const U256_524288: U256 = U256::from_limbs([524288, 0, 0, 0]);
+
+const U256_MAX_TICK: U256 = U256::from_limbs([887272, 0, 0, 0]);
+
+pub(crate) const MIN_TICK: i32 = -887272;
+pub(crate) const MAX_TICK: i32 = -MIN_TICK;
+
+const MIN_SQRT_RATIO: U256 = U256::from_limbs([4295128739, 0, 0, 0]);
+const MAX_SQRT_RATIO: U256 =
+    U256::from_limbs([6743328256752651558, 17280870778742802505, 4294805859, 0]);
+
+const SQRT_10001: I256 = I256::from_raw(U256::from_limbs([11745905768312294533, 13863, 0, 0]));
+const TICK_LOW: I256 = I256::from_raw(U256::from_limbs([
+    6552757943157144234,
+    184476617836266586,
+    0,
+    0,
+]));
+const TICK_HIGH: I256 = I256::from_raw(U256::from_limbs([
+    4998474450511881007,
+    15793544031827761793,
+    0,
+    0,
+]));
+
+pub(crate) fn get_sqrt_ratio_at_tick(tick: i32) -> Result<U256, TickMathError> {
+    let abs_tick = if tick < 0 {
+        U256::from(tick.neg())
+    } else {
+        U256::from(tick)
+    };
+
+    if abs_tick > U256_MAX_TICK {
+        return Err(TickMathError::TickOutOfBounds);
+    }
+
+    let mut ratio = if abs_tick & (U256_1) != U256::ZERO {
+        U256::from_limbs([12262481743371124737, 18445821805675392311, 0, 0])
+    } else {
+        U256::from_limbs([0, 0, 1, 0])
+    };
+
+    if !(abs_tick & U256_2).is_zero() {
+        ratio = (ratio * U256::from_limbs([6459403834229662010, 18444899583751176498, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_4).is_zero() {
+        ratio =
+            (ratio * U256::from_limbs([17226890335427755468, 18443055278223354162, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_8).is_zero() {
+        ratio = (ratio * U256::from_limbs([2032852871939366096, 18439367220385604838, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_16).is_zero() {
+        ratio =
+            (ratio * U256::from_limbs([14545316742740207172, 18431993317065449817, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_32).is_zero() {
+        ratio = (ratio * U256::from_limbs([5129152022828963008, 18417254355718160513, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_64).is_zero() {
+        ratio = (ratio * U256::from_limbs([4894419605888772193, 18387811781193591352, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_128).is_zero() {
+        ratio = (ratio * U256::from_limbs([1280255884321894483, 18329067761203520168, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_256).is_zero() {
+        ratio =
+            (ratio * U256::from_limbs([15924666964335305636, 18212142134806087854, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_512).is_zero() {
+        ratio = (ratio * U256::from_limbs([8010504389359918676, 17980523815641551639, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_1024).is_zero() {
+        ratio =
+            (ratio * U256::from_limbs([10668036004952895731, 17526086738831147013, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_2048).is_zero() {
+        ratio = (ratio * U256::from_limbs([4878133418470705625, 16651378430235024244, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_4096).is_zero() {
+        ratio = (ratio * U256::from_limbs([9537173718739605541, 15030750278693429944, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_8192).is_zero() {
+        ratio = (ratio * U256::from_limbs([9972618978014552549, 12247334978882834399, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_16384).is_zero() {
+        ratio = (ratio * U256::from_limbs([10428997489610666743, 8131365268884726200, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_32768).is_zero() {
+        ratio = (ratio * U256::from_limbs([9305304367709015974, 3584323654723342297, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_65536).is_zero() {
+        ratio = (ratio * U256::from_limbs([14301143598189091785, 696457651847595233, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_131072).is_zero() {
+        ratio = (ratio * U256::from_limbs([7393154844743099908, 26294789957452057, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_262144).is_zero() {
+        ratio = (ratio * U256::from_limbs([2209338891292245656, 37481735321082, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_524288).is_zero() {
+        ratio = (ratio * U256::from_limbs([10518117631919034274, 76158723, 0, 0])) >> 128
+    }
+
+    if tick > 0 {
+        ratio = U256::MAX / ratio;
+    }
+
+    Ok((ratio >> 32)
+        + if (ratio.wrapping_rem(U256_1 << 32)).is_zero() {
+            U256::ZERO
+        } else {
+            U256_1
+        })
+}
+
+pub(crate) fn get_tick_at_sqrt_ratio(sqrt_price_x_96: U256) -> Result<i32, TickMathError> {
+    if !(sqrt_price_x_96 >= MIN_SQRT_RATIO && sqrt_price_x_96 < MAX_SQRT_RATIO) {
+        return Err(TickMathError::SqrtPriceOutOfBounds);
+    }
+
+    let ratio: U256 = sqrt_price_x_96.shl(32);
+    let mut r = ratio;
+    let mut msb = U256::ZERO;
+
+    let mut f = if r > U256::from_limbs([18446744073709551615, 18446744073709551615, 0, 0]) {
+        U256_1.shl(U256_7)
+    } else {
+        U256::ZERO
+    };
+    msb = msb.bitor(f);
+    r = r.shr(f);
+
+    f = if r > U256::from_limbs([18446744073709551615, 0, 0, 0]) {
+        U256_1.shl(U256_6)
+    } else {
+        U256::ZERO
+    };
+    msb = msb.bitor(f);
+    r = r.shr(f);
+
+    f = if r > U256::from_limbs([4294967295, 0, 0, 0]) {
+        U256_1.shl(U256_5)
+    } else {
+        U256::ZERO
+    };
+    msb = msb.bitor(f);
+    r = r.shr(f);
+
+    f = if r > U256::from_limbs([65535, 0, 0, 0]) {
+        U256_1.shl(U256_4)
+    } else {
+        U256::ZERO
+    };
+    msb = msb.bitor(f);
+    r = r.shr(f);
+
+    f = if r > U256_255 {
+        U256_1.shl(U256_3)
+    } else {
+        U256::ZERO
+    };
+    msb = msb.bitor(f);
+    r = r.shr(f);
+
+    f = if r > U256_15 {
+        U256_1.shl(U256_2)
+    } else {
+        U256::ZERO
+    };
+    msb = msb.bitor(f);
+    r = r.shr(f);
+
+    f = if r > U256_3 {
+        U256_1.shl(U256_1)
+    } else {
+        U256::ZERO
+    };
+    msb = msb.bitor(f);
+    r = r.shr(f);
+
+    f = if r > U256_1 { U256_1 } else { U256::ZERO };
+
+    msb = msb.bitor(f);
+
+    r = if msb >= U256_128 {
+        ratio.shr(msb - U256_127)
+    } else {
+        ratio.shl(U256_127 - msb)
+    };
+
+    let mut log_2: I256 = (I256::from_raw(msb) - I256::from_limbs([128, 0, 0, 0])).shl(64);
+
+    for i in (51..=63).rev() {
+        r = r.overflowing_mul(r).0.shr(U256_127);
+        let f: U256 = r.shr(128);
+        log_2 = log_2.bitor(I256::from_raw(f.shl(i)));
+
+        r = r.shr(f);
+    }
+
+    r = r.overflowing_mul(r).0.shr(U256_127);
+    let f: U256 = r.shr(128);
+    log_2 = log_2.bitor(I256::from_raw(f.shl(50)));
+
+    let log_sqrt10001 = log_2.wrapping_mul(SQRT_10001);
+
+    let tick_low = ((log_sqrt10001 - TICK_LOW) >> 128_u8).low_i32();
+
+    let tick_high = ((log_sqrt10001 + TICK_HIGH) >> 128_u8).low_i32();
+
+    let tick = if tick_low == tick_high {
+        tick_low
+    } else if get_sqrt_ratio_at_tick(tick_high)? <= sqrt_price_x_96 {
+        tick_high
+    } else {
+        tick_low
+    };
+
+    Ok(tick)
+}
+
+/// Convert U256 to U64F64
+///
+/// # Arguments
+/// * `value` - The U256 value in Q64.96 format
+///
+/// # Returns
+/// * `Result<U64F64, &'static str>` - Converted value or error if too large
+pub(crate) fn u256_to_u64f64(
+    value: U256,
+    source_fractional_bits: u32,
+) -> Result<U64F64, TickMathError> {
+    if value > U256::from(u128::MAX) {
+        return Err(TickMathError::ConversionError);
+    }
+
+    let mut value: u128 = value
+        .try_into()
+        .map_err(|_| TickMathError::ConversionError)?;
+
+    // Adjust to 64 fractional bits (U64F64 format)
+    if source_fractional_bits < 64 {
+        // Shift left to add more fractional bits
+        value = value
+            .checked_shl(64 - source_fractional_bits)
+            .ok_or(TickMathError::Overflow)?;
+    } else if source_fractional_bits > 64 {
+        // Shift right to remove excess fractional bits
+        value = value >> (source_fractional_bits - 64);
+    }
+
+    Ok(U64F64::from_bits(value))
+}
+
+/// Convert U64F64 to U256
+///
+/// # Arguments
+/// * `value` - The U64F64 value to convert
+/// * `target_fractional_bits` - Number of fractional bits in the target U256 format
+///
+/// # Returns
+/// * `U256` - Converted value
+pub(crate) fn u64f64_to_u256(value: U64F64, target_fractional_bits: u32) -> U256 {
+    let mut bits = value.to_bits();
+
+    // Adjust to target fractional bits
+    if target_fractional_bits < 64 {
+        // Shift right to remove excess fractional bits
+        bits = bits >> (64 - target_fractional_bits);
+    } else if target_fractional_bits > 64 {
+        // Shift left to add more fractional bits
+        bits = bits << (target_fractional_bits - 64);
+    }
+
+    // Create U256
+    U256::from(bits)
+}
+
+/// Convert U256 in Q64.96 format (Uniswap's sqrt price format) to U64F64
+pub(crate) fn u256_q64_96_to_u64f64(value: U256) -> Result<U64F64, TickMathError> {
+    u256_to_u64f64(value, 96)
+}
+
+/// Convert U64F64 to U256 in Q64.96 format (Uniswap's sqrt price format)
+pub(crate) fn u64f64_to_u256_q64_96(value: U64F64) -> U256 {
+    u64f64_to_u256(value, 96)
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum TickMathError {
+    TickOutOfBounds,
+    SqrtPriceOutOfBounds,
+    ConversionError,
+    Overflow,
+}
+
+impl fmt::Display for TickMathError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+			Self::TickOutOfBounds => f.write_str("The given tick is outside of the minimum/maximum values."),
+			Self::SqrtPriceOutOfBounds =>f.write_str("Second inequality must be < because the price can never reach the price at the max tick"),
+			Self::ConversionError => f.write_str("Error converting from one number type into another"),
+			Self::Overflow => f.write_str("Number overflow in arithmetic operation")
+		}
+    }
+}
+
+impl Error for TickMathError {}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use std::{ops::Sub, str::FromStr};
+
+    #[test]
+    fn test_get_sqrt_ratio_at_tick_bounds() {
+        // the function should return an error if the tick is out of bounds
+        if let Err(err) = get_sqrt_ratio_at_tick(MIN_TICK - 1) {
+            assert!(matches!(err, TickMathError::TickOutOfBounds));
+        } else {
+            panic!("get_qrt_ratio_at_tick did not respect lower tick bound")
+        }
+        if let Err(err) = get_sqrt_ratio_at_tick(MAX_TICK + 1) {
+            assert!(matches!(err, TickMathError::TickOutOfBounds));
+        } else {
+            panic!("get_qrt_ratio_at_tick did not respect upper tick bound")
+        }
+    }
+
+    #[test]
+    fn test_get_sqrt_ratio_at_tick_values() {
+        // test individual values for correct results
+        assert_eq!(
+            get_sqrt_ratio_at_tick(MIN_TICK).unwrap(),
+            U256::from(4295128739u64),
+            "sqrt ratio at min incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(MIN_TICK + 1).unwrap(),
+            U256::from(4295343490u64),
+            "sqrt ratio at min + 1 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(MAX_TICK - 1).unwrap(),
+            U256::from_str("1461373636630004318706518188784493106690254656249").unwrap(),
+            "sqrt ratio at max - 1 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(MAX_TICK).unwrap(),
+            U256::from_str("1461446703485210103287273052203988822378723970342").unwrap(),
+            "sqrt ratio at max incorrect"
+        );
+        // checking hard coded values against solidity results
+        assert_eq!(
+            get_sqrt_ratio_at_tick(50).unwrap(),
+            U256::from(79426470787362580746886972461u128),
+            "sqrt ratio at 50 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(100).unwrap(),
+            U256::from(79625275426524748796330556128u128),
+            "sqrt ratio at 100 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(250).unwrap(),
+            U256::from(80224679980005306637834519095u128),
+            "sqrt ratio at 250 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(500).unwrap(),
+            U256::from(81233731461783161732293370115u128),
+            "sqrt ratio at 500 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(1000).unwrap(),
+            U256::from(83290069058676223003182343270u128),
+            "sqrt ratio at 1000 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(2500).unwrap(),
+            U256::from(89776708723587163891445672585u128),
+            "sqrt ratio at 2500 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(3000).unwrap(),
+            U256::from(92049301871182272007977902845u128),
+            "sqrt ratio at 3000 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(4000).unwrap(),
+            U256::from(96768528593268422080558758223u128),
+            "sqrt ratio at 4000 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(5000).unwrap(),
+            U256::from(101729702841318637793976746270u128),
+            "sqrt ratio at 5000 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(50000).unwrap(),
+            U256::from(965075977353221155028623082916u128),
+            "sqrt ratio at 50000 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(150000).unwrap(),
+            U256::from(143194173941309278083010301478497u128),
+            "sqrt ratio at 150000 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(250000).unwrap(),
+            U256::from(21246587762933397357449903968194344u128),
+            "sqrt ratio at 250000 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(500000).unwrap(),
+            U256::from_str("5697689776495288729098254600827762987878").unwrap(),
+            "sqrt ratio at 500000 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(738203).unwrap(),
+            U256::from_str("847134979253254120489401328389043031315994541").unwrap(),
+            "sqrt ratio at 738203 incorrect"
+        );
+    }
+
+    #[test]
+    fn test_get_tick_at_sqrt_ratio() {
+        //throws for too low
+        let result = get_tick_at_sqrt_ratio(MIN_SQRT_RATIO.sub(U256_1));
+        assert_eq!(
+            result.unwrap_err().to_string(),
+            "Second inequality must be < because the price can never reach the price at the max tick"
+        );
+
+        //throws for too high
+        let result = get_tick_at_sqrt_ratio(MAX_SQRT_RATIO);
+        assert_eq!(
+            result.unwrap_err().to_string(),
+            "Second inequality must be < because the price can never reach the price at the max tick"
+        );
+
+        //ratio of min tick
+        let result = get_tick_at_sqrt_ratio(MIN_SQRT_RATIO).unwrap();
+        assert_eq!(result, MIN_TICK);
+
+        //ratio of min tick + 1
+        let result = get_tick_at_sqrt_ratio(U256::from_str("4295343490").unwrap()).unwrap();
+        assert_eq!(result, MIN_TICK + 1);
+    }
+
+    #[test]
+    fn test_roundtrip() {
+        for tick_index in [
+            MIN_TICK + 1, // we can't use extremes because of rounding during roundtrip conversion
+            -1000,
+            -100,
+            -10,
+            -4,
+            -2,
+            0,
+            2,
+            4,
+            10,
+            100,
+            1000,
+            MAX_TICK - 1,
+        ]
+        .iter()
+        {
+            let sqrt_price = get_sqrt_ratio_at_tick(*tick_index).unwrap();
+            let round_trip_tick_index = get_tick_at_sqrt_ratio(sqrt_price).unwrap();
+            assert_eq!(round_trip_tick_index, *tick_index);
+        }
+    }
+
+    #[test]
+    fn test_u256_to_u64f64_q64_96() {
+        // Test tick 0 (sqrt price = 1.0 * 2^96)
+        let tick0_sqrt_price = U256::from(1u128 << 96);
+        let fixed_price = u256_q64_96_to_u64f64(tick0_sqrt_price).unwrap();
+
+        // Should be 1.0 in U64F64
+        assert_eq!(fixed_price, U64F64::from_num(1.0));
+
+        // Round trip back to U256 Q64.96
+        let back_to_u256 = u64f64_to_u256_q64_96(fixed_price);
+        assert_eq!(back_to_u256, tick0_sqrt_price);
+    }
+
+    #[test]
+    fn test_u256_with_other_formats() {
+        // Test with a value that has 32 fractional bits
+        let value_32frac = U256::from(123456789u128 << 32); // 123456789.0 in Q96.32
+        let fixed_value = u256_to_u64f64(value_32frac, 32).unwrap();
+
+        // Should be 123456789.0 in U64F64
+        assert_eq!(fixed_value, U64F64::from_num(123456789.0));
+
+        // Round trip back to U256 with 32 fractional bits
+        let back_to_u256 = u64f64_to_u256(fixed_value, 32);
+        assert_eq!(back_to_u256, value_32frac);
+    }
+}

From 7b5b6f7cfa6b8f195988127d761356d1ebaec693 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Thu, 20 Mar 2025 20:20:16 +0100
Subject: [PATCH 022/418] Merge tick with tick_math in swap

---
 pallets/swap/src/lib.rs       |   1 -
 pallets/swap/src/tick.rs      | 543 +++++++++++++++++++++++++++++++++-
 pallets/swap/src/tick_math.rs | 539 ---------------------------------
 primitives/swap/src/lib.rs    |   7 +-
 4 files changed, 536 insertions(+), 554 deletions(-)
 delete mode 100644 pallets/swap/src/tick_math.rs

diff --git a/pallets/swap/src/lib.rs b/pallets/swap/src/lib.rs
index 6926758e80..1e3aaf6379 100644
--- a/pallets/swap/src/lib.rs
+++ b/pallets/swap/src/lib.rs
@@ -14,7 +14,6 @@ use self::tick::{
 
 mod error;
 mod tick;
-mod tick_math;
 
 type SqrtPrice = U64F64;
 
diff --git a/pallets/swap/src/tick.rs b/pallets/swap/src/tick.rs
index e5e7eefc16..91a1ba05b0 100644
--- a/pallets/swap/src/tick.rs
+++ b/pallets/swap/src/tick.rs
@@ -1,17 +1,71 @@
+//! The math is adapted from github.com/0xKitsune/uniswap-v3-math
+use core::error::Error;
+use core::fmt;
+use core::ops::{BitOr, Neg, Shl, Shr};
+
+use alloy_primitives::{I256, U256};
 use substrate_fixed::types::U64F64;
 
-use crate::tick_math::{
-    MAX_TICK, MIN_TICK, TickMathError, get_sqrt_ratio_at_tick, get_tick_at_sqrt_ratio,
-    u64f64_to_u256_q64_96, u256_q64_96_to_u64f64,
-};
 use crate::{SqrtPrice, SwapDataOperations};
 
-// Maximum and minimum values of the tick index
-// The tick_math library uses different bitness, so we have to divide by 2.
-// Do not use tick_math::MIN_TICK and tick_math::MAX_TICK
+/// Maximum and minimum values of the tick index
+/// The tick_math library uses different bitness, so we have to divide by 2.
+/// Do not use tick_math::MIN_TICK and tick_math::MAX_TICK
 pub const MAX_TICK_INDEX: i32 = MAX_TICK / 2;
 pub const MIN_TICK_INDEX: i32 = MIN_TICK / 2;
 
+const U256_1: U256 = U256::from_limbs([1, 0, 0, 0]);
+const U256_2: U256 = U256::from_limbs([2, 0, 0, 0]);
+const U256_3: U256 = U256::from_limbs([3, 0, 0, 0]);
+const U256_4: U256 = U256::from_limbs([4, 0, 0, 0]);
+const U256_5: U256 = U256::from_limbs([5, 0, 0, 0]);
+const U256_6: U256 = U256::from_limbs([6, 0, 0, 0]);
+const U256_7: U256 = U256::from_limbs([7, 0, 0, 0]);
+const U256_8: U256 = U256::from_limbs([8, 0, 0, 0]);
+const U256_15: U256 = U256::from_limbs([15, 0, 0, 0]);
+const U256_16: U256 = U256::from_limbs([16, 0, 0, 0]);
+const U256_32: U256 = U256::from_limbs([32, 0, 0, 0]);
+const U256_64: U256 = U256::from_limbs([64, 0, 0, 0]);
+const U256_127: U256 = U256::from_limbs([127, 0, 0, 0]);
+const U256_128: U256 = U256::from_limbs([128, 0, 0, 0]);
+const U256_255: U256 = U256::from_limbs([255, 0, 0, 0]);
+
+const U256_256: U256 = U256::from_limbs([256, 0, 0, 0]);
+const U256_512: U256 = U256::from_limbs([512, 0, 0, 0]);
+const U256_1024: U256 = U256::from_limbs([1024, 0, 0, 0]);
+const U256_2048: U256 = U256::from_limbs([2048, 0, 0, 0]);
+const U256_4096: U256 = U256::from_limbs([4096, 0, 0, 0]);
+const U256_8192: U256 = U256::from_limbs([8192, 0, 0, 0]);
+const U256_16384: U256 = U256::from_limbs([16384, 0, 0, 0]);
+const U256_32768: U256 = U256::from_limbs([32768, 0, 0, 0]);
+const U256_65536: U256 = U256::from_limbs([65536, 0, 0, 0]);
+const U256_131072: U256 = U256::from_limbs([131072, 0, 0, 0]);
+const U256_262144: U256 = U256::from_limbs([262144, 0, 0, 0]);
+const U256_524288: U256 = U256::from_limbs([524288, 0, 0, 0]);
+
+const U256_MAX_TICK: U256 = U256::from_limbs([887272, 0, 0, 0]);
+
+const MIN_TICK: i32 = -887272;
+const MAX_TICK: i32 = -MIN_TICK;
+
+const MIN_SQRT_RATIO: U256 = U256::from_limbs([4295128739, 0, 0, 0]);
+const MAX_SQRT_RATIO: U256 =
+    U256::from_limbs([6743328256752651558, 17280870778742802505, 4294805859, 0]);
+
+const SQRT_10001: I256 = I256::from_raw(U256::from_limbs([11745905768312294533, 13863, 0, 0]));
+const TICK_LOW: I256 = I256::from_raw(U256::from_limbs([
+    6552757943157144234,
+    184476617836266586,
+    0,
+    0,
+]));
+const TICK_HIGH: I256 = I256::from_raw(U256::from_limbs([
+    4998474450511881007,
+    15793544031827761793,
+    0,
+    0,
+]));
+
 /// Tick is the price range determined by tick index (not part of this struct,
 /// but is the key at which the Tick is stored in state hash maps). Tick struct
 /// stores liquidity and fee information.
@@ -100,11 +154,484 @@ where
     }
 }
 
+fn get_sqrt_ratio_at_tick(tick: i32) -> Result<U256, TickMathError> {
+    let abs_tick = if tick < 0 {
+        U256::from(tick.neg())
+    } else {
+        U256::from(tick)
+    };
+
+    if abs_tick > U256_MAX_TICK {
+        return Err(TickMathError::TickOutOfBounds);
+    }
+
+    let mut ratio = if abs_tick & (U256_1) != U256::ZERO {
+        U256::from_limbs([12262481743371124737, 18445821805675392311, 0, 0])
+    } else {
+        U256::from_limbs([0, 0, 1, 0])
+    };
+
+    if !(abs_tick & U256_2).is_zero() {
+        ratio = (ratio * U256::from_limbs([6459403834229662010, 18444899583751176498, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_4).is_zero() {
+        ratio =
+            (ratio * U256::from_limbs([17226890335427755468, 18443055278223354162, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_8).is_zero() {
+        ratio = (ratio * U256::from_limbs([2032852871939366096, 18439367220385604838, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_16).is_zero() {
+        ratio =
+            (ratio * U256::from_limbs([14545316742740207172, 18431993317065449817, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_32).is_zero() {
+        ratio = (ratio * U256::from_limbs([5129152022828963008, 18417254355718160513, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_64).is_zero() {
+        ratio = (ratio * U256::from_limbs([4894419605888772193, 18387811781193591352, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_128).is_zero() {
+        ratio = (ratio * U256::from_limbs([1280255884321894483, 18329067761203520168, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_256).is_zero() {
+        ratio =
+            (ratio * U256::from_limbs([15924666964335305636, 18212142134806087854, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_512).is_zero() {
+        ratio = (ratio * U256::from_limbs([8010504389359918676, 17980523815641551639, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_1024).is_zero() {
+        ratio =
+            (ratio * U256::from_limbs([10668036004952895731, 17526086738831147013, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_2048).is_zero() {
+        ratio = (ratio * U256::from_limbs([4878133418470705625, 16651378430235024244, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_4096).is_zero() {
+        ratio = (ratio * U256::from_limbs([9537173718739605541, 15030750278693429944, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_8192).is_zero() {
+        ratio = (ratio * U256::from_limbs([9972618978014552549, 12247334978882834399, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_16384).is_zero() {
+        ratio = (ratio * U256::from_limbs([10428997489610666743, 8131365268884726200, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_32768).is_zero() {
+        ratio = (ratio * U256::from_limbs([9305304367709015974, 3584323654723342297, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_65536).is_zero() {
+        ratio = (ratio * U256::from_limbs([14301143598189091785, 696457651847595233, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_131072).is_zero() {
+        ratio = (ratio * U256::from_limbs([7393154844743099908, 26294789957452057, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_262144).is_zero() {
+        ratio = (ratio * U256::from_limbs([2209338891292245656, 37481735321082, 0, 0])) >> 128
+    }
+    if !(abs_tick & U256_524288).is_zero() {
+        ratio = (ratio * U256::from_limbs([10518117631919034274, 76158723, 0, 0])) >> 128
+    }
+
+    if tick > 0 {
+        ratio = U256::MAX / ratio;
+    }
+
+    Ok((ratio >> 32)
+        + if (ratio.wrapping_rem(U256_1 << 32)).is_zero() {
+            U256::ZERO
+        } else {
+            U256_1
+        })
+}
+
+fn get_tick_at_sqrt_ratio(sqrt_price_x_96: U256) -> Result<i32, TickMathError> {
+    if !(sqrt_price_x_96 >= MIN_SQRT_RATIO && sqrt_price_x_96 < MAX_SQRT_RATIO) {
+        return Err(TickMathError::SqrtPriceOutOfBounds);
+    }
+
+    let ratio: U256 = sqrt_price_x_96.shl(32);
+    let mut r = ratio;
+    let mut msb = U256::ZERO;
+
+    let mut f = if r > U256::from_limbs([18446744073709551615, 18446744073709551615, 0, 0]) {
+        U256_1.shl(U256_7)
+    } else {
+        U256::ZERO
+    };
+    msb = msb.bitor(f);
+    r = r.shr(f);
+
+    f = if r > U256::from_limbs([18446744073709551615, 0, 0, 0]) {
+        U256_1.shl(U256_6)
+    } else {
+        U256::ZERO
+    };
+    msb = msb.bitor(f);
+    r = r.shr(f);
+
+    f = if r > U256::from_limbs([4294967295, 0, 0, 0]) {
+        U256_1.shl(U256_5)
+    } else {
+        U256::ZERO
+    };
+    msb = msb.bitor(f);
+    r = r.shr(f);
+
+    f = if r > U256::from_limbs([65535, 0, 0, 0]) {
+        U256_1.shl(U256_4)
+    } else {
+        U256::ZERO
+    };
+    msb = msb.bitor(f);
+    r = r.shr(f);
+
+    f = if r > U256_255 {
+        U256_1.shl(U256_3)
+    } else {
+        U256::ZERO
+    };
+    msb = msb.bitor(f);
+    r = r.shr(f);
+
+    f = if r > U256_15 {
+        U256_1.shl(U256_2)
+    } else {
+        U256::ZERO
+    };
+    msb = msb.bitor(f);
+    r = r.shr(f);
+
+    f = if r > U256_3 {
+        U256_1.shl(U256_1)
+    } else {
+        U256::ZERO
+    };
+    msb = msb.bitor(f);
+    r = r.shr(f);
+
+    f = if r > U256_1 { U256_1 } else { U256::ZERO };
+
+    msb = msb.bitor(f);
+
+    r = if msb >= U256_128 {
+        ratio.shr(msb - U256_127)
+    } else {
+        ratio.shl(U256_127 - msb)
+    };
+
+    let mut log_2: I256 = (I256::from_raw(msb) - I256::from_limbs([128, 0, 0, 0])).shl(64);
+
+    for i in (51..=63).rev() {
+        r = r.overflowing_mul(r).0.shr(U256_127);
+        let f: U256 = r.shr(128);
+        log_2 = log_2.bitor(I256::from_raw(f.shl(i)));
+
+        r = r.shr(f);
+    }
+
+    r = r.overflowing_mul(r).0.shr(U256_127);
+    let f: U256 = r.shr(128);
+    log_2 = log_2.bitor(I256::from_raw(f.shl(50)));
+
+    let log_sqrt10001 = log_2.wrapping_mul(SQRT_10001);
+
+    let tick_low = ((log_sqrt10001 - TICK_LOW) >> 128_u8).low_i32();
+
+    let tick_high = ((log_sqrt10001 + TICK_HIGH) >> 128_u8).low_i32();
+
+    let tick = if tick_low == tick_high {
+        tick_low
+    } else if get_sqrt_ratio_at_tick(tick_high)? <= sqrt_price_x_96 {
+        tick_high
+    } else {
+        tick_low
+    };
+
+    Ok(tick)
+}
+
+/// Convert U256 to U64F64
+///
+/// # Arguments
+/// * `value` - The U256 value in Q64.96 format
+///
+/// # Returns
+/// * `Result<U64F64, &'static str>` - Converted value or error if too large
+fn u256_to_u64f64(value: U256, source_fractional_bits: u32) -> Result<U64F64, TickMathError> {
+    if value > U256::from(u128::MAX) {
+        return Err(TickMathError::ConversionError);
+    }
+
+    let mut value: u128 = value
+        .try_into()
+        .map_err(|_| TickMathError::ConversionError)?;
+
+    // Adjust to 64 fractional bits (U64F64 format)
+    if source_fractional_bits < 64 {
+        // Shift left to add more fractional bits
+        value = value
+            .checked_shl(64 - source_fractional_bits)
+            .ok_or(TickMathError::Overflow)?;
+    } else if source_fractional_bits > 64 {
+        // Shift right to remove excess fractional bits
+        value = value >> (source_fractional_bits - 64);
+    }
+
+    Ok(U64F64::from_bits(value))
+}
+
+/// Convert U64F64 to U256
+///
+/// # Arguments
+/// * `value` - The U64F64 value to convert
+/// * `target_fractional_bits` - Number of fractional bits in the target U256 format
+///
+/// # Returns
+/// * `U256` - Converted value
+fn u64f64_to_u256(value: U64F64, target_fractional_bits: u32) -> U256 {
+    let mut bits = value.to_bits();
+
+    // Adjust to target fractional bits
+    if target_fractional_bits < 64 {
+        // Shift right to remove excess fractional bits
+        bits = bits >> (64 - target_fractional_bits);
+    } else if target_fractional_bits > 64 {
+        // Shift left to add more fractional bits
+        bits = bits << (target_fractional_bits - 64);
+    }
+
+    // Create U256
+    U256::from(bits)
+}
+
+/// Convert U256 in Q64.96 format (Uniswap's sqrt price format) to U64F64
+fn u256_q64_96_to_u64f64(value: U256) -> Result<U64F64, TickMathError> {
+    u256_to_u64f64(value, 96)
+}
+
+/// Convert U64F64 to U256 in Q64.96 format (Uniswap's sqrt price format)
+fn u64f64_to_u256_q64_96(value: U64F64) -> U256 {
+    u64f64_to_u256(value, 96)
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum TickMathError {
+    TickOutOfBounds,
+    SqrtPriceOutOfBounds,
+    ConversionError,
+    Overflow,
+}
+
+impl fmt::Display for TickMathError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+			Self::TickOutOfBounds => f.write_str("The given tick is outside of the minimum/maximum values."),
+			Self::SqrtPriceOutOfBounds =>f.write_str("Second inequality must be < because the price can never reach the price at the max tick"),
+			Self::ConversionError => f.write_str("Error converting from one number type into another"),
+			Self::Overflow => f.write_str("Number overflow in arithmetic operation")
+		}
+    }
+}
+
+impl Error for TickMathError {}
+
 #[cfg(test)]
 mod tests {
-    use super::*;
+    use std::{ops::Sub, str::FromStr};
+
     use safe_math::FixedExt;
 
+    use super::*;
+
+    #[test]
+    fn test_get_sqrt_ratio_at_tick_bounds() {
+        // the function should return an error if the tick is out of bounds
+        if let Err(err) = get_sqrt_ratio_at_tick(MIN_TICK - 1) {
+            assert!(matches!(err, TickMathError::TickOutOfBounds));
+        } else {
+            panic!("get_qrt_ratio_at_tick did not respect lower tick bound")
+        }
+        if let Err(err) = get_sqrt_ratio_at_tick(MAX_TICK + 1) {
+            assert!(matches!(err, TickMathError::TickOutOfBounds));
+        } else {
+            panic!("get_qrt_ratio_at_tick did not respect upper tick bound")
+        }
+    }
+
+    #[test]
+    fn test_get_sqrt_ratio_at_tick_values() {
+        // test individual values for correct results
+        assert_eq!(
+            get_sqrt_ratio_at_tick(MIN_TICK).unwrap(),
+            U256::from(4295128739u64),
+            "sqrt ratio at min incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(MIN_TICK + 1).unwrap(),
+            U256::from(4295343490u64),
+            "sqrt ratio at min + 1 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(MAX_TICK - 1).unwrap(),
+            U256::from_str("1461373636630004318706518188784493106690254656249").unwrap(),
+            "sqrt ratio at max - 1 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(MAX_TICK).unwrap(),
+            U256::from_str("1461446703485210103287273052203988822378723970342").unwrap(),
+            "sqrt ratio at max incorrect"
+        );
+        // checking hard coded values against solidity results
+        assert_eq!(
+            get_sqrt_ratio_at_tick(50).unwrap(),
+            U256::from(79426470787362580746886972461u128),
+            "sqrt ratio at 50 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(100).unwrap(),
+            U256::from(79625275426524748796330556128u128),
+            "sqrt ratio at 100 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(250).unwrap(),
+            U256::from(80224679980005306637834519095u128),
+            "sqrt ratio at 250 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(500).unwrap(),
+            U256::from(81233731461783161732293370115u128),
+            "sqrt ratio at 500 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(1000).unwrap(),
+            U256::from(83290069058676223003182343270u128),
+            "sqrt ratio at 1000 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(2500).unwrap(),
+            U256::from(89776708723587163891445672585u128),
+            "sqrt ratio at 2500 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(3000).unwrap(),
+            U256::from(92049301871182272007977902845u128),
+            "sqrt ratio at 3000 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(4000).unwrap(),
+            U256::from(96768528593268422080558758223u128),
+            "sqrt ratio at 4000 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(5000).unwrap(),
+            U256::from(101729702841318637793976746270u128),
+            "sqrt ratio at 5000 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(50000).unwrap(),
+            U256::from(965075977353221155028623082916u128),
+            "sqrt ratio at 50000 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(150000).unwrap(),
+            U256::from(143194173941309278083010301478497u128),
+            "sqrt ratio at 150000 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(250000).unwrap(),
+            U256::from(21246587762933397357449903968194344u128),
+            "sqrt ratio at 250000 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(500000).unwrap(),
+            U256::from_str("5697689776495288729098254600827762987878").unwrap(),
+            "sqrt ratio at 500000 incorrect"
+        );
+        assert_eq!(
+            get_sqrt_ratio_at_tick(738203).unwrap(),
+            U256::from_str("847134979253254120489401328389043031315994541").unwrap(),
+            "sqrt ratio at 738203 incorrect"
+        );
+    }
+
+    #[test]
+    fn test_get_tick_at_sqrt_ratio() {
+        //throws for too low
+        let result = get_tick_at_sqrt_ratio(MIN_SQRT_RATIO.sub(U256_1));
+        assert_eq!(
+            result.unwrap_err().to_string(),
+            "Second inequality must be < because the price can never reach the price at the max tick"
+        );
+
+        //throws for too high
+        let result = get_tick_at_sqrt_ratio(MAX_SQRT_RATIO);
+        assert_eq!(
+            result.unwrap_err().to_string(),
+            "Second inequality must be < because the price can never reach the price at the max tick"
+        );
+
+        //ratio of min tick
+        let result = get_tick_at_sqrt_ratio(MIN_SQRT_RATIO).unwrap();
+        assert_eq!(result, MIN_TICK);
+
+        //ratio of min tick + 1
+        let result = get_tick_at_sqrt_ratio(U256::from_str("4295343490").unwrap()).unwrap();
+        assert_eq!(result, MIN_TICK + 1);
+    }
+
+    #[test]
+    fn test_roundtrip() {
+        for tick_index in [
+            MIN_TICK + 1, // we can't use extremes because of rounding during roundtrip conversion
+            -1000,
+            -100,
+            -10,
+            -4,
+            -2,
+            0,
+            2,
+            4,
+            10,
+            100,
+            1000,
+            MAX_TICK - 1,
+        ]
+        .iter()
+        {
+            let sqrt_price = get_sqrt_ratio_at_tick(*tick_index).unwrap();
+            let round_trip_tick_index = get_tick_at_sqrt_ratio(sqrt_price).unwrap();
+            assert_eq!(round_trip_tick_index, *tick_index);
+        }
+    }
+
+    #[test]
+    fn test_u256_to_u64f64_q64_96() {
+        // Test tick 0 (sqrt price = 1.0 * 2^96)
+        let tick0_sqrt_price = U256::from(1u128 << 96);
+        let fixed_price = u256_q64_96_to_u64f64(tick0_sqrt_price).unwrap();
+
+        // Should be 1.0 in U64F64
+        assert_eq!(fixed_price, U64F64::from_num(1.0));
+
+        // Round trip back to U256 Q64.96
+        let back_to_u256 = u64f64_to_u256_q64_96(fixed_price);
+        assert_eq!(back_to_u256, tick0_sqrt_price);
+    }
+
+    #[test]
+    fn test_u256_with_other_formats() {
+        // Test with a value that has 32 fractional bits
+        let value_32frac = U256::from(123456789u128 << 32); // 123456789.0 in Q96.32
+        let fixed_value = u256_to_u64f64(value_32frac, 32).unwrap();
+
+        // Should be 123456789.0 in U64F64
+        assert_eq!(fixed_value, U64F64::from_num(123456789.0));
+
+        // Round trip back to U256 with 32 fractional bits
+        let back_to_u256 = u64f64_to_u256(fixed_value, 32);
+        assert_eq!(back_to_u256, value_32frac);
+    }
     #[test]
     fn test_tick_index_to_sqrt_price() {
         let tick_spacing = SqrtPrice::from_num(1.0001);
diff --git a/pallets/swap/src/tick_math.rs b/pallets/swap/src/tick_math.rs
deleted file mode 100644
index 3dfcb0d514..0000000000
--- a/pallets/swap/src/tick_math.rs
+++ /dev/null
@@ -1,539 +0,0 @@
-//! This module is adopted from github.com/0xKitsune/uniswap-v3-math
-use core::error::Error;
-use core::fmt;
-use core::ops::{BitOr, Neg, Shl, Shr};
-
-use alloy_primitives::{I256, U256};
-use substrate_fixed::types::U64F64;
-
-const U256_1: U256 = U256::from_limbs([1, 0, 0, 0]);
-const U256_2: U256 = U256::from_limbs([2, 0, 0, 0]);
-const U256_3: U256 = U256::from_limbs([3, 0, 0, 0]);
-const U256_4: U256 = U256::from_limbs([4, 0, 0, 0]);
-const U256_5: U256 = U256::from_limbs([5, 0, 0, 0]);
-const U256_6: U256 = U256::from_limbs([6, 0, 0, 0]);
-const U256_7: U256 = U256::from_limbs([7, 0, 0, 0]);
-const U256_8: U256 = U256::from_limbs([8, 0, 0, 0]);
-const U256_15: U256 = U256::from_limbs([15, 0, 0, 0]);
-const U256_16: U256 = U256::from_limbs([16, 0, 0, 0]);
-const U256_32: U256 = U256::from_limbs([32, 0, 0, 0]);
-const U256_64: U256 = U256::from_limbs([64, 0, 0, 0]);
-const U256_127: U256 = U256::from_limbs([127, 0, 0, 0]);
-const U256_128: U256 = U256::from_limbs([128, 0, 0, 0]);
-const U256_255: U256 = U256::from_limbs([255, 0, 0, 0]);
-
-const U256_256: U256 = U256::from_limbs([256, 0, 0, 0]);
-const U256_512: U256 = U256::from_limbs([512, 0, 0, 0]);
-const U256_1024: U256 = U256::from_limbs([1024, 0, 0, 0]);
-const U256_2048: U256 = U256::from_limbs([2048, 0, 0, 0]);
-const U256_4096: U256 = U256::from_limbs([4096, 0, 0, 0]);
-const U256_8192: U256 = U256::from_limbs([8192, 0, 0, 0]);
-const U256_16384: U256 = U256::from_limbs([16384, 0, 0, 0]);
-const U256_32768: U256 = U256::from_limbs([32768, 0, 0, 0]);
-const U256_65536: U256 = U256::from_limbs([65536, 0, 0, 0]);
-const U256_131072: U256 = U256::from_limbs([131072, 0, 0, 0]);
-const U256_262144: U256 = U256::from_limbs([262144, 0, 0, 0]);
-const U256_524288: U256 = U256::from_limbs([524288, 0, 0, 0]);
-
-const U256_MAX_TICK: U256 = U256::from_limbs([887272, 0, 0, 0]);
-
-pub(crate) const MIN_TICK: i32 = -887272;
-pub(crate) const MAX_TICK: i32 = -MIN_TICK;
-
-const MIN_SQRT_RATIO: U256 = U256::from_limbs([4295128739, 0, 0, 0]);
-const MAX_SQRT_RATIO: U256 =
-    U256::from_limbs([6743328256752651558, 17280870778742802505, 4294805859, 0]);
-
-const SQRT_10001: I256 = I256::from_raw(U256::from_limbs([11745905768312294533, 13863, 0, 0]));
-const TICK_LOW: I256 = I256::from_raw(U256::from_limbs([
-    6552757943157144234,
-    184476617836266586,
-    0,
-    0,
-]));
-const TICK_HIGH: I256 = I256::from_raw(U256::from_limbs([
-    4998474450511881007,
-    15793544031827761793,
-    0,
-    0,
-]));
-
-pub(crate) fn get_sqrt_ratio_at_tick(tick: i32) -> Result<U256, TickMathError> {
-    let abs_tick = if tick < 0 {
-        U256::from(tick.neg())
-    } else {
-        U256::from(tick)
-    };
-
-    if abs_tick > U256_MAX_TICK {
-        return Err(TickMathError::TickOutOfBounds);
-    }
-
-    let mut ratio = if abs_tick & (U256_1) != U256::ZERO {
-        U256::from_limbs([12262481743371124737, 18445821805675392311, 0, 0])
-    } else {
-        U256::from_limbs([0, 0, 1, 0])
-    };
-
-    if !(abs_tick & U256_2).is_zero() {
-        ratio = (ratio * U256::from_limbs([6459403834229662010, 18444899583751176498, 0, 0])) >> 128
-    }
-    if !(abs_tick & U256_4).is_zero() {
-        ratio =
-            (ratio * U256::from_limbs([17226890335427755468, 18443055278223354162, 0, 0])) >> 128
-    }
-    if !(abs_tick & U256_8).is_zero() {
-        ratio = (ratio * U256::from_limbs([2032852871939366096, 18439367220385604838, 0, 0])) >> 128
-    }
-    if !(abs_tick & U256_16).is_zero() {
-        ratio =
-            (ratio * U256::from_limbs([14545316742740207172, 18431993317065449817, 0, 0])) >> 128
-    }
-    if !(abs_tick & U256_32).is_zero() {
-        ratio = (ratio * U256::from_limbs([5129152022828963008, 18417254355718160513, 0, 0])) >> 128
-    }
-    if !(abs_tick & U256_64).is_zero() {
-        ratio = (ratio * U256::from_limbs([4894419605888772193, 18387811781193591352, 0, 0])) >> 128
-    }
-    if !(abs_tick & U256_128).is_zero() {
-        ratio = (ratio * U256::from_limbs([1280255884321894483, 18329067761203520168, 0, 0])) >> 128
-    }
-    if !(abs_tick & U256_256).is_zero() {
-        ratio =
-            (ratio * U256::from_limbs([15924666964335305636, 18212142134806087854, 0, 0])) >> 128
-    }
-    if !(abs_tick & U256_512).is_zero() {
-        ratio = (ratio * U256::from_limbs([8010504389359918676, 17980523815641551639, 0, 0])) >> 128
-    }
-    if !(abs_tick & U256_1024).is_zero() {
-        ratio =
-            (ratio * U256::from_limbs([10668036004952895731, 17526086738831147013, 0, 0])) >> 128
-    }
-    if !(abs_tick & U256_2048).is_zero() {
-        ratio = (ratio * U256::from_limbs([4878133418470705625, 16651378430235024244, 0, 0])) >> 128
-    }
-    if !(abs_tick & U256_4096).is_zero() {
-        ratio = (ratio * U256::from_limbs([9537173718739605541, 15030750278693429944, 0, 0])) >> 128
-    }
-    if !(abs_tick & U256_8192).is_zero() {
-        ratio = (ratio * U256::from_limbs([9972618978014552549, 12247334978882834399, 0, 0])) >> 128
-    }
-    if !(abs_tick & U256_16384).is_zero() {
-        ratio = (ratio * U256::from_limbs([10428997489610666743, 8131365268884726200, 0, 0])) >> 128
-    }
-    if !(abs_tick & U256_32768).is_zero() {
-        ratio = (ratio * U256::from_limbs([9305304367709015974, 3584323654723342297, 0, 0])) >> 128
-    }
-    if !(abs_tick & U256_65536).is_zero() {
-        ratio = (ratio * U256::from_limbs([14301143598189091785, 696457651847595233, 0, 0])) >> 128
-    }
-    if !(abs_tick & U256_131072).is_zero() {
-        ratio = (ratio * U256::from_limbs([7393154844743099908, 26294789957452057, 0, 0])) >> 128
-    }
-    if !(abs_tick & U256_262144).is_zero() {
-        ratio = (ratio * U256::from_limbs([2209338891292245656, 37481735321082, 0, 0])) >> 128
-    }
-    if !(abs_tick & U256_524288).is_zero() {
-        ratio = (ratio * U256::from_limbs([10518117631919034274, 76158723, 0, 0])) >> 128
-    }
-
-    if tick > 0 {
-        ratio = U256::MAX / ratio;
-    }
-
-    Ok((ratio >> 32)
-        + if (ratio.wrapping_rem(U256_1 << 32)).is_zero() {
-            U256::ZERO
-        } else {
-            U256_1
-        })
-}
-
-pub(crate) fn get_tick_at_sqrt_ratio(sqrt_price_x_96: U256) -> Result<i32, TickMathError> {
-    if !(sqrt_price_x_96 >= MIN_SQRT_RATIO && sqrt_price_x_96 < MAX_SQRT_RATIO) {
-        return Err(TickMathError::SqrtPriceOutOfBounds);
-    }
-
-    let ratio: U256 = sqrt_price_x_96.shl(32);
-    let mut r = ratio;
-    let mut msb = U256::ZERO;
-
-    let mut f = if r > U256::from_limbs([18446744073709551615, 18446744073709551615, 0, 0]) {
-        U256_1.shl(U256_7)
-    } else {
-        U256::ZERO
-    };
-    msb = msb.bitor(f);
-    r = r.shr(f);
-
-    f = if r > U256::from_limbs([18446744073709551615, 0, 0, 0]) {
-        U256_1.shl(U256_6)
-    } else {
-        U256::ZERO
-    };
-    msb = msb.bitor(f);
-    r = r.shr(f);
-
-    f = if r > U256::from_limbs([4294967295, 0, 0, 0]) {
-        U256_1.shl(U256_5)
-    } else {
-        U256::ZERO
-    };
-    msb = msb.bitor(f);
-    r = r.shr(f);
-
-    f = if r > U256::from_limbs([65535, 0, 0, 0]) {
-        U256_1.shl(U256_4)
-    } else {
-        U256::ZERO
-    };
-    msb = msb.bitor(f);
-    r = r.shr(f);
-
-    f = if r > U256_255 {
-        U256_1.shl(U256_3)
-    } else {
-        U256::ZERO
-    };
-    msb = msb.bitor(f);
-    r = r.shr(f);
-
-    f = if r > U256_15 {
-        U256_1.shl(U256_2)
-    } else {
-        U256::ZERO
-    };
-    msb = msb.bitor(f);
-    r = r.shr(f);
-
-    f = if r > U256_3 {
-        U256_1.shl(U256_1)
-    } else {
-        U256::ZERO
-    };
-    msb = msb.bitor(f);
-    r = r.shr(f);
-
-    f = if r > U256_1 { U256_1 } else { U256::ZERO };
-
-    msb = msb.bitor(f);
-
-    r = if msb >= U256_128 {
-        ratio.shr(msb - U256_127)
-    } else {
-        ratio.shl(U256_127 - msb)
-    };
-
-    let mut log_2: I256 = (I256::from_raw(msb) - I256::from_limbs([128, 0, 0, 0])).shl(64);
-
-    for i in (51..=63).rev() {
-        r = r.overflowing_mul(r).0.shr(U256_127);
-        let f: U256 = r.shr(128);
-        log_2 = log_2.bitor(I256::from_raw(f.shl(i)));
-
-        r = r.shr(f);
-    }
-
-    r = r.overflowing_mul(r).0.shr(U256_127);
-    let f: U256 = r.shr(128);
-    log_2 = log_2.bitor(I256::from_raw(f.shl(50)));
-
-    let log_sqrt10001 = log_2.wrapping_mul(SQRT_10001);
-
-    let tick_low = ((log_sqrt10001 - TICK_LOW) >> 128_u8).low_i32();
-
-    let tick_high = ((log_sqrt10001 + TICK_HIGH) >> 128_u8).low_i32();
-
-    let tick = if tick_low == tick_high {
-        tick_low
-    } else if get_sqrt_ratio_at_tick(tick_high)? <= sqrt_price_x_96 {
-        tick_high
-    } else {
-        tick_low
-    };
-
-    Ok(tick)
-}
-
-/// Convert U256 to U64F64
-///
-/// # Arguments
-/// * `value` - The U256 value in Q64.96 format
-///
-/// # Returns
-/// * `Result<U64F64, &'static str>` - Converted value or error if too large
-pub(crate) fn u256_to_u64f64(
-    value: U256,
-    source_fractional_bits: u32,
-) -> Result<U64F64, TickMathError> {
-    if value > U256::from(u128::MAX) {
-        return Err(TickMathError::ConversionError);
-    }
-
-    let mut value: u128 = value
-        .try_into()
-        .map_err(|_| TickMathError::ConversionError)?;
-
-    // Adjust to 64 fractional bits (U64F64 format)
-    if source_fractional_bits < 64 {
-        // Shift left to add more fractional bits
-        value = value
-            .checked_shl(64 - source_fractional_bits)
-            .ok_or(TickMathError::Overflow)?;
-    } else if source_fractional_bits > 64 {
-        // Shift right to remove excess fractional bits
-        value = value >> (source_fractional_bits - 64);
-    }
-
-    Ok(U64F64::from_bits(value))
-}
-
-/// Convert U64F64 to U256
-///
-/// # Arguments
-/// * `value` - The U64F64 value to convert
-/// * `target_fractional_bits` - Number of fractional bits in the target U256 format
-///
-/// # Returns
-/// * `U256` - Converted value
-pub(crate) fn u64f64_to_u256(value: U64F64, target_fractional_bits: u32) -> U256 {
-    let mut bits = value.to_bits();
-
-    // Adjust to target fractional bits
-    if target_fractional_bits < 64 {
-        // Shift right to remove excess fractional bits
-        bits = bits >> (64 - target_fractional_bits);
-    } else if target_fractional_bits > 64 {
-        // Shift left to add more fractional bits
-        bits = bits << (target_fractional_bits - 64);
-    }
-
-    // Create U256
-    U256::from(bits)
-}
-
-/// Convert U256 in Q64.96 format (Uniswap's sqrt price format) to U64F64
-pub(crate) fn u256_q64_96_to_u64f64(value: U256) -> Result<U64F64, TickMathError> {
-    u256_to_u64f64(value, 96)
-}
-
-/// Convert U64F64 to U256 in Q64.96 format (Uniswap's sqrt price format)
-pub(crate) fn u64f64_to_u256_q64_96(value: U64F64) -> U256 {
-    u64f64_to_u256(value, 96)
-}
-
-#[derive(Debug, PartialEq, Eq)]
-pub enum TickMathError {
-    TickOutOfBounds,
-    SqrtPriceOutOfBounds,
-    ConversionError,
-    Overflow,
-}
-
-impl fmt::Display for TickMathError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-			Self::TickOutOfBounds => f.write_str("The given tick is outside of the minimum/maximum values."),
-			Self::SqrtPriceOutOfBounds =>f.write_str("Second inequality must be < because the price can never reach the price at the max tick"),
-			Self::ConversionError => f.write_str("Error converting from one number type into another"),
-			Self::Overflow => f.write_str("Number overflow in arithmetic operation")
-		}
-    }
-}
-
-impl Error for TickMathError {}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use std::{ops::Sub, str::FromStr};
-
-    #[test]
-    fn test_get_sqrt_ratio_at_tick_bounds() {
-        // the function should return an error if the tick is out of bounds
-        if let Err(err) = get_sqrt_ratio_at_tick(MIN_TICK - 1) {
-            assert!(matches!(err, TickMathError::TickOutOfBounds));
-        } else {
-            panic!("get_qrt_ratio_at_tick did not respect lower tick bound")
-        }
-        if let Err(err) = get_sqrt_ratio_at_tick(MAX_TICK + 1) {
-            assert!(matches!(err, TickMathError::TickOutOfBounds));
-        } else {
-            panic!("get_qrt_ratio_at_tick did not respect upper tick bound")
-        }
-    }
-
-    #[test]
-    fn test_get_sqrt_ratio_at_tick_values() {
-        // test individual values for correct results
-        assert_eq!(
-            get_sqrt_ratio_at_tick(MIN_TICK).unwrap(),
-            U256::from(4295128739u64),
-            "sqrt ratio at min incorrect"
-        );
-        assert_eq!(
-            get_sqrt_ratio_at_tick(MIN_TICK + 1).unwrap(),
-            U256::from(4295343490u64),
-            "sqrt ratio at min + 1 incorrect"
-        );
-        assert_eq!(
-            get_sqrt_ratio_at_tick(MAX_TICK - 1).unwrap(),
-            U256::from_str("1461373636630004318706518188784493106690254656249").unwrap(),
-            "sqrt ratio at max - 1 incorrect"
-        );
-        assert_eq!(
-            get_sqrt_ratio_at_tick(MAX_TICK).unwrap(),
-            U256::from_str("1461446703485210103287273052203988822378723970342").unwrap(),
-            "sqrt ratio at max incorrect"
-        );
-        // checking hard coded values against solidity results
-        assert_eq!(
-            get_sqrt_ratio_at_tick(50).unwrap(),
-            U256::from(79426470787362580746886972461u128),
-            "sqrt ratio at 50 incorrect"
-        );
-        assert_eq!(
-            get_sqrt_ratio_at_tick(100).unwrap(),
-            U256::from(79625275426524748796330556128u128),
-            "sqrt ratio at 100 incorrect"
-        );
-        assert_eq!(
-            get_sqrt_ratio_at_tick(250).unwrap(),
-            U256::from(80224679980005306637834519095u128),
-            "sqrt ratio at 250 incorrect"
-        );
-        assert_eq!(
-            get_sqrt_ratio_at_tick(500).unwrap(),
-            U256::from(81233731461783161732293370115u128),
-            "sqrt ratio at 500 incorrect"
-        );
-        assert_eq!(
-            get_sqrt_ratio_at_tick(1000).unwrap(),
-            U256::from(83290069058676223003182343270u128),
-            "sqrt ratio at 1000 incorrect"
-        );
-        assert_eq!(
-            get_sqrt_ratio_at_tick(2500).unwrap(),
-            U256::from(89776708723587163891445672585u128),
-            "sqrt ratio at 2500 incorrect"
-        );
-        assert_eq!(
-            get_sqrt_ratio_at_tick(3000).unwrap(),
-            U256::from(92049301871182272007977902845u128),
-            "sqrt ratio at 3000 incorrect"
-        );
-        assert_eq!(
-            get_sqrt_ratio_at_tick(4000).unwrap(),
-            U256::from(96768528593268422080558758223u128),
-            "sqrt ratio at 4000 incorrect"
-        );
-        assert_eq!(
-            get_sqrt_ratio_at_tick(5000).unwrap(),
-            U256::from(101729702841318637793976746270u128),
-            "sqrt ratio at 5000 incorrect"
-        );
-        assert_eq!(
-            get_sqrt_ratio_at_tick(50000).unwrap(),
-            U256::from(965075977353221155028623082916u128),
-            "sqrt ratio at 50000 incorrect"
-        );
-        assert_eq!(
-            get_sqrt_ratio_at_tick(150000).unwrap(),
-            U256::from(143194173941309278083010301478497u128),
-            "sqrt ratio at 150000 incorrect"
-        );
-        assert_eq!(
-            get_sqrt_ratio_at_tick(250000).unwrap(),
-            U256::from(21246587762933397357449903968194344u128),
-            "sqrt ratio at 250000 incorrect"
-        );
-        assert_eq!(
-            get_sqrt_ratio_at_tick(500000).unwrap(),
-            U256::from_str("5697689776495288729098254600827762987878").unwrap(),
-            "sqrt ratio at 500000 incorrect"
-        );
-        assert_eq!(
-            get_sqrt_ratio_at_tick(738203).unwrap(),
-            U256::from_str("847134979253254120489401328389043031315994541").unwrap(),
-            "sqrt ratio at 738203 incorrect"
-        );
-    }
-
-    #[test]
-    fn test_get_tick_at_sqrt_ratio() {
-        //throws for too low
-        let result = get_tick_at_sqrt_ratio(MIN_SQRT_RATIO.sub(U256_1));
-        assert_eq!(
-            result.unwrap_err().to_string(),
-            "Second inequality must be < because the price can never reach the price at the max tick"
-        );
-
-        //throws for too high
-        let result = get_tick_at_sqrt_ratio(MAX_SQRT_RATIO);
-        assert_eq!(
-            result.unwrap_err().to_string(),
-            "Second inequality must be < because the price can never reach the price at the max tick"
-        );
-
-        //ratio of min tick
-        let result = get_tick_at_sqrt_ratio(MIN_SQRT_RATIO).unwrap();
-        assert_eq!(result, MIN_TICK);
-
-        //ratio of min tick + 1
-        let result = get_tick_at_sqrt_ratio(U256::from_str("4295343490").unwrap()).unwrap();
-        assert_eq!(result, MIN_TICK + 1);
-    }
-
-    #[test]
-    fn test_roundtrip() {
-        for tick_index in [
-            MIN_TICK + 1, // we can't use extremes because of rounding during roundtrip conversion
-            -1000,
-            -100,
-            -10,
-            -4,
-            -2,
-            0,
-            2,
-            4,
-            10,
-            100,
-            1000,
-            MAX_TICK - 1,
-        ]
-        .iter()
-        {
-            let sqrt_price = get_sqrt_ratio_at_tick(*tick_index).unwrap();
-            let round_trip_tick_index = get_tick_at_sqrt_ratio(sqrt_price).unwrap();
-            assert_eq!(round_trip_tick_index, *tick_index);
-        }
-    }
-
-    #[test]
-    fn test_u256_to_u64f64_q64_96() {
-        // Test tick 0 (sqrt price = 1.0 * 2^96)
-        let tick0_sqrt_price = U256::from(1u128 << 96);
-        let fixed_price = u256_q64_96_to_u64f64(tick0_sqrt_price).unwrap();
-
-        // Should be 1.0 in U64F64
-        assert_eq!(fixed_price, U64F64::from_num(1.0));
-
-        // Round trip back to U256 Q64.96
-        let back_to_u256 = u64f64_to_u256_q64_96(fixed_price);
-        assert_eq!(back_to_u256, tick0_sqrt_price);
-    }
-
-    #[test]
-    fn test_u256_with_other_formats() {
-        // Test with a value that has 32 fractional bits
-        let value_32frac = U256::from(123456789u128 << 32); // 123456789.0 in Q96.32
-        let fixed_value = u256_to_u64f64(value_32frac, 32).unwrap();
-
-        // Should be 123456789.0 in U64F64
-        assert_eq!(fixed_value, U64F64::from_num(123456789.0));
-
-        // Round trip back to U256 with 32 fractional bits
-        let back_to_u256 = u64f64_to_u256(fixed_value, 32);
-        assert_eq!(back_to_u256, value_32frac);
-    }
-}
diff --git a/primitives/swap/src/lib.rs b/primitives/swap/src/lib.rs
index 24f9bff96e..d88f16090d 100644
--- a/primitives/swap/src/lib.rs
+++ b/primitives/swap/src/lib.rs
@@ -1692,11 +1692,7 @@ mod tests {
         // Test case is (price_low, price_high, liquidity)
         [
             // Repeat the protocol liquidity at maximum range: Expect all the same values
-            (
-                min_price,
-                max_price,
-                2_000_000_000_u64,
-            ),
+            (min_price, max_price, 2_000_000_000_u64),
         ]
         .iter()
         .for_each(|(price_low, price_high, liquidity)| {
@@ -1724,5 +1720,4 @@ mod tests {
             );
         });
     }
-
 }

From 10901ccf07baae518df94a0ed66a18ddeb1c056e Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Thu, 20 Mar 2025 20:22:04 +0100
Subject: [PATCH 023/418] Remove swap library (in favor of the pallet)

---
 Cargo.lock                       |   12 -
 primitives/swap/Cargo.toml       |   25 -
 primitives/swap/src/error.rs     |   26 -
 primitives/swap/src/lib.rs       | 1723 ------------------------------
 primitives/swap/src/tick.rs      |  191 ----
 primitives/swap/src/tick_math.rs |  539 ----------
 6 files changed, 2516 deletions(-)
 delete mode 100644 primitives/swap/Cargo.toml
 delete mode 100644 primitives/swap/src/error.rs
 delete mode 100644 primitives/swap/src/lib.rs
 delete mode 100644 primitives/swap/src/tick.rs
 delete mode 100644 primitives/swap/src/tick_math.rs

diff --git a/Cargo.lock b/Cargo.lock
index 6457e7e9e7..d6eb890244 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -11568,18 +11568,6 @@ version = "2.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
 
-[[package]]
-name = "swap"
-version = "0.1.0"
-dependencies = [
- "alloy-primitives",
- "approx",
- "safe-math",
- "sp-arithmetic",
- "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409)",
- "substrate-fixed",
-]
-
 [[package]]
 name = "syn"
 version = "1.0.109"
diff --git a/primitives/swap/Cargo.toml b/primitives/swap/Cargo.toml
deleted file mode 100644
index d69c31fa0d..0000000000
--- a/primitives/swap/Cargo.toml
+++ /dev/null
@@ -1,25 +0,0 @@
-[package]
-name = "swap"
-version = "0.1.0"
-edition = { workspace = true }
-
-[dependencies]
-alloy-primitives = { workspace = true }
-approx = { workspace = true }
-safe-math = { workspace = true }
-sp-arithmetic = { workspace = true }
-sp-std = { workspace = true }
-substrate-fixed = { workspace = true }
-
-[lints]
-workspace = true
-
-[features]
-default = ["std"]
-std = [
-	"alloy-primitives/std",
-	"safe-math/std",
-	"sp-arithmetic/std",
-	"sp-std/std",
-	"substrate-fixed/std",
-]
diff --git a/primitives/swap/src/error.rs b/primitives/swap/src/error.rs
deleted file mode 100644
index 748f6a740a..0000000000
--- a/primitives/swap/src/error.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-#[derive(Debug, PartialEq, Eq)]
-pub enum SwapError {
-    /// The provided amount is insufficient for the swap.
-    InsufficientInputAmount,
-
-    /// The provided liquidity is insufficient for the operation.
-    InsufficientLiquidity,
-
-    /// The operation would exceed the price limit.
-    PriceLimitExceeded,
-
-    /// The caller does not have enough balance for the operation.
-    InsufficientBalance,
-
-    /// Attempted to remove liquidity that does not exist.
-    LiquidityNotFound,
-
-    /// The provided tick range is invalid.
-    InvalidTickRange,
-
-    /// Maximum user positions exceeded
-    MaxPositionsExceeded,
-
-    /// Too many swap steps
-    TooManySwapSteps,
-}
diff --git a/primitives/swap/src/lib.rs b/primitives/swap/src/lib.rs
deleted file mode 100644
index d88f16090d..0000000000
--- a/primitives/swap/src/lib.rs
+++ /dev/null
@@ -1,1723 +0,0 @@
-use core::marker::PhantomData;
-use std::ops::Neg;
-
-use safe_math::*;
-use sp_arithmetic::helpers_128bit::sqrt;
-use substrate_fixed::types::U64F64;
-
-use self::error::SwapError;
-use self::tick::{
-    MAX_TICK_INDEX, MIN_TICK_INDEX, Tick, find_closest_higher_active_tick_index,
-    find_closest_lower_active_tick_index, sqrt_price_to_tick_index, tick_index_to_sqrt_price,
-};
-
-mod error;
-mod tick;
-mod tick_math;
-
-type SqrtPrice = U64F64;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum OrderType {
-    Sell,
-    Buy,
-}
-
-pub enum SwapStepAction {
-    Crossing,
-    StopOn,
-    StopIn,
-}
-
-#[derive(Debug, PartialEq)]
-pub struct RemoveLiquidityResult {
-    tao: u64,
-    alpha: u64,
-    fee_tao: u64,
-    fee_alpha: u64,
-}
-
-#[derive(Debug, PartialEq)]
-pub struct SwapResult {
-    amount_paid_out: u64,
-    refund: u64,
-}
-
-#[derive(Debug, PartialEq)]
-struct SwapStepResult {
-    amount_to_take: u64,
-    delta_out: u64,
-}
-
-/// Position designates one liquidity position.
-///
-/// Alpha price is expressed in rao units per one 10^9 unit. For example,
-/// price 1_000_000 is equal to 0.001 TAO per Alpha.
-///
-/// tick_low - tick index for lower boundary of price
-/// tick_high - tick index for higher boundary of price
-/// liquidity - position liquidity
-/// fees_tao - fees accrued by the position in quote currency (TAO)
-/// fees_alpha - fees accrued by the position in base currency (Alpha)
-///
-#[cfg_attr(test, derive(Debug, PartialEq, Clone))]
-pub struct Position {
-    tick_low: i32,
-    tick_high: i32,
-    liquidity: u64,
-    fees_tao: u64,
-    fees_alpha: u64,
-}
-
-impl Position {
-    /// Converts position to token amounts
-    ///
-    /// returns tuple of (TAO, Alpha)
-    ///
-    /// Pseudocode:
-    ///     if self.sqrt_price_curr < sqrt_pa:
-    ///         tao = 0
-    ///         alpha = L * (1 / sqrt_pa - 1 / sqrt_pb)
-    ///     elif self.sqrt_price_curr > sqrt_pb:
-    ///         tao = L * (sqrt_pb - sqrt_pa)
-    ///         alpha = 0
-    ///     else:
-    ///         tao = L * (self.sqrt_price_curr - sqrt_pa)
-    ///         alpha = L * (1 / self.sqrt_price_curr - 1 / sqrt_pb)
-    ///  
-    pub fn to_token_amounts(&self, sqrt_price_curr: SqrtPrice) -> Result<(u64, u64), SwapError> {
-        let one: U64F64 = U64F64::saturating_from_num(1);
-
-        let sqrt_pa: SqrtPrice =
-            tick_index_to_sqrt_price(self.tick_low).map_err(|_| SwapError::InvalidTickRange)?;
-        let sqrt_pb: SqrtPrice =
-            tick_index_to_sqrt_price(self.tick_high).map_err(|_| SwapError::InvalidTickRange)?;
-        let liquidity_fixed: U64F64 = U64F64::saturating_from_num(self.liquidity);
-
-        Ok(if sqrt_price_curr < sqrt_pa {
-            (
-                0,
-                liquidity_fixed
-                    .saturating_mul(one.safe_div(sqrt_pa).saturating_sub(one.safe_div(sqrt_pb)))
-                    .saturating_to_num::<u64>(),
-            )
-        } else if sqrt_price_curr > sqrt_pb {
-            (
-                liquidity_fixed
-                    .saturating_mul(sqrt_pb.saturating_sub(sqrt_pa))
-                    .saturating_to_num::<u64>(),
-                0,
-            )
-        } else {
-            (
-                liquidity_fixed
-                    .saturating_mul(sqrt_price_curr.saturating_sub(sqrt_pa))
-                    .saturating_to_num::<u64>(),
-                liquidity_fixed
-                    .saturating_mul(
-                        one.safe_div(sqrt_price_curr)
-                            .saturating_sub(one.safe_div(sqrt_pb)),
-                    )
-                    .saturating_to_num::<u64>(),
-            )
-        })
-    }
-}
-
-/// This trait implementation depends on Runtime and it needs to be implemented
-/// in the pallet to be able to work with chain state and per subnet. All subnet
-/// swaps are independent and hence netuid is abstracted away from swap implementation.
-///
-pub trait SwapDataOperations<AccountIdType> {
-    /// Tells if v3 swap is initialized in the state. v2 only provides base and quote
-    /// reserves, while v3 also stores ticks and positions, which need to be initialized
-    /// at the first pool creation.
-    fn is_v3_initialized(&self) -> bool;
-    fn set_v3_initialized(&mut self);
-    /// Returns u16::MAX normalized fee rate. For example, 0.3% is approximately 196.
-    fn get_fee_rate(&self) -> u16;
-    /// Minimum liquidity that is safe for rounding and integer math.
-    fn get_minimum_liquidity(&self) -> u64;
-    fn get_tick_by_index(&self, tick_index: i32) -> Option<Tick>;
-    fn insert_tick_by_index(&mut self, tick_index: i32, tick: Tick);
-    fn remove_tick_by_index(&mut self, tick_index: i32);
-    /// Minimum sqrt price across all active ticks
-    fn get_min_sqrt_price(&self) -> SqrtPrice;
-    /// Maximum sqrt price across all active ticks
-    fn get_max_sqrt_price(&self) -> SqrtPrice;
-    fn get_tao_reserve(&self) -> u64;
-    fn set_tao_reserve(&mut self, tao: u64) -> u64;
-    fn get_alpha_reserve(&self) -> u64;
-    fn set_alpha_reserve(&mut self, alpha: u64) -> u64;
-    fn get_alpha_sqrt_price(&self) -> SqrtPrice;
-    fn set_alpha_sqrt_price(&mut self, sqrt_price: SqrtPrice);
-
-    // Getters/setters for global accrued fees in alpha and tao per subnet
-    fn get_fee_global_tao(&self) -> U64F64;
-    fn set_fee_global_tao(&mut self, fee: U64F64);
-    fn get_fee_global_alpha(&self) -> U64F64;
-    fn set_fee_global_alpha(&mut self, fee: U64F64);
-
-    /// Get current tick liquidity
-    fn get_current_liquidity(&self) -> u64;
-    /// Set current tick liquidity
-    fn set_current_liquidity(&mut self, liquidity: u64);
-
-    // User account operations
-    fn get_protocol_account_id(&self) -> AccountIdType;
-    fn get_max_positions(&self) -> u16;
-    fn withdraw_balances(
-        &mut self,
-        account_id: &AccountIdType,
-        tao: u64,
-        alpha: u64,
-    ) -> Result<(u64, u64), SwapError>;
-    fn deposit_balances(&mut self, account_id: &AccountIdType, tao: u64, alpha: u64);
-    fn get_position_count(&self, account_id: &AccountIdType) -> u16;
-    fn get_position(&self, account_id: &AccountIdType, position_id: u16) -> Option<Position>;
-    fn create_position(&mut self, account_id: &AccountIdType, positions: Position) -> u16;
-    fn update_position(
-        &mut self,
-        account_id: &AccountIdType,
-        position_id: u16,
-        positions: Position,
-    );
-    fn remove_position(&mut self, account_id: &AccountIdType, position_id: u16);
-}
-
-/// All main swapping logic abstracted from Runtime implementation is concentrated
-/// in this struct
-///
-#[derive(Debug)]
-pub struct Swap<AccountIdType, Ops>
-where
-    AccountIdType: Eq,
-    Ops: SwapDataOperations<AccountIdType>,
-{
-    pub(crate) state_ops: Ops,
-    phantom_key: PhantomData<AccountIdType>,
-}
-
-impl<AccountIdType, Ops> Swap<AccountIdType, Ops>
-where
-    AccountIdType: Eq,
-    Ops: SwapDataOperations<AccountIdType>,
-{
-    pub fn new(mut ops: Ops) -> Self {
-        if !ops.is_v3_initialized() {
-            // Initialize the v3:
-            // Reserves are re-purposed, nothing to set, just query values for liquidity and price calculation
-            let tao_reserve = ops.get_tao_reserve();
-            let alpha_reserve = ops.get_alpha_reserve();
-
-            // Set price
-            let price: U64F64 = U64F64::saturating_from_num(tao_reserve)
-                .safe_div(U64F64::saturating_from_num(alpha_reserve));
-
-            let epsilon: U64F64 = U64F64::saturating_from_num(0.000001);
-            ops.set_alpha_sqrt_price(
-                price
-                    .checked_sqrt(epsilon)
-                    .unwrap_or(U64F64::saturating_from_num(0)),
-            );
-
-            // Set initial (protocol owned) liquidity and positions
-            // Protocol liquidity makes one position from MIN_TICK_INDEX to MAX_TICK_INDEX
-            // We are using the sp_arithmetic sqrt here, which works for u128
-            let liquidity: u64 = sqrt(tao_reserve as u128 * alpha_reserve as u128) as u64;
-            let mut swap = Swap {
-                state_ops: ops,
-                phantom_key: PhantomData,
-            };
-            let protocol_account_id = swap.state_ops.get_protocol_account_id();
-            let _ = swap.add_liquidity(
-                &protocol_account_id,
-                MIN_TICK_INDEX,
-                MAX_TICK_INDEX,
-                liquidity,
-                true,
-            );
-
-            swap
-        } else {
-            Swap {
-                state_ops: ops,
-                phantom_key: PhantomData,
-            }
-        }
-    }
-
-    /// Auxiliary method to calculate Alpha amount to match given TAO
-    /// amount at the current price for liquidity.
-    ///
-    /// Returns (Alpha, Liquidity) tuple
-    ///
-    pub fn get_tao_based_liquidity(&self, _tao: u64) -> (u64, u64) {
-        // let current_price = self.state_ops.get_alpha_sqrt_price();
-        todo!()
-    }
-
-    /// Auxiliary method to calculate TAO amount to match given Alpha
-    /// amount at the current price for liquidity.
-    ///
-    /// Returns (TAO, Liquidity) tuple
-    ///
-    pub fn get_alpha_based_liquidity(&self, _alpha: u64) -> (u64, u64) {
-        // let current_price = self.state_ops.get_alpha_sqrt_price();
-
-        todo!()
-    }
-
-    /// Add liquidity at tick index. Creates new tick if it doesn't exist
-    ///
-    fn add_liquidity_at_index(&mut self, tick_index: i32, liquidity: u64, upper: bool) {
-        // Calculate net liquidity addition
-        let net_addition = if upper {
-            (liquidity as i128).neg()
-        } else {
-            liquidity as i128
-        };
-
-        // Find tick by index
-        let new_tick = if let Some(mut tick) = self.state_ops.get_tick_by_index(tick_index) {
-            tick.liquidity_net = tick.liquidity_net.saturating_add(net_addition);
-            tick.liquidity_gross = tick.liquidity_gross.saturating_add(liquidity);
-            tick
-        } else {
-            // Create a new tick
-            Tick {
-                liquidity_net: net_addition,
-                liquidity_gross: liquidity,
-                fees_out_tao: U64F64::saturating_from_num(0),
-                fees_out_alpha: U64F64::saturating_from_num(0),
-            }
-        };
-
-        // TODO: Review why Python code uses this code to find index for the new ticks:
-        // self.get_tick_index(user_position[0]) + 1
-        self.state_ops.insert_tick_by_index(tick_index, new_tick);
-    }
-
-    /// Remove liquidity at tick index.
-    ///
-    fn remove_liquidity_at_index(&mut self, tick_index: i32, liquidity: u64, upper: bool) {
-        // Calculate net liquidity addition
-        let net_reduction = if upper {
-            (liquidity as i128).neg()
-        } else {
-            liquidity as i128
-        };
-
-        // Find tick by index
-        if let Some(mut tick) = self.state_ops.get_tick_by_index(tick_index) {
-            tick.liquidity_net = tick.liquidity_net.saturating_sub(net_reduction);
-            tick.liquidity_gross = tick.liquidity_gross.saturating_sub(liquidity);
-
-            // If any liquidity is left at the tick, update it, otherwise remove
-            if tick.liquidity_gross == 0 {
-                self.state_ops.remove_tick_by_index(tick_index);
-            } else {
-                self.state_ops.insert_tick_by_index(tick_index, tick);
-            }
-        };
-    }
-
-    /// Adds liquidity to the specified price range.
-    ///
-    /// This function allows an account to provide liquidity to a given range of price ticks.
-    /// The amount of liquidity to be added can be determined using the functions
-    /// [`get_tao_based_liquidity`] and [`get_alpha_based_liquidity`], which compute the
-    /// required liquidity based on TAO and Alpha balances for the current price tick.
-    ///
-    /// ### Behavior:
-    /// - If the `protocol` flag is **not set** (`false`), the function will attempt to
-    ///   **withdraw balances** from the account using `state_ops.withdraw_balances()`.
-    /// - If the `protocol` flag is **set** (`true`), the liquidity is added without modifying balances.
-    ///
-    /// ### Parameters:
-    /// - `account_id`: A reference to the account that is providing liquidity.
-    /// - `tick_low`: The lower bound of the price tick range.
-    /// - `tick_high`: The upper bound of the price tick range.
-    /// - `liquidity`: The amount of liquidity to be added.
-    /// - `protocol`: A boolean flag indicating whether the operation is protocol-managed:
-    ///   - `true` -> Do not use this value outside of this implementation. Liquidity is added **without**
-    ///               withdrawing balances.
-    ///   - `false` -> Use this value for all user transactions. Liquidity is added
-    ///               **after withdrawing balances**.
-    ///
-    /// ### Returns:
-    /// - `Ok(u64)`: The final liquidity amount added.
-    /// - `Err(SwapError)`: If the operation fails due to insufficient balance, invalid tick range,
-    ///   or other swap-related errors.
-    ///
-    /// ### Errors:
-    /// - [`SwapError::InsufficientBalance`] if the account does not have enough balance.
-    /// - [`SwapError::InvalidTickRange`] if `tick_low` is greater than or equal to `tick_high`.
-    /// - Other [`SwapError`] variants as applicable.
-    ///
-    pub fn add_liquidity(
-        &mut self,
-        account_id: &AccountIdType,
-        tick_low: i32,
-        tick_high: i32,
-        liquidity: u64,
-        protocol: bool,
-    ) -> Result<(), SwapError> {
-        // Check if we can add a position
-        let position_count = self.state_ops.get_position_count(account_id);
-        let max_positions = self.state_ops.get_max_positions();
-        if position_count >= max_positions {
-            return Err(SwapError::MaxPositionsExceeded);
-        }
-
-        // Add liquidity at tick
-        self.add_liquidity_at_index(tick_low, liquidity, false);
-        self.add_liquidity_at_index(tick_high, liquidity, true);
-
-        // Update current tick liquidity
-        let current_tick_index = self.get_current_tick_index();
-        if (tick_low <= current_tick_index) && (current_tick_index <= tick_high) {
-            let new_current_liquidity = self
-                .state_ops
-                .get_current_liquidity()
-                .saturating_add(liquidity);
-            self.state_ops.set_current_liquidity(new_current_liquidity);
-        }
-
-        // New position
-        let position = Position {
-            tick_low,
-            tick_high,
-            liquidity,
-            fees_tao: 0_u64,
-            fees_alpha: 0_u64,
-        };
-
-        // If this is a user transaction, withdraw balances and update reserves
-        if !protocol {
-            let current_price: SqrtPrice = self.state_ops.get_alpha_sqrt_price();
-            let (tao, alpha) = position.to_token_amounts(current_price)?;
-            self.state_ops.withdraw_balances(account_id, tao, alpha)?;
-
-            // Update reserves
-            let new_tao_reserve = self.state_ops.get_tao_reserve().saturating_add(tao);
-            self.state_ops.set_tao_reserve(new_tao_reserve);
-            let new_alpha_reserve = self.state_ops.get_alpha_reserve().saturating_add(alpha);
-            self.state_ops.set_alpha_reserve(new_alpha_reserve);
-        }
-
-        // Create a new user position
-        self.state_ops.create_position(account_id, position);
-
-        Ok(())
-    }
-
-    /// Remove liquidity and credit balances back to account_id
-    ///
-    /// Account ID and Position ID identify position in the storage map
-    ///
-    pub fn remove_liquidity(
-        &mut self,
-        account_id: &AccountIdType,
-        position_id: u16,
-    ) -> Result<RemoveLiquidityResult, SwapError> {
-        // Check if position exists
-        if let Some(mut pos) = self.state_ops.get_position(account_id, position_id) {
-            // Get current price
-            let current_tick_index = self.get_current_tick_index();
-
-            // Collect fees and get tao and alpha amounts
-            let (fee_tao, fee_alpha) = self.collect_fees(&mut pos);
-            let current_price: SqrtPrice = self.state_ops.get_alpha_sqrt_price();
-            let (tao, alpha) = pos.to_token_amounts(current_price)?;
-
-            // Update liquidity at position ticks
-            self.remove_liquidity_at_index(pos.tick_low, pos.liquidity, false);
-            self.remove_liquidity_at_index(pos.tick_high, pos.liquidity, true);
-
-            // Update current tick liquidity
-            if (pos.tick_low <= current_tick_index) && (current_tick_index <= pos.tick_high) {
-                let new_current_liquidity = self
-                    .state_ops
-                    .get_current_liquidity()
-                    .saturating_sub(pos.liquidity);
-                self.state_ops.set_current_liquidity(new_current_liquidity);
-            }
-
-            // Remove user position
-            self.state_ops.remove_position(account_id, position_id);
-
-            // Deposit balances
-            self.state_ops.deposit_balances(account_id, tao, alpha);
-
-            // Update reserves
-            let new_tao_reserve = self.state_ops.get_tao_reserve().saturating_sub(tao);
-            self.state_ops.set_tao_reserve(new_tao_reserve);
-            let new_alpha_reserve = self.state_ops.get_alpha_reserve().saturating_sub(alpha);
-            self.state_ops.set_alpha_reserve(new_alpha_reserve);
-
-            // TODO: Clear with R&D
-            // Update current price (why?)
-            // self.state_ops.set_alpha_sqrt_price(sqrt_price);
-
-            // Return Ok result
-            Ok(RemoveLiquidityResult {
-                tao,
-                alpha,
-                fee_tao,
-                fee_alpha,
-            })
-        } else {
-            // Position doesn't exist
-            Err(SwapError::LiquidityNotFound)
-        }
-    }
-
-    /// Perform a swap
-    ///
-    /// Returns a tuple (amount, refund), where amount is the resulting paid out amount
-    ///
-    pub fn swap(
-        &mut self,
-        order_type: &OrderType,
-        amount: u64,
-        sqrt_price_limit: SqrtPrice,
-    ) -> Result<SwapResult, SwapError> {
-        let one = U64F64::saturating_from_num(1);
-
-        // Here we store the remaining amount that needs to be exchanged
-        // If order_type is Buy, then it expresses Tao amount, if it is Sell,
-        // then amount_remaining is Alpha.
-        let mut amount_remaining = amount;
-        let mut amount_paid_out: u64 = 0;
-        let mut refund: u64 = 0;
-
-        // A bit of fool proofing
-        let mut iteration_counter: u16 = 0;
-        let iter_limit: u16 = 1000;
-
-        // Swap one tick at a time until we reach one of the following conditions:
-        //   - Swap all provided amount
-        //   - Reach limit price
-        //   - Use up all liquidity (up to safe minimum)
-        while amount_remaining > 0 {
-            let sqrt_price_edge = self.get_sqrt_price_edge(order_type);
-            let possible_delta_in =
-                amount_remaining.saturating_sub(self.get_fee_amount(amount_remaining));
-            let sqrt_price_target = self.get_sqrt_price_target(order_type, possible_delta_in);
-            let target_quantity = self.get_target_quantity(order_type, possible_delta_in);
-            let edge_quantity = U64F64::saturating_from_num(1).safe_div(sqrt_price_edge.into());
-            let lim_quantity = one
-                .safe_div(self.state_ops.get_min_sqrt_price())
-                .saturating_add(one.safe_div(sqrt_price_limit.into()));
-
-            let action: SwapStepAction;
-            let delta_in;
-            let final_price;
-            let mut stop_and_refund = false;
-
-            if target_quantity < edge_quantity {
-                if target_quantity <= lim_quantity {
-                    // stop_in at price target
-                    action = SwapStepAction::StopIn;
-                    delta_in = possible_delta_in;
-                    final_price = sqrt_price_target;
-                } else {
-                    // stop_in at price limit
-                    action = SwapStepAction::StopIn;
-                    delta_in = self.get_delta_in(order_type, sqrt_price_limit);
-                    final_price = sqrt_price_limit;
-                    stop_and_refund = true;
-                }
-            } else if target_quantity > edge_quantity {
-                if edge_quantity < lim_quantity {
-                    // do crossing at price edge
-                    action = SwapStepAction::Crossing;
-                    delta_in = self.get_delta_in(order_type, sqrt_price_edge);
-                    final_price = sqrt_price_edge;
-                } else if edge_quantity > lim_quantity {
-                    // stop_in at price limit
-                    action = SwapStepAction::StopIn;
-                    delta_in = self.get_delta_in(order_type, sqrt_price_limit);
-                    final_price = sqrt_price_limit;
-                    stop_and_refund = true;
-                } else {
-                    // stop_on at price limit
-                    action = SwapStepAction::StopOn;
-                    delta_in = self.get_delta_in(order_type, sqrt_price_edge);
-                    final_price = sqrt_price_edge;
-                    stop_and_refund = true;
-                }
-            } else {
-                // targetQuantity = edgeQuantity
-                if target_quantity <= lim_quantity {
-                    // stop_on at price edge
-                    delta_in = self.get_delta_in(order_type, sqrt_price_edge);
-                    final_price = sqrt_price_edge;
-                    action = if delta_in > 0 {
-                        SwapStepAction::StopOn
-                    } else {
-                        SwapStepAction::Crossing
-                    };
-                } else {
-                    // targetQuantity > limQuantity
-                    // stop_in at price lim
-                    action = SwapStepAction::StopIn;
-                    delta_in = self.get_delta_in(order_type, sqrt_price_limit);
-                    final_price = sqrt_price_limit;
-                    stop_and_refund = true;
-                }
-            }
-
-            let swap_result = self.swap_step(order_type, delta_in, final_price, action)?;
-            amount_remaining = amount_remaining.saturating_sub(swap_result.amount_to_take);
-            amount_paid_out = amount_paid_out.saturating_add(swap_result.delta_out);
-
-            if stop_and_refund {
-                refund = amount_remaining;
-                amount_remaining = 0;
-            }
-
-            iteration_counter = iteration_counter.saturating_add(1);
-            if iteration_counter > iter_limit {
-                return Err(SwapError::TooManySwapSteps);
-            }
-        }
-
-        Ok(SwapResult {
-            amount_paid_out,
-            refund,
-        })
-    }
-
-    fn get_current_tick_index(&mut self) -> i32 {
-        let current_price = self.state_ops.get_alpha_sqrt_price();
-        let maybe_current_tick_index = sqrt_price_to_tick_index(current_price);
-        if let Ok(index) = maybe_current_tick_index {
-            index
-        } else {
-            // Current price is out of allow the min-max range, and it should be corrected to
-            // maintain the range.
-            let max_price = tick_index_to_sqrt_price(MAX_TICK_INDEX)
-                .unwrap_or(SqrtPrice::saturating_from_num(1000));
-            let min_price = tick_index_to_sqrt_price(MIN_TICK_INDEX)
-                .unwrap_or(SqrtPrice::saturating_from_num(0.000001));
-            if current_price > max_price {
-                self.state_ops.set_alpha_sqrt_price(max_price);
-                MAX_TICK_INDEX
-            } else {
-                self.state_ops.set_alpha_sqrt_price(min_price);
-                MIN_TICK_INDEX
-            }
-        }
-    }
-
-    /// Process a single step of a swap
-    ///
-    fn swap_step(
-        &mut self,
-        order_type: &OrderType,
-        delta_in: u64,
-        sqrt_price_final: SqrtPrice,
-        action: SwapStepAction,
-    ) -> Result<SwapStepResult, SwapError> {
-        // amount_swapped = delta_in / (1 - self.fee_size)
-        let fee_rate = U64F64::saturating_from_num(self.state_ops.get_fee_rate());
-        let u16_max = U64F64::saturating_from_num(u16::MAX);
-        let delta_fixed = U64F64::saturating_from_num(delta_in);
-        let amount_swapped =
-            delta_fixed.saturating_mul(u16_max.safe_div(u16_max.saturating_sub(fee_rate)));
-
-        // Hold the fees
-        let fee = self.get_fee_amount(amount_swapped.saturating_to_num::<u64>());
-        self.add_fees(order_type, fee);
-        let delta_out = self.convert_deltas(order_type, delta_in);
-
-        self.update_reserves(order_type, delta_in, delta_out);
-
-        // Get current tick
-        let current_tick_index = self.get_current_tick_index();
-
-        match action {
-            SwapStepAction::Crossing => {
-                let maybe_tick = match order_type {
-                    OrderType::Sell => self.find_closest_lower_active_tick(current_tick_index),
-                    OrderType::Buy => self.find_closest_higher_active_tick(current_tick_index),
-                };
-                if let Some(mut tick) = maybe_tick {
-                    tick.fees_out_tao = self
-                        .state_ops
-                        .get_fee_global_tao()
-                        .saturating_sub(tick.fees_out_tao);
-                    tick.fees_out_alpha = self
-                        .state_ops
-                        .get_fee_global_alpha()
-                        .saturating_sub(tick.fees_out_alpha);
-                    self.update_liquidity_at_crossing(order_type)?;
-                    self.state_ops
-                        .insert_tick_by_index(current_tick_index, tick);
-                } else {
-                    return Err(SwapError::InsufficientLiquidity);
-                }
-            }
-            SwapStepAction::StopOn => match order_type {
-                OrderType::Sell => {}
-                OrderType::Buy => {
-                    self.update_liquidity_at_crossing(order_type)?;
-                    let maybe_tick = self.find_closest_higher_active_tick(current_tick_index);
-
-                    if let Some(mut tick) = maybe_tick {
-                        tick.fees_out_tao = self
-                            .state_ops
-                            .get_fee_global_tao()
-                            .saturating_sub(tick.fees_out_tao);
-                        tick.fees_out_alpha = self
-                            .state_ops
-                            .get_fee_global_alpha()
-                            .saturating_sub(tick.fees_out_alpha);
-                        self.state_ops
-                            .insert_tick_by_index(current_tick_index, tick);
-                    } else {
-                        return Err(SwapError::InsufficientLiquidity);
-                    }
-                }
-            },
-            SwapStepAction::StopIn => {}
-        }
-
-        // Update current price, which effectively updates current tick too
-        self.state_ops.set_alpha_sqrt_price(sqrt_price_final);
-
-        Ok(SwapStepResult {
-            amount_to_take: amount_swapped.saturating_to_num::<u64>(),
-            delta_out,
-        })
-    }
-
-    /// Get the square root price at the current tick edge for the given direction (order type)
-    /// If order type is Buy, then price edge is the high tick bound price, otherwise it is
-    /// the low tick bound price.
-    ///
-    /// If anything is wrong with tick math and it returns Err, we just abort the deal, i.e.
-    /// return the edge that is impossible to execute
-    ///
-    fn get_sqrt_price_edge(&self, order_type: &OrderType) -> SqrtPrice {
-        let fallback_price_edge_value = (match order_type {
-            OrderType::Buy => tick_index_to_sqrt_price(MIN_TICK_INDEX),
-            OrderType::Sell => tick_index_to_sqrt_price(MAX_TICK_INDEX),
-        })
-        .unwrap_or(SqrtPrice::saturating_from_num(0));
-
-        let current_price = self.state_ops.get_alpha_sqrt_price();
-        let maybe_current_tick_index = sqrt_price_to_tick_index(current_price);
-
-        if let Ok(current_tick_index) = maybe_current_tick_index {
-            tick_index_to_sqrt_price(match order_type {
-                OrderType::Buy => current_tick_index.saturating_add(1),
-                OrderType::Sell => current_tick_index,
-            })
-            .unwrap_or(fallback_price_edge_value)
-        } else {
-            fallback_price_edge_value
-        }
-    }
-
-    /// Calculate fee amount
-    ///
-    /// Fee is provided by state ops as u16-normalized value.
-    ///
-    fn get_fee_amount(&self, amount: u64) -> u64 {
-        let fee_rate = U64F64::saturating_from_num(self.state_ops.get_fee_rate())
-            .safe_div(U64F64::saturating_from_num(u16::MAX));
-        U64F64::saturating_from_num(amount)
-            .saturating_mul(fee_rate)
-            .saturating_to_num::<u64>()
-    }
-
-    /// Here we subtract minimum safe liquidity from current liquidity to stay in the
-    /// safe range
-    ///
-    fn get_safe_current_liquidity(&self) -> U64F64 {
-        U64F64::saturating_from_num(
-            self.state_ops
-                .get_current_liquidity()
-                .saturating_sub(self.state_ops.get_minimum_liquidity()),
-        )
-    }
-
-    /// Get the target square root price based on the input amount
-    ///
-    fn get_sqrt_price_target(&self, order_type: &OrderType, delta_in: u64) -> SqrtPrice {
-        let liquidity_curr = self.get_safe_current_liquidity();
-        let sqrt_price_curr = self.state_ops.get_alpha_sqrt_price().into();
-        let delta_fixed = U64F64::saturating_from_num(delta_in);
-        let one = U64F64::saturating_from_num(1);
-
-        if liquidity_curr > 0 {
-            match order_type {
-                OrderType::Buy => one.safe_div(
-                    delta_fixed
-                        .safe_div(liquidity_curr)
-                        .saturating_add(one.safe_div(sqrt_price_curr)),
-                ),
-                OrderType::Sell => delta_fixed
-                    .safe_div(liquidity_curr)
-                    .saturating_add(sqrt_price_curr),
-            }
-        } else {
-            // No liquidity means price should remain current
-            sqrt_price_curr
-        }
-    }
-
-    /// Get the target quantity, which is
-    ///     `1 / (target square root price)` in case of sell order
-    ///     `target square root price` in case of buy order
-    ///
-    /// ...based on the input amount, current liquidity, and current alpha price
-    ///
-    fn get_target_quantity(&self, order_type: &OrderType, delta_in: u64) -> SqrtPrice {
-        let liquidity_curr = self.get_safe_current_liquidity();
-        let sqrt_price_curr = self.state_ops.get_alpha_sqrt_price().into();
-        let delta_fixed = U64F64::saturating_from_num(delta_in);
-        let one = U64F64::saturating_from_num(1);
-
-        if liquidity_curr > 0 {
-            match order_type {
-                OrderType::Buy => delta_fixed
-                    .safe_div(liquidity_curr)
-                    .saturating_add(sqrt_price_curr)
-                    .into(),
-                OrderType::Sell => delta_fixed
-                    .safe_div(liquidity_curr)
-                    .saturating_add(one.safe_div(sqrt_price_curr))
-                    .into(),
-            }
-        } else {
-            // No liquidity means zero
-            SqrtPrice::saturating_from_num(0)
-        }
-    }
-
-    /// Get the input amount needed to reach the target price
-    ///
-    fn get_delta_in(&self, order_type: &OrderType, sqrt_price_target: SqrtPrice) -> u64 {
-        let liquidity_curr = self.get_safe_current_liquidity();
-        let one = U64F64::saturating_from_num(1);
-        let sqrt_price_curr = self.state_ops.get_alpha_sqrt_price().into();
-
-        (match order_type {
-            OrderType::Sell => liquidity_curr.saturating_mul(
-                one.safe_div(sqrt_price_target.into())
-                    .saturating_sub(one.safe_div(sqrt_price_curr)),
-            ),
-            OrderType::Buy => {
-                liquidity_curr.saturating_mul(sqrt_price_target.saturating_sub(sqrt_price_curr))
-            }
-        })
-        .saturating_to_num::<u64>()
-    }
-
-    /// Add fees to the global fee counters
-    fn add_fees(&mut self, order_type: &OrderType, fee: u64) {
-        let liquidity_curr = self.get_safe_current_liquidity();
-        if liquidity_curr > 0 {
-            let fee_global_tao: U64F64 = self.state_ops.get_fee_global_tao();
-            let fee_global_alpha: U64F64 = self.state_ops.get_fee_global_alpha();
-            let fee_fixed: U64F64 = U64F64::saturating_from_num(fee);
-
-            match order_type {
-                OrderType::Sell => {
-                    self.state_ops.set_fee_global_tao(
-                        fee_global_tao.saturating_add(fee_fixed.safe_div(liquidity_curr)),
-                    );
-                }
-                OrderType::Buy => {
-                    self.state_ops.set_fee_global_alpha(
-                        fee_global_alpha.saturating_add(fee_fixed.safe_div(liquidity_curr)),
-                    );
-                }
-            }
-        }
-    }
-
-    /// Convert input amount (delta_in) to output amount (delta_out)
-    ///
-    /// This is the core method of uniswap V3 that tells how much
-    /// output token is given for an amount of input token within one
-    /// price tick.
-    ///
-    fn convert_deltas(&self, order_type: &OrderType, delta_in: u64) -> u64 {
-        let liquidity_curr = SqrtPrice::saturating_from_num(self.state_ops.get_current_liquidity());
-        let sqrt_price_curr = self.state_ops.get_alpha_sqrt_price();
-        let delta_fixed = SqrtPrice::saturating_from_num(delta_in);
-
-        // TODO: Implement in safe and non-overflowing math
-        // Intentionally using unsafe math here to trigger CI
-
-        // // Prevent overflows:
-        // // If liquidity or delta are too large, reduce their precision and
-        // // save their factor for final correction. Price can take full U64F64
-        // // range, and it will not overflow u128 divisions or multiplications.
-        // let mut liquidity_factor: u64 = 1;
-        // if liquidity_curr > u32::MAX as u64 {
-        //     liquidity_factor = u32::MAX as u64;
-        //     liquidity_curr = liquidity_curr.safe_div(liquidity_factor);
-        // }
-        // let mut delta = delta_in as u64;
-        // let mut delta_factor: u64 = 1;
-        // if delta > u32::MAX as u64 {
-        //     delta_factor = u32::MAX as u64;
-        //     delta = delta.safe_div(delta_factor);
-        // }
-
-        // // This product does not overflow because we limit both
-        // // multipliers by u32::MAX (despite the u64 type)
-        // let delta_liquidity = delta.saturating_mul(liquidity);
-
-        // // This is product of delta_in * liquidity_curr * sqrt_price_curr
-        // let delta_liquidity_price: u128 =
-        //     Self::mul_u64_u64f64(delta_liquidity, sqrt_price_curr.into());
-
-        if delta_in > 0 {
-            (match order_type {
-                OrderType::Sell => {
-                    liquidity_curr * sqrt_price_curr * delta_fixed
-                        / (liquidity_curr / sqrt_price_curr + delta_fixed)
-                }
-                OrderType::Buy => {
-                    liquidity_curr / sqrt_price_curr * delta_fixed
-                        / (liquidity_curr * sqrt_price_curr + delta_fixed)
-                }
-            })
-            .to_num::<u64>()
-        } else {
-            0
-        }
-    }
-
-    /// Multiplies a `u64` by a `U64F64` and returns a `u128` result without overflow.
-    // pub fn mul_u64_u64f64(a: u64, b: U64F64) -> u128 {
-    //     // Multiply a by integer part of b in integer math.
-    //     // Result doesn't overflow u128 because both multipliers are 64 bit
-    //     let int_b: u64 = b.saturating_to_num::<u64>();
-    //     let high = (a as u128).saturating_mul(int_b as u128);
-
-    //     // Multiply a by fractional part of b using U64F64
-    //     let frac_b = b.saturating_sub(U64F64::saturating_from_num(int_b));
-    //     let low = U64F64::saturating_from_num(a).saturating_mul(frac_b);
-
-    //     // The only possible overflow (that is cut off by saturating math)
-    //     // is when a is u64::MAX, int_b is u64::MAX, and frac_b is non-zero,
-    //     // which is negligible error if we saturate and return u128::MAX
-    //     high.saturating_add(low).saturating_to_num::<u128>()
-    // }
-
-    /// Update token reserves after a swap
-    ///
-    fn update_reserves(&mut self, order_type: &OrderType, amount_in: u64, amount_out: u64) {
-        let (new_tao_reserve, new_alpha_reserve) = match order_type {
-            OrderType::Sell => (
-                self.state_ops.get_tao_reserve().saturating_add(amount_in),
-                self.state_ops
-                    .get_alpha_reserve()
-                    .saturating_sub(amount_out),
-            ),
-            OrderType::Buy => (
-                self.state_ops.get_tao_reserve().saturating_sub(amount_in),
-                self.state_ops
-                    .get_alpha_reserve()
-                    .saturating_add(amount_out),
-            ),
-        };
-
-        self.state_ops.set_tao_reserve(new_tao_reserve);
-        self.state_ops.set_alpha_reserve(new_alpha_reserve);
-    }
-
-    fn get_liquidity_update_u64(&self, tick: &Tick) -> u64 {
-        let liquidity_update_abs_i128 = tick.liquidity_net.abs();
-        if liquidity_update_abs_i128 > u64::MAX as i128 {
-            u64::MAX
-        } else {
-            liquidity_update_abs_i128 as u64
-        }
-    }
-
-    /// Update liquidity when crossing a tick
-    ///
-    fn update_liquidity_at_crossing(&mut self, order_type: &OrderType) -> Result<(), SwapError> {
-        let mut liquidity_curr = self.state_ops.get_current_liquidity();
-        let current_tick_index = self.get_current_tick_index();
-        match order_type {
-            OrderType::Sell => {
-                let maybe_tick = self.find_closest_lower_active_tick(current_tick_index);
-                if let Some(tick) = maybe_tick {
-                    let liquidity_update_abs_u64 = self.get_liquidity_update_u64(&tick);
-
-                    liquidity_curr = if tick.liquidity_net >= 0 {
-                        liquidity_curr.saturating_sub(liquidity_update_abs_u64)
-                    } else {
-                        liquidity_curr.saturating_add(liquidity_update_abs_u64)
-                    };
-                } else {
-                    return Err(SwapError::InsufficientLiquidity);
-                }
-            }
-            OrderType::Buy => {
-                let maybe_tick = self.find_closest_higher_active_tick(current_tick_index);
-                if let Some(tick) = maybe_tick {
-                    let liquidity_update_abs_u64 = self.get_liquidity_update_u64(&tick);
-
-                    liquidity_curr = if tick.liquidity_net >= 0 {
-                        liquidity_curr.saturating_add(liquidity_update_abs_u64)
-                    } else {
-                        liquidity_curr.saturating_sub(liquidity_update_abs_u64)
-                    };
-                } else {
-                    return Err(SwapError::InsufficientLiquidity);
-                }
-            }
-        }
-
-        self.state_ops.set_current_liquidity(liquidity_curr);
-        Ok(())
-    }
-
-    /// Collect fees for a position
-    /// Updates the position
-    ///
-    fn collect_fees(&mut self, position: &mut Position) -> (u64, u64) {
-        let mut fee_tao = self.get_fees_in_range(position, true);
-        let mut fee_alpha = self.get_fees_in_range(position, false);
-
-        fee_tao = fee_tao.saturating_sub(position.fees_tao);
-        fee_alpha = fee_alpha.saturating_sub(position.fees_alpha);
-
-        position.fees_tao = fee_tao;
-        position.fees_alpha = fee_alpha;
-
-        fee_tao = position.liquidity.saturating_mul(fee_tao);
-        fee_alpha = position.liquidity.saturating_mul(fee_alpha);
-
-        (fee_tao, fee_alpha)
-    }
-
-    /// Get fees in a position's range
-    ///
-    /// If quote flag is true, Tao is returned, otherwise alpha.
-    ///
-    fn get_fees_in_range(&mut self, position: &mut Position, quote: bool) -> u64 {
-        let i_lower = position.tick_low;
-        let i_upper = position.tick_high;
-
-        let fee_global = if quote {
-            self.state_ops.get_fee_global_tao()
-        } else {
-            self.state_ops.get_fee_global_alpha()
-        };
-
-        fee_global
-            .saturating_sub(self.get_fees_below(i_lower, quote))
-            .saturating_sub(self.get_fees_above(i_upper, quote))
-            .saturating_to_num::<u64>()
-    }
-
-    /// Get fees above a tick
-    ///
-    fn get_fees_above(&mut self, tick_index: i32, quote: bool) -> U64F64 {
-        let maybe_tick_index = find_closest_lower_active_tick_index(&self.state_ops, tick_index);
-        let current_tick = self.get_current_tick_index();
-
-        if let Some(tick_index) = maybe_tick_index {
-            let tick = self
-                .state_ops
-                .get_tick_by_index(tick_index)
-                .unwrap_or_default();
-            if tick_index <= current_tick {
-                if quote {
-                    self.state_ops
-                        .get_fee_global_tao()
-                        .saturating_sub(tick.fees_out_tao)
-                } else {
-                    self.state_ops
-                        .get_fee_global_alpha()
-                        .saturating_sub(tick.fees_out_alpha)
-                }
-            } else {
-                if quote {
-                    tick.fees_out_tao
-                } else {
-                    tick.fees_out_alpha
-                }
-            }
-        } else {
-            U64F64::saturating_from_num(0)
-        }
-    }
-
-    /// Get fees below a tick
-    fn get_fees_below(&mut self, tick_index: i32, quote: bool) -> U64F64 {
-        let maybe_tick_index = find_closest_lower_active_tick_index(&self.state_ops, tick_index);
-        let current_tick = self.get_current_tick_index();
-
-        if let Some(tick_index) = maybe_tick_index {
-            let tick = self
-                .state_ops
-                .get_tick_by_index(tick_index)
-                .unwrap_or_default();
-            if tick_index <= current_tick {
-                if quote {
-                    tick.fees_out_tao
-                } else {
-                    tick.fees_out_alpha
-                }
-            } else {
-                if quote {
-                    self.state_ops
-                        .get_fee_global_tao()
-                        .saturating_sub(tick.fees_out_tao)
-                } else {
-                    self.state_ops
-                        .get_fee_global_alpha()
-                        .saturating_sub(tick.fees_out_alpha)
-                }
-            }
-        } else {
-            U64F64::saturating_from_num(0)
-        }
-    }
-
-    pub fn find_closest_lower_active_tick(&self, index: i32) -> Option<Tick> {
-        let maybe_tick_index = find_closest_lower_active_tick_index(&self.state_ops, index);
-        if let Some(tick_index) = maybe_tick_index {
-            self.state_ops.get_tick_by_index(tick_index)
-        } else {
-            None
-        }
-    }
-
-    pub fn find_closest_higher_active_tick(&self, index: i32) -> Option<Tick> {
-        let maybe_tick_index = find_closest_higher_active_tick_index(&self.state_ops, index);
-        if let Some(tick_index) = maybe_tick_index {
-            self.state_ops.get_tick_by_index(tick_index)
-        } else {
-            None
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use approx::assert_abs_diff_eq;
-    use sp_arithmetic::helpers_128bit::sqrt;
-    use std::collections::HashMap;
-
-    #[derive(Debug, Clone)]
-    pub struct MockSwapDataOperations {
-        is_initialized: bool,
-        fee_rate: u16,
-        minimum_liquidity: u64,
-        ticks: HashMap<i32, Tick>,
-        min_sqrt_price: SqrtPrice,
-        max_sqrt_price: SqrtPrice,
-        tao_reserve: u64,
-        alpha_reserve: u64,
-        alpha_sqrt_price: SqrtPrice,
-        fee_global_tao: U64F64,
-        fee_global_alpha: U64F64,
-        current_liquidity: u64,
-        max_positions: u16,
-        balances: HashMap<u16, (u64, u64)>,
-        positions: HashMap<u16, HashMap<u16, Position>>,
-    }
-
-    impl MockSwapDataOperations {
-        pub fn new() -> Self {
-            Self {
-                is_initialized: false,
-                fee_rate: 196,
-                minimum_liquidity: 1000,
-                ticks: HashMap::new(),
-                min_sqrt_price: SqrtPrice::from_num(0.01),
-                max_sqrt_price: SqrtPrice::from_num(10),
-                tao_reserve: 0,
-                alpha_reserve: 0,
-                alpha_sqrt_price: SqrtPrice::from_num(0),
-                fee_global_tao: U64F64::from_num(0),
-                fee_global_alpha: U64F64::from_num(0),
-                current_liquidity: 0,
-                max_positions: 100,
-                balances: HashMap::new(),
-                positions: HashMap::new(),
-            }
-        }
-    }
-
-    impl SwapDataOperations<u16> for MockSwapDataOperations {
-        fn is_v3_initialized(&self) -> bool {
-            self.is_initialized
-        }
-
-        fn set_v3_initialized(&mut self) {
-            self.is_initialized = true;
-        }
-
-        fn get_fee_rate(&self) -> u16 {
-            self.fee_rate
-        }
-
-        fn get_minimum_liquidity(&self) -> u64 {
-            self.minimum_liquidity
-        }
-
-        fn get_tick_by_index(&self, tick_index: i32) -> Option<Tick> {
-            self.ticks.get(&tick_index).cloned()
-        }
-
-        fn insert_tick_by_index(&mut self, tick_index: i32, tick: Tick) {
-            self.ticks.insert(tick_index, tick);
-        }
-
-        fn remove_tick_by_index(&mut self, tick_index: i32) {
-            self.ticks.remove(&tick_index);
-        }
-
-        fn get_min_sqrt_price(&self) -> SqrtPrice {
-            self.min_sqrt_price
-        }
-
-        fn get_max_sqrt_price(&self) -> SqrtPrice {
-            self.max_sqrt_price
-        }
-
-        fn get_tao_reserve(&self) -> u64 {
-            self.tao_reserve
-        }
-
-        fn set_tao_reserve(&mut self, tao: u64) -> u64 {
-            self.tao_reserve = tao;
-            tao
-        }
-
-        fn get_alpha_reserve(&self) -> u64 {
-            self.alpha_reserve
-        }
-
-        fn set_alpha_reserve(&mut self, alpha: u64) -> u64 {
-            self.alpha_reserve = alpha;
-            alpha
-        }
-
-        fn get_alpha_sqrt_price(&self) -> SqrtPrice {
-            self.alpha_sqrt_price
-        }
-
-        fn set_alpha_sqrt_price(&mut self, sqrt_price: SqrtPrice) {
-            self.alpha_sqrt_price = sqrt_price;
-        }
-
-        fn get_fee_global_tao(&self) -> U64F64 {
-            self.fee_global_tao
-        }
-
-        fn set_fee_global_tao(&mut self, fee: U64F64) {
-            self.fee_global_tao = fee;
-        }
-
-        fn get_fee_global_alpha(&self) -> U64F64 {
-            self.fee_global_alpha
-        }
-
-        fn set_fee_global_alpha(&mut self, fee: U64F64) {
-            self.fee_global_alpha = fee;
-        }
-
-        fn get_current_liquidity(&self) -> u64 {
-            self.current_liquidity
-        }
-
-        fn set_current_liquidity(&mut self, liquidity: u64) {
-            self.current_liquidity = liquidity;
-        }
-
-        fn get_max_positions(&self) -> u16 {
-            self.max_positions
-        }
-
-        fn withdraw_balances(
-            &mut self,
-            account_id: &u16,
-            tao: u64,
-            alpha: u64,
-        ) -> Result<(u64, u64), SwapError> {
-            let (current_tao, current_alpha) =
-                self.balances.get(account_id).cloned().unwrap_or((0, 0));
-
-            if (tao > current_tao) || (alpha > current_alpha) {
-                return Err(SwapError::InsufficientBalance);
-            }
-
-            self.balances
-                .insert(*account_id, (current_tao - tao, current_alpha - alpha));
-
-            Ok((tao, alpha))
-        }
-
-        fn deposit_balances(&mut self, account_id: &u16, tao: u64, alpha: u64) {
-            let (current_tao, current_alpha) =
-                self.balances.get(account_id).cloned().unwrap_or((0, 0));
-            self.balances.insert(
-                account_id.clone(),
-                (current_tao + tao, current_alpha + alpha),
-            );
-        }
-
-        fn get_protocol_account_id(&self) -> u16 {
-            0xFFFF
-        }
-
-        fn get_position_count(&self, account_id: &u16) -> u16 {
-            self.positions.get(account_id).map_or(0, |p| p.len() as u16)
-        }
-
-        fn get_position(&self, account_id: &u16, position_id: u16) -> Option<Position> {
-            self.positions
-                .get(account_id)
-                .and_then(|p| p.get(&position_id).cloned())
-        }
-
-        fn create_position(&mut self, account_id: &u16, position: Position) -> u16 {
-            let entry = self
-                .positions
-                .entry(account_id.clone())
-                .or_insert_with(HashMap::new);
-
-            // Find the next available position ID
-            let new_position_id = entry.keys().max().map_or(0, |max_id| max_id + 1);
-
-            entry.insert(new_position_id, position);
-            new_position_id
-        }
-
-        fn update_position(&mut self, account_id: &u16, position_id: u16, position: Position) {
-            if let Some(account_positions) = self.positions.get_mut(account_id) {
-                account_positions.insert(position_id, position);
-            }
-        }
-
-        fn remove_position(&mut self, account_id: &u16, position_id: u16) {
-            if let Some(account_positions) = self.positions.get_mut(account_id) {
-                account_positions.remove(&position_id);
-            }
-        }
-    }
-
-    #[test]
-    fn test_swap_initialization() {
-        let tao = 1_000_000_000;
-        let alpha = 4_000_000_000;
-
-        let mut mock_ops = MockSwapDataOperations::new();
-        mock_ops.set_tao_reserve(tao);
-        mock_ops.set_alpha_reserve(alpha);
-        let swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
-
-        // Active ticks
-        let tick_low = swap.state_ops.get_tick_by_index(MIN_TICK_INDEX).unwrap();
-        let tick_high = swap.state_ops.get_tick_by_index(MAX_TICK_INDEX).unwrap();
-        let liquidity = sqrt(alpha as u128 * tao as u128) as u64;
-        let expected_liquidity_net_low: i128 = liquidity as i128;
-        let expected_liquidity_gross_low: u64 = liquidity;
-        let expected_liquidity_net_high: i128 = (liquidity as i128).neg();
-        let expected_liquidity_gross_high: u64 = liquidity;
-        assert_eq!(tick_low.liquidity_net, expected_liquidity_net_low,);
-        assert_eq!(tick_low.liquidity_gross, expected_liquidity_gross_low,);
-        assert_eq!(tick_high.liquidity_net, expected_liquidity_net_high,);
-        assert_eq!(tick_high.liquidity_gross, expected_liquidity_gross_high,);
-
-        // Liquidity position at correct ticks
-        let account_id = swap.state_ops.get_protocol_account_id();
-        assert_eq!(swap.state_ops.get_position_count(&account_id), 1);
-
-        let position = swap.state_ops.get_position(&account_id, 0).unwrap();
-        assert_eq!(position.liquidity, liquidity);
-        assert_eq!(position.tick_low, MIN_TICK_INDEX);
-        assert_eq!(position.tick_high, MAX_TICK_INDEX);
-        assert_eq!(position.fees_alpha, 0);
-        assert_eq!(position.fees_tao, 0);
-
-        // Current liquidity
-        assert_eq!(swap.state_ops.get_current_liquidity(), liquidity);
-
-        // Current price
-        let sqrt_price = swap.state_ops.get_alpha_sqrt_price();
-        assert_abs_diff_eq!(sqrt_price.to_num::<f64>(), 0.50, epsilon = 0.00001,);
-    }
-
-    fn price_to_tick(price: f64) -> i32 {
-        let price_sqrt: SqrtPrice = SqrtPrice::from_num(price.sqrt());
-        let mut tick = sqrt_price_to_tick_index(price_sqrt).unwrap();
-        if tick > MAX_TICK_INDEX {
-            tick = MAX_TICK_INDEX
-        }
-        tick
-    }
-
-    fn tick_to_price(tick: i32) -> f64 {
-        let price_sqrt: SqrtPrice = tick_index_to_sqrt_price(tick).unwrap();
-        (price_sqrt * price_sqrt).to_num::<f64>()
-    }
-
-    #[test]
-    fn test_tick_price_sanity_check() {
-        let min_price = tick_to_price(MIN_TICK_INDEX);
-        let max_price = tick_to_price(MAX_TICK_INDEX);
-        assert!(min_price > 0.);
-        assert!(max_price > 0.);
-        assert!(max_price > min_price);
-        assert!(min_price < 0.000001);
-        assert!(max_price > 10.);
-
-        // Roundtrip conversions
-        let min_price_sqrt: SqrtPrice = tick_index_to_sqrt_price(MIN_TICK_INDEX).unwrap();
-        let min_tick = sqrt_price_to_tick_index(min_price_sqrt).unwrap();
-        assert_eq!(min_tick, MIN_TICK_INDEX);
-
-        let max_price_sqrt: SqrtPrice = tick_index_to_sqrt_price(MAX_TICK_INDEX).unwrap();
-        let max_tick = sqrt_price_to_tick_index(max_price_sqrt).unwrap();
-        assert_eq!(max_tick, MAX_TICK_INDEX);
-    }
-
-    // Test adding liquidity on top of the existing protocol liquidity
-    #[test]
-    fn test_add_liquidity_basic() {
-        let protocol_tao = 1_000_000_000;
-        let protocol_alpha = 4_000_000_000;
-        let user_tao = 100_000_000_000;
-        let user_alpha = 100_000_000_000;
-        let account_id = 1;
-        let min_price = tick_to_price(MIN_TICK_INDEX);
-        let max_price = tick_to_price(MAX_TICK_INDEX);
-        let max_tick = price_to_tick(max_price);
-        let current_price = 0.25;
-        assert_eq!(max_tick, MAX_TICK_INDEX);
-
-        // As a user add liquidity with all possible corner cases
-        //   - Initial price is 0.25
-        //   - liquidity is expressed in RAO units
-        // Test case is (price_low, price_high, liquidity, tao, alpha)
-        [
-            // Repeat the protocol liquidity at maximum range: Expect all the same values
-            (
-                min_price,
-                max_price,
-                2_000_000_000_u64,
-                1_000_000_000_u64,
-                4_000_000_000_u64,
-            ),
-            // Repeat the protocol liquidity at current to max range: Expect the same alpha
-            (0.25, max_price, 2_000_000_000_u64, 0, 4_000_000_000),
-            // Repeat the protocol liquidity at min to current range: Expect all the same tao
-            (min_price, 0.24999, 2_000_000_000_u64, 1_000_000_000, 0),
-            // Half to double price - just some sane wothdraw amounts
-            (0.125, 0.5, 2_000_000_000_u64, 293_000_000, 1_171_000_000),
-            // Both below price - tao is non-zero, alpha is zero
-            (0.12, 0.13, 2_000_000_000_u64, 28_270_000, 0),
-            // Both above price - tao is zero, alpha is non-zero
-            (0.3, 0.4, 2_000_000_000_u64, 0, 489_200_000),
-        ]
-        .iter()
-        .for_each(|(price_low, price_high, liquidity, tao, alpha)| {
-            // Calculate ticks (assuming tick math is tested separately)
-            let tick_low = price_to_tick(*price_low);
-            let tick_high = price_to_tick(*price_high);
-
-            // Setup swap
-            let mut mock_ops = MockSwapDataOperations::new();
-            mock_ops.set_tao_reserve(protocol_tao);
-            mock_ops.set_alpha_reserve(protocol_alpha);
-            mock_ops.deposit_balances(&account_id, user_tao, user_alpha);
-            let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
-
-            // Get tick infos and liquidity before adding (to account for protocol liquidity)
-            let tick_low_info_before = swap
-                .state_ops
-                .get_tick_by_index(tick_low)
-                .unwrap_or_default();
-            let tick_high_info_before = swap
-                .state_ops
-                .get_tick_by_index(tick_high)
-                .unwrap_or_default();
-            let liquidity_before = swap.state_ops.get_current_liquidity();
-
-            // Add liquidity
-            assert!(
-                swap.add_liquidity(&account_id, tick_low, tick_high, *liquidity, false)
-                    .is_ok()
-            );
-
-            // Check that low and high ticks appear in the state and are properly updated
-            let tick_low_info = swap.state_ops.get_tick_by_index(tick_low).unwrap();
-            let tick_high_info = swap.state_ops.get_tick_by_index(tick_high).unwrap();
-            let expected_liquidity_net_low: i128 = *liquidity as i128;
-            let expected_liquidity_gross_low: u64 = *liquidity;
-            let expected_liquidity_net_high: i128 = (*liquidity as i128).neg();
-            let expected_liquidity_gross_high: u64 = *liquidity;
-            assert_eq!(
-                tick_low_info.liquidity_net - tick_low_info_before.liquidity_net,
-                expected_liquidity_net_low,
-            );
-            assert_eq!(
-                tick_low_info.liquidity_gross - tick_low_info_before.liquidity_gross,
-                expected_liquidity_gross_low,
-            );
-            assert_eq!(
-                tick_high_info.liquidity_net - tick_high_info_before.liquidity_net,
-                expected_liquidity_net_high,
-            );
-            assert_eq!(
-                tick_high_info.liquidity_gross - tick_high_info_before.liquidity_gross,
-                expected_liquidity_gross_high,
-            );
-
-            // Balances are withdrawn
-            let (user_tao_after, user_alpha_after) =
-                swap.state_ops.balances.get(&account_id).unwrap();
-            let tao_withdrawn = user_tao - user_tao_after;
-            let alpha_withdrawn = user_alpha - user_alpha_after;
-            assert_abs_diff_eq!(tao_withdrawn, *tao, epsilon = *tao / 1000);
-            assert_abs_diff_eq!(alpha_withdrawn, *alpha, epsilon = *alpha / 1000);
-
-            // Liquidity position at correct ticks
-            assert_eq!(swap.state_ops.get_position_count(&account_id), 1);
-
-            let position = swap.state_ops.get_position(&account_id, 0).unwrap();
-            assert_eq!(position.liquidity, *liquidity);
-            assert_eq!(position.tick_low, tick_low);
-            assert_eq!(position.tick_high, tick_high);
-            assert_eq!(position.fees_alpha, 0);
-            assert_eq!(position.fees_tao, 0);
-
-            // Current liquidity is updated only when price range includes the current price
-            if (*price_high >= current_price) && (*price_low <= current_price) {
-                assert_eq!(
-                    swap.state_ops.get_current_liquidity(),
-                    liquidity_before + *liquidity
-                );
-            } else {
-                assert_eq!(swap.state_ops.get_current_liquidity(), liquidity_before);
-            }
-
-            // Reserves are updated
-            assert_eq!(
-                swap.state_ops.get_tao_reserve(),
-                tao_withdrawn + protocol_tao,
-            );
-            assert_eq!(
-                swap.state_ops.get_alpha_reserve(),
-                alpha_withdrawn + protocol_alpha,
-            );
-        });
-    }
-
-    #[test]
-    fn test_add_liquidity_out_of_bounds() {
-        let protocol_tao = 1_000_000_000;
-        let protocol_alpha = 2_000_000_000;
-        let user_tao = 100_000_000_000;
-        let user_alpha = 100_000_000_000;
-        let account_id = 1;
-
-        [
-            (MIN_TICK_INDEX - 1, MAX_TICK_INDEX, 1_000_000_000_u64),
-            (MIN_TICK_INDEX, MAX_TICK_INDEX + 1, 1_000_000_000_u64),
-            (MIN_TICK_INDEX - 1, MAX_TICK_INDEX + 1, 1_000_000_000_u64),
-            (
-                MIN_TICK_INDEX - 100,
-                MAX_TICK_INDEX + 100,
-                1_000_000_000_u64,
-            ),
-        ]
-        .iter()
-        .for_each(|(tick_low, tick_high, liquidity)| {
-            // Setup swap
-            let mut mock_ops = MockSwapDataOperations::new();
-            mock_ops.set_tao_reserve(protocol_tao);
-            mock_ops.set_alpha_reserve(protocol_alpha);
-            mock_ops.deposit_balances(&account_id, user_tao, user_alpha);
-            let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
-
-            // Add liquidity
-            assert_eq!(
-                swap.add_liquidity(&account_id, *tick_low, *tick_high, *liquidity, false),
-                Err(SwapError::InvalidTickRange),
-            );
-        });
-    }
-
-    #[test]
-    fn test_add_liquidity_over_balance() {
-        let protocol_tao = 1_000_000_000;
-        let protocol_alpha = 4_000_000_000;
-        let user_tao = 1_000_000_000;
-        let user_alpha = 1_000_000_000;
-        let account_id = 1;
-
-        [
-            // Lower than price (not enough alpha)
-            (0.1, 0.2, 100_000_000_000_u64),
-            // Higher than price (not enough tao)
-            (0.3, 0.4, 100_000_000_000_u64),
-            // Around the price (not enough both)
-            (0.1, 0.4, 100_000_000_000_u64),
-        ]
-        .iter()
-        .for_each(|(price_low, price_high, liquidity)| {
-            // Calculate ticks
-            let tick_low = price_to_tick(*price_low);
-            let tick_high = price_to_tick(*price_high);
-
-            // Setup swap
-            let mut mock_ops = MockSwapDataOperations::new();
-            mock_ops.set_tao_reserve(protocol_tao);
-            mock_ops.set_alpha_reserve(protocol_alpha);
-            mock_ops.deposit_balances(&account_id, user_tao, user_alpha);
-            let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
-
-            // Add liquidity
-            assert_eq!(
-                swap.add_liquidity(&account_id, tick_low, tick_high, *liquidity, false),
-                Err(SwapError::InsufficientBalance),
-            );
-        });
-    }
-
-    // Test removing liquidity
-    #[test]
-    fn test_remove_liquidity_basic() {
-        let protocol_tao = 1_000_000_000;
-        let protocol_alpha = 4_000_000_000;
-        let user_tao = 100_000_000_000;
-        let user_alpha = 100_000_000_000;
-        let account_id = 1;
-        let min_price = tick_to_price(MIN_TICK_INDEX);
-        let max_price = tick_to_price(MAX_TICK_INDEX);
-        let max_tick = price_to_tick(max_price);
-        assert_eq!(max_tick, MAX_TICK_INDEX);
-
-        // As a user add liquidity with all possible corner cases
-        //   - Initial price is 0.25
-        //   - liquidity is expressed in RAO units
-        // Test case is (price_low, price_high, liquidity, tao, alpha)
-        [
-            // Repeat the protocol liquidity at maximum range: Expect all the same values
-            (
-                min_price,
-                max_price,
-                2_000_000_000_u64,
-                1_000_000_000_u64,
-                4_000_000_000_u64,
-            ),
-            // Repeat the protocol liquidity at current to max range: Expect the same alpha
-            (0.25, max_price, 2_000_000_000_u64, 0, 4_000_000_000),
-            // Repeat the protocol liquidity at min to current range: Expect all the same tao
-            (min_price, 0.24999, 2_000_000_000_u64, 1_000_000_000, 0),
-            // Half to double price - just some sane wothdraw amounts
-            (0.125, 0.5, 2_000_000_000_u64, 293_000_000, 1_171_000_000),
-            // Both below price - tao is non-zero, alpha is zero
-            (0.12, 0.13, 2_000_000_000_u64, 28_270_000, 0),
-            // Both above price - tao is zero, alpha is non-zero
-            (0.3, 0.4, 2_000_000_000_u64, 0, 489_200_000),
-        ]
-        .iter()
-        .for_each(|(price_low, price_high, liquidity, tao, alpha)| {
-            // Calculate ticks (assuming tick math is tested separately)
-            let tick_low = price_to_tick(*price_low);
-            let tick_high = price_to_tick(*price_high);
-
-            // Setup swap
-            let mut mock_ops = MockSwapDataOperations::new();
-            mock_ops.set_tao_reserve(protocol_tao);
-            mock_ops.set_alpha_reserve(protocol_alpha);
-            mock_ops.deposit_balances(&account_id, user_tao, user_alpha);
-            let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
-            let liquidity_before = swap.state_ops.get_current_liquidity();
-
-            // Add liquidity
-            assert!(
-                swap.add_liquidity(&account_id, tick_low, tick_high, *liquidity, false)
-                    .is_ok()
-            );
-
-            // Remove liquidity
-            let remove_result = swap.remove_liquidity(&account_id, 0).unwrap();
-            assert_abs_diff_eq!(remove_result.tao, *tao, epsilon = *tao / 1000);
-            assert_abs_diff_eq!(remove_result.alpha, *alpha, epsilon = *alpha / 1000);
-            assert_eq!(remove_result.fee_tao, 0);
-            assert_eq!(remove_result.fee_alpha, 0);
-
-            // Balances are returned
-            let (user_tao_after, user_alpha_after) =
-                swap.state_ops.balances.get(&account_id).unwrap();
-            assert_eq!(user_tao, *user_tao_after);
-            assert_eq!(user_alpha, *user_alpha_after);
-
-            // Liquidity position is removed
-            assert_eq!(swap.state_ops.get_position_count(&account_id), 0);
-            assert!(swap.state_ops.get_position(&account_id, 0).is_none());
-
-            // Current liquidity is updated (back where it was)
-            assert_eq!(swap.state_ops.get_current_liquidity(), liquidity_before);
-
-            // Reserves are updated (back where they were)
-            assert_eq!(swap.state_ops.get_tao_reserve(), protocol_tao,);
-            assert_eq!(swap.state_ops.get_alpha_reserve(), protocol_alpha,);
-        });
-    }
-
-    #[test]
-    fn test_remove_liquidity_nonexisting_position() {
-        let protocol_tao = 1_000_000_000;
-        let protocol_alpha = 4_000_000_000;
-        let user_tao = 100_000_000_000;
-        let user_alpha = 100_000_000_000;
-        let account_id = 1;
-        let min_price = tick_to_price(MIN_TICK_INDEX);
-        let max_price = tick_to_price(MAX_TICK_INDEX);
-        let max_tick = price_to_tick(max_price);
-        assert_eq!(max_tick, MAX_TICK_INDEX);
-
-        // Test case is (price_low, price_high, liquidity)
-        [
-            // Repeat the protocol liquidity at maximum range: Expect all the same values
-            (min_price, max_price, 2_000_000_000_u64),
-        ]
-        .iter()
-        .for_each(|(price_low, price_high, liquidity)| {
-            // Calculate ticks (assuming tick math is tested separately)
-            let tick_low = price_to_tick(*price_low);
-            let tick_high = price_to_tick(*price_high);
-
-            // Setup swap
-            let mut mock_ops = MockSwapDataOperations::new();
-            mock_ops.set_tao_reserve(protocol_tao);
-            mock_ops.set_alpha_reserve(protocol_alpha);
-            mock_ops.deposit_balances(&account_id, user_tao, user_alpha);
-            let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
-
-            // Add liquidity
-            assert!(
-                swap.add_liquidity(&account_id, tick_low, tick_high, *liquidity, false)
-                    .is_ok()
-            );
-
-            // Remove liquidity
-            assert_eq!(
-                swap.remove_liquidity(&account_id, 1),
-                Err(SwapError::LiquidityNotFound),
-            );
-        });
-    }
-}
diff --git a/primitives/swap/src/tick.rs b/primitives/swap/src/tick.rs
deleted file mode 100644
index e5e7eefc16..0000000000
--- a/primitives/swap/src/tick.rs
+++ /dev/null
@@ -1,191 +0,0 @@
-use substrate_fixed::types::U64F64;
-
-use crate::tick_math::{
-    MAX_TICK, MIN_TICK, TickMathError, get_sqrt_ratio_at_tick, get_tick_at_sqrt_ratio,
-    u64f64_to_u256_q64_96, u256_q64_96_to_u64f64,
-};
-use crate::{SqrtPrice, SwapDataOperations};
-
-// Maximum and minimum values of the tick index
-// The tick_math library uses different bitness, so we have to divide by 2.
-// Do not use tick_math::MIN_TICK and tick_math::MAX_TICK
-pub const MAX_TICK_INDEX: i32 = MAX_TICK / 2;
-pub const MIN_TICK_INDEX: i32 = MIN_TICK / 2;
-
-/// Tick is the price range determined by tick index (not part of this struct,
-/// but is the key at which the Tick is stored in state hash maps). Tick struct
-/// stores liquidity and fee information.
-///
-///   - Net liquidity
-///   - Gross liquidity
-///   - Fees (above global) in both currencies
-///
-#[derive(Debug, Default, Clone)]
-pub struct Tick {
-    pub liquidity_net: i128,
-    pub liquidity_gross: u64,
-    pub fees_out_tao: U64F64,
-    pub fees_out_alpha: U64F64,
-}
-
-/// Converts tick index into SQRT of lower price of this tick
-/// In order to find the higher price of this tick, call
-/// tick_index_to_sqrt_price(tick_idx + 1)
-pub fn tick_index_to_sqrt_price(tick_idx: i32) -> Result<SqrtPrice, TickMathError> {
-    // because of u256->u128 conversion we have twice less values for min/max ticks
-    if !(MIN_TICK / 2..=MAX_TICK / 2).contains(&tick_idx) {
-        return Err(TickMathError::TickOutOfBounds);
-    }
-    get_sqrt_ratio_at_tick(tick_idx).and_then(u256_q64_96_to_u64f64)
-}
-
-/// Converts SQRT price to tick index
-/// Because the tick is the range of prices [sqrt_lower_price, sqrt_higher_price),
-/// the resulting tick index matches the price by the following inequality:
-///    sqrt_lower_price <= sqrt_price < sqrt_higher_price
-pub fn sqrt_price_to_tick_index(sqrt_price: SqrtPrice) -> Result<i32, TickMathError> {
-    let tick = get_tick_at_sqrt_ratio(u64f64_to_u256_q64_96(sqrt_price))?;
-
-    // Correct for rounding error during conversions between different fixed-point formats
-    Ok(if tick == 0 {
-        tick
-    } else {
-        tick.saturating_add(1)
-    })
-}
-
-pub fn find_closest_lower_active_tick_index<Ops, AccountIdType>(
-    ops: &Ops,
-    index: i32,
-) -> Option<i32>
-where
-    AccountIdType: Eq,
-    Ops: SwapDataOperations<AccountIdType>,
-{
-    // TODO: Implement without iteration
-    let mut current_index = index;
-    loop {
-        if current_index < MIN_TICK {
-            return None;
-        }
-        if ops.get_tick_by_index(current_index).is_some() {
-            return Some(current_index);
-        }
-
-        // Intentionally using unsafe math here to trigger CI
-        current_index -= 1;
-    }
-}
-
-pub fn find_closest_higher_active_tick_index<Ops, AccountIdType>(
-    ops: &Ops,
-    index: i32,
-) -> Option<i32>
-where
-    AccountIdType: Eq,
-    Ops: SwapDataOperations<AccountIdType>,
-{
-    // TODO: Implement without iteration
-    let mut current_index = index;
-    loop {
-        if current_index > MAX_TICK {
-            return None;
-        }
-        if ops.get_tick_by_index(current_index).is_some() {
-            return Some(current_index);
-        }
-
-        // Intentionally using unsafe math here to trigger CI
-        current_index += 1;
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use safe_math::FixedExt;
-
-    #[test]
-    fn test_tick_index_to_sqrt_price() {
-        let tick_spacing = SqrtPrice::from_num(1.0001);
-
-        // check tick bounds
-        assert_eq!(
-            tick_index_to_sqrt_price(MIN_TICK),
-            Err(TickMathError::TickOutOfBounds)
-        );
-
-        assert_eq!(
-            tick_index_to_sqrt_price(MAX_TICK),
-            Err(TickMathError::TickOutOfBounds),
-        );
-
-        // At tick index 0, the sqrt price should be 1.0
-        let sqrt_price = tick_index_to_sqrt_price(0).unwrap();
-        assert_eq!(sqrt_price, SqrtPrice::from_num(1.0));
-
-        let sqrt_price = tick_index_to_sqrt_price(2).unwrap();
-        assert!(sqrt_price.abs_diff(tick_spacing) < SqrtPrice::from_num(1e-10));
-
-        let sqrt_price = tick_index_to_sqrt_price(4).unwrap();
-        // Calculate the expected value: (1 + TICK_SPACING/1e9 + 1.0)^2
-        let expected = tick_spacing * tick_spacing;
-        assert!(sqrt_price.abs_diff(expected) < SqrtPrice::from_num(1e-10));
-
-        // Test with tick index 10
-        let sqrt_price = tick_index_to_sqrt_price(10).unwrap();
-        // Calculate the expected value: (1 + TICK_SPACING/1e9 + 1.0)^5
-        let expected = tick_spacing.checked_pow(5).unwrap();
-        assert!(
-            sqrt_price.abs_diff(expected) < SqrtPrice::from_num(1e-10),
-            "diff: {}",
-            sqrt_price.abs_diff(expected),
-        );
-    }
-
-    #[test]
-    fn test_sqrt_price_to_tick_index() {
-        let tick_spacing = SqrtPrice::from_num(1.0001);
-        let tick_index = sqrt_price_to_tick_index(SqrtPrice::from_num(1.0)).unwrap();
-        assert_eq!(tick_index, 0);
-
-        // Test with sqrt price equal to tick_spacing_tao (should be tick index 2)
-        let tick_index = sqrt_price_to_tick_index(tick_spacing).unwrap();
-        assert_eq!(tick_index, 2);
-
-        // Test with sqrt price equal to tick_spacing_tao^2 (should be tick index 4)
-        let sqrt_price = tick_spacing * tick_spacing;
-        let tick_index = sqrt_price_to_tick_index(sqrt_price).unwrap();
-        assert_eq!(tick_index, 4);
-
-        // Test with sqrt price equal to tick_spacing_tao^5 (should be tick index 10)
-        let sqrt_price = tick_spacing.checked_pow(5).unwrap();
-        let tick_index = sqrt_price_to_tick_index(sqrt_price).unwrap();
-        assert_eq!(tick_index, 10);
-    }
-
-    #[test]
-    fn test_roundtrip_tick_index_sqrt_price() {
-        for tick_index in [
-            MIN_TICK / 2,
-            -1000,
-            -100,
-            -10,
-            -4,
-            -2,
-            0,
-            2,
-            4,
-            10,
-            100,
-            1000,
-            MAX_TICK / 2,
-        ]
-        .iter()
-        {
-            let sqrt_price = tick_index_to_sqrt_price(*tick_index).unwrap();
-            let round_trip_tick_index = sqrt_price_to_tick_index(sqrt_price).unwrap();
-            assert_eq!(round_trip_tick_index, *tick_index);
-        }
-    }
-}
diff --git a/primitives/swap/src/tick_math.rs b/primitives/swap/src/tick_math.rs
deleted file mode 100644
index 3dfcb0d514..0000000000
--- a/primitives/swap/src/tick_math.rs
+++ /dev/null
@@ -1,539 +0,0 @@
-//! This module is adopted from github.com/0xKitsune/uniswap-v3-math
-use core::error::Error;
-use core::fmt;
-use core::ops::{BitOr, Neg, Shl, Shr};
-
-use alloy_primitives::{I256, U256};
-use substrate_fixed::types::U64F64;
-
-const U256_1: U256 = U256::from_limbs([1, 0, 0, 0]);
-const U256_2: U256 = U256::from_limbs([2, 0, 0, 0]);
-const U256_3: U256 = U256::from_limbs([3, 0, 0, 0]);
-const U256_4: U256 = U256::from_limbs([4, 0, 0, 0]);
-const U256_5: U256 = U256::from_limbs([5, 0, 0, 0]);
-const U256_6: U256 = U256::from_limbs([6, 0, 0, 0]);
-const U256_7: U256 = U256::from_limbs([7, 0, 0, 0]);
-const U256_8: U256 = U256::from_limbs([8, 0, 0, 0]);
-const U256_15: U256 = U256::from_limbs([15, 0, 0, 0]);
-const U256_16: U256 = U256::from_limbs([16, 0, 0, 0]);
-const U256_32: U256 = U256::from_limbs([32, 0, 0, 0]);
-const U256_64: U256 = U256::from_limbs([64, 0, 0, 0]);
-const U256_127: U256 = U256::from_limbs([127, 0, 0, 0]);
-const U256_128: U256 = U256::from_limbs([128, 0, 0, 0]);
-const U256_255: U256 = U256::from_limbs([255, 0, 0, 0]);
-
-const U256_256: U256 = U256::from_limbs([256, 0, 0, 0]);
-const U256_512: U256 = U256::from_limbs([512, 0, 0, 0]);
-const U256_1024: U256 = U256::from_limbs([1024, 0, 0, 0]);
-const U256_2048: U256 = U256::from_limbs([2048, 0, 0, 0]);
-const U256_4096: U256 = U256::from_limbs([4096, 0, 0, 0]);
-const U256_8192: U256 = U256::from_limbs([8192, 0, 0, 0]);
-const U256_16384: U256 = U256::from_limbs([16384, 0, 0, 0]);
-const U256_32768: U256 = U256::from_limbs([32768, 0, 0, 0]);
-const U256_65536: U256 = U256::from_limbs([65536, 0, 0, 0]);
-const U256_131072: U256 = U256::from_limbs([131072, 0, 0, 0]);
-const U256_262144: U256 = U256::from_limbs([262144, 0, 0, 0]);
-const U256_524288: U256 = U256::from_limbs([524288, 0, 0, 0]);
-
-const U256_MAX_TICK: U256 = U256::from_limbs([887272, 0, 0, 0]);
-
-pub(crate) const MIN_TICK: i32 = -887272;
-pub(crate) const MAX_TICK: i32 = -MIN_TICK;
-
-const MIN_SQRT_RATIO: U256 = U256::from_limbs([4295128739, 0, 0, 0]);
-const MAX_SQRT_RATIO: U256 =
-    U256::from_limbs([6743328256752651558, 17280870778742802505, 4294805859, 0]);
-
-const SQRT_10001: I256 = I256::from_raw(U256::from_limbs([11745905768312294533, 13863, 0, 0]));
-const TICK_LOW: I256 = I256::from_raw(U256::from_limbs([
-    6552757943157144234,
-    184476617836266586,
-    0,
-    0,
-]));
-const TICK_HIGH: I256 = I256::from_raw(U256::from_limbs([
-    4998474450511881007,
-    15793544031827761793,
-    0,
-    0,
-]));
-
-pub(crate) fn get_sqrt_ratio_at_tick(tick: i32) -> Result<U256, TickMathError> {
-    let abs_tick = if tick < 0 {
-        U256::from(tick.neg())
-    } else {
-        U256::from(tick)
-    };
-
-    if abs_tick > U256_MAX_TICK {
-        return Err(TickMathError::TickOutOfBounds);
-    }
-
-    let mut ratio = if abs_tick & (U256_1) != U256::ZERO {
-        U256::from_limbs([12262481743371124737, 18445821805675392311, 0, 0])
-    } else {
-        U256::from_limbs([0, 0, 1, 0])
-    };
-
-    if !(abs_tick & U256_2).is_zero() {
-        ratio = (ratio * U256::from_limbs([6459403834229662010, 18444899583751176498, 0, 0])) >> 128
-    }
-    if !(abs_tick & U256_4).is_zero() {
-        ratio =
-            (ratio * U256::from_limbs([17226890335427755468, 18443055278223354162, 0, 0])) >> 128
-    }
-    if !(abs_tick & U256_8).is_zero() {
-        ratio = (ratio * U256::from_limbs([2032852871939366096, 18439367220385604838, 0, 0])) >> 128
-    }
-    if !(abs_tick & U256_16).is_zero() {
-        ratio =
-            (ratio * U256::from_limbs([14545316742740207172, 18431993317065449817, 0, 0])) >> 128
-    }
-    if !(abs_tick & U256_32).is_zero() {
-        ratio = (ratio * U256::from_limbs([5129152022828963008, 18417254355718160513, 0, 0])) >> 128
-    }
-    if !(abs_tick & U256_64).is_zero() {
-        ratio = (ratio * U256::from_limbs([4894419605888772193, 18387811781193591352, 0, 0])) >> 128
-    }
-    if !(abs_tick & U256_128).is_zero() {
-        ratio = (ratio * U256::from_limbs([1280255884321894483, 18329067761203520168, 0, 0])) >> 128
-    }
-    if !(abs_tick & U256_256).is_zero() {
-        ratio =
-            (ratio * U256::from_limbs([15924666964335305636, 18212142134806087854, 0, 0])) >> 128
-    }
-    if !(abs_tick & U256_512).is_zero() {
-        ratio = (ratio * U256::from_limbs([8010504389359918676, 17980523815641551639, 0, 0])) >> 128
-    }
-    if !(abs_tick & U256_1024).is_zero() {
-        ratio =
-            (ratio * U256::from_limbs([10668036004952895731, 17526086738831147013, 0, 0])) >> 128
-    }
-    if !(abs_tick & U256_2048).is_zero() {
-        ratio = (ratio * U256::from_limbs([4878133418470705625, 16651378430235024244, 0, 0])) >> 128
-    }
-    if !(abs_tick & U256_4096).is_zero() {
-        ratio = (ratio * U256::from_limbs([9537173718739605541, 15030750278693429944, 0, 0])) >> 128
-    }
-    if !(abs_tick & U256_8192).is_zero() {
-        ratio = (ratio * U256::from_limbs([9972618978014552549, 12247334978882834399, 0, 0])) >> 128
-    }
-    if !(abs_tick & U256_16384).is_zero() {
-        ratio = (ratio * U256::from_limbs([10428997489610666743, 8131365268884726200, 0, 0])) >> 128
-    }
-    if !(abs_tick & U256_32768).is_zero() {
-        ratio = (ratio * U256::from_limbs([9305304367709015974, 3584323654723342297, 0, 0])) >> 128
-    }
-    if !(abs_tick & U256_65536).is_zero() {
-        ratio = (ratio * U256::from_limbs([14301143598189091785, 696457651847595233, 0, 0])) >> 128
-    }
-    if !(abs_tick & U256_131072).is_zero() {
-        ratio = (ratio * U256::from_limbs([7393154844743099908, 26294789957452057, 0, 0])) >> 128
-    }
-    if !(abs_tick & U256_262144).is_zero() {
-        ratio = (ratio * U256::from_limbs([2209338891292245656, 37481735321082, 0, 0])) >> 128
-    }
-    if !(abs_tick & U256_524288).is_zero() {
-        ratio = (ratio * U256::from_limbs([10518117631919034274, 76158723, 0, 0])) >> 128
-    }
-
-    if tick > 0 {
-        ratio = U256::MAX / ratio;
-    }
-
-    Ok((ratio >> 32)
-        + if (ratio.wrapping_rem(U256_1 << 32)).is_zero() {
-            U256::ZERO
-        } else {
-            U256_1
-        })
-}
-
-pub(crate) fn get_tick_at_sqrt_ratio(sqrt_price_x_96: U256) -> Result<i32, TickMathError> {
-    if !(sqrt_price_x_96 >= MIN_SQRT_RATIO && sqrt_price_x_96 < MAX_SQRT_RATIO) {
-        return Err(TickMathError::SqrtPriceOutOfBounds);
-    }
-
-    let ratio: U256 = sqrt_price_x_96.shl(32);
-    let mut r = ratio;
-    let mut msb = U256::ZERO;
-
-    let mut f = if r > U256::from_limbs([18446744073709551615, 18446744073709551615, 0, 0]) {
-        U256_1.shl(U256_7)
-    } else {
-        U256::ZERO
-    };
-    msb = msb.bitor(f);
-    r = r.shr(f);
-
-    f = if r > U256::from_limbs([18446744073709551615, 0, 0, 0]) {
-        U256_1.shl(U256_6)
-    } else {
-        U256::ZERO
-    };
-    msb = msb.bitor(f);
-    r = r.shr(f);
-
-    f = if r > U256::from_limbs([4294967295, 0, 0, 0]) {
-        U256_1.shl(U256_5)
-    } else {
-        U256::ZERO
-    };
-    msb = msb.bitor(f);
-    r = r.shr(f);
-
-    f = if r > U256::from_limbs([65535, 0, 0, 0]) {
-        U256_1.shl(U256_4)
-    } else {
-        U256::ZERO
-    };
-    msb = msb.bitor(f);
-    r = r.shr(f);
-
-    f = if r > U256_255 {
-        U256_1.shl(U256_3)
-    } else {
-        U256::ZERO
-    };
-    msb = msb.bitor(f);
-    r = r.shr(f);
-
-    f = if r > U256_15 {
-        U256_1.shl(U256_2)
-    } else {
-        U256::ZERO
-    };
-    msb = msb.bitor(f);
-    r = r.shr(f);
-
-    f = if r > U256_3 {
-        U256_1.shl(U256_1)
-    } else {
-        U256::ZERO
-    };
-    msb = msb.bitor(f);
-    r = r.shr(f);
-
-    f = if r > U256_1 { U256_1 } else { U256::ZERO };
-
-    msb = msb.bitor(f);
-
-    r = if msb >= U256_128 {
-        ratio.shr(msb - U256_127)
-    } else {
-        ratio.shl(U256_127 - msb)
-    };
-
-    let mut log_2: I256 = (I256::from_raw(msb) - I256::from_limbs([128, 0, 0, 0])).shl(64);
-
-    for i in (51..=63).rev() {
-        r = r.overflowing_mul(r).0.shr(U256_127);
-        let f: U256 = r.shr(128);
-        log_2 = log_2.bitor(I256::from_raw(f.shl(i)));
-
-        r = r.shr(f);
-    }
-
-    r = r.overflowing_mul(r).0.shr(U256_127);
-    let f: U256 = r.shr(128);
-    log_2 = log_2.bitor(I256::from_raw(f.shl(50)));
-
-    let log_sqrt10001 = log_2.wrapping_mul(SQRT_10001);
-
-    let tick_low = ((log_sqrt10001 - TICK_LOW) >> 128_u8).low_i32();
-
-    let tick_high = ((log_sqrt10001 + TICK_HIGH) >> 128_u8).low_i32();
-
-    let tick = if tick_low == tick_high {
-        tick_low
-    } else if get_sqrt_ratio_at_tick(tick_high)? <= sqrt_price_x_96 {
-        tick_high
-    } else {
-        tick_low
-    };
-
-    Ok(tick)
-}
-
-/// Convert U256 to U64F64
-///
-/// # Arguments
-/// * `value` - The U256 value in Q64.96 format
-///
-/// # Returns
-/// * `Result<U64F64, &'static str>` - Converted value or error if too large
-pub(crate) fn u256_to_u64f64(
-    value: U256,
-    source_fractional_bits: u32,
-) -> Result<U64F64, TickMathError> {
-    if value > U256::from(u128::MAX) {
-        return Err(TickMathError::ConversionError);
-    }
-
-    let mut value: u128 = value
-        .try_into()
-        .map_err(|_| TickMathError::ConversionError)?;
-
-    // Adjust to 64 fractional bits (U64F64 format)
-    if source_fractional_bits < 64 {
-        // Shift left to add more fractional bits
-        value = value
-            .checked_shl(64 - source_fractional_bits)
-            .ok_or(TickMathError::Overflow)?;
-    } else if source_fractional_bits > 64 {
-        // Shift right to remove excess fractional bits
-        value = value >> (source_fractional_bits - 64);
-    }
-
-    Ok(U64F64::from_bits(value))
-}
-
-/// Convert U64F64 to U256
-///
-/// # Arguments
-/// * `value` - The U64F64 value to convert
-/// * `target_fractional_bits` - Number of fractional bits in the target U256 format
-///
-/// # Returns
-/// * `U256` - Converted value
-pub(crate) fn u64f64_to_u256(value: U64F64, target_fractional_bits: u32) -> U256 {
-    let mut bits = value.to_bits();
-
-    // Adjust to target fractional bits
-    if target_fractional_bits < 64 {
-        // Shift right to remove excess fractional bits
-        bits = bits >> (64 - target_fractional_bits);
-    } else if target_fractional_bits > 64 {
-        // Shift left to add more fractional bits
-        bits = bits << (target_fractional_bits - 64);
-    }
-
-    // Create U256
-    U256::from(bits)
-}
-
-/// Convert U256 in Q64.96 format (Uniswap's sqrt price format) to U64F64
-pub(crate) fn u256_q64_96_to_u64f64(value: U256) -> Result<U64F64, TickMathError> {
-    u256_to_u64f64(value, 96)
-}
-
-/// Convert U64F64 to U256 in Q64.96 format (Uniswap's sqrt price format)
-pub(crate) fn u64f64_to_u256_q64_96(value: U64F64) -> U256 {
-    u64f64_to_u256(value, 96)
-}
-
-#[derive(Debug, PartialEq, Eq)]
-pub enum TickMathError {
-    TickOutOfBounds,
-    SqrtPriceOutOfBounds,
-    ConversionError,
-    Overflow,
-}
-
-impl fmt::Display for TickMathError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-			Self::TickOutOfBounds => f.write_str("The given tick is outside of the minimum/maximum values."),
-			Self::SqrtPriceOutOfBounds =>f.write_str("Second inequality must be < because the price can never reach the price at the max tick"),
-			Self::ConversionError => f.write_str("Error converting from one number type into another"),
-			Self::Overflow => f.write_str("Number overflow in arithmetic operation")
-		}
-    }
-}
-
-impl Error for TickMathError {}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use std::{ops::Sub, str::FromStr};
-
-    #[test]
-    fn test_get_sqrt_ratio_at_tick_bounds() {
-        // the function should return an error if the tick is out of bounds
-        if let Err(err) = get_sqrt_ratio_at_tick(MIN_TICK - 1) {
-            assert!(matches!(err, TickMathError::TickOutOfBounds));
-        } else {
-            panic!("get_qrt_ratio_at_tick did not respect lower tick bound")
-        }
-        if let Err(err) = get_sqrt_ratio_at_tick(MAX_TICK + 1) {
-            assert!(matches!(err, TickMathError::TickOutOfBounds));
-        } else {
-            panic!("get_qrt_ratio_at_tick did not respect upper tick bound")
-        }
-    }
-
-    #[test]
-    fn test_get_sqrt_ratio_at_tick_values() {
-        // test individual values for correct results
-        assert_eq!(
-            get_sqrt_ratio_at_tick(MIN_TICK).unwrap(),
-            U256::from(4295128739u64),
-            "sqrt ratio at min incorrect"
-        );
-        assert_eq!(
-            get_sqrt_ratio_at_tick(MIN_TICK + 1).unwrap(),
-            U256::from(4295343490u64),
-            "sqrt ratio at min + 1 incorrect"
-        );
-        assert_eq!(
-            get_sqrt_ratio_at_tick(MAX_TICK - 1).unwrap(),
-            U256::from_str("1461373636630004318706518188784493106690254656249").unwrap(),
-            "sqrt ratio at max - 1 incorrect"
-        );
-        assert_eq!(
-            get_sqrt_ratio_at_tick(MAX_TICK).unwrap(),
-            U256::from_str("1461446703485210103287273052203988822378723970342").unwrap(),
-            "sqrt ratio at max incorrect"
-        );
-        // checking hard coded values against solidity results
-        assert_eq!(
-            get_sqrt_ratio_at_tick(50).unwrap(),
-            U256::from(79426470787362580746886972461u128),
-            "sqrt ratio at 50 incorrect"
-        );
-        assert_eq!(
-            get_sqrt_ratio_at_tick(100).unwrap(),
-            U256::from(79625275426524748796330556128u128),
-            "sqrt ratio at 100 incorrect"
-        );
-        assert_eq!(
-            get_sqrt_ratio_at_tick(250).unwrap(),
-            U256::from(80224679980005306637834519095u128),
-            "sqrt ratio at 250 incorrect"
-        );
-        assert_eq!(
-            get_sqrt_ratio_at_tick(500).unwrap(),
-            U256::from(81233731461783161732293370115u128),
-            "sqrt ratio at 500 incorrect"
-        );
-        assert_eq!(
-            get_sqrt_ratio_at_tick(1000).unwrap(),
-            U256::from(83290069058676223003182343270u128),
-            "sqrt ratio at 1000 incorrect"
-        );
-        assert_eq!(
-            get_sqrt_ratio_at_tick(2500).unwrap(),
-            U256::from(89776708723587163891445672585u128),
-            "sqrt ratio at 2500 incorrect"
-        );
-        assert_eq!(
-            get_sqrt_ratio_at_tick(3000).unwrap(),
-            U256::from(92049301871182272007977902845u128),
-            "sqrt ratio at 3000 incorrect"
-        );
-        assert_eq!(
-            get_sqrt_ratio_at_tick(4000).unwrap(),
-            U256::from(96768528593268422080558758223u128),
-            "sqrt ratio at 4000 incorrect"
-        );
-        assert_eq!(
-            get_sqrt_ratio_at_tick(5000).unwrap(),
-            U256::from(101729702841318637793976746270u128),
-            "sqrt ratio at 5000 incorrect"
-        );
-        assert_eq!(
-            get_sqrt_ratio_at_tick(50000).unwrap(),
-            U256::from(965075977353221155028623082916u128),
-            "sqrt ratio at 50000 incorrect"
-        );
-        assert_eq!(
-            get_sqrt_ratio_at_tick(150000).unwrap(),
-            U256::from(143194173941309278083010301478497u128),
-            "sqrt ratio at 150000 incorrect"
-        );
-        assert_eq!(
-            get_sqrt_ratio_at_tick(250000).unwrap(),
-            U256::from(21246587762933397357449903968194344u128),
-            "sqrt ratio at 250000 incorrect"
-        );
-        assert_eq!(
-            get_sqrt_ratio_at_tick(500000).unwrap(),
-            U256::from_str("5697689776495288729098254600827762987878").unwrap(),
-            "sqrt ratio at 500000 incorrect"
-        );
-        assert_eq!(
-            get_sqrt_ratio_at_tick(738203).unwrap(),
-            U256::from_str("847134979253254120489401328389043031315994541").unwrap(),
-            "sqrt ratio at 738203 incorrect"
-        );
-    }
-
-    #[test]
-    fn test_get_tick_at_sqrt_ratio() {
-        //throws for too low
-        let result = get_tick_at_sqrt_ratio(MIN_SQRT_RATIO.sub(U256_1));
-        assert_eq!(
-            result.unwrap_err().to_string(),
-            "Second inequality must be < because the price can never reach the price at the max tick"
-        );
-
-        //throws for too high
-        let result = get_tick_at_sqrt_ratio(MAX_SQRT_RATIO);
-        assert_eq!(
-            result.unwrap_err().to_string(),
-            "Second inequality must be < because the price can never reach the price at the max tick"
-        );
-
-        //ratio of min tick
-        let result = get_tick_at_sqrt_ratio(MIN_SQRT_RATIO).unwrap();
-        assert_eq!(result, MIN_TICK);
-
-        //ratio of min tick + 1
-        let result = get_tick_at_sqrt_ratio(U256::from_str("4295343490").unwrap()).unwrap();
-        assert_eq!(result, MIN_TICK + 1);
-    }
-
-    #[test]
-    fn test_roundtrip() {
-        for tick_index in [
-            MIN_TICK + 1, // we can't use extremes because of rounding during roundtrip conversion
-            -1000,
-            -100,
-            -10,
-            -4,
-            -2,
-            0,
-            2,
-            4,
-            10,
-            100,
-            1000,
-            MAX_TICK - 1,
-        ]
-        .iter()
-        {
-            let sqrt_price = get_sqrt_ratio_at_tick(*tick_index).unwrap();
-            let round_trip_tick_index = get_tick_at_sqrt_ratio(sqrt_price).unwrap();
-            assert_eq!(round_trip_tick_index, *tick_index);
-        }
-    }
-
-    #[test]
-    fn test_u256_to_u64f64_q64_96() {
-        // Test tick 0 (sqrt price = 1.0 * 2^96)
-        let tick0_sqrt_price = U256::from(1u128 << 96);
-        let fixed_price = u256_q64_96_to_u64f64(tick0_sqrt_price).unwrap();
-
-        // Should be 1.0 in U64F64
-        assert_eq!(fixed_price, U64F64::from_num(1.0));
-
-        // Round trip back to U256 Q64.96
-        let back_to_u256 = u64f64_to_u256_q64_96(fixed_price);
-        assert_eq!(back_to_u256, tick0_sqrt_price);
-    }
-
-    #[test]
-    fn test_u256_with_other_formats() {
-        // Test with a value that has 32 fractional bits
-        let value_32frac = U256::from(123456789u128 << 32); // 123456789.0 in Q96.32
-        let fixed_value = u256_to_u64f64(value_32frac, 32).unwrap();
-
-        // Should be 123456789.0 in U64F64
-        assert_eq!(fixed_value, U64F64::from_num(123456789.0));
-
-        // Round trip back to U256 with 32 fractional bits
-        let back_to_u256 = u64f64_to_u256(fixed_value, 32);
-        assert_eq!(back_to_u256, value_32frac);
-    }
-}

From cee93edef763a5d440b42827813cd447592437a9 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Fri, 21 Mar 2025 17:26:18 +0100
Subject: [PATCH 024/418] Init pallet implementation for swap

---
 Cargo.lock                     |   6 ++
 pallets/swap/Cargo.toml        |  13 +++++
 pallets/swap/src/error.rs      |  26 ---------
 pallets/swap/src/lib.rs        |  46 ++++++++++++---
 pallets/swap/src/pallet/mod.rs | 104 +++++++++++++++++++++++++++++++++
 pallets/swap/src/tick.rs       |  22 ++++---
 6 files changed, 173 insertions(+), 44 deletions(-)
 delete mode 100644 pallets/swap/src/error.rs
 create mode 100644 pallets/swap/src/pallet/mod.rs

diff --git a/Cargo.lock b/Cargo.lock
index d6eb890244..226fa3f722 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6840,9 +6840,15 @@ version = "0.1.0"
 dependencies = [
  "alloy-primitives",
  "approx",
+ "frame-support",
+ "frame-system",
  "pallet-subtensor-swap-interface",
+ "parity-scale-codec",
  "safe-math",
+ "scale-info",
+ "serde",
  "sp-arithmetic",
+ "sp-runtime",
  "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409)",
  "substrate-fixed",
 ]
diff --git a/pallets/swap/Cargo.toml b/pallets/swap/Cargo.toml
index 362ed0e429..b00c268aa6 100644
--- a/pallets/swap/Cargo.toml
+++ b/pallets/swap/Cargo.toml
@@ -6,8 +6,14 @@ edition = { workspace = true }
 [dependencies]
 alloy-primitives = { workspace = true }
 approx = { workspace = true }
+codec = {workspace = true }
+frame-support = { workspace = true }
+frame-system = { workspace = true }
 safe-math = { workspace = true }
+scale-info = { workspace = true }
+serde = { workspace = true, optional = true }
 sp-arithmetic = { workspace = true }
+sp-runtime = { workspace = true }
 sp-std = { workspace = true }
 substrate-fixed = { workspace = true }
 
@@ -20,8 +26,15 @@ workspace = true
 default = ["std"]
 std = [
 	"alloy-primitives/std",
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"pallet-subtensor-swap-interface/std",
 	"safe-math/std",
+	"scale-info/std",
+	"serde/std",
 	"sp-arithmetic/std",
+	"sp-runtime/std",
 	"sp-std/std",
 	"substrate-fixed/std",
 ]
diff --git a/pallets/swap/src/error.rs b/pallets/swap/src/error.rs
deleted file mode 100644
index 748f6a740a..0000000000
--- a/pallets/swap/src/error.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-#[derive(Debug, PartialEq, Eq)]
-pub enum SwapError {
-    /// The provided amount is insufficient for the swap.
-    InsufficientInputAmount,
-
-    /// The provided liquidity is insufficient for the operation.
-    InsufficientLiquidity,
-
-    /// The operation would exceed the price limit.
-    PriceLimitExceeded,
-
-    /// The caller does not have enough balance for the operation.
-    InsufficientBalance,
-
-    /// Attempted to remove liquidity that does not exist.
-    LiquidityNotFound,
-
-    /// The provided tick range is invalid.
-    InvalidTickRange,
-
-    /// Maximum user positions exceeded
-    MaxPositionsExceeded,
-
-    /// Too many swap steps
-    TooManySwapSteps,
-}
diff --git a/pallets/swap/src/lib.rs b/pallets/swap/src/lib.rs
index 1e3aaf6379..b119ece267 100644
--- a/pallets/swap/src/lib.rs
+++ b/pallets/swap/src/lib.rs
@@ -1,18 +1,19 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
 use core::marker::PhantomData;
-use std::ops::Neg;
+use core::ops::Neg;
 
 use pallet_subtensor_swap_interface::OrderType;
 use safe_math::*;
 use sp_arithmetic::helpers_128bit::sqrt;
 use substrate_fixed::types::U64F64;
 
-use self::error::SwapError;
 use self::tick::{
-    MAX_TICK_INDEX, MIN_TICK_INDEX, Tick, find_closest_higher_active_tick_index,
+    MAX_TICK_INDEX, MIN_TICK_INDEX, Tick, TickIndex, find_closest_higher_active_tick_index,
     find_closest_lower_active_tick_index, sqrt_price_to_tick_index, tick_index_to_sqrt_price,
 };
 
-mod error;
+pub mod pallet;
 mod tick;
 
 type SqrtPrice = U64F64;
@@ -56,8 +57,8 @@ struct SwapStepResult {
 ///
 #[cfg_attr(test, derive(Debug, PartialEq, Clone))]
 pub struct Position {
-    tick_low: i32,
-    tick_high: i32,
+    tick_low: TickIndex,
+    tick_high: TickIndex,
     liquidity: u64,
     fees_tao: u64,
     fees_alpha: u64,
@@ -132,9 +133,9 @@ pub trait SwapDataOperations<AccountIdType> {
     fn get_fee_rate(&self) -> u16;
     /// Minimum liquidity that is safe for rounding and integer math.
     fn get_minimum_liquidity(&self) -> u64;
-    fn get_tick_by_index(&self, tick_index: i32) -> Option<Tick>;
-    fn insert_tick_by_index(&mut self, tick_index: i32, tick: Tick);
-    fn remove_tick_by_index(&mut self, tick_index: i32);
+    fn get_tick_by_index(&self, tick_index: TickIndex) -> Option<Tick>;
+    fn insert_tick_by_index(&mut self, tick_index: TickIndex, tick: Tick);
+    fn remove_tick_by_index(&mut self, tick_index: TickIndex);
     /// Minimum sqrt price across all active ticks
     fn get_min_sqrt_price(&self) -> SqrtPrice;
     /// Maximum sqrt price across all active ticks
@@ -1101,6 +1102,33 @@ where
     }
 }
 
+#[derive(Debug, PartialEq, Eq)]
+pub enum SwapError {
+    /// The provided amount is insufficient for the swap.
+    InsufficientInputAmount,
+
+    /// The provided liquidity is insufficient for the operation.
+    InsufficientLiquidity,
+
+    /// The operation would exceed the price limit.
+    PriceLimitExceeded,
+
+    /// The caller does not have enough balance for the operation.
+    InsufficientBalance,
+
+    /// Attempted to remove liquidity that does not exist.
+    LiquidityNotFound,
+
+    /// The provided tick range is invalid.
+    InvalidTickRange,
+
+    /// Maximum user positions exceeded
+    MaxPositionsExceeded,
+
+    /// Too many swap steps
+    TooManySwapSteps,
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/pallets/swap/src/pallet/mod.rs b/pallets/swap/src/pallet/mod.rs
new file mode 100644
index 0000000000..d48b8479e3
--- /dev/null
+++ b/pallets/swap/src/pallet/mod.rs
@@ -0,0 +1,104 @@
+use frame_support::{pallet_prelude::*, traits::BuildGenesisConfig};
+use frame_system::pallet_prelude::*;
+use core::marker::PhantomData;
+
+use crate::tick::{Tick, TickIndex};
+
+#[frame_support::pallet]
+pub mod pallet {
+    use super::*;
+
+    #[pallet::pallet]
+    pub struct Pallet<T>(_);
+
+    /// Configure the pallet by specifying the parameters and types on which it depends.
+    #[pallet::config]
+    pub trait Config: frame_system::Config {
+        /// Because this pallet emits events, it depends on the runtime's definition of an event.
+        type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+        /// The origin which may configure the swap parameters
+        type AdminOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+        /// The maximum fee rate that can be set
+        #[pallet::constant]
+        type MaxFeeRate: Get<u16>;
+    }
+
+    /// The fee rate applied to swaps, normalized value between 0 and u16::MAX
+    ///
+    /// For example, 0.3% is approximately 196
+    #[pallet::storage]
+    #[pallet::getter(fn fee_rate)]
+    pub type FeeRate<T> = StorageValue<_, u16, ValueQuery>;
+    
+    /// Storage for all ticks, mapped by tick index
+    #[pallet::storage]
+    #[pallet::getter(fn ticks)]
+    pub type Ticks<T> = StorageMap<_, Twox64Concat, TickIndex, Tick>;
+
+    #[pallet::event]
+    #[pallet::generate_deposit(pub(super) fn deposit_event)]
+    pub enum Event<T: Config> {
+        /// Event emitted when the fee rate has been updated
+        FeeRateSet { rate: u16 },
+    }
+
+    #[pallet::error]
+    pub enum Error<T> {
+        /// The fee rate is too high
+        FeeRateTooHigh,
+    }
+
+    /// Genesis configuration for the swap pallet
+    #[pallet::genesis_config]
+    pub struct GenesisConfig<T: Config> {
+        /// Initial fee rate
+        pub fee_rate: u16,
+        /// Phantom data for unused generic
+        pub _phantom: PhantomData<T>,
+    }
+
+    impl<T: Config> Default for GenesisConfig<T> {
+        fn default() -> Self {
+            Self {
+                fee_rate: 0, // Default to 0% fee
+                _phantom: PhantomData,
+            }
+        }
+    }
+
+    #[pallet::genesis_build]
+    impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+        fn build(&self) {
+            // Ensure the fee rate is within bounds
+            assert!(
+                self.fee_rate <= T::MaxFeeRate::get(),
+                "Fee rate in genesis config is too high"
+            );
+
+            // Set the initial fee rate
+            <FeeRate<T>>::put(self.fee_rate);
+        }
+    }
+
+    #[pallet::call]
+    impl<T: Config> Pallet<T> {
+        /// Set the fee rate for swaps (normalized value). For example, 0.3% is approximately 196.
+        ///
+        /// Only callable by the admin origin
+        #[pallet::call_index(0)]
+        #[pallet::weight(10_000)]
+        pub fn set_fee_rate(origin: OriginFor<T>, rate: u16) -> DispatchResult {
+            T::AdminOrigin::ensure_origin(origin)?;
+
+            ensure!(rate <= T::MaxFeeRate::get(), Error::<T>::FeeRateTooHigh);
+
+            <FeeRate<T>>::put(rate);
+
+            Self::deposit_event(Event::FeeRateSet { rate });
+
+            Ok(())
+        }
+    }
+}
diff --git a/pallets/swap/src/tick.rs b/pallets/swap/src/tick.rs
index 91a1ba05b0..e38ab3d1b0 100644
--- a/pallets/swap/src/tick.rs
+++ b/pallets/swap/src/tick.rs
@@ -5,14 +5,15 @@ use core::ops::{BitOr, Neg, Shl, Shr};
 
 use alloy_primitives::{I256, U256};
 use substrate_fixed::types::U64F64;
+use frame_support::pallet_prelude::*;
 
 use crate::{SqrtPrice, SwapDataOperations};
 
 /// Maximum and minimum values of the tick index
 /// The tick_math library uses different bitness, so we have to divide by 2.
 /// Do not use tick_math::MIN_TICK and tick_math::MAX_TICK
-pub const MAX_TICK_INDEX: i32 = MAX_TICK / 2;
-pub const MIN_TICK_INDEX: i32 = MIN_TICK / 2;
+pub const MAX_TICK_INDEX: TickIndex = MAX_TICK / 2;
+pub const MIN_TICK_INDEX: TickIndex = MIN_TICK / 2;
 
 const U256_1: U256 = U256::from_limbs([1, 0, 0, 0]);
 const U256_2: U256 = U256::from_limbs([2, 0, 0, 0]);
@@ -74,7 +75,10 @@ const TICK_HIGH: I256 = I256::from_raw(U256::from_limbs([
 ///   - Gross liquidity
 ///   - Fees (above global) in both currencies
 ///
-#[derive(Debug, Default, Clone)]
+/// Type alias for tick index used throughout the crate
+pub type TickIndex = i32;
+
+#[derive(Debug, Default, Clone, Encode, Decode, TypeInfo, MaxEncodedLen, PartialEq, Eq)]
 pub struct Tick {
     pub liquidity_net: i128,
     pub liquidity_gross: u64,
@@ -85,7 +89,7 @@ pub struct Tick {
 /// Converts tick index into SQRT of lower price of this tick
 /// In order to find the higher price of this tick, call
 /// tick_index_to_sqrt_price(tick_idx + 1)
-pub fn tick_index_to_sqrt_price(tick_idx: i32) -> Result<SqrtPrice, TickMathError> {
+pub fn tick_index_to_sqrt_price(tick_idx: TickIndex) -> Result<SqrtPrice, TickMathError> {
     // because of u256->u128 conversion we have twice less values for min/max ticks
     if !(MIN_TICK / 2..=MAX_TICK / 2).contains(&tick_idx) {
         return Err(TickMathError::TickOutOfBounds);
@@ -97,7 +101,7 @@ pub fn tick_index_to_sqrt_price(tick_idx: i32) -> Result<SqrtPrice, TickMathErro
 /// Because the tick is the range of prices [sqrt_lower_price, sqrt_higher_price),
 /// the resulting tick index matches the price by the following inequality:
 ///    sqrt_lower_price <= sqrt_price < sqrt_higher_price
-pub fn sqrt_price_to_tick_index(sqrt_price: SqrtPrice) -> Result<i32, TickMathError> {
+pub fn sqrt_price_to_tick_index(sqrt_price: SqrtPrice) -> Result<TickIndex, TickMathError> {
     let tick = get_tick_at_sqrt_ratio(u64f64_to_u256_q64_96(sqrt_price))?;
 
     // Correct for rounding error during conversions between different fixed-point formats
@@ -110,8 +114,8 @@ pub fn sqrt_price_to_tick_index(sqrt_price: SqrtPrice) -> Result<i32, TickMathEr
 
 pub fn find_closest_lower_active_tick_index<Ops, AccountIdType>(
     ops: &Ops,
-    index: i32,
-) -> Option<i32>
+    index: TickIndex,
+) -> Option<TickIndex>
 where
     AccountIdType: Eq,
     Ops: SwapDataOperations<AccountIdType>,
@@ -133,8 +137,8 @@ where
 
 pub fn find_closest_higher_active_tick_index<Ops, AccountIdType>(
     ops: &Ops,
-    index: i32,
-) -> Option<i32>
+    index: TickIndex,
+) -> Option<TickIndex>
 where
     AccountIdType: Eq,
     Ops: SwapDataOperations<AccountIdType>,

From 938a417f0aaa505e6c96de863b53e012b738e360 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Fri, 21 Mar 2025 18:19:40 +0100
Subject: [PATCH 025/418] Strict TickIndex type

---
 pallets/swap/src/lib.rs  | 165 ++++++++++++---------
 pallets/swap/src/tick.rs | 310 +++++++++++++++++++++++++++------------
 2 files changed, 316 insertions(+), 159 deletions(-)

diff --git a/pallets/swap/src/lib.rs b/pallets/swap/src/lib.rs
index b119ece267..9045a1b45e 100644
--- a/pallets/swap/src/lib.rs
+++ b/pallets/swap/src/lib.rs
@@ -9,8 +9,7 @@ use sp_arithmetic::helpers_128bit::sqrt;
 use substrate_fixed::types::U64F64;
 
 use self::tick::{
-    MAX_TICK_INDEX, MIN_TICK_INDEX, Tick, TickIndex, find_closest_higher_active_tick_index,
-    find_closest_lower_active_tick_index, sqrt_price_to_tick_index, tick_index_to_sqrt_price,
+    Tick, TickIndex,
 };
 
 pub mod pallet;
@@ -84,9 +83,9 @@ impl Position {
         let one: U64F64 = U64F64::saturating_from_num(1);
 
         let sqrt_pa: SqrtPrice =
-            tick_index_to_sqrt_price(self.tick_low).map_err(|_| SwapError::InvalidTickRange)?;
+            self.tick_low.try_to_sqrt_price().map_err(|_| SwapError::InvalidTickRange)?;
         let sqrt_pb: SqrtPrice =
-            tick_index_to_sqrt_price(self.tick_high).map_err(|_| SwapError::InvalidTickRange)?;
+            self.tick_high.try_to_sqrt_price().map_err(|_| SwapError::InvalidTickRange)?;
         let liquidity_fixed: U64F64 = U64F64::saturating_from_num(self.liquidity);
 
         Ok(if sqrt_price_curr < sqrt_pa {
@@ -217,7 +216,7 @@ where
             );
 
             // Set initial (protocol owned) liquidity and positions
-            // Protocol liquidity makes one position from MIN_TICK_INDEX to MAX_TICK_INDEX
+            // Protocol liquidity makes one position from TickIndex::MIN to TickIndex::MAX
             // We are using the sp_arithmetic sqrt here, which works for u128
             let liquidity: u64 = sqrt(tao_reserve as u128 * alpha_reserve as u128) as u64;
             let mut swap = Swap {
@@ -227,8 +226,8 @@ where
             let protocol_account_id = swap.state_ops.get_protocol_account_id();
             let _ = swap.add_liquidity(
                 &protocol_account_id,
-                MIN_TICK_INDEX,
-                MAX_TICK_INDEX,
+                TickIndex::MIN,
+                TickIndex::MAX,
                 liquidity,
                 true,
             );
@@ -265,7 +264,7 @@ where
 
     /// Add liquidity at tick index. Creates new tick if it doesn't exist
     ///
-    fn add_liquidity_at_index(&mut self, tick_index: i32, liquidity: u64, upper: bool) {
+    fn add_liquidity_at_index(&mut self, tick_index: TickIndex, liquidity: u64, upper: bool) {
         // Calculate net liquidity addition
         let net_addition = if upper {
             (liquidity as i128).neg()
@@ -295,7 +294,7 @@ where
 
     /// Remove liquidity at tick index.
     ///
-    fn remove_liquidity_at_index(&mut self, tick_index: i32, liquidity: u64, upper: bool) {
+    fn remove_liquidity_at_index(&mut self, tick_index: TickIndex, liquidity: u64, upper: bool) {
         // Calculate net liquidity addition
         let net_reduction = if upper {
             (liquidity as i128).neg()
@@ -353,8 +352,8 @@ where
     pub fn add_liquidity(
         &mut self,
         account_id: &AccountIdType,
-        tick_low: i32,
-        tick_high: i32,
+        tick_low: TickIndex,
+        tick_high: TickIndex,
         liquidity: u64,
         protocol: bool,
     ) -> Result<(), SwapError> {
@@ -585,24 +584,24 @@ where
         })
     }
 
-    fn get_current_tick_index(&mut self) -> i32 {
+    fn get_current_tick_index(&mut self) -> TickIndex {
         let current_price = self.state_ops.get_alpha_sqrt_price();
-        let maybe_current_tick_index = sqrt_price_to_tick_index(current_price);
+        let maybe_current_tick_index = TickIndex::try_from_sqrt_price(current_price);
         if let Ok(index) = maybe_current_tick_index {
             index
         } else {
             // Current price is out of allow the min-max range, and it should be corrected to
             // maintain the range.
-            let max_price = tick_index_to_sqrt_price(MAX_TICK_INDEX)
+            let max_price = TickIndex::MAX.try_to_sqrt_price()
                 .unwrap_or(SqrtPrice::saturating_from_num(1000));
-            let min_price = tick_index_to_sqrt_price(MIN_TICK_INDEX)
+            let min_price = TickIndex::MIN.try_to_sqrt_price()
                 .unwrap_or(SqrtPrice::saturating_from_num(0.000001));
             if current_price > max_price {
                 self.state_ops.set_alpha_sqrt_price(max_price);
-                MAX_TICK_INDEX
+                TickIndex::MAX
             } else {
                 self.state_ops.set_alpha_sqrt_price(min_price);
-                MIN_TICK_INDEX
+                TickIndex::MIN
             }
         }
     }
@@ -698,19 +697,20 @@ where
     ///
     fn get_sqrt_price_edge(&self, order_type: &OrderType) -> SqrtPrice {
         let fallback_price_edge_value = (match order_type {
-            OrderType::Buy => tick_index_to_sqrt_price(MIN_TICK_INDEX),
-            OrderType::Sell => tick_index_to_sqrt_price(MAX_TICK_INDEX),
+            OrderType::Buy => TickIndex::MIN.try_to_sqrt_price(),
+            OrderType::Sell => TickIndex::MAX.try_to_sqrt_price(),
         })
         .unwrap_or(SqrtPrice::saturating_from_num(0));
 
         let current_price = self.state_ops.get_alpha_sqrt_price();
-        let maybe_current_tick_index = sqrt_price_to_tick_index(current_price);
+        let maybe_current_tick_index = TickIndex::try_from_sqrt_price(current_price);
 
         if let Ok(current_tick_index) = maybe_current_tick_index {
-            tick_index_to_sqrt_price(match order_type {
-                OrderType::Buy => current_tick_index.saturating_add(1),
+            match order_type {
+                OrderType::Buy => TickIndex::new_unchecked(current_tick_index.get().saturating_add(1)),
                 OrderType::Sell => current_tick_index,
-            })
+            }
+            .try_to_sqrt_price()
             .unwrap_or(fallback_price_edge_value)
         } else {
             fallback_price_edge_value
@@ -1020,8 +1020,8 @@ where
 
     /// Get fees above a tick
     ///
-    fn get_fees_above(&mut self, tick_index: i32, quote: bool) -> U64F64 {
-        let maybe_tick_index = find_closest_lower_active_tick_index(&self.state_ops, tick_index);
+    fn get_fees_above(&mut self, tick_index: TickIndex, quote: bool) -> U64F64 {
+        let maybe_tick_index = tick_index.find_closest_lower_active(&self.state_ops);
         let current_tick = self.get_current_tick_index();
 
         if let Some(tick_index) = maybe_tick_index {
@@ -1052,8 +1052,8 @@ where
     }
 
     /// Get fees below a tick
-    fn get_fees_below(&mut self, tick_index: i32, quote: bool) -> U64F64 {
-        let maybe_tick_index = find_closest_lower_active_tick_index(&self.state_ops, tick_index);
+    fn get_fees_below(&mut self, tick_index: TickIndex, quote: bool) -> U64F64 {
+        let maybe_tick_index = tick_index.find_closest_lower_active(&self.state_ops);
         let current_tick = self.get_current_tick_index();
 
         if let Some(tick_index) = maybe_tick_index {
@@ -1083,8 +1083,8 @@ where
         }
     }
 
-    pub fn find_closest_lower_active_tick(&self, index: i32) -> Option<Tick> {
-        let maybe_tick_index = find_closest_lower_active_tick_index(&self.state_ops, index);
+    pub fn find_closest_lower_active_tick(&self, index: TickIndex) -> Option<Tick> {
+        let maybe_tick_index = index.find_closest_lower_active(&self.state_ops);
         if let Some(tick_index) = maybe_tick_index {
             self.state_ops.get_tick_by_index(tick_index)
         } else {
@@ -1092,8 +1092,8 @@ where
         }
     }
 
-    pub fn find_closest_higher_active_tick(&self, index: i32) -> Option<Tick> {
-        let maybe_tick_index = find_closest_higher_active_tick_index(&self.state_ops, index);
+    pub fn find_closest_higher_active_tick(&self, index: TickIndex) -> Option<Tick> {
+        let maybe_tick_index = index.find_closest_higher_active(&self.state_ops);
         if let Some(tick_index) = maybe_tick_index {
             self.state_ops.get_tick_by_index(tick_index)
         } else {
@@ -1141,7 +1141,7 @@ mod tests {
         is_initialized: bool,
         fee_rate: u16,
         minimum_liquidity: u64,
-        ticks: HashMap<i32, Tick>,
+        ticks: HashMap<TickIndex, Tick>,
         min_sqrt_price: SqrtPrice,
         max_sqrt_price: SqrtPrice,
         tao_reserve: u64,
@@ -1194,15 +1194,15 @@ mod tests {
             self.minimum_liquidity
         }
 
-        fn get_tick_by_index(&self, tick_index: i32) -> Option<Tick> {
+        fn get_tick_by_index(&self, tick_index: TickIndex) -> Option<Tick> {
             self.ticks.get(&tick_index).cloned()
         }
 
-        fn insert_tick_by_index(&mut self, tick_index: i32, tick: Tick) {
+        fn insert_tick_by_index(&mut self, tick_index: TickIndex, tick: Tick) {
             self.ticks.insert(tick_index, tick);
         }
 
-        fn remove_tick_by_index(&mut self, tick_index: i32) {
+        fn remove_tick_by_index(&mut self, tick_index: TickIndex) {
             self.ticks.remove(&tick_index);
         }
 
@@ -1347,8 +1347,8 @@ mod tests {
         let swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
 
         // Active ticks
-        let tick_low = swap.state_ops.get_tick_by_index(MIN_TICK_INDEX).unwrap();
-        let tick_high = swap.state_ops.get_tick_by_index(MAX_TICK_INDEX).unwrap();
+        let tick_low = swap.state_ops.get_tick_by_index(TickIndex::MIN).unwrap();
+        let tick_high = swap.state_ops.get_tick_by_index(TickIndex::MAX).unwrap();
         let liquidity = sqrt(alpha as u128 * tao as u128) as u64;
         let expected_liquidity_net_low: i128 = liquidity as i128;
         let expected_liquidity_gross_low: u64 = liquidity;
@@ -1365,8 +1365,8 @@ mod tests {
 
         let position = swap.state_ops.get_position(&account_id, 0).unwrap();
         assert_eq!(position.liquidity, liquidity);
-        assert_eq!(position.tick_low, MIN_TICK_INDEX);
-        assert_eq!(position.tick_high, MAX_TICK_INDEX);
+        assert_eq!(position.tick_low, TickIndex::MIN);
+        assert_eq!(position.tick_high, TickIndex::MAX);
         assert_eq!(position.fees_alpha, 0);
         assert_eq!(position.fees_tao, 0);
 
@@ -1378,24 +1378,49 @@ mod tests {
         assert_abs_diff_eq!(sqrt_price.to_num::<f64>(), 0.50, epsilon = 0.00001,);
     }
 
-    fn price_to_tick(price: f64) -> i32 {
+    fn price_to_tick(price: f64) -> TickIndex {
         let price_sqrt: SqrtPrice = SqrtPrice::from_num(price.sqrt());
-        let mut tick = sqrt_price_to_tick_index(price_sqrt).unwrap();
-        if tick > MAX_TICK_INDEX {
-            tick = MAX_TICK_INDEX
+        // Handle potential errors in the conversion
+        match TickIndex::try_from_sqrt_price(price_sqrt) {
+            Ok(mut tick) => {
+                // Ensure the tick is within bounds
+                if tick > TickIndex::MAX {
+                    tick = TickIndex::MAX;
+                } else if tick < TickIndex::MIN {
+                    tick = TickIndex::MIN;
+                }
+                tick
+            },
+            // Default to a reasonable value when conversion fails
+            Err(_) => {
+                if price > 1.0 {
+                    TickIndex::MAX
+                } else {
+                    TickIndex::MIN
+                }
+            }
         }
-        tick
     }
 
-    fn tick_to_price(tick: i32) -> f64 {
-        let price_sqrt: SqrtPrice = tick_index_to_sqrt_price(tick).unwrap();
-        (price_sqrt * price_sqrt).to_num::<f64>()
+    fn tick_to_price(tick: TickIndex) -> f64 {
+        // Handle errors gracefully
+        match tick.try_to_sqrt_price() {
+            Ok(price_sqrt) => (price_sqrt * price_sqrt).to_num::<f64>(),
+            Err(_) => {
+                // Return a sensible default based on whether the tick is above or below the valid range
+                if tick > TickIndex::MAX {
+                    tick_to_price(TickIndex::MAX) // Use the max valid tick price
+                } else {
+                    tick_to_price(TickIndex::MIN) // Use the min valid tick price
+                }
+            }
+        }
     }
 
     #[test]
     fn test_tick_price_sanity_check() {
-        let min_price = tick_to_price(MIN_TICK_INDEX);
-        let max_price = tick_to_price(MAX_TICK_INDEX);
+        let min_price = tick_to_price(TickIndex::MIN);
+        let max_price = tick_to_price(TickIndex::MAX);
         assert!(min_price > 0.);
         assert!(max_price > 0.);
         assert!(max_price > min_price);
@@ -1403,13 +1428,13 @@ mod tests {
         assert!(max_price > 10.);
 
         // Roundtrip conversions
-        let min_price_sqrt: SqrtPrice = tick_index_to_sqrt_price(MIN_TICK_INDEX).unwrap();
-        let min_tick = sqrt_price_to_tick_index(min_price_sqrt).unwrap();
-        assert_eq!(min_tick, MIN_TICK_INDEX);
+        let min_price_sqrt: SqrtPrice = TickIndex::MIN.try_to_sqrt_price().unwrap();
+        let min_tick = TickIndex::try_from_sqrt_price(min_price_sqrt).unwrap();
+        assert_eq!(min_tick, TickIndex::MIN);
 
-        let max_price_sqrt: SqrtPrice = tick_index_to_sqrt_price(MAX_TICK_INDEX).unwrap();
-        let max_tick = sqrt_price_to_tick_index(max_price_sqrt).unwrap();
-        assert_eq!(max_tick, MAX_TICK_INDEX);
+        let max_price_sqrt: SqrtPrice = TickIndex::MAX.try_to_sqrt_price().unwrap();
+        let max_tick = TickIndex::try_from_sqrt_price(max_price_sqrt).unwrap();
+        assert_eq!(max_tick, TickIndex::MAX);
     }
 
     // Test adding liquidity on top of the existing protocol liquidity
@@ -1420,11 +1445,11 @@ mod tests {
         let user_tao = 100_000_000_000;
         let user_alpha = 100_000_000_000;
         let account_id = 1;
-        let min_price = tick_to_price(MIN_TICK_INDEX);
-        let max_price = tick_to_price(MAX_TICK_INDEX);
+        let min_price = tick_to_price(TickIndex::MIN);
+        let max_price = tick_to_price(TickIndex::MAX);
         let max_tick = price_to_tick(max_price);
         let current_price = 0.25;
-        assert_eq!(max_tick, MAX_TICK_INDEX);
+        assert_eq!(max_tick, TickIndex::MAX);
 
         // As a user add liquidity with all possible corner cases
         //   - Initial price is 0.25
@@ -1553,12 +1578,14 @@ mod tests {
         let account_id = 1;
 
         [
-            (MIN_TICK_INDEX - 1, MAX_TICK_INDEX, 1_000_000_000_u64),
-            (MIN_TICK_INDEX, MAX_TICK_INDEX + 1, 1_000_000_000_u64),
-            (MIN_TICK_INDEX - 1, MAX_TICK_INDEX + 1, 1_000_000_000_u64),
+            // For our tests, we'll construct TickIndex values that are intentionally
+            // outside the valid range for testing purposes only
+            (TickIndex::new_unchecked(TickIndex::MIN.get() - 1), TickIndex::MAX, 1_000_000_000_u64),
+            (TickIndex::MIN, TickIndex::new_unchecked(TickIndex::MAX.get() + 1), 1_000_000_000_u64),
+            (TickIndex::new_unchecked(TickIndex::MIN.get() - 1), TickIndex::new_unchecked(TickIndex::MAX.get() + 1), 1_000_000_000_u64),
             (
-                MIN_TICK_INDEX - 100,
-                MAX_TICK_INDEX + 100,
+                TickIndex::new_unchecked(TickIndex::MIN.get() - 100),
+                TickIndex::new_unchecked(TickIndex::MAX.get() + 100),
                 1_000_000_000_u64,
             ),
         ]
@@ -1624,10 +1651,10 @@ mod tests {
         let user_tao = 100_000_000_000;
         let user_alpha = 100_000_000_000;
         let account_id = 1;
-        let min_price = tick_to_price(MIN_TICK_INDEX);
-        let max_price = tick_to_price(MAX_TICK_INDEX);
+        let min_price = tick_to_price(TickIndex::MIN);
+        let max_price = tick_to_price(TickIndex::MAX);
         let max_tick = price_to_tick(max_price);
-        assert_eq!(max_tick, MAX_TICK_INDEX);
+        assert_eq!(max_tick, TickIndex::MAX);
 
         // As a user add liquidity with all possible corner cases
         //   - Initial price is 0.25
@@ -1706,10 +1733,10 @@ mod tests {
         let user_tao = 100_000_000_000;
         let user_alpha = 100_000_000_000;
         let account_id = 1;
-        let min_price = tick_to_price(MIN_TICK_INDEX);
-        let max_price = tick_to_price(MAX_TICK_INDEX);
+        let min_price = tick_to_price(TickIndex::MIN);
+        let max_price = tick_to_price(TickIndex::MAX);
         let max_tick = price_to_tick(max_price);
-        assert_eq!(max_tick, MAX_TICK_INDEX);
+        assert_eq!(max_tick.get(), TickIndex::MAX.get());
 
         // Test case is (price_low, price_high, liquidity)
         [
diff --git a/pallets/swap/src/tick.rs b/pallets/swap/src/tick.rs
index e38ab3d1b0..902a2191f7 100644
--- a/pallets/swap/src/tick.rs
+++ b/pallets/swap/src/tick.rs
@@ -1,20 +1,15 @@
 //! The math is adapted from github.com/0xKitsune/uniswap-v3-math
+use core::convert::TryFrom;
 use core::error::Error;
 use core::fmt;
 use core::ops::{BitOr, Neg, Shl, Shr};
 
 use alloy_primitives::{I256, U256};
-use substrate_fixed::types::U64F64;
 use frame_support::pallet_prelude::*;
+use substrate_fixed::types::U64F64;
 
 use crate::{SqrtPrice, SwapDataOperations};
 
-/// Maximum and minimum values of the tick index
-/// The tick_math library uses different bitness, so we have to divide by 2.
-/// Do not use tick_math::MIN_TICK and tick_math::MAX_TICK
-pub const MAX_TICK_INDEX: TickIndex = MAX_TICK / 2;
-pub const MIN_TICK_INDEX: TickIndex = MIN_TICK / 2;
-
 const U256_1: U256 = U256::from_limbs([1, 0, 0, 0]);
 const U256_2: U256 = U256::from_limbs([2, 0, 0, 0]);
 const U256_3: U256 = U256::from_limbs([3, 0, 0, 0]);
@@ -67,16 +62,14 @@ const TICK_HIGH: I256 = I256::from_raw(U256::from_limbs([
     0,
 ]));
 
-/// Tick is the price range determined by tick index (not part of this struct,
-/// but is the key at which the Tick is stored in state hash maps). Tick struct
-/// stores liquidity and fee information.
-///
-///   - Net liquidity
-///   - Gross liquidity
-///   - Fees (above global) in both currencies
+/// Tick is the price range determined by tick index (not part of this struct, but is the key at
+/// which the Tick is stored in state hash maps). Tick struct stores liquidity and fee information.
 ///
-/// Type alias for tick index used throughout the crate
-pub type TickIndex = i32;
+///  - Net liquidity
+///  - Gross liquidity
+///  - Fees (above global) in both currencies
+use core::hash::Hash;
+use core::ops::{Add, AddAssign, Deref, Sub, SubAssign};
 
 #[derive(Debug, Default, Clone, Encode, Decode, TypeInfo, MaxEncodedLen, PartialEq, Eq)]
 pub struct Tick {
@@ -86,75 +79,211 @@ pub struct Tick {
     pub fees_out_alpha: U64F64,
 }
 
-/// Converts tick index into SQRT of lower price of this tick
-/// In order to find the higher price of this tick, call
-/// tick_index_to_sqrt_price(tick_idx + 1)
-pub fn tick_index_to_sqrt_price(tick_idx: TickIndex) -> Result<SqrtPrice, TickMathError> {
-    // because of u256->u128 conversion we have twice less values for min/max ticks
-    if !(MIN_TICK / 2..=MAX_TICK / 2).contains(&tick_idx) {
-        return Err(TickMathError::TickOutOfBounds);
+/// Struct representing a tick index
+#[derive(
+    Debug,
+    Default,
+    Clone,
+    Copy,
+    Encode,
+    Decode,
+    TypeInfo,
+    MaxEncodedLen,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Hash,
+)]
+pub struct TickIndex(i32);
+
+impl Add<TickIndex> for TickIndex {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        // Note: This assumes the result is within bounds.
+        // For a safer implementation, consider using checked_add.
+        Self::new_unchecked(self.get() + rhs.get())
     }
-    get_sqrt_ratio_at_tick(tick_idx).and_then(u256_q64_96_to_u64f64)
 }
 
-/// Converts SQRT price to tick index
-/// Because the tick is the range of prices [sqrt_lower_price, sqrt_higher_price),
-/// the resulting tick index matches the price by the following inequality:
-///    sqrt_lower_price <= sqrt_price < sqrt_higher_price
-pub fn sqrt_price_to_tick_index(sqrt_price: SqrtPrice) -> Result<TickIndex, TickMathError> {
-    let tick = get_tick_at_sqrt_ratio(u64f64_to_u256_q64_96(sqrt_price))?;
+impl Sub<TickIndex> for TickIndex {
+    type Output = Self;
 
-    // Correct for rounding error during conversions between different fixed-point formats
-    Ok(if tick == 0 {
-        tick
-    } else {
-        tick.saturating_add(1)
-    })
+    fn sub(self, rhs: Self) -> Self::Output {
+        // Note: This assumes the result is within bounds.
+        // For a safer implementation, consider using checked_sub.
+        Self::new_unchecked(self.get() - rhs.get())
+    }
 }
 
-pub fn find_closest_lower_active_tick_index<Ops, AccountIdType>(
-    ops: &Ops,
-    index: TickIndex,
-) -> Option<TickIndex>
-where
-    AccountIdType: Eq,
-    Ops: SwapDataOperations<AccountIdType>,
-{
-    // TODO: Implement without iteration
-    let mut current_index = index;
-    loop {
-        if current_index < MIN_TICK {
-            return None;
-        }
-        if ops.get_tick_by_index(current_index).is_some() {
-            return Some(current_index);
-        }
+impl AddAssign<TickIndex> for TickIndex {
+    fn add_assign(&mut self, rhs: Self) {
+        *self = Self::new_unchecked(self.get() + rhs.get());
+    }
+}
 
-        // Intentionally using unsafe math here to trigger CI
-        current_index -= 1;
+impl SubAssign<TickIndex> for TickIndex {
+    fn sub_assign(&mut self, rhs: Self) {
+        *self = Self::new_unchecked(self.get() - rhs.get());
     }
 }
 
-pub fn find_closest_higher_active_tick_index<Ops, AccountIdType>(
-    ops: &Ops,
-    index: TickIndex,
-) -> Option<TickIndex>
-where
-    AccountIdType: Eq,
-    Ops: SwapDataOperations<AccountIdType>,
-{
-    // TODO: Implement without iteration
-    let mut current_index = index;
-    loop {
-        if current_index > MAX_TICK {
-            return None;
+impl TryFrom<i32> for TickIndex {
+    type Error = TickMathError;
+
+    fn try_from(value: i32) -> Result<Self, Self::Error> {
+        Self::new(value)
+    }
+}
+
+impl Deref for TickIndex {
+    type Target = i32;
+
+    fn deref(&self) -> &Self::Target {
+        // Using get() would create an infinite recursion, so this is one place where we need direct
+        // field access. This is safe because Self::Target is i32, which is exactly what we're
+        // storing
+        &self.0
+    }
+}
+
+/// Extension trait to make working with TryFrom more ergonomic
+pub trait TryIntoTickIndex {
+    /// Convert an i32 into a TickIndex, with bounds checking
+    fn into_tick_index(self) -> Result<TickIndex, TickMathError>;
+}
+
+impl TryIntoTickIndex for i32 {
+    fn into_tick_index(self) -> Result<TickIndex, TickMathError> {
+        TickIndex::try_from(self)
+    }
+}
+
+impl TickIndex {
+    /// Maximum value of the tick index
+    /// The tick_math library uses different bitness, so we have to divide by 2.
+    pub const MAX: Self = Self(MAX_TICK / 2);
+
+    /// Minimum value of the tick index
+    /// The tick_math library uses different bitness, so we have to divide by 2.
+    pub const MIN: Self = Self(MIN_TICK / 2);
+
+    /// Creates a new TickIndex instance with bounds checking
+    pub fn new(value: i32) -> Result<Self, TickMathError> {
+        if !(Self::MIN.0..=Self::MAX.0).contains(&value) {
+            Err(TickMathError::TickOutOfBounds)
+        } else {
+            Ok(Self(value))
+        }
+    }
+
+    /// Creates a new TickIndex without bounds checking
+    /// Use this function with caution, only when you're certain the value is valid
+    pub fn new_unchecked(value: i32) -> Self {
+        Self(value)
+    }
+
+    /// Get the inner value
+    pub fn get(&self) -> i32 {
+        self.0
+    }
+
+    /// Get the next tick index (incrementing by 1)
+    pub fn next(&self) -> Result<Self, TickMathError> {
+        Self::new(self.0 + 1)
+    }
+
+    /// Get the previous tick index (decrementing by 1)
+    pub fn prev(&self) -> Result<Self, TickMathError> {
+        Self::new(self.0 - 1)
+    }
+
+    /// Add a value to this tick index with bounds checking
+    pub fn checked_add(&self, value: i32) -> Result<Self, TickMathError> {
+        Self::new(self.0 + value)
+    }
+
+    /// Subtract a value from this tick index with bounds checking
+    pub fn checked_sub(&self, value: i32) -> Result<Self, TickMathError> {
+        Self::new(self.0 - value)
+    }
+
+    /// Converts tick index into SQRT of lower price of this tick
+    /// In order to find the higher price of this tick, call
+    /// tick_index_to_sqrt_price(tick_idx + 1)
+    pub fn try_to_sqrt_price(&self) -> Result<SqrtPrice, TickMathError> {
+        // because of u256->u128 conversion we have twice less values for min/max ticks
+        if !(Self::MIN..=Self::MAX).contains(self) {
+            return Err(TickMathError::TickOutOfBounds);
         }
-        if ops.get_tick_by_index(current_index).is_some() {
-            return Some(current_index);
+        get_sqrt_ratio_at_tick(self.0).and_then(u256_q64_96_to_u64f64)
+    }
+
+    /// Converts SQRT price to tick index
+    /// Because the tick is the range of prices [sqrt_lower_price, sqrt_higher_price),
+    /// the resulting tick index matches the price by the following inequality:
+    ///    sqrt_lower_price <= sqrt_price < sqrt_higher_price
+    pub fn try_from_sqrt_price(sqrt_price: SqrtPrice) -> Result<Self, TickMathError> {
+        let tick = get_tick_at_sqrt_ratio(u64f64_to_u256_q64_96(sqrt_price))?;
+
+        // Correct for rounding error during conversions between different fixed-point formats
+        if tick == 0 {
+            Ok(Self(tick))
+        } else {
+            match (tick + 1).into_tick_index() {
+                Ok(incremented) => Ok(incremented),
+                Err(e) => Err(e),
+            }
         }
+    }
 
-        // Intentionally using unsafe math here to trigger CI
-        current_index += 1;
+    /// Find the closest lower active tick index
+    pub fn find_closest_lower_active<Ops, AccountIdType>(&self, ops: &Ops) -> Option<Self>
+    where
+        AccountIdType: Eq,
+        Ops: SwapDataOperations<AccountIdType>,
+    {
+        // TODO: Implement without iteration
+        let mut current_index = *self;
+        loop {
+            if current_index.get() < Self::MIN.get() {
+                return None;
+            }
+            if ops.get_tick_by_index(current_index).is_some() {
+                return Some(current_index);
+            }
+
+            // Create a new index with value one less
+            match current_index.prev() {
+                Ok(next_index) => current_index = next_index,
+                Err(_) => return None, // Return None if we go out of bounds
+            }
+        }
+    }
+
+    /// Find the closest higher active tick index
+    pub fn find_closest_higher_active<Ops, AccountIdType>(&self, ops: &Ops) -> Option<Self>
+    where
+        AccountIdType: Eq,
+        Ops: SwapDataOperations<AccountIdType>,
+    {
+        // TODO: Implement without iteration
+        let mut current_index = *self;
+        loop {
+            if current_index.get() > Self::MAX.get() {
+                return None;
+            }
+            if ops.get_tick_by_index(current_index).is_some() {
+                return Some(current_index);
+            }
+
+            // Create a new index with value one more
+            match current_index.next() {
+                Ok(next_index) => current_index = next_index,
+                Err(_) => return None, // Return None if we go out of bounds
+            }
+        }
     }
 }
 
@@ -642,29 +771,29 @@ mod tests {
 
         // check tick bounds
         assert_eq!(
-            tick_index_to_sqrt_price(MIN_TICK),
+            TickIndex(MIN_TICK).try_to_sqrt_price(),
             Err(TickMathError::TickOutOfBounds)
         );
 
         assert_eq!(
-            tick_index_to_sqrt_price(MAX_TICK),
+            TickIndex(MAX_TICK).try_to_sqrt_price(),
             Err(TickMathError::TickOutOfBounds),
         );
 
         // At tick index 0, the sqrt price should be 1.0
-        let sqrt_price = tick_index_to_sqrt_price(0).unwrap();
+        let sqrt_price = TickIndex(0).try_to_sqrt_price().unwrap();
         assert_eq!(sqrt_price, SqrtPrice::from_num(1.0));
 
-        let sqrt_price = tick_index_to_sqrt_price(2).unwrap();
+        let sqrt_price = TickIndex(2).try_to_sqrt_price().unwrap();
         assert!(sqrt_price.abs_diff(tick_spacing) < SqrtPrice::from_num(1e-10));
 
-        let sqrt_price = tick_index_to_sqrt_price(4).unwrap();
+        let sqrt_price = TickIndex(4).try_to_sqrt_price().unwrap();
         // Calculate the expected value: (1 + TICK_SPACING/1e9 + 1.0)^2
         let expected = tick_spacing * tick_spacing;
         assert!(sqrt_price.abs_diff(expected) < SqrtPrice::from_num(1e-10));
 
         // Test with tick index 10
-        let sqrt_price = tick_index_to_sqrt_price(10).unwrap();
+        let sqrt_price = TickIndex(10).try_to_sqrt_price().unwrap();
         // Calculate the expected value: (1 + TICK_SPACING/1e9 + 1.0)^5
         let expected = tick_spacing.checked_pow(5).unwrap();
         assert!(
@@ -677,27 +806,27 @@ mod tests {
     #[test]
     fn test_sqrt_price_to_tick_index() {
         let tick_spacing = SqrtPrice::from_num(1.0001);
-        let tick_index = sqrt_price_to_tick_index(SqrtPrice::from_num(1.0)).unwrap();
-        assert_eq!(tick_index, 0);
+        let tick_index = TickIndex::try_from_sqrt_price(SqrtPrice::from_num(1.0)).unwrap();
+        assert_eq!(tick_index, TickIndex::new_unchecked(0));
 
         // Test with sqrt price equal to tick_spacing_tao (should be tick index 2)
-        let tick_index = sqrt_price_to_tick_index(tick_spacing).unwrap();
-        assert_eq!(tick_index, 2);
+        let tick_index = TickIndex::try_from_sqrt_price(tick_spacing).unwrap();
+        assert_eq!(tick_index, TickIndex::new_unchecked(2));
 
         // Test with sqrt price equal to tick_spacing_tao^2 (should be tick index 4)
         let sqrt_price = tick_spacing * tick_spacing;
-        let tick_index = sqrt_price_to_tick_index(sqrt_price).unwrap();
-        assert_eq!(tick_index, 4);
+        let tick_index = TickIndex::try_from_sqrt_price(sqrt_price).unwrap();
+        assert_eq!(tick_index, TickIndex::new_unchecked(4));
 
         // Test with sqrt price equal to tick_spacing_tao^5 (should be tick index 10)
         let sqrt_price = tick_spacing.checked_pow(5).unwrap();
-        let tick_index = sqrt_price_to_tick_index(sqrt_price).unwrap();
-        assert_eq!(tick_index, 10);
+        let tick_index = TickIndex::try_from_sqrt_price(sqrt_price).unwrap();
+        assert_eq!(tick_index, TickIndex::new_unchecked(10));
     }
 
     #[test]
     fn test_roundtrip_tick_index_sqrt_price() {
-        for tick_index in [
+        for i32_value in [
             MIN_TICK / 2,
             -1000,
             -100,
@@ -714,9 +843,10 @@ mod tests {
         ]
         .iter()
         {
-            let sqrt_price = tick_index_to_sqrt_price(*tick_index).unwrap();
-            let round_trip_tick_index = sqrt_price_to_tick_index(sqrt_price).unwrap();
-            assert_eq!(round_trip_tick_index, *tick_index);
+            let tick_index = TickIndex(*i32_value);
+            let sqrt_price = tick_index.try_to_sqrt_price().unwrap();
+            let round_trip_tick_index = TickIndex::try_from_sqrt_price(sqrt_price).unwrap();
+            assert_eq!(round_trip_tick_index, tick_index);
         }
     }
 }

From f6f568d50bc13eff225f93d53e172ba930b9ac25 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Tue, 25 Mar 2025 14:55:10 +0100
Subject: [PATCH 026/418] Add Pallet::add_liquidity related implementations

---
 pallets/swap-interface/src/lib.rs |   8 +-
 pallets/swap/src/lib.rs           |  12 +-
 pallets/swap/src/pallet/impls.rs  | 207 ++++++++++++++++++++++++++++++
 pallets/swap/src/pallet/mod.rs    | 122 ++++++++++++------
 pallets/swap/src/tick.rs          |  53 +++++++-
 5 files changed, 347 insertions(+), 55 deletions(-)
 create mode 100644 pallets/swap/src/pallet/impls.rs

diff --git a/pallets/swap-interface/src/lib.rs b/pallets/swap-interface/src/lib.rs
index a5dd7f415e..6a96af3e34 100644
--- a/pallets/swap-interface/src/lib.rs
+++ b/pallets/swap-interface/src/lib.rs
@@ -17,7 +17,9 @@ pub trait SwapHandler<AccountId> {
     fn remove_liquidity(account_id: AccountId) -> Result<(), Box<dyn Error>>;
 }
 
-pub trait LiquidityDataProvider<First, Second> {
-    fn first_reserve() -> First;
-    fn second_reserve() -> Second;
+pub trait LiquidityDataProvider {
+    fn tao_reserve() -> u64;
+    fn set_tao_reserve() -> u64;
+    fn alpha_reserve() -> u64;
+    fn set_alpha_reserve() -> u64;
 }
diff --git a/pallets/swap/src/lib.rs b/pallets/swap/src/lib.rs
index 9045a1b45e..3082c9b114 100644
--- a/pallets/swap/src/lib.rs
+++ b/pallets/swap/src/lib.rs
@@ -7,6 +7,7 @@ use pallet_subtensor_swap_interface::OrderType;
 use safe_math::*;
 use sp_arithmetic::helpers_128bit::sqrt;
 use substrate_fixed::types::U64F64;
+use frame_support::pallet_prelude::*;
 
 use self::tick::{
     Tick, TickIndex,
@@ -55,12 +56,13 @@ struct SwapStepResult {
 /// fees_alpha - fees accrued by the position in base currency (Alpha)
 ///
 #[cfg_attr(test, derive(Debug, PartialEq, Clone))]
+#[derive(Clone, Encode, Decode, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen, Default)]
 pub struct Position {
-    tick_low: TickIndex,
-    tick_high: TickIndex,
-    liquidity: u64,
-    fees_tao: u64,
-    fees_alpha: u64,
+    pub tick_low: TickIndex,
+    pub tick_high: TickIndex,
+    pub liquidity: u64,
+    pub fees_tao: u64,
+    pub fees_alpha: u64,
 }
 
 impl Position {
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
new file mode 100644
index 0000000000..beb93440ae
--- /dev/null
+++ b/pallets/swap/src/pallet/impls.rs
@@ -0,0 +1,207 @@
+use frame_support::{ensure, traits::Get};
+use pallet_subtensor_swap_interface::LiquidityDataProvider;
+use safe_math::*;
+use sp_arithmetic::helpers_128bit;
+use sp_runtime::traits::AccountIdConversion;
+use substrate_fixed::types::U64F64;
+
+use super::pallet::*;
+use crate::tick::{Tick, TickIndex};
+
+impl<T: Config> Pallet<T> {
+    // initializes V3 swap for a subnet
+    fn maybe_initialize_v3(netuid: u16) -> Result<(), Error<T>> {
+        if SwapV3Initialized::<T>::get(netuid) {
+            return Ok(());
+        }
+
+        // Initialize the v3:
+        // Reserves are re-purposed, nothing to set, just query values for liquidity and price calculation
+        let tao_reserve = <T as Config>::LiquidityDataProvider::tao_reserve();
+        let alpha_reserve = <T as Config>::LiquidityDataProvider::alpha_reserve();
+
+        // Set price
+        let price = U64F64::saturating_from_num(tao_reserve)
+            .safe_div(U64F64::saturating_from_num(alpha_reserve));
+
+        let epsilon = U64F64::saturating_from_num(0.000001);
+
+        AlphaSqrtPrice::<T>::set(
+            netuid,
+            price.checked_sqrt(epsilon).unwrap_or(U64F64::from_num(0)),
+        );
+
+        // Set initial (protocol owned) liquidity and positions
+        // Protocol liquidity makes one position from TickIndex::MIN to TickIndex::MAX
+        // We are using the sp_arithmetic sqrt here, which works for u128
+        let liquidity = helpers_128bit::sqrt(tao_reserve as u128 * alpha_reserve as u128) as u64;
+        let protocol_account_id = T::ProtocolId::get().into_account_truncating();
+
+        Self::add_liquidity(
+            netuid,
+            &protocol_account_id,
+            TickIndex::MIN,
+            TickIndex::MAX,
+            liquidity,
+            true,
+        )?;
+
+        Ok(())
+    }
+
+    /// Adds liquidity to the specified price range.
+    ///
+    /// This function allows an account to provide liquidity to a given range of price ticks. The
+    /// amount of liquidity to be added can be determined using
+    /// [`get_tao_based_liquidity`] and [`get_alpha_based_liquidity`], which compute the required
+    /// liquidity based on TAO and Alpha balances for the current price tick.
+    ///
+    /// ### Behavior:
+    /// - If the `protocol` flag is **not set** (`false`), the function will attempt to
+    ///   **withdraw balances** from the account using `state_ops.withdraw_balances()`.
+    /// - If the `protocol` flag is **set** (`true`), the liquidity is added without modifying balances.
+    /// - If swap V3 was not initialized before, updates the value in storage.
+    ///
+    /// ### Parameters:
+    /// - `account_id`: A reference to the account that is providing liquidity.
+    /// - `tick_low`: The lower bound of the price tick range.
+    /// - `tick_high`: The upper bound of the price tick range.
+    /// - `liquidity`: The amount of liquidity to be added.
+    /// - `protocol`: A boolean flag indicating whether the operation is protocol-managed:
+    ///   - `true` -> Do not use this value outside of this implementation. Liquidity is added **without**
+    ///               withdrawing balances.
+    ///   - `false` -> Use this value for all user transactions. Liquidity is added
+    ///               **after withdrawing balances**.
+    ///
+    /// ### Returns:
+    /// - `Ok(u64)`: The final liquidity amount added.
+    /// - `Err(SwapError)`: If the operation fails due to insufficient balance, invalid tick range,
+    ///   or other swap-related errors.
+    ///
+    /// ### Errors:
+    /// - [`SwapError::InsufficientBalance`] if the account does not have enough balance.
+    /// - [`SwapError::InvalidTickRange`] if `tick_low` is greater than or equal to `tick_high`.
+    /// - Other [`SwapError`] variants as applicable.
+    fn add_liquidity(
+        netuid: u16,
+        account_id: &<T as frame_system::Config>::AccountId,
+        tick_low: TickIndex,
+        tick_high: TickIndex,
+        liquidity: u64,
+        protocol: bool,
+    ) -> Result<(), Error<T>> {
+        ensure!(
+            Positions::<T>::get(netuid, account_id).len() <= T::MaxPositions::get() as usize,
+            Error::<T>::MaxPositionsExceeded
+        );
+
+        // Add liquidity at tick
+        Self::add_liquidity_at_index(netuid, tick_low, liquidity, false);
+        Self::add_liquidity_at_index(netuid, tick_high, liquidity, true);
+
+        // Update current tick liquidity
+        let current_tick_index = Self::bounded_current_tick_index(netuid);
+        Self::clamp_sqrt_price(netuid, current_tick_index);
+
+        Self::update_liquidity_if_needed(netuid, tick_low, tick_high, liquidity as i128);
+
+        // // New position
+        // let position = Position {
+        //     tick_low,
+        //     tick_high,
+        //     liquidity,
+        //     fees_tao: 0_u64,
+        //     fees_alpha: 0_u64,
+        // };
+
+        // // If this is a user transaction, withdraw balances and update reserves
+        // if !protocol {
+        //     let current_price = self.state_ops.get_alpha_sqrt_price();
+        //     let (tao, alpha) = position.to_token_amounts(current_price)?;
+        //     self.state_ops.withdraw_balances(account_id, tao, alpha)?;
+
+        //     // Update reserves
+        //     let new_tao_reserve = self.state_ops.get_tao_reserve().saturating_add(tao);
+        //     self.state_ops.set_tao_reserve(new_tao_reserve);
+        //     let new_alpha_reserve = self.state_ops.get_alpha_reserve().saturating_add(alpha);
+        //     self.state_ops.set_alpha_reserve(new_alpha_reserve);
+        // }
+
+        // // Create a new user position
+        // self.state_ops.create_position(account_id, position);
+
+        // SwapV3Initialized::<T>::set(netuid, true);
+
+        Ok(())
+    }
+
+    /// Adds or updates liquidity at a specific tick index for a subnet
+    ///
+    /// # Arguments
+    /// * `netuid` - The subnet ID
+    /// * `tick_index` - The tick index to add liquidity to
+    /// * `liquidity` - The amount of liquidity to add
+    fn add_liquidity_at_index(netuid: u16, tick_index: TickIndex, liquidity: u64, upper: bool) {
+        // Convert liquidity to signed value, negating it for upper bounds
+        let net_liquidity_change = if upper {
+            -(liquidity as i128)
+        } else {
+            liquidity as i128
+        };
+
+        Ticks::<T>::mutate(netuid, tick_index, |maybe_tick| match maybe_tick {
+            Some(tick) => {
+                tick.liquidity_net = tick.liquidity_net.saturating_add(net_liquidity_change);
+                tick.liquidity_gross = tick.liquidity_gross.saturating_add(liquidity);
+            }
+            None => {
+                *maybe_tick = Some(Tick {
+                    liquidity_net: net_liquidity_change,
+                    liquidity_gross: liquidity,
+                    fees_out_tao: U64F64::from_num(0),
+                    fees_out_alpha: U64F64::from_num(0),
+                });
+            }
+        });
+    }
+
+    /// Gets the current tick index for a subnet, ensuring it's within valid bounds
+    fn bounded_current_tick_index(netuid: u16) -> TickIndex {
+        let current_price = AlphaSqrtPrice::<T>::get(netuid);
+        TickIndex::from_sqrt_price_bounded(current_price)
+    }
+
+    /// Clamps the subnet's sqrt price when tick index is outside of valid bounds
+    fn clamp_sqrt_price(netuid: u16, tick_index: TickIndex) {
+        if tick_index >= TickIndex::MAX || tick_index <= TickIndex::MIN {
+            let corrected_price = tick_index.to_sqrt_price_bounded();
+            AlphaSqrtPrice::<T>::set(netuid, corrected_price);
+        }
+    }
+
+    /// Updates the current liquidity for a subnet if the current tick index is within the specified
+    /// range
+    ///
+    /// This function handles both increasing and decreasing liquidity based on the sign of the
+    /// liquidity parameter. It uses i128 to safely handle values up to u64::MAX in both positive
+    /// and negative directions.
+    fn update_liquidity_if_needed(
+        netuid: u16,
+        tick_low: TickIndex,
+        tick_high: TickIndex,
+        liquidity: i128,
+    ) {
+        let current_tick_index = Self::bounded_current_tick_index(netuid);
+        if (tick_low <= current_tick_index) && (current_tick_index <= tick_high) {
+            CurrentLiquidity::<T>::mutate(netuid, |current_liquidity| {
+                let is_neg = liquidity.is_negative();
+                let liquidity = liquidity.abs().min(u64::MAX as i128) as u64;
+                if is_neg {
+                    *current_liquidity = current_liquidity.saturating_sub(liquidity);
+                } else {
+                    *current_liquidity = current_liquidity.saturating_add(liquidity);
+                }
+            });
+        }
+    }
+}
diff --git a/pallets/swap/src/pallet/mod.rs b/pallets/swap/src/pallet/mod.rs
index d48b8479e3..4ed26d7966 100644
--- a/pallets/swap/src/pallet/mod.rs
+++ b/pallets/swap/src/pallet/mod.rs
@@ -1,9 +1,13 @@
-use frame_support::{pallet_prelude::*, traits::BuildGenesisConfig};
+use frame_support::{PalletId, pallet_prelude::*, traits::Get};
 use frame_system::pallet_prelude::*;
-use core::marker::PhantomData;
+use pallet_subtensor_swap_interface::LiquidityDataProvider;
+use substrate_fixed::types::U64F64;
 
+use crate::Position;
 use crate::tick::{Tick, TickIndex};
 
+mod impls;
+
 #[frame_support::pallet]
 pub mod pallet {
     use super::*;
@@ -20,83 +24,117 @@ pub mod pallet {
         /// The origin which may configure the swap parameters
         type AdminOrigin: EnsureOrigin<Self::RuntimeOrigin>;
 
+        /// Implementor of
+        /// [`LiquidityDataProvider`](pallet_subtensor_swap_interface::LiquidityDataProvider).
+        type LiquidityDataProvider: LiquidityDataProvider;
+
+        /// This type is used to derive protocol accoun ID.
+        #[pallet::constant]
+        type ProtocolId: Get<PalletId>;
+
         /// The maximum fee rate that can be set
         #[pallet::constant]
         type MaxFeeRate: Get<u16>;
+
+        /// The maximum number of positions a user can have
+        #[pallet::constant]
+        type MaxPositions: Get<u32>;
     }
 
-    /// The fee rate applied to swaps, normalized value between 0 and u16::MAX
+    /// The fee rate applied to swaps per subnet, normalized value between 0 and u16::MAX
     ///
     /// For example, 0.3% is approximately 196
     #[pallet::storage]
     #[pallet::getter(fn fee_rate)]
-    pub type FeeRate<T> = StorageValue<_, u16, ValueQuery>;
-    
-    /// Storage for all ticks, mapped by tick index
+    pub type FeeRate<T> = StorageMap<_, Twox64Concat, u16, u16, ValueQuery>;
+
+    /// Storage for all ticks, using subnet ID as the primary key and tick index as the secondary key
     #[pallet::storage]
     #[pallet::getter(fn ticks)]
-    pub type Ticks<T> = StorageMap<_, Twox64Concat, TickIndex, Tick>;
+    pub type Ticks<T> = StorageDoubleMap<_, Twox64Concat, u16, Twox64Concat, TickIndex, Tick>;
+
+    /// Storage to determine whether swap V3 was initialized for a specific subnet.
+    #[pallet::storage]
+    #[pallet::getter(fn swap_v3_initialized)]
+    pub type SwapV3Initialized<T> = StorageMap<_, Twox64Concat, u16, bool, ValueQuery>;
+
+    /// Storage for the square root price of Alpha token for each subnet.
+    #[pallet::storage]
+    #[pallet::getter(fn alpha_sqrt_price)]
+    pub type AlphaSqrtPrice<T> = StorageMap<_, Twox64Concat, u16, U64F64, ValueQuery>;
+
+    /// Storage for the current liquidity amount for each subnet.
+    #[pallet::storage]
+    #[pallet::getter(fn current_liquidity)]
+    pub type CurrentLiquidity<T> = StorageMap<_, Twox64Concat, u16, u64, ValueQuery>;
+
+    /// Storage for user positions, using subnet ID and account ID as keys
+    /// The value is a bounded vector of Position structs with details about the liquidity positions
+    #[pallet::storage]
+    #[pallet::getter(fn positions)]
+    pub type Positions<T: Config> = StorageDoubleMap<
+        _,
+        Twox64Concat,
+        u16,
+        Twox64Concat,
+        T::AccountId,
+        BoundedVec<Position, T::MaxPositions>,
+        ValueQuery,
+    >;
 
     #[pallet::event]
     #[pallet::generate_deposit(pub(super) fn deposit_event)]
     pub enum Event<T: Config> {
-        /// Event emitted when the fee rate has been updated
-        FeeRateSet { rate: u16 },
+        /// Event emitted when the fee rate has been updated for a subnet
+        FeeRateSet { netuid: u16, rate: u16 },
     }
 
     #[pallet::error]
     pub enum Error<T> {
         /// The fee rate is too high
         FeeRateTooHigh,
-    }
 
-    /// Genesis configuration for the swap pallet
-    #[pallet::genesis_config]
-    pub struct GenesisConfig<T: Config> {
-        /// Initial fee rate
-        pub fee_rate: u16,
-        /// Phantom data for unused generic
-        pub _phantom: PhantomData<T>,
-    }
+        /// The provided amount is insufficient for the swap.
+        InsufficientInputAmount,
 
-    impl<T: Config> Default for GenesisConfig<T> {
-        fn default() -> Self {
-            Self {
-                fee_rate: 0, // Default to 0% fee
-                _phantom: PhantomData,
-            }
-        }
-    }
+        /// The provided liquidity is insufficient for the operation.
+        InsufficientLiquidity,
 
-    #[pallet::genesis_build]
-    impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
-        fn build(&self) {
-            // Ensure the fee rate is within bounds
-            assert!(
-                self.fee_rate <= T::MaxFeeRate::get(),
-                "Fee rate in genesis config is too high"
-            );
-
-            // Set the initial fee rate
-            <FeeRate<T>>::put(self.fee_rate);
-        }
+        /// The operation would exceed the price limit.
+        PriceLimitExceeded,
+
+        /// The caller does not have enough balance for the operation.
+        InsufficientBalance,
+
+        /// Attempted to remove liquidity that does not exist.
+        LiquidityNotFound,
+
+        /// The provided tick range is invalid.
+        InvalidTickRange,
+
+        /// Maximum user positions exceeded
+        MaxPositionsExceeded,
+
+        /// Too many swap steps
+        TooManySwapSteps,
     }
 
     #[pallet::call]
     impl<T: Config> Pallet<T> {
-        /// Set the fee rate for swaps (normalized value). For example, 0.3% is approximately 196.
+        /// Set the fee rate for swaps on a specific subnet (normalized value).
+        /// For example, 0.3% is approximately 196.
         ///
         /// Only callable by the admin origin
         #[pallet::call_index(0)]
         #[pallet::weight(10_000)]
-        pub fn set_fee_rate(origin: OriginFor<T>, rate: u16) -> DispatchResult {
+        pub fn set_fee_rate(origin: OriginFor<T>, netuid: u16, rate: u16) -> DispatchResult {
             T::AdminOrigin::ensure_origin(origin)?;
 
             ensure!(rate <= T::MaxFeeRate::get(), Error::<T>::FeeRateTooHigh);
 
-            <FeeRate<T>>::put(rate);
+            FeeRate::<T>::insert(netuid, rate);
 
-            Self::deposit_event(Event::FeeRateSet { rate });
+            Self::deposit_event(Event::FeeRateSet { netuid, rate });
 
             Ok(())
         }
diff --git a/pallets/swap/src/tick.rs b/pallets/swap/src/tick.rs
index 902a2191f7..64dfd04ca6 100644
--- a/pallets/swap/src/tick.rs
+++ b/pallets/swap/src/tick.rs
@@ -169,6 +169,50 @@ impl TickIndex {
     /// The tick_math library uses different bitness, so we have to divide by 2.
     pub const MIN: Self = Self(MIN_TICK / 2);
 
+    /// Converts a sqrt price to a tick index, ensuring it's within valid bounds
+    ///
+    /// If the price is outside the valid range, this function will return the appropriate boundary
+    /// tick index (MIN or MAX) instead of an error.
+    ///
+    /// # Arguments
+    /// * `sqrt_price` - The square root price to convert to a tick index
+    ///
+    /// # Returns
+    /// * `TickIndex` - A tick index that is guaranteed to be within valid bounds
+    pub fn from_sqrt_price_bounded(sqrt_price: SqrtPrice) -> Self {
+        match Self::try_from_sqrt_price(sqrt_price) {
+            Ok(index) => index,
+            Err(_) => {
+                let max_price = Self::MAX
+                    .try_to_sqrt_price()
+                    .unwrap_or(SqrtPrice::saturating_from_num(1000));
+
+                if sqrt_price > max_price {
+                    Self::MAX
+                } else {
+                    Self::MIN
+                }
+            }
+        }
+    }
+
+    /// Converts a tick index to a sqrt price, ensuring it's within valid bounds
+    ///
+    /// Unlike try_to_sqrt_price which returns an error for boundary indices, this function
+    /// guarantees a valid sqrt price by using fallback values if conversion fails.
+    ///
+    /// # Returns
+    /// * `SqrtPrice` - A sqrt price that is guaranteed to be a valid value
+    pub fn to_sqrt_price_bounded(&self) -> SqrtPrice {
+        self.try_to_sqrt_price().unwrap_or_else(|_| {
+            if *self >= Self::MAX {
+                SqrtPrice::saturating_from_num(1000)
+            } else {
+                SqrtPrice::saturating_from_num(0.000001)
+            }
+        })
+    }
+
     /// Creates a new TickIndex instance with bounds checking
     pub fn new(value: i32) -> Result<Self, TickMathError> {
         if !(Self::MIN.0..=Self::MAX.0).contains(&value) {
@@ -209,9 +253,8 @@ impl TickIndex {
         Self::new(self.0 - value)
     }
 
-    /// Converts tick index into SQRT of lower price of this tick
-    /// In order to find the higher price of this tick, call
-    /// tick_index_to_sqrt_price(tick_idx + 1)
+    /// Converts tick index into SQRT of lower price of this tick In order to find the higher price
+    /// of this tick, call tick_index_to_sqrt_price(tick_idx + 1)
     pub fn try_to_sqrt_price(&self) -> Result<SqrtPrice, TickMathError> {
         // because of u256->u128 conversion we have twice less values for min/max ticks
         if !(Self::MIN..=Self::MAX).contains(self) {
@@ -221,8 +264,8 @@ impl TickIndex {
     }
 
     /// Converts SQRT price to tick index
-    /// Because the tick is the range of prices [sqrt_lower_price, sqrt_higher_price),
-    /// the resulting tick index matches the price by the following inequality:
+    /// Because the tick is the range of prices [sqrt_lower_price, sqrt_higher_price), the resulting
+    /// tick index matches the price by the following inequality:
     ///    sqrt_lower_price <= sqrt_price < sqrt_higher_price
     pub fn try_from_sqrt_price(sqrt_price: SqrtPrice) -> Result<Self, TickMathError> {
         let tick = get_tick_at_sqrt_ratio(u64f64_to_u256_q64_96(sqrt_price))?;

From 7e8482ca08664de264fc7dad1cc6fa9b4cd130d1 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Tue, 25 Mar 2025 13:03:29 -0400
Subject: [PATCH 027/418] Adding tick search in progress

---
 pallets/swap/src/lib.rs  | 462 ++++++++++++++++++++++++++++++++++++++-
 pallets/swap/src/tick.rs |   3 +
 2 files changed, 461 insertions(+), 4 deletions(-)

diff --git a/pallets/swap/src/lib.rs b/pallets/swap/src/lib.rs
index 3082c9b114..eebff51c47 100644
--- a/pallets/swap/src/lib.rs
+++ b/pallets/swap/src/lib.rs
@@ -10,7 +10,7 @@ use substrate_fixed::types::U64F64;
 use frame_support::pallet_prelude::*;
 
 use self::tick::{
-    Tick, TickIndex,
+    MAX_TICK_INDEX, MIN_TICK_INDEX, Tick, TickIndex,
 };
 
 pub mod pallet;
@@ -18,6 +18,8 @@ mod tick;
 
 type SqrtPrice = U64F64;
 
+const TICK_OFFSET: u32 = 887272;
+
 pub enum SwapStepAction {
     Crossing,
     StopOn,
@@ -55,7 +57,6 @@ struct SwapStepResult {
 /// fees_tao - fees accrued by the position in quote currency (TAO)
 /// fees_alpha - fees accrued by the position in base currency (Alpha)
 ///
-#[cfg_attr(test, derive(Debug, PartialEq, Clone))]
 #[derive(Clone, Encode, Decode, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen, Default)]
 pub struct Position {
     pub tick_low: TickIndex,
@@ -179,6 +180,18 @@ pub trait SwapDataOperations<AccountIdType> {
         positions: Position,
     );
     fn remove_position(&mut self, account_id: &AccountIdType, position_id: u16);
+
+    // Tick index storage
+    // Storage is organized in 3 layers:
+    //    Layer 0 consists of one u128 that stores 55 bits. Each bit indicates which layer 1 words are active.
+    //    Layer 1 consists of up to 55 u128's that store 6932 bits for the layer 2 words.
+    //    Layer 2 consists of up to 6932 u128's that store 887272 bits for active/inactive ticks.
+    fn get_layer0_word(&self, word_index: u32) -> u128;
+    fn get_layer1_word(&self, word_index: u32) -> u128;
+    fn get_layer2_word(&self, word_index: u32) -> u128;
+    fn set_layer0_word(&mut self, word_index: u32, word: u128);
+    fn set_layer1_word(&mut self, word_index: u32, word: u128);
+    fn set_layer2_word(&mut self, word_index: u32, word: u128);
 }
 
 /// All main swapping logic abstracted from Runtime implementation is concentrated
@@ -1085,8 +1098,232 @@ where
         }
     }
 
-    pub fn find_closest_lower_active_tick(&self, index: TickIndex) -> Option<Tick> {
-        let maybe_tick_index = index.find_closest_lower_active(&self.state_ops);
+    /// Active tick operations
+    /// 
+    /// Data structure: 
+    ///    Active ticks are stored in three hash maps, each representing a "Level"
+    ///    Level 0 stores one u128 word, where each bit represents one Level 1 word.
+    ///    Level 1 words each store also a u128 word, where each bit represents one Level 2 word.
+    ///    Level 2 words each store u128 word, where each bit represents a tick.
+    /// 
+    /// Insertion: 3 reads, 3 writes
+    /// Search: 3-5 reads
+    /// Deletion: 2 reads, 1-3 writes
+    ///
+
+    // Addresses an index as (word, bit)
+    fn index_to_address(index: u32) -> (u32, u32) {
+        let word: u32 = index.safe_div(128);
+        let bit: u32 = index.checked_rem(128).unwrap_or_default();
+        (word, bit)
+    }
+
+    // Reconstructs an index from address in lower level
+    fn address_to_index(word: u32, bit: u32) -> u32 {
+        word.saturating_mul(128).saturating_add(bit)
+    }
+
+    pub fn insert_active_tick(&mut self, index: i32) {
+        // Check the range
+        if (index < MIN_TICK_INDEX) || (index > MAX_TICK_INDEX) {
+            return;
+        }
+
+        // Ticks are between -443636 and 443636, so there is no
+        // overflow here. The u32 offset_index is the format we store indexes in the tree
+        // to avoid working with the sign bit.
+        let offset_index = (index.saturating_add(TICK_OFFSET as i32)) as u32;
+
+        // Calculate index in each layer
+        let (layer2_word, layer2_bit) = Self::index_to_address(offset_index);
+        let (layer1_word, layer1_bit) = Self::index_to_address(layer2_word);
+        let (layer0_word, layer0_bit) = Self::index_to_address(layer1_word);
+
+        // Update layer words
+        let mut word0_value = self.state_ops.get_layer0_word(layer0_word);
+        let mut word1_value = self.state_ops.get_layer1_word(layer1_word);
+        let mut word2_value = self.state_ops.get_layer2_word(layer2_word);        
+
+        let bit: u128 = 1;
+        word0_value = word0_value | bit.wrapping_shl(layer0_bit);
+        word1_value = word1_value | bit.wrapping_shl(layer1_bit);
+        word2_value = word2_value | bit.wrapping_shl(layer2_bit);
+
+        self.state_ops.set_layer0_word(layer0_word, word0_value);
+        self.state_ops.set_layer1_word(layer1_word, word1_value);
+        self.state_ops.set_layer2_word(layer2_word, word2_value);        
+    }
+
+    pub fn remove_active_tick(&mut self, index: i32) {
+        // Check the range
+        if (index < MIN_TICK_INDEX) || (index > MAX_TICK_INDEX) {
+            return;
+        }
+
+        // Ticks are between -443636 and 443636, so there is no
+        // overflow here. The u32 offset_index is the format we store indexes in the tree
+        // to avoid working with the sign bit.
+        let offset_index = (index.saturating_add(TICK_OFFSET as i32)) as u32;
+
+        // Calculate index in each layer
+        let (layer2_word, layer2_bit) = Self::index_to_address(offset_index);
+        let (layer1_word, layer1_bit) = Self::index_to_address(layer2_word);
+        let (layer0_word, layer0_bit) = Self::index_to_address(layer1_word);
+
+        // Update layer words
+        let mut word0_value = self.state_ops.get_layer0_word(layer0_word);
+        let mut word1_value = self.state_ops.get_layer1_word(layer1_word);
+        let mut word2_value = self.state_ops.get_layer2_word(layer2_word);        
+
+        // Turn the bit off (& !bit) and save as needed
+        let bit: u128 = 1;
+        word2_value = word2_value & !bit.wrapping_shl(layer2_bit);
+        self.state_ops.set_layer2_word(layer2_word, word2_value);        
+        if word2_value == 0 {
+            word1_value = word1_value & !bit.wrapping_shl(layer1_bit);
+            self.state_ops.set_layer1_word(layer1_word, word1_value);
+        }
+        if word1_value == 0 {
+            word0_value = word0_value & !bit.wrapping_shl(layer0_bit);
+            self.state_ops.set_layer0_word(layer0_word, word0_value);
+        }
+    }
+
+    // Finds the closest active bit and, if active bit exactly matches bit, then the next one
+    // Exact match: return Some([next, bit])
+    // Non-exact match: return Some([next])
+    // No match: return None
+    fn find_closest_active_bit_candidates(&self, word: u128, bit: u32, lower: bool) -> Vec<u32> {
+        let mut result = vec![];
+        let mut mask: u128 = 1_u128.wrapping_shl(bit);
+        let mut layer0_active_bit: u32 = bit;
+        while mask > 0 {
+            if mask & word != 0 {
+                result.push(layer0_active_bit);
+                if layer0_active_bit != bit {
+                    break;
+                }
+            }
+            mask = if lower {
+                layer0_active_bit = layer0_active_bit.saturating_sub(1);
+                mask.wrapping_shr(1)
+            } else {
+                layer0_active_bit = layer0_active_bit.saturating_add(1);
+                mask.wrapping_shl(1)
+            };
+        }
+        result
+    }
+
+    pub fn find_closest_active_tick_index(
+        &self,
+        index: i32,
+        lower: bool,
+    ) -> Option<i32>
+    {
+        // Check the range
+        if (index < MIN_TICK_INDEX) || (index > MAX_TICK_INDEX) {
+            return None;
+        }
+
+        // Ticks are between -443636 and 443636, so there is no
+        // overflow here. The u32 offset_index is the format we store indexes in the tree
+        // to avoid working with the sign bit.
+        let offset_index = (index.saturating_add(TICK_OFFSET as i32)) as u32;
+        let mut found = false;
+        let mut result: u32 = 0;
+
+        // Calculate index in each layer
+        let (layer2_word, layer2_bit) = Self::index_to_address(offset_index);
+        let (layer1_word, layer1_bit) = Self::index_to_address(layer2_word);
+        let (layer0_word, layer0_bit) = Self::index_to_address(layer1_word);
+
+        // Find the closest active bits in layer 0, then 1, then 2
+
+        ///////////////
+        // Level 0
+        let word0 = self.state_ops.get_layer0_word(layer0_word);
+        let closest_bits_l0 = self.find_closest_active_bit_candidates(word0, layer0_bit, lower);
+
+        closest_bits_l0.iter().for_each(|&closest_bit_l0| {
+            ///////////////
+            // Level 1
+            let word1_index = Self::address_to_index(0, closest_bit_l0);
+
+            // Layer 1 words are different, shift the bit to the word edge
+            let start_from_l1_bit = 
+                if word1_index < layer1_word {
+                    127
+                } else if word1_index > layer1_word {
+                    0
+                } else {
+                    layer1_bit
+                };
+            let word1_value = self.state_ops.get_layer1_word(word1_index);
+
+            let closest_bits_l1 = self.find_closest_active_bit_candidates(word1_value, start_from_l1_bit, lower);
+            closest_bits_l1.iter().for_each(|&closest_bit_l1| {
+                ///////////////
+                // Level 2
+                let word2_index = Self::address_to_index(word1_index, closest_bit_l1);
+
+                // Layer 2 words are different, shift the bit to the word edge
+                let start_from_l2_bit = 
+                    if word2_index < layer2_word {
+                        127
+                    } else if word2_index > layer2_word {
+                        0
+                    } else {
+                        layer2_bit
+                    };
+
+                let word2_value = self.state_ops.get_layer2_word(word2_index);
+                let closest_bits_l2 = self.find_closest_active_bit_candidates(word2_value, start_from_l2_bit, lower);
+
+                if closest_bits_l2.len() > 0 {
+                    // The active tick is found, restore its full index and return
+                    let offset_found_index = Self::address_to_index(word2_index, closest_bits_l2[0]);
+
+                    if lower {
+                        if (offset_found_index > result) || (!found) {
+                            result = offset_found_index;
+                            found = true;
+                        }
+                    } else {
+                        if (offset_found_index < result) || (!found) {
+                            result = offset_found_index;
+                            found = true;
+                        }
+                    }
+                }
+            });
+        });
+
+        if found {
+            Some((result as i32).saturating_sub(TICK_OFFSET as i32))
+        } else {
+            None
+        }
+    }
+
+    pub fn find_closest_lower_active_tick_index(
+        &self,
+        index: i32,
+    ) -> Option<i32>
+    {
+        self.find_closest_active_tick_index(index, true)
+    }
+
+    pub fn find_closest_higher_active_tick_index(
+        &self,
+        index: i32,
+    ) -> Option<i32>
+    {
+        self.find_closest_active_tick_index(index, false)
+    }
+
+    pub fn find_closest_lower_active_tick(&self, index: i32) -> Option<Tick> {
+        let maybe_tick_index = find_closest_lower_active_tick_index(&self.state_ops, index);
         if let Some(tick_index) = maybe_tick_index {
             self.state_ops.get_tick_by_index(tick_index)
         } else {
@@ -1771,4 +2008,221 @@ mod tests {
             );
         });
     }
+
+    // cargo test --package pallet-subtensor-swap --lib -- tests::test_tick_search_basic --exact --show-output
+    #[test]
+    fn test_tick_search_basic() {
+        let mock_ops = MockSwapDataOperations::new();
+        let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
+
+        swap.insert_active_tick(MIN_TICK_INDEX);
+        assert_eq!(swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX).unwrap(), MIN_TICK_INDEX);
+        assert_eq!(swap.find_closest_lower_active_tick_index(MAX_TICK_INDEX).unwrap(), MIN_TICK_INDEX);
+        assert_eq!(swap.find_closest_lower_active_tick_index(MAX_TICK_INDEX/2).unwrap(), MIN_TICK_INDEX);
+        assert_eq!(swap.find_closest_lower_active_tick_index(MAX_TICK_INDEX - 1).unwrap(), MIN_TICK_INDEX);
+        assert_eq!(swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX+1).unwrap(), MIN_TICK_INDEX);
+
+        assert_eq!(swap.find_closest_higher_active_tick_index(MIN_TICK_INDEX).unwrap(), MIN_TICK_INDEX);
+        assert_eq!(swap.find_closest_higher_active_tick_index(MAX_TICK_INDEX), None);
+        assert_eq!(swap.find_closest_higher_active_tick_index(MAX_TICK_INDEX/2), None);
+        assert_eq!(swap.find_closest_higher_active_tick_index(MAX_TICK_INDEX - 1), None);
+        assert_eq!(swap.find_closest_higher_active_tick_index(MIN_TICK_INDEX+1), None);
+
+        swap.insert_active_tick(MAX_TICK_INDEX);
+        assert_eq!(swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX).unwrap(), MIN_TICK_INDEX);
+        assert_eq!(swap.find_closest_lower_active_tick_index(MAX_TICK_INDEX).unwrap(), MAX_TICK_INDEX);
+        assert_eq!(swap.find_closest_lower_active_tick_index(MAX_TICK_INDEX/2).unwrap(), MIN_TICK_INDEX);
+        assert_eq!(swap.find_closest_lower_active_tick_index(MAX_TICK_INDEX - 1).unwrap(), MIN_TICK_INDEX);
+        assert_eq!(swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX + 1).unwrap(), MIN_TICK_INDEX);
+    }
+
+    #[test]
+    fn test_tick_search_sparse_queries() {
+        let mock_ops = MockSwapDataOperations::new();
+        let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
+
+        swap.insert_active_tick(MIN_TICK_INDEX + 10);
+        assert_eq!(swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX + 10).unwrap(), MIN_TICK_INDEX + 10);
+        assert_eq!(swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX + 11).unwrap(), MIN_TICK_INDEX + 10);
+        assert_eq!(swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX + 12).unwrap(), MIN_TICK_INDEX + 10);
+        assert_eq!(swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX), None);
+        assert_eq!(swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX + 9), None);
+
+        assert_eq!(swap.find_closest_higher_active_tick_index(MIN_TICK_INDEX + 10).unwrap(), MIN_TICK_INDEX + 10);
+        assert_eq!(swap.find_closest_higher_active_tick_index(MIN_TICK_INDEX + 11), None);
+        assert_eq!(swap.find_closest_higher_active_tick_index(MIN_TICK_INDEX + 12), None);
+        assert_eq!(swap.find_closest_higher_active_tick_index(MIN_TICK_INDEX).unwrap(), MIN_TICK_INDEX + 10);
+        assert_eq!(swap.find_closest_higher_active_tick_index(MIN_TICK_INDEX + 9).unwrap(), MIN_TICK_INDEX + 10); 
+    }
+
+    #[test]
+    fn test_tick_search_many_lows() {
+        let mock_ops = MockSwapDataOperations::new();
+        let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
+
+        for i in 0..1000 {
+            swap.insert_active_tick(MIN_TICK_INDEX + i);
+        }
+        for i in 0..1000 {
+            assert_eq!(swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX + i).unwrap(), MIN_TICK_INDEX + i);
+            assert_eq!(swap.find_closest_higher_active_tick_index(MIN_TICK_INDEX + i).unwrap(), MIN_TICK_INDEX + i);
+        }
+    }
+
+    #[test]
+    fn test_tick_search_many_sparse() {
+        let mock_ops = MockSwapDataOperations::new();
+        let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
+        let count: i32 = 1000;
+
+        for i in 0..=count {
+            swap.insert_active_tick(i * 10);
+        }
+        for i in 1..count {
+            assert_eq!(swap.find_closest_lower_active_tick_index(i * 10).unwrap(), i * 10);
+            assert_eq!(swap.find_closest_higher_active_tick_index(i * 10).unwrap(), i * 10);
+            for j in 1..=9 {
+                assert_eq!(swap.find_closest_lower_active_tick_index(i * 10 - j).unwrap(), (i-1) * 10);
+                assert_eq!(swap.find_closest_lower_active_tick_index(i * 10 + j).unwrap(), i * 10);
+                assert_eq!(swap.find_closest_higher_active_tick_index(i * 10 - j).unwrap(), i * 10);
+                assert_eq!(swap.find_closest_higher_active_tick_index(i * 10 + j).unwrap(), (i+1) * 10);
+            }
+        }
+    }
+
+    #[test]
+    fn test_tick_search_many_lows_sparse_reversed() {
+        let mock_ops = MockSwapDataOperations::new();
+        let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
+        let count: i32 = 1000;
+
+        for i in (0..=count).rev() {
+            swap.insert_active_tick(i * 10);
+        }
+        for i in 1..count {
+            assert_eq!(swap.find_closest_lower_active_tick_index(i * 10).unwrap(), i * 10);
+            assert_eq!(swap.find_closest_higher_active_tick_index(i * 10).unwrap(), i * 10);
+            for j in 1..=9 {
+                assert_eq!(swap.find_closest_lower_active_tick_index(i * 10 - j).unwrap(), (i-1) * 10);
+                assert_eq!(swap.find_closest_lower_active_tick_index(i * 10 + j).unwrap(), i * 10);
+                assert_eq!(swap.find_closest_higher_active_tick_index(i * 10 - j).unwrap(), i * 10);
+                assert_eq!(swap.find_closest_higher_active_tick_index(i * 10 + j).unwrap(), (i+1) * 10);
+            }
+        }        
+    }
+
+    #[test]
+    fn test_tick_search_repeated_insertions() {
+        let mock_ops = MockSwapDataOperations::new();
+        let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
+        let count: i32 = 1000;
+
+        for _ in 0..10 {
+            for i in 0..=count {
+                swap.insert_active_tick(i * 10);
+            }
+            for i in 1..count {
+                assert_eq!(swap.find_closest_lower_active_tick_index(i * 10).unwrap(), i * 10);
+                assert_eq!(swap.find_closest_higher_active_tick_index(i * 10).unwrap(), i * 10);
+                for j in 1..=9 {
+                    assert_eq!(swap.find_closest_lower_active_tick_index(i * 10 - j).unwrap(), (i-1) * 10);
+                    assert_eq!(swap.find_closest_lower_active_tick_index(i * 10 + j).unwrap(), i * 10);
+                    assert_eq!(swap.find_closest_higher_active_tick_index(i * 10 - j).unwrap(), i * 10);
+                    assert_eq!(swap.find_closest_higher_active_tick_index(i * 10 + j).unwrap(), (i+1) * 10);
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn test_tick_search_full_range() {
+        let mock_ops = MockSwapDataOperations::new();
+        let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
+        let step= 1019;
+        let count = (MAX_TICK_INDEX - MIN_TICK_INDEX) / step;
+
+        for i in 0..=count {
+            let index = MIN_TICK_INDEX + i * step;
+            swap.insert_active_tick(index);
+        }
+        for i in 1..count {
+            let index = MIN_TICK_INDEX + i * step;
+
+            assert_eq!(swap.find_closest_lower_active_tick_index(index - step).unwrap(), index - step);
+            assert_eq!(swap.find_closest_lower_active_tick_index(index).unwrap(), index);
+            assert_eq!(swap.find_closest_lower_active_tick_index(index + step - 1).unwrap(), index);
+            assert_eq!(swap.find_closest_lower_active_tick_index(index + step/2).unwrap(), index);
+
+            assert_eq!(swap.find_closest_higher_active_tick_index(index).unwrap(), index);
+            assert_eq!(swap.find_closest_higher_active_tick_index(index + step).unwrap(), index + step);
+            assert_eq!(swap.find_closest_higher_active_tick_index(index + step/2).unwrap(), index + step);
+            assert_eq!(swap.find_closest_higher_active_tick_index(index + step - 1).unwrap(), index + step);
+            for j in 1..=9 {
+                assert_eq!(swap.find_closest_lower_active_tick_index(index - j).unwrap(), index - step);
+                assert_eq!(swap.find_closest_lower_active_tick_index(index + j).unwrap(), index);
+                assert_eq!(swap.find_closest_higher_active_tick_index(index - j).unwrap(), index);
+                assert_eq!(swap.find_closest_higher_active_tick_index(index + j).unwrap(), index + step);
+            }
+        }
+    }    
+
+    #[test]
+    fn test_tick_remove_basic() {
+        let mock_ops = MockSwapDataOperations::new();
+        let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
+
+        swap.insert_active_tick(MIN_TICK_INDEX);
+        swap.insert_active_tick(MAX_TICK_INDEX);
+        swap.remove_active_tick(MAX_TICK_INDEX);
+
+        assert_eq!(swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX).unwrap(), MIN_TICK_INDEX);
+        assert_eq!(swap.find_closest_lower_active_tick_index(MAX_TICK_INDEX).unwrap(), MIN_TICK_INDEX);
+        assert_eq!(swap.find_closest_lower_active_tick_index(MAX_TICK_INDEX/2).unwrap(), MIN_TICK_INDEX);
+        assert_eq!(swap.find_closest_lower_active_tick_index(MAX_TICK_INDEX - 1).unwrap(), MIN_TICK_INDEX);
+        assert_eq!(swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX+1).unwrap(), MIN_TICK_INDEX);
+
+        assert_eq!(swap.find_closest_higher_active_tick_index(MIN_TICK_INDEX).unwrap(), MIN_TICK_INDEX);
+        assert_eq!(swap.find_closest_higher_active_tick_index(MAX_TICK_INDEX), None);
+        assert_eq!(swap.find_closest_higher_active_tick_index(MAX_TICK_INDEX/2), None);
+        assert_eq!(swap.find_closest_higher_active_tick_index(MAX_TICK_INDEX - 1), None);
+        assert_eq!(swap.find_closest_higher_active_tick_index(MIN_TICK_INDEX+1), None);
+    }    
+
+    #[test]
+    fn test_tick_remove_full_range() {
+        let mock_ops = MockSwapDataOperations::new();
+        let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
+        let step= 1019;
+        let count = (MAX_TICK_INDEX - MIN_TICK_INDEX) / step;
+        let remove_frequency = 5; // Remove every 5th tick
+
+        // Insert ticks
+        for i in 0..=count {
+            let index = MIN_TICK_INDEX + i * step;
+            swap.insert_active_tick(index);
+        }
+
+        // Remove some ticks
+        for i in 1..count {
+            if i % remove_frequency == 0 {
+                let index = MIN_TICK_INDEX + i * step;
+                swap.remove_active_tick(index);
+            }
+        }
+
+        // Verify
+        for i in 1..count {
+            let index = MIN_TICK_INDEX + i * step;
+
+            if i % remove_frequency == 0 {
+                let lower = swap.find_closest_lower_active_tick_index(index);
+                let higher = swap.find_closest_higher_active_tick_index(index);
+                assert!(lower != Some(index));
+                assert!(higher != Some(index));
+            } else {
+                assert_eq!(swap.find_closest_lower_active_tick_index(index).unwrap(), index);
+                assert_eq!(swap.find_closest_higher_active_tick_index(index).unwrap(), index);
+            }
+        }
+    }
 }
diff --git a/pallets/swap/src/tick.rs b/pallets/swap/src/tick.rs
index 64dfd04ca6..f311e4b922 100644
--- a/pallets/swap/src/tick.rs
+++ b/pallets/swap/src/tick.rs
@@ -44,6 +44,9 @@ const U256_MAX_TICK: U256 = U256::from_limbs([887272, 0, 0, 0]);
 const MIN_TICK: i32 = -887272;
 const MAX_TICK: i32 = -MIN_TICK;
 
+pub const MIN_TICK_INDEX: i32 = -443636;
+pub const MAX_TICK_INDEX: i32 = -MIN_TICK_INDEX;
+
 const MIN_SQRT_RATIO: U256 = U256::from_limbs([4295128739, 0, 0, 0]);
 const MAX_SQRT_RATIO: U256 =
     U256::from_limbs([6743328256752651558, 17280870778742802505, 4294805859, 0]);

From a3b1bf8160dd874c87224f6e2fc63293974284f3 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Tue, 25 Mar 2025 13:17:21 -0400
Subject: [PATCH 028/418] Add tick search

---
 pallets/swap/src/lib.rs  | 47 +++++++++++++++++++++++++++++++---------
 pallets/swap/src/tick.rs |  2 +-
 2 files changed, 38 insertions(+), 11 deletions(-)

diff --git a/pallets/swap/src/lib.rs b/pallets/swap/src/lib.rs
index eebff51c47..d2d261d32b 100644
--- a/pallets/swap/src/lib.rs
+++ b/pallets/swap/src/lib.rs
@@ -18,7 +18,9 @@ mod tick;
 
 type SqrtPrice = U64F64;
 
-const TICK_OFFSET: u32 = 887272;
+/// All tick indexes are offset by TICK_OFFSET for the search and active tick storage needs 
+/// so that tick indexes are positive, which simplifies bit logic
+pub const TICK_OFFSET: u32 = 887272;
 
 pub enum SwapStepAction {
     Crossing,
@@ -645,7 +647,7 @@ where
         self.update_reserves(order_type, delta_in, delta_out);
 
         // Get current tick
-        let current_tick_index = self.get_current_tick_index();
+        let TickIndex(current_tick_index) = self.get_current_tick_index();
 
         match action {
             SwapStepAction::Crossing => {
@@ -664,7 +666,7 @@ where
                         .saturating_sub(tick.fees_out_alpha);
                     self.update_liquidity_at_crossing(order_type)?;
                     self.state_ops
-                        .insert_tick_by_index(current_tick_index, tick);
+                        .insert_tick_by_index(TickIndex(current_tick_index), tick);
                 } else {
                     return Err(SwapError::InsufficientLiquidity);
                 }
@@ -685,7 +687,7 @@ where
                             .get_fee_global_alpha()
                             .saturating_sub(tick.fees_out_alpha);
                         self.state_ops
-                            .insert_tick_by_index(current_tick_index, tick);
+                            .insert_tick_by_index(TickIndex(current_tick_index), tick);
                     } else {
                         return Err(SwapError::InsufficientLiquidity);
                     }
@@ -958,7 +960,7 @@ where
     ///
     fn update_liquidity_at_crossing(&mut self, order_type: &OrderType) -> Result<(), SwapError> {
         let mut liquidity_curr = self.state_ops.get_current_liquidity();
-        let current_tick_index = self.get_current_tick_index();
+        let TickIndex(current_tick_index) = self.get_current_tick_index();
         match order_type {
             OrderType::Sell => {
                 let maybe_tick = self.find_closest_lower_active_tick(current_tick_index);
@@ -1323,18 +1325,18 @@ where
     }
 
     pub fn find_closest_lower_active_tick(&self, index: i32) -> Option<Tick> {
-        let maybe_tick_index = find_closest_lower_active_tick_index(&self.state_ops, index);
+        let maybe_tick_index = self.find_closest_lower_active_tick_index(index);
         if let Some(tick_index) = maybe_tick_index {
-            self.state_ops.get_tick_by_index(tick_index)
+            self.state_ops.get_tick_by_index(TickIndex(tick_index))
         } else {
             None
         }
     }
 
-    pub fn find_closest_higher_active_tick(&self, index: TickIndex) -> Option<Tick> {
-        let maybe_tick_index = index.find_closest_higher_active(&self.state_ops);
+    pub fn find_closest_higher_active_tick(&self, index: i32) -> Option<Tick> {
+        let maybe_tick_index = self.find_closest_higher_active_tick_index(index);
         if let Some(tick_index) = maybe_tick_index {
-            self.state_ops.get_tick_by_index(tick_index)
+            self.state_ops.get_tick_by_index(TickIndex(tick_index))
         } else {
             None
         }
@@ -1392,6 +1394,9 @@ mod tests {
         max_positions: u16,
         balances: HashMap<u16, (u64, u64)>,
         positions: HashMap<u16, HashMap<u16, Position>>,
+        tick_index_l0: HashMap<u32, u128>,
+        tick_index_l1: HashMap<u32, u128>,
+        tick_index_l2: HashMap<u32, u128>,
     }
 
     impl MockSwapDataOperations {
@@ -1412,6 +1417,9 @@ mod tests {
                 max_positions: 100,
                 balances: HashMap::new(),
                 positions: HashMap::new(),
+                tick_index_l0: HashMap::new(),
+                tick_index_l1: HashMap::new(),
+                tick_index_l2: HashMap::new(),
             }
         }
     }
@@ -1573,6 +1581,25 @@ mod tests {
                 account_positions.remove(&position_id);
             }
         }
+
+        fn get_layer0_word(&self, word_index: u32) -> u128 {
+            *self.tick_index_l0.get(&word_index).unwrap_or(&0_u128)
+        }
+        fn get_layer1_word(&self, word_index: u32) -> u128 {
+            *self.tick_index_l1.get(&word_index).unwrap_or(&0_u128)
+        }
+        fn get_layer2_word(&self, word_index: u32) -> u128 {
+            *self.tick_index_l2.get(&word_index).unwrap_or(&0_u128)
+        }
+        fn set_layer0_word(&mut self, word_index: u32, word: u128) {
+            self.tick_index_l0.insert(word_index, word);
+        }
+        fn set_layer1_word(&mut self, word_index: u32, word: u128) {
+            self.tick_index_l1.insert(word_index, word);
+        }
+        fn set_layer2_word(&mut self, word_index: u32, word: u128) {
+            self.tick_index_l2.insert(word_index, word);
+        }
     }
 
     #[test]
diff --git a/pallets/swap/src/tick.rs b/pallets/swap/src/tick.rs
index f311e4b922..610f7cd2d4 100644
--- a/pallets/swap/src/tick.rs
+++ b/pallets/swap/src/tick.rs
@@ -98,7 +98,7 @@ pub struct Tick {
     Ord,
     Hash,
 )]
-pub struct TickIndex(i32);
+pub struct TickIndex(pub i32);
 
 impl Add<TickIndex> for TickIndex {
     type Output = Self;

From c7df009fec8ffaad586af05f2a41cf5dbf4a17bf Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Tue, 25 Mar 2025 20:58:46 +0100
Subject: [PATCH 029/418] Replace i32 to TickIndex where needed

---
 pallets/swap/src/lib.rs  | 571 ++++++++++++++++++++++++++++-----------
 pallets/swap/src/tick.rs |  91 ++++++-
 2 files changed, 502 insertions(+), 160 deletions(-)

diff --git a/pallets/swap/src/lib.rs b/pallets/swap/src/lib.rs
index d2d261d32b..04a4fd1f70 100644
--- a/pallets/swap/src/lib.rs
+++ b/pallets/swap/src/lib.rs
@@ -3,22 +3,20 @@
 use core::marker::PhantomData;
 use core::ops::Neg;
 
+use frame_support::pallet_prelude::*;
 use pallet_subtensor_swap_interface::OrderType;
 use safe_math::*;
 use sp_arithmetic::helpers_128bit::sqrt;
 use substrate_fixed::types::U64F64;
-use frame_support::pallet_prelude::*;
 
-use self::tick::{
-    MAX_TICK_INDEX, MIN_TICK_INDEX, Tick, TickIndex,
-};
+use self::tick::{Tick, TickIndex};
 
 pub mod pallet;
 mod tick;
 
 type SqrtPrice = U64F64;
 
-/// All tick indexes are offset by TICK_OFFSET for the search and active tick storage needs 
+/// All tick indexes are offset by TICK_OFFSET for the search and active tick storage needs
 /// so that tick indexes are positive, which simplifies bit logic
 pub const TICK_OFFSET: u32 = 887272;
 
@@ -87,10 +85,14 @@ impl Position {
     pub fn to_token_amounts(&self, sqrt_price_curr: SqrtPrice) -> Result<(u64, u64), SwapError> {
         let one: U64F64 = U64F64::saturating_from_num(1);
 
-        let sqrt_pa: SqrtPrice =
-            self.tick_low.try_to_sqrt_price().map_err(|_| SwapError::InvalidTickRange)?;
-        let sqrt_pb: SqrtPrice =
-            self.tick_high.try_to_sqrt_price().map_err(|_| SwapError::InvalidTickRange)?;
+        let sqrt_pa: SqrtPrice = self
+            .tick_low
+            .try_to_sqrt_price()
+            .map_err(|_| SwapError::InvalidTickRange)?;
+        let sqrt_pb: SqrtPrice = self
+            .tick_high
+            .try_to_sqrt_price()
+            .map_err(|_| SwapError::InvalidTickRange)?;
         let liquidity_fixed: U64F64 = U64F64::saturating_from_num(self.liquidity);
 
         Ok(if sqrt_price_curr < sqrt_pa {
@@ -609,9 +611,11 @@ where
         } else {
             // Current price is out of allow the min-max range, and it should be corrected to
             // maintain the range.
-            let max_price = TickIndex::MAX.try_to_sqrt_price()
+            let max_price = TickIndex::MAX
+                .try_to_sqrt_price()
                 .unwrap_or(SqrtPrice::saturating_from_num(1000));
-            let min_price = TickIndex::MIN.try_to_sqrt_price()
+            let min_price = TickIndex::MIN
+                .try_to_sqrt_price()
                 .unwrap_or(SqrtPrice::saturating_from_num(0.000001));
             if current_price > max_price {
                 self.state_ops.set_alpha_sqrt_price(max_price);
@@ -647,7 +651,7 @@ where
         self.update_reserves(order_type, delta_in, delta_out);
 
         // Get current tick
-        let TickIndex(current_tick_index) = self.get_current_tick_index();
+        let current_tick_index = self.get_current_tick_index();
 
         match action {
             SwapStepAction::Crossing => {
@@ -666,7 +670,7 @@ where
                         .saturating_sub(tick.fees_out_alpha);
                     self.update_liquidity_at_crossing(order_type)?;
                     self.state_ops
-                        .insert_tick_by_index(TickIndex(current_tick_index), tick);
+                        .insert_tick_by_index(current_tick_index, tick);
                 } else {
                     return Err(SwapError::InsufficientLiquidity);
                 }
@@ -687,7 +691,7 @@ where
                             .get_fee_global_alpha()
                             .saturating_sub(tick.fees_out_alpha);
                         self.state_ops
-                            .insert_tick_by_index(TickIndex(current_tick_index), tick);
+                            .insert_tick_by_index(current_tick_index, tick);
                     } else {
                         return Err(SwapError::InsufficientLiquidity);
                     }
@@ -724,7 +728,9 @@ where
 
         if let Ok(current_tick_index) = maybe_current_tick_index {
             match order_type {
-                OrderType::Buy => TickIndex::new_unchecked(current_tick_index.get().saturating_add(1)),
+                OrderType::Buy => {
+                    TickIndex::new_unchecked(current_tick_index.get().saturating_add(1))
+                }
                 OrderType::Sell => current_tick_index,
             }
             .try_to_sqrt_price()
@@ -960,7 +966,7 @@ where
     ///
     fn update_liquidity_at_crossing(&mut self, order_type: &OrderType) -> Result<(), SwapError> {
         let mut liquidity_curr = self.state_ops.get_current_liquidity();
-        let TickIndex(current_tick_index) = self.get_current_tick_index();
+        let current_tick_index = self.get_current_tick_index();
         match order_type {
             OrderType::Sell => {
                 let maybe_tick = self.find_closest_lower_active_tick(current_tick_index);
@@ -1101,13 +1107,13 @@ where
     }
 
     /// Active tick operations
-    /// 
-    /// Data structure: 
+    ///
+    /// Data structure:
     ///    Active ticks are stored in three hash maps, each representing a "Level"
     ///    Level 0 stores one u128 word, where each bit represents one Level 1 word.
     ///    Level 1 words each store also a u128 word, where each bit represents one Level 2 word.
     ///    Level 2 words each store u128 word, where each bit represents a tick.
-    /// 
+    ///
     /// Insertion: 3 reads, 3 writes
     /// Search: 3-5 reads
     /// Deletion: 2 reads, 1-3 writes
@@ -1125,16 +1131,15 @@ where
         word.saturating_mul(128).saturating_add(bit)
     }
 
-    pub fn insert_active_tick(&mut self, index: i32) {
+    pub fn insert_active_tick(&mut self, index: tick::TickIndex) {
         // Check the range
-        if (index < MIN_TICK_INDEX) || (index > MAX_TICK_INDEX) {
+        if (index < tick::TickIndex::MIN) || (index > tick::TickIndex::MAX) {
             return;
         }
 
-        // Ticks are between -443636 and 443636, so there is no
-        // overflow here. The u32 offset_index is the format we store indexes in the tree
+        // Convert the tick index value to an offset_index for the tree representation
         // to avoid working with the sign bit.
-        let offset_index = (index.saturating_add(TICK_OFFSET as i32)) as u32;
+        let offset_index = index.saturating_add(TICK_OFFSET as i32).get() as u32;
 
         // Calculate index in each layer
         let (layer2_word, layer2_bit) = Self::index_to_address(offset_index);
@@ -1144,7 +1149,7 @@ where
         // Update layer words
         let mut word0_value = self.state_ops.get_layer0_word(layer0_word);
         let mut word1_value = self.state_ops.get_layer1_word(layer1_word);
-        let mut word2_value = self.state_ops.get_layer2_word(layer2_word);        
+        let mut word2_value = self.state_ops.get_layer2_word(layer2_word);
 
         let bit: u128 = 1;
         word0_value = word0_value | bit.wrapping_shl(layer0_bit);
@@ -1153,19 +1158,18 @@ where
 
         self.state_ops.set_layer0_word(layer0_word, word0_value);
         self.state_ops.set_layer1_word(layer1_word, word1_value);
-        self.state_ops.set_layer2_word(layer2_word, word2_value);        
+        self.state_ops.set_layer2_word(layer2_word, word2_value);
     }
 
-    pub fn remove_active_tick(&mut self, index: i32) {
+    pub fn remove_active_tick(&mut self, index: tick::TickIndex) {
         // Check the range
-        if (index < MIN_TICK_INDEX) || (index > MAX_TICK_INDEX) {
+        if (index < tick::TickIndex::MIN) || (index > tick::TickIndex::MAX) {
             return;
         }
 
-        // Ticks are between -443636 and 443636, so there is no
-        // overflow here. The u32 offset_index is the format we store indexes in the tree
+        // Convert the tick index value to an offset_index for the tree representation
         // to avoid working with the sign bit.
-        let offset_index = (index.saturating_add(TICK_OFFSET as i32)) as u32;
+        let offset_index = index.saturating_add(TICK_OFFSET as i32).get() as u32;
 
         // Calculate index in each layer
         let (layer2_word, layer2_bit) = Self::index_to_address(offset_index);
@@ -1175,12 +1179,12 @@ where
         // Update layer words
         let mut word0_value = self.state_ops.get_layer0_word(layer0_word);
         let mut word1_value = self.state_ops.get_layer1_word(layer1_word);
-        let mut word2_value = self.state_ops.get_layer2_word(layer2_word);        
+        let mut word2_value = self.state_ops.get_layer2_word(layer2_word);
 
         // Turn the bit off (& !bit) and save as needed
         let bit: u128 = 1;
         word2_value = word2_value & !bit.wrapping_shl(layer2_bit);
-        self.state_ops.set_layer2_word(layer2_word, word2_value);        
+        self.state_ops.set_layer2_word(layer2_word, word2_value);
         if word2_value == 0 {
             word1_value = word1_value & !bit.wrapping_shl(layer1_bit);
             self.state_ops.set_layer1_word(layer1_word, word1_value);
@@ -1219,19 +1223,17 @@ where
 
     pub fn find_closest_active_tick_index(
         &self,
-        index: i32,
+        index: tick::TickIndex,
         lower: bool,
-    ) -> Option<i32>
-    {
+    ) -> Option<tick::TickIndex> {
         // Check the range
-        if (index < MIN_TICK_INDEX) || (index > MAX_TICK_INDEX) {
+        if (index < tick::TickIndex::MIN) || (index > tick::TickIndex::MAX) {
             return None;
         }
 
-        // Ticks are between -443636 and 443636, so there is no
-        // overflow here. The u32 offset_index is the format we store indexes in the tree
+        // Convert the tick index value to an offset_index for the tree representation
         // to avoid working with the sign bit.
-        let offset_index = (index.saturating_add(TICK_OFFSET as i32)) as u32;
+        let offset_index = index.saturating_add(TICK_OFFSET as i32).get() as u32;
         let mut found = false;
         let mut result: u32 = 0;
 
@@ -1253,38 +1255,39 @@ where
             let word1_index = Self::address_to_index(0, closest_bit_l0);
 
             // Layer 1 words are different, shift the bit to the word edge
-            let start_from_l1_bit = 
-                if word1_index < layer1_word {
-                    127
-                } else if word1_index > layer1_word {
-                    0
-                } else {
-                    layer1_bit
-                };
+            let start_from_l1_bit = if word1_index < layer1_word {
+                127
+            } else if word1_index > layer1_word {
+                0
+            } else {
+                layer1_bit
+            };
             let word1_value = self.state_ops.get_layer1_word(word1_index);
 
-            let closest_bits_l1 = self.find_closest_active_bit_candidates(word1_value, start_from_l1_bit, lower);
+            let closest_bits_l1 =
+                self.find_closest_active_bit_candidates(word1_value, start_from_l1_bit, lower);
             closest_bits_l1.iter().for_each(|&closest_bit_l1| {
                 ///////////////
                 // Level 2
                 let word2_index = Self::address_to_index(word1_index, closest_bit_l1);
 
                 // Layer 2 words are different, shift the bit to the word edge
-                let start_from_l2_bit = 
-                    if word2_index < layer2_word {
-                        127
-                    } else if word2_index > layer2_word {
-                        0
-                    } else {
-                        layer2_bit
-                    };
+                let start_from_l2_bit = if word2_index < layer2_word {
+                    127
+                } else if word2_index > layer2_word {
+                    0
+                } else {
+                    layer2_bit
+                };
 
                 let word2_value = self.state_ops.get_layer2_word(word2_index);
-                let closest_bits_l2 = self.find_closest_active_bit_candidates(word2_value, start_from_l2_bit, lower);
+                let closest_bits_l2 =
+                    self.find_closest_active_bit_candidates(word2_value, start_from_l2_bit, lower);
 
                 if closest_bits_l2.len() > 0 {
                     // The active tick is found, restore its full index and return
-                    let offset_found_index = Self::address_to_index(word2_index, closest_bits_l2[0]);
+                    let offset_found_index =
+                        Self::address_to_index(word2_index, closest_bits_l2[0]);
 
                     if lower {
                         if (offset_found_index > result) || (!found) {
@@ -1302,7 +1305,9 @@ where
         });
 
         if found {
-            Some((result as i32).saturating_sub(TICK_OFFSET as i32))
+            // Convert the tree offset_index back to a tick index value
+            let tick_value = (result as i32).saturating_sub(TICK_OFFSET as i32);
+            Some(tick::TickIndex::new_unchecked(tick_value))
         } else {
             None
         }
@@ -1310,33 +1315,31 @@ where
 
     pub fn find_closest_lower_active_tick_index(
         &self,
-        index: i32,
-    ) -> Option<i32>
-    {
+        index: tick::TickIndex,
+    ) -> Option<tick::TickIndex> {
         self.find_closest_active_tick_index(index, true)
     }
 
     pub fn find_closest_higher_active_tick_index(
         &self,
-        index: i32,
-    ) -> Option<i32>
-    {
+        index: tick::TickIndex,
+    ) -> Option<tick::TickIndex> {
         self.find_closest_active_tick_index(index, false)
     }
 
-    pub fn find_closest_lower_active_tick(&self, index: i32) -> Option<Tick> {
+    pub fn find_closest_lower_active_tick(&self, index: tick::TickIndex) -> Option<Tick> {
         let maybe_tick_index = self.find_closest_lower_active_tick_index(index);
         if let Some(tick_index) = maybe_tick_index {
-            self.state_ops.get_tick_by_index(TickIndex(tick_index))
+            self.state_ops.get_tick_by_index(tick_index)
         } else {
             None
         }
     }
 
-    pub fn find_closest_higher_active_tick(&self, index: i32) -> Option<Tick> {
+    pub fn find_closest_higher_active_tick(&self, index: tick::TickIndex) -> Option<Tick> {
         let maybe_tick_index = self.find_closest_higher_active_tick_index(index);
         if let Some(tick_index) = maybe_tick_index {
-            self.state_ops.get_tick_by_index(TickIndex(tick_index))
+            self.state_ops.get_tick_by_index(tick_index)
         } else {
             None
         }
@@ -1656,7 +1659,7 @@ mod tests {
                     tick = TickIndex::MIN;
                 }
                 tick
-            },
+            }
             // Default to a reasonable value when conversion fails
             Err(_) => {
                 if price > 1.0 {
@@ -1846,9 +1849,21 @@ mod tests {
         [
             // For our tests, we'll construct TickIndex values that are intentionally
             // outside the valid range for testing purposes only
-            (TickIndex::new_unchecked(TickIndex::MIN.get() - 1), TickIndex::MAX, 1_000_000_000_u64),
-            (TickIndex::MIN, TickIndex::new_unchecked(TickIndex::MAX.get() + 1), 1_000_000_000_u64),
-            (TickIndex::new_unchecked(TickIndex::MIN.get() - 1), TickIndex::new_unchecked(TickIndex::MAX.get() + 1), 1_000_000_000_u64),
+            (
+                TickIndex::new_unchecked(TickIndex::MIN.get() - 1),
+                TickIndex::MAX,
+                1_000_000_000_u64,
+            ),
+            (
+                TickIndex::MIN,
+                TickIndex::new_unchecked(TickIndex::MAX.get() + 1),
+                1_000_000_000_u64,
+            ),
+            (
+                TickIndex::new_unchecked(TickIndex::MIN.get() - 1),
+                TickIndex::new_unchecked(TickIndex::MAX.get() + 1),
+                1_000_000_000_u64,
+            ),
             (
                 TickIndex::new_unchecked(TickIndex::MIN.get() - 100),
                 TickIndex::new_unchecked(TickIndex::MAX.get() + 100),
@@ -2043,24 +2058,80 @@ mod tests {
         let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
 
         swap.insert_active_tick(MIN_TICK_INDEX);
-        assert_eq!(swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX).unwrap(), MIN_TICK_INDEX);
-        assert_eq!(swap.find_closest_lower_active_tick_index(MAX_TICK_INDEX).unwrap(), MIN_TICK_INDEX);
-        assert_eq!(swap.find_closest_lower_active_tick_index(MAX_TICK_INDEX/2).unwrap(), MIN_TICK_INDEX);
-        assert_eq!(swap.find_closest_lower_active_tick_index(MAX_TICK_INDEX - 1).unwrap(), MIN_TICK_INDEX);
-        assert_eq!(swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX+1).unwrap(), MIN_TICK_INDEX);
-
-        assert_eq!(swap.find_closest_higher_active_tick_index(MIN_TICK_INDEX).unwrap(), MIN_TICK_INDEX);
-        assert_eq!(swap.find_closest_higher_active_tick_index(MAX_TICK_INDEX), None);
-        assert_eq!(swap.find_closest_higher_active_tick_index(MAX_TICK_INDEX/2), None);
-        assert_eq!(swap.find_closest_higher_active_tick_index(MAX_TICK_INDEX - 1), None);
-        assert_eq!(swap.find_closest_higher_active_tick_index(MIN_TICK_INDEX+1), None);
+        assert_eq!(
+            swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX)
+                .unwrap(),
+            MIN_TICK_INDEX
+        );
+        assert_eq!(
+            swap.find_closest_lower_active_tick_index(MAX_TICK_INDEX)
+                .unwrap(),
+            MIN_TICK_INDEX
+        );
+        assert_eq!(
+            swap.find_closest_lower_active_tick_index(MAX_TICK_INDEX / 2)
+                .unwrap(),
+            MIN_TICK_INDEX
+        );
+        assert_eq!(
+            swap.find_closest_lower_active_tick_index(MAX_TICK_INDEX - 1)
+                .unwrap(),
+            MIN_TICK_INDEX
+        );
+        assert_eq!(
+            swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX + 1)
+                .unwrap(),
+            MIN_TICK_INDEX
+        );
+
+        assert_eq!(
+            swap.find_closest_higher_active_tick_index(MIN_TICK_INDEX)
+                .unwrap(),
+            MIN_TICK_INDEX
+        );
+        assert_eq!(
+            swap.find_closest_higher_active_tick_index(MAX_TICK_INDEX),
+            None
+        );
+        assert_eq!(
+            swap.find_closest_higher_active_tick_index(MAX_TICK_INDEX / 2),
+            None
+        );
+        assert_eq!(
+            swap.find_closest_higher_active_tick_index(MAX_TICK_INDEX - 1),
+            None
+        );
+        assert_eq!(
+            swap.find_closest_higher_active_tick_index(MIN_TICK_INDEX + 1),
+            None
+        );
 
         swap.insert_active_tick(MAX_TICK_INDEX);
-        assert_eq!(swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX).unwrap(), MIN_TICK_INDEX);
-        assert_eq!(swap.find_closest_lower_active_tick_index(MAX_TICK_INDEX).unwrap(), MAX_TICK_INDEX);
-        assert_eq!(swap.find_closest_lower_active_tick_index(MAX_TICK_INDEX/2).unwrap(), MIN_TICK_INDEX);
-        assert_eq!(swap.find_closest_lower_active_tick_index(MAX_TICK_INDEX - 1).unwrap(), MIN_TICK_INDEX);
-        assert_eq!(swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX + 1).unwrap(), MIN_TICK_INDEX);
+        assert_eq!(
+            swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX)
+                .unwrap(),
+            MIN_TICK_INDEX
+        );
+        assert_eq!(
+            swap.find_closest_lower_active_tick_index(MAX_TICK_INDEX)
+                .unwrap(),
+            MAX_TICK_INDEX
+        );
+        assert_eq!(
+            swap.find_closest_lower_active_tick_index(MAX_TICK_INDEX / 2)
+                .unwrap(),
+            MIN_TICK_INDEX
+        );
+        assert_eq!(
+            swap.find_closest_lower_active_tick_index(MAX_TICK_INDEX - 1)
+                .unwrap(),
+            MIN_TICK_INDEX
+        );
+        assert_eq!(
+            swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX + 1)
+                .unwrap(),
+            MIN_TICK_INDEX
+        );
     }
 
     #[test]
@@ -2069,17 +2140,53 @@ mod tests {
         let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
 
         swap.insert_active_tick(MIN_TICK_INDEX + 10);
-        assert_eq!(swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX + 10).unwrap(), MIN_TICK_INDEX + 10);
-        assert_eq!(swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX + 11).unwrap(), MIN_TICK_INDEX + 10);
-        assert_eq!(swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX + 12).unwrap(), MIN_TICK_INDEX + 10);
-        assert_eq!(swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX), None);
-        assert_eq!(swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX + 9), None);
-
-        assert_eq!(swap.find_closest_higher_active_tick_index(MIN_TICK_INDEX + 10).unwrap(), MIN_TICK_INDEX + 10);
-        assert_eq!(swap.find_closest_higher_active_tick_index(MIN_TICK_INDEX + 11), None);
-        assert_eq!(swap.find_closest_higher_active_tick_index(MIN_TICK_INDEX + 12), None);
-        assert_eq!(swap.find_closest_higher_active_tick_index(MIN_TICK_INDEX).unwrap(), MIN_TICK_INDEX + 10);
-        assert_eq!(swap.find_closest_higher_active_tick_index(MIN_TICK_INDEX + 9).unwrap(), MIN_TICK_INDEX + 10); 
+        assert_eq!(
+            swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX + 10)
+                .unwrap(),
+            MIN_TICK_INDEX + 10
+        );
+        assert_eq!(
+            swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX + 11)
+                .unwrap(),
+            MIN_TICK_INDEX + 10
+        );
+        assert_eq!(
+            swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX + 12)
+                .unwrap(),
+            MIN_TICK_INDEX + 10
+        );
+        assert_eq!(
+            swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX),
+            None
+        );
+        assert_eq!(
+            swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX + 9),
+            None
+        );
+
+        assert_eq!(
+            swap.find_closest_higher_active_tick_index(MIN_TICK_INDEX + 10)
+                .unwrap(),
+            MIN_TICK_INDEX + 10
+        );
+        assert_eq!(
+            swap.find_closest_higher_active_tick_index(MIN_TICK_INDEX + 11),
+            None
+        );
+        assert_eq!(
+            swap.find_closest_higher_active_tick_index(MIN_TICK_INDEX + 12),
+            None
+        );
+        assert_eq!(
+            swap.find_closest_higher_active_tick_index(MIN_TICK_INDEX)
+                .unwrap(),
+            MIN_TICK_INDEX + 10
+        );
+        assert_eq!(
+            swap.find_closest_higher_active_tick_index(MIN_TICK_INDEX + 9)
+                .unwrap(),
+            MIN_TICK_INDEX + 10
+        );
     }
 
     #[test]
@@ -2091,8 +2198,16 @@ mod tests {
             swap.insert_active_tick(MIN_TICK_INDEX + i);
         }
         for i in 0..1000 {
-            assert_eq!(swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX + i).unwrap(), MIN_TICK_INDEX + i);
-            assert_eq!(swap.find_closest_higher_active_tick_index(MIN_TICK_INDEX + i).unwrap(), MIN_TICK_INDEX + i);
+            assert_eq!(
+                swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX + i)
+                    .unwrap(),
+                MIN_TICK_INDEX + i
+            );
+            assert_eq!(
+                swap.find_closest_higher_active_tick_index(MIN_TICK_INDEX + i)
+                    .unwrap(),
+                MIN_TICK_INDEX + i
+            );
         }
     }
 
@@ -2106,13 +2221,35 @@ mod tests {
             swap.insert_active_tick(i * 10);
         }
         for i in 1..count {
-            assert_eq!(swap.find_closest_lower_active_tick_index(i * 10).unwrap(), i * 10);
-            assert_eq!(swap.find_closest_higher_active_tick_index(i * 10).unwrap(), i * 10);
+            assert_eq!(
+                swap.find_closest_lower_active_tick_index(i * 10).unwrap(),
+                i * 10
+            );
+            assert_eq!(
+                swap.find_closest_higher_active_tick_index(i * 10).unwrap(),
+                i * 10
+            );
             for j in 1..=9 {
-                assert_eq!(swap.find_closest_lower_active_tick_index(i * 10 - j).unwrap(), (i-1) * 10);
-                assert_eq!(swap.find_closest_lower_active_tick_index(i * 10 + j).unwrap(), i * 10);
-                assert_eq!(swap.find_closest_higher_active_tick_index(i * 10 - j).unwrap(), i * 10);
-                assert_eq!(swap.find_closest_higher_active_tick_index(i * 10 + j).unwrap(), (i+1) * 10);
+                assert_eq!(
+                    swap.find_closest_lower_active_tick_index(i * 10 - j)
+                        .unwrap(),
+                    (i - 1) * 10
+                );
+                assert_eq!(
+                    swap.find_closest_lower_active_tick_index(i * 10 + j)
+                        .unwrap(),
+                    i * 10
+                );
+                assert_eq!(
+                    swap.find_closest_higher_active_tick_index(i * 10 - j)
+                        .unwrap(),
+                    i * 10
+                );
+                assert_eq!(
+                    swap.find_closest_higher_active_tick_index(i * 10 + j)
+                        .unwrap(),
+                    (i + 1) * 10
+                );
             }
         }
     }
@@ -2127,15 +2264,37 @@ mod tests {
             swap.insert_active_tick(i * 10);
         }
         for i in 1..count {
-            assert_eq!(swap.find_closest_lower_active_tick_index(i * 10).unwrap(), i * 10);
-            assert_eq!(swap.find_closest_higher_active_tick_index(i * 10).unwrap(), i * 10);
+            assert_eq!(
+                swap.find_closest_lower_active_tick_index(i * 10).unwrap(),
+                i * 10
+            );
+            assert_eq!(
+                swap.find_closest_higher_active_tick_index(i * 10).unwrap(),
+                i * 10
+            );
             for j in 1..=9 {
-                assert_eq!(swap.find_closest_lower_active_tick_index(i * 10 - j).unwrap(), (i-1) * 10);
-                assert_eq!(swap.find_closest_lower_active_tick_index(i * 10 + j).unwrap(), i * 10);
-                assert_eq!(swap.find_closest_higher_active_tick_index(i * 10 - j).unwrap(), i * 10);
-                assert_eq!(swap.find_closest_higher_active_tick_index(i * 10 + j).unwrap(), (i+1) * 10);
+                assert_eq!(
+                    swap.find_closest_lower_active_tick_index(i * 10 - j)
+                        .unwrap(),
+                    (i - 1) * 10
+                );
+                assert_eq!(
+                    swap.find_closest_lower_active_tick_index(i * 10 + j)
+                        .unwrap(),
+                    i * 10
+                );
+                assert_eq!(
+                    swap.find_closest_higher_active_tick_index(i * 10 - j)
+                        .unwrap(),
+                    i * 10
+                );
+                assert_eq!(
+                    swap.find_closest_higher_active_tick_index(i * 10 + j)
+                        .unwrap(),
+                    (i + 1) * 10
+                );
             }
-        }        
+        }
     }
 
     #[test]
@@ -2149,13 +2308,35 @@ mod tests {
                 swap.insert_active_tick(i * 10);
             }
             for i in 1..count {
-                assert_eq!(swap.find_closest_lower_active_tick_index(i * 10).unwrap(), i * 10);
-                assert_eq!(swap.find_closest_higher_active_tick_index(i * 10).unwrap(), i * 10);
+                assert_eq!(
+                    swap.find_closest_lower_active_tick_index(i * 10).unwrap(),
+                    i * 10
+                );
+                assert_eq!(
+                    swap.find_closest_higher_active_tick_index(i * 10).unwrap(),
+                    i * 10
+                );
                 for j in 1..=9 {
-                    assert_eq!(swap.find_closest_lower_active_tick_index(i * 10 - j).unwrap(), (i-1) * 10);
-                    assert_eq!(swap.find_closest_lower_active_tick_index(i * 10 + j).unwrap(), i * 10);
-                    assert_eq!(swap.find_closest_higher_active_tick_index(i * 10 - j).unwrap(), i * 10);
-                    assert_eq!(swap.find_closest_higher_active_tick_index(i * 10 + j).unwrap(), (i+1) * 10);
+                    assert_eq!(
+                        swap.find_closest_lower_active_tick_index(i * 10 - j)
+                            .unwrap(),
+                        (i - 1) * 10
+                    );
+                    assert_eq!(
+                        swap.find_closest_lower_active_tick_index(i * 10 + j)
+                            .unwrap(),
+                        i * 10
+                    );
+                    assert_eq!(
+                        swap.find_closest_higher_active_tick_index(i * 10 - j)
+                            .unwrap(),
+                        i * 10
+                    );
+                    assert_eq!(
+                        swap.find_closest_higher_active_tick_index(i * 10 + j)
+                            .unwrap(),
+                        (i + 1) * 10
+                    );
                 }
             }
         }
@@ -2165,7 +2346,7 @@ mod tests {
     fn test_tick_search_full_range() {
         let mock_ops = MockSwapDataOperations::new();
         let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
-        let step= 1019;
+        let step = 1019;
         let count = (MAX_TICK_INDEX - MIN_TICK_INDEX) / step;
 
         for i in 0..=count {
@@ -2175,23 +2356,69 @@ mod tests {
         for i in 1..count {
             let index = MIN_TICK_INDEX + i * step;
 
-            assert_eq!(swap.find_closest_lower_active_tick_index(index - step).unwrap(), index - step);
-            assert_eq!(swap.find_closest_lower_active_tick_index(index).unwrap(), index);
-            assert_eq!(swap.find_closest_lower_active_tick_index(index + step - 1).unwrap(), index);
-            assert_eq!(swap.find_closest_lower_active_tick_index(index + step/2).unwrap(), index);
+            assert_eq!(
+                swap.find_closest_lower_active_tick_index(index - step)
+                    .unwrap(),
+                index - step
+            );
+            assert_eq!(
+                swap.find_closest_lower_active_tick_index(index).unwrap(),
+                index
+            );
+            assert_eq!(
+                swap.find_closest_lower_active_tick_index(index + step - 1)
+                    .unwrap(),
+                index
+            );
+            assert_eq!(
+                swap.find_closest_lower_active_tick_index(index + step / 2)
+                    .unwrap(),
+                index
+            );
 
-            assert_eq!(swap.find_closest_higher_active_tick_index(index).unwrap(), index);
-            assert_eq!(swap.find_closest_higher_active_tick_index(index + step).unwrap(), index + step);
-            assert_eq!(swap.find_closest_higher_active_tick_index(index + step/2).unwrap(), index + step);
-            assert_eq!(swap.find_closest_higher_active_tick_index(index + step - 1).unwrap(), index + step);
+            assert_eq!(
+                swap.find_closest_higher_active_tick_index(index).unwrap(),
+                index
+            );
+            assert_eq!(
+                swap.find_closest_higher_active_tick_index(index + step)
+                    .unwrap(),
+                index + step
+            );
+            assert_eq!(
+                swap.find_closest_higher_active_tick_index(index + step / 2)
+                    .unwrap(),
+                index + step
+            );
+            assert_eq!(
+                swap.find_closest_higher_active_tick_index(index + step - 1)
+                    .unwrap(),
+                index + step
+            );
             for j in 1..=9 {
-                assert_eq!(swap.find_closest_lower_active_tick_index(index - j).unwrap(), index - step);
-                assert_eq!(swap.find_closest_lower_active_tick_index(index + j).unwrap(), index);
-                assert_eq!(swap.find_closest_higher_active_tick_index(index - j).unwrap(), index);
-                assert_eq!(swap.find_closest_higher_active_tick_index(index + j).unwrap(), index + step);
+                assert_eq!(
+                    swap.find_closest_lower_active_tick_index(index - j)
+                        .unwrap(),
+                    index - step
+                );
+                assert_eq!(
+                    swap.find_closest_lower_active_tick_index(index + j)
+                        .unwrap(),
+                    index
+                );
+                assert_eq!(
+                    swap.find_closest_higher_active_tick_index(index - j)
+                        .unwrap(),
+                    index
+                );
+                assert_eq!(
+                    swap.find_closest_higher_active_tick_index(index + j)
+                        .unwrap(),
+                    index + step
+                );
             }
         }
-    }    
+    }
 
     #[test]
     fn test_tick_remove_basic() {
@@ -2202,24 +2429,60 @@ mod tests {
         swap.insert_active_tick(MAX_TICK_INDEX);
         swap.remove_active_tick(MAX_TICK_INDEX);
 
-        assert_eq!(swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX).unwrap(), MIN_TICK_INDEX);
-        assert_eq!(swap.find_closest_lower_active_tick_index(MAX_TICK_INDEX).unwrap(), MIN_TICK_INDEX);
-        assert_eq!(swap.find_closest_lower_active_tick_index(MAX_TICK_INDEX/2).unwrap(), MIN_TICK_INDEX);
-        assert_eq!(swap.find_closest_lower_active_tick_index(MAX_TICK_INDEX - 1).unwrap(), MIN_TICK_INDEX);
-        assert_eq!(swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX+1).unwrap(), MIN_TICK_INDEX);
-
-        assert_eq!(swap.find_closest_higher_active_tick_index(MIN_TICK_INDEX).unwrap(), MIN_TICK_INDEX);
-        assert_eq!(swap.find_closest_higher_active_tick_index(MAX_TICK_INDEX), None);
-        assert_eq!(swap.find_closest_higher_active_tick_index(MAX_TICK_INDEX/2), None);
-        assert_eq!(swap.find_closest_higher_active_tick_index(MAX_TICK_INDEX - 1), None);
-        assert_eq!(swap.find_closest_higher_active_tick_index(MIN_TICK_INDEX+1), None);
-    }    
+        assert_eq!(
+            swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX)
+                .unwrap(),
+            MIN_TICK_INDEX
+        );
+        assert_eq!(
+            swap.find_closest_lower_active_tick_index(MAX_TICK_INDEX)
+                .unwrap(),
+            MIN_TICK_INDEX
+        );
+        assert_eq!(
+            swap.find_closest_lower_active_tick_index(MAX_TICK_INDEX / 2)
+                .unwrap(),
+            MIN_TICK_INDEX
+        );
+        assert_eq!(
+            swap.find_closest_lower_active_tick_index(MAX_TICK_INDEX - 1)
+                .unwrap(),
+            MIN_TICK_INDEX
+        );
+        assert_eq!(
+            swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX + 1)
+                .unwrap(),
+            MIN_TICK_INDEX
+        );
+
+        assert_eq!(
+            swap.find_closest_higher_active_tick_index(MIN_TICK_INDEX)
+                .unwrap(),
+            MIN_TICK_INDEX
+        );
+        assert_eq!(
+            swap.find_closest_higher_active_tick_index(MAX_TICK_INDEX),
+            None
+        );
+        assert_eq!(
+            swap.find_closest_higher_active_tick_index(MAX_TICK_INDEX / 2),
+            None
+        );
+        assert_eq!(
+            swap.find_closest_higher_active_tick_index(MAX_TICK_INDEX - 1),
+            None
+        );
+        assert_eq!(
+            swap.find_closest_higher_active_tick_index(MIN_TICK_INDEX + 1),
+            None
+        );
+    }
 
     #[test]
     fn test_tick_remove_full_range() {
         let mock_ops = MockSwapDataOperations::new();
         let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
-        let step= 1019;
+        let step = 1019;
         let count = (MAX_TICK_INDEX - MIN_TICK_INDEX) / step;
         let remove_frequency = 5; // Remove every 5th tick
 
@@ -2247,8 +2510,14 @@ mod tests {
                 assert!(lower != Some(index));
                 assert!(higher != Some(index));
             } else {
-                assert_eq!(swap.find_closest_lower_active_tick_index(index).unwrap(), index);
-                assert_eq!(swap.find_closest_higher_active_tick_index(index).unwrap(), index);
+                assert_eq!(
+                    swap.find_closest_lower_active_tick_index(index).unwrap(),
+                    index
+                );
+                assert_eq!(
+                    swap.find_closest_higher_active_tick_index(index).unwrap(),
+                    index
+                );
             }
         }
     }
diff --git a/pallets/swap/src/tick.rs b/pallets/swap/src/tick.rs
index 610f7cd2d4..7f2272b415 100644
--- a/pallets/swap/src/tick.rs
+++ b/pallets/swap/src/tick.rs
@@ -2,7 +2,8 @@
 use core::convert::TryFrom;
 use core::error::Error;
 use core::fmt;
-use core::ops::{BitOr, Neg, Shl, Shr};
+use core::hash::Hash;
+use core::ops::{Add, AddAssign, BitOr, Deref, Neg, Shl, Shr, Sub, SubAssign};
 
 use alloy_primitives::{I256, U256};
 use frame_support::pallet_prelude::*;
@@ -44,9 +45,6 @@ const U256_MAX_TICK: U256 = U256::from_limbs([887272, 0, 0, 0]);
 const MIN_TICK: i32 = -887272;
 const MAX_TICK: i32 = -MIN_TICK;
 
-pub const MIN_TICK_INDEX: i32 = -443636;
-pub const MAX_TICK_INDEX: i32 = -MIN_TICK_INDEX;
-
 const MIN_SQRT_RATIO: U256 = U256::from_limbs([4295128739, 0, 0, 0]);
 const MAX_SQRT_RATIO: U256 =
     U256::from_limbs([6743328256752651558, 17280870778742802505, 4294805859, 0]);
@@ -71,9 +69,6 @@ const TICK_HIGH: I256 = I256::from_raw(U256::from_limbs([
 ///  - Net liquidity
 ///  - Gross liquidity
 ///  - Fees (above global) in both currencies
-use core::hash::Hash;
-use core::ops::{Add, AddAssign, Deref, Sub, SubAssign};
-
 #[derive(Debug, Default, Clone, Encode, Decode, TypeInfo, MaxEncodedLen, PartialEq, Eq)]
 pub struct Tick {
     pub liquidity_net: i128,
@@ -98,7 +93,7 @@ pub struct Tick {
     Ord,
     Hash,
 )]
-pub struct TickIndex(pub i32);
+pub struct TickIndex(i32);
 
 impl Add<TickIndex> for TickIndex {
     type Output = Self;
@@ -256,6 +251,82 @@ impl TickIndex {
         Self::new(self.0 - value)
     }
 
+    /// Add a value to this tick index, saturating at the bounds instead of overflowing
+    pub fn saturating_add(&self, value: i32) -> Self {
+        match self.checked_add(value) {
+            Ok(result) => result,
+            Err(_) => {
+                if value > 0 {
+                    Self::MAX
+                } else {
+                    Self::MIN
+                }
+            }
+        }
+    }
+
+    /// Subtract a value from this tick index, saturating at the bounds instead of overflowing
+    pub fn saturating_sub(&self, value: i32) -> Self {
+        match self.checked_sub(value) {
+            Ok(result) => result,
+            Err(_) => {
+                if value > 0 {
+                    Self::MIN
+                } else {
+                    Self::MAX
+                }
+            }
+        }
+    }
+
+    /// Divide the tick index by a value with bounds checking
+    pub fn checked_div(&self, value: i32) -> Result<Self, TickMathError> {
+        if value == 0 {
+            return Err(TickMathError::DivisionByZero);
+        }
+        Self::new(self.0 / value)
+    }
+
+    /// Divide the tick index by a value, saturating at the bounds
+    pub fn saturating_div(&self, value: i32) -> Self {
+        if value == 0 {
+            return Self::MAX; // Return MAX for division by zero
+        }
+        match self.checked_div(value) {
+            Ok(result) => result,
+            Err(_) => {
+                if (self.0 < 0 && value > 0) || (self.0 > 0 && value < 0) {
+                    Self::MIN
+                } else {
+                    Self::MAX
+                }
+            }
+        }
+    }
+
+    /// Multiply the tick index by a value with bounds checking
+    pub fn checked_mul(&self, value: i32) -> Result<Self, TickMathError> {
+        // Check for potential overflow
+        match self.0.checked_mul(value) {
+            Some(result) => Self::new(result),
+            None => Err(TickMathError::Overflow),
+        }
+    }
+
+    /// Multiply the tick index by a value, saturating at the bounds
+    pub fn saturating_mul(&self, value: i32) -> Self {
+        match self.checked_mul(value) {
+            Ok(result) => result,
+            Err(_) => {
+                if (self.0 < 0 && value > 0) || (self.0 > 0 && value < 0) {
+                    Self::MIN
+                } else {
+                    Self::MAX
+                }
+            }
+        }
+    }
+
     /// Converts tick index into SQRT of lower price of this tick In order to find the higher price
     /// of this tick, call tick_index_to_sqrt_price(tick_idx + 1)
     pub fn try_to_sqrt_price(&self) -> Result<SqrtPrice, TickMathError> {
@@ -600,6 +671,7 @@ pub enum TickMathError {
     SqrtPriceOutOfBounds,
     ConversionError,
     Overflow,
+    DivisionByZero,
 }
 
 impl fmt::Display for TickMathError {
@@ -608,7 +680,8 @@ impl fmt::Display for TickMathError {
 			Self::TickOutOfBounds => f.write_str("The given tick is outside of the minimum/maximum values."),
 			Self::SqrtPriceOutOfBounds =>f.write_str("Second inequality must be < because the price can never reach the price at the max tick"),
 			Self::ConversionError => f.write_str("Error converting from one number type into another"),
-			Self::Overflow => f.write_str("Number overflow in arithmetic operation")
+			Self::Overflow => f.write_str("Number overflow in arithmetic operation"),
+			Self::DivisionByZero => f.write_str("Division by zero is not allowed")
 		}
     }
 }

From 9e92b07ec7c5b2e566f7734d365ddbc62fd988d9 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Wed, 26 Mar 2025 12:05:36 +0100
Subject: [PATCH 030/418] Replace TICK_OFFSET with TickIndex::OFFSET

---
 pallets/swap/src/lib.rs  | 42 +++++++++++++++-------------------------
 pallets/swap/src/tick.rs |  4 ++++
 2 files changed, 20 insertions(+), 26 deletions(-)

diff --git a/pallets/swap/src/lib.rs b/pallets/swap/src/lib.rs
index 04a4fd1f70..bfb5978339 100644
--- a/pallets/swap/src/lib.rs
+++ b/pallets/swap/src/lib.rs
@@ -16,10 +16,6 @@ mod tick;
 
 type SqrtPrice = U64F64;
 
-/// All tick indexes are offset by TICK_OFFSET for the search and active tick storage needs
-/// so that tick indexes are positive, which simplifies bit logic
-pub const TICK_OFFSET: u32 = 887272;
-
 pub enum SwapStepAction {
     Crossing,
     StopOn,
@@ -1131,15 +1127,15 @@ where
         word.saturating_mul(128).saturating_add(bit)
     }
 
-    pub fn insert_active_tick(&mut self, index: tick::TickIndex) {
+    pub fn insert_active_tick(&mut self, index: TickIndex) {
         // Check the range
-        if (index < tick::TickIndex::MIN) || (index > tick::TickIndex::MAX) {
+        if (index < TickIndex::MIN) || (index > TickIndex::MAX) {
             return;
         }
 
         // Convert the tick index value to an offset_index for the tree representation
         // to avoid working with the sign bit.
-        let offset_index = index.saturating_add(TICK_OFFSET as i32).get() as u32;
+        let offset_index = (index.get() + TickIndex::OFFSET.get()) as u32;
 
         // Calculate index in each layer
         let (layer2_word, layer2_bit) = Self::index_to_address(offset_index);
@@ -1161,15 +1157,15 @@ where
         self.state_ops.set_layer2_word(layer2_word, word2_value);
     }
 
-    pub fn remove_active_tick(&mut self, index: tick::TickIndex) {
+    pub fn remove_active_tick(&mut self, index: TickIndex) {
         // Check the range
-        if (index < tick::TickIndex::MIN) || (index > tick::TickIndex::MAX) {
+        if (index < TickIndex::MIN) || (index > TickIndex::MAX) {
             return;
         }
 
         // Convert the tick index value to an offset_index for the tree representation
         // to avoid working with the sign bit.
-        let offset_index = index.saturating_add(TICK_OFFSET as i32).get() as u32;
+        let offset_index = (index.get() + TickIndex::OFFSET.get()) as u32;
 
         // Calculate index in each layer
         let (layer2_word, layer2_bit) = Self::index_to_address(offset_index);
@@ -1223,17 +1219,17 @@ where
 
     pub fn find_closest_active_tick_index(
         &self,
-        index: tick::TickIndex,
+        index: TickIndex,
         lower: bool,
-    ) -> Option<tick::TickIndex> {
+    ) -> Option<TickIndex> {
         // Check the range
-        if (index < tick::TickIndex::MIN) || (index > tick::TickIndex::MAX) {
+        if (index < TickIndex::MIN) || (index > TickIndex::MAX) {
             return None;
         }
 
         // Convert the tick index value to an offset_index for the tree representation
         // to avoid working with the sign bit.
-        let offset_index = index.saturating_add(TICK_OFFSET as i32).get() as u32;
+        let offset_index = (index.get() + TickIndex::OFFSET.get()) as u32;
         let mut found = false;
         let mut result: u32 = 0;
 
@@ -1306,28 +1302,22 @@ where
 
         if found {
             // Convert the tree offset_index back to a tick index value
-            let tick_value = (result as i32).saturating_sub(TICK_OFFSET as i32);
-            Some(tick::TickIndex::new_unchecked(tick_value))
+            let tick_value = (result as i32).saturating_sub(TickIndex::OFFSET.get());
+            Some(TickIndex::new_unchecked(tick_value))
         } else {
             None
         }
     }
 
-    pub fn find_closest_lower_active_tick_index(
-        &self,
-        index: tick::TickIndex,
-    ) -> Option<tick::TickIndex> {
+    pub fn find_closest_lower_active_tick_index(&self, index: TickIndex) -> Option<TickIndex> {
         self.find_closest_active_tick_index(index, true)
     }
 
-    pub fn find_closest_higher_active_tick_index(
-        &self,
-        index: tick::TickIndex,
-    ) -> Option<tick::TickIndex> {
+    pub fn find_closest_higher_active_tick_index(&self, index: TickIndex) -> Option<TickIndex> {
         self.find_closest_active_tick_index(index, false)
     }
 
-    pub fn find_closest_lower_active_tick(&self, index: tick::TickIndex) -> Option<Tick> {
+    pub fn find_closest_lower_active_tick(&self, index: TickIndex) -> Option<Tick> {
         let maybe_tick_index = self.find_closest_lower_active_tick_index(index);
         if let Some(tick_index) = maybe_tick_index {
             self.state_ops.get_tick_by_index(tick_index)
@@ -1336,7 +1326,7 @@ where
         }
     }
 
-    pub fn find_closest_higher_active_tick(&self, index: tick::TickIndex) -> Option<Tick> {
+    pub fn find_closest_higher_active_tick(&self, index: TickIndex) -> Option<Tick> {
         let maybe_tick_index = self.find_closest_higher_active_tick_index(index);
         if let Some(tick_index) = maybe_tick_index {
             self.state_ops.get_tick_by_index(tick_index)
diff --git a/pallets/swap/src/tick.rs b/pallets/swap/src/tick.rs
index 7f2272b415..809b261702 100644
--- a/pallets/swap/src/tick.rs
+++ b/pallets/swap/src/tick.rs
@@ -166,6 +166,10 @@ impl TickIndex {
     /// Minimum value of the tick index
     /// The tick_math library uses different bitness, so we have to divide by 2.
     pub const MIN: Self = Self(MIN_TICK / 2);
+    
+    /// All tick indexes are offset by this value for storage needs
+    /// so that tick indexes are positive, which simplifies bit logic
+    pub const OFFSET: Self = Self(MAX_TICK);
 
     /// Converts a sqrt price to a tick index, ensuring it's within valid bounds
     ///

From 548cf7b1a36a1a9784ae61b47c906f159c401010 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Wed, 26 Mar 2025 14:23:08 +0100
Subject: [PATCH 031/418] Actualize tests in pallet-subtensor-swap

---
 pallets/swap/src/lib.rs | 304 ++++++++++++++++++++++------------------
 1 file changed, 170 insertions(+), 134 deletions(-)

diff --git a/pallets/swap/src/lib.rs b/pallets/swap/src/lib.rs
index bfb5978339..ab98205b44 100644
--- a/pallets/swap/src/lib.rs
+++ b/pallets/swap/src/lib.rs
@@ -2047,80 +2047,80 @@ mod tests {
         let mock_ops = MockSwapDataOperations::new();
         let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
 
-        swap.insert_active_tick(MIN_TICK_INDEX);
+        swap.insert_active_tick(TickIndex::MIN);
         assert_eq!(
-            swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX)
+            swap.find_closest_lower_active_tick_index(TickIndex::MIN)
                 .unwrap(),
-            MIN_TICK_INDEX
+            TickIndex::MIN
         );
         assert_eq!(
-            swap.find_closest_lower_active_tick_index(MAX_TICK_INDEX)
+            swap.find_closest_lower_active_tick_index(TickIndex::MAX)
                 .unwrap(),
-            MIN_TICK_INDEX
+            TickIndex::MIN
         );
         assert_eq!(
-            swap.find_closest_lower_active_tick_index(MAX_TICK_INDEX / 2)
+            swap.find_closest_lower_active_tick_index(TickIndex::MAX.saturating_div(2))
                 .unwrap(),
-            MIN_TICK_INDEX
+            TickIndex::MIN
         );
         assert_eq!(
-            swap.find_closest_lower_active_tick_index(MAX_TICK_INDEX - 1)
+            swap.find_closest_lower_active_tick_index(TickIndex::MAX.prev().unwrap())
                 .unwrap(),
-            MIN_TICK_INDEX
+            TickIndex::MIN
         );
         assert_eq!(
-            swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX + 1)
+            swap.find_closest_lower_active_tick_index(TickIndex::MIN.next().unwrap())
                 .unwrap(),
-            MIN_TICK_INDEX
+            TickIndex::MIN
         );
 
         assert_eq!(
-            swap.find_closest_higher_active_tick_index(MIN_TICK_INDEX)
+            swap.find_closest_higher_active_tick_index(TickIndex::MIN)
                 .unwrap(),
-            MIN_TICK_INDEX
+            TickIndex::MIN
         );
         assert_eq!(
-            swap.find_closest_higher_active_tick_index(MAX_TICK_INDEX),
+            swap.find_closest_higher_active_tick_index(TickIndex::MAX),
             None
         );
         assert_eq!(
-            swap.find_closest_higher_active_tick_index(MAX_TICK_INDEX / 2),
+            swap.find_closest_higher_active_tick_index(TickIndex::MAX.saturating_div(2)),
             None
         );
         assert_eq!(
-            swap.find_closest_higher_active_tick_index(MAX_TICK_INDEX - 1),
+            swap.find_closest_higher_active_tick_index(TickIndex::MAX.prev().unwrap()),
             None
         );
         assert_eq!(
-            swap.find_closest_higher_active_tick_index(MIN_TICK_INDEX + 1),
+            swap.find_closest_higher_active_tick_index(TickIndex::MIN.next().unwrap()),
             None
         );
 
-        swap.insert_active_tick(MAX_TICK_INDEX);
+        swap.insert_active_tick(TickIndex::MAX);
         assert_eq!(
-            swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX)
+            swap.find_closest_lower_active_tick_index(TickIndex::MIN)
                 .unwrap(),
-            MIN_TICK_INDEX
+            TickIndex::MIN
         );
         assert_eq!(
-            swap.find_closest_lower_active_tick_index(MAX_TICK_INDEX)
+            swap.find_closest_lower_active_tick_index(TickIndex::MAX)
                 .unwrap(),
-            MAX_TICK_INDEX
+            TickIndex::MAX
         );
         assert_eq!(
-            swap.find_closest_lower_active_tick_index(MAX_TICK_INDEX / 2)
+            swap.find_closest_lower_active_tick_index(TickIndex::MAX.saturating_div(2))
                 .unwrap(),
-            MIN_TICK_INDEX
+            TickIndex::MIN
         );
         assert_eq!(
-            swap.find_closest_lower_active_tick_index(MAX_TICK_INDEX - 1)
+            swap.find_closest_lower_active_tick_index(TickIndex::MAX.prev().unwrap())
                 .unwrap(),
-            MIN_TICK_INDEX
+            TickIndex::MIN
         );
         assert_eq!(
-            swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX + 1)
+            swap.find_closest_lower_active_tick_index(TickIndex::MIN.next().unwrap())
                 .unwrap(),
-            MIN_TICK_INDEX
+            TickIndex::MIN
         );
     }
 
@@ -2129,53 +2129,54 @@ mod tests {
         let mock_ops = MockSwapDataOperations::new();
         let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
 
-        swap.insert_active_tick(MIN_TICK_INDEX + 10);
+        let active_index = TickIndex::MIN.saturating_add(10);
+        swap.insert_active_tick(active_index);
         assert_eq!(
-            swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX + 10)
+            swap.find_closest_lower_active_tick_index(active_index)
                 .unwrap(),
-            MIN_TICK_INDEX + 10
+            active_index
         );
         assert_eq!(
-            swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX + 11)
+            swap.find_closest_lower_active_tick_index(TickIndex::MIN.saturating_add(11))
                 .unwrap(),
-            MIN_TICK_INDEX + 10
+            active_index
         );
         assert_eq!(
-            swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX + 12)
+            swap.find_closest_lower_active_tick_index(TickIndex::MIN.saturating_add(12))
                 .unwrap(),
-            MIN_TICK_INDEX + 10
+            active_index
         );
         assert_eq!(
-            swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX),
+            swap.find_closest_lower_active_tick_index(TickIndex::MIN),
             None
         );
         assert_eq!(
-            swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX + 9),
+            swap.find_closest_lower_active_tick_index(TickIndex::MIN.saturating_add(9)),
             None
         );
 
         assert_eq!(
-            swap.find_closest_higher_active_tick_index(MIN_TICK_INDEX + 10)
+            swap.find_closest_higher_active_tick_index(active_index)
                 .unwrap(),
-            MIN_TICK_INDEX + 10
+            active_index
         );
         assert_eq!(
-            swap.find_closest_higher_active_tick_index(MIN_TICK_INDEX + 11),
+            swap.find_closest_higher_active_tick_index(TickIndex::MIN.saturating_add(11)),
             None
         );
         assert_eq!(
-            swap.find_closest_higher_active_tick_index(MIN_TICK_INDEX + 12),
+            swap.find_closest_higher_active_tick_index(TickIndex::MIN.saturating_add(12)),
             None
         );
         assert_eq!(
-            swap.find_closest_higher_active_tick_index(MIN_TICK_INDEX)
+            swap.find_closest_higher_active_tick_index(TickIndex::MIN)
                 .unwrap(),
-            MIN_TICK_INDEX + 10
+            active_index
         );
         assert_eq!(
-            swap.find_closest_higher_active_tick_index(MIN_TICK_INDEX + 9)
+            swap.find_closest_higher_active_tick_index(TickIndex::MIN.saturating_add(9))
                 .unwrap(),
-            MIN_TICK_INDEX + 10
+            active_index
         );
     }
 
@@ -2184,19 +2185,21 @@ mod tests {
         let mock_ops = MockSwapDataOperations::new();
         let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
 
+        (0..1000).for_each(|i| {
+            swap.insert_active_tick(TickIndex::MIN.saturating_add(i));
+        });
+
         for i in 0..1000 {
-            swap.insert_active_tick(MIN_TICK_INDEX + i);
-        }
-        for i in 0..1000 {
+            let test_index = TickIndex::MIN.saturating_add(i);
             assert_eq!(
-                swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX + i)
+                swap.find_closest_lower_active_tick_index(test_index)
                     .unwrap(),
-                MIN_TICK_INDEX + i
+                test_index
             );
             assert_eq!(
-                swap.find_closest_higher_active_tick_index(MIN_TICK_INDEX + i)
+                swap.find_closest_higher_active_tick_index(test_index)
                     .unwrap(),
-                MIN_TICK_INDEX + i
+                test_index
             );
         }
     }
@@ -2208,37 +2211,42 @@ mod tests {
         let count: i32 = 1000;
 
         for i in 0..=count {
-            swap.insert_active_tick(i * 10);
+            swap.insert_active_tick(TickIndex::new_unchecked(i * 10));
         }
         for i in 1..count {
+            let tick = TickIndex::new_unchecked(i * 10);
             assert_eq!(
-                swap.find_closest_lower_active_tick_index(i * 10).unwrap(),
-                i * 10
+                swap.find_closest_lower_active_tick_index(tick).unwrap(),
+                tick
             );
             assert_eq!(
-                swap.find_closest_higher_active_tick_index(i * 10).unwrap(),
-                i * 10
+                swap.find_closest_higher_active_tick_index(tick).unwrap(),
+                tick
             );
             for j in 1..=9 {
+                let before_tick = TickIndex::new_unchecked(i * 10 - j);
+                let after_tick = TickIndex::new_unchecked(i * 10 + j);
+                let prev_tick = TickIndex::new_unchecked((i - 1) * 10);
+                let next_tick = TickIndex::new_unchecked((i + 1) * 10);
                 assert_eq!(
-                    swap.find_closest_lower_active_tick_index(i * 10 - j)
+                    swap.find_closest_lower_active_tick_index(before_tick)
                         .unwrap(),
-                    (i - 1) * 10
+                    prev_tick
                 );
                 assert_eq!(
-                    swap.find_closest_lower_active_tick_index(i * 10 + j)
+                    swap.find_closest_lower_active_tick_index(after_tick)
                         .unwrap(),
-                    i * 10
+                    tick
                 );
                 assert_eq!(
-                    swap.find_closest_higher_active_tick_index(i * 10 - j)
+                    swap.find_closest_higher_active_tick_index(before_tick)
                         .unwrap(),
-                    i * 10
+                    tick
                 );
                 assert_eq!(
-                    swap.find_closest_higher_active_tick_index(i * 10 + j)
+                    swap.find_closest_higher_active_tick_index(after_tick)
                         .unwrap(),
-                    (i + 1) * 10
+                    next_tick
                 );
             }
         }
@@ -2251,37 +2259,43 @@ mod tests {
         let count: i32 = 1000;
 
         for i in (0..=count).rev() {
-            swap.insert_active_tick(i * 10);
+            swap.insert_active_tick(TickIndex::new_unchecked(i * 10));
         }
         for i in 1..count {
+            let tick = TickIndex::new_unchecked(i * 10);
             assert_eq!(
-                swap.find_closest_lower_active_tick_index(i * 10).unwrap(),
-                i * 10
+                swap.find_closest_lower_active_tick_index(tick).unwrap(),
+                tick
             );
             assert_eq!(
-                swap.find_closest_higher_active_tick_index(i * 10).unwrap(),
-                i * 10
+                swap.find_closest_higher_active_tick_index(tick).unwrap(),
+                tick
             );
             for j in 1..=9 {
+                let before_tick = TickIndex::new_unchecked(i * 10 - j);
+                let after_tick = TickIndex::new_unchecked(i * 10 + j);
+                let prev_tick = TickIndex::new_unchecked((i - 1) * 10);
+                let next_tick = TickIndex::new_unchecked((i + 1) * 10);
+
                 assert_eq!(
-                    swap.find_closest_lower_active_tick_index(i * 10 - j)
+                    swap.find_closest_lower_active_tick_index(before_tick)
                         .unwrap(),
-                    (i - 1) * 10
+                    prev_tick
                 );
                 assert_eq!(
-                    swap.find_closest_lower_active_tick_index(i * 10 + j)
+                    swap.find_closest_lower_active_tick_index(after_tick)
                         .unwrap(),
-                    i * 10
+                    tick
                 );
                 assert_eq!(
-                    swap.find_closest_higher_active_tick_index(i * 10 - j)
+                    swap.find_closest_higher_active_tick_index(before_tick)
                         .unwrap(),
-                    i * 10
+                    tick
                 );
                 assert_eq!(
-                    swap.find_closest_higher_active_tick_index(i * 10 + j)
+                    swap.find_closest_higher_active_tick_index(after_tick)
                         .unwrap(),
-                    (i + 1) * 10
+                    next_tick
                 );
             }
         }
@@ -2295,37 +2309,44 @@ mod tests {
 
         for _ in 0..10 {
             for i in 0..=count {
-                swap.insert_active_tick(i * 10);
+                let tick = TickIndex::new_unchecked(i * 10);
+                swap.insert_active_tick(tick);
             }
             for i in 1..count {
+                let tick = TickIndex::new_unchecked(i * 10);
                 assert_eq!(
-                    swap.find_closest_lower_active_tick_index(i * 10).unwrap(),
-                    i * 10
+                    swap.find_closest_lower_active_tick_index(tick).unwrap(),
+                    tick
                 );
                 assert_eq!(
-                    swap.find_closest_higher_active_tick_index(i * 10).unwrap(),
-                    i * 10
+                    swap.find_closest_higher_active_tick_index(tick).unwrap(),
+                    tick
                 );
                 for j in 1..=9 {
+                    let before_tick = TickIndex::new_unchecked(i * 10 - j);
+                    let after_tick = TickIndex::new_unchecked(i * 10 + j);
+                    let prev_tick = TickIndex::new_unchecked((i - 1) * 10);
+                    let next_tick = TickIndex::new_unchecked((i + 1) * 10);
+
                     assert_eq!(
-                        swap.find_closest_lower_active_tick_index(i * 10 - j)
+                        swap.find_closest_lower_active_tick_index(before_tick)
                             .unwrap(),
-                        (i - 1) * 10
+                        prev_tick
                     );
                     assert_eq!(
-                        swap.find_closest_lower_active_tick_index(i * 10 + j)
+                        swap.find_closest_lower_active_tick_index(after_tick)
                             .unwrap(),
-                        i * 10
+                        tick
                     );
                     assert_eq!(
-                        swap.find_closest_higher_active_tick_index(i * 10 - j)
+                        swap.find_closest_higher_active_tick_index(before_tick)
                             .unwrap(),
-                        i * 10
+                        tick
                     );
                     assert_eq!(
-                        swap.find_closest_higher_active_tick_index(i * 10 + j)
+                        swap.find_closest_higher_active_tick_index(after_tick)
                             .unwrap(),
-                        (i + 1) * 10
+                        next_tick
                     );
                 }
             }
@@ -2337,32 +2358,37 @@ mod tests {
         let mock_ops = MockSwapDataOperations::new();
         let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
         let step = 1019;
-        let count = (MAX_TICK_INDEX - MIN_TICK_INDEX) / step;
+        // Get the full valid tick range by subtracting MIN from MAX
+        let count = (TickIndex::MAX.get() - TickIndex::MIN.get()) / step;
 
         for i in 0..=count {
-            let index = MIN_TICK_INDEX + i * step;
+            let index = TickIndex::MIN.saturating_add(i * step);
             swap.insert_active_tick(index);
         }
         for i in 1..count {
-            let index = MIN_TICK_INDEX + i * step;
+            let index = TickIndex::MIN.saturating_add(i * step);
+
+            let prev_index = TickIndex::new_unchecked(index.get() - step);
+            let next_minus_one = TickIndex::new_unchecked(index.get() + step - 1);
 
             assert_eq!(
-                swap.find_closest_lower_active_tick_index(index - step)
+                swap.find_closest_lower_active_tick_index(prev_index)
                     .unwrap(),
-                index - step
+                prev_index
             );
             assert_eq!(
                 swap.find_closest_lower_active_tick_index(index).unwrap(),
                 index
             );
             assert_eq!(
-                swap.find_closest_lower_active_tick_index(index + step - 1)
+                swap.find_closest_lower_active_tick_index(next_minus_one)
                     .unwrap(),
                 index
             );
+
+            let mid_next = TickIndex::new_unchecked(index.get() + step / 2);
             assert_eq!(
-                swap.find_closest_lower_active_tick_index(index + step / 2)
-                    .unwrap(),
+                swap.find_closest_lower_active_tick_index(mid_next).unwrap(),
                 index
             );
 
@@ -2370,41 +2396,50 @@ mod tests {
                 swap.find_closest_higher_active_tick_index(index).unwrap(),
                 index
             );
+
+            let next_index = TickIndex::new_unchecked(index.get() + step);
             assert_eq!(
-                swap.find_closest_higher_active_tick_index(index + step)
+                swap.find_closest_higher_active_tick_index(next_index)
                     .unwrap(),
-                index + step
+                next_index
             );
+
+            let mid_next = TickIndex::new_unchecked(index.get() + step / 2);
             assert_eq!(
-                swap.find_closest_higher_active_tick_index(index + step / 2)
+                swap.find_closest_higher_active_tick_index(mid_next)
                     .unwrap(),
-                index + step
+                next_index
             );
+
+            let next_minus_1 = TickIndex::new_unchecked(index.get() + step - 1);
             assert_eq!(
-                swap.find_closest_higher_active_tick_index(index + step - 1)
+                swap.find_closest_higher_active_tick_index(next_minus_1)
                     .unwrap(),
-                index + step
+                next_index
             );
             for j in 1..=9 {
+                let before_index = TickIndex::new_unchecked(index.get() - j);
+                let after_index = TickIndex::new_unchecked(index.get() + j);
+
                 assert_eq!(
-                    swap.find_closest_lower_active_tick_index(index - j)
+                    swap.find_closest_lower_active_tick_index(before_index)
                         .unwrap(),
-                    index - step
+                    prev_index
                 );
                 assert_eq!(
-                    swap.find_closest_lower_active_tick_index(index + j)
+                    swap.find_closest_lower_active_tick_index(after_index)
                         .unwrap(),
                     index
                 );
                 assert_eq!(
-                    swap.find_closest_higher_active_tick_index(index - j)
+                    swap.find_closest_higher_active_tick_index(before_index)
                         .unwrap(),
                     index
                 );
                 assert_eq!(
-                    swap.find_closest_higher_active_tick_index(index + j)
+                    swap.find_closest_higher_active_tick_index(after_index)
                         .unwrap(),
-                    index + step
+                    next_index
                 );
             }
         }
@@ -2415,55 +2450,55 @@ mod tests {
         let mock_ops = MockSwapDataOperations::new();
         let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
 
-        swap.insert_active_tick(MIN_TICK_INDEX);
-        swap.insert_active_tick(MAX_TICK_INDEX);
-        swap.remove_active_tick(MAX_TICK_INDEX);
+        swap.insert_active_tick(TickIndex::MIN);
+        swap.insert_active_tick(TickIndex::MAX);
+        swap.remove_active_tick(TickIndex::MAX);
 
         assert_eq!(
-            swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX)
+            swap.find_closest_lower_active_tick_index(TickIndex::MIN)
                 .unwrap(),
-            MIN_TICK_INDEX
+            TickIndex::MIN
         );
         assert_eq!(
-            swap.find_closest_lower_active_tick_index(MAX_TICK_INDEX)
+            swap.find_closest_lower_active_tick_index(TickIndex::MAX)
                 .unwrap(),
-            MIN_TICK_INDEX
+            TickIndex::MIN
         );
         assert_eq!(
-            swap.find_closest_lower_active_tick_index(MAX_TICK_INDEX / 2)
+            swap.find_closest_lower_active_tick_index(TickIndex::MAX.saturating_div(2))
                 .unwrap(),
-            MIN_TICK_INDEX
+            TickIndex::MIN
         );
         assert_eq!(
-            swap.find_closest_lower_active_tick_index(MAX_TICK_INDEX - 1)
+            swap.find_closest_lower_active_tick_index(TickIndex::MAX.prev().unwrap())
                 .unwrap(),
-            MIN_TICK_INDEX
+            TickIndex::MIN
         );
         assert_eq!(
-            swap.find_closest_lower_active_tick_index(MIN_TICK_INDEX + 1)
+            swap.find_closest_lower_active_tick_index(TickIndex::MIN.next().unwrap())
                 .unwrap(),
-            MIN_TICK_INDEX
+            TickIndex::MIN
         );
 
         assert_eq!(
-            swap.find_closest_higher_active_tick_index(MIN_TICK_INDEX)
+            swap.find_closest_higher_active_tick_index(TickIndex::MIN)
                 .unwrap(),
-            MIN_TICK_INDEX
+            TickIndex::MIN
         );
         assert_eq!(
-            swap.find_closest_higher_active_tick_index(MAX_TICK_INDEX),
+            swap.find_closest_higher_active_tick_index(TickIndex::MAX),
             None
         );
         assert_eq!(
-            swap.find_closest_higher_active_tick_index(MAX_TICK_INDEX / 2),
+            swap.find_closest_higher_active_tick_index(TickIndex::MAX.saturating_div(2)),
             None
         );
         assert_eq!(
-            swap.find_closest_higher_active_tick_index(MAX_TICK_INDEX - 1),
+            swap.find_closest_higher_active_tick_index(TickIndex::MAX.prev().unwrap()),
             None
         );
         assert_eq!(
-            swap.find_closest_higher_active_tick_index(MIN_TICK_INDEX + 1),
+            swap.find_closest_higher_active_tick_index(TickIndex::MIN.next().unwrap()),
             None
         );
     }
@@ -2473,26 +2508,27 @@ mod tests {
         let mock_ops = MockSwapDataOperations::new();
         let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
         let step = 1019;
-        let count = (MAX_TICK_INDEX - MIN_TICK_INDEX) / step;
+        // Get the full valid tick range by subtracting MIN from MAX
+        let count = (TickIndex::MAX.get() - TickIndex::MIN.get()) / step;
         let remove_frequency = 5; // Remove every 5th tick
 
         // Insert ticks
         for i in 0..=count {
-            let index = MIN_TICK_INDEX + i * step;
+            let index = TickIndex::MIN.saturating_add(i * step);
             swap.insert_active_tick(index);
         }
 
         // Remove some ticks
         for i in 1..count {
             if i % remove_frequency == 0 {
-                let index = MIN_TICK_INDEX + i * step;
+                let index = TickIndex::MIN.saturating_add(i * step);
                 swap.remove_active_tick(index);
             }
         }
 
         // Verify
         for i in 1..count {
-            let index = MIN_TICK_INDEX + i * step;
+            let index = TickIndex::MIN.saturating_add(i * step);
 
             if i % remove_frequency == 0 {
                 let lower = swap.find_closest_lower_active_tick_index(index);

From 1c9e17a5bbd181522cb749354f474044f45ae916 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Wed, 26 Mar 2025 17:51:43 +0100
Subject: [PATCH 032/418] Add TickIndexBitmap

---
 pallets/swap/src/lib.rs  | 162 +++++++++++++++----------------------
 pallets/swap/src/tick.rs | 170 ++++++++++++++++++++++++++++++++++++++-
 2 files changed, 231 insertions(+), 101 deletions(-)

diff --git a/pallets/swap/src/lib.rs b/pallets/swap/src/lib.rs
index ab98205b44..a6e44e77f1 100644
--- a/pallets/swap/src/lib.rs
+++ b/pallets/swap/src/lib.rs
@@ -9,7 +9,7 @@ use safe_math::*;
 use sp_arithmetic::helpers_128bit::sqrt;
 use substrate_fixed::types::U64F64;
 
-use self::tick::{Tick, TickIndex};
+use self::tick::{Tick, TickIndex, TickIndexBitmap};
 
 pub mod pallet;
 mod tick;
@@ -1115,17 +1115,7 @@ where
     /// Deletion: 2 reads, 1-3 writes
     ///
 
-    // Addresses an index as (word, bit)
-    fn index_to_address(index: u32) -> (u32, u32) {
-        let word: u32 = index.safe_div(128);
-        let bit: u32 = index.checked_rem(128).unwrap_or_default();
-        (word, bit)
-    }
-
-    // Reconstructs an index from address in lower level
-    fn address_to_index(word: u32, bit: u32) -> u32 {
-        word.saturating_mul(128).saturating_add(bit)
-    }
+    // Use TickIndexBitmap::layer_to_index instead
 
     pub fn insert_active_tick(&mut self, index: TickIndex) {
         // Check the range
@@ -1133,28 +1123,26 @@ where
             return;
         }
 
-        // Convert the tick index value to an offset_index for the tree representation
-        // to avoid working with the sign bit.
-        let offset_index = (index.get() + TickIndex::OFFSET.get()) as u32;
-
-        // Calculate index in each layer
-        let (layer2_word, layer2_bit) = Self::index_to_address(offset_index);
-        let (layer1_word, layer1_bit) = Self::index_to_address(layer2_word);
-        let (layer0_word, layer0_bit) = Self::index_to_address(layer1_word);
+        // Convert to bitmap representation
+        let bitmap = TickIndexBitmap::from(index);
 
         // Update layer words
-        let mut word0_value = self.state_ops.get_layer0_word(layer0_word);
-        let mut word1_value = self.state_ops.get_layer1_word(layer1_word);
-        let mut word2_value = self.state_ops.get_layer2_word(layer2_word);
-
-        let bit: u128 = 1;
-        word0_value = word0_value | bit.wrapping_shl(layer0_bit);
-        word1_value = word1_value | bit.wrapping_shl(layer1_bit);
-        word2_value = word2_value | bit.wrapping_shl(layer2_bit);
-
-        self.state_ops.set_layer0_word(layer0_word, word0_value);
-        self.state_ops.set_layer1_word(layer1_word, word1_value);
-        self.state_ops.set_layer2_word(layer2_word, word2_value);
+        let mut word0_value = self.state_ops.get_layer0_word(bitmap.word_at(0));
+        let mut word1_value = self.state_ops.get_layer1_word(bitmap.word_at(1));
+        let mut word2_value = self.state_ops.get_layer2_word(bitmap.word_at(2));
+
+        // Set bits in each layer
+        word0_value |= bitmap.bit_mask(0);
+        word1_value |= bitmap.bit_mask(1);
+        word2_value |= bitmap.bit_mask(2);
+
+        // Update the storage
+        self.state_ops
+            .set_layer0_word(bitmap.word_at(0), word0_value);
+        self.state_ops
+            .set_layer1_word(bitmap.word_at(1), word1_value);
+        self.state_ops
+            .set_layer2_word(bitmap.word_at(2), word2_value);
     }
 
     pub fn remove_active_tick(&mut self, index: TickIndex) {
@@ -1163,58 +1151,30 @@ where
             return;
         }
 
-        // Convert the tick index value to an offset_index for the tree representation
-        // to avoid working with the sign bit.
-        let offset_index = (index.get() + TickIndex::OFFSET.get()) as u32;
-
-        // Calculate index in each layer
-        let (layer2_word, layer2_bit) = Self::index_to_address(offset_index);
-        let (layer1_word, layer1_bit) = Self::index_to_address(layer2_word);
-        let (layer0_word, layer0_bit) = Self::index_to_address(layer1_word);
+        // Convert to bitmap representation
+        let bitmap = TickIndexBitmap::from(index);
 
         // Update layer words
-        let mut word0_value = self.state_ops.get_layer0_word(layer0_word);
-        let mut word1_value = self.state_ops.get_layer1_word(layer1_word);
-        let mut word2_value = self.state_ops.get_layer2_word(layer2_word);
+        let mut word0_value = self.state_ops.get_layer0_word(bitmap.word_at(0));
+        let mut word1_value = self.state_ops.get_layer1_word(bitmap.word_at(1));
+        let mut word2_value = self.state_ops.get_layer2_word(bitmap.word_at(2));
 
         // Turn the bit off (& !bit) and save as needed
-        let bit: u128 = 1;
-        word2_value = word2_value & !bit.wrapping_shl(layer2_bit);
-        self.state_ops.set_layer2_word(layer2_word, word2_value);
+        word2_value &= !bitmap.bit_mask(2);
+        self.state_ops
+            .set_layer2_word(bitmap.word_at(2), word2_value);
+
         if word2_value == 0 {
-            word1_value = word1_value & !bit.wrapping_shl(layer1_bit);
-            self.state_ops.set_layer1_word(layer1_word, word1_value);
-        }
-        if word1_value == 0 {
-            word0_value = word0_value & !bit.wrapping_shl(layer0_bit);
-            self.state_ops.set_layer0_word(layer0_word, word0_value);
+            word1_value &= !bitmap.bit_mask(1);
+            self.state_ops
+                .set_layer1_word(bitmap.word_at(1), word1_value);
         }
-    }
 
-    // Finds the closest active bit and, if active bit exactly matches bit, then the next one
-    // Exact match: return Some([next, bit])
-    // Non-exact match: return Some([next])
-    // No match: return None
-    fn find_closest_active_bit_candidates(&self, word: u128, bit: u32, lower: bool) -> Vec<u32> {
-        let mut result = vec![];
-        let mut mask: u128 = 1_u128.wrapping_shl(bit);
-        let mut layer0_active_bit: u32 = bit;
-        while mask > 0 {
-            if mask & word != 0 {
-                result.push(layer0_active_bit);
-                if layer0_active_bit != bit {
-                    break;
-                }
-            }
-            mask = if lower {
-                layer0_active_bit = layer0_active_bit.saturating_sub(1);
-                mask.wrapping_shr(1)
-            } else {
-                layer0_active_bit = layer0_active_bit.saturating_add(1);
-                mask.wrapping_shl(1)
-            };
+        if word1_value == 0 {
+            word0_value &= !bitmap.bit_mask(0);
+            self.state_ops
+                .set_layer0_word(bitmap.word_at(0), word0_value);
         }
-        result
     }
 
     pub fn find_closest_active_tick_index(
@@ -1227,28 +1187,31 @@ where
             return None;
         }
 
-        // Convert the tick index value to an offset_index for the tree representation
-        // to avoid working with the sign bit.
-        let offset_index = (index.get() + TickIndex::OFFSET.get()) as u32;
+        // Convert to bitmap representation
+        let bitmap = TickIndexBitmap::from(index);
         let mut found = false;
         let mut result: u32 = 0;
 
-        // Calculate index in each layer
-        let (layer2_word, layer2_bit) = Self::index_to_address(offset_index);
-        let (layer1_word, layer1_bit) = Self::index_to_address(layer2_word);
-        let (layer0_word, layer0_bit) = Self::index_to_address(layer1_word);
+        // Layer positions from bitmap
+        let layer0_word = bitmap.word_at(0);
+        let layer0_bit = bitmap.bit_at(0);
+        let layer1_word = bitmap.word_at(1);
+        let layer1_bit = bitmap.bit_at(1);
+        let layer2_word = bitmap.word_at(2);
+        let layer2_bit = bitmap.bit_at(2);
 
         // Find the closest active bits in layer 0, then 1, then 2
 
         ///////////////
         // Level 0
         let word0 = self.state_ops.get_layer0_word(layer0_word);
-        let closest_bits_l0 = self.find_closest_active_bit_candidates(word0, layer0_bit, lower);
+        let closest_bits_l0 =
+            TickIndexBitmap::find_closest_active_bit_candidates(word0, layer0_bit, lower);
 
         closest_bits_l0.iter().for_each(|&closest_bit_l0| {
             ///////////////
             // Level 1
-            let word1_index = Self::address_to_index(0, closest_bit_l0);
+            let word1_index = TickIndexBitmap::layer_to_index(0, closest_bit_l0);
 
             // Layer 1 words are different, shift the bit to the word edge
             let start_from_l1_bit = if word1_index < layer1_word {
@@ -1260,12 +1223,15 @@ where
             };
             let word1_value = self.state_ops.get_layer1_word(word1_index);
 
-            let closest_bits_l1 =
-                self.find_closest_active_bit_candidates(word1_value, start_from_l1_bit, lower);
+            let closest_bits_l1 = TickIndexBitmap::find_closest_active_bit_candidates(
+                word1_value,
+                start_from_l1_bit,
+                lower,
+            );
             closest_bits_l1.iter().for_each(|&closest_bit_l1| {
                 ///////////////
                 // Level 2
-                let word2_index = Self::address_to_index(word1_index, closest_bit_l1);
+                let word2_index = TickIndexBitmap::layer_to_index(word1_index, closest_bit_l1);
 
                 // Layer 2 words are different, shift the bit to the word edge
                 let start_from_l2_bit = if word2_index < layer2_word {
@@ -1277,13 +1243,16 @@ where
                 };
 
                 let word2_value = self.state_ops.get_layer2_word(word2_index);
-                let closest_bits_l2 =
-                    self.find_closest_active_bit_candidates(word2_value, start_from_l2_bit, lower);
+                let closest_bits_l2 = TickIndexBitmap::find_closest_active_bit_candidates(
+                    word2_value,
+                    start_from_l2_bit,
+                    lower,
+                );
 
                 if closest_bits_l2.len() > 0 {
                     // The active tick is found, restore its full index and return
                     let offset_found_index =
-                        Self::address_to_index(word2_index, closest_bits_l2[0]);
+                        TickIndexBitmap::layer_to_index(word2_index, closest_bits_l2[0]);
 
                     if lower {
                         if (offset_found_index > result) || (!found) {
@@ -1300,13 +1269,12 @@ where
             });
         });
 
-        if found {
-            // Convert the tree offset_index back to a tick index value
-            let tick_value = (result as i32).saturating_sub(TickIndex::OFFSET.get());
-            Some(TickIndex::new_unchecked(tick_value))
-        } else {
-            None
+        if !found {
+            return None;
         }
+
+        // Convert the result offset_index back to a tick index
+        TickIndex::from_offset_index(result).ok()
     }
 
     pub fn find_closest_lower_active_tick_index(&self, index: TickIndex) -> Option<TickIndex> {
diff --git a/pallets/swap/src/tick.rs b/pallets/swap/src/tick.rs
index 809b261702..f1ede828d9 100644
--- a/pallets/swap/src/tick.rs
+++ b/pallets/swap/src/tick.rs
@@ -7,6 +7,7 @@ use core::ops::{Add, AddAssign, BitOr, Deref, Neg, Shl, Shr, Sub, SubAssign};
 
 use alloy_primitives::{I256, U256};
 use frame_support::pallet_prelude::*;
+use safe_math::*;
 use substrate_fixed::types::U64F64;
 
 use crate::{SqrtPrice, SwapDataOperations};
@@ -159,14 +160,16 @@ impl TryIntoTickIndex for i32 {
 }
 
 impl TickIndex {
+    /// Minimum value of the tick index
+    /// The tick_math library uses different bitness, so we have to divide by 2.
+    /// It's unsafe to change this value to something else.
+    pub const MIN: Self = Self(MIN_TICK / 2);
+
     /// Maximum value of the tick index
     /// The tick_math library uses different bitness, so we have to divide by 2.
+    /// It's unsafe to change this value to something else.
     pub const MAX: Self = Self(MAX_TICK / 2);
 
-    /// Minimum value of the tick index
-    /// The tick_math library uses different bitness, so we have to divide by 2.
-    pub const MIN: Self = Self(MIN_TICK / 2);
-    
     /// All tick indexes are offset by this value for storage needs
     /// so that tick indexes are positive, which simplifies bit logic
     pub const OFFSET: Self = Self(MAX_TICK);
@@ -235,6 +238,18 @@ impl TickIndex {
         self.0
     }
 
+    /// Creates a TickIndex from an offset representation (u32)
+    ///
+    /// # Arguments
+    /// * `offset_index` - An offset index (u32 value) representing a tick index
+    ///
+    /// # Returns
+    /// * `Result<TickIndex, TickMathError>` - The corresponding TickIndex if within valid bounds
+    pub fn from_offset_index(offset_index: u32) -> Result<Self, TickMathError> {
+        let signed_index = (offset_index as i64 - Self::OFFSET.get() as i64) as i32;
+        Self::new(signed_index)
+    }
+
     /// Get the next tick index (incrementing by 1)
     pub fn next(&self) -> Result<Self, TickMathError> {
         Self::new(self.0 + 1)
@@ -408,6 +423,122 @@ impl TickIndex {
     }
 }
 
+/// A bitmap representation of a tick index position across the three-layer structure
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct TickIndexBitmap {
+    /// The position in layer 0 (top layer)
+    pub layer0: (u32, u32), // (word, bit)
+    /// The position in layer 1 (middle layer)
+    pub layer1: (u32, u32), // (word, bit)
+    /// The position in layer 2 (bottom layer)
+    pub layer2: (u32, u32), // (word, bit)
+}
+
+impl TickIndexBitmap {
+    /// Helper function to convert a bitmap index to a (word, bit) tuple in a bitmap layer using
+    /// safe methods
+    ///
+    /// Note: This function operates on bitmap navigation indices, NOT tick indices.
+    /// It converts a flat index within the bitmap structure to a (word, bit) position.
+    fn index_to_layer(index: u32) -> (u32, u32) {
+        let word = index.safe_div(128);
+        let bit = index.checked_rem(128).unwrap_or_default();
+        (word, bit)
+    }
+
+    /// Converts a position (word, bit) within a layer to a word index in the next layer down
+    /// Note: This returns a bitmap navigation index, NOT a tick index
+    pub fn layer_to_index(word: u32, bit: u32) -> u32 {
+        word.saturating_mul(128).saturating_add(bit)
+    }
+
+    /// Get the mask for a bit in the specified layer
+    pub fn bit_mask(&self, layer: u8) -> u128 {
+        match layer {
+            0 => 1u128 << self.layer0.1,
+            1 => 1u128 << self.layer1.1,
+            2 => 1u128 << self.layer2.1,
+            _ => panic!("Invalid layer: must be 0, 1, or 2"),
+        }
+    }
+
+    /// Get the word for the specified layer
+    pub fn word_at(&self, layer: u8) -> u32 {
+        match layer {
+            0 => self.layer0.0,
+            1 => self.layer1.0,
+            2 => self.layer2.0,
+            _ => panic!("Invalid layer: must be 0, 1, or 2"),
+        }
+    }
+
+    /// Get the bit for the specified layer
+    pub fn bit_at(&self, layer: u8) -> u32 {
+        match layer {
+            0 => self.layer0.1,
+            1 => self.layer1.1,
+            2 => self.layer2.1,
+            _ => panic!("Invalid layer: must be 0, 1, or 2"),
+        }
+    }
+
+    /// Finds the closest active bit in a bitmap word, and if the active bit exactly matches the
+    /// requested bit, then it finds the next one as well
+    ///
+    /// # Arguments
+    /// * `word` - The bitmap word to search within
+    /// * `bit` - The bit position to start searching from
+    /// * `lower` - If true, search for lower bits (decreasing bit position),
+    ///             if false, search for higher bits (increasing bit position)
+    ///
+    /// # Returns
+    /// * Exact match: Vec with [next_bit, bit]
+    /// * Non-exact match: Vec with [closest_bit]
+    /// * No match: Empty Vec
+    pub fn find_closest_active_bit_candidates(word: u128, bit: u32, lower: bool) -> Vec<u32> {
+        let mut result = vec![];
+        let mut mask: u128 = 1_u128.wrapping_shl(bit);
+        let mut active_bit: u32 = bit;
+
+        while mask > 0 {
+            if mask & word != 0 {
+                result.push(active_bit);
+                if active_bit != bit {
+                    break;
+                }
+            }
+
+            mask = if lower {
+                active_bit = active_bit.saturating_sub(1);
+                mask.wrapping_shr(1)
+            } else {
+                active_bit = active_bit.saturating_add(1);
+                mask.wrapping_shl(1)
+            };
+        }
+
+        result
+    }
+}
+
+impl From<TickIndex> for TickIndexBitmap {
+    fn from(tick_index: TickIndex) -> Self {
+        // Convert to offset index (internal operation only)
+        let offset_index = (tick_index.get().saturating_add(TickIndex::OFFSET.get())) as u32;
+
+        // Calculate layer positions
+        let layer2 = Self::index_to_layer(offset_index);
+        let layer1 = Self::index_to_layer(layer2.0);
+        let layer0 = Self::index_to_layer(layer1.0);
+
+        Self {
+            layer0,
+            layer1,
+            layer2,
+        }
+    }
+}
+
 fn get_sqrt_ratio_at_tick(tick: i32) -> Result<U256, TickMathError> {
     let abs_tick = if tick < 0 {
         U256::from(tick.neg())
@@ -972,4 +1103,35 @@ mod tests {
             assert_eq!(round_trip_tick_index, tick_index);
         }
     }
+
+    #[test]
+    fn test_from_offset_index() {
+        // Test various tick indices
+        for i32_value in [
+            MIN_TICK / 2,
+            -1000,
+            -100,
+            -10,
+            0,
+            10,
+            100,
+            1000,
+            MAX_TICK / 2,
+        ] {
+            let original_tick = TickIndex::new_unchecked(i32_value);
+
+            // Calculate the offset index (adding OFFSET)
+            let offset_index = (i32_value + TickIndex::OFFSET.get()) as u32;
+
+            // Convert back from offset index to tick index
+            let roundtrip_tick = TickIndex::from_offset_index(offset_index).unwrap();
+
+            // Check that we get the same tick index back
+            assert_eq!(original_tick, roundtrip_tick);
+        }
+
+        // Test out of bounds values
+        let too_large = (TickIndex::MAX.get() + TickIndex::OFFSET.get() + 1) as u32;
+        assert!(TickIndex::from_offset_index(too_large).is_err());
+    }
 }

From e6e5041f69bdd1714438c01df0b84297b05626dc Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Wed, 26 Mar 2025 17:58:41 +0100
Subject: [PATCH 033/418] Make TickIndex::OFFSET private

---
 pallets/swap/src/tick.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pallets/swap/src/tick.rs b/pallets/swap/src/tick.rs
index f1ede828d9..7c932bf725 100644
--- a/pallets/swap/src/tick.rs
+++ b/pallets/swap/src/tick.rs
@@ -172,7 +172,7 @@ impl TickIndex {
 
     /// All tick indexes are offset by this value for storage needs
     /// so that tick indexes are positive, which simplifies bit logic
-    pub const OFFSET: Self = Self(MAX_TICK);
+    const OFFSET: Self = Self(MAX_TICK);
 
     /// Converts a sqrt price to a tick index, ensuring it's within valid bounds
     ///

From 1b2efeb8ffe7f878d09bb39bf6ece4b502a1cb63 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Wed, 26 Mar 2025 18:05:31 +0100
Subject: [PATCH 034/418] Use new active index lookup functions

---
 pallets/swap/src/lib.rs  |  4 ++--
 pallets/swap/src/tick.rs | 48 ----------------------------------------
 2 files changed, 2 insertions(+), 50 deletions(-)

diff --git a/pallets/swap/src/lib.rs b/pallets/swap/src/lib.rs
index a6e44e77f1..1a6c618099 100644
--- a/pallets/swap/src/lib.rs
+++ b/pallets/swap/src/lib.rs
@@ -1040,7 +1040,7 @@ where
     /// Get fees above a tick
     ///
     fn get_fees_above(&mut self, tick_index: TickIndex, quote: bool) -> U64F64 {
-        let maybe_tick_index = tick_index.find_closest_lower_active(&self.state_ops);
+        let maybe_tick_index = self.find_closest_lower_active_tick_index(tick_index);
         let current_tick = self.get_current_tick_index();
 
         if let Some(tick_index) = maybe_tick_index {
@@ -1072,7 +1072,7 @@ where
 
     /// Get fees below a tick
     fn get_fees_below(&mut self, tick_index: TickIndex, quote: bool) -> U64F64 {
-        let maybe_tick_index = tick_index.find_closest_lower_active(&self.state_ops);
+        let maybe_tick_index = self.find_closest_lower_active_tick_index(tick_index);
         let current_tick = self.get_current_tick_index();
 
         if let Some(tick_index) = maybe_tick_index {
diff --git a/pallets/swap/src/tick.rs b/pallets/swap/src/tick.rs
index 7c932bf725..d60cff0a62 100644
--- a/pallets/swap/src/tick.rs
+++ b/pallets/swap/src/tick.rs
@@ -373,54 +373,6 @@ impl TickIndex {
             }
         }
     }
-
-    /// Find the closest lower active tick index
-    pub fn find_closest_lower_active<Ops, AccountIdType>(&self, ops: &Ops) -> Option<Self>
-    where
-        AccountIdType: Eq,
-        Ops: SwapDataOperations<AccountIdType>,
-    {
-        // TODO: Implement without iteration
-        let mut current_index = *self;
-        loop {
-            if current_index.get() < Self::MIN.get() {
-                return None;
-            }
-            if ops.get_tick_by_index(current_index).is_some() {
-                return Some(current_index);
-            }
-
-            // Create a new index with value one less
-            match current_index.prev() {
-                Ok(next_index) => current_index = next_index,
-                Err(_) => return None, // Return None if we go out of bounds
-            }
-        }
-    }
-
-    /// Find the closest higher active tick index
-    pub fn find_closest_higher_active<Ops, AccountIdType>(&self, ops: &Ops) -> Option<Self>
-    where
-        AccountIdType: Eq,
-        Ops: SwapDataOperations<AccountIdType>,
-    {
-        // TODO: Implement without iteration
-        let mut current_index = *self;
-        loop {
-            if current_index.get() > Self::MAX.get() {
-                return None;
-            }
-            if ops.get_tick_by_index(current_index).is_some() {
-                return Some(current_index);
-            }
-
-            // Create a new index with value one more
-            match current_index.next() {
-                Ok(next_index) => current_index = next_index,
-                Err(_) => return None, // Return None if we go out of bounds
-            }
-        }
-    }
 }
 
 /// A bitmap representation of a tick index position across the three-layer structure

From aa885363d6e3e56b971911f39f7f23aea5121dee Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Wed, 26 Mar 2025 18:07:14 +0100
Subject: [PATCH 035/418] Make TickIndexBitmap fields private

---
 pallets/swap/src/tick.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/pallets/swap/src/tick.rs b/pallets/swap/src/tick.rs
index d60cff0a62..75dcbd8688 100644
--- a/pallets/swap/src/tick.rs
+++ b/pallets/swap/src/tick.rs
@@ -379,11 +379,11 @@ impl TickIndex {
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct TickIndexBitmap {
     /// The position in layer 0 (top layer)
-    pub layer0: (u32, u32), // (word, bit)
+    layer0: (u32, u32), // (word, bit)
     /// The position in layer 1 (middle layer)
-    pub layer1: (u32, u32), // (word, bit)
+    layer1: (u32, u32), // (word, bit)
     /// The position in layer 2 (bottom layer)
-    pub layer2: (u32, u32), // (word, bit)
+    layer2: (u32, u32), // (word, bit)
 }
 
 impl TickIndexBitmap {

From 6b0f6e6d84085e63e56d24346915aa77d85d65a5 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Wed, 26 Mar 2025 18:41:39 +0100
Subject: [PATCH 036/418] Add layer enum for tick index bitmap

---
 pallets/swap/src/lib.rs  | 58 +++++++++++++++++++++++-----------------
 pallets/swap/src/tick.rs | 40 ++++++++++++++++-----------
 2 files changed, 57 insertions(+), 41 deletions(-)

diff --git a/pallets/swap/src/lib.rs b/pallets/swap/src/lib.rs
index 1a6c618099..6526aa5937 100644
--- a/pallets/swap/src/lib.rs
+++ b/pallets/swap/src/lib.rs
@@ -9,7 +9,7 @@ use safe_math::*;
 use sp_arithmetic::helpers_128bit::sqrt;
 use substrate_fixed::types::U64F64;
 
-use self::tick::{Tick, TickIndex, TickIndexBitmap};
+use self::tick::{Layer, Tick, TickIndex, TickIndexBitmap};
 
 pub mod pallet;
 mod tick;
@@ -1127,22 +1127,26 @@ where
         let bitmap = TickIndexBitmap::from(index);
 
         // Update layer words
-        let mut word0_value = self.state_ops.get_layer0_word(bitmap.word_at(0));
-        let mut word1_value = self.state_ops.get_layer1_word(bitmap.word_at(1));
-        let mut word2_value = self.state_ops.get_layer2_word(bitmap.word_at(2));
+        let mut word0_value = self.state_ops.get_layer0_word(bitmap.word_at(Layer::Top));
+        let mut word1_value = self
+            .state_ops
+            .get_layer1_word(bitmap.word_at(Layer::Middle));
+        let mut word2_value = self
+            .state_ops
+            .get_layer2_word(bitmap.word_at(Layer::Bottom));
 
         // Set bits in each layer
-        word0_value |= bitmap.bit_mask(0);
-        word1_value |= bitmap.bit_mask(1);
-        word2_value |= bitmap.bit_mask(2);
+        word0_value |= bitmap.bit_mask(Layer::Top);
+        word1_value |= bitmap.bit_mask(Layer::Middle);
+        word2_value |= bitmap.bit_mask(Layer::Bottom);
 
         // Update the storage
         self.state_ops
-            .set_layer0_word(bitmap.word_at(0), word0_value);
+            .set_layer0_word(bitmap.word_at(Layer::Top), word0_value);
         self.state_ops
-            .set_layer1_word(bitmap.word_at(1), word1_value);
+            .set_layer1_word(bitmap.word_at(Layer::Middle), word1_value);
         self.state_ops
-            .set_layer2_word(bitmap.word_at(2), word2_value);
+            .set_layer2_word(bitmap.word_at(Layer::Bottom), word2_value);
     }
 
     pub fn remove_active_tick(&mut self, index: TickIndex) {
@@ -1155,25 +1159,29 @@ where
         let bitmap = TickIndexBitmap::from(index);
 
         // Update layer words
-        let mut word0_value = self.state_ops.get_layer0_word(bitmap.word_at(0));
-        let mut word1_value = self.state_ops.get_layer1_word(bitmap.word_at(1));
-        let mut word2_value = self.state_ops.get_layer2_word(bitmap.word_at(2));
+        let mut word0_value = self.state_ops.get_layer0_word(bitmap.word_at(Layer::Top));
+        let mut word1_value = self
+            .state_ops
+            .get_layer1_word(bitmap.word_at(Layer::Middle));
+        let mut word2_value = self
+            .state_ops
+            .get_layer2_word(bitmap.word_at(Layer::Bottom));
 
         // Turn the bit off (& !bit) and save as needed
-        word2_value &= !bitmap.bit_mask(2);
+        word2_value &= !bitmap.bit_mask(Layer::Bottom);
         self.state_ops
-            .set_layer2_word(bitmap.word_at(2), word2_value);
+            .set_layer2_word(bitmap.word_at(Layer::Bottom), word2_value);
 
         if word2_value == 0 {
-            word1_value &= !bitmap.bit_mask(1);
+            word1_value &= !bitmap.bit_mask(Layer::Middle);
             self.state_ops
-                .set_layer1_word(bitmap.word_at(1), word1_value);
+                .set_layer1_word(bitmap.word_at(Layer::Middle), word1_value);
         }
 
         if word1_value == 0 {
-            word0_value &= !bitmap.bit_mask(0);
+            word0_value &= !bitmap.bit_mask(Layer::Top);
             self.state_ops
-                .set_layer0_word(bitmap.word_at(0), word0_value);
+                .set_layer0_word(bitmap.word_at(Layer::Top), word0_value);
         }
     }
 
@@ -1193,12 +1201,12 @@ where
         let mut result: u32 = 0;
 
         // Layer positions from bitmap
-        let layer0_word = bitmap.word_at(0);
-        let layer0_bit = bitmap.bit_at(0);
-        let layer1_word = bitmap.word_at(1);
-        let layer1_bit = bitmap.bit_at(1);
-        let layer2_word = bitmap.word_at(2);
-        let layer2_bit = bitmap.bit_at(2);
+        let layer0_word = bitmap.word_at(Layer::Top);
+        let layer0_bit = bitmap.bit_at(Layer::Top);
+        let layer1_word = bitmap.word_at(Layer::Middle);
+        let layer1_bit = bitmap.bit_at(Layer::Middle);
+        let layer2_word = bitmap.word_at(Layer::Bottom);
+        let layer2_bit = bitmap.bit_at(Layer::Bottom);
 
         // Find the closest active bits in layer 0, then 1, then 2
 
diff --git a/pallets/swap/src/tick.rs b/pallets/swap/src/tick.rs
index 75dcbd8688..9a21dd70d4 100644
--- a/pallets/swap/src/tick.rs
+++ b/pallets/swap/src/tick.rs
@@ -10,7 +10,7 @@ use frame_support::pallet_prelude::*;
 use safe_math::*;
 use substrate_fixed::types::U64F64;
 
-use crate::{SqrtPrice, SwapDataOperations};
+use crate::SqrtPrice;
 
 const U256_1: U256 = U256::from_limbs([1, 0, 0, 0]);
 const U256_2: U256 = U256::from_limbs([2, 0, 0, 0]);
@@ -375,6 +375,17 @@ impl TickIndex {
     }
 }
 
+/// Represents the three layers in the Uniswap V3 bitmap structure
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Layer {
+    /// Top layer (highest level of the hierarchy)
+    Top = 0,
+    /// Middle layer
+    Middle = 1,
+    /// Bottom layer (contains the actual ticks)
+    Bottom = 2,
+}
+
 /// A bitmap representation of a tick index position across the three-layer structure
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct TickIndexBitmap {
@@ -405,32 +416,29 @@ impl TickIndexBitmap {
     }
 
     /// Get the mask for a bit in the specified layer
-    pub fn bit_mask(&self, layer: u8) -> u128 {
+    pub fn bit_mask(&self, layer: Layer) -> u128 {
         match layer {
-            0 => 1u128 << self.layer0.1,
-            1 => 1u128 << self.layer1.1,
-            2 => 1u128 << self.layer2.1,
-            _ => panic!("Invalid layer: must be 0, 1, or 2"),
+            Layer::Top => 1u128 << self.layer0.1,
+            Layer::Middle => 1u128 << self.layer1.1,
+            Layer::Bottom => 1u128 << self.layer2.1,
         }
     }
 
     /// Get the word for the specified layer
-    pub fn word_at(&self, layer: u8) -> u32 {
+    pub fn word_at(&self, layer: Layer) -> u32 {
         match layer {
-            0 => self.layer0.0,
-            1 => self.layer1.0,
-            2 => self.layer2.0,
-            _ => panic!("Invalid layer: must be 0, 1, or 2"),
+            Layer::Top => self.layer0.0,
+            Layer::Middle => self.layer1.0,
+            Layer::Bottom => self.layer2.0,
         }
     }
 
     /// Get the bit for the specified layer
-    pub fn bit_at(&self, layer: u8) -> u32 {
+    pub fn bit_at(&self, layer: Layer) -> u32 {
         match layer {
-            0 => self.layer0.1,
-            1 => self.layer1.1,
-            2 => self.layer2.1,
-            _ => panic!("Invalid layer: must be 0, 1, or 2"),
+            Layer::Top => self.layer0.1,
+            Layer::Middle => self.layer1.1,
+            Layer::Bottom => self.layer2.1,
         }
     }
 

From 5a6198e3f0c16a2d4684c8aaf894d1ee4415019e Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Thu, 27 Mar 2025 16:55:33 +0100
Subject: [PATCH 037/418] Encapsulate Swap into module

---
 Cargo.lock                        |   10 +
 Cargo.toml                        |    1 +
 pallets/swap-interface/src/lib.rs |    4 +-
 pallets/swap/Cargo.toml           |    4 +-
 pallets/swap/src/lib.rs           | 2426 +----------------------------
 pallets/swap/src/pallet/impls.rs  |  143 +-
 pallets/swap/src/pallet/mod.rs    |   50 +-
 pallets/swap/src/swap.rs          | 2247 ++++++++++++++++++++++++++
 8 files changed, 2439 insertions(+), 2446 deletions(-)
 create mode 100644 pallets/swap/src/swap.rs

diff --git a/Cargo.lock b/Cargo.lock
index 226fa3f722..ea63630307 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6851,6 +6851,7 @@ dependencies = [
  "sp-runtime",
  "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409)",
  "substrate-fixed",
+ "uuid",
 ]
 
 [[package]]
@@ -12414,6 +12415,15 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 
+[[package]]
+name = "uuid"
+version = "1.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "458f7a779bf54acc9f347480ac654f68407d3aab21269a6e3c9f922acd9e2da9"
+dependencies = [
+ "getrandom 0.3.1",
+]
+
 [[package]]
 name = "valuable"
 version = "0.1.1"
diff --git a/Cargo.toml b/Cargo.toml
index fa6c2b396a..20f3f03507 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -101,6 +101,7 @@ thiserror = "1.0"
 walkdir = "2"
 approx = "0.5"
 alloy-primitives = { version = "0.8.23", default-features = false }
+uuid = { version = "1.16.0", default-features = false }
 
 subtensor-macros = { path = "support/macros" }
 
diff --git a/pallets/swap-interface/src/lib.rs b/pallets/swap-interface/src/lib.rs
index 6a96af3e34..44ca298d18 100644
--- a/pallets/swap-interface/src/lib.rs
+++ b/pallets/swap-interface/src/lib.rs
@@ -13,13 +13,11 @@ pub enum OrderType {
 
 pub trait SwapHandler<AccountId> {
     fn swap(order_t: OrderType, amount: u64) -> Result<(), Box<dyn Error>>;
-    fn add_liquidity(account_id: AccountId, liquidity: u64) -> Result<(), Box<dyn Error>>;
+    fn add_liquidity(account_id: AccountId, liquidity: u64) -> Result<(u64, u64), Box<dyn Error>>;
     fn remove_liquidity(account_id: AccountId) -> Result<(), Box<dyn Error>>;
 }
 
 pub trait LiquidityDataProvider {
     fn tao_reserve() -> u64;
-    fn set_tao_reserve() -> u64;
     fn alpha_reserve() -> u64;
-    fn set_alpha_reserve() -> u64;
 }
diff --git a/pallets/swap/Cargo.toml b/pallets/swap/Cargo.toml
index b00c268aa6..459f7fc45e 100644
--- a/pallets/swap/Cargo.toml
+++ b/pallets/swap/Cargo.toml
@@ -6,7 +6,7 @@ edition = { workspace = true }
 [dependencies]
 alloy-primitives = { workspace = true }
 approx = { workspace = true }
-codec = {workspace = true }
+codec = { workspace = true }
 frame-support = { workspace = true }
 frame-system = { workspace = true }
 safe-math = { workspace = true }
@@ -16,6 +16,7 @@ sp-arithmetic = { workspace = true }
 sp-runtime = { workspace = true }
 sp-std = { workspace = true }
 substrate-fixed = { workspace = true }
+uuid = { workspace = true, features = ["v4"] }
 
 pallet-subtensor-swap-interface = { workspace = true }
 
@@ -37,4 +38,5 @@ std = [
 	"sp-runtime/std",
 	"sp-std/std",
 	"substrate-fixed/std",
+	"uuid/std",
 ]
diff --git a/pallets/swap/src/lib.rs b/pallets/swap/src/lib.rs
index 6526aa5937..e6fc350425 100644
--- a/pallets/swap/src/lib.rs
+++ b/pallets/swap/src/lib.rs
@@ -3,25 +3,22 @@
 use core::marker::PhantomData;
 use core::ops::Neg;
 
+use codec::{Decode, Encode, MaxEncodedLen};
 use frame_support::pallet_prelude::*;
 use pallet_subtensor_swap_interface::OrderType;
 use safe_math::*;
-use sp_arithmetic::helpers_128bit::sqrt;
 use substrate_fixed::types::U64F64;
+use uuid::Uuid;
 
 use self::tick::{Layer, Tick, TickIndex, TickIndexBitmap};
+use crate::pallet::{Config, Error};
 
 pub mod pallet;
 mod tick;
+pub(crate) mod swap;
 
 type SqrtPrice = U64F64;
 
-pub enum SwapStepAction {
-    Crossing,
-    StopOn,
-    StopIn,
-}
-
 #[derive(Debug, PartialEq)]
 pub struct RemoveLiquidityResult {
     tao: u64,
@@ -30,18 +27,6 @@ pub struct RemoveLiquidityResult {
     fee_alpha: u64,
 }
 
-#[derive(Debug, PartialEq)]
-pub struct SwapResult {
-    amount_paid_out: u64,
-    refund: u64,
-}
-
-#[derive(Debug, PartialEq)]
-struct SwapStepResult {
-    amount_to_take: u64,
-    delta_out: u64,
-}
-
 /// Position designates one liquidity position.
 ///
 /// Alpha price is expressed in rao units per one 10^9 unit. For example,
@@ -55,6 +40,7 @@ struct SwapStepResult {
 ///
 #[derive(Clone, Encode, Decode, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen, Default)]
 pub struct Position {
+    pub id: PositionId,
     pub tick_low: TickIndex,
     pub tick_high: TickIndex,
     pub liquidity: u64,
@@ -78,17 +64,20 @@ impl Position {
     ///         tao = L * (self.sqrt_price_curr - sqrt_pa)
     ///         alpha = L * (1 / self.sqrt_price_curr - 1 / sqrt_pb)
     ///
-    pub fn to_token_amounts(&self, sqrt_price_curr: SqrtPrice) -> Result<(u64, u64), SwapError> {
+    pub fn to_token_amounts<T: Config>(
+        &self,
+        sqrt_price_curr: SqrtPrice,
+    ) -> Result<(u64, u64), Error<T>> {
         let one: U64F64 = U64F64::saturating_from_num(1);
 
         let sqrt_pa: SqrtPrice = self
             .tick_low
             .try_to_sqrt_price()
-            .map_err(|_| SwapError::InvalidTickRange)?;
+            .map_err(|_| Error::<T>::InvalidTickRange)?;
         let sqrt_pb: SqrtPrice = self
             .tick_high
             .try_to_sqrt_price()
-            .map_err(|_| SwapError::InvalidTickRange)?;
+            .map_err(|_| Error::<T>::InvalidTickRange)?;
         let liquidity_fixed: U64F64 = U64F64::saturating_from_num(self.liquidity);
 
         Ok(if sqrt_price_curr < sqrt_pa {
@@ -121,1198 +110,48 @@ impl Position {
     }
 }
 
-/// This trait implementation depends on Runtime and it needs to be implemented
-/// in the pallet to be able to work with chain state and per subnet. All subnet
-/// swaps are independent and hence netuid is abstracted away from swap implementation.
-///
-pub trait SwapDataOperations<AccountIdType> {
-    /// Tells if v3 swap is initialized in the state. v2 only provides base and quote
-    /// reserves, while v3 also stores ticks and positions, which need to be initialized
-    /// at the first pool creation.
-    fn is_v3_initialized(&self) -> bool;
-    fn set_v3_initialized(&mut self);
-    /// Returns u16::MAX normalized fee rate. For example, 0.3% is approximately 196.
-    fn get_fee_rate(&self) -> u16;
-    /// Minimum liquidity that is safe for rounding and integer math.
-    fn get_minimum_liquidity(&self) -> u64;
-    fn get_tick_by_index(&self, tick_index: TickIndex) -> Option<Tick>;
-    fn insert_tick_by_index(&mut self, tick_index: TickIndex, tick: Tick);
-    fn remove_tick_by_index(&mut self, tick_index: TickIndex);
-    /// Minimum sqrt price across all active ticks
-    fn get_min_sqrt_price(&self) -> SqrtPrice;
-    /// Maximum sqrt price across all active ticks
-    fn get_max_sqrt_price(&self) -> SqrtPrice;
-    fn get_tao_reserve(&self) -> u64;
-    fn set_tao_reserve(&mut self, tao: u64) -> u64;
-    fn get_alpha_reserve(&self) -> u64;
-    fn set_alpha_reserve(&mut self, alpha: u64) -> u64;
-    fn get_alpha_sqrt_price(&self) -> SqrtPrice;
-    fn set_alpha_sqrt_price(&mut self, sqrt_price: SqrtPrice);
-
-    // Getters/setters for global accrued fees in alpha and tao per subnet
-    fn get_fee_global_tao(&self) -> U64F64;
-    fn set_fee_global_tao(&mut self, fee: U64F64);
-    fn get_fee_global_alpha(&self) -> U64F64;
-    fn set_fee_global_alpha(&mut self, fee: U64F64);
-
-    /// Get current tick liquidity
-    fn get_current_liquidity(&self) -> u64;
-    /// Set current tick liquidity
-    fn set_current_liquidity(&mut self, liquidity: u64);
-
-    // User account operations
-    fn get_protocol_account_id(&self) -> AccountIdType;
-    fn get_max_positions(&self) -> u16;
-    fn withdraw_balances(
-        &mut self,
-        account_id: &AccountIdType,
-        tao: u64,
-        alpha: u64,
-    ) -> Result<(u64, u64), SwapError>;
-    fn deposit_balances(&mut self, account_id: &AccountIdType, tao: u64, alpha: u64);
-    fn get_position_count(&self, account_id: &AccountIdType) -> u16;
-    fn get_position(&self, account_id: &AccountIdType, position_id: u16) -> Option<Position>;
-    fn create_position(&mut self, account_id: &AccountIdType, positions: Position) -> u16;
-    fn update_position(
-        &mut self,
-        account_id: &AccountIdType,
-        position_id: u16,
-        positions: Position,
-    );
-    fn remove_position(&mut self, account_id: &AccountIdType, position_id: u16);
-
-    // Tick index storage
-    // Storage is organized in 3 layers:
-    //    Layer 0 consists of one u128 that stores 55 bits. Each bit indicates which layer 1 words are active.
-    //    Layer 1 consists of up to 55 u128's that store 6932 bits for the layer 2 words.
-    //    Layer 2 consists of up to 6932 u128's that store 887272 bits for active/inactive ticks.
-    fn get_layer0_word(&self, word_index: u32) -> u128;
-    fn get_layer1_word(&self, word_index: u32) -> u128;
-    fn get_layer2_word(&self, word_index: u32) -> u128;
-    fn set_layer0_word(&mut self, word_index: u32, word: u128);
-    fn set_layer1_word(&mut self, word_index: u32, word: u128);
-    fn set_layer2_word(&mut self, word_index: u32, word: u128);
-}
-
-/// All main swapping logic abstracted from Runtime implementation is concentrated
-/// in this struct
-///
-#[derive(Debug)]
-pub struct Swap<AccountIdType, Ops>
-where
-    AccountIdType: Eq,
-    Ops: SwapDataOperations<AccountIdType>,
-{
-    pub(crate) state_ops: Ops,
-    phantom_key: PhantomData<AccountIdType>,
-}
-
-impl<AccountIdType, Ops> Swap<AccountIdType, Ops>
-where
-    AccountIdType: Eq,
-    Ops: SwapDataOperations<AccountIdType>,
-{
-    pub fn new(mut ops: Ops) -> Self {
-        if !ops.is_v3_initialized() {
-            // Initialize the v3:
-            // Reserves are re-purposed, nothing to set, just query values for liquidity and price calculation
-            let tao_reserve = ops.get_tao_reserve();
-            let alpha_reserve = ops.get_alpha_reserve();
-
-            // Set price
-            let price: U64F64 = U64F64::saturating_from_num(tao_reserve)
-                .safe_div(U64F64::saturating_from_num(alpha_reserve));
-
-            let epsilon: U64F64 = U64F64::saturating_from_num(0.000001);
-            ops.set_alpha_sqrt_price(
-                price
-                    .checked_sqrt(epsilon)
-                    .unwrap_or(U64F64::saturating_from_num(0)),
-            );
-
-            // Set initial (protocol owned) liquidity and positions
-            // Protocol liquidity makes one position from TickIndex::MIN to TickIndex::MAX
-            // We are using the sp_arithmetic sqrt here, which works for u128
-            let liquidity: u64 = sqrt(tao_reserve as u128 * alpha_reserve as u128) as u64;
-            let mut swap = Swap {
-                state_ops: ops,
-                phantom_key: PhantomData,
-            };
-            let protocol_account_id = swap.state_ops.get_protocol_account_id();
-            let _ = swap.add_liquidity(
-                &protocol_account_id,
-                TickIndex::MIN,
-                TickIndex::MAX,
-                liquidity,
-                true,
-            );
-
-            swap
-        } else {
-            Swap {
-                state_ops: ops,
-                phantom_key: PhantomData,
-            }
-        }
-    }
-
-    /// Auxiliary method to calculate Alpha amount to match given TAO
-    /// amount at the current price for liquidity.
-    ///
-    /// Returns (Alpha, Liquidity) tuple
-    ///
-    pub fn get_tao_based_liquidity(&self, _tao: u64) -> (u64, u64) {
-        // let current_price = self.state_ops.get_alpha_sqrt_price();
-        todo!()
-    }
-
-    /// Auxiliary method to calculate TAO amount to match given Alpha
-    /// amount at the current price for liquidity.
-    ///
-    /// Returns (TAO, Liquidity) tuple
-    ///
-    pub fn get_alpha_based_liquidity(&self, _alpha: u64) -> (u64, u64) {
-        // let current_price = self.state_ops.get_alpha_sqrt_price();
-
-        todo!()
-    }
-
-    /// Add liquidity at tick index. Creates new tick if it doesn't exist
-    ///
-    fn add_liquidity_at_index(&mut self, tick_index: TickIndex, liquidity: u64, upper: bool) {
-        // Calculate net liquidity addition
-        let net_addition = if upper {
-            (liquidity as i128).neg()
-        } else {
-            liquidity as i128
-        };
-
-        // Find tick by index
-        let new_tick = if let Some(mut tick) = self.state_ops.get_tick_by_index(tick_index) {
-            tick.liquidity_net = tick.liquidity_net.saturating_add(net_addition);
-            tick.liquidity_gross = tick.liquidity_gross.saturating_add(liquidity);
-            tick
-        } else {
-            // Create a new tick
-            Tick {
-                liquidity_net: net_addition,
-                liquidity_gross: liquidity,
-                fees_out_tao: U64F64::saturating_from_num(0),
-                fees_out_alpha: U64F64::saturating_from_num(0),
-            }
-        };
-
-        // TODO: Review why Python code uses this code to find index for the new ticks:
-        // self.get_tick_index(user_position[0]) + 1
-        self.state_ops.insert_tick_by_index(tick_index, new_tick);
-    }
-
-    /// Remove liquidity at tick index.
-    ///
-    fn remove_liquidity_at_index(&mut self, tick_index: TickIndex, liquidity: u64, upper: bool) {
-        // Calculate net liquidity addition
-        let net_reduction = if upper {
-            (liquidity as i128).neg()
-        } else {
-            liquidity as i128
-        };
-
-        // Find tick by index
-        if let Some(mut tick) = self.state_ops.get_tick_by_index(tick_index) {
-            tick.liquidity_net = tick.liquidity_net.saturating_sub(net_reduction);
-            tick.liquidity_gross = tick.liquidity_gross.saturating_sub(liquidity);
-
-            // If any liquidity is left at the tick, update it, otherwise remove
-            if tick.liquidity_gross == 0 {
-                self.state_ops.remove_tick_by_index(tick_index);
-            } else {
-                self.state_ops.insert_tick_by_index(tick_index, tick);
-            }
-        };
-    }
-
-    /// Adds liquidity to the specified price range.
-    ///
-    /// This function allows an account to provide liquidity to a given range of price ticks.
-    /// The amount of liquidity to be added can be determined using the functions
-    /// [`get_tao_based_liquidity`] and [`get_alpha_based_liquidity`], which compute the
-    /// required liquidity based on TAO and Alpha balances for the current price tick.
-    ///
-    /// ### Behavior:
-    /// - If the `protocol` flag is **not set** (`false`), the function will attempt to
-    ///   **withdraw balances** from the account using `state_ops.withdraw_balances()`.
-    /// - If the `protocol` flag is **set** (`true`), the liquidity is added without modifying balances.
-    ///
-    /// ### Parameters:
-    /// - `account_id`: A reference to the account that is providing liquidity.
-    /// - `tick_low`: The lower bound of the price tick range.
-    /// - `tick_high`: The upper bound of the price tick range.
-    /// - `liquidity`: The amount of liquidity to be added.
-    /// - `protocol`: A boolean flag indicating whether the operation is protocol-managed:
-    ///   - `true` -> Do not use this value outside of this implementation. Liquidity is added **without**
-    ///               withdrawing balances.
-    ///   - `false` -> Use this value for all user transactions. Liquidity is added
-    ///               **after withdrawing balances**.
-    ///
-    /// ### Returns:
-    /// - `Ok(u64)`: The final liquidity amount added.
-    /// - `Err(SwapError)`: If the operation fails due to insufficient balance, invalid tick range,
-    ///   or other swap-related errors.
-    ///
-    /// ### Errors:
-    /// - [`SwapError::InsufficientBalance`] if the account does not have enough balance.
-    /// - [`SwapError::InvalidTickRange`] if `tick_low` is greater than or equal to `tick_high`.
-    /// - Other [`SwapError`] variants as applicable.
-    ///
-    pub fn add_liquidity(
-        &mut self,
-        account_id: &AccountIdType,
-        tick_low: TickIndex,
-        tick_high: TickIndex,
-        liquidity: u64,
-        protocol: bool,
-    ) -> Result<(), SwapError> {
-        // Check if we can add a position
-        let position_count = self.state_ops.get_position_count(account_id);
-        let max_positions = self.state_ops.get_max_positions();
-        if position_count >= max_positions {
-            return Err(SwapError::MaxPositionsExceeded);
-        }
-
-        // Add liquidity at tick
-        self.add_liquidity_at_index(tick_low, liquidity, false);
-        self.add_liquidity_at_index(tick_high, liquidity, true);
-
-        // Update current tick liquidity
-        let current_tick_index = self.get_current_tick_index();
-        if (tick_low <= current_tick_index) && (current_tick_index <= tick_high) {
-            let new_current_liquidity = self
-                .state_ops
-                .get_current_liquidity()
-                .saturating_add(liquidity);
-            self.state_ops.set_current_liquidity(new_current_liquidity);
-        }
-
-        // New position
-        let position = Position {
-            tick_low,
-            tick_high,
-            liquidity,
-            fees_tao: 0_u64,
-            fees_alpha: 0_u64,
-        };
-
-        // If this is a user transaction, withdraw balances and update reserves
-        if !protocol {
-            let current_price: SqrtPrice = self.state_ops.get_alpha_sqrt_price();
-            let (tao, alpha) = position.to_token_amounts(current_price)?;
-            self.state_ops.withdraw_balances(account_id, tao, alpha)?;
-
-            // Update reserves
-            let new_tao_reserve = self.state_ops.get_tao_reserve().saturating_add(tao);
-            self.state_ops.set_tao_reserve(new_tao_reserve);
-            let new_alpha_reserve = self.state_ops.get_alpha_reserve().saturating_add(alpha);
-            self.state_ops.set_alpha_reserve(new_alpha_reserve);
-        }
-
-        // Create a new user position
-        self.state_ops.create_position(account_id, position);
-
-        Ok(())
-    }
-
-    /// Remove liquidity and credit balances back to account_id
-    ///
-    /// Account ID and Position ID identify position in the storage map
-    ///
-    pub fn remove_liquidity(
-        &mut self,
-        account_id: &AccountIdType,
-        position_id: u16,
-    ) -> Result<RemoveLiquidityResult, SwapError> {
-        // Check if position exists
-        if let Some(mut pos) = self.state_ops.get_position(account_id, position_id) {
-            // Get current price
-            let current_tick_index = self.get_current_tick_index();
-
-            // Collect fees and get tao and alpha amounts
-            let (fee_tao, fee_alpha) = self.collect_fees(&mut pos);
-            let current_price: SqrtPrice = self.state_ops.get_alpha_sqrt_price();
-            let (tao, alpha) = pos.to_token_amounts(current_price)?;
-
-            // Update liquidity at position ticks
-            self.remove_liquidity_at_index(pos.tick_low, pos.liquidity, false);
-            self.remove_liquidity_at_index(pos.tick_high, pos.liquidity, true);
-
-            // Update current tick liquidity
-            if (pos.tick_low <= current_tick_index) && (current_tick_index <= pos.tick_high) {
-                let new_current_liquidity = self
-                    .state_ops
-                    .get_current_liquidity()
-                    .saturating_sub(pos.liquidity);
-                self.state_ops.set_current_liquidity(new_current_liquidity);
-            }
-
-            // Remove user position
-            self.state_ops.remove_position(account_id, position_id);
-
-            // Deposit balances
-            self.state_ops.deposit_balances(account_id, tao, alpha);
-
-            // Update reserves
-            let new_tao_reserve = self.state_ops.get_tao_reserve().saturating_sub(tao);
-            self.state_ops.set_tao_reserve(new_tao_reserve);
-            let new_alpha_reserve = self.state_ops.get_alpha_reserve().saturating_sub(alpha);
-            self.state_ops.set_alpha_reserve(new_alpha_reserve);
-
-            // TODO: Clear with R&D
-            // Update current price (why?)
-            // self.state_ops.set_alpha_sqrt_price(sqrt_price);
-
-            // Return Ok result
-            Ok(RemoveLiquidityResult {
-                tao,
-                alpha,
-                fee_tao,
-                fee_alpha,
-            })
-        } else {
-            // Position doesn't exist
-            Err(SwapError::LiquidityNotFound)
-        }
-    }
-
-    /// Perform a swap
-    ///
-    /// Returns a tuple (amount, refund), where amount is the resulting paid out amount
-    ///
-    pub fn swap(
-        &mut self,
-        order_type: &OrderType,
-        amount: u64,
-        sqrt_price_limit: SqrtPrice,
-    ) -> Result<SwapResult, SwapError> {
-        let one = U64F64::saturating_from_num(1);
-
-        // Here we store the remaining amount that needs to be exchanged
-        // If order_type is Buy, then it expresses Tao amount, if it is Sell,
-        // then amount_remaining is Alpha.
-        let mut amount_remaining = amount;
-        let mut amount_paid_out: u64 = 0;
-        let mut refund: u64 = 0;
-
-        // A bit of fool proofing
-        let mut iteration_counter: u16 = 0;
-        let iter_limit: u16 = 1000;
-
-        // Swap one tick at a time until we reach one of the following conditions:
-        //   - Swap all provided amount
-        //   - Reach limit price
-        //   - Use up all liquidity (up to safe minimum)
-        while amount_remaining > 0 {
-            let sqrt_price_edge = self.get_sqrt_price_edge(order_type);
-            let possible_delta_in =
-                amount_remaining.saturating_sub(self.get_fee_amount(amount_remaining));
-            let sqrt_price_target = self.get_sqrt_price_target(order_type, possible_delta_in);
-            let target_quantity = self.get_target_quantity(order_type, possible_delta_in);
-            let edge_quantity = U64F64::saturating_from_num(1).safe_div(sqrt_price_edge.into());
-            let lim_quantity = one
-                .safe_div(self.state_ops.get_min_sqrt_price())
-                .saturating_add(one.safe_div(sqrt_price_limit.into()));
-
-            let action: SwapStepAction;
-            let delta_in;
-            let final_price;
-            let mut stop_and_refund = false;
-
-            if target_quantity < edge_quantity {
-                if target_quantity <= lim_quantity {
-                    // stop_in at price target
-                    action = SwapStepAction::StopIn;
-                    delta_in = possible_delta_in;
-                    final_price = sqrt_price_target;
-                } else {
-                    // stop_in at price limit
-                    action = SwapStepAction::StopIn;
-                    delta_in = self.get_delta_in(order_type, sqrt_price_limit);
-                    final_price = sqrt_price_limit;
-                    stop_and_refund = true;
-                }
-            } else if target_quantity > edge_quantity {
-                if edge_quantity < lim_quantity {
-                    // do crossing at price edge
-                    action = SwapStepAction::Crossing;
-                    delta_in = self.get_delta_in(order_type, sqrt_price_edge);
-                    final_price = sqrt_price_edge;
-                } else if edge_quantity > lim_quantity {
-                    // stop_in at price limit
-                    action = SwapStepAction::StopIn;
-                    delta_in = self.get_delta_in(order_type, sqrt_price_limit);
-                    final_price = sqrt_price_limit;
-                    stop_and_refund = true;
-                } else {
-                    // stop_on at price limit
-                    action = SwapStepAction::StopOn;
-                    delta_in = self.get_delta_in(order_type, sqrt_price_edge);
-                    final_price = sqrt_price_edge;
-                    stop_and_refund = true;
-                }
-            } else {
-                // targetQuantity = edgeQuantity
-                if target_quantity <= lim_quantity {
-                    // stop_on at price edge
-                    delta_in = self.get_delta_in(order_type, sqrt_price_edge);
-                    final_price = sqrt_price_edge;
-                    action = if delta_in > 0 {
-                        SwapStepAction::StopOn
-                    } else {
-                        SwapStepAction::Crossing
-                    };
-                } else {
-                    // targetQuantity > limQuantity
-                    // stop_in at price lim
-                    action = SwapStepAction::StopIn;
-                    delta_in = self.get_delta_in(order_type, sqrt_price_limit);
-                    final_price = sqrt_price_limit;
-                    stop_and_refund = true;
-                }
-            }
-
-            let swap_result = self.swap_step(order_type, delta_in, final_price, action)?;
-            amount_remaining = amount_remaining.saturating_sub(swap_result.amount_to_take);
-            amount_paid_out = amount_paid_out.saturating_add(swap_result.delta_out);
-
-            if stop_and_refund {
-                refund = amount_remaining;
-                amount_remaining = 0;
-            }
-
-            iteration_counter = iteration_counter.saturating_add(1);
-            if iteration_counter > iter_limit {
-                return Err(SwapError::TooManySwapSteps);
-            }
-        }
-
-        Ok(SwapResult {
-            amount_paid_out,
-            refund,
-        })
-    }
-
-    fn get_current_tick_index(&mut self) -> TickIndex {
-        let current_price = self.state_ops.get_alpha_sqrt_price();
-        let maybe_current_tick_index = TickIndex::try_from_sqrt_price(current_price);
-        if let Ok(index) = maybe_current_tick_index {
-            index
-        } else {
-            // Current price is out of allow the min-max range, and it should be corrected to
-            // maintain the range.
-            let max_price = TickIndex::MAX
-                .try_to_sqrt_price()
-                .unwrap_or(SqrtPrice::saturating_from_num(1000));
-            let min_price = TickIndex::MIN
-                .try_to_sqrt_price()
-                .unwrap_or(SqrtPrice::saturating_from_num(0.000001));
-            if current_price > max_price {
-                self.state_ops.set_alpha_sqrt_price(max_price);
-                TickIndex::MAX
-            } else {
-                self.state_ops.set_alpha_sqrt_price(min_price);
-                TickIndex::MIN
-            }
-        }
-    }
-
-    /// Process a single step of a swap
-    ///
-    fn swap_step(
-        &mut self,
-        order_type: &OrderType,
-        delta_in: u64,
-        sqrt_price_final: SqrtPrice,
-        action: SwapStepAction,
-    ) -> Result<SwapStepResult, SwapError> {
-        // amount_swapped = delta_in / (1 - self.fee_size)
-        let fee_rate = U64F64::saturating_from_num(self.state_ops.get_fee_rate());
-        let u16_max = U64F64::saturating_from_num(u16::MAX);
-        let delta_fixed = U64F64::saturating_from_num(delta_in);
-        let amount_swapped =
-            delta_fixed.saturating_mul(u16_max.safe_div(u16_max.saturating_sub(fee_rate)));
-
-        // Hold the fees
-        let fee = self.get_fee_amount(amount_swapped.saturating_to_num::<u64>());
-        self.add_fees(order_type, fee);
-        let delta_out = self.convert_deltas(order_type, delta_in);
-
-        self.update_reserves(order_type, delta_in, delta_out);
-
-        // Get current tick
-        let current_tick_index = self.get_current_tick_index();
-
-        match action {
-            SwapStepAction::Crossing => {
-                let maybe_tick = match order_type {
-                    OrderType::Sell => self.find_closest_lower_active_tick(current_tick_index),
-                    OrderType::Buy => self.find_closest_higher_active_tick(current_tick_index),
-                };
-                if let Some(mut tick) = maybe_tick {
-                    tick.fees_out_tao = self
-                        .state_ops
-                        .get_fee_global_tao()
-                        .saturating_sub(tick.fees_out_tao);
-                    tick.fees_out_alpha = self
-                        .state_ops
-                        .get_fee_global_alpha()
-                        .saturating_sub(tick.fees_out_alpha);
-                    self.update_liquidity_at_crossing(order_type)?;
-                    self.state_ops
-                        .insert_tick_by_index(current_tick_index, tick);
-                } else {
-                    return Err(SwapError::InsufficientLiquidity);
-                }
-            }
-            SwapStepAction::StopOn => match order_type {
-                OrderType::Sell => {}
-                OrderType::Buy => {
-                    self.update_liquidity_at_crossing(order_type)?;
-                    let maybe_tick = self.find_closest_higher_active_tick(current_tick_index);
-
-                    if let Some(mut tick) = maybe_tick {
-                        tick.fees_out_tao = self
-                            .state_ops
-                            .get_fee_global_tao()
-                            .saturating_sub(tick.fees_out_tao);
-                        tick.fees_out_alpha = self
-                            .state_ops
-                            .get_fee_global_alpha()
-                            .saturating_sub(tick.fees_out_alpha);
-                        self.state_ops
-                            .insert_tick_by_index(current_tick_index, tick);
-                    } else {
-                        return Err(SwapError::InsufficientLiquidity);
-                    }
-                }
-            },
-            SwapStepAction::StopIn => {}
-        }
-
-        // Update current price, which effectively updates current tick too
-        self.state_ops.set_alpha_sqrt_price(sqrt_price_final);
-
-        Ok(SwapStepResult {
-            amount_to_take: amount_swapped.saturating_to_num::<u64>(),
-            delta_out,
-        })
-    }
-
-    /// Get the square root price at the current tick edge for the given direction (order type)
-    /// If order type is Buy, then price edge is the high tick bound price, otherwise it is
-    /// the low tick bound price.
-    ///
-    /// If anything is wrong with tick math and it returns Err, we just abort the deal, i.e.
-    /// return the edge that is impossible to execute
-    ///
-    fn get_sqrt_price_edge(&self, order_type: &OrderType) -> SqrtPrice {
-        let fallback_price_edge_value = (match order_type {
-            OrderType::Buy => TickIndex::MIN.try_to_sqrt_price(),
-            OrderType::Sell => TickIndex::MAX.try_to_sqrt_price(),
-        })
-        .unwrap_or(SqrtPrice::saturating_from_num(0));
-
-        let current_price = self.state_ops.get_alpha_sqrt_price();
-        let maybe_current_tick_index = TickIndex::try_from_sqrt_price(current_price);
-
-        if let Ok(current_tick_index) = maybe_current_tick_index {
-            match order_type {
-                OrderType::Buy => {
-                    TickIndex::new_unchecked(current_tick_index.get().saturating_add(1))
-                }
-                OrderType::Sell => current_tick_index,
-            }
-            .try_to_sqrt_price()
-            .unwrap_or(fallback_price_edge_value)
-        } else {
-            fallback_price_edge_value
-        }
-    }
-
-    /// Calculate fee amount
-    ///
-    /// Fee is provided by state ops as u16-normalized value.
-    ///
-    fn get_fee_amount(&self, amount: u64) -> u64 {
-        let fee_rate = U64F64::saturating_from_num(self.state_ops.get_fee_rate())
-            .safe_div(U64F64::saturating_from_num(u16::MAX));
-        U64F64::saturating_from_num(amount)
-            .saturating_mul(fee_rate)
-            .saturating_to_num::<u64>()
-    }
+#[derive(
+    Clone, Copy, Decode, Default, Encode, Eq, MaxEncodedLen, PartialEq, RuntimeDebug, TypeInfo,
+)]
+pub struct PositionId([u8; 16]);
 
-    /// Here we subtract minimum safe liquidity from current liquidity to stay in the
-    /// safe range
-    ///
-    fn get_safe_current_liquidity(&self) -> U64F64 {
-        U64F64::saturating_from_num(
-            self.state_ops
-                .get_current_liquidity()
-                .saturating_sub(self.state_ops.get_minimum_liquidity()),
-        )
+impl PositionId {
+    /// Create a new position ID using UUID v4
+    pub fn new() -> Self {
+        Self(Uuid::new_v4().into_bytes())
     }
+}
 
-    /// Get the target square root price based on the input amount
-    ///
-    fn get_sqrt_price_target(&self, order_type: &OrderType, delta_in: u64) -> SqrtPrice {
-        let liquidity_curr = self.get_safe_current_liquidity();
-        let sqrt_price_curr = self.state_ops.get_alpha_sqrt_price().into();
-        let delta_fixed = U64F64::saturating_from_num(delta_in);
-        let one = U64F64::saturating_from_num(1);
-
-        if liquidity_curr > 0 {
-            match order_type {
-                OrderType::Buy => one.safe_div(
-                    delta_fixed
-                        .safe_div(liquidity_curr)
-                        .saturating_add(one.safe_div(sqrt_price_curr)),
-                ),
-                OrderType::Sell => delta_fixed
-                    .safe_div(liquidity_curr)
-                    .saturating_add(sqrt_price_curr),
-            }
-        } else {
-            // No liquidity means price should remain current
-            sqrt_price_curr
-        }
-    }
-
-    /// Get the target quantity, which is
-    ///     `1 / (target square root price)` in case of sell order
-    ///     `target square root price` in case of buy order
-    ///
-    /// ...based on the input amount, current liquidity, and current alpha price
-    ///
-    fn get_target_quantity(&self, order_type: &OrderType, delta_in: u64) -> SqrtPrice {
-        let liquidity_curr = self.get_safe_current_liquidity();
-        let sqrt_price_curr = self.state_ops.get_alpha_sqrt_price().into();
-        let delta_fixed = U64F64::saturating_from_num(delta_in);
-        let one = U64F64::saturating_from_num(1);
-
-        if liquidity_curr > 0 {
-            match order_type {
-                OrderType::Buy => delta_fixed
-                    .safe_div(liquidity_curr)
-                    .saturating_add(sqrt_price_curr)
-                    .into(),
-                OrderType::Sell => delta_fixed
-                    .safe_div(liquidity_curr)
-                    .saturating_add(one.safe_div(sqrt_price_curr))
-                    .into(),
-            }
-        } else {
-            // No liquidity means zero
-            SqrtPrice::saturating_from_num(0)
-        }
-    }
-
-    /// Get the input amount needed to reach the target price
-    ///
-    fn get_delta_in(&self, order_type: &OrderType, sqrt_price_target: SqrtPrice) -> u64 {
-        let liquidity_curr = self.get_safe_current_liquidity();
-        let one = U64F64::saturating_from_num(1);
-        let sqrt_price_curr = self.state_ops.get_alpha_sqrt_price().into();
-
-        (match order_type {
-            OrderType::Sell => liquidity_curr.saturating_mul(
-                one.safe_div(sqrt_price_target.into())
-                    .saturating_sub(one.safe_div(sqrt_price_curr)),
-            ),
-            OrderType::Buy => {
-                liquidity_curr.saturating_mul(sqrt_price_target.saturating_sub(sqrt_price_curr))
-            }
-        })
-        .saturating_to_num::<u64>()
-    }
-
-    /// Add fees to the global fee counters
-    fn add_fees(&mut self, order_type: &OrderType, fee: u64) {
-        let liquidity_curr = self.get_safe_current_liquidity();
-        if liquidity_curr > 0 {
-            let fee_global_tao: U64F64 = self.state_ops.get_fee_global_tao();
-            let fee_global_alpha: U64F64 = self.state_ops.get_fee_global_alpha();
-            let fee_fixed: U64F64 = U64F64::saturating_from_num(fee);
-
-            match order_type {
-                OrderType::Sell => {
-                    self.state_ops.set_fee_global_tao(
-                        fee_global_tao.saturating_add(fee_fixed.safe_div(liquidity_curr)),
-                    );
-                }
-                OrderType::Buy => {
-                    self.state_ops.set_fee_global_alpha(
-                        fee_global_alpha.saturating_add(fee_fixed.safe_div(liquidity_curr)),
-                    );
-                }
-            }
-        }
-    }
-
-    /// Convert input amount (delta_in) to output amount (delta_out)
-    ///
-    /// This is the core method of uniswap V3 that tells how much
-    /// output token is given for an amount of input token within one
-    /// price tick.
-    ///
-    fn convert_deltas(&self, order_type: &OrderType, delta_in: u64) -> u64 {
-        let liquidity_curr = SqrtPrice::saturating_from_num(self.state_ops.get_current_liquidity());
-        let sqrt_price_curr = self.state_ops.get_alpha_sqrt_price();
-        let delta_fixed = SqrtPrice::saturating_from_num(delta_in);
-
-        // TODO: Implement in safe and non-overflowing math
-        // Intentionally using unsafe math here to trigger CI
-
-        // // Prevent overflows:
-        // // If liquidity or delta are too large, reduce their precision and
-        // // save their factor for final correction. Price can take full U64F64
-        // // range, and it will not overflow u128 divisions or multiplications.
-        // let mut liquidity_factor: u64 = 1;
-        // if liquidity_curr > u32::MAX as u64 {
-        //     liquidity_factor = u32::MAX as u64;
-        //     liquidity_curr = liquidity_curr.safe_div(liquidity_factor);
-        // }
-        // let mut delta = delta_in as u64;
-        // let mut delta_factor: u64 = 1;
-        // if delta > u32::MAX as u64 {
-        //     delta_factor = u32::MAX as u64;
-        //     delta = delta.safe_div(delta_factor);
-        // }
-
-        // // This product does not overflow because we limit both
-        // // multipliers by u32::MAX (despite the u64 type)
-        // let delta_liquidity = delta.saturating_mul(liquidity);
-
-        // // This is product of delta_in * liquidity_curr * sqrt_price_curr
-        // let delta_liquidity_price: u128 =
-        //     Self::mul_u64_u64f64(delta_liquidity, sqrt_price_curr.into());
-
-        if delta_in > 0 {
-            (match order_type {
-                OrderType::Sell => {
-                    liquidity_curr * sqrt_price_curr * delta_fixed
-                        / (liquidity_curr / sqrt_price_curr + delta_fixed)
-                }
-                OrderType::Buy => {
-                    liquidity_curr / sqrt_price_curr * delta_fixed
-                        / (liquidity_curr * sqrt_price_curr + delta_fixed)
-                }
-            })
-            .to_num::<u64>()
-        } else {
-            0
-        }
-    }
-
-    /// Multiplies a `u64` by a `U64F64` and returns a `u128` result without overflow.
-    // pub fn mul_u64_u64f64(a: u64, b: U64F64) -> u128 {
-    //     // Multiply a by integer part of b in integer math.
-    //     // Result doesn't overflow u128 because both multipliers are 64 bit
-    //     let int_b: u64 = b.saturating_to_num::<u64>();
-    //     let high = (a as u128).saturating_mul(int_b as u128);
-
-    //     // Multiply a by fractional part of b using U64F64
-    //     let frac_b = b.saturating_sub(U64F64::saturating_from_num(int_b));
-    //     let low = U64F64::saturating_from_num(a).saturating_mul(frac_b);
-
-    //     // The only possible overflow (that is cut off by saturating math)
-    //     // is when a is u64::MAX, int_b is u64::MAX, and frac_b is non-zero,
-    //     // which is negligible error if we saturate and return u128::MAX
-    //     high.saturating_add(low).saturating_to_num::<u128>()
-    // }
-
-    /// Update token reserves after a swap
-    ///
-    fn update_reserves(&mut self, order_type: &OrderType, amount_in: u64, amount_out: u64) {
-        let (new_tao_reserve, new_alpha_reserve) = match order_type {
-            OrderType::Sell => (
-                self.state_ops.get_tao_reserve().saturating_add(amount_in),
-                self.state_ops
-                    .get_alpha_reserve()
-                    .saturating_sub(amount_out),
-            ),
-            OrderType::Buy => (
-                self.state_ops.get_tao_reserve().saturating_sub(amount_in),
-                self.state_ops
-                    .get_alpha_reserve()
-                    .saturating_add(amount_out),
-            ),
-        };
-
-        self.state_ops.set_tao_reserve(new_tao_reserve);
-        self.state_ops.set_alpha_reserve(new_alpha_reserve);
-    }
-
-    fn get_liquidity_update_u64(&self, tick: &Tick) -> u64 {
-        let liquidity_update_abs_i128 = tick.liquidity_net.abs();
-        if liquidity_update_abs_i128 > u64::MAX as i128 {
-            u64::MAX
-        } else {
-            liquidity_update_abs_i128 as u64
-        }
-    }
-
-    /// Update liquidity when crossing a tick
-    ///
-    fn update_liquidity_at_crossing(&mut self, order_type: &OrderType) -> Result<(), SwapError> {
-        let mut liquidity_curr = self.state_ops.get_current_liquidity();
-        let current_tick_index = self.get_current_tick_index();
-        match order_type {
-            OrderType::Sell => {
-                let maybe_tick = self.find_closest_lower_active_tick(current_tick_index);
-                if let Some(tick) = maybe_tick {
-                    let liquidity_update_abs_u64 = self.get_liquidity_update_u64(&tick);
-
-                    liquidity_curr = if tick.liquidity_net >= 0 {
-                        liquidity_curr.saturating_sub(liquidity_update_abs_u64)
-                    } else {
-                        liquidity_curr.saturating_add(liquidity_update_abs_u64)
-                    };
-                } else {
-                    return Err(SwapError::InsufficientLiquidity);
-                }
-            }
-            OrderType::Buy => {
-                let maybe_tick = self.find_closest_higher_active_tick(current_tick_index);
-                if let Some(tick) = maybe_tick {
-                    let liquidity_update_abs_u64 = self.get_liquidity_update_u64(&tick);
-
-                    liquidity_curr = if tick.liquidity_net >= 0 {
-                        liquidity_curr.saturating_add(liquidity_update_abs_u64)
-                    } else {
-                        liquidity_curr.saturating_sub(liquidity_update_abs_u64)
-                    };
-                } else {
-                    return Err(SwapError::InsufficientLiquidity);
-                }
-            }
-        }
-
-        self.state_ops.set_current_liquidity(liquidity_curr);
-        Ok(())
-    }
-
-    /// Collect fees for a position
-    /// Updates the position
-    ///
-    fn collect_fees(&mut self, position: &mut Position) -> (u64, u64) {
-        let mut fee_tao = self.get_fees_in_range(position, true);
-        let mut fee_alpha = self.get_fees_in_range(position, false);
-
-        fee_tao = fee_tao.saturating_sub(position.fees_tao);
-        fee_alpha = fee_alpha.saturating_sub(position.fees_alpha);
-
-        position.fees_tao = fee_tao;
-        position.fees_alpha = fee_alpha;
-
-        fee_tao = position.liquidity.saturating_mul(fee_tao);
-        fee_alpha = position.liquidity.saturating_mul(fee_alpha);
-
-        (fee_tao, fee_alpha)
-    }
-
-    /// Get fees in a position's range
-    ///
-    /// If quote flag is true, Tao is returned, otherwise alpha.
-    ///
-    fn get_fees_in_range(&mut self, position: &mut Position, quote: bool) -> u64 {
-        let i_lower = position.tick_low;
-        let i_upper = position.tick_high;
-
-        let fee_global = if quote {
-            self.state_ops.get_fee_global_tao()
-        } else {
-            self.state_ops.get_fee_global_alpha()
-        };
-
-        fee_global
-            .saturating_sub(self.get_fees_below(i_lower, quote))
-            .saturating_sub(self.get_fees_above(i_upper, quote))
-            .saturating_to_num::<u64>()
-    }
-
-    /// Get fees above a tick
-    ///
-    fn get_fees_above(&mut self, tick_index: TickIndex, quote: bool) -> U64F64 {
-        let maybe_tick_index = self.find_closest_lower_active_tick_index(tick_index);
-        let current_tick = self.get_current_tick_index();
-
-        if let Some(tick_index) = maybe_tick_index {
-            let tick = self
-                .state_ops
-                .get_tick_by_index(tick_index)
-                .unwrap_or_default();
-            if tick_index <= current_tick {
-                if quote {
-                    self.state_ops
-                        .get_fee_global_tao()
-                        .saturating_sub(tick.fees_out_tao)
-                } else {
-                    self.state_ops
-                        .get_fee_global_alpha()
-                        .saturating_sub(tick.fees_out_alpha)
-                }
-            } else {
-                if quote {
-                    tick.fees_out_tao
-                } else {
-                    tick.fees_out_alpha
-                }
-            }
-        } else {
-            U64F64::saturating_from_num(0)
-        }
-    }
-
-    /// Get fees below a tick
-    fn get_fees_below(&mut self, tick_index: TickIndex, quote: bool) -> U64F64 {
-        let maybe_tick_index = self.find_closest_lower_active_tick_index(tick_index);
-        let current_tick = self.get_current_tick_index();
-
-        if let Some(tick_index) = maybe_tick_index {
-            let tick = self
-                .state_ops
-                .get_tick_by_index(tick_index)
-                .unwrap_or_default();
-            if tick_index <= current_tick {
-                if quote {
-                    tick.fees_out_tao
-                } else {
-                    tick.fees_out_alpha
-                }
-            } else {
-                if quote {
-                    self.state_ops
-                        .get_fee_global_tao()
-                        .saturating_sub(tick.fees_out_tao)
-                } else {
-                    self.state_ops
-                        .get_fee_global_alpha()
-                        .saturating_sub(tick.fees_out_alpha)
-                }
-            }
-        } else {
-            U64F64::saturating_from_num(0)
-        }
-    }
-
-    /// Active tick operations
-    ///
-    /// Data structure:
-    ///    Active ticks are stored in three hash maps, each representing a "Level"
-    ///    Level 0 stores one u128 word, where each bit represents one Level 1 word.
-    ///    Level 1 words each store also a u128 word, where each bit represents one Level 2 word.
-    ///    Level 2 words each store u128 word, where each bit represents a tick.
-    ///
-    /// Insertion: 3 reads, 3 writes
-    /// Search: 3-5 reads
-    /// Deletion: 2 reads, 1-3 writes
-    ///
-
-    // Use TickIndexBitmap::layer_to_index instead
-
-    pub fn insert_active_tick(&mut self, index: TickIndex) {
-        // Check the range
-        if (index < TickIndex::MIN) || (index > TickIndex::MAX) {
-            return;
-        }
-
-        // Convert to bitmap representation
-        let bitmap = TickIndexBitmap::from(index);
-
-        // Update layer words
-        let mut word0_value = self.state_ops.get_layer0_word(bitmap.word_at(Layer::Top));
-        let mut word1_value = self
-            .state_ops
-            .get_layer1_word(bitmap.word_at(Layer::Middle));
-        let mut word2_value = self
-            .state_ops
-            .get_layer2_word(bitmap.word_at(Layer::Bottom));
-
-        // Set bits in each layer
-        word0_value |= bitmap.bit_mask(Layer::Top);
-        word1_value |= bitmap.bit_mask(Layer::Middle);
-        word2_value |= bitmap.bit_mask(Layer::Bottom);
-
-        // Update the storage
-        self.state_ops
-            .set_layer0_word(bitmap.word_at(Layer::Top), word0_value);
-        self.state_ops
-            .set_layer1_word(bitmap.word_at(Layer::Middle), word1_value);
-        self.state_ops
-            .set_layer2_word(bitmap.word_at(Layer::Bottom), word2_value);
-    }
-
-    pub fn remove_active_tick(&mut self, index: TickIndex) {
-        // Check the range
-        if (index < TickIndex::MIN) || (index > TickIndex::MAX) {
-            return;
-        }
-
-        // Convert to bitmap representation
-        let bitmap = TickIndexBitmap::from(index);
-
-        // Update layer words
-        let mut word0_value = self.state_ops.get_layer0_word(bitmap.word_at(Layer::Top));
-        let mut word1_value = self
-            .state_ops
-            .get_layer1_word(bitmap.word_at(Layer::Middle));
-        let mut word2_value = self
-            .state_ops
-            .get_layer2_word(bitmap.word_at(Layer::Bottom));
-
-        // Turn the bit off (& !bit) and save as needed
-        word2_value &= !bitmap.bit_mask(Layer::Bottom);
-        self.state_ops
-            .set_layer2_word(bitmap.word_at(Layer::Bottom), word2_value);
-
-        if word2_value == 0 {
-            word1_value &= !bitmap.bit_mask(Layer::Middle);
-            self.state_ops
-                .set_layer1_word(bitmap.word_at(Layer::Middle), word1_value);
-        }
-
-        if word1_value == 0 {
-            word0_value &= !bitmap.bit_mask(Layer::Top);
-            self.state_ops
-                .set_layer0_word(bitmap.word_at(Layer::Top), word0_value);
-        }
-    }
-
-    pub fn find_closest_active_tick_index(
-        &self,
-        index: TickIndex,
-        lower: bool,
-    ) -> Option<TickIndex> {
-        // Check the range
-        if (index < TickIndex::MIN) || (index > TickIndex::MAX) {
-            return None;
-        }
-
-        // Convert to bitmap representation
-        let bitmap = TickIndexBitmap::from(index);
-        let mut found = false;
-        let mut result: u32 = 0;
-
-        // Layer positions from bitmap
-        let layer0_word = bitmap.word_at(Layer::Top);
-        let layer0_bit = bitmap.bit_at(Layer::Top);
-        let layer1_word = bitmap.word_at(Layer::Middle);
-        let layer1_bit = bitmap.bit_at(Layer::Middle);
-        let layer2_word = bitmap.word_at(Layer::Bottom);
-        let layer2_bit = bitmap.bit_at(Layer::Bottom);
-
-        // Find the closest active bits in layer 0, then 1, then 2
-
-        ///////////////
-        // Level 0
-        let word0 = self.state_ops.get_layer0_word(layer0_word);
-        let closest_bits_l0 =
-            TickIndexBitmap::find_closest_active_bit_candidates(word0, layer0_bit, lower);
-
-        closest_bits_l0.iter().for_each(|&closest_bit_l0| {
-            ///////////////
-            // Level 1
-            let word1_index = TickIndexBitmap::layer_to_index(0, closest_bit_l0);
-
-            // Layer 1 words are different, shift the bit to the word edge
-            let start_from_l1_bit = if word1_index < layer1_word {
-                127
-            } else if word1_index > layer1_word {
-                0
-            } else {
-                layer1_bit
-            };
-            let word1_value = self.state_ops.get_layer1_word(word1_index);
-
-            let closest_bits_l1 = TickIndexBitmap::find_closest_active_bit_candidates(
-                word1_value,
-                start_from_l1_bit,
-                lower,
-            );
-            closest_bits_l1.iter().for_each(|&closest_bit_l1| {
-                ///////////////
-                // Level 2
-                let word2_index = TickIndexBitmap::layer_to_index(word1_index, closest_bit_l1);
-
-                // Layer 2 words are different, shift the bit to the word edge
-                let start_from_l2_bit = if word2_index < layer2_word {
-                    127
-                } else if word2_index > layer2_word {
-                    0
-                } else {
-                    layer2_bit
-                };
-
-                let word2_value = self.state_ops.get_layer2_word(word2_index);
-                let closest_bits_l2 = TickIndexBitmap::find_closest_active_bit_candidates(
-                    word2_value,
-                    start_from_l2_bit,
-                    lower,
-                );
-
-                if closest_bits_l2.len() > 0 {
-                    // The active tick is found, restore its full index and return
-                    let offset_found_index =
-                        TickIndexBitmap::layer_to_index(word2_index, closest_bits_l2[0]);
-
-                    if lower {
-                        if (offset_found_index > result) || (!found) {
-                            result = offset_found_index;
-                            found = true;
-                        }
-                    } else {
-                        if (offset_found_index < result) || (!found) {
-                            result = offset_found_index;
-                            found = true;
-                        }
-                    }
-                }
-            });
-        });
-
-        if !found {
-            return None;
-        }
-
-        // Convert the result offset_index back to a tick index
-        TickIndex::from_offset_index(result).ok()
+impl From<Uuid> for PositionId {
+    fn from(value: Uuid) -> Self {
+        Self(value.into_bytes())
     }
+}
 
-    pub fn find_closest_lower_active_tick_index(&self, index: TickIndex) -> Option<TickIndex> {
-        self.find_closest_active_tick_index(index, true)
+impl From<PositionId> for Uuid {
+    fn from(value: PositionId) -> Self {
+        Uuid::from_bytes(value.0)
     }
+}
 
-    pub fn find_closest_higher_active_tick_index(&self, index: TickIndex) -> Option<TickIndex> {
-        self.find_closest_active_tick_index(index, false)
-    }
+#[derive(
+    Clone, Copy, Decode, Default, Encode, Eq, MaxEncodedLen, PartialEq, RuntimeDebug, TypeInfo,
+)]
+pub struct NetUid(u16);
 
-    pub fn find_closest_lower_active_tick(&self, index: TickIndex) -> Option<Tick> {
-        let maybe_tick_index = self.find_closest_lower_active_tick_index(index);
-        if let Some(tick_index) = maybe_tick_index {
-            self.state_ops.get_tick_by_index(tick_index)
-        } else {
-            None
-        }
+impl From<NetUid> for u16 {
+    fn from(val: NetUid) -> Self {
+        val.0
     }
+}
 
-    pub fn find_closest_higher_active_tick(&self, index: TickIndex) -> Option<Tick> {
-        let maybe_tick_index = self.find_closest_higher_active_tick_index(index);
-        if let Some(tick_index) = maybe_tick_index {
-            self.state_ops.get_tick_by_index(tick_index)
-        } else {
-            None
-        }
+impl From<u16> for NetUid {
+    fn from(value: u16) -> Self {
+        Self(value)
     }
 }
 
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, Decode, Encode, Eq, PartialEq)]
 pub enum SwapError {
     /// The provided amount is insufficient for the swap.
     InsufficientInputAmount,
@@ -1339,1188 +178,3 @@ pub enum SwapError {
     TooManySwapSteps,
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use approx::assert_abs_diff_eq;
-    use sp_arithmetic::helpers_128bit::sqrt;
-    use std::collections::HashMap;
-
-    #[derive(Debug, Clone)]
-    pub struct MockSwapDataOperations {
-        is_initialized: bool,
-        fee_rate: u16,
-        minimum_liquidity: u64,
-        ticks: HashMap<TickIndex, Tick>,
-        min_sqrt_price: SqrtPrice,
-        max_sqrt_price: SqrtPrice,
-        tao_reserve: u64,
-        alpha_reserve: u64,
-        alpha_sqrt_price: SqrtPrice,
-        fee_global_tao: U64F64,
-        fee_global_alpha: U64F64,
-        current_liquidity: u64,
-        max_positions: u16,
-        balances: HashMap<u16, (u64, u64)>,
-        positions: HashMap<u16, HashMap<u16, Position>>,
-        tick_index_l0: HashMap<u32, u128>,
-        tick_index_l1: HashMap<u32, u128>,
-        tick_index_l2: HashMap<u32, u128>,
-    }
-
-    impl MockSwapDataOperations {
-        pub fn new() -> Self {
-            Self {
-                is_initialized: false,
-                fee_rate: 196,
-                minimum_liquidity: 1000,
-                ticks: HashMap::new(),
-                min_sqrt_price: SqrtPrice::from_num(0.01),
-                max_sqrt_price: SqrtPrice::from_num(10),
-                tao_reserve: 0,
-                alpha_reserve: 0,
-                alpha_sqrt_price: SqrtPrice::from_num(0),
-                fee_global_tao: U64F64::from_num(0),
-                fee_global_alpha: U64F64::from_num(0),
-                current_liquidity: 0,
-                max_positions: 100,
-                balances: HashMap::new(),
-                positions: HashMap::new(),
-                tick_index_l0: HashMap::new(),
-                tick_index_l1: HashMap::new(),
-                tick_index_l2: HashMap::new(),
-            }
-        }
-    }
-
-    impl SwapDataOperations<u16> for MockSwapDataOperations {
-        fn is_v3_initialized(&self) -> bool {
-            self.is_initialized
-        }
-
-        fn set_v3_initialized(&mut self) {
-            self.is_initialized = true;
-        }
-
-        fn get_fee_rate(&self) -> u16 {
-            self.fee_rate
-        }
-
-        fn get_minimum_liquidity(&self) -> u64 {
-            self.minimum_liquidity
-        }
-
-        fn get_tick_by_index(&self, tick_index: TickIndex) -> Option<Tick> {
-            self.ticks.get(&tick_index).cloned()
-        }
-
-        fn insert_tick_by_index(&mut self, tick_index: TickIndex, tick: Tick) {
-            self.ticks.insert(tick_index, tick);
-        }
-
-        fn remove_tick_by_index(&mut self, tick_index: TickIndex) {
-            self.ticks.remove(&tick_index);
-        }
-
-        fn get_min_sqrt_price(&self) -> SqrtPrice {
-            self.min_sqrt_price
-        }
-
-        fn get_max_sqrt_price(&self) -> SqrtPrice {
-            self.max_sqrt_price
-        }
-
-        fn get_tao_reserve(&self) -> u64 {
-            self.tao_reserve
-        }
-
-        fn set_tao_reserve(&mut self, tao: u64) -> u64 {
-            self.tao_reserve = tao;
-            tao
-        }
-
-        fn get_alpha_reserve(&self) -> u64 {
-            self.alpha_reserve
-        }
-
-        fn set_alpha_reserve(&mut self, alpha: u64) -> u64 {
-            self.alpha_reserve = alpha;
-            alpha
-        }
-
-        fn get_alpha_sqrt_price(&self) -> SqrtPrice {
-            self.alpha_sqrt_price
-        }
-
-        fn set_alpha_sqrt_price(&mut self, sqrt_price: SqrtPrice) {
-            self.alpha_sqrt_price = sqrt_price;
-        }
-
-        fn get_fee_global_tao(&self) -> U64F64 {
-            self.fee_global_tao
-        }
-
-        fn set_fee_global_tao(&mut self, fee: U64F64) {
-            self.fee_global_tao = fee;
-        }
-
-        fn get_fee_global_alpha(&self) -> U64F64 {
-            self.fee_global_alpha
-        }
-
-        fn set_fee_global_alpha(&mut self, fee: U64F64) {
-            self.fee_global_alpha = fee;
-        }
-
-        fn get_current_liquidity(&self) -> u64 {
-            self.current_liquidity
-        }
-
-        fn set_current_liquidity(&mut self, liquidity: u64) {
-            self.current_liquidity = liquidity;
-        }
-
-        fn get_max_positions(&self) -> u16 {
-            self.max_positions
-        }
-
-        fn withdraw_balances(
-            &mut self,
-            account_id: &u16,
-            tao: u64,
-            alpha: u64,
-        ) -> Result<(u64, u64), SwapError> {
-            let (current_tao, current_alpha) =
-                self.balances.get(account_id).cloned().unwrap_or((0, 0));
-
-            if (tao > current_tao) || (alpha > current_alpha) {
-                return Err(SwapError::InsufficientBalance);
-            }
-
-            self.balances
-                .insert(*account_id, (current_tao - tao, current_alpha - alpha));
-
-            Ok((tao, alpha))
-        }
-
-        fn deposit_balances(&mut self, account_id: &u16, tao: u64, alpha: u64) {
-            let (current_tao, current_alpha) =
-                self.balances.get(account_id).cloned().unwrap_or((0, 0));
-            self.balances.insert(
-                account_id.clone(),
-                (current_tao + tao, current_alpha + alpha),
-            );
-        }
-
-        fn get_protocol_account_id(&self) -> u16 {
-            0xFFFF
-        }
-
-        fn get_position_count(&self, account_id: &u16) -> u16 {
-            self.positions.get(account_id).map_or(0, |p| p.len() as u16)
-        }
-
-        fn get_position(&self, account_id: &u16, position_id: u16) -> Option<Position> {
-            self.positions
-                .get(account_id)
-                .and_then(|p| p.get(&position_id).cloned())
-        }
-
-        fn create_position(&mut self, account_id: &u16, position: Position) -> u16 {
-            let entry = self
-                .positions
-                .entry(account_id.clone())
-                .or_insert_with(HashMap::new);
-
-            // Find the next available position ID
-            let new_position_id = entry.keys().max().map_or(0, |max_id| max_id + 1);
-
-            entry.insert(new_position_id, position);
-            new_position_id
-        }
-
-        fn update_position(&mut self, account_id: &u16, position_id: u16, position: Position) {
-            if let Some(account_positions) = self.positions.get_mut(account_id) {
-                account_positions.insert(position_id, position);
-            }
-        }
-
-        fn remove_position(&mut self, account_id: &u16, position_id: u16) {
-            if let Some(account_positions) = self.positions.get_mut(account_id) {
-                account_positions.remove(&position_id);
-            }
-        }
-
-        fn get_layer0_word(&self, word_index: u32) -> u128 {
-            *self.tick_index_l0.get(&word_index).unwrap_or(&0_u128)
-        }
-        fn get_layer1_word(&self, word_index: u32) -> u128 {
-            *self.tick_index_l1.get(&word_index).unwrap_or(&0_u128)
-        }
-        fn get_layer2_word(&self, word_index: u32) -> u128 {
-            *self.tick_index_l2.get(&word_index).unwrap_or(&0_u128)
-        }
-        fn set_layer0_word(&mut self, word_index: u32, word: u128) {
-            self.tick_index_l0.insert(word_index, word);
-        }
-        fn set_layer1_word(&mut self, word_index: u32, word: u128) {
-            self.tick_index_l1.insert(word_index, word);
-        }
-        fn set_layer2_word(&mut self, word_index: u32, word: u128) {
-            self.tick_index_l2.insert(word_index, word);
-        }
-    }
-
-    #[test]
-    fn test_swap_initialization() {
-        let tao = 1_000_000_000;
-        let alpha = 4_000_000_000;
-
-        let mut mock_ops = MockSwapDataOperations::new();
-        mock_ops.set_tao_reserve(tao);
-        mock_ops.set_alpha_reserve(alpha);
-        let swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
-
-        // Active ticks
-        let tick_low = swap.state_ops.get_tick_by_index(TickIndex::MIN).unwrap();
-        let tick_high = swap.state_ops.get_tick_by_index(TickIndex::MAX).unwrap();
-        let liquidity = sqrt(alpha as u128 * tao as u128) as u64;
-        let expected_liquidity_net_low: i128 = liquidity as i128;
-        let expected_liquidity_gross_low: u64 = liquidity;
-        let expected_liquidity_net_high: i128 = (liquidity as i128).neg();
-        let expected_liquidity_gross_high: u64 = liquidity;
-        assert_eq!(tick_low.liquidity_net, expected_liquidity_net_low,);
-        assert_eq!(tick_low.liquidity_gross, expected_liquidity_gross_low,);
-        assert_eq!(tick_high.liquidity_net, expected_liquidity_net_high,);
-        assert_eq!(tick_high.liquidity_gross, expected_liquidity_gross_high,);
-
-        // Liquidity position at correct ticks
-        let account_id = swap.state_ops.get_protocol_account_id();
-        assert_eq!(swap.state_ops.get_position_count(&account_id), 1);
-
-        let position = swap.state_ops.get_position(&account_id, 0).unwrap();
-        assert_eq!(position.liquidity, liquidity);
-        assert_eq!(position.tick_low, TickIndex::MIN);
-        assert_eq!(position.tick_high, TickIndex::MAX);
-        assert_eq!(position.fees_alpha, 0);
-        assert_eq!(position.fees_tao, 0);
-
-        // Current liquidity
-        assert_eq!(swap.state_ops.get_current_liquidity(), liquidity);
-
-        // Current price
-        let sqrt_price = swap.state_ops.get_alpha_sqrt_price();
-        assert_abs_diff_eq!(sqrt_price.to_num::<f64>(), 0.50, epsilon = 0.00001,);
-    }
-
-    fn price_to_tick(price: f64) -> TickIndex {
-        let price_sqrt: SqrtPrice = SqrtPrice::from_num(price.sqrt());
-        // Handle potential errors in the conversion
-        match TickIndex::try_from_sqrt_price(price_sqrt) {
-            Ok(mut tick) => {
-                // Ensure the tick is within bounds
-                if tick > TickIndex::MAX {
-                    tick = TickIndex::MAX;
-                } else if tick < TickIndex::MIN {
-                    tick = TickIndex::MIN;
-                }
-                tick
-            }
-            // Default to a reasonable value when conversion fails
-            Err(_) => {
-                if price > 1.0 {
-                    TickIndex::MAX
-                } else {
-                    TickIndex::MIN
-                }
-            }
-        }
-    }
-
-    fn tick_to_price(tick: TickIndex) -> f64 {
-        // Handle errors gracefully
-        match tick.try_to_sqrt_price() {
-            Ok(price_sqrt) => (price_sqrt * price_sqrt).to_num::<f64>(),
-            Err(_) => {
-                // Return a sensible default based on whether the tick is above or below the valid range
-                if tick > TickIndex::MAX {
-                    tick_to_price(TickIndex::MAX) // Use the max valid tick price
-                } else {
-                    tick_to_price(TickIndex::MIN) // Use the min valid tick price
-                }
-            }
-        }
-    }
-
-    #[test]
-    fn test_tick_price_sanity_check() {
-        let min_price = tick_to_price(TickIndex::MIN);
-        let max_price = tick_to_price(TickIndex::MAX);
-        assert!(min_price > 0.);
-        assert!(max_price > 0.);
-        assert!(max_price > min_price);
-        assert!(min_price < 0.000001);
-        assert!(max_price > 10.);
-
-        // Roundtrip conversions
-        let min_price_sqrt: SqrtPrice = TickIndex::MIN.try_to_sqrt_price().unwrap();
-        let min_tick = TickIndex::try_from_sqrt_price(min_price_sqrt).unwrap();
-        assert_eq!(min_tick, TickIndex::MIN);
-
-        let max_price_sqrt: SqrtPrice = TickIndex::MAX.try_to_sqrt_price().unwrap();
-        let max_tick = TickIndex::try_from_sqrt_price(max_price_sqrt).unwrap();
-        assert_eq!(max_tick, TickIndex::MAX);
-    }
-
-    // Test adding liquidity on top of the existing protocol liquidity
-    #[test]
-    fn test_add_liquidity_basic() {
-        let protocol_tao = 1_000_000_000;
-        let protocol_alpha = 4_000_000_000;
-        let user_tao = 100_000_000_000;
-        let user_alpha = 100_000_000_000;
-        let account_id = 1;
-        let min_price = tick_to_price(TickIndex::MIN);
-        let max_price = tick_to_price(TickIndex::MAX);
-        let max_tick = price_to_tick(max_price);
-        let current_price = 0.25;
-        assert_eq!(max_tick, TickIndex::MAX);
-
-        // As a user add liquidity with all possible corner cases
-        //   - Initial price is 0.25
-        //   - liquidity is expressed in RAO units
-        // Test case is (price_low, price_high, liquidity, tao, alpha)
-        [
-            // Repeat the protocol liquidity at maximum range: Expect all the same values
-            (
-                min_price,
-                max_price,
-                2_000_000_000_u64,
-                1_000_000_000_u64,
-                4_000_000_000_u64,
-            ),
-            // Repeat the protocol liquidity at current to max range: Expect the same alpha
-            (0.25, max_price, 2_000_000_000_u64, 0, 4_000_000_000),
-            // Repeat the protocol liquidity at min to current range: Expect all the same tao
-            (min_price, 0.24999, 2_000_000_000_u64, 1_000_000_000, 0),
-            // Half to double price - just some sane wothdraw amounts
-            (0.125, 0.5, 2_000_000_000_u64, 293_000_000, 1_171_000_000),
-            // Both below price - tao is non-zero, alpha is zero
-            (0.12, 0.13, 2_000_000_000_u64, 28_270_000, 0),
-            // Both above price - tao is zero, alpha is non-zero
-            (0.3, 0.4, 2_000_000_000_u64, 0, 489_200_000),
-        ]
-        .iter()
-        .for_each(|(price_low, price_high, liquidity, tao, alpha)| {
-            // Calculate ticks (assuming tick math is tested separately)
-            let tick_low = price_to_tick(*price_low);
-            let tick_high = price_to_tick(*price_high);
-
-            // Setup swap
-            let mut mock_ops = MockSwapDataOperations::new();
-            mock_ops.set_tao_reserve(protocol_tao);
-            mock_ops.set_alpha_reserve(protocol_alpha);
-            mock_ops.deposit_balances(&account_id, user_tao, user_alpha);
-            let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
-
-            // Get tick infos and liquidity before adding (to account for protocol liquidity)
-            let tick_low_info_before = swap
-                .state_ops
-                .get_tick_by_index(tick_low)
-                .unwrap_or_default();
-            let tick_high_info_before = swap
-                .state_ops
-                .get_tick_by_index(tick_high)
-                .unwrap_or_default();
-            let liquidity_before = swap.state_ops.get_current_liquidity();
-
-            // Add liquidity
-            assert!(
-                swap.add_liquidity(&account_id, tick_low, tick_high, *liquidity, false)
-                    .is_ok()
-            );
-
-            // Check that low and high ticks appear in the state and are properly updated
-            let tick_low_info = swap.state_ops.get_tick_by_index(tick_low).unwrap();
-            let tick_high_info = swap.state_ops.get_tick_by_index(tick_high).unwrap();
-            let expected_liquidity_net_low: i128 = *liquidity as i128;
-            let expected_liquidity_gross_low: u64 = *liquidity;
-            let expected_liquidity_net_high: i128 = (*liquidity as i128).neg();
-            let expected_liquidity_gross_high: u64 = *liquidity;
-            assert_eq!(
-                tick_low_info.liquidity_net - tick_low_info_before.liquidity_net,
-                expected_liquidity_net_low,
-            );
-            assert_eq!(
-                tick_low_info.liquidity_gross - tick_low_info_before.liquidity_gross,
-                expected_liquidity_gross_low,
-            );
-            assert_eq!(
-                tick_high_info.liquidity_net - tick_high_info_before.liquidity_net,
-                expected_liquidity_net_high,
-            );
-            assert_eq!(
-                tick_high_info.liquidity_gross - tick_high_info_before.liquidity_gross,
-                expected_liquidity_gross_high,
-            );
-
-            // Balances are withdrawn
-            let (user_tao_after, user_alpha_after) =
-                swap.state_ops.balances.get(&account_id).unwrap();
-            let tao_withdrawn = user_tao - user_tao_after;
-            let alpha_withdrawn = user_alpha - user_alpha_after;
-            assert_abs_diff_eq!(tao_withdrawn, *tao, epsilon = *tao / 1000);
-            assert_abs_diff_eq!(alpha_withdrawn, *alpha, epsilon = *alpha / 1000);
-
-            // Liquidity position at correct ticks
-            assert_eq!(swap.state_ops.get_position_count(&account_id), 1);
-
-            let position = swap.state_ops.get_position(&account_id, 0).unwrap();
-            assert_eq!(position.liquidity, *liquidity);
-            assert_eq!(position.tick_low, tick_low);
-            assert_eq!(position.tick_high, tick_high);
-            assert_eq!(position.fees_alpha, 0);
-            assert_eq!(position.fees_tao, 0);
-
-            // Current liquidity is updated only when price range includes the current price
-            if (*price_high >= current_price) && (*price_low <= current_price) {
-                assert_eq!(
-                    swap.state_ops.get_current_liquidity(),
-                    liquidity_before + *liquidity
-                );
-            } else {
-                assert_eq!(swap.state_ops.get_current_liquidity(), liquidity_before);
-            }
-
-            // Reserves are updated
-            assert_eq!(
-                swap.state_ops.get_tao_reserve(),
-                tao_withdrawn + protocol_tao,
-            );
-            assert_eq!(
-                swap.state_ops.get_alpha_reserve(),
-                alpha_withdrawn + protocol_alpha,
-            );
-        });
-    }
-
-    #[test]
-    fn test_add_liquidity_out_of_bounds() {
-        let protocol_tao = 1_000_000_000;
-        let protocol_alpha = 2_000_000_000;
-        let user_tao = 100_000_000_000;
-        let user_alpha = 100_000_000_000;
-        let account_id = 1;
-
-        [
-            // For our tests, we'll construct TickIndex values that are intentionally
-            // outside the valid range for testing purposes only
-            (
-                TickIndex::new_unchecked(TickIndex::MIN.get() - 1),
-                TickIndex::MAX,
-                1_000_000_000_u64,
-            ),
-            (
-                TickIndex::MIN,
-                TickIndex::new_unchecked(TickIndex::MAX.get() + 1),
-                1_000_000_000_u64,
-            ),
-            (
-                TickIndex::new_unchecked(TickIndex::MIN.get() - 1),
-                TickIndex::new_unchecked(TickIndex::MAX.get() + 1),
-                1_000_000_000_u64,
-            ),
-            (
-                TickIndex::new_unchecked(TickIndex::MIN.get() - 100),
-                TickIndex::new_unchecked(TickIndex::MAX.get() + 100),
-                1_000_000_000_u64,
-            ),
-        ]
-        .iter()
-        .for_each(|(tick_low, tick_high, liquidity)| {
-            // Setup swap
-            let mut mock_ops = MockSwapDataOperations::new();
-            mock_ops.set_tao_reserve(protocol_tao);
-            mock_ops.set_alpha_reserve(protocol_alpha);
-            mock_ops.deposit_balances(&account_id, user_tao, user_alpha);
-            let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
-
-            // Add liquidity
-            assert_eq!(
-                swap.add_liquidity(&account_id, *tick_low, *tick_high, *liquidity, false),
-                Err(SwapError::InvalidTickRange),
-            );
-        });
-    }
-
-    #[test]
-    fn test_add_liquidity_over_balance() {
-        let protocol_tao = 1_000_000_000;
-        let protocol_alpha = 4_000_000_000;
-        let user_tao = 1_000_000_000;
-        let user_alpha = 1_000_000_000;
-        let account_id = 1;
-
-        [
-            // Lower than price (not enough alpha)
-            (0.1, 0.2, 100_000_000_000_u64),
-            // Higher than price (not enough tao)
-            (0.3, 0.4, 100_000_000_000_u64),
-            // Around the price (not enough both)
-            (0.1, 0.4, 100_000_000_000_u64),
-        ]
-        .iter()
-        .for_each(|(price_low, price_high, liquidity)| {
-            // Calculate ticks
-            let tick_low = price_to_tick(*price_low);
-            let tick_high = price_to_tick(*price_high);
-
-            // Setup swap
-            let mut mock_ops = MockSwapDataOperations::new();
-            mock_ops.set_tao_reserve(protocol_tao);
-            mock_ops.set_alpha_reserve(protocol_alpha);
-            mock_ops.deposit_balances(&account_id, user_tao, user_alpha);
-            let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
-
-            // Add liquidity
-            assert_eq!(
-                swap.add_liquidity(&account_id, tick_low, tick_high, *liquidity, false),
-                Err(SwapError::InsufficientBalance),
-            );
-        });
-    }
-
-    // Test removing liquidity
-    #[test]
-    fn test_remove_liquidity_basic() {
-        let protocol_tao = 1_000_000_000;
-        let protocol_alpha = 4_000_000_000;
-        let user_tao = 100_000_000_000;
-        let user_alpha = 100_000_000_000;
-        let account_id = 1;
-        let min_price = tick_to_price(TickIndex::MIN);
-        let max_price = tick_to_price(TickIndex::MAX);
-        let max_tick = price_to_tick(max_price);
-        assert_eq!(max_tick, TickIndex::MAX);
-
-        // As a user add liquidity with all possible corner cases
-        //   - Initial price is 0.25
-        //   - liquidity is expressed in RAO units
-        // Test case is (price_low, price_high, liquidity, tao, alpha)
-        [
-            // Repeat the protocol liquidity at maximum range: Expect all the same values
-            (
-                min_price,
-                max_price,
-                2_000_000_000_u64,
-                1_000_000_000_u64,
-                4_000_000_000_u64,
-            ),
-            // Repeat the protocol liquidity at current to max range: Expect the same alpha
-            (0.25, max_price, 2_000_000_000_u64, 0, 4_000_000_000),
-            // Repeat the protocol liquidity at min to current range: Expect all the same tao
-            (min_price, 0.24999, 2_000_000_000_u64, 1_000_000_000, 0),
-            // Half to double price - just some sane wothdraw amounts
-            (0.125, 0.5, 2_000_000_000_u64, 293_000_000, 1_171_000_000),
-            // Both below price - tao is non-zero, alpha is zero
-            (0.12, 0.13, 2_000_000_000_u64, 28_270_000, 0),
-            // Both above price - tao is zero, alpha is non-zero
-            (0.3, 0.4, 2_000_000_000_u64, 0, 489_200_000),
-        ]
-        .iter()
-        .for_each(|(price_low, price_high, liquidity, tao, alpha)| {
-            // Calculate ticks (assuming tick math is tested separately)
-            let tick_low = price_to_tick(*price_low);
-            let tick_high = price_to_tick(*price_high);
-
-            // Setup swap
-            let mut mock_ops = MockSwapDataOperations::new();
-            mock_ops.set_tao_reserve(protocol_tao);
-            mock_ops.set_alpha_reserve(protocol_alpha);
-            mock_ops.deposit_balances(&account_id, user_tao, user_alpha);
-            let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
-            let liquidity_before = swap.state_ops.get_current_liquidity();
-
-            // Add liquidity
-            assert!(
-                swap.add_liquidity(&account_id, tick_low, tick_high, *liquidity, false)
-                    .is_ok()
-            );
-
-            // Remove liquidity
-            let remove_result = swap.remove_liquidity(&account_id, 0).unwrap();
-            assert_abs_diff_eq!(remove_result.tao, *tao, epsilon = *tao / 1000);
-            assert_abs_diff_eq!(remove_result.alpha, *alpha, epsilon = *alpha / 1000);
-            assert_eq!(remove_result.fee_tao, 0);
-            assert_eq!(remove_result.fee_alpha, 0);
-
-            // Balances are returned
-            let (user_tao_after, user_alpha_after) =
-                swap.state_ops.balances.get(&account_id).unwrap();
-            assert_eq!(user_tao, *user_tao_after);
-            assert_eq!(user_alpha, *user_alpha_after);
-
-            // Liquidity position is removed
-            assert_eq!(swap.state_ops.get_position_count(&account_id), 0);
-            assert!(swap.state_ops.get_position(&account_id, 0).is_none());
-
-            // Current liquidity is updated (back where it was)
-            assert_eq!(swap.state_ops.get_current_liquidity(), liquidity_before);
-
-            // Reserves are updated (back where they were)
-            assert_eq!(swap.state_ops.get_tao_reserve(), protocol_tao,);
-            assert_eq!(swap.state_ops.get_alpha_reserve(), protocol_alpha,);
-        });
-    }
-
-    #[test]
-    fn test_remove_liquidity_nonexisting_position() {
-        let protocol_tao = 1_000_000_000;
-        let protocol_alpha = 4_000_000_000;
-        let user_tao = 100_000_000_000;
-        let user_alpha = 100_000_000_000;
-        let account_id = 1;
-        let min_price = tick_to_price(TickIndex::MIN);
-        let max_price = tick_to_price(TickIndex::MAX);
-        let max_tick = price_to_tick(max_price);
-        assert_eq!(max_tick.get(), TickIndex::MAX.get());
-
-        // Test case is (price_low, price_high, liquidity)
-        [
-            // Repeat the protocol liquidity at maximum range: Expect all the same values
-            (min_price, max_price, 2_000_000_000_u64),
-        ]
-        .iter()
-        .for_each(|(price_low, price_high, liquidity)| {
-            // Calculate ticks (assuming tick math is tested separately)
-            let tick_low = price_to_tick(*price_low);
-            let tick_high = price_to_tick(*price_high);
-
-            // Setup swap
-            let mut mock_ops = MockSwapDataOperations::new();
-            mock_ops.set_tao_reserve(protocol_tao);
-            mock_ops.set_alpha_reserve(protocol_alpha);
-            mock_ops.deposit_balances(&account_id, user_tao, user_alpha);
-            let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
-
-            // Add liquidity
-            assert!(
-                swap.add_liquidity(&account_id, tick_low, tick_high, *liquidity, false)
-                    .is_ok()
-            );
-
-            // Remove liquidity
-            assert_eq!(
-                swap.remove_liquidity(&account_id, 1),
-                Err(SwapError::LiquidityNotFound),
-            );
-        });
-    }
-
-    // cargo test --package pallet-subtensor-swap --lib -- tests::test_tick_search_basic --exact --show-output
-    #[test]
-    fn test_tick_search_basic() {
-        let mock_ops = MockSwapDataOperations::new();
-        let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
-
-        swap.insert_active_tick(TickIndex::MIN);
-        assert_eq!(
-            swap.find_closest_lower_active_tick_index(TickIndex::MIN)
-                .unwrap(),
-            TickIndex::MIN
-        );
-        assert_eq!(
-            swap.find_closest_lower_active_tick_index(TickIndex::MAX)
-                .unwrap(),
-            TickIndex::MIN
-        );
-        assert_eq!(
-            swap.find_closest_lower_active_tick_index(TickIndex::MAX.saturating_div(2))
-                .unwrap(),
-            TickIndex::MIN
-        );
-        assert_eq!(
-            swap.find_closest_lower_active_tick_index(TickIndex::MAX.prev().unwrap())
-                .unwrap(),
-            TickIndex::MIN
-        );
-        assert_eq!(
-            swap.find_closest_lower_active_tick_index(TickIndex::MIN.next().unwrap())
-                .unwrap(),
-            TickIndex::MIN
-        );
-
-        assert_eq!(
-            swap.find_closest_higher_active_tick_index(TickIndex::MIN)
-                .unwrap(),
-            TickIndex::MIN
-        );
-        assert_eq!(
-            swap.find_closest_higher_active_tick_index(TickIndex::MAX),
-            None
-        );
-        assert_eq!(
-            swap.find_closest_higher_active_tick_index(TickIndex::MAX.saturating_div(2)),
-            None
-        );
-        assert_eq!(
-            swap.find_closest_higher_active_tick_index(TickIndex::MAX.prev().unwrap()),
-            None
-        );
-        assert_eq!(
-            swap.find_closest_higher_active_tick_index(TickIndex::MIN.next().unwrap()),
-            None
-        );
-
-        swap.insert_active_tick(TickIndex::MAX);
-        assert_eq!(
-            swap.find_closest_lower_active_tick_index(TickIndex::MIN)
-                .unwrap(),
-            TickIndex::MIN
-        );
-        assert_eq!(
-            swap.find_closest_lower_active_tick_index(TickIndex::MAX)
-                .unwrap(),
-            TickIndex::MAX
-        );
-        assert_eq!(
-            swap.find_closest_lower_active_tick_index(TickIndex::MAX.saturating_div(2))
-                .unwrap(),
-            TickIndex::MIN
-        );
-        assert_eq!(
-            swap.find_closest_lower_active_tick_index(TickIndex::MAX.prev().unwrap())
-                .unwrap(),
-            TickIndex::MIN
-        );
-        assert_eq!(
-            swap.find_closest_lower_active_tick_index(TickIndex::MIN.next().unwrap())
-                .unwrap(),
-            TickIndex::MIN
-        );
-    }
-
-    #[test]
-    fn test_tick_search_sparse_queries() {
-        let mock_ops = MockSwapDataOperations::new();
-        let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
-
-        let active_index = TickIndex::MIN.saturating_add(10);
-        swap.insert_active_tick(active_index);
-        assert_eq!(
-            swap.find_closest_lower_active_tick_index(active_index)
-                .unwrap(),
-            active_index
-        );
-        assert_eq!(
-            swap.find_closest_lower_active_tick_index(TickIndex::MIN.saturating_add(11))
-                .unwrap(),
-            active_index
-        );
-        assert_eq!(
-            swap.find_closest_lower_active_tick_index(TickIndex::MIN.saturating_add(12))
-                .unwrap(),
-            active_index
-        );
-        assert_eq!(
-            swap.find_closest_lower_active_tick_index(TickIndex::MIN),
-            None
-        );
-        assert_eq!(
-            swap.find_closest_lower_active_tick_index(TickIndex::MIN.saturating_add(9)),
-            None
-        );
-
-        assert_eq!(
-            swap.find_closest_higher_active_tick_index(active_index)
-                .unwrap(),
-            active_index
-        );
-        assert_eq!(
-            swap.find_closest_higher_active_tick_index(TickIndex::MIN.saturating_add(11)),
-            None
-        );
-        assert_eq!(
-            swap.find_closest_higher_active_tick_index(TickIndex::MIN.saturating_add(12)),
-            None
-        );
-        assert_eq!(
-            swap.find_closest_higher_active_tick_index(TickIndex::MIN)
-                .unwrap(),
-            active_index
-        );
-        assert_eq!(
-            swap.find_closest_higher_active_tick_index(TickIndex::MIN.saturating_add(9))
-                .unwrap(),
-            active_index
-        );
-    }
-
-    #[test]
-    fn test_tick_search_many_lows() {
-        let mock_ops = MockSwapDataOperations::new();
-        let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
-
-        (0..1000).for_each(|i| {
-            swap.insert_active_tick(TickIndex::MIN.saturating_add(i));
-        });
-
-        for i in 0..1000 {
-            let test_index = TickIndex::MIN.saturating_add(i);
-            assert_eq!(
-                swap.find_closest_lower_active_tick_index(test_index)
-                    .unwrap(),
-                test_index
-            );
-            assert_eq!(
-                swap.find_closest_higher_active_tick_index(test_index)
-                    .unwrap(),
-                test_index
-            );
-        }
-    }
-
-    #[test]
-    fn test_tick_search_many_sparse() {
-        let mock_ops = MockSwapDataOperations::new();
-        let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
-        let count: i32 = 1000;
-
-        for i in 0..=count {
-            swap.insert_active_tick(TickIndex::new_unchecked(i * 10));
-        }
-        for i in 1..count {
-            let tick = TickIndex::new_unchecked(i * 10);
-            assert_eq!(
-                swap.find_closest_lower_active_tick_index(tick).unwrap(),
-                tick
-            );
-            assert_eq!(
-                swap.find_closest_higher_active_tick_index(tick).unwrap(),
-                tick
-            );
-            for j in 1..=9 {
-                let before_tick = TickIndex::new_unchecked(i * 10 - j);
-                let after_tick = TickIndex::new_unchecked(i * 10 + j);
-                let prev_tick = TickIndex::new_unchecked((i - 1) * 10);
-                let next_tick = TickIndex::new_unchecked((i + 1) * 10);
-                assert_eq!(
-                    swap.find_closest_lower_active_tick_index(before_tick)
-                        .unwrap(),
-                    prev_tick
-                );
-                assert_eq!(
-                    swap.find_closest_lower_active_tick_index(after_tick)
-                        .unwrap(),
-                    tick
-                );
-                assert_eq!(
-                    swap.find_closest_higher_active_tick_index(before_tick)
-                        .unwrap(),
-                    tick
-                );
-                assert_eq!(
-                    swap.find_closest_higher_active_tick_index(after_tick)
-                        .unwrap(),
-                    next_tick
-                );
-            }
-        }
-    }
-
-    #[test]
-    fn test_tick_search_many_lows_sparse_reversed() {
-        let mock_ops = MockSwapDataOperations::new();
-        let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
-        let count: i32 = 1000;
-
-        for i in (0..=count).rev() {
-            swap.insert_active_tick(TickIndex::new_unchecked(i * 10));
-        }
-        for i in 1..count {
-            let tick = TickIndex::new_unchecked(i * 10);
-            assert_eq!(
-                swap.find_closest_lower_active_tick_index(tick).unwrap(),
-                tick
-            );
-            assert_eq!(
-                swap.find_closest_higher_active_tick_index(tick).unwrap(),
-                tick
-            );
-            for j in 1..=9 {
-                let before_tick = TickIndex::new_unchecked(i * 10 - j);
-                let after_tick = TickIndex::new_unchecked(i * 10 + j);
-                let prev_tick = TickIndex::new_unchecked((i - 1) * 10);
-                let next_tick = TickIndex::new_unchecked((i + 1) * 10);
-
-                assert_eq!(
-                    swap.find_closest_lower_active_tick_index(before_tick)
-                        .unwrap(),
-                    prev_tick
-                );
-                assert_eq!(
-                    swap.find_closest_lower_active_tick_index(after_tick)
-                        .unwrap(),
-                    tick
-                );
-                assert_eq!(
-                    swap.find_closest_higher_active_tick_index(before_tick)
-                        .unwrap(),
-                    tick
-                );
-                assert_eq!(
-                    swap.find_closest_higher_active_tick_index(after_tick)
-                        .unwrap(),
-                    next_tick
-                );
-            }
-        }
-    }
-
-    #[test]
-    fn test_tick_search_repeated_insertions() {
-        let mock_ops = MockSwapDataOperations::new();
-        let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
-        let count: i32 = 1000;
-
-        for _ in 0..10 {
-            for i in 0..=count {
-                let tick = TickIndex::new_unchecked(i * 10);
-                swap.insert_active_tick(tick);
-            }
-            for i in 1..count {
-                let tick = TickIndex::new_unchecked(i * 10);
-                assert_eq!(
-                    swap.find_closest_lower_active_tick_index(tick).unwrap(),
-                    tick
-                );
-                assert_eq!(
-                    swap.find_closest_higher_active_tick_index(tick).unwrap(),
-                    tick
-                );
-                for j in 1..=9 {
-                    let before_tick = TickIndex::new_unchecked(i * 10 - j);
-                    let after_tick = TickIndex::new_unchecked(i * 10 + j);
-                    let prev_tick = TickIndex::new_unchecked((i - 1) * 10);
-                    let next_tick = TickIndex::new_unchecked((i + 1) * 10);
-
-                    assert_eq!(
-                        swap.find_closest_lower_active_tick_index(before_tick)
-                            .unwrap(),
-                        prev_tick
-                    );
-                    assert_eq!(
-                        swap.find_closest_lower_active_tick_index(after_tick)
-                            .unwrap(),
-                        tick
-                    );
-                    assert_eq!(
-                        swap.find_closest_higher_active_tick_index(before_tick)
-                            .unwrap(),
-                        tick
-                    );
-                    assert_eq!(
-                        swap.find_closest_higher_active_tick_index(after_tick)
-                            .unwrap(),
-                        next_tick
-                    );
-                }
-            }
-        }
-    }
-
-    #[test]
-    fn test_tick_search_full_range() {
-        let mock_ops = MockSwapDataOperations::new();
-        let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
-        let step = 1019;
-        // Get the full valid tick range by subtracting MIN from MAX
-        let count = (TickIndex::MAX.get() - TickIndex::MIN.get()) / step;
-
-        for i in 0..=count {
-            let index = TickIndex::MIN.saturating_add(i * step);
-            swap.insert_active_tick(index);
-        }
-        for i in 1..count {
-            let index = TickIndex::MIN.saturating_add(i * step);
-
-            let prev_index = TickIndex::new_unchecked(index.get() - step);
-            let next_minus_one = TickIndex::new_unchecked(index.get() + step - 1);
-
-            assert_eq!(
-                swap.find_closest_lower_active_tick_index(prev_index)
-                    .unwrap(),
-                prev_index
-            );
-            assert_eq!(
-                swap.find_closest_lower_active_tick_index(index).unwrap(),
-                index
-            );
-            assert_eq!(
-                swap.find_closest_lower_active_tick_index(next_minus_one)
-                    .unwrap(),
-                index
-            );
-
-            let mid_next = TickIndex::new_unchecked(index.get() + step / 2);
-            assert_eq!(
-                swap.find_closest_lower_active_tick_index(mid_next).unwrap(),
-                index
-            );
-
-            assert_eq!(
-                swap.find_closest_higher_active_tick_index(index).unwrap(),
-                index
-            );
-
-            let next_index = TickIndex::new_unchecked(index.get() + step);
-            assert_eq!(
-                swap.find_closest_higher_active_tick_index(next_index)
-                    .unwrap(),
-                next_index
-            );
-
-            let mid_next = TickIndex::new_unchecked(index.get() + step / 2);
-            assert_eq!(
-                swap.find_closest_higher_active_tick_index(mid_next)
-                    .unwrap(),
-                next_index
-            );
-
-            let next_minus_1 = TickIndex::new_unchecked(index.get() + step - 1);
-            assert_eq!(
-                swap.find_closest_higher_active_tick_index(next_minus_1)
-                    .unwrap(),
-                next_index
-            );
-            for j in 1..=9 {
-                let before_index = TickIndex::new_unchecked(index.get() - j);
-                let after_index = TickIndex::new_unchecked(index.get() + j);
-
-                assert_eq!(
-                    swap.find_closest_lower_active_tick_index(before_index)
-                        .unwrap(),
-                    prev_index
-                );
-                assert_eq!(
-                    swap.find_closest_lower_active_tick_index(after_index)
-                        .unwrap(),
-                    index
-                );
-                assert_eq!(
-                    swap.find_closest_higher_active_tick_index(before_index)
-                        .unwrap(),
-                    index
-                );
-                assert_eq!(
-                    swap.find_closest_higher_active_tick_index(after_index)
-                        .unwrap(),
-                    next_index
-                );
-            }
-        }
-    }
-
-    #[test]
-    fn test_tick_remove_basic() {
-        let mock_ops = MockSwapDataOperations::new();
-        let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
-
-        swap.insert_active_tick(TickIndex::MIN);
-        swap.insert_active_tick(TickIndex::MAX);
-        swap.remove_active_tick(TickIndex::MAX);
-
-        assert_eq!(
-            swap.find_closest_lower_active_tick_index(TickIndex::MIN)
-                .unwrap(),
-            TickIndex::MIN
-        );
-        assert_eq!(
-            swap.find_closest_lower_active_tick_index(TickIndex::MAX)
-                .unwrap(),
-            TickIndex::MIN
-        );
-        assert_eq!(
-            swap.find_closest_lower_active_tick_index(TickIndex::MAX.saturating_div(2))
-                .unwrap(),
-            TickIndex::MIN
-        );
-        assert_eq!(
-            swap.find_closest_lower_active_tick_index(TickIndex::MAX.prev().unwrap())
-                .unwrap(),
-            TickIndex::MIN
-        );
-        assert_eq!(
-            swap.find_closest_lower_active_tick_index(TickIndex::MIN.next().unwrap())
-                .unwrap(),
-            TickIndex::MIN
-        );
-
-        assert_eq!(
-            swap.find_closest_higher_active_tick_index(TickIndex::MIN)
-                .unwrap(),
-            TickIndex::MIN
-        );
-        assert_eq!(
-            swap.find_closest_higher_active_tick_index(TickIndex::MAX),
-            None
-        );
-        assert_eq!(
-            swap.find_closest_higher_active_tick_index(TickIndex::MAX.saturating_div(2)),
-            None
-        );
-        assert_eq!(
-            swap.find_closest_higher_active_tick_index(TickIndex::MAX.prev().unwrap()),
-            None
-        );
-        assert_eq!(
-            swap.find_closest_higher_active_tick_index(TickIndex::MIN.next().unwrap()),
-            None
-        );
-    }
-
-    #[test]
-    fn test_tick_remove_full_range() {
-        let mock_ops = MockSwapDataOperations::new();
-        let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
-        let step = 1019;
-        // Get the full valid tick range by subtracting MIN from MAX
-        let count = (TickIndex::MAX.get() - TickIndex::MIN.get()) / step;
-        let remove_frequency = 5; // Remove every 5th tick
-
-        // Insert ticks
-        for i in 0..=count {
-            let index = TickIndex::MIN.saturating_add(i * step);
-            swap.insert_active_tick(index);
-        }
-
-        // Remove some ticks
-        for i in 1..count {
-            if i % remove_frequency == 0 {
-                let index = TickIndex::MIN.saturating_add(i * step);
-                swap.remove_active_tick(index);
-            }
-        }
-
-        // Verify
-        for i in 1..count {
-            let index = TickIndex::MIN.saturating_add(i * step);
-
-            if i % remove_frequency == 0 {
-                let lower = swap.find_closest_lower_active_tick_index(index);
-                let higher = swap.find_closest_higher_active_tick_index(index);
-                assert!(lower != Some(index));
-                assert!(higher != Some(index));
-            } else {
-                assert_eq!(
-                    swap.find_closest_lower_active_tick_index(index).unwrap(),
-                    index
-                );
-                assert_eq!(
-                    swap.find_closest_higher_active_tick_index(index).unwrap(),
-                    index
-                );
-            }
-        }
-    }
-}
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index beb93440ae..8456bb45bd 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -6,11 +6,14 @@ use sp_runtime::traits::AccountIdConversion;
 use substrate_fixed::types::U64F64;
 
 use super::pallet::*;
-use crate::tick::{Tick, TickIndex};
+use crate::{
+    NetUid, Position, PositionId, RemoveLiquidityResult,
+    tick::{Tick, TickIndex},
+};
 
 impl<T: Config> Pallet<T> {
-    // initializes V3 swap for a subnet
-    fn maybe_initialize_v3(netuid: u16) -> Result<(), Error<T>> {
+    // initializes V3 swap for a subnet if needed
+    fn maybe_initialize_v3(netuid: NetUid) -> Result<(), Error<T>> {
         if SwapV3Initialized::<T>::get(netuid) {
             return Ok(());
         }
@@ -34,16 +37,17 @@ impl<T: Config> Pallet<T> {
         // Set initial (protocol owned) liquidity and positions
         // Protocol liquidity makes one position from TickIndex::MIN to TickIndex::MAX
         // We are using the sp_arithmetic sqrt here, which works for u128
-        let liquidity = helpers_128bit::sqrt(tao_reserve as u128 * alpha_reserve as u128) as u64;
+        let liquidity =
+            helpers_128bit::sqrt((tao_reserve as u128).saturating_mul(alpha_reserve as u128))
+                as u64;
         let protocol_account_id = T::ProtocolId::get().into_account_truncating();
 
-        Self::add_liquidity(
+        let _ = Self::add_liquidity(
             netuid,
             &protocol_account_id,
             TickIndex::MIN,
             TickIndex::MAX,
             liquidity,
-            true,
         )?;
 
         Ok(())
@@ -67,14 +71,9 @@ impl<T: Config> Pallet<T> {
     /// - `tick_low`: The lower bound of the price tick range.
     /// - `tick_high`: The upper bound of the price tick range.
     /// - `liquidity`: The amount of liquidity to be added.
-    /// - `protocol`: A boolean flag indicating whether the operation is protocol-managed:
-    ///   - `true` -> Do not use this value outside of this implementation. Liquidity is added **without**
-    ///               withdrawing balances.
-    ///   - `false` -> Use this value for all user transactions. Liquidity is added
-    ///               **after withdrawing balances**.
     ///
     /// ### Returns:
-    /// - `Ok(u64)`: The final liquidity amount added.
+    /// - `Ok((u64, u64))`: (tao, alpha) amounts at new position
     /// - `Err(SwapError)`: If the operation fails due to insufficient balance, invalid tick range,
     ///   or other swap-related errors.
     ///
@@ -82,16 +81,15 @@ impl<T: Config> Pallet<T> {
     /// - [`SwapError::InsufficientBalance`] if the account does not have enough balance.
     /// - [`SwapError::InvalidTickRange`] if `tick_low` is greater than or equal to `tick_high`.
     /// - Other [`SwapError`] variants as applicable.
-    fn add_liquidity(
-        netuid: u16,
-        account_id: &<T as frame_system::Config>::AccountId,
+    pub fn add_liquidity(
+        netuid: NetUid,
+        account_id: &T::AccountId,
         tick_low: TickIndex,
         tick_high: TickIndex,
         liquidity: u64,
-        protocol: bool,
-    ) -> Result<(), Error<T>> {
+    ) -> Result<(u64, u64), Error<T>> {
         ensure!(
-            Positions::<T>::get(netuid, account_id).len() <= T::MaxPositions::get() as usize,
+            Self::count_positions(netuid, account_id) <= T::MaxPositions::get() as usize,
             Error::<T>::MaxPositionsExceeded
         );
 
@@ -105,16 +103,23 @@ impl<T: Config> Pallet<T> {
 
         Self::update_liquidity_if_needed(netuid, tick_low, tick_high, liquidity as i128);
 
-        // // New position
-        // let position = Position {
-        //     tick_low,
-        //     tick_high,
-        //     liquidity,
-        //     fees_tao: 0_u64,
-        //     fees_alpha: 0_u64,
-        // };
+        // New position
+        let position = Position {
+            id: PositionId::new(),
+            tick_low,
+            tick_high,
+            liquidity,
+            fees_tao: 0,
+            fees_alpha: 0,
+        };
+
+        let current_price = AlphaSqrtPrice::<T>::get(netuid);
+        let (tao, alpha) = position.to_token_amounts(current_price)?;
 
-        // // If this is a user transaction, withdraw balances and update reserves
+        // If this is a user transaction, withdraw balances and update reserves
+        // TODO this should be returned (tao, alpha) from this function to prevent
+        // mutation of outside storage - the logic should be passed to the user of
+        // pallet_subtensor_swap_interface
         // if !protocol {
         //     let current_price = self.state_ops.get_alpha_sqrt_price();
         //     let (tao, alpha) = position.to_token_amounts(current_price)?;
@@ -127,12 +132,11 @@ impl<T: Config> Pallet<T> {
         //     self.state_ops.set_alpha_reserve(new_alpha_reserve);
         // }
 
-        // // Create a new user position
-        // self.state_ops.create_position(account_id, position);
+        Positions::<T>::insert(&(netuid, account_id, position.id), position);
 
-        // SwapV3Initialized::<T>::set(netuid, true);
+        SwapV3Initialized::<T>::set(netuid, true);
 
-        Ok(())
+        Ok((tao, alpha))
     }
 
     /// Adds or updates liquidity at a specific tick index for a subnet
@@ -141,7 +145,7 @@ impl<T: Config> Pallet<T> {
     /// * `netuid` - The subnet ID
     /// * `tick_index` - The tick index to add liquidity to
     /// * `liquidity` - The amount of liquidity to add
-    fn add_liquidity_at_index(netuid: u16, tick_index: TickIndex, liquidity: u64, upper: bool) {
+    fn add_liquidity_at_index(netuid: NetUid, tick_index: TickIndex, liquidity: u64, upper: bool) {
         // Convert liquidity to signed value, negating it for upper bounds
         let net_liquidity_change = if upper {
             -(liquidity as i128)
@@ -165,14 +169,71 @@ impl<T: Config> Pallet<T> {
         });
     }
 
+    /// Remove liquidity and credit balances back to account_id
+    ///
+    /// Account ID and Position ID identify position in the storage map
+    pub fn remove_liquidity(
+        netuid: NetUid,
+        account_id: &T::AccountId,
+        position_id: PositionId,
+    ) -> Result<RemoveLiquidityResult, Error<T>> {
+        let Some(mut pos) = Positions::<T>::get((netuid, account_id, position_id)) else {
+            return Err(Error::<T>::LiquidityNotFound);
+        };
+        let current_tick_index = CurrentTickIndex::<T>::get(netuid);
+
+        // Collect fees and get tao and alpha amounts
+		// let (fee_tao, fee_alpha) = self.collect_fees(&mut pos);
+        //     let current_price: SqrtPrice = self.state_ops.get_alpha_sqrt_price();
+        //     let (tao, alpha) = pos.to_token_amounts(current_price)?;
+
+        //     // Update liquidity at position ticks
+        //     self.remove_liquidity_at_index(pos.tick_low, pos.liquidity, false);
+        //     self.remove_liquidity_at_index(pos.tick_high, pos.liquidity, true);
+
+        //     // Update current tick liquidity
+        //     if (pos.tick_low <= current_tick_index) && (current_tick_index <= pos.tick_high) {
+        //         let new_current_liquidity = self
+        //             .state_ops
+        //             .get_current_liquidity()
+        //             .saturating_sub(pos.liquidity);
+        //         self.state_ops.set_current_liquidity(new_current_liquidity);
+        //     }
+
+        //     // Remove user position
+        //     self.state_ops.remove_position(account_id, position_id);
+
+        //     // Deposit balances
+        //     self.state_ops.deposit_balances(account_id, tao, alpha);
+
+        //     // Update reserves
+        //     let new_tao_reserve = self.state_ops.get_tao_reserve().saturating_sub(tao);
+        //     self.state_ops.set_tao_reserve(new_tao_reserve);
+        //     let new_alpha_reserve = self.state_ops.get_alpha_reserve().saturating_sub(alpha);
+        //     self.state_ops.set_alpha_reserve(new_alpha_reserve);
+
+        //     // TODO: Clear with R&D
+        //     // Update current price (why?)
+        //     // self.state_ops.set_alpha_sqrt_price(sqrt_price);
+
+        //     // Return Ok result
+        //     Ok(RemoveLiquidityResult {
+        //         tao,
+        //         alpha,
+        //         fee_tao,
+        //         fee_alpha,
+        //     })
+        todo!()
+    }
+
     /// Gets the current tick index for a subnet, ensuring it's within valid bounds
-    fn bounded_current_tick_index(netuid: u16) -> TickIndex {
+    fn bounded_current_tick_index(netuid: NetUid) -> TickIndex {
         let current_price = AlphaSqrtPrice::<T>::get(netuid);
         TickIndex::from_sqrt_price_bounded(current_price)
     }
 
     /// Clamps the subnet's sqrt price when tick index is outside of valid bounds
-    fn clamp_sqrt_price(netuid: u16, tick_index: TickIndex) {
+    fn clamp_sqrt_price(netuid: NetUid, tick_index: TickIndex) {
         if tick_index >= TickIndex::MAX || tick_index <= TickIndex::MIN {
             let corrected_price = tick_index.to_sqrt_price_bounded();
             AlphaSqrtPrice::<T>::set(netuid, corrected_price);
@@ -186,7 +247,7 @@ impl<T: Config> Pallet<T> {
     /// liquidity parameter. It uses i128 to safely handle values up to u64::MAX in both positive
     /// and negative directions.
     fn update_liquidity_if_needed(
-        netuid: u16,
+        netuid: NetUid,
         tick_low: TickIndex,
         tick_high: TickIndex,
         liquidity: i128,
@@ -204,4 +265,16 @@ impl<T: Config> Pallet<T> {
             });
         }
     }
+
+    /// Returns the number of positions for an account in a specific subnet
+    ///
+    /// # Arguments
+    /// * `netuid` - The subnet ID
+    /// * `account_id` - The account ID
+    ///
+    /// # Returns
+    /// The number of positions that the account has in the specified subnet
+    fn count_positions(netuid: NetUid, account_id: &T::AccountId) -> usize {
+        Positions::<T>::iter_prefix_values((netuid, account_id.clone())).count()
+    }
 }
diff --git a/pallets/swap/src/pallet/mod.rs b/pallets/swap/src/pallet/mod.rs
index 4ed26d7966..ad54f366dc 100644
--- a/pallets/swap/src/pallet/mod.rs
+++ b/pallets/swap/src/pallet/mod.rs
@@ -3,13 +3,18 @@ use frame_system::pallet_prelude::*;
 use pallet_subtensor_swap_interface::LiquidityDataProvider;
 use substrate_fixed::types::U64F64;
 
-use crate::Position;
-use crate::tick::{Tick, TickIndex};
+use crate::{
+    NetUid, Position, PositionId,
+    tick::{Tick, TickIndex},
+};
+
+pub use pallet::*;
 
 mod impls;
 
+#[allow(clippy::module_inception)]
 #[frame_support::pallet]
-pub mod pallet {
+mod pallet {
     use super::*;
 
     #[pallet::pallet]
@@ -45,48 +50,48 @@ pub mod pallet {
     ///
     /// For example, 0.3% is approximately 196
     #[pallet::storage]
-    #[pallet::getter(fn fee_rate)]
-    pub type FeeRate<T> = StorageMap<_, Twox64Concat, u16, u16, ValueQuery>;
+    pub type FeeRate<T> = StorageMap<_, Twox64Concat, NetUid, u16, ValueQuery>;
 
     /// Storage for all ticks, using subnet ID as the primary key and tick index as the secondary key
     #[pallet::storage]
-    #[pallet::getter(fn ticks)]
-    pub type Ticks<T> = StorageDoubleMap<_, Twox64Concat, u16, Twox64Concat, TickIndex, Tick>;
+    pub type Ticks<T> = StorageDoubleMap<_, Twox64Concat, NetUid, Twox64Concat, TickIndex, Tick>;
 
     /// Storage to determine whether swap V3 was initialized for a specific subnet.
     #[pallet::storage]
-    #[pallet::getter(fn swap_v3_initialized)]
-    pub type SwapV3Initialized<T> = StorageMap<_, Twox64Concat, u16, bool, ValueQuery>;
+    pub type SwapV3Initialized<T> = StorageMap<_, Twox64Concat, NetUid, bool, ValueQuery>;
 
     /// Storage for the square root price of Alpha token for each subnet.
     #[pallet::storage]
-    #[pallet::getter(fn alpha_sqrt_price)]
-    pub type AlphaSqrtPrice<T> = StorageMap<_, Twox64Concat, u16, U64F64, ValueQuery>;
+    pub type AlphaSqrtPrice<T> = StorageMap<_, Twox64Concat, NetUid, U64F64, ValueQuery>;
 
     /// Storage for the current liquidity amount for each subnet.
     #[pallet::storage]
-    #[pallet::getter(fn current_liquidity)]
-    pub type CurrentLiquidity<T> = StorageMap<_, Twox64Concat, u16, u64, ValueQuery>;
+    pub type CurrentLiquidity<T> = StorageMap<_, Twox64Concat, NetUid, u64, ValueQuery>;
+
+    /// Storage for the current tick index for each subnet.
+    #[pallet::storage]
+    pub type CurrentTickIndex<T> = StorageMap<_, Twox64Concat, NetUid, TickIndex>;
 
     /// Storage for user positions, using subnet ID and account ID as keys
     /// The value is a bounded vector of Position structs with details about the liquidity positions
     #[pallet::storage]
     #[pallet::getter(fn positions)]
-    pub type Positions<T: Config> = StorageDoubleMap<
+    pub type Positions<T: Config> = StorageNMap<
         _,
-        Twox64Concat,
-        u16,
-        Twox64Concat,
-        T::AccountId,
-        BoundedVec<Position, T::MaxPositions>,
-        ValueQuery,
+        (
+            NMapKey<Twox64Concat, NetUid>,       // Subnet ID
+            NMapKey<Twox64Concat, T::AccountId>, // Account ID
+            NMapKey<Twox64Concat, PositionId>,   // Position ID
+        ),
+        Position,
+        OptionQuery,
     >;
 
     #[pallet::event]
     #[pallet::generate_deposit(pub(super) fn deposit_event)]
     pub enum Event<T: Config> {
         /// Event emitted when the fee rate has been updated for a subnet
-        FeeRateSet { netuid: u16, rate: u16 },
+        FeeRateSet { netuid: NetUid, rate: u16 },
     }
 
     #[pallet::error]
@@ -130,6 +135,9 @@ pub mod pallet {
         pub fn set_fee_rate(origin: OriginFor<T>, netuid: u16, rate: u16) -> DispatchResult {
             T::AdminOrigin::ensure_origin(origin)?;
 
+            // using u16 for compatibility
+            let netuid = netuid.into();
+
             ensure!(rate <= T::MaxFeeRate::get(), Error::<T>::FeeRateTooHigh);
 
             FeeRate::<T>::insert(netuid, rate);
diff --git a/pallets/swap/src/swap.rs b/pallets/swap/src/swap.rs
new file mode 100644
index 0000000000..e9d72d4d68
--- /dev/null
+++ b/pallets/swap/src/swap.rs
@@ -0,0 +1,2247 @@
+use core::marker::PhantomData;
+use core::ops::Neg;
+
+use pallet_subtensor_swap_interface::OrderType;
+use safe_math::*;
+use substrate_fixed::types::U64F64;
+
+use crate::{
+    Position, RemoveLiquidityResult, SqrtPrice, SwapError,
+    tick::{Layer, Tick, TickIndex, TickIndexBitmap},
+};
+
+#[derive(Debug, PartialEq)]
+pub struct SwapResult {
+    amount_paid_out: u64,
+    refund: u64,
+}
+
+pub enum SwapStepAction {
+    Crossing,
+    StopOn,
+    StopIn,
+}
+
+#[derive(Debug, PartialEq)]
+struct SwapStepResult {
+    amount_to_take: u64,
+    delta_out: u64,
+}
+
+/// This trait implementation depends on Runtime and it needs to be implemented
+/// in the pallet to be able to work with chain state and per subnet. All subnet
+/// swaps are independent and hence netuid is abstracted away from swap implementation.
+///
+pub trait SwapDataOperations<AccountIdType> {
+    /// Tells if v3 swap is initialized in the state. v2 only provides base and quote
+    /// reserves, while v3 also stores ticks and positions, which need to be initialized
+    /// at the first pool creation.
+    fn is_v3_initialized(&self) -> bool;
+    fn set_v3_initialized(&mut self);
+    /// Returns u16::MAX normalized fee rate. For example, 0.3% is approximately 196.
+    fn get_fee_rate(&self) -> u16;
+    /// Minimum liquidity that is safe for rounding and integer math.
+    fn get_minimum_liquidity(&self) -> u64;
+    fn get_tick_by_index(&self, tick_index: TickIndex) -> Option<Tick>;
+    fn insert_tick_by_index(&mut self, tick_index: TickIndex, tick: Tick);
+    fn remove_tick_by_index(&mut self, tick_index: TickIndex);
+    /// Minimum sqrt price across all active ticks
+    fn get_min_sqrt_price(&self) -> SqrtPrice;
+    /// Maximum sqrt price across all active ticks
+    fn get_max_sqrt_price(&self) -> SqrtPrice;
+    fn get_tao_reserve(&self) -> u64;
+    fn set_tao_reserve(&mut self, tao: u64) -> u64;
+    fn get_alpha_reserve(&self) -> u64;
+    fn set_alpha_reserve(&mut self, alpha: u64) -> u64;
+    fn get_alpha_sqrt_price(&self) -> SqrtPrice;
+    fn set_alpha_sqrt_price(&mut self, sqrt_price: SqrtPrice);
+
+    // Getters/setters for global accrued fees in alpha and tao per subnet
+    fn get_fee_global_tao(&self) -> U64F64;
+    fn set_fee_global_tao(&mut self, fee: U64F64);
+    fn get_fee_global_alpha(&self) -> U64F64;
+    fn set_fee_global_alpha(&mut self, fee: U64F64);
+
+    /// Get current tick liquidity
+    fn get_current_liquidity(&self) -> u64;
+    /// Set current tick liquidity
+    fn set_current_liquidity(&mut self, liquidity: u64);
+
+    // User account operations
+    fn get_protocol_account_id(&self) -> AccountIdType;
+    fn get_max_positions(&self) -> u16;
+    fn withdraw_balances(
+        &mut self,
+        account_id: &AccountIdType,
+        tao: u64,
+        alpha: u64,
+    ) -> Result<(u64, u64), SwapError>;
+    fn deposit_balances(&mut self, account_id: &AccountIdType, tao: u64, alpha: u64);
+    fn get_position_count(&self, account_id: &AccountIdType) -> u16;
+    fn get_position(&self, account_id: &AccountIdType, position_id: u16) -> Option<Position>;
+    fn create_position(&mut self, account_id: &AccountIdType, positions: Position) -> u16;
+    fn update_position(
+        &mut self,
+        account_id: &AccountIdType,
+        position_id: u16,
+        positions: Position,
+    );
+    fn remove_position(&mut self, account_id: &AccountIdType, position_id: u16);
+
+    // Tick index storage
+    // Storage is organized in 3 layers:
+    //    Layer 0 consists of one u128 that stores 55 bits. Each bit indicates which layer 1 words are active.
+    //    Layer 1 consists of up to 55 u128's that store 6932 bits for the layer 2 words.
+    //    Layer 2 consists of up to 6932 u128's that store 887272 bits for active/inactive ticks.
+    fn get_layer0_word(&self, word_index: u32) -> u128;
+    fn get_layer1_word(&self, word_index: u32) -> u128;
+    fn get_layer2_word(&self, word_index: u32) -> u128;
+    fn set_layer0_word(&mut self, word_index: u32, word: u128);
+    fn set_layer1_word(&mut self, word_index: u32, word: u128);
+    fn set_layer2_word(&mut self, word_index: u32, word: u128);
+}
+
+/// All main swapping logic abstracted from Runtime implementation is concentrated
+/// in this struct
+///
+#[derive(Debug)]
+pub struct Swap<AccountIdType, Ops>
+where
+    AccountIdType: Eq,
+    Ops: SwapDataOperations<AccountIdType>,
+{
+    pub(crate) state_ops: Ops,
+    phantom_key: PhantomData<AccountIdType>,
+}
+
+impl<AccountIdType, Ops> Swap<AccountIdType, Ops>
+where
+    AccountIdType: Eq,
+    Ops: SwapDataOperations<AccountIdType>,
+{
+    pub fn new(mut ops: Ops) -> Self {
+        todo!("transfered to Pallet::maybe_initialize_v3")
+    }
+
+    /// Auxiliary method to calculate Alpha amount to match given TAO
+    /// amount at the current price for liquidity.
+    ///
+    /// Returns (Alpha, Liquidity) tuple
+    ///
+    pub fn get_tao_based_liquidity(&self, _tao: u64) -> (u64, u64) {
+        // let current_price = self.state_ops.get_alpha_sqrt_price();
+        todo!()
+    }
+
+    /// Auxiliary method to calculate TAO amount to match given Alpha
+    /// amount at the current price for liquidity.
+    ///
+    /// Returns (TAO, Liquidity) tuple
+    ///
+    pub fn get_alpha_based_liquidity(&self, _alpha: u64) -> (u64, u64) {
+        // let current_price = self.state_ops.get_alpha_sqrt_price();
+
+        todo!()
+    }
+
+    /// Add liquidity at tick index. Creates new tick if it doesn't exist
+    ///
+    fn add_liquidity_at_index(&mut self, tick_index: TickIndex, liquidity: u64, upper: bool) {
+        todo!("tranfered to Pallet, but still needed here for code to compile")
+    }
+
+    /// Remove liquidity at tick index.
+    ///
+    fn remove_liquidity_at_index(&mut self, tick_index: TickIndex, liquidity: u64, upper: bool) {
+        // Calculate net liquidity addition
+        let net_reduction = if upper {
+            (liquidity as i128).neg()
+        } else {
+            liquidity as i128
+        };
+
+        // Find tick by index
+        if let Some(mut tick) = self.state_ops.get_tick_by_index(tick_index) {
+            tick.liquidity_net = tick.liquidity_net.saturating_sub(net_reduction);
+            tick.liquidity_gross = tick.liquidity_gross.saturating_sub(liquidity);
+
+            // If any liquidity is left at the tick, update it, otherwise remove
+            if tick.liquidity_gross == 0 {
+                self.state_ops.remove_tick_by_index(tick_index);
+            } else {
+                self.state_ops.insert_tick_by_index(tick_index, tick);
+            }
+        };
+    }
+
+    /// Adds liquidity to the specified price range.
+    ///
+    /// This function allows an account to provide liquidity to a given range of price ticks.
+    /// The amount of liquidity to be added can be determined using the functions
+    /// [`get_tao_based_liquidity`] and [`get_alpha_based_liquidity`], which compute the
+    /// required liquidity based on TAO and Alpha balances for the current price tick.
+    ///
+    /// ### Behavior:
+    /// - If the `protocol` flag is **not set** (`false`), the function will attempt to
+    ///   **withdraw balances** from the account using `state_ops.withdraw_balances()`.
+    /// - If the `protocol` flag is **set** (`true`), the liquidity is added without modifying balances.
+    ///
+    /// ### Parameters:
+    /// - `account_id`: A reference to the account that is providing liquidity.
+    /// - `tick_low`: The lower bound of the price tick range.
+    /// - `tick_high`: The upper bound of the price tick range.
+    /// - `liquidity`: The amount of liquidity to be added.
+    /// - `protocol`: A boolean flag indicating whether the operation is protocol-managed:
+    ///   - `true` -> Do not use this value outside of this implementation. Liquidity is added **without**
+    ///               withdrawing balances.
+    ///   - `false` -> Use this value for all user transactions. Liquidity is added
+    ///               **after withdrawing balances**.
+    ///
+    /// ### Returns:
+    /// - `Ok(u64)`: The final liquidity amount added.
+    /// - `Err(SwapError)`: If the operation fails due to insufficient balance, invalid tick range,
+    ///   or other swap-related errors.
+    ///
+    /// ### Errors:
+    /// - [`SwapError::InsufficientBalance`] if the account does not have enough balance.
+    /// - [`SwapError::InvalidTickRange`] if `tick_low` is greater than or equal to `tick_high`.
+    /// - Other [`SwapError`] variants as applicable.
+    ///
+    pub fn add_liquidity(
+        &mut self,
+        account_id: &AccountIdType,
+        tick_low: TickIndex,
+        tick_high: TickIndex,
+        liquidity: u64,
+        protocol: bool,
+    ) -> Result<(), SwapError> {
+        todo!("transfered to Pallet::add_liquidity")
+    }
+
+    /// Remove liquidity and credit balances back to account_id
+    ///
+    /// Account ID and Position ID identify position in the storage map
+    ///
+    pub fn remove_liquidity(
+        &mut self,
+        account_id: &AccountIdType,
+        position_id: u16,
+    ) -> Result<RemoveLiquidityResult, SwapError> {
+        todo!("moved to Pallet::remove_liquidity")
+    }
+
+    /// Perform a swap
+    ///
+    /// Returns a tuple (amount, refund), where amount is the resulting paid out amount
+    ///
+    pub fn swap(
+        &mut self,
+        order_type: &OrderType,
+        amount: u64,
+        sqrt_price_limit: SqrtPrice,
+    ) -> Result<SwapResult, SwapError> {
+        let one = U64F64::saturating_from_num(1);
+
+        // Here we store the remaining amount that needs to be exchanged
+        // If order_type is Buy, then it expresses Tao amount, if it is Sell,
+        // then amount_remaining is Alpha.
+        let mut amount_remaining = amount;
+        let mut amount_paid_out: u64 = 0;
+        let mut refund: u64 = 0;
+
+        // A bit of fool proofing
+        let mut iteration_counter: u16 = 0;
+        let iter_limit: u16 = 1000;
+
+        // Swap one tick at a time until we reach one of the following conditions:
+        //   - Swap all provided amount
+        //   - Reach limit price
+        //   - Use up all liquidity (up to safe minimum)
+        while amount_remaining > 0 {
+            let sqrt_price_edge = self.get_sqrt_price_edge(order_type);
+            let possible_delta_in =
+                amount_remaining.saturating_sub(self.get_fee_amount(amount_remaining));
+            let sqrt_price_target = self.get_sqrt_price_target(order_type, possible_delta_in);
+            let target_quantity = self.get_target_quantity(order_type, possible_delta_in);
+            let edge_quantity = U64F64::saturating_from_num(1).safe_div(sqrt_price_edge.into());
+            let lim_quantity = one
+                .safe_div(self.state_ops.get_min_sqrt_price())
+                .saturating_add(one.safe_div(sqrt_price_limit.into()));
+
+            let action: SwapStepAction;
+            let delta_in;
+            let final_price;
+            let mut stop_and_refund = false;
+
+            if target_quantity < edge_quantity {
+                if target_quantity <= lim_quantity {
+                    // stop_in at price target
+                    action = SwapStepAction::StopIn;
+                    delta_in = possible_delta_in;
+                    final_price = sqrt_price_target;
+                } else {
+                    // stop_in at price limit
+                    action = SwapStepAction::StopIn;
+                    delta_in = self.get_delta_in(order_type, sqrt_price_limit);
+                    final_price = sqrt_price_limit;
+                    stop_and_refund = true;
+                }
+            } else if target_quantity > edge_quantity {
+                if edge_quantity < lim_quantity {
+                    // do crossing at price edge
+                    action = SwapStepAction::Crossing;
+                    delta_in = self.get_delta_in(order_type, sqrt_price_edge);
+                    final_price = sqrt_price_edge;
+                } else if edge_quantity > lim_quantity {
+                    // stop_in at price limit
+                    action = SwapStepAction::StopIn;
+                    delta_in = self.get_delta_in(order_type, sqrt_price_limit);
+                    final_price = sqrt_price_limit;
+                    stop_and_refund = true;
+                } else {
+                    // stop_on at price limit
+                    action = SwapStepAction::StopOn;
+                    delta_in = self.get_delta_in(order_type, sqrt_price_edge);
+                    final_price = sqrt_price_edge;
+                    stop_and_refund = true;
+                }
+            } else {
+                // targetQuantity = edgeQuantity
+                if target_quantity <= lim_quantity {
+                    // stop_on at price edge
+                    delta_in = self.get_delta_in(order_type, sqrt_price_edge);
+                    final_price = sqrt_price_edge;
+                    action = if delta_in > 0 {
+                        SwapStepAction::StopOn
+                    } else {
+                        SwapStepAction::Crossing
+                    };
+                } else {
+                    // targetQuantity > limQuantity
+                    // stop_in at price lim
+                    action = SwapStepAction::StopIn;
+                    delta_in = self.get_delta_in(order_type, sqrt_price_limit);
+                    final_price = sqrt_price_limit;
+                    stop_and_refund = true;
+                }
+            }
+
+            let swap_result = self.swap_step(order_type, delta_in, final_price, action)?;
+            amount_remaining = amount_remaining.saturating_sub(swap_result.amount_to_take);
+            amount_paid_out = amount_paid_out.saturating_add(swap_result.delta_out);
+
+            if stop_and_refund {
+                refund = amount_remaining;
+                amount_remaining = 0;
+            }
+
+            iteration_counter = iteration_counter.saturating_add(1);
+            if iteration_counter > iter_limit {
+                return Err(SwapError::TooManySwapSteps);
+            }
+        }
+
+        Ok(SwapResult {
+            amount_paid_out,
+            refund,
+        })
+    }
+
+    fn get_current_tick_index(&mut self) -> TickIndex {
+        let current_price = self.state_ops.get_alpha_sqrt_price();
+        let maybe_current_tick_index = TickIndex::try_from_sqrt_price(current_price);
+        if let Ok(index) = maybe_current_tick_index {
+            index
+        } else {
+            // Current price is out of allow the min-max range, and it should be corrected to
+            // maintain the range.
+            let max_price = TickIndex::MAX
+                .try_to_sqrt_price()
+                .unwrap_or(SqrtPrice::saturating_from_num(1000));
+            let min_price = TickIndex::MIN
+                .try_to_sqrt_price()
+                .unwrap_or(SqrtPrice::saturating_from_num(0.000001));
+            if current_price > max_price {
+                self.state_ops.set_alpha_sqrt_price(max_price);
+                TickIndex::MAX
+            } else {
+                self.state_ops.set_alpha_sqrt_price(min_price);
+                TickIndex::MIN
+            }
+        }
+    }
+
+    /// Process a single step of a swap
+    ///
+    fn swap_step(
+        &mut self,
+        order_type: &OrderType,
+        delta_in: u64,
+        sqrt_price_final: SqrtPrice,
+        action: SwapStepAction,
+    ) -> Result<SwapStepResult, SwapError> {
+        // amount_swapped = delta_in / (1 - self.fee_size)
+        let fee_rate = U64F64::saturating_from_num(self.state_ops.get_fee_rate());
+        let u16_max = U64F64::saturating_from_num(u16::MAX);
+        let delta_fixed = U64F64::saturating_from_num(delta_in);
+        let amount_swapped =
+            delta_fixed.saturating_mul(u16_max.safe_div(u16_max.saturating_sub(fee_rate)));
+
+        // Hold the fees
+        let fee = self.get_fee_amount(amount_swapped.saturating_to_num::<u64>());
+        self.add_fees(order_type, fee);
+        let delta_out = self.convert_deltas(order_type, delta_in);
+
+        self.update_reserves(order_type, delta_in, delta_out);
+
+        // Get current tick
+        let current_tick_index = self.get_current_tick_index();
+
+        match action {
+            SwapStepAction::Crossing => {
+                let maybe_tick = match order_type {
+                    OrderType::Sell => self.find_closest_lower_active_tick(current_tick_index),
+                    OrderType::Buy => self.find_closest_higher_active_tick(current_tick_index),
+                };
+                if let Some(mut tick) = maybe_tick {
+                    tick.fees_out_tao = self
+                        .state_ops
+                        .get_fee_global_tao()
+                        .saturating_sub(tick.fees_out_tao);
+                    tick.fees_out_alpha = self
+                        .state_ops
+                        .get_fee_global_alpha()
+                        .saturating_sub(tick.fees_out_alpha);
+                    self.update_liquidity_at_crossing(order_type)?;
+                    self.state_ops
+                        .insert_tick_by_index(current_tick_index, tick);
+                } else {
+                    return Err(SwapError::InsufficientLiquidity);
+                }
+            }
+            SwapStepAction::StopOn => match order_type {
+                OrderType::Sell => {}
+                OrderType::Buy => {
+                    self.update_liquidity_at_crossing(order_type)?;
+                    let maybe_tick = self.find_closest_higher_active_tick(current_tick_index);
+
+                    if let Some(mut tick) = maybe_tick {
+                        tick.fees_out_tao = self
+                            .state_ops
+                            .get_fee_global_tao()
+                            .saturating_sub(tick.fees_out_tao);
+                        tick.fees_out_alpha = self
+                            .state_ops
+                            .get_fee_global_alpha()
+                            .saturating_sub(tick.fees_out_alpha);
+                        self.state_ops
+                            .insert_tick_by_index(current_tick_index, tick);
+                    } else {
+                        return Err(SwapError::InsufficientLiquidity);
+                    }
+                }
+            },
+            SwapStepAction::StopIn => {}
+        }
+
+        // Update current price, which effectively updates current tick too
+        self.state_ops.set_alpha_sqrt_price(sqrt_price_final);
+
+        Ok(SwapStepResult {
+            amount_to_take: amount_swapped.saturating_to_num::<u64>(),
+            delta_out,
+        })
+    }
+
+    /// Get the square root price at the current tick edge for the given direction (order type)
+    /// If order type is Buy, then price edge is the high tick bound price, otherwise it is
+    /// the low tick bound price.
+    ///
+    /// If anything is wrong with tick math and it returns Err, we just abort the deal, i.e.
+    /// return the edge that is impossible to execute
+    ///
+    fn get_sqrt_price_edge(&self, order_type: &OrderType) -> SqrtPrice {
+        let fallback_price_edge_value = (match order_type {
+            OrderType::Buy => TickIndex::MIN.try_to_sqrt_price(),
+            OrderType::Sell => TickIndex::MAX.try_to_sqrt_price(),
+        })
+        .unwrap_or(SqrtPrice::saturating_from_num(0));
+
+        let current_price = self.state_ops.get_alpha_sqrt_price();
+        let maybe_current_tick_index = TickIndex::try_from_sqrt_price(current_price);
+
+        if let Ok(current_tick_index) = maybe_current_tick_index {
+            match order_type {
+                OrderType::Buy => {
+                    TickIndex::new_unchecked(current_tick_index.get().saturating_add(1))
+                }
+                OrderType::Sell => current_tick_index,
+            }
+            .try_to_sqrt_price()
+            .unwrap_or(fallback_price_edge_value)
+        } else {
+            fallback_price_edge_value
+        }
+    }
+
+    /// Calculate fee amount
+    ///
+    /// Fee is provided by state ops as u16-normalized value.
+    ///
+    fn get_fee_amount(&self, amount: u64) -> u64 {
+        let fee_rate = U64F64::saturating_from_num(self.state_ops.get_fee_rate())
+            .safe_div(U64F64::saturating_from_num(u16::MAX));
+        U64F64::saturating_from_num(amount)
+            .saturating_mul(fee_rate)
+            .saturating_to_num::<u64>()
+    }
+
+    /// Here we subtract minimum safe liquidity from current liquidity to stay in the
+    /// safe range
+    ///
+    fn get_safe_current_liquidity(&self) -> U64F64 {
+        U64F64::saturating_from_num(
+            self.state_ops
+                .get_current_liquidity()
+                .saturating_sub(self.state_ops.get_minimum_liquidity()),
+        )
+    }
+
+    /// Get the target square root price based on the input amount
+    ///
+    fn get_sqrt_price_target(&self, order_type: &OrderType, delta_in: u64) -> SqrtPrice {
+        let liquidity_curr = self.get_safe_current_liquidity();
+        let sqrt_price_curr = self.state_ops.get_alpha_sqrt_price().into();
+        let delta_fixed = U64F64::saturating_from_num(delta_in);
+        let one = U64F64::saturating_from_num(1);
+
+        if liquidity_curr > 0 {
+            match order_type {
+                OrderType::Buy => one.safe_div(
+                    delta_fixed
+                        .safe_div(liquidity_curr)
+                        .saturating_add(one.safe_div(sqrt_price_curr)),
+                ),
+                OrderType::Sell => delta_fixed
+                    .safe_div(liquidity_curr)
+                    .saturating_add(sqrt_price_curr),
+            }
+        } else {
+            // No liquidity means price should remain current
+            sqrt_price_curr
+        }
+    }
+
+    /// Get the target quantity, which is
+    ///     `1 / (target square root price)` in case of sell order
+    ///     `target square root price` in case of buy order
+    ///
+    /// ...based on the input amount, current liquidity, and current alpha price
+    ///
+    fn get_target_quantity(&self, order_type: &OrderType, delta_in: u64) -> SqrtPrice {
+        let liquidity_curr = self.get_safe_current_liquidity();
+        let sqrt_price_curr = self.state_ops.get_alpha_sqrt_price().into();
+        let delta_fixed = U64F64::saturating_from_num(delta_in);
+        let one = U64F64::saturating_from_num(1);
+
+        if liquidity_curr > 0 {
+            match order_type {
+                OrderType::Buy => delta_fixed
+                    .safe_div(liquidity_curr)
+                    .saturating_add(sqrt_price_curr)
+                    .into(),
+                OrderType::Sell => delta_fixed
+                    .safe_div(liquidity_curr)
+                    .saturating_add(one.safe_div(sqrt_price_curr))
+                    .into(),
+            }
+        } else {
+            // No liquidity means zero
+            SqrtPrice::saturating_from_num(0)
+        }
+    }
+
+    /// Get the input amount needed to reach the target price
+    ///
+    fn get_delta_in(&self, order_type: &OrderType, sqrt_price_target: SqrtPrice) -> u64 {
+        let liquidity_curr = self.get_safe_current_liquidity();
+        let one = U64F64::saturating_from_num(1);
+        let sqrt_price_curr = self.state_ops.get_alpha_sqrt_price().into();
+
+        (match order_type {
+            OrderType::Sell => liquidity_curr.saturating_mul(
+                one.safe_div(sqrt_price_target.into())
+                    .saturating_sub(one.safe_div(sqrt_price_curr)),
+            ),
+            OrderType::Buy => {
+                liquidity_curr.saturating_mul(sqrt_price_target.saturating_sub(sqrt_price_curr))
+            }
+        })
+        .saturating_to_num::<u64>()
+    }
+
+    /// Add fees to the global fee counters
+    fn add_fees(&mut self, order_type: &OrderType, fee: u64) {
+        let liquidity_curr = self.get_safe_current_liquidity();
+        if liquidity_curr > 0 {
+            let fee_global_tao: U64F64 = self.state_ops.get_fee_global_tao();
+            let fee_global_alpha: U64F64 = self.state_ops.get_fee_global_alpha();
+            let fee_fixed: U64F64 = U64F64::saturating_from_num(fee);
+
+            match order_type {
+                OrderType::Sell => {
+                    self.state_ops.set_fee_global_tao(
+                        fee_global_tao.saturating_add(fee_fixed.safe_div(liquidity_curr)),
+                    );
+                }
+                OrderType::Buy => {
+                    self.state_ops.set_fee_global_alpha(
+                        fee_global_alpha.saturating_add(fee_fixed.safe_div(liquidity_curr)),
+                    );
+                }
+            }
+        }
+    }
+
+    /// Convert input amount (delta_in) to output amount (delta_out)
+    ///
+    /// This is the core method of uniswap V3 that tells how much
+    /// output token is given for an amount of input token within one
+    /// price tick.
+    ///
+    fn convert_deltas(&self, order_type: &OrderType, delta_in: u64) -> u64 {
+        let liquidity_curr = SqrtPrice::saturating_from_num(self.state_ops.get_current_liquidity());
+        let sqrt_price_curr = self.state_ops.get_alpha_sqrt_price();
+        let delta_fixed = SqrtPrice::saturating_from_num(delta_in);
+
+        // TODO: Implement in safe and non-overflowing math
+        // Intentionally using unsafe math here to trigger CI
+
+        // // Prevent overflows:
+        // // If liquidity or delta are too large, reduce their precision and
+        // // save their factor for final correction. Price can take full U64F64
+        // // range, and it will not overflow u128 divisions or multiplications.
+        // let mut liquidity_factor: u64 = 1;
+        // if liquidity_curr > u32::MAX as u64 {
+        //     liquidity_factor = u32::MAX as u64;
+        //     liquidity_curr = liquidity_curr.safe_div(liquidity_factor);
+        // }
+        // let mut delta = delta_in as u64;
+        // let mut delta_factor: u64 = 1;
+        // if delta > u32::MAX as u64 {
+        //     delta_factor = u32::MAX as u64;
+        //     delta = delta.safe_div(delta_factor);
+        // }
+
+        // // This product does not overflow because we limit both
+        // // multipliers by u32::MAX (despite the u64 type)
+        // let delta_liquidity = delta.saturating_mul(liquidity);
+
+        // // This is product of delta_in * liquidity_curr * sqrt_price_curr
+        // let delta_liquidity_price: u128 =
+        //     Self::mul_u64_u64f64(delta_liquidity, sqrt_price_curr.into());
+
+        if delta_in > 0 {
+            (match order_type {
+                OrderType::Sell => {
+                    liquidity_curr * sqrt_price_curr * delta_fixed
+                        / (liquidity_curr / sqrt_price_curr + delta_fixed)
+                }
+                OrderType::Buy => {
+                    liquidity_curr / sqrt_price_curr * delta_fixed
+                        / (liquidity_curr * sqrt_price_curr + delta_fixed)
+                }
+            })
+            .to_num::<u64>()
+        } else {
+            0
+        }
+    }
+
+    /// Multiplies a `u64` by a `U64F64` and returns a `u128` result without overflow.
+    // pub fn mul_u64_u64f64(a: u64, b: U64F64) -> u128 {
+    //     // Multiply a by integer part of b in integer math.
+    //     // Result doesn't overflow u128 because both multipliers are 64 bit
+    //     let int_b: u64 = b.saturating_to_num::<u64>();
+    //     let high = (a as u128).saturating_mul(int_b as u128);
+
+    //     // Multiply a by fractional part of b using U64F64
+    //     let frac_b = b.saturating_sub(U64F64::saturating_from_num(int_b));
+    //     let low = U64F64::saturating_from_num(a).saturating_mul(frac_b);
+
+    //     // The only possible overflow (that is cut off by saturating math)
+    //     // is when a is u64::MAX, int_b is u64::MAX, and frac_b is non-zero,
+    //     // which is negligible error if we saturate and return u128::MAX
+    //     high.saturating_add(low).saturating_to_num::<u128>()
+    // }
+
+    /// Update token reserves after a swap
+    ///
+    fn update_reserves(&mut self, order_type: &OrderType, amount_in: u64, amount_out: u64) {
+        let (new_tao_reserve, new_alpha_reserve) = match order_type {
+            OrderType::Sell => (
+                self.state_ops.get_tao_reserve().saturating_add(amount_in),
+                self.state_ops
+                    .get_alpha_reserve()
+                    .saturating_sub(amount_out),
+            ),
+            OrderType::Buy => (
+                self.state_ops.get_tao_reserve().saturating_sub(amount_in),
+                self.state_ops
+                    .get_alpha_reserve()
+                    .saturating_add(amount_out),
+            ),
+        };
+
+        self.state_ops.set_tao_reserve(new_tao_reserve);
+        self.state_ops.set_alpha_reserve(new_alpha_reserve);
+    }
+
+    fn get_liquidity_update_u64(&self, tick: &Tick) -> u64 {
+        let liquidity_update_abs_i128 = tick.liquidity_net.abs();
+        if liquidity_update_abs_i128 > u64::MAX as i128 {
+            u64::MAX
+        } else {
+            liquidity_update_abs_i128 as u64
+        }
+    }
+
+    /// Update liquidity when crossing a tick
+    ///
+    fn update_liquidity_at_crossing(&mut self, order_type: &OrderType) -> Result<(), SwapError> {
+        let mut liquidity_curr = self.state_ops.get_current_liquidity();
+        let current_tick_index = self.get_current_tick_index();
+        match order_type {
+            OrderType::Sell => {
+                let maybe_tick = self.find_closest_lower_active_tick(current_tick_index);
+                if let Some(tick) = maybe_tick {
+                    let liquidity_update_abs_u64 = self.get_liquidity_update_u64(&tick);
+
+                    liquidity_curr = if tick.liquidity_net >= 0 {
+                        liquidity_curr.saturating_sub(liquidity_update_abs_u64)
+                    } else {
+                        liquidity_curr.saturating_add(liquidity_update_abs_u64)
+                    };
+                } else {
+                    return Err(SwapError::InsufficientLiquidity);
+                }
+            }
+            OrderType::Buy => {
+                let maybe_tick = self.find_closest_higher_active_tick(current_tick_index);
+                if let Some(tick) = maybe_tick {
+                    let liquidity_update_abs_u64 = self.get_liquidity_update_u64(&tick);
+
+                    liquidity_curr = if tick.liquidity_net >= 0 {
+                        liquidity_curr.saturating_add(liquidity_update_abs_u64)
+                    } else {
+                        liquidity_curr.saturating_sub(liquidity_update_abs_u64)
+                    };
+                } else {
+                    return Err(SwapError::InsufficientLiquidity);
+                }
+            }
+        }
+
+        self.state_ops.set_current_liquidity(liquidity_curr);
+        Ok(())
+    }
+
+    /// Collect fees for a position
+    /// Updates the position
+    ///
+    fn collect_fees(&mut self, position: &mut Position) -> (u64, u64) {
+        let mut fee_tao = self.get_fees_in_range(position, true);
+        let mut fee_alpha = self.get_fees_in_range(position, false);
+
+        fee_tao = fee_tao.saturating_sub(position.fees_tao);
+        fee_alpha = fee_alpha.saturating_sub(position.fees_alpha);
+
+        position.fees_tao = fee_tao;
+        position.fees_alpha = fee_alpha;
+
+        fee_tao = position.liquidity.saturating_mul(fee_tao);
+        fee_alpha = position.liquidity.saturating_mul(fee_alpha);
+
+        (fee_tao, fee_alpha)
+    }
+
+    /// Get fees in a position's range
+    ///
+    /// If quote flag is true, Tao is returned, otherwise alpha.
+    ///
+    fn get_fees_in_range(&mut self, position: &Position, quote: bool) -> u64 {
+        let i_lower = position.tick_low;
+        let i_upper = position.tick_high;
+
+        let fee_global = if quote {
+            self.state_ops.get_fee_global_tao()
+        } else {
+            self.state_ops.get_fee_global_alpha()
+        };
+
+        fee_global
+            .saturating_sub(self.get_fees_below(i_lower, quote))
+            .saturating_sub(self.get_fees_above(i_upper, quote))
+            .saturating_to_num::<u64>()
+    }
+
+    /// Get fees above a tick
+    ///
+    fn get_fees_above(&mut self, tick_index: TickIndex, quote: bool) -> U64F64 {
+        let maybe_tick_index = self.find_closest_lower_active_tick_index(tick_index);
+        let current_tick = self.get_current_tick_index();
+
+        if let Some(tick_index) = maybe_tick_index {
+            let tick = self
+                .state_ops
+                .get_tick_by_index(tick_index)
+                .unwrap_or_default();
+            if tick_index <= current_tick {
+                if quote {
+                    self.state_ops
+                        .get_fee_global_tao()
+                        .saturating_sub(tick.fees_out_tao)
+                } else {
+                    self.state_ops
+                        .get_fee_global_alpha()
+                        .saturating_sub(tick.fees_out_alpha)
+                }
+            } else {
+                if quote {
+                    tick.fees_out_tao
+                } else {
+                    tick.fees_out_alpha
+                }
+            }
+        } else {
+            U64F64::saturating_from_num(0)
+        }
+    }
+
+    /// Get fees below a tick
+    fn get_fees_below(&mut self, tick_index: TickIndex, quote: bool) -> U64F64 {
+        let maybe_tick_index = self.find_closest_lower_active_tick_index(tick_index);
+        let current_tick = self.get_current_tick_index();
+
+        if let Some(tick_index) = maybe_tick_index {
+            let tick = self
+                .state_ops
+                .get_tick_by_index(tick_index)
+                .unwrap_or_default();
+            if tick_index <= current_tick {
+                if quote {
+                    tick.fees_out_tao
+                } else {
+                    tick.fees_out_alpha
+                }
+            } else {
+                if quote {
+                    self.state_ops
+                        .get_fee_global_tao()
+                        .saturating_sub(tick.fees_out_tao)
+                } else {
+                    self.state_ops
+                        .get_fee_global_alpha()
+                        .saturating_sub(tick.fees_out_alpha)
+                }
+            }
+        } else {
+            U64F64::saturating_from_num(0)
+        }
+    }
+
+    /// Active tick operations
+    ///
+    /// Data structure:
+    ///    Active ticks are stored in three hash maps, each representing a "Level"
+    ///    Level 0 stores one u128 word, where each bit represents one Level 1 word.
+    ///    Level 1 words each store also a u128 word, where each bit represents one Level 2 word.
+    ///    Level 2 words each store u128 word, where each bit represents a tick.
+    ///
+    /// Insertion: 3 reads, 3 writes
+    /// Search: 3-5 reads
+    /// Deletion: 2 reads, 1-3 writes
+    ///
+
+    // Use TickIndexBitmap::layer_to_index instead
+
+    pub fn insert_active_tick(&mut self, index: TickIndex) {
+        // Check the range
+        if (index < TickIndex::MIN) || (index > TickIndex::MAX) {
+            return;
+        }
+
+        // Convert to bitmap representation
+        let bitmap = TickIndexBitmap::from(index);
+
+        // Update layer words
+        let mut word0_value = self.state_ops.get_layer0_word(bitmap.word_at(Layer::Top));
+        let mut word1_value = self
+            .state_ops
+            .get_layer1_word(bitmap.word_at(Layer::Middle));
+        let mut word2_value = self
+            .state_ops
+            .get_layer2_word(bitmap.word_at(Layer::Bottom));
+
+        // Set bits in each layer
+        word0_value |= bitmap.bit_mask(Layer::Top);
+        word1_value |= bitmap.bit_mask(Layer::Middle);
+        word2_value |= bitmap.bit_mask(Layer::Bottom);
+
+        // Update the storage
+        self.state_ops
+            .set_layer0_word(bitmap.word_at(Layer::Top), word0_value);
+        self.state_ops
+            .set_layer1_word(bitmap.word_at(Layer::Middle), word1_value);
+        self.state_ops
+            .set_layer2_word(bitmap.word_at(Layer::Bottom), word2_value);
+    }
+
+    pub fn remove_active_tick(&mut self, index: TickIndex) {
+        // Check the range
+        if (index < TickIndex::MIN) || (index > TickIndex::MAX) {
+            return;
+        }
+
+        // Convert to bitmap representation
+        let bitmap = TickIndexBitmap::from(index);
+
+        // Update layer words
+        let mut word0_value = self.state_ops.get_layer0_word(bitmap.word_at(Layer::Top));
+        let mut word1_value = self
+            .state_ops
+            .get_layer1_word(bitmap.word_at(Layer::Middle));
+        let mut word2_value = self
+            .state_ops
+            .get_layer2_word(bitmap.word_at(Layer::Bottom));
+
+        // Turn the bit off (& !bit) and save as needed
+        word2_value &= !bitmap.bit_mask(Layer::Bottom);
+        self.state_ops
+            .set_layer2_word(bitmap.word_at(Layer::Bottom), word2_value);
+
+        if word2_value == 0 {
+            word1_value &= !bitmap.bit_mask(Layer::Middle);
+            self.state_ops
+                .set_layer1_word(bitmap.word_at(Layer::Middle), word1_value);
+        }
+
+        if word1_value == 0 {
+            word0_value &= !bitmap.bit_mask(Layer::Top);
+            self.state_ops
+                .set_layer0_word(bitmap.word_at(Layer::Top), word0_value);
+        }
+    }
+
+    pub fn find_closest_active_tick_index(
+        &self,
+        index: TickIndex,
+        lower: bool,
+    ) -> Option<TickIndex> {
+        // Check the range
+        if (index < TickIndex::MIN) || (index > TickIndex::MAX) {
+            return None;
+        }
+
+        // Convert to bitmap representation
+        let bitmap = TickIndexBitmap::from(index);
+        let mut found = false;
+        let mut result: u32 = 0;
+
+        // Layer positions from bitmap
+        let layer0_word = bitmap.word_at(Layer::Top);
+        let layer0_bit = bitmap.bit_at(Layer::Top);
+        let layer1_word = bitmap.word_at(Layer::Middle);
+        let layer1_bit = bitmap.bit_at(Layer::Middle);
+        let layer2_word = bitmap.word_at(Layer::Bottom);
+        let layer2_bit = bitmap.bit_at(Layer::Bottom);
+
+        // Find the closest active bits in layer 0, then 1, then 2
+
+        ///////////////
+        // Level 0
+        let word0 = self.state_ops.get_layer0_word(layer0_word);
+        let closest_bits_l0 =
+            TickIndexBitmap::find_closest_active_bit_candidates(word0, layer0_bit, lower);
+
+        closest_bits_l0.iter().for_each(|&closest_bit_l0| {
+            ///////////////
+            // Level 1
+            let word1_index = TickIndexBitmap::layer_to_index(0, closest_bit_l0);
+
+            // Layer 1 words are different, shift the bit to the word edge
+            let start_from_l1_bit = if word1_index < layer1_word {
+                127
+            } else if word1_index > layer1_word {
+                0
+            } else {
+                layer1_bit
+            };
+            let word1_value = self.state_ops.get_layer1_word(word1_index);
+
+            let closest_bits_l1 = TickIndexBitmap::find_closest_active_bit_candidates(
+                word1_value,
+                start_from_l1_bit,
+                lower,
+            );
+            closest_bits_l1.iter().for_each(|&closest_bit_l1| {
+                ///////////////
+                // Level 2
+                let word2_index = TickIndexBitmap::layer_to_index(word1_index, closest_bit_l1);
+
+                // Layer 2 words are different, shift the bit to the word edge
+                let start_from_l2_bit = if word2_index < layer2_word {
+                    127
+                } else if word2_index > layer2_word {
+                    0
+                } else {
+                    layer2_bit
+                };
+
+                let word2_value = self.state_ops.get_layer2_word(word2_index);
+                let closest_bits_l2 = TickIndexBitmap::find_closest_active_bit_candidates(
+                    word2_value,
+                    start_from_l2_bit,
+                    lower,
+                );
+
+                if closest_bits_l2.len() > 0 {
+                    // The active tick is found, restore its full index and return
+                    let offset_found_index =
+                        TickIndexBitmap::layer_to_index(word2_index, closest_bits_l2[0]);
+
+                    if lower {
+                        if (offset_found_index > result) || (!found) {
+                            result = offset_found_index;
+                            found = true;
+                        }
+                    } else {
+                        if (offset_found_index < result) || (!found) {
+                            result = offset_found_index;
+                            found = true;
+                        }
+                    }
+                }
+            });
+        });
+
+        if !found {
+            return None;
+        }
+
+        // Convert the result offset_index back to a tick index
+        TickIndex::from_offset_index(result).ok()
+    }
+
+    pub fn find_closest_lower_active_tick_index(&self, index: TickIndex) -> Option<TickIndex> {
+        self.find_closest_active_tick_index(index, true)
+    }
+
+    pub fn find_closest_higher_active_tick_index(&self, index: TickIndex) -> Option<TickIndex> {
+        self.find_closest_active_tick_index(index, false)
+    }
+
+    pub fn find_closest_lower_active_tick(&self, index: TickIndex) -> Option<Tick> {
+        let maybe_tick_index = self.find_closest_lower_active_tick_index(index);
+        if let Some(tick_index) = maybe_tick_index {
+            self.state_ops.get_tick_by_index(tick_index)
+        } else {
+            None
+        }
+    }
+
+    pub fn find_closest_higher_active_tick(&self, index: TickIndex) -> Option<Tick> {
+        let maybe_tick_index = self.find_closest_higher_active_tick_index(index);
+        if let Some(tick_index) = maybe_tick_index {
+            self.state_ops.get_tick_by_index(tick_index)
+        } else {
+            None
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use approx::assert_abs_diff_eq;
+    use sp_arithmetic::helpers_128bit::sqrt;
+    use std::collections::HashMap;
+
+    #[derive(Debug, Clone)]
+    pub struct MockSwapDataOperations {
+        is_initialized: bool,
+        fee_rate: u16,
+        minimum_liquidity: u64,
+        ticks: HashMap<TickIndex, Tick>,
+        min_sqrt_price: SqrtPrice,
+        max_sqrt_price: SqrtPrice,
+        tao_reserve: u64,
+        alpha_reserve: u64,
+        alpha_sqrt_price: SqrtPrice,
+        fee_global_tao: U64F64,
+        fee_global_alpha: U64F64,
+        current_liquidity: u64,
+        max_positions: u16,
+        balances: HashMap<u16, (u64, u64)>,
+        positions: HashMap<u16, HashMap<u16, Position>>,
+        tick_index_l0: HashMap<u32, u128>,
+        tick_index_l1: HashMap<u32, u128>,
+        tick_index_l2: HashMap<u32, u128>,
+    }
+
+    impl MockSwapDataOperations {
+        pub fn new() -> Self {
+            Self {
+                is_initialized: false,
+                fee_rate: 196,
+                minimum_liquidity: 1000,
+                ticks: HashMap::new(),
+                min_sqrt_price: SqrtPrice::from_num(0.01),
+                max_sqrt_price: SqrtPrice::from_num(10),
+                tao_reserve: 0,
+                alpha_reserve: 0,
+                alpha_sqrt_price: SqrtPrice::from_num(0),
+                fee_global_tao: U64F64::from_num(0),
+                fee_global_alpha: U64F64::from_num(0),
+                current_liquidity: 0,
+                max_positions: 100,
+                balances: HashMap::new(),
+                positions: HashMap::new(),
+                tick_index_l0: HashMap::new(),
+                tick_index_l1: HashMap::new(),
+                tick_index_l2: HashMap::new(),
+            }
+        }
+    }
+
+    impl SwapDataOperations<u16> for MockSwapDataOperations {
+        fn is_v3_initialized(&self) -> bool {
+            self.is_initialized
+        }
+
+        fn set_v3_initialized(&mut self) {
+            self.is_initialized = true;
+        }
+
+        fn get_fee_rate(&self) -> u16 {
+            self.fee_rate
+        }
+
+        fn get_minimum_liquidity(&self) -> u64 {
+            self.minimum_liquidity
+        }
+
+        fn get_tick_by_index(&self, tick_index: TickIndex) -> Option<Tick> {
+            self.ticks.get(&tick_index).cloned()
+        }
+
+        fn insert_tick_by_index(&mut self, tick_index: TickIndex, tick: Tick) {
+            self.ticks.insert(tick_index, tick);
+        }
+
+        fn remove_tick_by_index(&mut self, tick_index: TickIndex) {
+            self.ticks.remove(&tick_index);
+        }
+
+        fn get_min_sqrt_price(&self) -> SqrtPrice {
+            self.min_sqrt_price
+        }
+
+        fn get_max_sqrt_price(&self) -> SqrtPrice {
+            self.max_sqrt_price
+        }
+
+        fn get_tao_reserve(&self) -> u64 {
+            self.tao_reserve
+        }
+
+        fn set_tao_reserve(&mut self, tao: u64) -> u64 {
+            self.tao_reserve = tao;
+            tao
+        }
+
+        fn get_alpha_reserve(&self) -> u64 {
+            self.alpha_reserve
+        }
+
+        fn set_alpha_reserve(&mut self, alpha: u64) -> u64 {
+            self.alpha_reserve = alpha;
+            alpha
+        }
+
+        fn get_alpha_sqrt_price(&self) -> SqrtPrice {
+            self.alpha_sqrt_price
+        }
+
+        fn set_alpha_sqrt_price(&mut self, sqrt_price: SqrtPrice) {
+            self.alpha_sqrt_price = sqrt_price;
+        }
+
+        fn get_fee_global_tao(&self) -> U64F64 {
+            self.fee_global_tao
+        }
+
+        fn set_fee_global_tao(&mut self, fee: U64F64) {
+            self.fee_global_tao = fee;
+        }
+
+        fn get_fee_global_alpha(&self) -> U64F64 {
+            self.fee_global_alpha
+        }
+
+        fn set_fee_global_alpha(&mut self, fee: U64F64) {
+            self.fee_global_alpha = fee;
+        }
+
+        fn get_current_liquidity(&self) -> u64 {
+            self.current_liquidity
+        }
+
+        fn set_current_liquidity(&mut self, liquidity: u64) {
+            self.current_liquidity = liquidity;
+        }
+
+        fn get_max_positions(&self) -> u16 {
+            self.max_positions
+        }
+
+        fn withdraw_balances(
+            &mut self,
+            account_id: &u16,
+            tao: u64,
+            alpha: u64,
+        ) -> Result<(u64, u64), SwapError> {
+            let (current_tao, current_alpha) =
+                self.balances.get(account_id).cloned().unwrap_or((0, 0));
+
+            if (tao > current_tao) || (alpha > current_alpha) {
+                return Err(SwapError::InsufficientBalance);
+            }
+
+            self.balances
+                .insert(*account_id, (current_tao - tao, current_alpha - alpha));
+
+            Ok((tao, alpha))
+        }
+
+        fn deposit_balances(&mut self, account_id: &u16, tao: u64, alpha: u64) {
+            let (current_tao, current_alpha) =
+                self.balances.get(account_id).cloned().unwrap_or((0, 0));
+            self.balances.insert(
+                account_id.clone(),
+                (current_tao + tao, current_alpha + alpha),
+            );
+        }
+
+        fn get_protocol_account_id(&self) -> u16 {
+            0xFFFF
+        }
+
+        fn get_position_count(&self, account_id: &u16) -> u16 {
+            self.positions.get(account_id).map_or(0, |p| p.len() as u16)
+        }
+
+        fn get_position(&self, account_id: &u16, position_id: u16) -> Option<Position> {
+            self.positions
+                .get(account_id)
+                .and_then(|p| p.get(&position_id).cloned())
+        }
+
+        fn create_position(&mut self, account_id: &u16, position: Position) -> u16 {
+            let entry = self
+                .positions
+                .entry(account_id.clone())
+                .or_insert_with(HashMap::new);
+
+            // Find the next available position ID
+            let new_position_id = entry.keys().max().map_or(0, |max_id| max_id + 1);
+
+            entry.insert(new_position_id, position);
+            new_position_id
+        }
+
+        fn update_position(&mut self, account_id: &u16, position_id: u16, position: Position) {
+            if let Some(account_positions) = self.positions.get_mut(account_id) {
+                account_positions.insert(position_id, position);
+            }
+        }
+
+        fn remove_position(&mut self, account_id: &u16, position_id: u16) {
+            if let Some(account_positions) = self.positions.get_mut(account_id) {
+                account_positions.remove(&position_id);
+            }
+        }
+
+        fn get_layer0_word(&self, word_index: u32) -> u128 {
+            *self.tick_index_l0.get(&word_index).unwrap_or(&0_u128)
+        }
+        fn get_layer1_word(&self, word_index: u32) -> u128 {
+            *self.tick_index_l1.get(&word_index).unwrap_or(&0_u128)
+        }
+        fn get_layer2_word(&self, word_index: u32) -> u128 {
+            *self.tick_index_l2.get(&word_index).unwrap_or(&0_u128)
+        }
+        fn set_layer0_word(&mut self, word_index: u32, word: u128) {
+            self.tick_index_l0.insert(word_index, word);
+        }
+        fn set_layer1_word(&mut self, word_index: u32, word: u128) {
+            self.tick_index_l1.insert(word_index, word);
+        }
+        fn set_layer2_word(&mut self, word_index: u32, word: u128) {
+            self.tick_index_l2.insert(word_index, word);
+        }
+    }
+
+    #[test]
+    fn test_swap_initialization() {
+        let tao = 1_000_000_000;
+        let alpha = 4_000_000_000;
+
+        let mut mock_ops = MockSwapDataOperations::new();
+        mock_ops.set_tao_reserve(tao);
+        mock_ops.set_alpha_reserve(alpha);
+        let swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
+
+        // Active ticks
+        let tick_low = swap.state_ops.get_tick_by_index(TickIndex::MIN).unwrap();
+        let tick_high = swap.state_ops.get_tick_by_index(TickIndex::MAX).unwrap();
+        let liquidity = sqrt(alpha as u128 * tao as u128) as u64;
+        let expected_liquidity_net_low: i128 = liquidity as i128;
+        let expected_liquidity_gross_low: u64 = liquidity;
+        let expected_liquidity_net_high: i128 = (liquidity as i128).neg();
+        let expected_liquidity_gross_high: u64 = liquidity;
+        assert_eq!(tick_low.liquidity_net, expected_liquidity_net_low,);
+        assert_eq!(tick_low.liquidity_gross, expected_liquidity_gross_low,);
+        assert_eq!(tick_high.liquidity_net, expected_liquidity_net_high,);
+        assert_eq!(tick_high.liquidity_gross, expected_liquidity_gross_high,);
+
+        // Liquidity position at correct ticks
+        let account_id = swap.state_ops.get_protocol_account_id();
+        assert_eq!(swap.state_ops.get_position_count(&account_id), 1);
+
+        let position = swap.state_ops.get_position(&account_id, 0).unwrap();
+        assert_eq!(position.liquidity, liquidity);
+        assert_eq!(position.tick_low, TickIndex::MIN);
+        assert_eq!(position.tick_high, TickIndex::MAX);
+        assert_eq!(position.fees_alpha, 0);
+        assert_eq!(position.fees_tao, 0);
+
+        // Current liquidity
+        assert_eq!(swap.state_ops.get_current_liquidity(), liquidity);
+
+        // Current price
+        let sqrt_price = swap.state_ops.get_alpha_sqrt_price();
+        assert_abs_diff_eq!(sqrt_price.to_num::<f64>(), 0.50, epsilon = 0.00001,);
+    }
+
+    fn price_to_tick(price: f64) -> TickIndex {
+        let price_sqrt: SqrtPrice = SqrtPrice::from_num(price.sqrt());
+        // Handle potential errors in the conversion
+        match TickIndex::try_from_sqrt_price(price_sqrt) {
+            Ok(mut tick) => {
+                // Ensure the tick is within bounds
+                if tick > TickIndex::MAX {
+                    tick = TickIndex::MAX;
+                } else if tick < TickIndex::MIN {
+                    tick = TickIndex::MIN;
+                }
+                tick
+            }
+            // Default to a reasonable value when conversion fails
+            Err(_) => {
+                if price > 1.0 {
+                    TickIndex::MAX
+                } else {
+                    TickIndex::MIN
+                }
+            }
+        }
+    }
+
+    fn tick_to_price(tick: TickIndex) -> f64 {
+        // Handle errors gracefully
+        match tick.try_to_sqrt_price() {
+            Ok(price_sqrt) => (price_sqrt * price_sqrt).to_num::<f64>(),
+            Err(_) => {
+                // Return a sensible default based on whether the tick is above or below the valid range
+                if tick > TickIndex::MAX {
+                    tick_to_price(TickIndex::MAX) // Use the max valid tick price
+                } else {
+                    tick_to_price(TickIndex::MIN) // Use the min valid tick price
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn test_tick_price_sanity_check() {
+        let min_price = tick_to_price(TickIndex::MIN);
+        let max_price = tick_to_price(TickIndex::MAX);
+        assert!(min_price > 0.);
+        assert!(max_price > 0.);
+        assert!(max_price > min_price);
+        assert!(min_price < 0.000001);
+        assert!(max_price > 10.);
+
+        // Roundtrip conversions
+        let min_price_sqrt: SqrtPrice = TickIndex::MIN.try_to_sqrt_price().unwrap();
+        let min_tick = TickIndex::try_from_sqrt_price(min_price_sqrt).unwrap();
+        assert_eq!(min_tick, TickIndex::MIN);
+
+        let max_price_sqrt: SqrtPrice = TickIndex::MAX.try_to_sqrt_price().unwrap();
+        let max_tick = TickIndex::try_from_sqrt_price(max_price_sqrt).unwrap();
+        assert_eq!(max_tick, TickIndex::MAX);
+    }
+
+    // Test adding liquidity on top of the existing protocol liquidity
+    #[test]
+    fn test_add_liquidity_basic() {
+        let protocol_tao = 1_000_000_000;
+        let protocol_alpha = 4_000_000_000;
+        let user_tao = 100_000_000_000;
+        let user_alpha = 100_000_000_000;
+        let account_id = 1;
+        let min_price = tick_to_price(TickIndex::MIN);
+        let max_price = tick_to_price(TickIndex::MAX);
+        let max_tick = price_to_tick(max_price);
+        let current_price = 0.25;
+        assert_eq!(max_tick, TickIndex::MAX);
+
+        // As a user add liquidity with all possible corner cases
+        //   - Initial price is 0.25
+        //   - liquidity is expressed in RAO units
+        // Test case is (price_low, price_high, liquidity, tao, alpha)
+        [
+            // Repeat the protocol liquidity at maximum range: Expect all the same values
+            (
+                min_price,
+                max_price,
+                2_000_000_000_u64,
+                1_000_000_000_u64,
+                4_000_000_000_u64,
+            ),
+            // Repeat the protocol liquidity at current to max range: Expect the same alpha
+            (0.25, max_price, 2_000_000_000_u64, 0, 4_000_000_000),
+            // Repeat the protocol liquidity at min to current range: Expect all the same tao
+            (min_price, 0.24999, 2_000_000_000_u64, 1_000_000_000, 0),
+            // Half to double price - just some sane wothdraw amounts
+            (0.125, 0.5, 2_000_000_000_u64, 293_000_000, 1_171_000_000),
+            // Both below price - tao is non-zero, alpha is zero
+            (0.12, 0.13, 2_000_000_000_u64, 28_270_000, 0),
+            // Both above price - tao is zero, alpha is non-zero
+            (0.3, 0.4, 2_000_000_000_u64, 0, 489_200_000),
+        ]
+        .iter()
+        .for_each(|(price_low, price_high, liquidity, tao, alpha)| {
+            // Calculate ticks (assuming tick math is tested separately)
+            let tick_low = price_to_tick(*price_low);
+            let tick_high = price_to_tick(*price_high);
+
+            // Setup swap
+            let mut mock_ops = MockSwapDataOperations::new();
+            mock_ops.set_tao_reserve(protocol_tao);
+            mock_ops.set_alpha_reserve(protocol_alpha);
+            mock_ops.deposit_balances(&account_id, user_tao, user_alpha);
+            let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
+
+            // Get tick infos and liquidity before adding (to account for protocol liquidity)
+            let tick_low_info_before = swap
+                .state_ops
+                .get_tick_by_index(tick_low)
+                .unwrap_or_default();
+            let tick_high_info_before = swap
+                .state_ops
+                .get_tick_by_index(tick_high)
+                .unwrap_or_default();
+            let liquidity_before = swap.state_ops.get_current_liquidity();
+
+            // Add liquidity
+            assert!(
+                swap.add_liquidity(&account_id, tick_low, tick_high, *liquidity, false)
+                    .is_ok()
+            );
+
+            // Check that low and high ticks appear in the state and are properly updated
+            let tick_low_info = swap.state_ops.get_tick_by_index(tick_low).unwrap();
+            let tick_high_info = swap.state_ops.get_tick_by_index(tick_high).unwrap();
+            let expected_liquidity_net_low: i128 = *liquidity as i128;
+            let expected_liquidity_gross_low: u64 = *liquidity;
+            let expected_liquidity_net_high: i128 = (*liquidity as i128).neg();
+            let expected_liquidity_gross_high: u64 = *liquidity;
+            assert_eq!(
+                tick_low_info.liquidity_net - tick_low_info_before.liquidity_net,
+                expected_liquidity_net_low,
+            );
+            assert_eq!(
+                tick_low_info.liquidity_gross - tick_low_info_before.liquidity_gross,
+                expected_liquidity_gross_low,
+            );
+            assert_eq!(
+                tick_high_info.liquidity_net - tick_high_info_before.liquidity_net,
+                expected_liquidity_net_high,
+            );
+            assert_eq!(
+                tick_high_info.liquidity_gross - tick_high_info_before.liquidity_gross,
+                expected_liquidity_gross_high,
+            );
+
+            // Balances are withdrawn
+            let (user_tao_after, user_alpha_after) =
+                swap.state_ops.balances.get(&account_id).unwrap();
+            let tao_withdrawn = user_tao - user_tao_after;
+            let alpha_withdrawn = user_alpha - user_alpha_after;
+            assert_abs_diff_eq!(tao_withdrawn, *tao, epsilon = *tao / 1000);
+            assert_abs_diff_eq!(alpha_withdrawn, *alpha, epsilon = *alpha / 1000);
+
+            // Liquidity position at correct ticks
+            assert_eq!(swap.state_ops.get_position_count(&account_id), 1);
+
+            let position = swap.state_ops.get_position(&account_id, 0).unwrap();
+            assert_eq!(position.liquidity, *liquidity);
+            assert_eq!(position.tick_low, tick_low);
+            assert_eq!(position.tick_high, tick_high);
+            assert_eq!(position.fees_alpha, 0);
+            assert_eq!(position.fees_tao, 0);
+
+            // Current liquidity is updated only when price range includes the current price
+            if (*price_high >= current_price) && (*price_low <= current_price) {
+                assert_eq!(
+                    swap.state_ops.get_current_liquidity(),
+                    liquidity_before + *liquidity
+                );
+            } else {
+                assert_eq!(swap.state_ops.get_current_liquidity(), liquidity_before);
+            }
+
+            // Reserves are updated
+            assert_eq!(
+                swap.state_ops.get_tao_reserve(),
+                tao_withdrawn + protocol_tao,
+            );
+            assert_eq!(
+                swap.state_ops.get_alpha_reserve(),
+                alpha_withdrawn + protocol_alpha,
+            );
+        });
+    }
+
+    #[test]
+    fn test_add_liquidity_out_of_bounds() {
+        let protocol_tao = 1_000_000_000;
+        let protocol_alpha = 2_000_000_000;
+        let user_tao = 100_000_000_000;
+        let user_alpha = 100_000_000_000;
+        let account_id = 1;
+
+        [
+            // For our tests, we'll construct TickIndex values that are intentionally
+            // outside the valid range for testing purposes only
+            (
+                TickIndex::new_unchecked(TickIndex::MIN.get() - 1),
+                TickIndex::MAX,
+                1_000_000_000_u64,
+            ),
+            (
+                TickIndex::MIN,
+                TickIndex::new_unchecked(TickIndex::MAX.get() + 1),
+                1_000_000_000_u64,
+            ),
+            (
+                TickIndex::new_unchecked(TickIndex::MIN.get() - 1),
+                TickIndex::new_unchecked(TickIndex::MAX.get() + 1),
+                1_000_000_000_u64,
+            ),
+            (
+                TickIndex::new_unchecked(TickIndex::MIN.get() - 100),
+                TickIndex::new_unchecked(TickIndex::MAX.get() + 100),
+                1_000_000_000_u64,
+            ),
+        ]
+        .iter()
+        .for_each(|(tick_low, tick_high, liquidity)| {
+            // Setup swap
+            let mut mock_ops = MockSwapDataOperations::new();
+            mock_ops.set_tao_reserve(protocol_tao);
+            mock_ops.set_alpha_reserve(protocol_alpha);
+            mock_ops.deposit_balances(&account_id, user_tao, user_alpha);
+            let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
+
+            // Add liquidity
+            assert_eq!(
+                swap.add_liquidity(&account_id, *tick_low, *tick_high, *liquidity, false),
+                Err(SwapError::InvalidTickRange),
+            );
+        });
+    }
+
+    #[test]
+    fn test_add_liquidity_over_balance() {
+        let protocol_tao = 1_000_000_000;
+        let protocol_alpha = 4_000_000_000;
+        let user_tao = 1_000_000_000;
+        let user_alpha = 1_000_000_000;
+        let account_id = 1;
+
+        [
+            // Lower than price (not enough alpha)
+            (0.1, 0.2, 100_000_000_000_u64),
+            // Higher than price (not enough tao)
+            (0.3, 0.4, 100_000_000_000_u64),
+            // Around the price (not enough both)
+            (0.1, 0.4, 100_000_000_000_u64),
+        ]
+        .iter()
+        .for_each(|(price_low, price_high, liquidity)| {
+            // Calculate ticks
+            let tick_low = price_to_tick(*price_low);
+            let tick_high = price_to_tick(*price_high);
+
+            // Setup swap
+            let mut mock_ops = MockSwapDataOperations::new();
+            mock_ops.set_tao_reserve(protocol_tao);
+            mock_ops.set_alpha_reserve(protocol_alpha);
+            mock_ops.deposit_balances(&account_id, user_tao, user_alpha);
+            let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
+
+            // Add liquidity
+            assert_eq!(
+                swap.add_liquidity(&account_id, tick_low, tick_high, *liquidity, false),
+                Err(SwapError::InsufficientBalance),
+            );
+        });
+    }
+
+    // Test removing liquidity
+    #[test]
+    fn test_remove_liquidity_basic() {
+        let protocol_tao = 1_000_000_000;
+        let protocol_alpha = 4_000_000_000;
+        let user_tao = 100_000_000_000;
+        let user_alpha = 100_000_000_000;
+        let account_id = 1;
+        let min_price = tick_to_price(TickIndex::MIN);
+        let max_price = tick_to_price(TickIndex::MAX);
+        let max_tick = price_to_tick(max_price);
+        assert_eq!(max_tick, TickIndex::MAX);
+
+        // As a user add liquidity with all possible corner cases
+        //   - Initial price is 0.25
+        //   - liquidity is expressed in RAO units
+        // Test case is (price_low, price_high, liquidity, tao, alpha)
+        [
+            // Repeat the protocol liquidity at maximum range: Expect all the same values
+            (
+                min_price,
+                max_price,
+                2_000_000_000_u64,
+                1_000_000_000_u64,
+                4_000_000_000_u64,
+            ),
+            // Repeat the protocol liquidity at current to max range: Expect the same alpha
+            (0.25, max_price, 2_000_000_000_u64, 0, 4_000_000_000),
+            // Repeat the protocol liquidity at min to current range: Expect all the same tao
+            (min_price, 0.24999, 2_000_000_000_u64, 1_000_000_000, 0),
+            // Half to double price - just some sane wothdraw amounts
+            (0.125, 0.5, 2_000_000_000_u64, 293_000_000, 1_171_000_000),
+            // Both below price - tao is non-zero, alpha is zero
+            (0.12, 0.13, 2_000_000_000_u64, 28_270_000, 0),
+            // Both above price - tao is zero, alpha is non-zero
+            (0.3, 0.4, 2_000_000_000_u64, 0, 489_200_000),
+        ]
+        .iter()
+        .for_each(|(price_low, price_high, liquidity, tao, alpha)| {
+            // Calculate ticks (assuming tick math is tested separately)
+            let tick_low = price_to_tick(*price_low);
+            let tick_high = price_to_tick(*price_high);
+
+            // Setup swap
+            let mut mock_ops = MockSwapDataOperations::new();
+            mock_ops.set_tao_reserve(protocol_tao);
+            mock_ops.set_alpha_reserve(protocol_alpha);
+            mock_ops.deposit_balances(&account_id, user_tao, user_alpha);
+            let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
+            let liquidity_before = swap.state_ops.get_current_liquidity();
+
+            // Add liquidity
+            assert!(
+                swap.add_liquidity(&account_id, tick_low, tick_high, *liquidity, false)
+                    .is_ok()
+            );
+
+            // Remove liquidity
+            let remove_result = swap.remove_liquidity(&account_id, 0).unwrap();
+            assert_abs_diff_eq!(remove_result.tao, *tao, epsilon = *tao / 1000);
+            assert_abs_diff_eq!(remove_result.alpha, *alpha, epsilon = *alpha / 1000);
+            assert_eq!(remove_result.fee_tao, 0);
+            assert_eq!(remove_result.fee_alpha, 0);
+
+            // Balances are returned
+            let (user_tao_after, user_alpha_after) =
+                swap.state_ops.balances.get(&account_id).unwrap();
+            assert_eq!(user_tao, *user_tao_after);
+            assert_eq!(user_alpha, *user_alpha_after);
+
+            // Liquidity position is removed
+            assert_eq!(swap.state_ops.get_position_count(&account_id), 0);
+            assert!(swap.state_ops.get_position(&account_id, 0).is_none());
+
+            // Current liquidity is updated (back where it was)
+            assert_eq!(swap.state_ops.get_current_liquidity(), liquidity_before);
+
+            // Reserves are updated (back where they were)
+            assert_eq!(swap.state_ops.get_tao_reserve(), protocol_tao,);
+            assert_eq!(swap.state_ops.get_alpha_reserve(), protocol_alpha,);
+        });
+    }
+
+    #[test]
+    fn test_remove_liquidity_nonexisting_position() {
+        let protocol_tao = 1_000_000_000;
+        let protocol_alpha = 4_000_000_000;
+        let user_tao = 100_000_000_000;
+        let user_alpha = 100_000_000_000;
+        let account_id = 1;
+        let min_price = tick_to_price(TickIndex::MIN);
+        let max_price = tick_to_price(TickIndex::MAX);
+        let max_tick = price_to_tick(max_price);
+        assert_eq!(max_tick.get(), TickIndex::MAX.get());
+
+        // Test case is (price_low, price_high, liquidity)
+        [
+            // Repeat the protocol liquidity at maximum range: Expect all the same values
+            (min_price, max_price, 2_000_000_000_u64),
+        ]
+        .iter()
+        .for_each(|(price_low, price_high, liquidity)| {
+            // Calculate ticks (assuming tick math is tested separately)
+            let tick_low = price_to_tick(*price_low);
+            let tick_high = price_to_tick(*price_high);
+
+            // Setup swap
+            let mut mock_ops = MockSwapDataOperations::new();
+            mock_ops.set_tao_reserve(protocol_tao);
+            mock_ops.set_alpha_reserve(protocol_alpha);
+            mock_ops.deposit_balances(&account_id, user_tao, user_alpha);
+            let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
+
+            // Add liquidity
+            assert!(
+                swap.add_liquidity(&account_id, tick_low, tick_high, *liquidity, false)
+                    .is_ok()
+            );
+
+            // Remove liquidity
+            assert_eq!(
+                swap.remove_liquidity(&account_id, 1),
+                Err(SwapError::LiquidityNotFound),
+            );
+        });
+    }
+
+    // cargo test --package pallet-subtensor-swap --lib -- tests::test_tick_search_basic --exact --show-output
+    #[test]
+    fn test_tick_search_basic() {
+        let mock_ops = MockSwapDataOperations::new();
+        let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
+
+        swap.insert_active_tick(TickIndex::MIN);
+        assert_eq!(
+            swap.find_closest_lower_active_tick_index(TickIndex::MIN)
+                .unwrap(),
+            TickIndex::MIN
+        );
+        assert_eq!(
+            swap.find_closest_lower_active_tick_index(TickIndex::MAX)
+                .unwrap(),
+            TickIndex::MIN
+        );
+        assert_eq!(
+            swap.find_closest_lower_active_tick_index(TickIndex::MAX.saturating_div(2))
+                .unwrap(),
+            TickIndex::MIN
+        );
+        assert_eq!(
+            swap.find_closest_lower_active_tick_index(TickIndex::MAX.prev().unwrap())
+                .unwrap(),
+            TickIndex::MIN
+        );
+        assert_eq!(
+            swap.find_closest_lower_active_tick_index(TickIndex::MIN.next().unwrap())
+                .unwrap(),
+            TickIndex::MIN
+        );
+
+        assert_eq!(
+            swap.find_closest_higher_active_tick_index(TickIndex::MIN)
+                .unwrap(),
+            TickIndex::MIN
+        );
+        assert_eq!(
+            swap.find_closest_higher_active_tick_index(TickIndex::MAX),
+            None
+        );
+        assert_eq!(
+            swap.find_closest_higher_active_tick_index(TickIndex::MAX.saturating_div(2)),
+            None
+        );
+        assert_eq!(
+            swap.find_closest_higher_active_tick_index(TickIndex::MAX.prev().unwrap()),
+            None
+        );
+        assert_eq!(
+            swap.find_closest_higher_active_tick_index(TickIndex::MIN.next().unwrap()),
+            None
+        );
+
+        swap.insert_active_tick(TickIndex::MAX);
+        assert_eq!(
+            swap.find_closest_lower_active_tick_index(TickIndex::MIN)
+                .unwrap(),
+            TickIndex::MIN
+        );
+        assert_eq!(
+            swap.find_closest_lower_active_tick_index(TickIndex::MAX)
+                .unwrap(),
+            TickIndex::MAX
+        );
+        assert_eq!(
+            swap.find_closest_lower_active_tick_index(TickIndex::MAX.saturating_div(2))
+                .unwrap(),
+            TickIndex::MIN
+        );
+        assert_eq!(
+            swap.find_closest_lower_active_tick_index(TickIndex::MAX.prev().unwrap())
+                .unwrap(),
+            TickIndex::MIN
+        );
+        assert_eq!(
+            swap.find_closest_lower_active_tick_index(TickIndex::MIN.next().unwrap())
+                .unwrap(),
+            TickIndex::MIN
+        );
+    }
+
+    #[test]
+    fn test_tick_search_sparse_queries() {
+        let mock_ops = MockSwapDataOperations::new();
+        let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
+
+        let active_index = TickIndex::MIN.saturating_add(10);
+        swap.insert_active_tick(active_index);
+        assert_eq!(
+            swap.find_closest_lower_active_tick_index(active_index)
+                .unwrap(),
+            active_index
+        );
+        assert_eq!(
+            swap.find_closest_lower_active_tick_index(TickIndex::MIN.saturating_add(11))
+                .unwrap(),
+            active_index
+        );
+        assert_eq!(
+            swap.find_closest_lower_active_tick_index(TickIndex::MIN.saturating_add(12))
+                .unwrap(),
+            active_index
+        );
+        assert_eq!(
+            swap.find_closest_lower_active_tick_index(TickIndex::MIN),
+            None
+        );
+        assert_eq!(
+            swap.find_closest_lower_active_tick_index(TickIndex::MIN.saturating_add(9)),
+            None
+        );
+
+        assert_eq!(
+            swap.find_closest_higher_active_tick_index(active_index)
+                .unwrap(),
+            active_index
+        );
+        assert_eq!(
+            swap.find_closest_higher_active_tick_index(TickIndex::MIN.saturating_add(11)),
+            None
+        );
+        assert_eq!(
+            swap.find_closest_higher_active_tick_index(TickIndex::MIN.saturating_add(12)),
+            None
+        );
+        assert_eq!(
+            swap.find_closest_higher_active_tick_index(TickIndex::MIN)
+                .unwrap(),
+            active_index
+        );
+        assert_eq!(
+            swap.find_closest_higher_active_tick_index(TickIndex::MIN.saturating_add(9))
+                .unwrap(),
+            active_index
+        );
+    }
+
+    #[test]
+    fn test_tick_search_many_lows() {
+        let mock_ops = MockSwapDataOperations::new();
+        let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
+
+        (0..1000).for_each(|i| {
+            swap.insert_active_tick(TickIndex::MIN.saturating_add(i));
+        });
+
+        for i in 0..1000 {
+            let test_index = TickIndex::MIN.saturating_add(i);
+            assert_eq!(
+                swap.find_closest_lower_active_tick_index(test_index)
+                    .unwrap(),
+                test_index
+            );
+            assert_eq!(
+                swap.find_closest_higher_active_tick_index(test_index)
+                    .unwrap(),
+                test_index
+            );
+        }
+    }
+
+    #[test]
+    fn test_tick_search_many_sparse() {
+        let mock_ops = MockSwapDataOperations::new();
+        let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
+        let count: i32 = 1000;
+
+        for i in 0..=count {
+            swap.insert_active_tick(TickIndex::new_unchecked(i * 10));
+        }
+        for i in 1..count {
+            let tick = TickIndex::new_unchecked(i * 10);
+            assert_eq!(
+                swap.find_closest_lower_active_tick_index(tick).unwrap(),
+                tick
+            );
+            assert_eq!(
+                swap.find_closest_higher_active_tick_index(tick).unwrap(),
+                tick
+            );
+            for j in 1..=9 {
+                let before_tick = TickIndex::new_unchecked(i * 10 - j);
+                let after_tick = TickIndex::new_unchecked(i * 10 + j);
+                let prev_tick = TickIndex::new_unchecked((i - 1) * 10);
+                let next_tick = TickIndex::new_unchecked((i + 1) * 10);
+                assert_eq!(
+                    swap.find_closest_lower_active_tick_index(before_tick)
+                        .unwrap(),
+                    prev_tick
+                );
+                assert_eq!(
+                    swap.find_closest_lower_active_tick_index(after_tick)
+                        .unwrap(),
+                    tick
+                );
+                assert_eq!(
+                    swap.find_closest_higher_active_tick_index(before_tick)
+                        .unwrap(),
+                    tick
+                );
+                assert_eq!(
+                    swap.find_closest_higher_active_tick_index(after_tick)
+                        .unwrap(),
+                    next_tick
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn test_tick_search_many_lows_sparse_reversed() {
+        let mock_ops = MockSwapDataOperations::new();
+        let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
+        let count: i32 = 1000;
+
+        for i in (0..=count).rev() {
+            swap.insert_active_tick(TickIndex::new_unchecked(i * 10));
+        }
+        for i in 1..count {
+            let tick = TickIndex::new_unchecked(i * 10);
+            assert_eq!(
+                swap.find_closest_lower_active_tick_index(tick).unwrap(),
+                tick
+            );
+            assert_eq!(
+                swap.find_closest_higher_active_tick_index(tick).unwrap(),
+                tick
+            );
+            for j in 1..=9 {
+                let before_tick = TickIndex::new_unchecked(i * 10 - j);
+                let after_tick = TickIndex::new_unchecked(i * 10 + j);
+                let prev_tick = TickIndex::new_unchecked((i - 1) * 10);
+                let next_tick = TickIndex::new_unchecked((i + 1) * 10);
+
+                assert_eq!(
+                    swap.find_closest_lower_active_tick_index(before_tick)
+                        .unwrap(),
+                    prev_tick
+                );
+                assert_eq!(
+                    swap.find_closest_lower_active_tick_index(after_tick)
+                        .unwrap(),
+                    tick
+                );
+                assert_eq!(
+                    swap.find_closest_higher_active_tick_index(before_tick)
+                        .unwrap(),
+                    tick
+                );
+                assert_eq!(
+                    swap.find_closest_higher_active_tick_index(after_tick)
+                        .unwrap(),
+                    next_tick
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn test_tick_search_repeated_insertions() {
+        let mock_ops = MockSwapDataOperations::new();
+        let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
+        let count: i32 = 1000;
+
+        for _ in 0..10 {
+            for i in 0..=count {
+                let tick = TickIndex::new_unchecked(i * 10);
+                swap.insert_active_tick(tick);
+            }
+            for i in 1..count {
+                let tick = TickIndex::new_unchecked(i * 10);
+                assert_eq!(
+                    swap.find_closest_lower_active_tick_index(tick).unwrap(),
+                    tick
+                );
+                assert_eq!(
+                    swap.find_closest_higher_active_tick_index(tick).unwrap(),
+                    tick
+                );
+                for j in 1..=9 {
+                    let before_tick = TickIndex::new_unchecked(i * 10 - j);
+                    let after_tick = TickIndex::new_unchecked(i * 10 + j);
+                    let prev_tick = TickIndex::new_unchecked((i - 1) * 10);
+                    let next_tick = TickIndex::new_unchecked((i + 1) * 10);
+
+                    assert_eq!(
+                        swap.find_closest_lower_active_tick_index(before_tick)
+                            .unwrap(),
+                        prev_tick
+                    );
+                    assert_eq!(
+                        swap.find_closest_lower_active_tick_index(after_tick)
+                            .unwrap(),
+                        tick
+                    );
+                    assert_eq!(
+                        swap.find_closest_higher_active_tick_index(before_tick)
+                            .unwrap(),
+                        tick
+                    );
+                    assert_eq!(
+                        swap.find_closest_higher_active_tick_index(after_tick)
+                            .unwrap(),
+                        next_tick
+                    );
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn test_tick_search_full_range() {
+        let mock_ops = MockSwapDataOperations::new();
+        let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
+        let step = 1019;
+        // Get the full valid tick range by subtracting MIN from MAX
+        let count = (TickIndex::MAX.get() - TickIndex::MIN.get()) / step;
+
+        for i in 0..=count {
+            let index = TickIndex::MIN.saturating_add(i * step);
+            swap.insert_active_tick(index);
+        }
+        for i in 1..count {
+            let index = TickIndex::MIN.saturating_add(i * step);
+
+            let prev_index = TickIndex::new_unchecked(index.get() - step);
+            let next_minus_one = TickIndex::new_unchecked(index.get() + step - 1);
+
+            assert_eq!(
+                swap.find_closest_lower_active_tick_index(prev_index)
+                    .unwrap(),
+                prev_index
+            );
+            assert_eq!(
+                swap.find_closest_lower_active_tick_index(index).unwrap(),
+                index
+            );
+            assert_eq!(
+                swap.find_closest_lower_active_tick_index(next_minus_one)
+                    .unwrap(),
+                index
+            );
+
+            let mid_next = TickIndex::new_unchecked(index.get() + step / 2);
+            assert_eq!(
+                swap.find_closest_lower_active_tick_index(mid_next).unwrap(),
+                index
+            );
+
+            assert_eq!(
+                swap.find_closest_higher_active_tick_index(index).unwrap(),
+                index
+            );
+
+            let next_index = TickIndex::new_unchecked(index.get() + step);
+            assert_eq!(
+                swap.find_closest_higher_active_tick_index(next_index)
+                    .unwrap(),
+                next_index
+            );
+
+            let mid_next = TickIndex::new_unchecked(index.get() + step / 2);
+            assert_eq!(
+                swap.find_closest_higher_active_tick_index(mid_next)
+                    .unwrap(),
+                next_index
+            );
+
+            let next_minus_1 = TickIndex::new_unchecked(index.get() + step - 1);
+            assert_eq!(
+                swap.find_closest_higher_active_tick_index(next_minus_1)
+                    .unwrap(),
+                next_index
+            );
+            for j in 1..=9 {
+                let before_index = TickIndex::new_unchecked(index.get() - j);
+                let after_index = TickIndex::new_unchecked(index.get() + j);
+
+                assert_eq!(
+                    swap.find_closest_lower_active_tick_index(before_index)
+                        .unwrap(),
+                    prev_index
+                );
+                assert_eq!(
+                    swap.find_closest_lower_active_tick_index(after_index)
+                        .unwrap(),
+                    index
+                );
+                assert_eq!(
+                    swap.find_closest_higher_active_tick_index(before_index)
+                        .unwrap(),
+                    index
+                );
+                assert_eq!(
+                    swap.find_closest_higher_active_tick_index(after_index)
+                        .unwrap(),
+                    next_index
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn test_tick_remove_basic() {
+        let mock_ops = MockSwapDataOperations::new();
+        let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
+
+        swap.insert_active_tick(TickIndex::MIN);
+        swap.insert_active_tick(TickIndex::MAX);
+        swap.remove_active_tick(TickIndex::MAX);
+
+        assert_eq!(
+            swap.find_closest_lower_active_tick_index(TickIndex::MIN)
+                .unwrap(),
+            TickIndex::MIN
+        );
+        assert_eq!(
+            swap.find_closest_lower_active_tick_index(TickIndex::MAX)
+                .unwrap(),
+            TickIndex::MIN
+        );
+        assert_eq!(
+            swap.find_closest_lower_active_tick_index(TickIndex::MAX.saturating_div(2))
+                .unwrap(),
+            TickIndex::MIN
+        );
+        assert_eq!(
+            swap.find_closest_lower_active_tick_index(TickIndex::MAX.prev().unwrap())
+                .unwrap(),
+            TickIndex::MIN
+        );
+        assert_eq!(
+            swap.find_closest_lower_active_tick_index(TickIndex::MIN.next().unwrap())
+                .unwrap(),
+            TickIndex::MIN
+        );
+
+        assert_eq!(
+            swap.find_closest_higher_active_tick_index(TickIndex::MIN)
+                .unwrap(),
+            TickIndex::MIN
+        );
+        assert_eq!(
+            swap.find_closest_higher_active_tick_index(TickIndex::MAX),
+            None
+        );
+        assert_eq!(
+            swap.find_closest_higher_active_tick_index(TickIndex::MAX.saturating_div(2)),
+            None
+        );
+        assert_eq!(
+            swap.find_closest_higher_active_tick_index(TickIndex::MAX.prev().unwrap()),
+            None
+        );
+        assert_eq!(
+            swap.find_closest_higher_active_tick_index(TickIndex::MIN.next().unwrap()),
+            None
+        );
+    }
+
+    #[test]
+    fn test_tick_remove_full_range() {
+        let mock_ops = MockSwapDataOperations::new();
+        let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
+        let step = 1019;
+        // Get the full valid tick range by subtracting MIN from MAX
+        let count = (TickIndex::MAX.get() - TickIndex::MIN.get()) / step;
+        let remove_frequency = 5; // Remove every 5th tick
+
+        // Insert ticks
+        for i in 0..=count {
+            let index = TickIndex::MIN.saturating_add(i * step);
+            swap.insert_active_tick(index);
+        }
+
+        // Remove some ticks
+        for i in 1..count {
+            if i % remove_frequency == 0 {
+                let index = TickIndex::MIN.saturating_add(i * step);
+                swap.remove_active_tick(index);
+            }
+        }
+
+        // Verify
+        for i in 1..count {
+            let index = TickIndex::MIN.saturating_add(i * step);
+
+            if i % remove_frequency == 0 {
+                let lower = swap.find_closest_lower_active_tick_index(index);
+                let higher = swap.find_closest_higher_active_tick_index(index);
+                assert!(lower != Some(index));
+                assert!(higher != Some(index));
+            } else {
+                assert_eq!(
+                    swap.find_closest_lower_active_tick_index(index).unwrap(),
+                    index
+                );
+                assert_eq!(
+                    swap.find_closest_higher_active_tick_index(index).unwrap(),
+                    index
+                );
+            }
+        }
+    }
+}

From 8560168916ead46dc25ab72e3847c76a710cc0f0 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Thu, 27 Mar 2025 17:45:13 +0100
Subject: [PATCH 038/418] Encapsulate position into module

---
 pallets/swap/src/lib.rs          | 107 +---------------------------
 pallets/swap/src/pallet/impls.rs |   5 +-
 pallets/swap/src/pallet/mod.rs   |   3 +-
 pallets/swap/src/position.rs     | 115 ++++++++++++++++++++++++++++++
 pallets/swap/src/swap.rs         | 118 ++++++++++++++++++++++++++++++-
 5 files changed, 238 insertions(+), 110 deletions(-)
 create mode 100644 pallets/swap/src/position.rs

diff --git a/pallets/swap/src/lib.rs b/pallets/swap/src/lib.rs
index e6fc350425..2482203cef 100644
--- a/pallets/swap/src/lib.rs
+++ b/pallets/swap/src/lib.rs
@@ -15,6 +15,7 @@ use crate::pallet::{Config, Error};
 
 pub mod pallet;
 mod tick;
+mod position;
 pub(crate) mod swap;
 
 type SqrtPrice = U64F64;
@@ -27,112 +28,6 @@ pub struct RemoveLiquidityResult {
     fee_alpha: u64,
 }
 
-/// Position designates one liquidity position.
-///
-/// Alpha price is expressed in rao units per one 10^9 unit. For example,
-/// price 1_000_000 is equal to 0.001 TAO per Alpha.
-///
-/// tick_low - tick index for lower boundary of price
-/// tick_high - tick index for higher boundary of price
-/// liquidity - position liquidity
-/// fees_tao - fees accrued by the position in quote currency (TAO)
-/// fees_alpha - fees accrued by the position in base currency (Alpha)
-///
-#[derive(Clone, Encode, Decode, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen, Default)]
-pub struct Position {
-    pub id: PositionId,
-    pub tick_low: TickIndex,
-    pub tick_high: TickIndex,
-    pub liquidity: u64,
-    pub fees_tao: u64,
-    pub fees_alpha: u64,
-}
-
-impl Position {
-    /// Converts position to token amounts
-    ///
-    /// returns tuple of (TAO, Alpha)
-    ///
-    /// Pseudocode:
-    ///     if self.sqrt_price_curr < sqrt_pa:
-    ///         tao = 0
-    ///         alpha = L * (1 / sqrt_pa - 1 / sqrt_pb)
-    ///     elif self.sqrt_price_curr > sqrt_pb:
-    ///         tao = L * (sqrt_pb - sqrt_pa)
-    ///         alpha = 0
-    ///     else:
-    ///         tao = L * (self.sqrt_price_curr - sqrt_pa)
-    ///         alpha = L * (1 / self.sqrt_price_curr - 1 / sqrt_pb)
-    ///
-    pub fn to_token_amounts<T: Config>(
-        &self,
-        sqrt_price_curr: SqrtPrice,
-    ) -> Result<(u64, u64), Error<T>> {
-        let one: U64F64 = U64F64::saturating_from_num(1);
-
-        let sqrt_pa: SqrtPrice = self
-            .tick_low
-            .try_to_sqrt_price()
-            .map_err(|_| Error::<T>::InvalidTickRange)?;
-        let sqrt_pb: SqrtPrice = self
-            .tick_high
-            .try_to_sqrt_price()
-            .map_err(|_| Error::<T>::InvalidTickRange)?;
-        let liquidity_fixed: U64F64 = U64F64::saturating_from_num(self.liquidity);
-
-        Ok(if sqrt_price_curr < sqrt_pa {
-            (
-                0,
-                liquidity_fixed
-                    .saturating_mul(one.safe_div(sqrt_pa).saturating_sub(one.safe_div(sqrt_pb)))
-                    .saturating_to_num::<u64>(),
-            )
-        } else if sqrt_price_curr > sqrt_pb {
-            (
-                liquidity_fixed
-                    .saturating_mul(sqrt_pb.saturating_sub(sqrt_pa))
-                    .saturating_to_num::<u64>(),
-                0,
-            )
-        } else {
-            (
-                liquidity_fixed
-                    .saturating_mul(sqrt_price_curr.saturating_sub(sqrt_pa))
-                    .saturating_to_num::<u64>(),
-                liquidity_fixed
-                    .saturating_mul(
-                        one.safe_div(sqrt_price_curr)
-                            .saturating_sub(one.safe_div(sqrt_pb)),
-                    )
-                    .saturating_to_num::<u64>(),
-            )
-        })
-    }
-}
-
-#[derive(
-    Clone, Copy, Decode, Default, Encode, Eq, MaxEncodedLen, PartialEq, RuntimeDebug, TypeInfo,
-)]
-pub struct PositionId([u8; 16]);
-
-impl PositionId {
-    /// Create a new position ID using UUID v4
-    pub fn new() -> Self {
-        Self(Uuid::new_v4().into_bytes())
-    }
-}
-
-impl From<Uuid> for PositionId {
-    fn from(value: Uuid) -> Self {
-        Self(value.into_bytes())
-    }
-}
-
-impl From<PositionId> for Uuid {
-    fn from(value: PositionId) -> Self {
-        Uuid::from_bytes(value.0)
-    }
-}
 
 #[derive(
     Clone, Copy, Decode, Default, Encode, Eq, MaxEncodedLen, PartialEq, RuntimeDebug, TypeInfo,
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 8456bb45bd..b0f7676ee3 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -7,7 +7,8 @@ use substrate_fixed::types::U64F64;
 
 use super::pallet::*;
 use crate::{
-    NetUid, Position, PositionId, RemoveLiquidityResult,
+    NetUid, RemoveLiquidityResult,
+    position::{Position, PositionId},
     tick::{Tick, TickIndex},
 };
 
@@ -183,7 +184,7 @@ impl<T: Config> Pallet<T> {
         let current_tick_index = CurrentTickIndex::<T>::get(netuid);
 
         // Collect fees and get tao and alpha amounts
-		// let (fee_tao, fee_alpha) = self.collect_fees(&mut pos);
+        // let (fee_tao, fee_alpha) = self.collect_fees(&mut pos);
         //     let current_price: SqrtPrice = self.state_ops.get_alpha_sqrt_price();
         //     let (tao, alpha) = pos.to_token_amounts(current_price)?;
 
diff --git a/pallets/swap/src/pallet/mod.rs b/pallets/swap/src/pallet/mod.rs
index ad54f366dc..93e6a7f5ec 100644
--- a/pallets/swap/src/pallet/mod.rs
+++ b/pallets/swap/src/pallet/mod.rs
@@ -4,7 +4,8 @@ use pallet_subtensor_swap_interface::LiquidityDataProvider;
 use substrate_fixed::types::U64F64;
 
 use crate::{
-    NetUid, Position, PositionId,
+    NetUid,
+    position::{Position, PositionId},
     tick::{Tick, TickIndex},
 };
 
diff --git a/pallets/swap/src/position.rs b/pallets/swap/src/position.rs
new file mode 100644
index 0000000000..b3746c1fbc
--- /dev/null
+++ b/pallets/swap/src/position.rs
@@ -0,0 +1,115 @@
+use codec::{Decode, Encode, MaxEncodedLen};
+use frame_support::pallet_prelude::*;
+use safe_math::*;
+use substrate_fixed::types::U64F64;
+use uuid::Uuid;
+
+use crate::SqrtPrice;
+use crate::pallet::{Config, Error};
+use crate::tick::TickIndex;
+
+/// Position designates one liquidity position.
+///
+/// Alpha price is expressed in rao units per one 10^9 unit. For example,
+/// price 1_000_000 is equal to 0.001 TAO per Alpha.
+///
+/// tick_low - tick index for lower boundary of price
+/// tick_high - tick index for higher boundary of price
+/// liquidity - position liquidity
+/// fees_tao - fees accrued by the position in quote currency (TAO)
+/// fees_alpha - fees accrued by the position in base currency (Alpha)
+#[derive(Clone, Encode, Decode, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen, Default)]
+pub struct Position {
+    pub id: PositionId,
+    pub tick_low: TickIndex,
+    pub tick_high: TickIndex,
+    pub liquidity: u64,
+    pub fees_tao: u64,
+    pub fees_alpha: u64,
+}
+
+impl Position {
+    /// Converts position to token amounts
+    ///
+    /// returns tuple of (TAO, Alpha)
+    ///
+    /// Pseudocode:
+    ///     if self.sqrt_price_curr < sqrt_pa:
+    ///         tao = 0
+    ///         alpha = L * (1 / sqrt_pa - 1 / sqrt_pb)
+    ///     elif self.sqrt_price_curr > sqrt_pb:
+    ///         tao = L * (sqrt_pb - sqrt_pa)
+    ///         alpha = 0
+    ///     else:
+    ///         tao = L * (self.sqrt_price_curr - sqrt_pa)
+    ///         alpha = L * (1 / self.sqrt_price_curr - 1 / sqrt_pb)
+    ///
+    pub fn to_token_amounts<T: Config>(
+        &self,
+        sqrt_price_curr: SqrtPrice,
+    ) -> Result<(u64, u64), Error<T>> {
+        let one = U64F64::saturating_from_num(1);
+
+        let sqrt_pa: SqrtPrice = self
+            .tick_low
+            .try_to_sqrt_price()
+            .map_err(|_| Error::<T>::InvalidTickRange)?;
+        let sqrt_pb: SqrtPrice = self
+            .tick_high
+            .try_to_sqrt_price()
+            .map_err(|_| Error::<T>::InvalidTickRange)?;
+        let liquidity_fixed: U64F64 = U64F64::saturating_from_num(self.liquidity);
+
+        Ok(if sqrt_price_curr < sqrt_pa {
+            (
+                0,
+                liquidity_fixed
+                    .saturating_mul(one.safe_div(sqrt_pa).saturating_sub(one.safe_div(sqrt_pb)))
+                    .saturating_to_num::<u64>(),
+            )
+        } else if sqrt_price_curr > sqrt_pb {
+            (
+                liquidity_fixed
+                    .saturating_mul(sqrt_pb.saturating_sub(sqrt_pa))
+                    .saturating_to_num::<u64>(),
+                0,
+            )
+        } else {
+            (
+                liquidity_fixed
+                    .saturating_mul(sqrt_price_curr.saturating_sub(sqrt_pa))
+                    .saturating_to_num::<u64>(),
+                liquidity_fixed
+                    .saturating_mul(
+                        one.safe_div(sqrt_price_curr)
+                            .saturating_sub(one.safe_div(sqrt_pb)),
+                    )
+                    .saturating_to_num::<u64>(),
+            )
+        })
+    }
+}
+
+#[derive(
+    Clone, Copy, Decode, Default, Encode, Eq, MaxEncodedLen, PartialEq, RuntimeDebug, TypeInfo,
+)]
+pub struct PositionId([u8; 16]);
+
+impl PositionId {
+    /// Create a new position ID using UUID v4
+    pub fn new() -> Self {
+        Self(Uuid::new_v4().into_bytes())
+    }
+}
+
+impl From<Uuid> for PositionId {
+    fn from(value: Uuid) -> Self {
+        Self(value.into_bytes())
+    }
+}
+
+impl From<PositionId> for Uuid {
+    fn from(value: PositionId) -> Self {
+        Uuid::from_bytes(value.0)
+    }
+}
diff --git a/pallets/swap/src/swap.rs b/pallets/swap/src/swap.rs
index e9d72d4d68..9a58bf1f61 100644
--- a/pallets/swap/src/swap.rs
+++ b/pallets/swap/src/swap.rs
@@ -6,7 +6,7 @@ use safe_math::*;
 use substrate_fixed::types::U64F64;
 
 use crate::{
-    Position, RemoveLiquidityResult, SqrtPrice, SwapError,
+    position::Position, RemoveLiquidityResult, SqrtPrice, SwapError,
     tick::{Layer, Tick, TickIndex, TickIndexBitmap},
 };
 
@@ -1738,6 +1738,122 @@ mod tests {
         });
     }
 
+	// Test swapping against protocol liquidity only
+    #[test]
+    fn test_swap_basic() {
+        let protocol_tao = 1_000_000_000;
+        let protocol_alpha = 4_000_000_000;
+
+        // Current price is 0.25
+        // Test case is (order_type, liquidity, limit_price, output_amount)
+        [
+            (OrderType::Buy, 500_000_000u64, 1000.0_f64, 3990_u64),
+        ]
+        .iter()
+        .for_each(|(order_type, liquidity, limit_price, output_amount)| {
+            // Consumed liquidity ticks
+            let tick_low = TickIndex::MIN;
+            let tick_high = TickIndex::MAX;
+
+            // Setup swap
+            let mut mock_ops = MockSwapDataOperations::new();
+            mock_ops.set_tao_reserve(protocol_tao);
+            mock_ops.set_alpha_reserve(protocol_alpha);
+            let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
+
+            // Get tick infos before the swap
+            let tick_low_info_before = swap
+                .state_ops
+                .get_tick_by_index(tick_low)
+                .unwrap_or_default();
+            let tick_high_info_before = swap
+                .state_ops
+                .get_tick_by_index(tick_high)
+                .unwrap_or_default();
+            let liquidity_before = swap.state_ops.get_current_liquidity();
+
+            // Swap
+            let sqrt_limit_price: SqrtPrice = SqrtPrice::from_num((*limit_price).sqrt());
+            let swap_result = swap.swap(order_type, *liquidity, sqrt_limit_price);
+            // assert_abs_diff_eq!(
+            //     swap_result.unwrap().amount_paid_out,
+            //     *output_amount,
+            //     epsilon = *output_amount/1000
+            // );
+
+            // Check that low and high ticks' fees were updated properly, and liquidity values were not updated
+            let tick_low_info = swap.state_ops.get_tick_by_index(tick_low).unwrap();
+            let tick_high_info = swap.state_ops.get_tick_by_index(tick_high).unwrap();
+            let expected_liquidity_net_low: i128 = tick_low_info_before.liquidity_net;
+            let expected_liquidity_gross_low: u64 = tick_low_info_before.liquidity_gross;
+            let expected_liquidity_net_high: i128 = tick_high_info_before.liquidity_net;
+            let expected_liquidity_gross_high: u64 = tick_high_info_before.liquidity_gross;
+            assert_eq!(
+                tick_low_info.liquidity_net,
+                expected_liquidity_net_low,
+            );
+            assert_eq!(
+                tick_low_info.liquidity_gross,
+                expected_liquidity_gross_low,
+            );
+            assert_eq!(
+                tick_high_info.liquidity_net,
+                expected_liquidity_net_high,
+            );
+            assert_eq!(
+                tick_high_info.liquidity_gross,
+                expected_liquidity_gross_high,
+            );
+
+            // Expected fee amount
+            let fee_rate = swap.state_ops.get_fee_rate() as f64 / u16::MAX as f64;
+            let expected_fee = output_amount * fee_rate as u64;
+
+            // Global fees should be updated
+            let actual_global_fee: U64F64 = match order_type {
+                OrderType::Buy => swap.state_ops.get_fee_global_alpha(),
+                OrderType::Sell => swap.state_ops.get_fee_global_tao(),
+            };
+            println!("actual_global_fee {:?}", actual_global_fee);
+            assert_eq!(actual_global_fee, expected_fee);
+
+            // Tick fees should be updated
+
+
+
+
+            // Liquidity position should not be updated
+            let protocol_id = swap.state_ops.get_protocol_account_id();
+
+            let position = swap.state_ops.get_position(&protocol_id, 0).unwrap();
+            assert_eq!(position.liquidity, sqrt(protocol_tao as u128 * protocol_alpha as u128) as u64);
+            assert_eq!(position.tick_low, tick_low);
+            assert_eq!(position.tick_high, tick_high);
+            assert_eq!(position.fees_alpha, 0);
+            assert_eq!(position.fees_tao, 0);
+
+            // // Current liquidity is updated only when price range includes the current price
+            // if (*price_high >= current_price) && (*price_low <= current_price) {
+            //     assert_eq!(
+            //         swap.state_ops.get_current_liquidity(),
+            //         liquidity_before + *liquidity
+            //     );
+            // } else {
+            //     assert_eq!(swap.state_ops.get_current_liquidity(), liquidity_before);
+            // }
+
+            // // Reserves are updated
+            // assert_eq!(
+            //     swap.state_ops.get_tao_reserve(),
+            //     tao_withdrawn + protocol_tao,
+            // );
+            // assert_eq!(
+            //     swap.state_ops.get_alpha_reserve(),
+            //     alpha_withdrawn + protocol_alpha,
+            // );
+        });
+    }
+
     // cargo test --package pallet-subtensor-swap --lib -- tests::test_tick_search_basic --exact --show-output
     #[test]
     fn test_tick_search_basic() {

From 6d4c6002a1bdf67aa9f389819fc8af441ad286b6 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Thu, 27 Mar 2025 19:43:32 +0100
Subject: [PATCH 039/418] Add ActiveTickIndexManager

---
 pallets/swap/src/lib.rs          |   3 +-
 pallets/swap/src/pallet/impls.rs |   3 +-
 pallets/swap/src/pallet/mod.rs   |  24 +-
 pallets/swap/src/position.rs     |  37 ++-
 pallets/swap/src/swap.rs         | 446 +++++++------------------------
 pallets/swap/src/tick.rs         | 343 ++++++++++++++++++++++--
 6 files changed, 482 insertions(+), 374 deletions(-)

diff --git a/pallets/swap/src/lib.rs b/pallets/swap/src/lib.rs
index 2482203cef..997d6da96d 100644
--- a/pallets/swap/src/lib.rs
+++ b/pallets/swap/src/lib.rs
@@ -10,7 +10,7 @@ use safe_math::*;
 use substrate_fixed::types::U64F64;
 use uuid::Uuid;
 
-use self::tick::{Layer, Tick, TickIndex, TickIndexBitmap};
+use self::tick::{LayerLevel, Tick, TickIndex, TickIndexBitmap};
 use crate::pallet::{Config, Error};
 
 pub mod pallet;
@@ -28,7 +28,6 @@ pub struct RemoveLiquidityResult {
     fee_alpha: u64,
 }
 
-
 #[derive(
     Clone, Copy, Decode, Default, Encode, Eq, MaxEncodedLen, PartialEq, RuntimeDebug, TypeInfo,
 )]
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index b0f7676ee3..e1a9c742aa 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -107,6 +107,7 @@ impl<T: Config> Pallet<T> {
         // New position
         let position = Position {
             id: PositionId::new(),
+            netuid,
             tick_low,
             tick_high,
             liquidity,
@@ -184,7 +185,7 @@ impl<T: Config> Pallet<T> {
         let current_tick_index = CurrentTickIndex::<T>::get(netuid);
 
         // Collect fees and get tao and alpha amounts
-        // let (fee_tao, fee_alpha) = self.collect_fees(&mut pos);
+        let (fee_tao, fee_alpha) = pos.collect_fees::<T>();
         //     let current_price: SqrtPrice = self.state_ops.get_alpha_sqrt_price();
         //     let (tao, alpha) = pos.to_token_amounts(current_price)?;
 
diff --git a/pallets/swap/src/pallet/mod.rs b/pallets/swap/src/pallet/mod.rs
index 93e6a7f5ec..364ffe1d3f 100644
--- a/pallets/swap/src/pallet/mod.rs
+++ b/pallets/swap/src/pallet/mod.rs
@@ -6,7 +6,7 @@ use substrate_fixed::types::U64F64;
 use crate::{
     NetUid,
     position::{Position, PositionId},
-    tick::{Tick, TickIndex},
+    tick::{LayerLevel, Tick, TickIndex},
 };
 
 pub use pallet::*;
@@ -76,7 +76,6 @@ mod pallet {
     /// Storage for user positions, using subnet ID and account ID as keys
     /// The value is a bounded vector of Position structs with details about the liquidity positions
     #[pallet::storage]
-    #[pallet::getter(fn positions)]
     pub type Positions<T: Config> = StorageNMap<
         _,
         (
@@ -88,6 +87,27 @@ mod pallet {
         OptionQuery,
     >;
 
+    // Global accrued fees in tao per subnet
+    #[pallet::storage]
+    pub type FeeGlobalTao<T> = StorageMap<_, Twox64Concat, NetUid, U64F64>;
+
+    // Global accrued fees in alpha per subnet
+    #[pallet::storage]
+    pub type FeeGlobalAlpha<T> = StorageMap<_, Twox64Concat, NetUid, U64F64>;
+
+    /// Tick index bitmap words storage
+    #[pallet::storage]
+    pub type TickIndexBitmapWords<T: Config> = StorageNMap<
+        _,
+        (
+            NMapKey<Twox64Concat, NetUid>,     // Subnet ID
+            NMapKey<Twox64Concat, LayerLevel>, // Layer level
+            NMapKey<Twox64Concat, u32>,        // word index
+        ),
+        u128,
+        ValueQuery,
+    >;
+
     #[pallet::event]
     #[pallet::generate_deposit(pub(super) fn deposit_event)]
     pub enum Event<T: Config> {
diff --git a/pallets/swap/src/position.rs b/pallets/swap/src/position.rs
index b3746c1fbc..6fad4eed3a 100644
--- a/pallets/swap/src/position.rs
+++ b/pallets/swap/src/position.rs
@@ -4,9 +4,9 @@ use safe_math::*;
 use substrate_fixed::types::U64F64;
 use uuid::Uuid;
 
-use crate::SqrtPrice;
-use crate::pallet::{Config, Error};
+use crate::pallet::{Config, Error, FeeGlobalAlpha, FeeGlobalTao};
 use crate::tick::TickIndex;
+use crate::{NetUid, SqrtPrice};
 
 /// Position designates one liquidity position.
 ///
@@ -21,6 +21,7 @@ use crate::tick::TickIndex;
 #[derive(Clone, Encode, Decode, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen, Default)]
 pub struct Position {
     pub id: PositionId,
+    pub netuid: NetUid,
     pub tick_low: TickIndex,
     pub tick_high: TickIndex,
     pub liquidity: u64,
@@ -88,6 +89,38 @@ impl Position {
             )
         })
     }
+
+    /// Collect fees for a position
+    /// Updates the position
+    pub fn collect_fees<T: Config>(&mut self) -> (u64, u64) {
+        let mut fee_tao = self.fees_in_range::<T>(true);
+        let mut fee_alpha = self.fees_in_range::<T>(false);
+
+        fee_tao = fee_tao.saturating_sub(self.fees_tao);
+        fee_alpha = fee_alpha.saturating_sub(self.fees_alpha);
+
+        self.fees_tao = fee_tao;
+        self.fees_alpha = fee_alpha;
+
+        fee_tao = self.liquidity.saturating_mul(fee_tao);
+        fee_alpha = self.liquidity.saturating_mul(fee_alpha);
+
+        (fee_tao, fee_alpha)
+    }
+
+    /// Get fees in a position's range
+    ///
+    /// If quote flag is true, Tao is returned, otherwise alpha.
+    fn fees_in_range<T: Config>(&self, quote: bool) -> u64 {
+        if quote {
+            FeeGlobalTao::<T>::get(self.netuid).unwrap_or_default()
+        } else {
+            FeeGlobalAlpha::<T>::get(self.netuid).unwrap_or_default()
+        }
+        .saturating_sub(self.tick_low.fees_below::<T>(self.netuid, quote))
+        .saturating_sub(self.tick_high.fees_above::<T>(self.netuid, quote))
+        .saturating_to_num::<u64>()
+    }
 }
 
 #[derive(
diff --git a/pallets/swap/src/swap.rs b/pallets/swap/src/swap.rs
index 9a58bf1f61..d06b56ab37 100644
--- a/pallets/swap/src/swap.rs
+++ b/pallets/swap/src/swap.rs
@@ -6,8 +6,9 @@ use safe_math::*;
 use substrate_fixed::types::U64F64;
 
 use crate::{
-    position::Position, RemoveLiquidityResult, SqrtPrice, SwapError,
-    tick::{Layer, Tick, TickIndex, TickIndexBitmap},
+    RemoveLiquidityResult, SqrtPrice, SwapError,
+    position::Position,
+    tick::{LayerLevel, Tick, TickIndex, TickIndexBitmap},
 };
 
 #[derive(Debug, PartialEq)]
@@ -750,19 +751,7 @@ where
     /// Updates the position
     ///
     fn collect_fees(&mut self, position: &mut Position) -> (u64, u64) {
-        let mut fee_tao = self.get_fees_in_range(position, true);
-        let mut fee_alpha = self.get_fees_in_range(position, false);
-
-        fee_tao = fee_tao.saturating_sub(position.fees_tao);
-        fee_alpha = fee_alpha.saturating_sub(position.fees_alpha);
-
-        position.fees_tao = fee_tao;
-        position.fees_alpha = fee_alpha;
-
-        fee_tao = position.liquidity.saturating_mul(fee_tao);
-        fee_alpha = position.liquidity.saturating_mul(fee_alpha);
-
-        (fee_tao, fee_alpha)
+        todo!("moved to Position::collect_fees")
     }
 
     /// Get fees in a position's range
@@ -770,84 +759,18 @@ where
     /// If quote flag is true, Tao is returned, otherwise alpha.
     ///
     fn get_fees_in_range(&mut self, position: &Position, quote: bool) -> u64 {
-        let i_lower = position.tick_low;
-        let i_upper = position.tick_high;
-
-        let fee_global = if quote {
-            self.state_ops.get_fee_global_tao()
-        } else {
-            self.state_ops.get_fee_global_alpha()
-        };
-
-        fee_global
-            .saturating_sub(self.get_fees_below(i_lower, quote))
-            .saturating_sub(self.get_fees_above(i_upper, quote))
-            .saturating_to_num::<u64>()
+        todo!("moved to Position::fees_in_range")
     }
 
     /// Get fees above a tick
     ///
     fn get_fees_above(&mut self, tick_index: TickIndex, quote: bool) -> U64F64 {
-        let maybe_tick_index = self.find_closest_lower_active_tick_index(tick_index);
-        let current_tick = self.get_current_tick_index();
-
-        if let Some(tick_index) = maybe_tick_index {
-            let tick = self
-                .state_ops
-                .get_tick_by_index(tick_index)
-                .unwrap_or_default();
-            if tick_index <= current_tick {
-                if quote {
-                    self.state_ops
-                        .get_fee_global_tao()
-                        .saturating_sub(tick.fees_out_tao)
-                } else {
-                    self.state_ops
-                        .get_fee_global_alpha()
-                        .saturating_sub(tick.fees_out_alpha)
-                }
-            } else {
-                if quote {
-                    tick.fees_out_tao
-                } else {
-                    tick.fees_out_alpha
-                }
-            }
-        } else {
-            U64F64::saturating_from_num(0)
-        }
+        todo!("moved to TickIndex::fees_above")
     }
 
     /// Get fees below a tick
     fn get_fees_below(&mut self, tick_index: TickIndex, quote: bool) -> U64F64 {
-        let maybe_tick_index = self.find_closest_lower_active_tick_index(tick_index);
-        let current_tick = self.get_current_tick_index();
-
-        if let Some(tick_index) = maybe_tick_index {
-            let tick = self
-                .state_ops
-                .get_tick_by_index(tick_index)
-                .unwrap_or_default();
-            if tick_index <= current_tick {
-                if quote {
-                    tick.fees_out_tao
-                } else {
-                    tick.fees_out_alpha
-                }
-            } else {
-                if quote {
-                    self.state_ops
-                        .get_fee_global_tao()
-                        .saturating_sub(tick.fees_out_tao)
-                } else {
-                    self.state_ops
-                        .get_fee_global_alpha()
-                        .saturating_sub(tick.fees_out_alpha)
-                }
-            }
-        } else {
-            U64F64::saturating_from_num(0)
-        }
+		todo!("moved to TickIndex::fees_below")
     }
 
     /// Active tick operations
@@ -866,71 +789,11 @@ where
     // Use TickIndexBitmap::layer_to_index instead
 
     pub fn insert_active_tick(&mut self, index: TickIndex) {
-        // Check the range
-        if (index < TickIndex::MIN) || (index > TickIndex::MAX) {
-            return;
-        }
-
-        // Convert to bitmap representation
-        let bitmap = TickIndexBitmap::from(index);
-
-        // Update layer words
-        let mut word0_value = self.state_ops.get_layer0_word(bitmap.word_at(Layer::Top));
-        let mut word1_value = self
-            .state_ops
-            .get_layer1_word(bitmap.word_at(Layer::Middle));
-        let mut word2_value = self
-            .state_ops
-            .get_layer2_word(bitmap.word_at(Layer::Bottom));
-
-        // Set bits in each layer
-        word0_value |= bitmap.bit_mask(Layer::Top);
-        word1_value |= bitmap.bit_mask(Layer::Middle);
-        word2_value |= bitmap.bit_mask(Layer::Bottom);
-
-        // Update the storage
-        self.state_ops
-            .set_layer0_word(bitmap.word_at(Layer::Top), word0_value);
-        self.state_ops
-            .set_layer1_word(bitmap.word_at(Layer::Middle), word1_value);
-        self.state_ops
-            .set_layer2_word(bitmap.word_at(Layer::Bottom), word2_value);
+		todo!("moved to ActiveTickIndexManager::insert")
     }
 
     pub fn remove_active_tick(&mut self, index: TickIndex) {
-        // Check the range
-        if (index < TickIndex::MIN) || (index > TickIndex::MAX) {
-            return;
-        }
-
-        // Convert to bitmap representation
-        let bitmap = TickIndexBitmap::from(index);
-
-        // Update layer words
-        let mut word0_value = self.state_ops.get_layer0_word(bitmap.word_at(Layer::Top));
-        let mut word1_value = self
-            .state_ops
-            .get_layer1_word(bitmap.word_at(Layer::Middle));
-        let mut word2_value = self
-            .state_ops
-            .get_layer2_word(bitmap.word_at(Layer::Bottom));
-
-        // Turn the bit off (& !bit) and save as needed
-        word2_value &= !bitmap.bit_mask(Layer::Bottom);
-        self.state_ops
-            .set_layer2_word(bitmap.word_at(Layer::Bottom), word2_value);
-
-        if word2_value == 0 {
-            word1_value &= !bitmap.bit_mask(Layer::Middle);
-            self.state_ops
-                .set_layer1_word(bitmap.word_at(Layer::Middle), word1_value);
-        }
-
-        if word1_value == 0 {
-            word0_value &= !bitmap.bit_mask(Layer::Top);
-            self.state_ops
-                .set_layer0_word(bitmap.word_at(Layer::Top), word0_value);
-        }
+		todo!("moved to ActiveTickIndexManager::remove")
     }
 
     pub fn find_closest_active_tick_index(
@@ -938,107 +801,15 @@ where
         index: TickIndex,
         lower: bool,
     ) -> Option<TickIndex> {
-        // Check the range
-        if (index < TickIndex::MIN) || (index > TickIndex::MAX) {
-            return None;
-        }
-
-        // Convert to bitmap representation
-        let bitmap = TickIndexBitmap::from(index);
-        let mut found = false;
-        let mut result: u32 = 0;
-
-        // Layer positions from bitmap
-        let layer0_word = bitmap.word_at(Layer::Top);
-        let layer0_bit = bitmap.bit_at(Layer::Top);
-        let layer1_word = bitmap.word_at(Layer::Middle);
-        let layer1_bit = bitmap.bit_at(Layer::Middle);
-        let layer2_word = bitmap.word_at(Layer::Bottom);
-        let layer2_bit = bitmap.bit_at(Layer::Bottom);
-
-        // Find the closest active bits in layer 0, then 1, then 2
-
-        ///////////////
-        // Level 0
-        let word0 = self.state_ops.get_layer0_word(layer0_word);
-        let closest_bits_l0 =
-            TickIndexBitmap::find_closest_active_bit_candidates(word0, layer0_bit, lower);
-
-        closest_bits_l0.iter().for_each(|&closest_bit_l0| {
-            ///////////////
-            // Level 1
-            let word1_index = TickIndexBitmap::layer_to_index(0, closest_bit_l0);
-
-            // Layer 1 words are different, shift the bit to the word edge
-            let start_from_l1_bit = if word1_index < layer1_word {
-                127
-            } else if word1_index > layer1_word {
-                0
-            } else {
-                layer1_bit
-            };
-            let word1_value = self.state_ops.get_layer1_word(word1_index);
-
-            let closest_bits_l1 = TickIndexBitmap::find_closest_active_bit_candidates(
-                word1_value,
-                start_from_l1_bit,
-                lower,
-            );
-            closest_bits_l1.iter().for_each(|&closest_bit_l1| {
-                ///////////////
-                // Level 2
-                let word2_index = TickIndexBitmap::layer_to_index(word1_index, closest_bit_l1);
-
-                // Layer 2 words are different, shift the bit to the word edge
-                let start_from_l2_bit = if word2_index < layer2_word {
-                    127
-                } else if word2_index > layer2_word {
-                    0
-                } else {
-                    layer2_bit
-                };
-
-                let word2_value = self.state_ops.get_layer2_word(word2_index);
-                let closest_bits_l2 = TickIndexBitmap::find_closest_active_bit_candidates(
-                    word2_value,
-                    start_from_l2_bit,
-                    lower,
-                );
-
-                if closest_bits_l2.len() > 0 {
-                    // The active tick is found, restore its full index and return
-                    let offset_found_index =
-                        TickIndexBitmap::layer_to_index(word2_index, closest_bits_l2[0]);
-
-                    if lower {
-                        if (offset_found_index > result) || (!found) {
-                            result = offset_found_index;
-                            found = true;
-                        }
-                    } else {
-                        if (offset_found_index < result) || (!found) {
-                            result = offset_found_index;
-                            found = true;
-                        }
-                    }
-                }
-            });
-        });
-
-        if !found {
-            return None;
-        }
-
-        // Convert the result offset_index back to a tick index
-        TickIndex::from_offset_index(result).ok()
+		todo!("moved to ActiveTickIndexManager::find_closet")
     }
 
     pub fn find_closest_lower_active_tick_index(&self, index: TickIndex) -> Option<TickIndex> {
-        self.find_closest_active_tick_index(index, true)
+        todo!("moved to ActiveTickIndexManager::find_closest_lower")
     }
 
     pub fn find_closest_higher_active_tick_index(&self, index: TickIndex) -> Option<TickIndex> {
-        self.find_closest_active_tick_index(index, false)
+        todo!("moved to ActiveTickIndexManager::find_closest_higher")
     }
 
     pub fn find_closest_lower_active_tick(&self, index: TickIndex) -> Option<Tick> {
@@ -1738,7 +1509,7 @@ mod tests {
         });
     }
 
-	// Test swapping against protocol liquidity only
+    // Test swapping against protocol liquidity only
     #[test]
     fn test_swap_basic() {
         let protocol_tao = 1_000_000_000;
@@ -1746,112 +1517,101 @@ mod tests {
 
         // Current price is 0.25
         // Test case is (order_type, liquidity, limit_price, output_amount)
-        [
-            (OrderType::Buy, 500_000_000u64, 1000.0_f64, 3990_u64),
-        ]
-        .iter()
-        .for_each(|(order_type, liquidity, limit_price, output_amount)| {
-            // Consumed liquidity ticks
-            let tick_low = TickIndex::MIN;
-            let tick_high = TickIndex::MAX;
-
-            // Setup swap
-            let mut mock_ops = MockSwapDataOperations::new();
-            mock_ops.set_tao_reserve(protocol_tao);
-            mock_ops.set_alpha_reserve(protocol_alpha);
-            let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
-
-            // Get tick infos before the swap
-            let tick_low_info_before = swap
-                .state_ops
-                .get_tick_by_index(tick_low)
-                .unwrap_or_default();
-            let tick_high_info_before = swap
-                .state_ops
-                .get_tick_by_index(tick_high)
-                .unwrap_or_default();
-            let liquidity_before = swap.state_ops.get_current_liquidity();
-
-            // Swap
-            let sqrt_limit_price: SqrtPrice = SqrtPrice::from_num((*limit_price).sqrt());
-            let swap_result = swap.swap(order_type, *liquidity, sqrt_limit_price);
-            // assert_abs_diff_eq!(
-            //     swap_result.unwrap().amount_paid_out,
-            //     *output_amount,
-            //     epsilon = *output_amount/1000
-            // );
-
-            // Check that low and high ticks' fees were updated properly, and liquidity values were not updated
-            let tick_low_info = swap.state_ops.get_tick_by_index(tick_low).unwrap();
-            let tick_high_info = swap.state_ops.get_tick_by_index(tick_high).unwrap();
-            let expected_liquidity_net_low: i128 = tick_low_info_before.liquidity_net;
-            let expected_liquidity_gross_low: u64 = tick_low_info_before.liquidity_gross;
-            let expected_liquidity_net_high: i128 = tick_high_info_before.liquidity_net;
-            let expected_liquidity_gross_high: u64 = tick_high_info_before.liquidity_gross;
-            assert_eq!(
-                tick_low_info.liquidity_net,
-                expected_liquidity_net_low,
-            );
-            assert_eq!(
-                tick_low_info.liquidity_gross,
-                expected_liquidity_gross_low,
-            );
-            assert_eq!(
-                tick_high_info.liquidity_net,
-                expected_liquidity_net_high,
-            );
-            assert_eq!(
-                tick_high_info.liquidity_gross,
-                expected_liquidity_gross_high,
-            );
-
-            // Expected fee amount
-            let fee_rate = swap.state_ops.get_fee_rate() as f64 / u16::MAX as f64;
-            let expected_fee = output_amount * fee_rate as u64;
-
-            // Global fees should be updated
-            let actual_global_fee: U64F64 = match order_type {
-                OrderType::Buy => swap.state_ops.get_fee_global_alpha(),
-                OrderType::Sell => swap.state_ops.get_fee_global_tao(),
-            };
-            println!("actual_global_fee {:?}", actual_global_fee);
-            assert_eq!(actual_global_fee, expected_fee);
-
-            // Tick fees should be updated
-
+        [(OrderType::Buy, 500_000_000u64, 1000.0_f64, 3990_u64)]
+            .iter()
+            .for_each(|(order_type, liquidity, limit_price, output_amount)| {
+                // Consumed liquidity ticks
+                let tick_low = TickIndex::MIN;
+                let tick_high = TickIndex::MAX;
+
+                // Setup swap
+                let mut mock_ops = MockSwapDataOperations::new();
+                mock_ops.set_tao_reserve(protocol_tao);
+                mock_ops.set_alpha_reserve(protocol_alpha);
+                let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
+
+                // Get tick infos before the swap
+                let tick_low_info_before = swap
+                    .state_ops
+                    .get_tick_by_index(tick_low)
+                    .unwrap_or_default();
+                let tick_high_info_before = swap
+                    .state_ops
+                    .get_tick_by_index(tick_high)
+                    .unwrap_or_default();
+                let liquidity_before = swap.state_ops.get_current_liquidity();
+
+                // Swap
+                let sqrt_limit_price: SqrtPrice = SqrtPrice::from_num((*limit_price).sqrt());
+                let swap_result = swap.swap(order_type, *liquidity, sqrt_limit_price);
+                // assert_abs_diff_eq!(
+                //     swap_result.unwrap().amount_paid_out,
+                //     *output_amount,
+                //     epsilon = *output_amount/1000
+                // );
+
+                // Check that low and high ticks' fees were updated properly, and liquidity values were not updated
+                let tick_low_info = swap.state_ops.get_tick_by_index(tick_low).unwrap();
+                let tick_high_info = swap.state_ops.get_tick_by_index(tick_high).unwrap();
+                let expected_liquidity_net_low: i128 = tick_low_info_before.liquidity_net;
+                let expected_liquidity_gross_low: u64 = tick_low_info_before.liquidity_gross;
+                let expected_liquidity_net_high: i128 = tick_high_info_before.liquidity_net;
+                let expected_liquidity_gross_high: u64 = tick_high_info_before.liquidity_gross;
+                assert_eq!(tick_low_info.liquidity_net, expected_liquidity_net_low,);
+                assert_eq!(tick_low_info.liquidity_gross, expected_liquidity_gross_low,);
+                assert_eq!(tick_high_info.liquidity_net, expected_liquidity_net_high,);
+                assert_eq!(
+                    tick_high_info.liquidity_gross,
+                    expected_liquidity_gross_high,
+                );
 
+                // Expected fee amount
+                let fee_rate = swap.state_ops.get_fee_rate() as f64 / u16::MAX as f64;
+                let expected_fee = output_amount * fee_rate as u64;
 
+                // Global fees should be updated
+                let actual_global_fee: U64F64 = match order_type {
+                    OrderType::Buy => swap.state_ops.get_fee_global_alpha(),
+                    OrderType::Sell => swap.state_ops.get_fee_global_tao(),
+                };
+                println!("actual_global_fee {:?}", actual_global_fee);
+                assert_eq!(actual_global_fee, expected_fee);
 
-            // Liquidity position should not be updated
-            let protocol_id = swap.state_ops.get_protocol_account_id();
+                // Tick fees should be updated
 
-            let position = swap.state_ops.get_position(&protocol_id, 0).unwrap();
-            assert_eq!(position.liquidity, sqrt(protocol_tao as u128 * protocol_alpha as u128) as u64);
-            assert_eq!(position.tick_low, tick_low);
-            assert_eq!(position.tick_high, tick_high);
-            assert_eq!(position.fees_alpha, 0);
-            assert_eq!(position.fees_tao, 0);
+                // Liquidity position should not be updated
+                let protocol_id = swap.state_ops.get_protocol_account_id();
 
-            // // Current liquidity is updated only when price range includes the current price
-            // if (*price_high >= current_price) && (*price_low <= current_price) {
-            //     assert_eq!(
-            //         swap.state_ops.get_current_liquidity(),
-            //         liquidity_before + *liquidity
-            //     );
-            // } else {
-            //     assert_eq!(swap.state_ops.get_current_liquidity(), liquidity_before);
-            // }
-
-            // // Reserves are updated
-            // assert_eq!(
-            //     swap.state_ops.get_tao_reserve(),
-            //     tao_withdrawn + protocol_tao,
-            // );
-            // assert_eq!(
-            //     swap.state_ops.get_alpha_reserve(),
-            //     alpha_withdrawn + protocol_alpha,
-            // );
-        });
+                let position = swap.state_ops.get_position(&protocol_id, 0).unwrap();
+                assert_eq!(
+                    position.liquidity,
+                    sqrt(protocol_tao as u128 * protocol_alpha as u128) as u64
+                );
+                assert_eq!(position.tick_low, tick_low);
+                assert_eq!(position.tick_high, tick_high);
+                assert_eq!(position.fees_alpha, 0);
+                assert_eq!(position.fees_tao, 0);
+
+                // // Current liquidity is updated only when price range includes the current price
+                // if (*price_high >= current_price) && (*price_low <= current_price) {
+                //     assert_eq!(
+                //         swap.state_ops.get_current_liquidity(),
+                //         liquidity_before + *liquidity
+                //     );
+                // } else {
+                //     assert_eq!(swap.state_ops.get_current_liquidity(), liquidity_before);
+                // }
+
+                // // Reserves are updated
+                // assert_eq!(
+                //     swap.state_ops.get_tao_reserve(),
+                //     tao_withdrawn + protocol_tao,
+                // );
+                // assert_eq!(
+                //     swap.state_ops.get_alpha_reserve(),
+                //     alpha_withdrawn + protocol_alpha,
+                // );
+            });
     }
 
     // cargo test --package pallet-subtensor-swap --lib -- tests::test_tick_search_basic --exact --show-output
diff --git a/pallets/swap/src/tick.rs b/pallets/swap/src/tick.rs
index 9a21dd70d4..cbc803a942 100644
--- a/pallets/swap/src/tick.rs
+++ b/pallets/swap/src/tick.rs
@@ -6,11 +6,15 @@ use core::hash::Hash;
 use core::ops::{Add, AddAssign, BitOr, Deref, Neg, Shl, Shr, Sub, SubAssign};
 
 use alloy_primitives::{I256, U256};
+use codec::{Decode, Encode, MaxEncodedLen};
 use frame_support::pallet_prelude::*;
 use safe_math::*;
 use substrate_fixed::types::U64F64;
 
-use crate::SqrtPrice;
+use crate::pallet::{
+    Config, CurrentTickIndex, FeeGlobalAlpha, FeeGlobalTao, TickIndexBitmapWords, Ticks,
+};
+use crate::{NetUid, SqrtPrice};
 
 const U256_1: U256 = U256::from_limbs([1, 0, 0, 0]);
 const U256_2: U256 = U256::from_limbs([2, 0, 0, 0]);
@@ -174,6 +178,61 @@ impl TickIndex {
     /// so that tick indexes are positive, which simplifies bit logic
     const OFFSET: Self = Self(MAX_TICK);
 
+    /// Get fees above a tick
+    pub fn fees_above<T: Config>(&self, netuid: NetUid, quote: bool) -> U64F64 {
+        let current_tick = CurrentTickIndex::<T>::get(netuid).unwrap_or_default();
+
+        let Some(tick_index) = ActiveTickIndexManager::find_closest_lower::<T>(netuid, *self)
+        else {
+            return U64F64::from_num(0);
+        };
+
+        let tick = Ticks::<T>::get(netuid, tick_index).unwrap_or_default();
+        if tick_index <= current_tick {
+            if quote {
+                FeeGlobalTao::<T>::get(netuid)
+                    .unwrap_or_default()
+                    .saturating_sub(tick.fees_out_tao)
+            } else {
+                FeeGlobalAlpha::<T>::get(netuid)
+                    .unwrap_or_default()
+                    .saturating_sub(tick.fees_out_alpha)
+            }
+        } else if quote {
+            tick.fees_out_tao
+        } else {
+            tick.fees_out_alpha
+        }
+    }
+
+    /// Get fees below a tick
+    pub fn fees_below<T: Config>(&self, netuid: NetUid, quote: bool) -> U64F64 {
+        let current_tick = CurrentTickIndex::<T>::get(netuid).unwrap_or_default();
+
+        let Some(tick_index) = ActiveTickIndexManager::find_closest_lower::<T>(netuid, *self)
+        else {
+            return U64F64::saturating_from_num(0);
+        };
+
+        let tick = Ticks::<T>::get(netuid, tick_index).unwrap_or_default();
+
+        if tick_index <= current_tick {
+            if quote {
+                tick.fees_out_tao
+            } else {
+                tick.fees_out_alpha
+            }
+        } else if quote {
+            FeeGlobalTao::<T>::get(netuid)
+                .unwrap_or_default()
+                .saturating_sub(tick.fees_out_tao)
+        } else {
+            FeeGlobalAlpha::<T>::get(netuid)
+                .unwrap_or_default()
+                .saturating_sub(tick.fees_out_alpha)
+        }
+    }
+
     /// Converts a sqrt price to a tick index, ensuring it's within valid bounds
     ///
     /// If the price is outside the valid range, this function will return the appropriate boundary
@@ -375,9 +434,233 @@ impl TickIndex {
     }
 }
 
+pub struct ActiveTickIndexManager;
+
+impl ActiveTickIndexManager {
+    pub fn insert<T: Config>(netuid: NetUid, index: TickIndex) {
+        // Check the range
+        if (index < TickIndex::MIN) || (index > TickIndex::MAX) {
+            return;
+        }
+
+        // Convert to bitmap representation
+        let bitmap = TickIndexBitmap::from(index);
+
+        // Update layer words
+        let mut word0_value = TickIndexBitmapWords::<T>::get((
+            netuid,
+            LayerLevel::Top,
+            bitmap.word_at(LayerLevel::Top),
+        ));
+        let mut word1_value = TickIndexBitmapWords::<T>::get((
+            netuid,
+            LayerLevel::Middle,
+            bitmap.word_at(LayerLevel::Middle),
+        ));
+        let mut word2_value = TickIndexBitmapWords::<T>::get((
+            netuid,
+            LayerLevel::Bottom,
+            bitmap.word_at(LayerLevel::Bottom),
+        ));
+
+        // Set bits in each layer
+        word0_value |= bitmap.bit_mask(LayerLevel::Top);
+        word1_value |= bitmap.bit_mask(LayerLevel::Middle);
+        word2_value |= bitmap.bit_mask(LayerLevel::Bottom);
+
+        // Update the storage
+        TickIndexBitmapWords::<T>::set(
+            (netuid, LayerLevel::Top, bitmap.word_at(LayerLevel::Top)),
+            word0_value,
+        );
+        TickIndexBitmapWords::<T>::set(
+            (
+                netuid,
+                LayerLevel::Middle,
+                bitmap.word_at(LayerLevel::Middle),
+            ),
+            word1_value,
+        );
+        TickIndexBitmapWords::<T>::set(
+            (
+                netuid,
+                LayerLevel::Bottom,
+                bitmap.word_at(LayerLevel::Bottom),
+            ),
+            word2_value,
+        );
+    }
+
+    pub fn remove<T: Config>(netuid: NetUid, index: TickIndex) {
+        // Check the range
+        if (index < TickIndex::MIN) || (index > TickIndex::MAX) {
+            return;
+        }
+
+        // Convert to bitmap representation
+        let bitmap = TickIndexBitmap::from(index);
+
+        // Update layer words
+        let mut word0_value = TickIndexBitmapWords::<T>::get((
+            netuid,
+            LayerLevel::Top,
+            bitmap.word_at(LayerLevel::Top),
+        ));
+        let mut word1_value = TickIndexBitmapWords::<T>::get((
+            netuid,
+            LayerLevel::Middle,
+            bitmap.word_at(LayerLevel::Middle),
+        ));
+        let mut word2_value = TickIndexBitmapWords::<T>::get((
+            netuid,
+            LayerLevel::Bottom,
+            bitmap.word_at(LayerLevel::Bottom),
+        ));
+
+        // Turn the bit off (& !bit) and save as needed
+        word2_value &= !bitmap.bit_mask(LayerLevel::Bottom);
+        TickIndexBitmapWords::<T>::set(
+            (
+                netuid,
+                LayerLevel::Bottom,
+                bitmap.word_at(LayerLevel::Bottom),
+            ),
+            word2_value,
+        );
+
+        if word2_value == 0 {
+            word1_value &= !bitmap.bit_mask(LayerLevel::Middle);
+            TickIndexBitmapWords::<T>::set(
+                (
+                    netuid,
+                    LayerLevel::Middle,
+                    bitmap.word_at(LayerLevel::Middle),
+                ),
+                word1_value,
+            );
+        }
+
+        if word1_value == 0 {
+            word0_value &= !bitmap.bit_mask(LayerLevel::Top);
+            TickIndexBitmapWords::<T>::set(
+                (netuid, LayerLevel::Top, bitmap.word_at(LayerLevel::Top)),
+                word0_value,
+            );
+        }
+    }
+
+    pub fn find_closest_lower<T: Config>(netuid: NetUid, index: TickIndex) -> Option<TickIndex> {
+        Self::find_closest::<T>(netuid, index, true)
+    }
+
+    pub fn find_closest_higher<T: Config>(netuid: NetUid, index: TickIndex) -> Option<TickIndex> {
+        Self::find_closest::<T>(netuid, index, false)
+    }
+
+    fn find_closest<T: Config>(netuid: NetUid, index: TickIndex, lower: bool) -> Option<TickIndex> {
+        // Check the range
+        if (index < TickIndex::MIN) || (index > TickIndex::MAX) {
+            return None;
+        }
+
+        // Convert to bitmap representation
+        let bitmap = TickIndexBitmap::from(index);
+        let mut found = false;
+        let mut result: u32 = 0;
+
+        // Layer positions from bitmap
+        let layer0_word = bitmap.word_at(LayerLevel::Top);
+        let layer0_bit = bitmap.bit_at(LayerLevel::Top);
+        let layer1_word = bitmap.word_at(LayerLevel::Middle);
+        let layer1_bit = bitmap.bit_at(LayerLevel::Middle);
+        let layer2_word = bitmap.word_at(LayerLevel::Bottom);
+        let layer2_bit = bitmap.bit_at(LayerLevel::Bottom);
+
+        // Find the closest active bits in layer 0, then 1, then 2
+
+        ///////////////
+        // Level 0
+        let word0 = TickIndexBitmapWords::<T>::get((netuid, LayerLevel::Top, layer0_word));
+        let closest_bits_l0 =
+            TickIndexBitmap::find_closest_active_bit_candidates(word0, layer0_bit, lower);
+
+        for closest_bit_l0 in closest_bits_l0.iter() {
+            ///////////////
+            // Level 1
+            let word1_index = TickIndexBitmap::layer_to_index(BitmapLayer::new(0, *closest_bit_l0));
+
+            // Layer 1 words are different, shift the bit to the word edge
+            let start_from_l1_bit = if word1_index < layer1_word {
+                127
+            } else if word1_index > layer1_word {
+                0
+            } else {
+                layer1_bit
+            };
+            let word1_value =
+                TickIndexBitmapWords::<T>::get((netuid, LayerLevel::Middle, word1_index));
+            let closest_bits_l1 = TickIndexBitmap::find_closest_active_bit_candidates(
+                word1_value,
+                start_from_l1_bit,
+                lower,
+            );
+
+            for closest_bit_l1 in closest_bits_l1.iter() {
+                ///////////////
+                // Level 2
+                let word2_index =
+                    TickIndexBitmap::layer_to_index(BitmapLayer::new(word1_index, *closest_bit_l1));
+
+                // Layer 2 words are different, shift the bit to the word edge
+                let start_from_l2_bit = if word2_index < layer2_word {
+                    127
+                } else if word2_index > layer2_word {
+                    0
+                } else {
+                    layer2_bit
+                };
+
+                let word2_value =
+                    TickIndexBitmapWords::<T>::get((netuid, LayerLevel::Bottom, word2_index));
+
+                let closest_bits_l2 = TickIndexBitmap::find_closest_active_bit_candidates(
+                    word2_value,
+                    start_from_l2_bit,
+                    lower,
+                );
+
+                if closest_bits_l2.len() > 0 {
+                    // The active tick is found, restore its full index and return
+                    let offset_found_index = TickIndexBitmap::layer_to_index(BitmapLayer::new(
+                        word2_index,
+                        closest_bits_l2[0],
+                    ));
+
+                    if lower {
+                        if (offset_found_index > result) || (!found) {
+                            result = offset_found_index;
+                            found = true;
+                        }
+                    } else if (offset_found_index < result) || (!found) {
+                        result = offset_found_index;
+                        found = true;
+                    }
+                }
+            }
+        }
+
+        if !found {
+            return None;
+        }
+
+        // Convert the result offset_index back to a tick index
+        TickIndex::from_offset_index(result).ok()
+    }
+}
+
 /// Represents the three layers in the Uniswap V3 bitmap structure
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum Layer {
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Encode, Decode, TypeInfo, MaxEncodedLen)]
+pub enum LayerLevel {
     /// Top layer (highest level of the hierarchy)
     Top = 0,
     /// Middle layer
@@ -386,15 +669,27 @@ pub enum Layer {
     Bottom = 2,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Encode, Decode, TypeInfo, MaxEncodedLen)]
+struct BitmapLayer {
+    word: u32,
+    bit: u32,
+}
+
+impl BitmapLayer {
+    pub fn new(word: u32, bit: u32) -> Self {
+        Self { word, bit }
+    }
+}
+
 /// A bitmap representation of a tick index position across the three-layer structure
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct TickIndexBitmap {
     /// The position in layer 0 (top layer)
-    layer0: (u32, u32), // (word, bit)
+    layer0: BitmapLayer,
     /// The position in layer 1 (middle layer)
-    layer1: (u32, u32), // (word, bit)
+    layer1: BitmapLayer,
     /// The position in layer 2 (bottom layer)
-    layer2: (u32, u32), // (word, bit)
+    layer2: BitmapLayer,
 }
 
 impl TickIndexBitmap {
@@ -403,42 +698,42 @@ impl TickIndexBitmap {
     ///
     /// Note: This function operates on bitmap navigation indices, NOT tick indices.
     /// It converts a flat index within the bitmap structure to a (word, bit) position.
-    fn index_to_layer(index: u32) -> (u32, u32) {
+    fn index_to_layer(index: u32) -> BitmapLayer {
         let word = index.safe_div(128);
         let bit = index.checked_rem(128).unwrap_or_default();
-        (word, bit)
+        BitmapLayer { word, bit }
     }
 
     /// Converts a position (word, bit) within a layer to a word index in the next layer down
     /// Note: This returns a bitmap navigation index, NOT a tick index
-    pub fn layer_to_index(word: u32, bit: u32) -> u32 {
-        word.saturating_mul(128).saturating_add(bit)
+    pub fn layer_to_index(layer: BitmapLayer) -> u32 {
+        layer.word.saturating_mul(128).saturating_add(layer.bit)
     }
 
     /// Get the mask for a bit in the specified layer
-    pub fn bit_mask(&self, layer: Layer) -> u128 {
+    pub fn bit_mask(&self, layer: LayerLevel) -> u128 {
         match layer {
-            Layer::Top => 1u128 << self.layer0.1,
-            Layer::Middle => 1u128 << self.layer1.1,
-            Layer::Bottom => 1u128 << self.layer2.1,
+            LayerLevel::Top => 1u128 << self.layer0.bit,
+            LayerLevel::Middle => 1u128 << self.layer1.bit,
+            LayerLevel::Bottom => 1u128 << self.layer2.bit,
         }
     }
 
     /// Get the word for the specified layer
-    pub fn word_at(&self, layer: Layer) -> u32 {
+    pub fn word_at(&self, layer: LayerLevel) -> u32 {
         match layer {
-            Layer::Top => self.layer0.0,
-            Layer::Middle => self.layer1.0,
-            Layer::Bottom => self.layer2.0,
+            LayerLevel::Top => self.layer0.word,
+            LayerLevel::Middle => self.layer1.word,
+            LayerLevel::Bottom => self.layer2.word,
         }
     }
 
     /// Get the bit for the specified layer
-    pub fn bit_at(&self, layer: Layer) -> u32 {
+    pub fn bit_at(&self, layer: LayerLevel) -> u32 {
         match layer {
-            Layer::Top => self.layer0.1,
-            Layer::Middle => self.layer1.1,
-            Layer::Bottom => self.layer2.1,
+            LayerLevel::Top => self.layer0.bit,
+            LayerLevel::Middle => self.layer1.bit,
+            LayerLevel::Bottom => self.layer2.bit,
         }
     }
 
@@ -488,8 +783,8 @@ impl From<TickIndex> for TickIndexBitmap {
 
         // Calculate layer positions
         let layer2 = Self::index_to_layer(offset_index);
-        let layer1 = Self::index_to_layer(layer2.0);
-        let layer0 = Self::index_to_layer(layer1.0);
+        let layer1 = Self::index_to_layer(layer2.word);
+        let layer0 = Self::index_to_layer(layer1.word);
 
         Self {
             layer0,

From dd4c722c3d4073b8f3219ca69fcba3c061f844a0 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Fri, 28 Mar 2025 13:45:37 +0100
Subject: [PATCH 040/418] Move Swap::remove_liquidity to Pallet

---
 pallets/swap/src/pallet/impls.rs | 155 ++++++++++++++++++-------------
 pallets/swap/src/pallet/mod.rs   |   4 -
 pallets/swap/src/swap.rs         |  50 ++--------
 pallets/swap/src/tick.rs         |  12 ++-
 4 files changed, 103 insertions(+), 118 deletions(-)

diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index e1a9c742aa..9cfe961be5 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -99,7 +99,7 @@ impl<T: Config> Pallet<T> {
         Self::add_liquidity_at_index(netuid, tick_high, liquidity, true);
 
         // Update current tick liquidity
-        let current_tick_index = Self::bounded_current_tick_index(netuid);
+        let current_tick_index = TickIndex::current_bounded::<T>(netuid);
         Self::clamp_sqrt_price(netuid, current_tick_index);
 
         Self::update_liquidity_if_needed(netuid, tick_low, tick_high, liquidity as i128);
@@ -141,6 +141,63 @@ impl<T: Config> Pallet<T> {
         Ok((tao, alpha))
     }
 
+    /// Remove liquidity and credit balances back to account_id
+    ///
+    /// Account ID and Position ID identify position in the storage map
+    pub fn remove_liquidity(
+        netuid: NetUid,
+        account_id: &T::AccountId,
+        position_id: PositionId,
+    ) -> Result<RemoveLiquidityResult, Error<T>> {
+        let Some(mut pos) = Positions::<T>::get((netuid, account_id, position_id)) else {
+            return Err(Error::<T>::LiquidityNotFound);
+        };
+        let current_tick_index = TickIndex::current_bounded::<T>(netuid);
+
+        // Collect fees and get tao and alpha amounts
+        let (fee_tao, fee_alpha) = pos.collect_fees::<T>();
+        let current_price = AlphaSqrtPrice::<T>::get(netuid);
+        let (tao, alpha) = pos.to_token_amounts(current_price)?;
+
+        // Update liquidity at position ticks
+        Self::remove_liquidity_at_index(netuid, pos.tick_low, pos.liquidity, false);
+        Self::remove_liquidity_at_index(netuid, pos.tick_high, pos.liquidity, true);
+
+        // Update current tick liquidity
+        Self::update_liquidity_if_needed(
+            netuid,
+            pos.tick_low,
+            pos.tick_high,
+            -(pos.liquidity as i128),
+        );
+
+        // Remove user position
+        Positions::<T>::remove((netuid, account_id, position_id));
+
+        {
+            // TODO we move this logic to the outside depender to prevent mutating its state
+            //     // Deposit balances
+            //     self.state_ops.deposit_balances(account_id, tao, alpha);
+
+            //     // Update reserves
+            //     let new_tao_reserve = self.state_ops.get_tao_reserve().saturating_sub(tao);
+            //     self.state_ops.set_tao_reserve(new_tao_reserve);
+            //     let new_alpha_reserve = self.state_ops.get_alpha_reserve().saturating_sub(alpha);
+            //     self.state_ops.set_alpha_reserve(new_alpha_reserve);
+        }
+
+        // TODO: Clear with R&D
+        // Update current price (why?)
+        // AlphaSqrtPrice::<T>::set(netuid, sqrt_price);
+
+        Ok(RemoveLiquidityResult {
+            tao,
+            alpha,
+            fee_tao,
+            fee_alpha,
+        })
+    }
+
     /// Adds or updates liquidity at a specific tick index for a subnet
     ///
     /// # Arguments
@@ -171,75 +228,31 @@ impl<T: Config> Pallet<T> {
         });
     }
 
-    /// Remove liquidity and credit balances back to account_id
-    ///
-    /// Account ID and Position ID identify position in the storage map
-    pub fn remove_liquidity(
+    /// Remove liquidity at tick index.
+    fn remove_liquidity_at_index(
         netuid: NetUid,
-        account_id: &T::AccountId,
-        position_id: PositionId,
-    ) -> Result<RemoveLiquidityResult, Error<T>> {
-        let Some(mut pos) = Positions::<T>::get((netuid, account_id, position_id)) else {
-            return Err(Error::<T>::LiquidityNotFound);
+        tick_index: TickIndex,
+        liquidity: u64,
+        upper: bool,
+    ) {
+        // Calculate net liquidity addition
+        let net_reduction = if upper {
+            -(liquidity as i128)
+        } else {
+            liquidity as i128
         };
-        let current_tick_index = CurrentTickIndex::<T>::get(netuid);
-
-        // Collect fees and get tao and alpha amounts
-        let (fee_tao, fee_alpha) = pos.collect_fees::<T>();
-        //     let current_price: SqrtPrice = self.state_ops.get_alpha_sqrt_price();
-        //     let (tao, alpha) = pos.to_token_amounts(current_price)?;
-
-        //     // Update liquidity at position ticks
-        //     self.remove_liquidity_at_index(pos.tick_low, pos.liquidity, false);
-        //     self.remove_liquidity_at_index(pos.tick_high, pos.liquidity, true);
-
-        //     // Update current tick liquidity
-        //     if (pos.tick_low <= current_tick_index) && (current_tick_index <= pos.tick_high) {
-        //         let new_current_liquidity = self
-        //             .state_ops
-        //             .get_current_liquidity()
-        //             .saturating_sub(pos.liquidity);
-        //         self.state_ops.set_current_liquidity(new_current_liquidity);
-        //     }
 
-        //     // Remove user position
-        //     self.state_ops.remove_position(account_id, position_id);
+        Ticks::<T>::mutate_exists(netuid, tick_index, |maybe_tick| {
+            if let Some(tick) = maybe_tick {
+                tick.liquidity_net = tick.liquidity_net.saturating_sub(net_reduction);
+                tick.liquidity_gross = tick.liquidity_gross.saturating_sub(liquidity);
 
-        //     // Deposit balances
-        //     self.state_ops.deposit_balances(account_id, tao, alpha);
-
-        //     // Update reserves
-        //     let new_tao_reserve = self.state_ops.get_tao_reserve().saturating_sub(tao);
-        //     self.state_ops.set_tao_reserve(new_tao_reserve);
-        //     let new_alpha_reserve = self.state_ops.get_alpha_reserve().saturating_sub(alpha);
-        //     self.state_ops.set_alpha_reserve(new_alpha_reserve);
-
-        //     // TODO: Clear with R&D
-        //     // Update current price (why?)
-        //     // self.state_ops.set_alpha_sqrt_price(sqrt_price);
-
-        //     // Return Ok result
-        //     Ok(RemoveLiquidityResult {
-        //         tao,
-        //         alpha,
-        //         fee_tao,
-        //         fee_alpha,
-        //     })
-        todo!()
-    }
-
-    /// Gets the current tick index for a subnet, ensuring it's within valid bounds
-    fn bounded_current_tick_index(netuid: NetUid) -> TickIndex {
-        let current_price = AlphaSqrtPrice::<T>::get(netuid);
-        TickIndex::from_sqrt_price_bounded(current_price)
-    }
-
-    /// Clamps the subnet's sqrt price when tick index is outside of valid bounds
-    fn clamp_sqrt_price(netuid: NetUid, tick_index: TickIndex) {
-        if tick_index >= TickIndex::MAX || tick_index <= TickIndex::MIN {
-            let corrected_price = tick_index.to_sqrt_price_bounded();
-            AlphaSqrtPrice::<T>::set(netuid, corrected_price);
-        }
+                // If no liquidity is left at the tick, remove it
+                if tick.liquidity_gross == 0 {
+                    *maybe_tick = None;
+                }
+            }
+        });
     }
 
     /// Updates the current liquidity for a subnet if the current tick index is within the specified
@@ -254,7 +267,7 @@ impl<T: Config> Pallet<T> {
         tick_high: TickIndex,
         liquidity: i128,
     ) {
-        let current_tick_index = Self::bounded_current_tick_index(netuid);
+        let current_tick_index = TickIndex::current_bounded::<T>(netuid);
         if (tick_low <= current_tick_index) && (current_tick_index <= tick_high) {
             CurrentLiquidity::<T>::mutate(netuid, |current_liquidity| {
                 let is_neg = liquidity.is_negative();
@@ -268,6 +281,14 @@ impl<T: Config> Pallet<T> {
         }
     }
 
+    /// Clamps the subnet's sqrt price when tick index is outside of valid bounds
+    fn clamp_sqrt_price(netuid: NetUid, tick_index: TickIndex) {
+        if tick_index >= TickIndex::MAX || tick_index <= TickIndex::MIN {
+            let corrected_price = tick_index.to_sqrt_price_bounded();
+            AlphaSqrtPrice::<T>::set(netuid, corrected_price);
+        }
+    }
+
     /// Returns the number of positions for an account in a specific subnet
     ///
     /// # Arguments
diff --git a/pallets/swap/src/pallet/mod.rs b/pallets/swap/src/pallet/mod.rs
index 364ffe1d3f..f6ddb8afe4 100644
--- a/pallets/swap/src/pallet/mod.rs
+++ b/pallets/swap/src/pallet/mod.rs
@@ -69,10 +69,6 @@ mod pallet {
     #[pallet::storage]
     pub type CurrentLiquidity<T> = StorageMap<_, Twox64Concat, NetUid, u64, ValueQuery>;
 
-    /// Storage for the current tick index for each subnet.
-    #[pallet::storage]
-    pub type CurrentTickIndex<T> = StorageMap<_, Twox64Concat, NetUid, TickIndex>;
-
     /// Storage for user positions, using subnet ID and account ID as keys
     /// The value is a bounded vector of Position structs with details about the liquidity positions
     #[pallet::storage]
diff --git a/pallets/swap/src/swap.rs b/pallets/swap/src/swap.rs
index d06b56ab37..54a22e2cfb 100644
--- a/pallets/swap/src/swap.rs
+++ b/pallets/swap/src/swap.rs
@@ -154,25 +154,7 @@ where
     /// Remove liquidity at tick index.
     ///
     fn remove_liquidity_at_index(&mut self, tick_index: TickIndex, liquidity: u64, upper: bool) {
-        // Calculate net liquidity addition
-        let net_reduction = if upper {
-            (liquidity as i128).neg()
-        } else {
-            liquidity as i128
-        };
-
-        // Find tick by index
-        if let Some(mut tick) = self.state_ops.get_tick_by_index(tick_index) {
-            tick.liquidity_net = tick.liquidity_net.saturating_sub(net_reduction);
-            tick.liquidity_gross = tick.liquidity_gross.saturating_sub(liquidity);
-
-            // If any liquidity is left at the tick, update it, otherwise remove
-            if tick.liquidity_gross == 0 {
-                self.state_ops.remove_tick_by_index(tick_index);
-            } else {
-                self.state_ops.insert_tick_by_index(tick_index, tick);
-            }
-        };
+        todo!("moved to Pallet::remove_liquidity_at_index");
     }
 
     /// Adds liquidity to the specified price range.
@@ -349,27 +331,7 @@ where
     }
 
     fn get_current_tick_index(&mut self) -> TickIndex {
-        let current_price = self.state_ops.get_alpha_sqrt_price();
-        let maybe_current_tick_index = TickIndex::try_from_sqrt_price(current_price);
-        if let Ok(index) = maybe_current_tick_index {
-            index
-        } else {
-            // Current price is out of allow the min-max range, and it should be corrected to
-            // maintain the range.
-            let max_price = TickIndex::MAX
-                .try_to_sqrt_price()
-                .unwrap_or(SqrtPrice::saturating_from_num(1000));
-            let min_price = TickIndex::MIN
-                .try_to_sqrt_price()
-                .unwrap_or(SqrtPrice::saturating_from_num(0.000001));
-            if current_price > max_price {
-                self.state_ops.set_alpha_sqrt_price(max_price);
-                TickIndex::MAX
-            } else {
-                self.state_ops.set_alpha_sqrt_price(min_price);
-                TickIndex::MIN
-            }
-        }
+        todo!("moved to TickIndex::current_bounded")
     }
 
     /// Process a single step of a swap
@@ -770,7 +732,7 @@ where
 
     /// Get fees below a tick
     fn get_fees_below(&mut self, tick_index: TickIndex, quote: bool) -> U64F64 {
-		todo!("moved to TickIndex::fees_below")
+        todo!("moved to TickIndex::fees_below")
     }
 
     /// Active tick operations
@@ -789,11 +751,11 @@ where
     // Use TickIndexBitmap::layer_to_index instead
 
     pub fn insert_active_tick(&mut self, index: TickIndex) {
-		todo!("moved to ActiveTickIndexManager::insert")
+        todo!("moved to ActiveTickIndexManager::insert")
     }
 
     pub fn remove_active_tick(&mut self, index: TickIndex) {
-		todo!("moved to ActiveTickIndexManager::remove")
+        todo!("moved to ActiveTickIndexManager::remove")
     }
 
     pub fn find_closest_active_tick_index(
@@ -801,7 +763,7 @@ where
         index: TickIndex,
         lower: bool,
     ) -> Option<TickIndex> {
-		todo!("moved to ActiveTickIndexManager::find_closet")
+        todo!("moved to ActiveTickIndexManager::find_closet")
     }
 
     pub fn find_closest_lower_active_tick_index(&self, index: TickIndex) -> Option<TickIndex> {
diff --git a/pallets/swap/src/tick.rs b/pallets/swap/src/tick.rs
index cbc803a942..ebc4eac12d 100644
--- a/pallets/swap/src/tick.rs
+++ b/pallets/swap/src/tick.rs
@@ -12,7 +12,7 @@ use safe_math::*;
 use substrate_fixed::types::U64F64;
 
 use crate::pallet::{
-    Config, CurrentTickIndex, FeeGlobalAlpha, FeeGlobalTao, TickIndexBitmapWords, Ticks,
+    AlphaSqrtPrice, Config, FeeGlobalAlpha, FeeGlobalTao, TickIndexBitmapWords, Ticks,
 };
 use crate::{NetUid, SqrtPrice};
 
@@ -180,7 +180,7 @@ impl TickIndex {
 
     /// Get fees above a tick
     pub fn fees_above<T: Config>(&self, netuid: NetUid, quote: bool) -> U64F64 {
-        let current_tick = CurrentTickIndex::<T>::get(netuid).unwrap_or_default();
+        let current_tick = Self::current_bounded::<T>(netuid);
 
         let Some(tick_index) = ActiveTickIndexManager::find_closest_lower::<T>(netuid, *self)
         else {
@@ -207,7 +207,7 @@ impl TickIndex {
 
     /// Get fees below a tick
     pub fn fees_below<T: Config>(&self, netuid: NetUid, quote: bool) -> U64F64 {
-        let current_tick = CurrentTickIndex::<T>::get(netuid).unwrap_or_default();
+        let current_tick = Self::current_bounded::<T>(netuid);
 
         let Some(tick_index) = ActiveTickIndexManager::find_closest_lower::<T>(netuid, *self)
         else {
@@ -233,6 +233,12 @@ impl TickIndex {
         }
     }
 
+    /// Get the current tick index for a subnet, ensuring it's within valid bounds
+    pub fn current_bounded<T: Config>(netuid: NetUid) -> Self {
+        let current_price = AlphaSqrtPrice::<T>::get(netuid);
+        Self::from_sqrt_price_bounded(current_price)
+    }
+
     /// Converts a sqrt price to a tick index, ensuring it's within valid bounds
     ///
     /// If the price is outside the valid range, this function will return the appropriate boundary

From c4f871f5a70348d40b309d21773a6bbb6bad2978 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Fri, 28 Mar 2025 19:36:14 +0100
Subject: [PATCH 041/418] Move Swap::swap to Pallet

---
 pallets/swap/src/lib.rs          |  18 ++
 pallets/swap/src/pallet/impls.rs | 536 ++++++++++++++++++++++++++++++-
 pallets/swap/src/pallet/mod.rs   |  30 +-
 pallets/swap/src/position.rs     |   4 +-
 pallets/swap/src/swap.rs         | 413 +-----------------------
 pallets/swap/src/tick.rs         |  10 +-
 6 files changed, 587 insertions(+), 424 deletions(-)

diff --git a/pallets/swap/src/lib.rs b/pallets/swap/src/lib.rs
index 997d6da96d..7cbb28b472 100644
--- a/pallets/swap/src/lib.rs
+++ b/pallets/swap/src/lib.rs
@@ -45,6 +45,24 @@ impl From<u16> for NetUid {
     }
 }
 
+#[derive(Debug, PartialEq)]
+pub struct SwapResult {
+    amount_paid_out: u64,
+    refund: u64,
+}
+
+#[derive(Debug, PartialEq)]
+struct SwapStepResult {
+    amount_to_take: u64,
+    delta_out: u64,
+}
+
+pub enum SwapStepAction {
+    Crossing,
+    StopOn,
+    StopIn,
+}
+
 #[derive(Debug, Decode, Encode, Eq, PartialEq)]
 pub enum SwapError {
     /// The provided amount is insufficient for the swap.
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 9cfe961be5..c2f7e14f10 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -7,9 +7,10 @@ use substrate_fixed::types::U64F64;
 
 use super::pallet::*;
 use crate::{
-    NetUid, RemoveLiquidityResult,
+    NetUid, OrderType, RemoveLiquidityResult, SqrtPrice, SwapResult, SwapStepAction,
+    SwapStepResult,
     position::{Position, PositionId},
-    tick::{Tick, TickIndex},
+    tick::{ActiveTickIndexManager, Tick, TickIndex},
 };
 
 impl<T: Config> Pallet<T> {
@@ -54,6 +55,520 @@ impl<T: Config> Pallet<T> {
         Ok(())
     }
 
+    /// Perform a swap
+    ///
+    /// Returns a tuple (amount, refund), where amount is the resulting paid out amount
+    pub fn swap(
+        netuid: NetUid,
+        order_type: OrderType,
+        amount: u64,
+        sqrt_price_limit: SqrtPrice,
+    ) -> Result<SwapResult, Error<T>> {
+        Self::maybe_initialize_v3(netuid)?;
+
+        let one = U64F64::from_num(1);
+
+        // Here we store the remaining amount that needs to be exchanged
+        // If order_type is Buy, then it expresses Tao amount, if it is Sell,
+        // then amount_remaining is Alpha.
+        let mut amount_remaining = amount;
+        let mut amount_paid_out: u64 = 0;
+        let mut refund: u64 = 0;
+
+        // A bit of fool proofing
+        let mut iteration_counter: u16 = 0;
+        let iter_limit: u16 = 1000;
+
+        // Swap one tick at a time until we reach one of the following conditions:
+        //   - Swap all provided amount
+        //   - Reach limit price
+        //   - Use up all liquidity (up to safe minimum)
+        while amount_remaining > 0 {
+            let current_price = AlphaSqrtPrice::<T>::get(netuid);
+            let current_liquidity = Self::current_liquidity_safe(netuid);
+            let sqrt_price_edge = Self::sqrt_price_edge(current_price, order_type);
+            let possible_delta_in = amount_remaining
+                .saturating_sub(Self::calculate_fee_amount(netuid, amount_remaining));
+            let sqrt_price_target = Self::sqrt_price_target(
+                order_type,
+                current_liquidity,
+                current_price,
+                possible_delta_in,
+            );
+            let target_quantity = Self::target_quantity(
+                order_type,
+                current_liquidity,
+                current_price,
+                possible_delta_in,
+            );
+            let edge_quantity = U64F64::from_num(1).safe_div(sqrt_price_edge.into());
+            let lim_quantity = one
+                .safe_div(T::MinSqrtPrice::get())
+                .saturating_add(one.safe_div(sqrt_price_limit.into()));
+
+            let action: SwapStepAction;
+            let delta_in;
+            let final_price;
+            let mut stop_and_refund = false;
+
+            if target_quantity < edge_quantity {
+                if target_quantity <= lim_quantity {
+                    // stop_in at price target
+                    action = SwapStepAction::StopIn;
+                    delta_in = possible_delta_in;
+                    final_price = sqrt_price_target;
+                } else {
+                    // stop_in at price limit
+                    action = SwapStepAction::StopIn;
+                    delta_in = Self::delta_in(
+                        order_type,
+                        current_liquidity,
+                        current_price,
+                        sqrt_price_limit,
+                    );
+                    final_price = sqrt_price_limit;
+                    stop_and_refund = true;
+                }
+            } else if target_quantity > edge_quantity {
+                if edge_quantity < lim_quantity {
+                    // do crossing at price edge
+                    action = SwapStepAction::Crossing;
+                    delta_in = Self::delta_in(
+                        order_type,
+                        current_liquidity,
+                        current_price,
+                        sqrt_price_edge,
+                    );
+                    final_price = sqrt_price_edge;
+                } else if edge_quantity > lim_quantity {
+                    // stop_in at price limit
+                    action = SwapStepAction::StopIn;
+                    delta_in = Self::delta_in(
+                        order_type,
+                        current_liquidity,
+                        current_price,
+                        sqrt_price_limit,
+                    );
+                    final_price = sqrt_price_limit;
+                    stop_and_refund = true;
+                } else {
+                    // stop_on at price limit
+                    action = SwapStepAction::StopOn;
+                    delta_in = Self::delta_in(
+                        order_type,
+                        current_liquidity,
+                        current_price,
+                        sqrt_price_edge,
+                    );
+                    final_price = sqrt_price_edge;
+                    stop_and_refund = true;
+                }
+            } else {
+                // targetQuantity = edgeQuantity
+                if target_quantity <= lim_quantity {
+                    // stop_on at price edge
+                    delta_in = Self::delta_in(
+                        order_type,
+                        current_liquidity,
+                        current_price,
+                        sqrt_price_edge,
+                    );
+                    final_price = sqrt_price_edge;
+                    action = if delta_in > 0 {
+                        SwapStepAction::StopOn
+                    } else {
+                        SwapStepAction::Crossing
+                    };
+                } else {
+                    // targetQuantity > limQuantity
+                    // stop_in at price lim
+                    action = SwapStepAction::StopIn;
+                    delta_in = Self::delta_in(
+                        order_type,
+                        current_liquidity,
+                        current_price,
+                        sqrt_price_limit,
+                    );
+                    final_price = sqrt_price_limit;
+                    stop_and_refund = true;
+                }
+            }
+
+            let swap_result = Self::swap_step(netuid, order_type, delta_in, final_price, action)?;
+            amount_remaining = amount_remaining.saturating_sub(swap_result.amount_to_take);
+            amount_paid_out = amount_paid_out.saturating_add(swap_result.delta_out);
+
+            if stop_and_refund {
+                refund = amount_remaining;
+                amount_remaining = 0;
+            }
+
+            iteration_counter = iteration_counter.saturating_add(1);
+            if iteration_counter > iter_limit {
+                return Err(Error::<T>::TooManySwapSteps);
+            }
+        }
+
+        Ok(SwapResult {
+            amount_paid_out,
+            refund,
+        })
+    }
+
+    /// Process a single step of a swap
+    fn swap_step(
+        netuid: NetUid,
+        order_type: OrderType,
+        delta_in: u64,
+        sqrt_price_final: SqrtPrice,
+        action: SwapStepAction,
+    ) -> Result<SwapStepResult, Error<T>> {
+        // amount_swapped = delta_in / (1 - self.fee_size)
+        let fee_rate = U64F64::saturating_from_num(FeeRate::<T>::get(netuid));
+        let u16_max = U64F64::saturating_from_num(u16::MAX);
+        let delta_fixed = U64F64::saturating_from_num(delta_in);
+        let amount_swapped =
+            delta_fixed.saturating_mul(u16_max.safe_div(u16_max.saturating_sub(fee_rate)));
+
+        // Hold the fees
+        let fee = Self::calculate_fee_amount(netuid, amount_swapped.saturating_to_num::<u64>());
+        Self::add_fees(netuid, order_type, fee);
+        let delta_out = Self::convert_deltas(netuid, order_type, delta_in);
+
+        // TODO (look inside method)
+        Self::update_reserves(netuid, order_type, delta_in, delta_out);
+
+        // Get current tick
+        let current_tick_index = TickIndex::current_bounded::<T>(netuid);
+
+        match action {
+            SwapStepAction::Crossing => {
+                let mut tick = match order_type {
+                    OrderType::Sell => {
+                        Self::find_closest_lower_active_tick(netuid, current_tick_index)
+                    }
+                    OrderType::Buy => {
+                        Self::find_closest_higher_active_tick(netuid, current_tick_index)
+                    }
+                }
+                .ok_or(Error::<T>::InsufficientLiquidity)?;
+
+                tick.fees_out_tao =
+                    FeeGlobalTao::<T>::get(netuid).saturating_sub(tick.fees_out_tao);
+                tick.fees_out_alpha =
+                    FeeGlobalAlpha::<T>::get(netuid).saturating_sub(tick.fees_out_alpha);
+                Self::update_liquidity_at_crossing(netuid, order_type)?;
+                Ticks::<T>::insert(netuid, current_tick_index, tick);
+            }
+
+            SwapStepAction::StopOn => match order_type {
+                OrderType::Buy => {
+                    Self::update_liquidity_at_crossing(netuid, order_type)?;
+                    let Some(mut tick) =
+                        Self::find_closest_higher_active_tick(netuid, current_tick_index)
+                    else {
+                        return Err(Error::<T>::InsufficientLiquidity);
+                    };
+
+                    tick.fees_out_tao =
+                        FeeGlobalTao::<T>::get(netuid).saturating_sub(tick.fees_out_tao);
+                    tick.fees_out_alpha =
+                        FeeGlobalAlpha::<T>::get(netuid).saturating_sub(tick.fees_out_alpha);
+                    Ticks::<T>::insert(netuid, current_tick_index, tick);
+                }
+                OrderType::Sell => {}
+            },
+
+            SwapStepAction::StopIn => {}
+        }
+
+        // Update current price, which effectively updates current tick too
+        AlphaSqrtPrice::<T>::set(netuid, sqrt_price_final);
+
+        Ok(SwapStepResult {
+            amount_to_take: amount_swapped.saturating_to_num::<u64>(),
+            delta_out,
+        })
+    }
+
+    /// Get the square root price at the current tick edge for the given direction (order type) If
+    /// order type is Buy, then price edge is the high tick bound price, otherwise it is the low
+    /// tick bound price.
+    ///
+    /// If anything is wrong with tick math and it returns Err, we just abort the deal, i.e. return
+    /// the edge that is impossible to execute
+    fn sqrt_price_edge(current_price: U64F64, order_type: OrderType) -> SqrtPrice {
+        let fallback_price_edge_value = (match order_type {
+            OrderType::Buy => TickIndex::MIN.try_to_sqrt_price(),
+            OrderType::Sell => TickIndex::MAX.try_to_sqrt_price(),
+        })
+        .unwrap_or(SqrtPrice::from_num(0));
+
+        TickIndex::try_from_sqrt_price(current_price)
+            .and_then(|current_tick_index| {
+                match order_type {
+                    OrderType::Buy => {
+                        TickIndex::new_unchecked(current_tick_index.get().saturating_add(1))
+                    }
+                    OrderType::Sell => current_tick_index,
+                }
+                .try_to_sqrt_price()
+            })
+            .unwrap_or(fallback_price_edge_value)
+    }
+
+    /// Calculate fee amount
+    ///
+    /// Fee is provided by state ops as u16-normalized value.
+    fn calculate_fee_amount(netuid: NetUid, amount: u64) -> u64 {
+        let fee_rate = U64F64::saturating_from_num(FeeRate::<T>::get(netuid))
+            .safe_div(U64F64::saturating_from_num(u16::MAX));
+
+        U64F64::saturating_from_num(amount)
+            .saturating_mul(fee_rate)
+            .saturating_to_num::<u64>()
+    }
+
+    /// Add fees to the global fee counters
+    fn add_fees(netuid: NetUid, order_type: OrderType, fee: u64) {
+        let liquidity_curr = Self::current_liquidity_safe(netuid);
+
+        if liquidity_curr == 0 {
+            return;
+        }
+
+        let fee_global_tao = FeeGlobalTao::<T>::get(netuid);
+        let fee_global_alpha = FeeGlobalAlpha::<T>::get(netuid);
+        let fee_fixed = U64F64::saturating_from_num(fee);
+
+        match order_type {
+            OrderType::Sell => {
+                FeeGlobalTao::<T>::set(
+                    netuid,
+                    fee_global_tao.saturating_add(fee_fixed.safe_div(liquidity_curr)),
+                );
+            }
+            OrderType::Buy => {
+                FeeGlobalAlpha::<T>::set(
+                    netuid,
+                    fee_global_alpha.saturating_add(fee_fixed.safe_div(liquidity_curr)),
+                );
+            }
+        }
+    }
+
+    /// Convert input amount (delta_in) to output amount (delta_out)
+    ///
+    /// This is the core method of uniswap V3 that tells how much output token is given for an
+    /// amount of input token within one price tick.
+    fn convert_deltas(netuid: NetUid, order_type: OrderType, delta_in: u64) -> u64 {
+        let liquidity_curr = SqrtPrice::saturating_from_num(CurrentLiquidity::<T>::get(netuid));
+        let sqrt_price_curr = AlphaSqrtPrice::<T>::get(netuid);
+        let delta_fixed = SqrtPrice::saturating_from_num(delta_in);
+
+        // TODO: Implement in safe and non-overflowing math
+        // Intentionally using unsafe math here to trigger CI
+
+        // // Prevent overflows:
+        // // If liquidity or delta are too large, reduce their precision and
+        // // save their factor for final correction. Price can take full U64F64
+        // // range, and it will not overflow u128 divisions or multiplications.
+        // let mut liquidity_factor: u64 = 1;
+        // if liquidity_curr > u32::MAX as u64 {
+        //     liquidity_factor = u32::MAX as u64;
+        //     liquidity_curr = liquidity_curr.safe_div(liquidity_factor);
+        // }
+        // let mut delta = delta_in as u64;
+        // let mut delta_factor: u64 = 1;
+        // if delta > u32::MAX as u64 {
+        //     delta_factor = u32::MAX as u64;
+        //     delta = delta.safe_div(delta_factor);
+        // }
+
+        // // This product does not overflow because we limit both
+        // // multipliers by u32::MAX (despite the u64 type)
+        // let delta_liquidity = delta.saturating_mul(liquidity);
+
+        // // This is product of delta_in * liquidity_curr * sqrt_price_curr
+        // let delta_liquidity_price: u128 =
+        //     Self::mul_u64_u64f64(delta_liquidity, sqrt_price_curr.into());
+
+        if delta_in > 0 {
+            (match order_type {
+                OrderType::Sell => {
+                    liquidity_curr * sqrt_price_curr * delta_fixed
+                        / (liquidity_curr / sqrt_price_curr + delta_fixed)
+                }
+                OrderType::Buy => {
+                    liquidity_curr / sqrt_price_curr * delta_fixed
+                        / (liquidity_curr * sqrt_price_curr + delta_fixed)
+                }
+            })
+            .to_num::<u64>()
+        } else {
+            0
+        }
+    }
+
+    /// Get the target square root price based on the input amount
+    fn sqrt_price_target(
+        order_type: OrderType,
+        liquidity_curr: U64F64,
+        sqrt_price_curr: U64F64,
+        delta_in: u64,
+    ) -> SqrtPrice {
+        let delta_fixed = U64F64::saturating_from_num(delta_in);
+        let one = U64F64::saturating_from_num(1);
+
+        if liquidity_curr == 0 {
+            // No liquidity means price should remain current
+            return sqrt_price_curr;
+        }
+
+        match order_type {
+            OrderType::Buy => one.safe_div(
+                delta_fixed
+                    .safe_div(liquidity_curr)
+                    .saturating_add(one.safe_div(sqrt_price_curr)),
+            ),
+            OrderType::Sell => delta_fixed
+                .safe_div(liquidity_curr)
+                .saturating_add(sqrt_price_curr),
+        }
+    }
+
+    /// Get the target quantity, which is
+    ///     `1 / (target square root price)` in case of sell order
+    ///     `target square root price` in case of buy order
+    ///
+    /// ...based on the input amount, current liquidity, and current alpha price
+    fn target_quantity(
+        order_type: OrderType,
+        liquidity_curr: U64F64,
+        sqrt_price_curr: U64F64,
+        delta_in: u64,
+    ) -> SqrtPrice {
+        let delta_fixed = U64F64::saturating_from_num(delta_in);
+        let one = U64F64::saturating_from_num(1);
+
+        if liquidity_curr == 0 {
+            // No liquidity means zero
+            return SqrtPrice::saturating_from_num(0);
+        }
+
+        match order_type {
+            OrderType::Buy => delta_fixed
+                .safe_div(liquidity_curr)
+                .saturating_add(sqrt_price_curr)
+                .into(),
+            OrderType::Sell => delta_fixed
+                .safe_div(liquidity_curr)
+                .saturating_add(one.safe_div(sqrt_price_curr))
+                .into(),
+        }
+    }
+
+    /// Get the input amount needed to reach the target price
+    fn delta_in(
+        order_type: OrderType,
+        liquidity_curr: U64F64,
+        sqrt_price_curr: U64F64,
+        sqrt_price_target: SqrtPrice,
+    ) -> u64 {
+        let one = U64F64::saturating_from_num(1);
+
+        (match order_type {
+            OrderType::Sell => liquidity_curr.saturating_mul(
+                one.safe_div(sqrt_price_target.into())
+                    .saturating_sub(one.safe_div(sqrt_price_curr)),
+            ),
+            OrderType::Buy => {
+                liquidity_curr.saturating_mul(sqrt_price_target.saturating_sub(sqrt_price_curr))
+            }
+        })
+        .saturating_to_num::<u64>()
+    }
+
+    /// Update token reserves after a swap
+    fn update_reserves(netuid: NetUid, order_type: OrderType, amount_in: u64, amount_out: u64) {
+        // TODO can we return the values from Self::swap, so the depender updated their state
+        // (instead of us mutating it)
+        todo!("update_reserves needs consideration")
+        // let (new_tao_reserve, new_alpha_reserve) = match order_type {
+        //     OrderType::Sell => (
+        //         self.state_ops.get_tao_reserve().saturating_add(amount_in),
+        //         self.state_ops
+        //             .get_alpha_reserve()
+        //             .saturating_sub(amount_out),
+        //     ),
+        //     OrderType::Buy => (
+        //         self.state_ops.get_tao_reserve().saturating_sub(amount_in),
+        //         self.state_ops
+        //             .get_alpha_reserve()
+        //             .saturating_add(amount_out),
+        //     ),
+        // };
+
+        // self.state_ops.set_tao_reserve(new_tao_reserve);
+        // self.state_ops.set_alpha_reserve(new_alpha_reserve);
+    }
+
+    /// Update liquidity when crossing a tick
+    fn update_liquidity_at_crossing(netuid: NetUid, order_type: OrderType) -> Result<(), Error<T>> {
+        let mut liquidity_curr = CurrentLiquidity::<T>::get(netuid);
+        let current_tick_index = TickIndex::current_bounded::<T>(netuid);
+        match order_type {
+            OrderType::Sell => {
+                let Some(tick) = Self::find_closest_lower_active_tick(netuid, current_tick_index)
+                else {
+                    return Err(Error::<T>::InsufficientLiquidity);
+                };
+
+                let liquidity_update_abs_u64 = tick.liquidity_net_as_u64();
+
+                liquidity_curr = if tick.liquidity_net >= 0 {
+                    liquidity_curr.saturating_sub(liquidity_update_abs_u64)
+                } else {
+                    liquidity_curr.saturating_add(liquidity_update_abs_u64)
+                };
+            }
+            OrderType::Buy => {
+                let Some(tick) = Self::find_closest_higher_active_tick(netuid, current_tick_index)
+                else {
+                    return Err(Error::<T>::InsufficientLiquidity);
+                };
+                let liquidity_update_abs_u64 = tick.liquidity_net_as_u64();
+
+                liquidity_curr = if tick.liquidity_net >= 0 {
+                    liquidity_curr.saturating_add(liquidity_update_abs_u64)
+                } else {
+                    liquidity_curr.saturating_sub(liquidity_update_abs_u64)
+                };
+            }
+        }
+
+        CurrentLiquidity::<T>::set(netuid, liquidity_curr);
+
+        Ok(())
+    }
+
+    pub fn find_closest_lower_active_tick(netuid: NetUid, index: TickIndex) -> Option<Tick> {
+        ActiveTickIndexManager::find_closest_lower::<T>(netuid, index)
+            .and_then(|ti| Ticks::<T>::get(netuid, ti))
+    }
+
+    pub fn find_closest_higher_active_tick(netuid: NetUid, index: TickIndex) -> Option<Tick> {
+        ActiveTickIndexManager::find_closest_higher::<T>(netuid, index)
+            .and_then(|ti| Ticks::<T>::get(netuid, ti))
+    }
+
+    /// Here we subtract minimum safe liquidity from current liquidity to stay in the safe range
+    fn current_liquidity_safe(netuid: NetUid) -> U64F64 {
+        U64F64::saturating_from_num(
+            CurrentLiquidity::<T>::get(netuid).saturating_sub(T::MinimumLiquidity::get()),
+        )
+    }
+
     /// Adds liquidity to the specified price range.
     ///
     /// This function allows an account to provide liquidity to a given range of price ticks. The
@@ -149,26 +664,25 @@ impl<T: Config> Pallet<T> {
         account_id: &T::AccountId,
         position_id: PositionId,
     ) -> Result<RemoveLiquidityResult, Error<T>> {
-        let Some(mut pos) = Positions::<T>::get((netuid, account_id, position_id)) else {
+        let Some(mut position) = Positions::<T>::get((netuid, account_id, position_id)) else {
             return Err(Error::<T>::LiquidityNotFound);
         };
-        let current_tick_index = TickIndex::current_bounded::<T>(netuid);
 
         // Collect fees and get tao and alpha amounts
-        let (fee_tao, fee_alpha) = pos.collect_fees::<T>();
+        let (fee_tao, fee_alpha) = position.collect_fees::<T>();
         let current_price = AlphaSqrtPrice::<T>::get(netuid);
-        let (tao, alpha) = pos.to_token_amounts(current_price)?;
+        let (tao, alpha) = position.to_token_amounts(current_price)?;
 
         // Update liquidity at position ticks
-        Self::remove_liquidity_at_index(netuid, pos.tick_low, pos.liquidity, false);
-        Self::remove_liquidity_at_index(netuid, pos.tick_high, pos.liquidity, true);
+        Self::remove_liquidity_at_index(netuid, position.tick_low, position.liquidity, false);
+        Self::remove_liquidity_at_index(netuid, position.tick_high, position.liquidity, true);
 
         // Update current tick liquidity
         Self::update_liquidity_if_needed(
             netuid,
-            pos.tick_low,
-            pos.tick_high,
-            -(pos.liquidity as i128),
+            position.tick_low,
+            position.tick_high,
+            -(position.liquidity as i128),
         );
 
         // Remove user position
diff --git a/pallets/swap/src/pallet/mod.rs b/pallets/swap/src/pallet/mod.rs
index f6ddb8afe4..787b89a877 100644
--- a/pallets/swap/src/pallet/mod.rs
+++ b/pallets/swap/src/pallet/mod.rs
@@ -4,7 +4,7 @@ use pallet_subtensor_swap_interface::LiquidityDataProvider;
 use substrate_fixed::types::U64F64;
 
 use crate::{
-    NetUid,
+    NetUid, SqrtPrice,
     position::{Position, PositionId},
     tick::{LayerLevel, Tick, TickIndex},
 };
@@ -45,6 +45,18 @@ mod pallet {
         /// The maximum number of positions a user can have
         #[pallet::constant]
         type MaxPositions: Get<u32>;
+
+        /// Minimum liquidity that is safe for rounding and integer math.
+        #[pallet::constant]
+        type MinimumLiquidity: Get<u64>;
+
+        /// Minimum sqrt price across all active ticks
+        #[pallet::constant]
+        type MinSqrtPrice: Get<SqrtPrice>;
+
+        /// Maximum sqrt price across all active ticks
+        #[pallet::constant]
+        type MaxSqrtPrice: Get<SqrtPrice>;
     }
 
     /// The fee rate applied to swaps per subnet, normalized value between 0 and u16::MAX
@@ -53,6 +65,14 @@ mod pallet {
     #[pallet::storage]
     pub type FeeRate<T> = StorageMap<_, Twox64Concat, NetUid, u16, ValueQuery>;
 
+    // Global accrued fees in tao per subnet
+    #[pallet::storage]
+    pub type FeeGlobalTao<T> = StorageMap<_, Twox64Concat, NetUid, U64F64, ValueQuery>;
+
+    // Global accrued fees in alpha per subnet
+    #[pallet::storage]
+    pub type FeeGlobalAlpha<T> = StorageMap<_, Twox64Concat, NetUid, U64F64, ValueQuery>;
+
     /// Storage for all ticks, using subnet ID as the primary key and tick index as the secondary key
     #[pallet::storage]
     pub type Ticks<T> = StorageDoubleMap<_, Twox64Concat, NetUid, Twox64Concat, TickIndex, Tick>;
@@ -83,14 +103,6 @@ mod pallet {
         OptionQuery,
     >;
 
-    // Global accrued fees in tao per subnet
-    #[pallet::storage]
-    pub type FeeGlobalTao<T> = StorageMap<_, Twox64Concat, NetUid, U64F64>;
-
-    // Global accrued fees in alpha per subnet
-    #[pallet::storage]
-    pub type FeeGlobalAlpha<T> = StorageMap<_, Twox64Concat, NetUid, U64F64>;
-
     /// Tick index bitmap words storage
     #[pallet::storage]
     pub type TickIndexBitmapWords<T: Config> = StorageNMap<
diff --git a/pallets/swap/src/position.rs b/pallets/swap/src/position.rs
index 6fad4eed3a..2a275e0e19 100644
--- a/pallets/swap/src/position.rs
+++ b/pallets/swap/src/position.rs
@@ -113,9 +113,9 @@ impl Position {
     /// If quote flag is true, Tao is returned, otherwise alpha.
     fn fees_in_range<T: Config>(&self, quote: bool) -> u64 {
         if quote {
-            FeeGlobalTao::<T>::get(self.netuid).unwrap_or_default()
+            FeeGlobalTao::<T>::get(self.netuid)
         } else {
-            FeeGlobalAlpha::<T>::get(self.netuid).unwrap_or_default()
+            FeeGlobalAlpha::<T>::get(self.netuid)
         }
         .saturating_sub(self.tick_low.fees_below::<T>(self.netuid, quote))
         .saturating_sub(self.tick_high.fees_above::<T>(self.netuid, quote))
diff --git a/pallets/swap/src/swap.rs b/pallets/swap/src/swap.rs
index 54a22e2cfb..35821d76c9 100644
--- a/pallets/swap/src/swap.rs
+++ b/pallets/swap/src/swap.rs
@@ -6,29 +6,11 @@ use safe_math::*;
 use substrate_fixed::types::U64F64;
 
 use crate::{
-    RemoveLiquidityResult, SqrtPrice, SwapError,
+    RemoveLiquidityResult, SqrtPrice, SwapError, SwapResult, SwapStepAction, SwapStepResult,
     position::Position,
     tick::{LayerLevel, Tick, TickIndex, TickIndexBitmap},
 };
 
-#[derive(Debug, PartialEq)]
-pub struct SwapResult {
-    amount_paid_out: u64,
-    refund: u64,
-}
-
-pub enum SwapStepAction {
-    Crossing,
-    StopOn,
-    StopIn,
-}
-
-#[derive(Debug, PartialEq)]
-struct SwapStepResult {
-    amount_to_take: u64,
-    delta_out: u64,
-}
-
 /// This trait implementation depends on Runtime and it needs to be implemented
 /// in the pallet to be able to work with chain state and per subnet. All subnet
 /// swaps are independent and hence netuid is abstracted away from swap implementation.
@@ -223,111 +205,7 @@ where
         amount: u64,
         sqrt_price_limit: SqrtPrice,
     ) -> Result<SwapResult, SwapError> {
-        let one = U64F64::saturating_from_num(1);
-
-        // Here we store the remaining amount that needs to be exchanged
-        // If order_type is Buy, then it expresses Tao amount, if it is Sell,
-        // then amount_remaining is Alpha.
-        let mut amount_remaining = amount;
-        let mut amount_paid_out: u64 = 0;
-        let mut refund: u64 = 0;
-
-        // A bit of fool proofing
-        let mut iteration_counter: u16 = 0;
-        let iter_limit: u16 = 1000;
-
-        // Swap one tick at a time until we reach one of the following conditions:
-        //   - Swap all provided amount
-        //   - Reach limit price
-        //   - Use up all liquidity (up to safe minimum)
-        while amount_remaining > 0 {
-            let sqrt_price_edge = self.get_sqrt_price_edge(order_type);
-            let possible_delta_in =
-                amount_remaining.saturating_sub(self.get_fee_amount(amount_remaining));
-            let sqrt_price_target = self.get_sqrt_price_target(order_type, possible_delta_in);
-            let target_quantity = self.get_target_quantity(order_type, possible_delta_in);
-            let edge_quantity = U64F64::saturating_from_num(1).safe_div(sqrt_price_edge.into());
-            let lim_quantity = one
-                .safe_div(self.state_ops.get_min_sqrt_price())
-                .saturating_add(one.safe_div(sqrt_price_limit.into()));
-
-            let action: SwapStepAction;
-            let delta_in;
-            let final_price;
-            let mut stop_and_refund = false;
-
-            if target_quantity < edge_quantity {
-                if target_quantity <= lim_quantity {
-                    // stop_in at price target
-                    action = SwapStepAction::StopIn;
-                    delta_in = possible_delta_in;
-                    final_price = sqrt_price_target;
-                } else {
-                    // stop_in at price limit
-                    action = SwapStepAction::StopIn;
-                    delta_in = self.get_delta_in(order_type, sqrt_price_limit);
-                    final_price = sqrt_price_limit;
-                    stop_and_refund = true;
-                }
-            } else if target_quantity > edge_quantity {
-                if edge_quantity < lim_quantity {
-                    // do crossing at price edge
-                    action = SwapStepAction::Crossing;
-                    delta_in = self.get_delta_in(order_type, sqrt_price_edge);
-                    final_price = sqrt_price_edge;
-                } else if edge_quantity > lim_quantity {
-                    // stop_in at price limit
-                    action = SwapStepAction::StopIn;
-                    delta_in = self.get_delta_in(order_type, sqrt_price_limit);
-                    final_price = sqrt_price_limit;
-                    stop_and_refund = true;
-                } else {
-                    // stop_on at price limit
-                    action = SwapStepAction::StopOn;
-                    delta_in = self.get_delta_in(order_type, sqrt_price_edge);
-                    final_price = sqrt_price_edge;
-                    stop_and_refund = true;
-                }
-            } else {
-                // targetQuantity = edgeQuantity
-                if target_quantity <= lim_quantity {
-                    // stop_on at price edge
-                    delta_in = self.get_delta_in(order_type, sqrt_price_edge);
-                    final_price = sqrt_price_edge;
-                    action = if delta_in > 0 {
-                        SwapStepAction::StopOn
-                    } else {
-                        SwapStepAction::Crossing
-                    };
-                } else {
-                    // targetQuantity > limQuantity
-                    // stop_in at price lim
-                    action = SwapStepAction::StopIn;
-                    delta_in = self.get_delta_in(order_type, sqrt_price_limit);
-                    final_price = sqrt_price_limit;
-                    stop_and_refund = true;
-                }
-            }
-
-            let swap_result = self.swap_step(order_type, delta_in, final_price, action)?;
-            amount_remaining = amount_remaining.saturating_sub(swap_result.amount_to_take);
-            amount_paid_out = amount_paid_out.saturating_add(swap_result.delta_out);
-
-            if stop_and_refund {
-                refund = amount_remaining;
-                amount_remaining = 0;
-            }
-
-            iteration_counter = iteration_counter.saturating_add(1);
-            if iteration_counter > iter_limit {
-                return Err(SwapError::TooManySwapSteps);
-            }
-        }
-
-        Ok(SwapResult {
-            amount_paid_out,
-            refund,
-        })
+        todo!("moved to Pallet::swap")
     }
 
     fn get_current_tick_index(&mut self) -> TickIndex {
@@ -343,77 +221,7 @@ where
         sqrt_price_final: SqrtPrice,
         action: SwapStepAction,
     ) -> Result<SwapStepResult, SwapError> {
-        // amount_swapped = delta_in / (1 - self.fee_size)
-        let fee_rate = U64F64::saturating_from_num(self.state_ops.get_fee_rate());
-        let u16_max = U64F64::saturating_from_num(u16::MAX);
-        let delta_fixed = U64F64::saturating_from_num(delta_in);
-        let amount_swapped =
-            delta_fixed.saturating_mul(u16_max.safe_div(u16_max.saturating_sub(fee_rate)));
-
-        // Hold the fees
-        let fee = self.get_fee_amount(amount_swapped.saturating_to_num::<u64>());
-        self.add_fees(order_type, fee);
-        let delta_out = self.convert_deltas(order_type, delta_in);
-
-        self.update_reserves(order_type, delta_in, delta_out);
-
-        // Get current tick
-        let current_tick_index = self.get_current_tick_index();
-
-        match action {
-            SwapStepAction::Crossing => {
-                let maybe_tick = match order_type {
-                    OrderType::Sell => self.find_closest_lower_active_tick(current_tick_index),
-                    OrderType::Buy => self.find_closest_higher_active_tick(current_tick_index),
-                };
-                if let Some(mut tick) = maybe_tick {
-                    tick.fees_out_tao = self
-                        .state_ops
-                        .get_fee_global_tao()
-                        .saturating_sub(tick.fees_out_tao);
-                    tick.fees_out_alpha = self
-                        .state_ops
-                        .get_fee_global_alpha()
-                        .saturating_sub(tick.fees_out_alpha);
-                    self.update_liquidity_at_crossing(order_type)?;
-                    self.state_ops
-                        .insert_tick_by_index(current_tick_index, tick);
-                } else {
-                    return Err(SwapError::InsufficientLiquidity);
-                }
-            }
-            SwapStepAction::StopOn => match order_type {
-                OrderType::Sell => {}
-                OrderType::Buy => {
-                    self.update_liquidity_at_crossing(order_type)?;
-                    let maybe_tick = self.find_closest_higher_active_tick(current_tick_index);
-
-                    if let Some(mut tick) = maybe_tick {
-                        tick.fees_out_tao = self
-                            .state_ops
-                            .get_fee_global_tao()
-                            .saturating_sub(tick.fees_out_tao);
-                        tick.fees_out_alpha = self
-                            .state_ops
-                            .get_fee_global_alpha()
-                            .saturating_sub(tick.fees_out_alpha);
-                        self.state_ops
-                            .insert_tick_by_index(current_tick_index, tick);
-                    } else {
-                        return Err(SwapError::InsufficientLiquidity);
-                    }
-                }
-            },
-            SwapStepAction::StopIn => {}
-        }
-
-        // Update current price, which effectively updates current tick too
-        self.state_ops.set_alpha_sqrt_price(sqrt_price_final);
-
-        Ok(SwapStepResult {
-            amount_to_take: amount_swapped.saturating_to_num::<u64>(),
-            delta_out,
-        })
+        todo!("moved to Pallet::swap_step")
     }
 
     /// Get the square root price at the current tick edge for the given direction (order type)
@@ -424,27 +232,7 @@ where
     /// return the edge that is impossible to execute
     ///
     fn get_sqrt_price_edge(&self, order_type: &OrderType) -> SqrtPrice {
-        let fallback_price_edge_value = (match order_type {
-            OrderType::Buy => TickIndex::MIN.try_to_sqrt_price(),
-            OrderType::Sell => TickIndex::MAX.try_to_sqrt_price(),
-        })
-        .unwrap_or(SqrtPrice::saturating_from_num(0));
-
-        let current_price = self.state_ops.get_alpha_sqrt_price();
-        let maybe_current_tick_index = TickIndex::try_from_sqrt_price(current_price);
-
-        if let Ok(current_tick_index) = maybe_current_tick_index {
-            match order_type {
-                OrderType::Buy => {
-                    TickIndex::new_unchecked(current_tick_index.get().saturating_add(1))
-                }
-                OrderType::Sell => current_tick_index,
-            }
-            .try_to_sqrt_price()
-            .unwrap_or(fallback_price_edge_value)
-        } else {
-            fallback_price_edge_value
-        }
+        todo!("moved to Pallet::sqrt_price_edge")
     }
 
     /// Calculate fee amount
@@ -452,47 +240,20 @@ where
     /// Fee is provided by state ops as u16-normalized value.
     ///
     fn get_fee_amount(&self, amount: u64) -> u64 {
-        let fee_rate = U64F64::saturating_from_num(self.state_ops.get_fee_rate())
-            .safe_div(U64F64::saturating_from_num(u16::MAX));
-        U64F64::saturating_from_num(amount)
-            .saturating_mul(fee_rate)
-            .saturating_to_num::<u64>()
+        todo!("moved to Pallet::calculate_fee_amount")
     }
 
     /// Here we subtract minimum safe liquidity from current liquidity to stay in the
     /// safe range
     ///
     fn get_safe_current_liquidity(&self) -> U64F64 {
-        U64F64::saturating_from_num(
-            self.state_ops
-                .get_current_liquidity()
-                .saturating_sub(self.state_ops.get_minimum_liquidity()),
-        )
+        todo!("moved to Pallet::current_liquidity_safe")
     }
 
     /// Get the target square root price based on the input amount
     ///
     fn get_sqrt_price_target(&self, order_type: &OrderType, delta_in: u64) -> SqrtPrice {
-        let liquidity_curr = self.get_safe_current_liquidity();
-        let sqrt_price_curr = self.state_ops.get_alpha_sqrt_price().into();
-        let delta_fixed = U64F64::saturating_from_num(delta_in);
-        let one = U64F64::saturating_from_num(1);
-
-        if liquidity_curr > 0 {
-            match order_type {
-                OrderType::Buy => one.safe_div(
-                    delta_fixed
-                        .safe_div(liquidity_curr)
-                        .saturating_add(one.safe_div(sqrt_price_curr)),
-                ),
-                OrderType::Sell => delta_fixed
-                    .safe_div(liquidity_curr)
-                    .saturating_add(sqrt_price_curr),
-            }
-        } else {
-            // No liquidity means price should remain current
-            sqrt_price_curr
-        }
+        todo!("moved to Pallet::sqrt_price_target")
     }
 
     /// Get the target quantity, which is
@@ -502,68 +263,18 @@ where
     /// ...based on the input amount, current liquidity, and current alpha price
     ///
     fn get_target_quantity(&self, order_type: &OrderType, delta_in: u64) -> SqrtPrice {
-        let liquidity_curr = self.get_safe_current_liquidity();
-        let sqrt_price_curr = self.state_ops.get_alpha_sqrt_price().into();
-        let delta_fixed = U64F64::saturating_from_num(delta_in);
-        let one = U64F64::saturating_from_num(1);
-
-        if liquidity_curr > 0 {
-            match order_type {
-                OrderType::Buy => delta_fixed
-                    .safe_div(liquidity_curr)
-                    .saturating_add(sqrt_price_curr)
-                    .into(),
-                OrderType::Sell => delta_fixed
-                    .safe_div(liquidity_curr)
-                    .saturating_add(one.safe_div(sqrt_price_curr))
-                    .into(),
-            }
-        } else {
-            // No liquidity means zero
-            SqrtPrice::saturating_from_num(0)
-        }
+        todo!("moved to Pallet::target_quantity")
     }
 
     /// Get the input amount needed to reach the target price
     ///
     fn get_delta_in(&self, order_type: &OrderType, sqrt_price_target: SqrtPrice) -> u64 {
-        let liquidity_curr = self.get_safe_current_liquidity();
-        let one = U64F64::saturating_from_num(1);
-        let sqrt_price_curr = self.state_ops.get_alpha_sqrt_price().into();
-
-        (match order_type {
-            OrderType::Sell => liquidity_curr.saturating_mul(
-                one.safe_div(sqrt_price_target.into())
-                    .saturating_sub(one.safe_div(sqrt_price_curr)),
-            ),
-            OrderType::Buy => {
-                liquidity_curr.saturating_mul(sqrt_price_target.saturating_sub(sqrt_price_curr))
-            }
-        })
-        .saturating_to_num::<u64>()
+        todo!("moved to Pallet::delat_in")
     }
 
     /// Add fees to the global fee counters
     fn add_fees(&mut self, order_type: &OrderType, fee: u64) {
-        let liquidity_curr = self.get_safe_current_liquidity();
-        if liquidity_curr > 0 {
-            let fee_global_tao: U64F64 = self.state_ops.get_fee_global_tao();
-            let fee_global_alpha: U64F64 = self.state_ops.get_fee_global_alpha();
-            let fee_fixed: U64F64 = U64F64::saturating_from_num(fee);
-
-            match order_type {
-                OrderType::Sell => {
-                    self.state_ops.set_fee_global_tao(
-                        fee_global_tao.saturating_add(fee_fixed.safe_div(liquidity_curr)),
-                    );
-                }
-                OrderType::Buy => {
-                    self.state_ops.set_fee_global_alpha(
-                        fee_global_alpha.saturating_add(fee_fixed.safe_div(liquidity_curr)),
-                    );
-                }
-            }
-        }
+        todo!("moved to Pallet::add_fees")
     }
 
     /// Convert input amount (delta_in) to output amount (delta_out)
@@ -573,52 +284,7 @@ where
     /// price tick.
     ///
     fn convert_deltas(&self, order_type: &OrderType, delta_in: u64) -> u64 {
-        let liquidity_curr = SqrtPrice::saturating_from_num(self.state_ops.get_current_liquidity());
-        let sqrt_price_curr = self.state_ops.get_alpha_sqrt_price();
-        let delta_fixed = SqrtPrice::saturating_from_num(delta_in);
-
-        // TODO: Implement in safe and non-overflowing math
-        // Intentionally using unsafe math here to trigger CI
-
-        // // Prevent overflows:
-        // // If liquidity or delta are too large, reduce their precision and
-        // // save their factor for final correction. Price can take full U64F64
-        // // range, and it will not overflow u128 divisions or multiplications.
-        // let mut liquidity_factor: u64 = 1;
-        // if liquidity_curr > u32::MAX as u64 {
-        //     liquidity_factor = u32::MAX as u64;
-        //     liquidity_curr = liquidity_curr.safe_div(liquidity_factor);
-        // }
-        // let mut delta = delta_in as u64;
-        // let mut delta_factor: u64 = 1;
-        // if delta > u32::MAX as u64 {
-        //     delta_factor = u32::MAX as u64;
-        //     delta = delta.safe_div(delta_factor);
-        // }
-
-        // // This product does not overflow because we limit both
-        // // multipliers by u32::MAX (despite the u64 type)
-        // let delta_liquidity = delta.saturating_mul(liquidity);
-
-        // // This is product of delta_in * liquidity_curr * sqrt_price_curr
-        // let delta_liquidity_price: u128 =
-        //     Self::mul_u64_u64f64(delta_liquidity, sqrt_price_curr.into());
-
-        if delta_in > 0 {
-            (match order_type {
-                OrderType::Sell => {
-                    liquidity_curr * sqrt_price_curr * delta_fixed
-                        / (liquidity_curr / sqrt_price_curr + delta_fixed)
-                }
-                OrderType::Buy => {
-                    liquidity_curr / sqrt_price_curr * delta_fixed
-                        / (liquidity_curr * sqrt_price_curr + delta_fixed)
-                }
-            })
-            .to_num::<u64>()
-        } else {
-            0
-        }
+        todo!("moved to Pallet::convert_deltas")
     }
 
     /// Multiplies a `u64` by a `U64F64` and returns a `u128` result without overflow.
@@ -661,52 +327,13 @@ where
     }
 
     fn get_liquidity_update_u64(&self, tick: &Tick) -> u64 {
-        let liquidity_update_abs_i128 = tick.liquidity_net.abs();
-        if liquidity_update_abs_i128 > u64::MAX as i128 {
-            u64::MAX
-        } else {
-            liquidity_update_abs_i128 as u64
-        }
+        todo!("moved to Tick::liquidity_net_as_u64")
     }
 
     /// Update liquidity when crossing a tick
     ///
     fn update_liquidity_at_crossing(&mut self, order_type: &OrderType) -> Result<(), SwapError> {
-        let mut liquidity_curr = self.state_ops.get_current_liquidity();
-        let current_tick_index = self.get_current_tick_index();
-        match order_type {
-            OrderType::Sell => {
-                let maybe_tick = self.find_closest_lower_active_tick(current_tick_index);
-                if let Some(tick) = maybe_tick {
-                    let liquidity_update_abs_u64 = self.get_liquidity_update_u64(&tick);
-
-                    liquidity_curr = if tick.liquidity_net >= 0 {
-                        liquidity_curr.saturating_sub(liquidity_update_abs_u64)
-                    } else {
-                        liquidity_curr.saturating_add(liquidity_update_abs_u64)
-                    };
-                } else {
-                    return Err(SwapError::InsufficientLiquidity);
-                }
-            }
-            OrderType::Buy => {
-                let maybe_tick = self.find_closest_higher_active_tick(current_tick_index);
-                if let Some(tick) = maybe_tick {
-                    let liquidity_update_abs_u64 = self.get_liquidity_update_u64(&tick);
-
-                    liquidity_curr = if tick.liquidity_net >= 0 {
-                        liquidity_curr.saturating_add(liquidity_update_abs_u64)
-                    } else {
-                        liquidity_curr.saturating_sub(liquidity_update_abs_u64)
-                    };
-                } else {
-                    return Err(SwapError::InsufficientLiquidity);
-                }
-            }
-        }
-
-        self.state_ops.set_current_liquidity(liquidity_curr);
-        Ok(())
+        todo!("moved to Pallet::update_liquidity_at_crossing")
     }
 
     /// Collect fees for a position
@@ -775,21 +402,11 @@ where
     }
 
     pub fn find_closest_lower_active_tick(&self, index: TickIndex) -> Option<Tick> {
-        let maybe_tick_index = self.find_closest_lower_active_tick_index(index);
-        if let Some(tick_index) = maybe_tick_index {
-            self.state_ops.get_tick_by_index(tick_index)
-        } else {
-            None
-        }
+        todo!("moved to Pallet::find_closest_lower")
     }
 
     pub fn find_closest_higher_active_tick(&self, index: TickIndex) -> Option<Tick> {
-        let maybe_tick_index = self.find_closest_higher_active_tick_index(index);
-        if let Some(tick_index) = maybe_tick_index {
-            self.state_ops.get_tick_by_index(tick_index)
-        } else {
-            None
-        }
+        todo!("moved to Pallet::find_closest_higher")
     }
 }
 
diff --git a/pallets/swap/src/tick.rs b/pallets/swap/src/tick.rs
index ebc4eac12d..07bd659788 100644
--- a/pallets/swap/src/tick.rs
+++ b/pallets/swap/src/tick.rs
@@ -82,6 +82,12 @@ pub struct Tick {
     pub fees_out_alpha: U64F64,
 }
 
+impl Tick {
+    pub fn liquidity_net_as_u64(&self) -> u64 {
+        self.liquidity_net.abs().min(u64::MAX as i128) as u64
+    }
+}
+
 /// Struct representing a tick index
 #[derive(
     Debug,
@@ -191,11 +197,9 @@ impl TickIndex {
         if tick_index <= current_tick {
             if quote {
                 FeeGlobalTao::<T>::get(netuid)
-                    .unwrap_or_default()
                     .saturating_sub(tick.fees_out_tao)
             } else {
                 FeeGlobalAlpha::<T>::get(netuid)
-                    .unwrap_or_default()
                     .saturating_sub(tick.fees_out_alpha)
             }
         } else if quote {
@@ -224,11 +228,9 @@ impl TickIndex {
             }
         } else if quote {
             FeeGlobalTao::<T>::get(netuid)
-                .unwrap_or_default()
                 .saturating_sub(tick.fees_out_tao)
         } else {
             FeeGlobalAlpha::<T>::get(netuid)
-                .unwrap_or_default()
                 .saturating_sub(tick.fees_out_alpha)
         }
     }

From 162876f8b5a9045d9caea43fae64c44eb22a1f5b Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Mon, 31 Mar 2025 19:45:58 +0200
Subject: [PATCH 042/418] Add mock, transfer a few tests

---
 Cargo.lock                        |   2 +
 pallets/swap-interface/src/lib.rs |   4 +-
 pallets/swap/Cargo.toml           |   4 +
 pallets/swap/src/lib.rs           |   3 +
 pallets/swap/src/mock.rs          | 150 ++++++++++++++
 pallets/swap/src/pallet/impls.rs  | 326 +++++++++++++++++++++++++++++-
 pallets/swap/src/pallet/mod.rs    |  38 ++++
 pallets/swap/src/swap.rs          |  65 +-----
 pallets/swap/src/tick.rs          |  42 ++--
 9 files changed, 556 insertions(+), 78 deletions(-)
 create mode 100644 pallets/swap/src/mock.rs

diff --git a/Cargo.lock b/Cargo.lock
index ea63630307..d6ba6b07f6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6848,6 +6848,8 @@ dependencies = [
  "scale-info",
  "serde",
  "sp-arithmetic",
+ "sp-core",
+ "sp-io",
  "sp-runtime",
  "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409)",
  "substrate-fixed",
diff --git a/pallets/swap-interface/src/lib.rs b/pallets/swap-interface/src/lib.rs
index 44ca298d18..2fd0609097 100644
--- a/pallets/swap-interface/src/lib.rs
+++ b/pallets/swap-interface/src/lib.rs
@@ -18,6 +18,6 @@ pub trait SwapHandler<AccountId> {
 }
 
 pub trait LiquidityDataProvider {
-    fn tao_reserve() -> u64;
-    fn alpha_reserve() -> u64;
+    fn tao_reserve(netuid: u16) -> u64;
+    fn alpha_reserve(netuid: u16) -> u64;
 }
diff --git a/pallets/swap/Cargo.toml b/pallets/swap/Cargo.toml
index 459f7fc45e..6b711754fd 100644
--- a/pallets/swap/Cargo.toml
+++ b/pallets/swap/Cargo.toml
@@ -13,6 +13,8 @@ safe-math = { workspace = true }
 scale-info = { workspace = true }
 serde = { workspace = true, optional = true }
 sp-arithmetic = { workspace = true }
+sp-core = { workspace = true }
+sp-io = { workspace = true }
 sp-runtime = { workspace = true }
 sp-std = { workspace = true }
 substrate-fixed = { workspace = true }
@@ -35,6 +37,8 @@ std = [
 	"scale-info/std",
 	"serde/std",
 	"sp-arithmetic/std",
+	"sp-core/std",
+	"sp-io/std",
 	"sp-runtime/std",
 	"sp-std/std",
 	"substrate-fixed/std",
diff --git a/pallets/swap/src/lib.rs b/pallets/swap/src/lib.rs
index 7cbb28b472..047f29dcab 100644
--- a/pallets/swap/src/lib.rs
+++ b/pallets/swap/src/lib.rs
@@ -18,6 +18,9 @@ mod tick;
 mod position;
 pub(crate) mod swap;
 
+#[cfg(test)]
+pub(crate) mod mock;
+
 type SqrtPrice = U64F64;
 
 #[derive(Debug, PartialEq)]
diff --git a/pallets/swap/src/mock.rs b/pallets/swap/src/mock.rs
new file mode 100644
index 0000000000..5be5cd5a58
--- /dev/null
+++ b/pallets/swap/src/mock.rs
@@ -0,0 +1,150 @@
+use frame_support::construct_runtime;
+use frame_support::{
+    PalletId, assert_ok, parameter_types,
+    traits::{ConstU32, Everything},
+};
+use frame_system::{self as system, EnsureRoot};
+use pallet_subtensor_swap_interface::LiquidityDataProvider;
+use sp_core::{H256, U256};
+use sp_runtime::{
+    BuildStorage,
+    traits::{BlakeTwo256, IdentityLookup},
+};
+use substrate_fixed::types::U64F64;
+
+use crate::{
+    NetUid, SqrtPrice,
+    pallet::{AlphaSqrtPrice, Pallet as SwapModule, SwapV3Initialized},
+};
+
+construct_runtime!(
+    pub enum Test {
+        System: frame_system,
+        Swap: crate::pallet,
+    }
+);
+
+pub type Block = frame_system::mocking::MockBlock<Test>;
+pub type AccountId = u32;
+
+parameter_types! {
+    pub const BlockHashCount: u64 = 250;
+    pub const SS58Prefix: u8 = 42;
+}
+
+impl system::Config for Test {
+    type BaseCallFilter = Everything;
+    type BlockWeights = ();
+    type BlockLength = ();
+    type DbWeight = ();
+    type RuntimeOrigin = RuntimeOrigin;
+    type RuntimeCall = RuntimeCall;
+    type Hash = H256;
+    type Hashing = BlakeTwo256;
+    type AccountId = AccountId;
+    type Lookup = IdentityLookup<Self::AccountId>;
+    type RuntimeEvent = RuntimeEvent;
+    type BlockHashCount = BlockHashCount;
+    type Version = ();
+    type PalletInfo = PalletInfo;
+    type AccountData = ();
+    type OnNewAccount = ();
+    type OnKilledAccount = ();
+    type SystemWeightInfo = ();
+    type SS58Prefix = SS58Prefix;
+    type OnSetCode = ();
+    type MaxConsumers = ConstU32<16>;
+    type Nonce = u64;
+    type Block = Block;
+    type RuntimeTask = ();
+    type SingleBlockMigrations = ();
+    type MultiBlockMigrator = ();
+    type PreInherents = ();
+    type PostInherents = ();
+    type PostTransactions = ();
+}
+
+parameter_types! {
+    pub const SwapProtocolId: PalletId = PalletId(*b"ten/swap");
+    pub const MaxFeeRate: u16 = 10000; // 15.26%
+    pub const MaxPositions: u32 = 100;
+    pub const MinimumLiquidity: u64 = 1_000;
+    pub MinSqrtPrice: SqrtPrice = U64F64::from_num(0.00001);
+    pub MaxSqrtPrice: SqrtPrice = U64F64::from_num(100000.0);
+}
+
+// Mock implementor of LiquidityDataProvider trait
+pub struct MockLiquidityProvider;
+
+impl LiquidityDataProvider for MockLiquidityProvider {
+    fn tao_reserve(_: u16) -> u64 {
+        1_000_000_000 // 1 TAO
+    }
+
+    fn alpha_reserve(_: u16) -> u64 {
+        4_000_000_000 // 4 Alpha
+    }
+}
+
+// Implementations of traits don't support visibility qualifiers
+impl crate::pallet::Config for Test {
+    type RuntimeEvent = RuntimeEvent;
+    type AdminOrigin = EnsureRoot<AccountId>;
+    type LiquidityDataProvider = MockLiquidityProvider;
+    type ProtocolId = SwapProtocolId;
+    type MaxFeeRate = MaxFeeRate;
+    type MaxPositions = MaxPositions;
+    type MinimumLiquidity = MinimumLiquidity;
+    type MinSqrtPrice = MinSqrtPrice;
+    type MaxSqrtPrice = MaxSqrtPrice;
+}
+
+// Build genesis storage according to the mock runtime.
+pub fn new_test_ext() -> sp_io::TestExternalities {
+    let storage = system::GenesisConfig::<Test>::default()
+        .build_storage()
+        .unwrap();
+    let mut ext = sp_io::TestExternalities::new(storage);
+    ext.execute_with(|| System::set_block_number(1));
+    ext
+}
+
+// Helper function to initialize a subnet with a specific fee rate
+pub fn initialize_subnet(netuid: u16, fee_rate: u16) {
+    let netuid = NetUid::from(netuid);
+    // Set initial sqrt price (1.0 means 1 TAO = 1 Alpha)
+    let initial_sqrt_price = U64F64::from_num(1.0);
+    AlphaSqrtPrice::<Test>::insert(netuid, initial_sqrt_price);
+
+    // Set the fee rate
+    assert_ok!(SwapModule::<Test>::set_fee_rate(
+        RuntimeOrigin::root(),
+        netuid.into(),
+        fee_rate
+    ));
+
+    // Mark the swap as initialized
+    SwapV3Initialized::<Test>::insert(netuid, true);
+}
+
+mod test {
+    use super::*;
+    use crate::pallet::*;
+
+    #[test]
+    fn test_subnet_initialization() {
+        new_test_ext().execute_with(|| {
+            let netuid = 1u16;
+            let fee_rate = 500; // 0.76% fee
+
+            // Initialize subnet
+            initialize_subnet(netuid, fee_rate);
+
+            // Verify initialization
+            let netuid = NetUid::from(netuid);
+            assert_eq!(FeeRate::<Test>::get(netuid), fee_rate);
+            assert_eq!(AlphaSqrtPrice::<Test>::get(netuid), U64F64::from_num(1.0));
+            assert!(SwapV3Initialized::<Test>::get(netuid));
+        });
+    }
+}
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index c2f7e14f10..298262f777 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -22,8 +22,8 @@ impl<T: Config> Pallet<T> {
 
         // Initialize the v3:
         // Reserves are re-purposed, nothing to set, just query values for liquidity and price calculation
-        let tao_reserve = <T as Config>::LiquidityDataProvider::tao_reserve();
-        let alpha_reserve = <T as Config>::LiquidityDataProvider::alpha_reserve();
+        let tao_reserve = <T as Config>::LiquidityDataProvider::tao_reserve(netuid.into());
+        let alpha_reserve = <T as Config>::LiquidityDataProvider::alpha_reserve(netuid.into());
 
         // Set price
         let price = U64F64::saturating_from_num(tao_reserve)
@@ -814,4 +814,326 @@ impl<T: Config> Pallet<T> {
     fn count_positions(netuid: NetUid, account_id: &T::AccountId) -> usize {
         Positions::<T>::iter_prefix_values((netuid, account_id.clone())).count()
     }
+
+    /// Returns the protocol account ID
+    ///
+    /// # Returns
+    /// The account ID of the protocol account
+    pub fn protocol_account_id() -> T::AccountId {
+        T::ProtocolId::get().into_account_truncating()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use approx::assert_abs_diff_eq;
+    use frame_support::{assert_err, assert_ok};
+    use sp_arithmetic::helpers_128bit;
+
+    use super::*;
+    use crate::{mock::*, pallet::*};
+
+    #[test]
+    fn test_swap_initialization() {
+        new_test_ext().execute_with(|| {
+            let netuid = NetUid::from(1);
+
+            // Get reserves from the mock provider
+            let tao = MockLiquidityProvider::tao_reserve(netuid.into());
+            let alpha = MockLiquidityProvider::alpha_reserve(netuid.into());
+
+            assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
+
+            assert!(SwapV3Initialized::<Test>::get(netuid));
+
+            let sqrt_price = AlphaSqrtPrice::<Test>::get(netuid);
+            let expected_sqrt_price = U64F64::from_num(tao)
+                .safe_div(U64F64::from_num(alpha))
+                .checked_sqrt(U64F64::from_num(0.000001))
+                .unwrap();
+            assert_eq!(sqrt_price, expected_sqrt_price);
+
+            // Calculate expected liquidity
+            let expected_liquidity =
+                helpers_128bit::sqrt((tao as u128).saturating_mul(alpha as u128)) as u64;
+
+            // Get the protocol account
+            let protocol_account_id = Pallet::<Test>::protocol_account_id();
+
+            // Verify position created for protocol account
+            let positions = Positions::<Test>::iter_prefix_values((netuid, protocol_account_id))
+                .collect::<Vec<_>>();
+            assert_eq!(positions.len(), 1);
+
+            let position = &positions[0];
+            assert_eq!(position.liquidity, expected_liquidity);
+            assert_eq!(position.tick_low, TickIndex::MIN);
+            assert_eq!(position.tick_high, TickIndex::MAX);
+            assert_eq!(position.fees_tao, 0);
+            assert_eq!(position.fees_alpha, 0);
+
+            // Verify ticks were created
+            let tick_low = Ticks::<Test>::get(netuid, TickIndex::MIN).unwrap();
+            let tick_high = Ticks::<Test>::get(netuid, TickIndex::MAX).unwrap();
+
+            // Check liquidity values
+            assert_eq!(tick_low.liquidity_net, expected_liquidity as i128);
+            assert_eq!(tick_low.liquidity_gross, expected_liquidity);
+            assert_eq!(tick_high.liquidity_net, -(expected_liquidity as i128));
+            assert_eq!(tick_high.liquidity_gross, expected_liquidity);
+
+            // Verify current liquidity is set
+            assert_eq!(CurrentLiquidity::<Test>::get(netuid), expected_liquidity);
+        });
+    }
+
+    // Test adding liquidity on top of the existing protocol liquidity
+    #[test]
+    fn test_add_liquidity_basic() {
+        assert!(false, "unfinished transfering from Swap");
+
+        new_test_ext().execute_with(|| {
+            let account_id = 1;
+            let netuid = NetUid::from(1);
+            let min_price = TickIndex::MIN
+                .try_to_sqrt_price()
+                .unwrap()
+                .saturating_to_num::<f32>();
+            let max_price = TickIndex::MAX
+                .try_to_sqrt_price()
+                .unwrap()
+                .saturating_to_num::<f32>();
+            let max_tick = TickIndex::from_sqrt_price_bounded(SqrtPrice::from_num(max_price));
+            let current_price = 0.25;
+            assert_eq!(max_tick, TickIndex::MAX);
+
+            assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
+
+            // As a user add liquidity with all possible corner cases
+            //   - Initial price is 0.25
+            //   - liquidity is expressed in RAO units
+            // Test case is (price_low, price_high, liquidity, tao, alpha)
+            [
+                // Repeat the protocol liquidity at maximum range: Expect all the same values
+                (
+                    min_price,
+                    max_price,
+                    2_000_000_000_u64,
+                    1_000_000_000_u64,
+                    4_000_000_000_u64,
+                ),
+                // Repeat the protocol liquidity at current to max range: Expect the same alpha
+                (0.25, max_price, 2_000_000_000_u64, 0, 4_000_000_000),
+                // Repeat the protocol liquidity at min to current range: Expect all the same tao
+                (min_price, 0.24999, 2_000_000_000_u64, 1_000_000_000, 0),
+                // Half to double price - just some sane wothdraw amounts
+                (0.125, 0.5, 2_000_000_000_u64, 293_000_000, 1_171_000_000),
+                // Both below price - tao is non-zero, alpha is zero
+                (0.12, 0.13, 2_000_000_000_u64, 28_270_000, 0),
+                // Both above price - tao is zero, alpha is non-zero
+                (0.3, 0.4, 2_000_000_000_u64, 0, 489_200_000),
+            ]
+            .into_iter()
+            .enumerate()
+            .map(|(n, (price_low, price_high, liquidity, tao, alpha))| {
+                (
+                    n + 1,
+                    SqrtPrice::from_num(price_low),
+                    SqrtPrice::from_num(price_high),
+                    liquidity,
+                    tao,
+                    alpha,
+                )
+            })
+            .for_each(
+                |(
+                    expected_count,
+                    price_low,
+                    price_high,
+                    liquidity,
+                    expected_tao,
+                    expected_alpha,
+                )| {
+                    // Calculate ticks (assuming tick math is tested separately)
+                    let tick_low = TickIndex::from_sqrt_price_bounded(price_low);
+                    let tick_high = TickIndex::from_sqrt_price_bounded(price_high);
+
+                    // // Setup swap
+                    // let mut mock_ops = MockSwapDataOperations::new();
+                    // mock_ops.set_tao_reserve(protocol_tao);
+                    // mock_ops.set_alpha_reserve(protocol_alpha);
+                    // mock_ops.deposit_balances(&account_id, user_tao, user_alpha);
+                    // let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
+
+                    // Get tick infos and liquidity before adding (to account for protocol liquidity)
+                    let tick_low_info_before =
+                        Ticks::<Test>::get(netuid, tick_low).unwrap_or_default();
+                    let tick_high_info_before =
+                        Ticks::<Test>::get(netuid, tick_high).unwrap_or_default();
+                    let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
+
+                    // Add liquidity
+                    let (tao, alpha) = Pallet::<Test>::add_liquidity(
+                        netuid,
+                        &account_id,
+                        tick_low,
+                        tick_high,
+                        liquidity,
+                    )
+                    .unwrap();
+
+                    assert_abs_diff_eq!(tao, expected_tao, epsilon = tao / 1000);
+                    assert_abs_diff_eq!(alpha, expected_alpha, epsilon = alpha / 1000);
+
+                    // Check that low and high ticks appear in the state and are properly updated
+                    let tick_low_info = Ticks::<Test>::get(netuid, tick_low).unwrap();
+                    let tick_high_info = Ticks::<Test>::get(netuid, tick_high).unwrap();
+                    let expected_liquidity_net_low = liquidity as i128;
+                    let expected_liquidity_gross_low = liquidity;
+                    let expected_liquidity_net_high = -(liquidity as i128);
+                    let expected_liquidity_gross_high = liquidity;
+
+                    assert_eq!(
+                        tick_low_info.liquidity_net - tick_low_info_before.liquidity_net,
+                        expected_liquidity_net_low,
+                    );
+                    assert_eq!(
+                        tick_low_info.liquidity_gross - tick_low_info_before.liquidity_gross,
+                        expected_liquidity_gross_low,
+                    );
+                    assert_eq!(
+                        tick_high_info.liquidity_net - tick_high_info_before.liquidity_net,
+                        expected_liquidity_net_high,
+                    );
+                    assert_eq!(
+                        tick_high_info.liquidity_gross - tick_high_info_before.liquidity_gross,
+                        expected_liquidity_gross_high,
+                    );
+
+                    // // Balances are withdrawn
+                    // let (user_tao_after, user_alpha_after) =
+                    //     swap.state_ops.balances.get(&account_id).unwrap();
+                    // let tao_withdrawn = user_tao - user_tao_after;
+                    // let alpha_withdrawn = user_alpha - user_alpha_after;
+                    // assert_abs_diff_eq!(tao_withdrawn, *tao, epsilon = *tao / 1000);
+                    // assert_abs_diff_eq!(alpha_withdrawn, *alpha, epsilon = *alpha / 1000);
+
+                    // Liquidity position at correct ticks
+                    assert_eq!(
+                        Pallet::<Test>::count_positions(netuid, &account_id),
+                        expected_count
+                    );
+
+                    // let position = swap.state_ops.get_position(&account_id, 0).unwrap();
+                    // assert_eq!(position.liquidity, *liquidity);
+                    // assert_eq!(position.tick_low, tick_low);
+                    // assert_eq!(position.tick_high, tick_high);
+                    // assert_eq!(position.fees_alpha, 0);
+                    // assert_eq!(position.fees_tao, 0);
+
+                    // // Current liquidity is updated only when price range includes the current price
+                    // if (*price_high >= current_price) && (*price_low <= current_price) {
+                    //     assert_eq!(
+                    //         swap.state_ops.get_current_liquidity(),
+                    //         liquidity_before + *liquidity
+                    //     );
+                    // } else {
+                    //     assert_eq!(swap.state_ops.get_current_liquidity(), liquidity_before);
+                    // }
+
+                    // // Reserves are updated
+                    // assert_eq!(
+                    //     swap.state_ops.get_tao_reserve(),
+                    //     tao_withdrawn + protocol_tao,
+                    // );
+                    // assert_eq!(
+                    //     swap.state_ops.get_alpha_reserve(),
+                    //     alpha_withdrawn + protocol_alpha,
+                    // );
+                },
+            );
+        });
+    }
+
+    #[test]
+    fn test_add_liquidity_out_of_bounds() {
+        new_test_ext().execute_with(|| {
+            let netuid = NetUid::from(1);
+            let account_id = 1;
+
+            assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
+
+            [
+                // For our tests, we'll construct TickIndex values that are intentionally
+                // outside the valid range for testing purposes only
+                (
+                    TickIndex::new_unchecked(TickIndex::MIN.get() - 1),
+                    TickIndex::MAX,
+                    1_000_000_000_u64,
+                ),
+                (
+                    TickIndex::MIN,
+                    TickIndex::new_unchecked(TickIndex::MAX.get() + 1),
+                    1_000_000_000_u64,
+                ),
+                (
+                    TickIndex::new_unchecked(TickIndex::MIN.get() - 1),
+                    TickIndex::new_unchecked(TickIndex::MAX.get() + 1),
+                    1_000_000_000_u64,
+                ),
+                (
+                    TickIndex::new_unchecked(TickIndex::MIN.get() - 100),
+                    TickIndex::new_unchecked(TickIndex::MAX.get() + 100),
+                    1_000_000_000_u64,
+                ),
+            ]
+            .into_iter()
+            .for_each(|(tick_low, tick_high, liquidity)| {
+                // Add liquidity
+                assert_err!(
+                    Swap::add_liquidity(netuid, &account_id, tick_low, tick_high, liquidity),
+                    Error::<Test>::InvalidTickRange,
+                );
+            });
+        });
+    }
+
+    #[test]
+    fn test_add_liquidity_over_balance() {
+        assert!(false, "unfinished transfering from Swap");
+        new_test_ext().execute_with(|| {
+            let account_id = 1;
+            let netuid = NetUid::from(1);
+
+            assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
+
+            [
+                // Lower than price (not enough alpha)
+                (0.1, 0.2, 100_000_000_000_u64),
+                // Higher than price (not enough tao)
+                (0.3, 0.4, 100_000_000_000_u64),
+                // Around the price (not enough both)
+                (0.1, 0.4, 100_000_000_000_u64),
+            ]
+            .into_iter()
+            .map(|(pl, ph, l)| (SqrtPrice::from_num(pl), SqrtPrice::from_num(ph), l))
+            .for_each(|(price_low, price_high, liquidity)| {
+                // Calculate ticks
+                let tick_low = TickIndex::from_sqrt_price_bounded(price_low);
+                let tick_high = TickIndex::from_sqrt_price_bounded(price_high);
+
+                // Add liquidity
+                assert_err!(
+                    Pallet::<Test>::add_liquidity(
+                        netuid,
+                        &account_id,
+                        tick_low,
+                        tick_high,
+                        liquidity
+                    ),
+                    Error::<Test>::InsufficientBalance,
+                );
+            });
+        });
+    }
 }
diff --git a/pallets/swap/src/pallet/mod.rs b/pallets/swap/src/pallet/mod.rs
index 787b89a877..e6cefbd036 100644
--- a/pallets/swap/src/pallet/mod.rs
+++ b/pallets/swap/src/pallet/mod.rs
@@ -124,6 +124,7 @@ mod pallet {
     }
 
     #[pallet::error]
+	#[derive(PartialEq)]
     pub enum Error<T> {
         /// The fee rate is too high
         FeeRateTooHigh,
@@ -177,3 +178,40 @@ mod pallet {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        NetUid,
+        mock::*,
+        pallet::{Error, FeeRate, Pallet as SwapModule},
+    };
+    use frame_support::{assert_noop, assert_ok};
+
+    #[test]
+    fn test_set_fee_rate() {
+        new_test_ext().execute_with(|| {
+            // Create a test subnet
+            let netuid = 1u16;
+            let fee_rate = 500; // 0.76% fee
+
+            // Set fee rate (requires admin/root origin)
+            assert_ok!(SwapModule::<Test>::set_fee_rate(
+                RuntimeOrigin::root(),
+                netuid,
+                fee_rate
+            ));
+
+            // Check that fee rate was set correctly
+            let netuid_struct = NetUid::from(netuid);
+            assert_eq!(FeeRate::<Test>::get(netuid_struct), fee_rate);
+
+            // Verify fee rate validation - should fail if too high
+            let too_high_fee = MaxFeeRate::get() + 1;
+            assert_noop!(
+                SwapModule::<Test>::set_fee_rate(RuntimeOrigin::root(), netuid, too_high_fee),
+                Error::<Test>::FeeRateTooHigh
+            );
+        });
+    }
+}
diff --git a/pallets/swap/src/swap.rs b/pallets/swap/src/swap.rs
index 35821d76c9..34a35e8cc2 100644
--- a/pallets/swap/src/swap.rs
+++ b/pallets/swap/src/swap.rs
@@ -642,48 +642,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn test_swap_initialization() {
-        let tao = 1_000_000_000;
-        let alpha = 4_000_000_000;
-
-        let mut mock_ops = MockSwapDataOperations::new();
-        mock_ops.set_tao_reserve(tao);
-        mock_ops.set_alpha_reserve(alpha);
-        let swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
-
-        // Active ticks
-        let tick_low = swap.state_ops.get_tick_by_index(TickIndex::MIN).unwrap();
-        let tick_high = swap.state_ops.get_tick_by_index(TickIndex::MAX).unwrap();
-        let liquidity = sqrt(alpha as u128 * tao as u128) as u64;
-        let expected_liquidity_net_low: i128 = liquidity as i128;
-        let expected_liquidity_gross_low: u64 = liquidity;
-        let expected_liquidity_net_high: i128 = (liquidity as i128).neg();
-        let expected_liquidity_gross_high: u64 = liquidity;
-        assert_eq!(tick_low.liquidity_net, expected_liquidity_net_low,);
-        assert_eq!(tick_low.liquidity_gross, expected_liquidity_gross_low,);
-        assert_eq!(tick_high.liquidity_net, expected_liquidity_net_high,);
-        assert_eq!(tick_high.liquidity_gross, expected_liquidity_gross_high,);
-
-        // Liquidity position at correct ticks
-        let account_id = swap.state_ops.get_protocol_account_id();
-        assert_eq!(swap.state_ops.get_position_count(&account_id), 1);
-
-        let position = swap.state_ops.get_position(&account_id, 0).unwrap();
-        assert_eq!(position.liquidity, liquidity);
-        assert_eq!(position.tick_low, TickIndex::MIN);
-        assert_eq!(position.tick_high, TickIndex::MAX);
-        assert_eq!(position.fees_alpha, 0);
-        assert_eq!(position.fees_tao, 0);
-
-        // Current liquidity
-        assert_eq!(swap.state_ops.get_current_liquidity(), liquidity);
-
-        // Current price
-        let sqrt_price = swap.state_ops.get_alpha_sqrt_price();
-        assert_abs_diff_eq!(sqrt_price.to_num::<f64>(), 0.50, epsilon = 0.00001,);
-    }
-
     fn price_to_tick(price: f64) -> TickIndex {
         let price_sqrt: SqrtPrice = SqrtPrice::from_num(price.sqrt());
         // Handle potential errors in the conversion
@@ -723,27 +681,8 @@ mod tests {
         }
     }
 
-    #[test]
-    fn test_tick_price_sanity_check() {
-        let min_price = tick_to_price(TickIndex::MIN);
-        let max_price = tick_to_price(TickIndex::MAX);
-        assert!(min_price > 0.);
-        assert!(max_price > 0.);
-        assert!(max_price > min_price);
-        assert!(min_price < 0.000001);
-        assert!(max_price > 10.);
-
-        // Roundtrip conversions
-        let min_price_sqrt: SqrtPrice = TickIndex::MIN.try_to_sqrt_price().unwrap();
-        let min_tick = TickIndex::try_from_sqrt_price(min_price_sqrt).unwrap();
-        assert_eq!(min_tick, TickIndex::MIN);
-
-        let max_price_sqrt: SqrtPrice = TickIndex::MAX.try_to_sqrt_price().unwrap();
-        let max_tick = TickIndex::try_from_sqrt_price(max_price_sqrt).unwrap();
-        assert_eq!(max_tick, TickIndex::MAX);
-    }
-
     // Test adding liquidity on top of the existing protocol liquidity
+	#[ignore]
     #[test]
     fn test_add_liquidity_basic() {
         let protocol_tao = 1_000_000_000;
@@ -875,6 +814,7 @@ mod tests {
         });
     }
 
+	#[ignore]
     #[test]
     fn test_add_liquidity_out_of_bounds() {
         let protocol_tao = 1_000_000_000;
@@ -924,6 +864,7 @@ mod tests {
         });
     }
 
+	#[ignore]
     #[test]
     fn test_add_liquidity_over_balance() {
         let protocol_tao = 1_000_000_000;
diff --git a/pallets/swap/src/tick.rs b/pallets/swap/src/tick.rs
index 07bd659788..9a690cb235 100644
--- a/pallets/swap/src/tick.rs
+++ b/pallets/swap/src/tick.rs
@@ -196,11 +196,9 @@ impl TickIndex {
         let tick = Ticks::<T>::get(netuid, tick_index).unwrap_or_default();
         if tick_index <= current_tick {
             if quote {
-                FeeGlobalTao::<T>::get(netuid)
-                    .saturating_sub(tick.fees_out_tao)
+                FeeGlobalTao::<T>::get(netuid).saturating_sub(tick.fees_out_tao)
             } else {
-                FeeGlobalAlpha::<T>::get(netuid)
-                    .saturating_sub(tick.fees_out_alpha)
+                FeeGlobalAlpha::<T>::get(netuid).saturating_sub(tick.fees_out_alpha)
             }
         } else if quote {
             tick.fees_out_tao
@@ -227,11 +225,9 @@ impl TickIndex {
                 tick.fees_out_alpha
             }
         } else if quote {
-            FeeGlobalTao::<T>::get(netuid)
-                .saturating_sub(tick.fees_out_tao)
+            FeeGlobalTao::<T>::get(netuid).saturating_sub(tick.fees_out_tao)
         } else {
-            FeeGlobalAlpha::<T>::get(netuid)
-                .saturating_sub(tick.fees_out_alpha)
+            FeeGlobalAlpha::<T>::get(netuid).saturating_sub(tick.fees_out_alpha)
         }
     }
 
@@ -1282,6 +1278,7 @@ mod tests {
         let back_to_u256 = u64f64_to_u256(fixed_value, 32);
         assert_eq!(back_to_u256, value_32frac);
     }
+
     #[test]
     fn test_tick_index_to_sqrt_price() {
         let tick_spacing = SqrtPrice::from_num(1.0001);
@@ -1344,7 +1341,7 @@ mod tests {
     #[test]
     fn test_roundtrip_tick_index_sqrt_price() {
         for i32_value in [
-            MIN_TICK / 2,
+            TickIndex::MIN.get(),
             -1000,
             -100,
             -10,
@@ -1356,7 +1353,7 @@ mod tests {
             10,
             100,
             1000,
-            MAX_TICK / 2,
+            TickIndex::MAX.get(),
         ]
         .iter()
         {
@@ -1371,7 +1368,7 @@ mod tests {
     fn test_from_offset_index() {
         // Test various tick indices
         for i32_value in [
-            MIN_TICK / 2,
+            TickIndex::MIN.get(),
             -1000,
             -100,
             -10,
@@ -1379,7 +1376,7 @@ mod tests {
             10,
             100,
             1000,
-            MAX_TICK / 2,
+            TickIndex::MAX.get(),
         ] {
             let original_tick = TickIndex::new_unchecked(i32_value);
 
@@ -1397,4 +1394,25 @@ mod tests {
         let too_large = (TickIndex::MAX.get() + TickIndex::OFFSET.get() + 1) as u32;
         assert!(TickIndex::from_offset_index(too_large).is_err());
     }
+
+    #[test]
+    fn test_tick_price_sanity_check() {
+        let min_price = TickIndex::MIN.try_to_sqrt_price().unwrap();
+        let max_price = TickIndex::MAX.try_to_sqrt_price().unwrap();
+
+        assert!(min_price > 0.);
+        assert!(max_price > 0.);
+        assert!(max_price > min_price);
+        assert!(min_price < 0.000001);
+        assert!(max_price > 10.);
+
+        // Roundtrip conversions
+        let min_price_sqrt = TickIndex::MIN.try_to_sqrt_price().unwrap();
+        let min_tick = TickIndex::try_from_sqrt_price(min_price_sqrt).unwrap();
+        assert_eq!(min_tick, TickIndex::MIN);
+
+        let max_price_sqrt: SqrtPrice = TickIndex::MAX.try_to_sqrt_price().unwrap();
+        let max_tick = TickIndex::try_from_sqrt_price(max_price_sqrt).unwrap();
+        assert_eq!(max_tick, TickIndex::MAX);
+    }
 }

From 803a98aa570eaf254f705ba2dd683356962fc41b Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Tue, 1 Apr 2025 18:28:53 +0200
Subject: [PATCH 043/418] Port add/remove liquidity tests

---
 pallets/swap-interface/src/lib.rs |   4 +-
 pallets/swap/src/mock.rs          |  29 ++-
 pallets/swap/src/pallet/impls.rs  | 337 ++++++++++++++++++++---------
 pallets/swap/src/pallet/mod.rs    |   2 +-
 pallets/swap/src/position.rs      |   6 +
 pallets/swap/src/swap.rs          | 348 ------------------------------
 pallets/swap/src/tick.rs          |  13 ++
 7 files changed, 277 insertions(+), 462 deletions(-)

diff --git a/pallets/swap-interface/src/lib.rs b/pallets/swap-interface/src/lib.rs
index 2fd0609097..ff79e7f93f 100644
--- a/pallets/swap-interface/src/lib.rs
+++ b/pallets/swap-interface/src/lib.rs
@@ -17,7 +17,9 @@ pub trait SwapHandler<AccountId> {
     fn remove_liquidity(account_id: AccountId) -> Result<(), Box<dyn Error>>;
 }
 
-pub trait LiquidityDataProvider {
+pub trait LiquidityDataProvider<AccountId> {
     fn tao_reserve(netuid: u16) -> u64;
     fn alpha_reserve(netuid: u16) -> u64;
+    fn tao_balance(netuid: u16, account_id: &AccountId) -> u64;
+    fn alpha_balance(netuid: u16, account_id: &AccountId) -> u64;
 }
diff --git a/pallets/swap/src/mock.rs b/pallets/swap/src/mock.rs
index 5be5cd5a58..90c5762e92 100644
--- a/pallets/swap/src/mock.rs
+++ b/pallets/swap/src/mock.rs
@@ -5,7 +5,7 @@ use frame_support::{
 };
 use frame_system::{self as system, EnsureRoot};
 use pallet_subtensor_swap_interface::LiquidityDataProvider;
-use sp_core::{H256, U256};
+use sp_core::H256;
 use sp_runtime::{
     BuildStorage,
     traits::{BlakeTwo256, IdentityLookup},
@@ -26,6 +26,7 @@ construct_runtime!(
 
 pub type Block = frame_system::mocking::MockBlock<Test>;
 pub type AccountId = u32;
+pub const OK_ACCOUNT_ID: AccountId = 1;
 
 parameter_types! {
     pub const BlockHashCount: u64 = 250;
@@ -69,20 +70,36 @@ parameter_types! {
     pub const MaxFeeRate: u16 = 10000; // 15.26%
     pub const MaxPositions: u32 = 100;
     pub const MinimumLiquidity: u64 = 1_000;
-    pub MinSqrtPrice: SqrtPrice = U64F64::from_num(0.00001);
-    pub MaxSqrtPrice: SqrtPrice = U64F64::from_num(100000.0);
+    pub MinSqrtPrice: SqrtPrice = U64F64::from_num(0.001);
+    pub MaxSqrtPrice: SqrtPrice = U64F64::from_num(10.0);
 }
 
 // Mock implementor of LiquidityDataProvider trait
 pub struct MockLiquidityProvider;
 
-impl LiquidityDataProvider for MockLiquidityProvider {
+impl LiquidityDataProvider<AccountId> for MockLiquidityProvider {
     fn tao_reserve(_: u16) -> u64 {
-        1_000_000_000 // 1 TAO
+        1_000_000_000
     }
 
     fn alpha_reserve(_: u16) -> u64 {
-        4_000_000_000 // 4 Alpha
+        4_000_000_000
+    }
+
+    fn tao_balance(_: u16, account_id: &AccountId) -> u64 {
+        if *account_id == OK_ACCOUNT_ID {
+            100_000_000_000
+        } else {
+            1_000_000_000
+        }
+    }
+
+    fn alpha_balance(_: u16, account_id: &AccountId) -> u64 {
+        if *account_id == OK_ACCOUNT_ID {
+            100_000_000_000
+        } else {
+            1_000_000_000
+        }
     }
 }
 
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 298262f777..1ec4ef645c 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -42,9 +42,9 @@ impl<T: Config> Pallet<T> {
         let liquidity =
             helpers_128bit::sqrt((tao_reserve as u128).saturating_mul(alpha_reserve as u128))
                 as u64;
-        let protocol_account_id = T::ProtocolId::get().into_account_truncating();
+        let protocol_account_id = Self::protocol_account_id();
 
-        let _ = Self::add_liquidity(
+        let (position, _, _) = Self::add_liquidity_not_insert(
             netuid,
             &protocol_account_id,
             TickIndex::MIN,
@@ -52,6 +52,8 @@ impl<T: Config> Pallet<T> {
             liquidity,
         )?;
 
+        Positions::<T>::insert(&(netuid, protocol_account_id, position.id), position);
+
         Ok(())
     }
 
@@ -603,7 +605,33 @@ impl<T: Config> Pallet<T> {
         tick_low: TickIndex,
         tick_high: TickIndex,
         liquidity: u64,
-    ) -> Result<(u64, u64), Error<T>> {
+    ) -> Result<(PositionId, u64, u64), Error<T>> {
+        let (position, tao, alpha) =
+            Self::add_liquidity_not_insert(netuid, account_id, tick_low, tick_high, liquidity)?;
+        let position_id = position.id;
+
+        ensure!(
+            T::LiquidityDataProvider::tao_balance(netuid.into(), account_id) >= tao
+                && T::LiquidityDataProvider::alpha_balance(netuid.into(), account_id) >= alpha,
+            Error::<T>::InsufficientBalance
+        );
+
+        Positions::<T>::insert(&(netuid, account_id, position.id), position);
+
+        Ok((position_id, tao, alpha))
+    }
+
+    // add liquidity without inserting position into storage (used privately for v3 intiialization).
+    // unlike Self::add_liquidity it also doesn't perform account's balance check.
+    //
+    // the public interface is [`Self::add_liquidity`]
+    fn add_liquidity_not_insert(
+        netuid: NetUid,
+        account_id: &T::AccountId,
+        tick_low: TickIndex,
+        tick_high: TickIndex,
+        liquidity: u64,
+    ) -> Result<(Position, u64, u64), Error<T>> {
         ensure!(
             Self::count_positions(netuid, account_id) <= T::MaxPositions::get() as usize,
             Error::<T>::MaxPositionsExceeded
@@ -620,8 +648,9 @@ impl<T: Config> Pallet<T> {
         Self::update_liquidity_if_needed(netuid, tick_low, tick_high, liquidity as i128);
 
         // New position
+        let position_id = PositionId::new();
         let position = Position {
-            id: PositionId::new(),
+            id: position_id,
             netuid,
             tick_low,
             tick_high,
@@ -649,11 +678,9 @@ impl<T: Config> Pallet<T> {
         //     self.state_ops.set_alpha_reserve(new_alpha_reserve);
         // }
 
-        Positions::<T>::insert(&(netuid, account_id, position.id), position);
-
         SwapV3Initialized::<T>::set(netuid, true);
 
-        Ok((tao, alpha))
+        Ok((position, tao, alpha))
     }
 
     /// Remove liquidity and credit balances back to account_id
@@ -833,6 +860,49 @@ mod tests {
     use super::*;
     use crate::{mock::*, pallet::*};
 
+    // this function is used to convert price (NON-SQRT price!) to TickIndex. it's only utility for
+    // testing, all the implementation logic is based on sqrt prices
+    fn price_to_tick(price: f64) -> TickIndex {
+        let price_sqrt: SqrtPrice = SqrtPrice::from_num(price.sqrt());
+        // Handle potential errors in the conversion
+        match TickIndex::try_from_sqrt_price(price_sqrt) {
+            Ok(mut tick) => {
+                // Ensure the tick is within bounds
+                if tick > TickIndex::MAX {
+                    tick = TickIndex::MAX;
+                } else if tick < TickIndex::MIN {
+                    tick = TickIndex::MIN;
+                }
+                tick
+            }
+            // Default to a reasonable value when conversion fails
+            Err(_) => {
+                if price > 1.0 {
+                    TickIndex::MAX
+                } else {
+                    TickIndex::MIN
+                }
+            }
+        }
+    }
+
+    // this function is used to convert tick index NON-SQRT (!) price. it's only utility for
+    // testing, all the implementation logic is based on sqrt prices
+    fn tick_to_price(tick: TickIndex) -> f64 {
+        // Handle errors gracefully
+        match tick.try_to_sqrt_price() {
+            Ok(price_sqrt) => (price_sqrt * price_sqrt).to_num::<f64>(),
+            Err(_) => {
+                // Return a sensible default based on whether the tick is above or below the valid range
+                if tick > TickIndex::MAX {
+                    tick_to_price(TickIndex::MAX) // Use the max valid tick price
+                } else {
+                    tick_to_price(TickIndex::MIN) // Use the min valid tick price
+                }
+            }
+        }
+    }
+
     #[test]
     fn test_swap_initialization() {
         new_test_ext().execute_with(|| {
@@ -890,25 +960,13 @@ mod tests {
     // Test adding liquidity on top of the existing protocol liquidity
     #[test]
     fn test_add_liquidity_basic() {
-        assert!(false, "unfinished transfering from Swap");
-
         new_test_ext().execute_with(|| {
-            let account_id = 1;
-            let netuid = NetUid::from(1);
-            let min_price = TickIndex::MIN
-                .try_to_sqrt_price()
-                .unwrap()
-                .saturating_to_num::<f32>();
-            let max_price = TickIndex::MAX
-                .try_to_sqrt_price()
-                .unwrap()
-                .saturating_to_num::<f32>();
-            let max_tick = TickIndex::from_sqrt_price_bounded(SqrtPrice::from_num(max_price));
+            let min_price = tick_to_price(TickIndex::MIN);
+            let max_price = tick_to_price(TickIndex::MAX);
+            let max_tick = price_to_tick(max_price);
             let current_price = 0.25;
             assert_eq!(max_tick, TickIndex::MAX);
 
-            assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
-
             // As a user add liquidity with all possible corner cases
             //   - Initial price is 0.25
             //   - liquidity is expressed in RAO units
@@ -935,35 +993,14 @@ mod tests {
             ]
             .into_iter()
             .enumerate()
-            .map(|(n, (price_low, price_high, liquidity, tao, alpha))| {
-                (
-                    n + 1,
-                    SqrtPrice::from_num(price_low),
-                    SqrtPrice::from_num(price_high),
-                    liquidity,
-                    tao,
-                    alpha,
-                )
-            })
+            .map(|(n, v)| (NetUid::from(n as u16 + 1), v.0, v.1, v.2, v.3, v.4))
             .for_each(
-                |(
-                    expected_count,
-                    price_low,
-                    price_high,
-                    liquidity,
-                    expected_tao,
-                    expected_alpha,
-                )| {
-                    // Calculate ticks (assuming tick math is tested separately)
-                    let tick_low = TickIndex::from_sqrt_price_bounded(price_low);
-                    let tick_high = TickIndex::from_sqrt_price_bounded(price_high);
+                |(netuid, price_low, price_high, liquidity, expected_tao, expected_alpha)| {
+                    assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
 
-                    // // Setup swap
-                    // let mut mock_ops = MockSwapDataOperations::new();
-                    // mock_ops.set_tao_reserve(protocol_tao);
-                    // mock_ops.set_alpha_reserve(protocol_alpha);
-                    // mock_ops.deposit_balances(&account_id, user_tao, user_alpha);
-                    // let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
+                    // Calculate ticks (assuming tick math is tested separately)
+                    let tick_low = price_to_tick(price_low);
+                    let tick_high = price_to_tick(price_high);
 
                     // Get tick infos and liquidity before adding (to account for protocol liquidity)
                     let tick_low_info_before =
@@ -973,15 +1010,17 @@ mod tests {
                     let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
 
                     // Add liquidity
-                    let (tao, alpha) = Pallet::<Test>::add_liquidity(
+                    let (position_id, tao, alpha) = Pallet::<Test>::add_liquidity(
                         netuid,
-                        &account_id,
+                        &OK_ACCOUNT_ID,
                         tick_low,
                         tick_high,
                         liquidity,
                     )
                     .unwrap();
 
+                    // dbg!((tao, expected_tao), (alpha, expected_alpha));
+
                     assert_abs_diff_eq!(tao, expected_tao, epsilon = tao / 1000);
                     assert_abs_diff_eq!(alpha, expected_alpha, epsilon = alpha / 1000);
 
@@ -1010,46 +1049,26 @@ mod tests {
                         expected_liquidity_gross_high,
                     );
 
-                    // // Balances are withdrawn
-                    // let (user_tao_after, user_alpha_after) =
-                    //     swap.state_ops.balances.get(&account_id).unwrap();
-                    // let tao_withdrawn = user_tao - user_tao_after;
-                    // let alpha_withdrawn = user_alpha - user_alpha_after;
-                    // assert_abs_diff_eq!(tao_withdrawn, *tao, epsilon = *tao / 1000);
-                    // assert_abs_diff_eq!(alpha_withdrawn, *alpha, epsilon = *alpha / 1000);
-
                     // Liquidity position at correct ticks
-                    assert_eq!(
-                        Pallet::<Test>::count_positions(netuid, &account_id),
-                        expected_count
-                    );
-
-                    // let position = swap.state_ops.get_position(&account_id, 0).unwrap();
-                    // assert_eq!(position.liquidity, *liquidity);
-                    // assert_eq!(position.tick_low, tick_low);
-                    // assert_eq!(position.tick_high, tick_high);
-                    // assert_eq!(position.fees_alpha, 0);
-                    // assert_eq!(position.fees_tao, 0);
-
-                    // // Current liquidity is updated only when price range includes the current price
-                    // if (*price_high >= current_price) && (*price_low <= current_price) {
-                    //     assert_eq!(
-                    //         swap.state_ops.get_current_liquidity(),
-                    //         liquidity_before + *liquidity
-                    //     );
-                    // } else {
-                    //     assert_eq!(swap.state_ops.get_current_liquidity(), liquidity_before);
-                    // }
-
-                    // // Reserves are updated
-                    // assert_eq!(
-                    //     swap.state_ops.get_tao_reserve(),
-                    //     tao_withdrawn + protocol_tao,
-                    // );
-                    // assert_eq!(
-                    //     swap.state_ops.get_alpha_reserve(),
-                    //     alpha_withdrawn + protocol_alpha,
-                    // );
+                    assert_eq!(Pallet::<Test>::count_positions(netuid, &OK_ACCOUNT_ID), 1);
+
+                    let position =
+                        Positions::<Test>::get(&(netuid, OK_ACCOUNT_ID, position_id)).unwrap();
+                    assert_eq!(position.liquidity, liquidity);
+                    assert_eq!(position.tick_low, tick_low);
+                    assert_eq!(position.tick_high, tick_high);
+                    assert_eq!(position.fees_alpha, 0);
+                    assert_eq!(position.fees_tao, 0);
+
+                    // Current liquidity is updated only when price range includes the current price
+                    let expected_liquidity =
+                        if (price_high >= current_price) && (price_low <= current_price) {
+                            liquidity_before + liquidity
+                        } else {
+                            liquidity_before
+                        };
+
+                    assert_eq!(CurrentLiquidity::<Test>::get(netuid), expected_liquidity)
                 },
             );
         });
@@ -1058,11 +1077,6 @@ mod tests {
     #[test]
     fn test_add_liquidity_out_of_bounds() {
         new_test_ext().execute_with(|| {
-            let netuid = NetUid::from(1);
-            let account_id = 1;
-
-            assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
-
             [
                 // For our tests, we'll construct TickIndex values that are intentionally
                 // outside the valid range for testing purposes only
@@ -1088,10 +1102,14 @@ mod tests {
                 ),
             ]
             .into_iter()
-            .for_each(|(tick_low, tick_high, liquidity)| {
+            .enumerate()
+            .map(|(n, v)| (NetUid::from(n as u16), v.0, v.1, v.2))
+            .for_each(|(netuid, tick_low, tick_high, liquidity)| {
+                assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
+
                 // Add liquidity
                 assert_err!(
-                    Swap::add_liquidity(netuid, &account_id, tick_low, tick_high, liquidity),
+                    Swap::add_liquidity(netuid, &OK_ACCOUNT_ID, tick_low, tick_high, liquidity),
                     Error::<Test>::InvalidTickRange,
                 );
             });
@@ -1100,12 +1118,8 @@ mod tests {
 
     #[test]
     fn test_add_liquidity_over_balance() {
-        assert!(false, "unfinished transfering from Swap");
         new_test_ext().execute_with(|| {
-            let account_id = 1;
-            let netuid = NetUid::from(1);
-
-            assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
+            let account_id = 2;
 
             [
                 // Lower than price (not enough alpha)
@@ -1116,11 +1130,14 @@ mod tests {
                 (0.1, 0.4, 100_000_000_000_u64),
             ]
             .into_iter()
-            .map(|(pl, ph, l)| (SqrtPrice::from_num(pl), SqrtPrice::from_num(ph), l))
-            .for_each(|(price_low, price_high, liquidity)| {
+            .enumerate()
+            .map(|(n, v)| (NetUid::from(n as u16), v.0, v.1, v.2))
+            .for_each(|(netuid, price_low, price_high, liquidity)| {
                 // Calculate ticks
-                let tick_low = TickIndex::from_sqrt_price_bounded(price_low);
-                let tick_high = TickIndex::from_sqrt_price_bounded(price_high);
+                let tick_low = price_to_tick(price_low);
+                let tick_high = price_to_tick(price_high);
+
+                assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
 
                 // Add liquidity
                 assert_err!(
@@ -1136,4 +1153,112 @@ mod tests {
             });
         });
     }
+
+    #[test]
+    fn test_remove_liquidity_basic() {
+        new_test_ext().execute_with(|| {
+            let min_price = tick_to_price(TickIndex::MIN);
+            let max_price = tick_to_price(TickIndex::MAX);
+            let max_tick = price_to_tick(max_price);
+            assert_eq!(max_tick, TickIndex::MAX);
+
+            // As a user add liquidity with all possible corner cases
+            //   - Initial price is 0.25
+            //   - liquidity is expressed in RAO units
+            // Test case is (price_low, price_high, liquidity, tao, alpha)
+            [
+                // Repeat the protocol liquidity at maximum range: Expect all the same values
+                (
+                    min_price,
+                    max_price,
+                    2_000_000_000_u64,
+                    1_000_000_000_u64,
+                    4_000_000_000_u64,
+                ),
+                // Repeat the protocol liquidity at current to max range: Expect the same alpha
+                (0.25, max_price, 2_000_000_000_u64, 0, 4_000_000_000),
+                // Repeat the protocol liquidity at min to current range: Expect all the same tao
+                (min_price, 0.24999, 2_000_000_000_u64, 1_000_000_000, 0),
+                // Half to double price - just some sane wothdraw amounts
+                (0.125, 0.5, 2_000_000_000_u64, 293_000_000, 1_171_000_000),
+                // Both below price - tao is non-zero, alpha is zero
+                (0.12, 0.13, 2_000_000_000_u64, 28_270_000, 0),
+                // Both above price - tao is zero, alpha is non-zero
+                (0.3, 0.4, 2_000_000_000_u64, 0, 489_200_000),
+            ]
+            .into_iter()
+            .enumerate()
+            .map(|(n, v)| (NetUid::from(n as u16), v.0, v.1, v.2, v.3, v.4))
+            .for_each(|(netuid, price_low, price_high, liquidity, tao, alpha)| {
+                // Calculate ticks (assuming tick math is tested separately)
+                let tick_low = price_to_tick(price_low);
+                let tick_high = price_to_tick(price_high);
+
+                assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
+                let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
+
+                // Add liquidity
+                let (position_id, _, _) = Pallet::<Test>::add_liquidity(
+                    netuid,
+                    &OK_ACCOUNT_ID,
+                    tick_low,
+                    tick_high,
+                    liquidity,
+                )
+                .unwrap();
+
+                // Remove liquidity
+                let remove_result =
+                    Pallet::<Test>::remove_liquidity(netuid, &OK_ACCOUNT_ID, position_id).unwrap();
+                assert_abs_diff_eq!(remove_result.tao, tao, epsilon = tao / 1000);
+                assert_abs_diff_eq!(remove_result.alpha, alpha, epsilon = alpha / 1000);
+                assert_eq!(remove_result.fee_tao, 0);
+                assert_eq!(remove_result.fee_alpha, 0);
+
+                // Liquidity position is removed
+                assert_eq!(Pallet::<Test>::count_positions(netuid, &OK_ACCOUNT_ID), 0);
+                assert!(Positions::<Test>::get((netuid, OK_ACCOUNT_ID, position_id)).is_none());
+
+                // Current liquidity is updated (back where it was)
+                assert_eq!(CurrentLiquidity::<Test>::get(netuid), liquidity_before);
+            });
+        });
+    }
+
+    #[test]
+    fn test_remove_liquidity_nonexisting_position() {
+        new_test_ext().execute_with(|| {
+            let min_price = tick_to_price(TickIndex::MIN);
+            let max_price = tick_to_price(TickIndex::MAX);
+            let max_tick = price_to_tick(max_price);
+            assert_eq!(max_tick.get(), TickIndex::MAX.get());
+
+            let liquidity = 2_000_000_000_u64;
+            let netuid = NetUid::from(1);
+
+            // Calculate ticks (assuming tick math is tested separately)
+            let tick_low = price_to_tick(min_price);
+            let tick_high = price_to_tick(max_price);
+
+            // Setup swap
+            assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
+
+            // Add liquidity
+            assert_ok!(Pallet::<Test>::add_liquidity(
+                netuid,
+                &OK_ACCOUNT_ID,
+                tick_low,
+                tick_high,
+                liquidity,
+            ));
+
+            assert!(Pallet::<Test>::count_positions(netuid, &OK_ACCOUNT_ID) > 0);
+
+            // Remove liquidity
+            assert_err!(
+                Pallet::<Test>::remove_liquidity(netuid, &OK_ACCOUNT_ID, PositionId::new()),
+                Error::<Test>::LiquidityNotFound,
+            );
+        });
+    }
 }
diff --git a/pallets/swap/src/pallet/mod.rs b/pallets/swap/src/pallet/mod.rs
index e6cefbd036..fdaaeb0f73 100644
--- a/pallets/swap/src/pallet/mod.rs
+++ b/pallets/swap/src/pallet/mod.rs
@@ -32,7 +32,7 @@ mod pallet {
 
         /// Implementor of
         /// [`LiquidityDataProvider`](pallet_subtensor_swap_interface::LiquidityDataProvider).
-        type LiquidityDataProvider: LiquidityDataProvider;
+        type LiquidityDataProvider: LiquidityDataProvider<Self::AccountId>;
 
         /// This type is used to derive protocol accoun ID.
         #[pallet::constant]
diff --git a/pallets/swap/src/position.rs b/pallets/swap/src/position.rs
index 2a275e0e19..2d4e2c77ed 100644
--- a/pallets/swap/src/position.rs
+++ b/pallets/swap/src/position.rs
@@ -146,3 +146,9 @@ impl From<PositionId> for Uuid {
         Uuid::from_bytes(value.0)
     }
 }
+
+impl From<[u8; 16]> for PositionId {
+    fn from(value: [u8; 16]) -> Self {
+        Self(value)
+    }
+}
diff --git a/pallets/swap/src/swap.rs b/pallets/swap/src/swap.rs
index 34a35e8cc2..bc7cee5239 100644
--- a/pallets/swap/src/swap.rs
+++ b/pallets/swap/src/swap.rs
@@ -681,354 +681,6 @@ mod tests {
         }
     }
 
-    // Test adding liquidity on top of the existing protocol liquidity
-	#[ignore]
-    #[test]
-    fn test_add_liquidity_basic() {
-        let protocol_tao = 1_000_000_000;
-        let protocol_alpha = 4_000_000_000;
-        let user_tao = 100_000_000_000;
-        let user_alpha = 100_000_000_000;
-        let account_id = 1;
-        let min_price = tick_to_price(TickIndex::MIN);
-        let max_price = tick_to_price(TickIndex::MAX);
-        let max_tick = price_to_tick(max_price);
-        let current_price = 0.25;
-        assert_eq!(max_tick, TickIndex::MAX);
-
-        // As a user add liquidity with all possible corner cases
-        //   - Initial price is 0.25
-        //   - liquidity is expressed in RAO units
-        // Test case is (price_low, price_high, liquidity, tao, alpha)
-        [
-            // Repeat the protocol liquidity at maximum range: Expect all the same values
-            (
-                min_price,
-                max_price,
-                2_000_000_000_u64,
-                1_000_000_000_u64,
-                4_000_000_000_u64,
-            ),
-            // Repeat the protocol liquidity at current to max range: Expect the same alpha
-            (0.25, max_price, 2_000_000_000_u64, 0, 4_000_000_000),
-            // Repeat the protocol liquidity at min to current range: Expect all the same tao
-            (min_price, 0.24999, 2_000_000_000_u64, 1_000_000_000, 0),
-            // Half to double price - just some sane wothdraw amounts
-            (0.125, 0.5, 2_000_000_000_u64, 293_000_000, 1_171_000_000),
-            // Both below price - tao is non-zero, alpha is zero
-            (0.12, 0.13, 2_000_000_000_u64, 28_270_000, 0),
-            // Both above price - tao is zero, alpha is non-zero
-            (0.3, 0.4, 2_000_000_000_u64, 0, 489_200_000),
-        ]
-        .iter()
-        .for_each(|(price_low, price_high, liquidity, tao, alpha)| {
-            // Calculate ticks (assuming tick math is tested separately)
-            let tick_low = price_to_tick(*price_low);
-            let tick_high = price_to_tick(*price_high);
-
-            // Setup swap
-            let mut mock_ops = MockSwapDataOperations::new();
-            mock_ops.set_tao_reserve(protocol_tao);
-            mock_ops.set_alpha_reserve(protocol_alpha);
-            mock_ops.deposit_balances(&account_id, user_tao, user_alpha);
-            let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
-
-            // Get tick infos and liquidity before adding (to account for protocol liquidity)
-            let tick_low_info_before = swap
-                .state_ops
-                .get_tick_by_index(tick_low)
-                .unwrap_or_default();
-            let tick_high_info_before = swap
-                .state_ops
-                .get_tick_by_index(tick_high)
-                .unwrap_or_default();
-            let liquidity_before = swap.state_ops.get_current_liquidity();
-
-            // Add liquidity
-            assert!(
-                swap.add_liquidity(&account_id, tick_low, tick_high, *liquidity, false)
-                    .is_ok()
-            );
-
-            // Check that low and high ticks appear in the state and are properly updated
-            let tick_low_info = swap.state_ops.get_tick_by_index(tick_low).unwrap();
-            let tick_high_info = swap.state_ops.get_tick_by_index(tick_high).unwrap();
-            let expected_liquidity_net_low: i128 = *liquidity as i128;
-            let expected_liquidity_gross_low: u64 = *liquidity;
-            let expected_liquidity_net_high: i128 = (*liquidity as i128).neg();
-            let expected_liquidity_gross_high: u64 = *liquidity;
-            assert_eq!(
-                tick_low_info.liquidity_net - tick_low_info_before.liquidity_net,
-                expected_liquidity_net_low,
-            );
-            assert_eq!(
-                tick_low_info.liquidity_gross - tick_low_info_before.liquidity_gross,
-                expected_liquidity_gross_low,
-            );
-            assert_eq!(
-                tick_high_info.liquidity_net - tick_high_info_before.liquidity_net,
-                expected_liquidity_net_high,
-            );
-            assert_eq!(
-                tick_high_info.liquidity_gross - tick_high_info_before.liquidity_gross,
-                expected_liquidity_gross_high,
-            );
-
-            // Balances are withdrawn
-            let (user_tao_after, user_alpha_after) =
-                swap.state_ops.balances.get(&account_id).unwrap();
-            let tao_withdrawn = user_tao - user_tao_after;
-            let alpha_withdrawn = user_alpha - user_alpha_after;
-            assert_abs_diff_eq!(tao_withdrawn, *tao, epsilon = *tao / 1000);
-            assert_abs_diff_eq!(alpha_withdrawn, *alpha, epsilon = *alpha / 1000);
-
-            // Liquidity position at correct ticks
-            assert_eq!(swap.state_ops.get_position_count(&account_id), 1);
-
-            let position = swap.state_ops.get_position(&account_id, 0).unwrap();
-            assert_eq!(position.liquidity, *liquidity);
-            assert_eq!(position.tick_low, tick_low);
-            assert_eq!(position.tick_high, tick_high);
-            assert_eq!(position.fees_alpha, 0);
-            assert_eq!(position.fees_tao, 0);
-
-            // Current liquidity is updated only when price range includes the current price
-            if (*price_high >= current_price) && (*price_low <= current_price) {
-                assert_eq!(
-                    swap.state_ops.get_current_liquidity(),
-                    liquidity_before + *liquidity
-                );
-            } else {
-                assert_eq!(swap.state_ops.get_current_liquidity(), liquidity_before);
-            }
-
-            // Reserves are updated
-            assert_eq!(
-                swap.state_ops.get_tao_reserve(),
-                tao_withdrawn + protocol_tao,
-            );
-            assert_eq!(
-                swap.state_ops.get_alpha_reserve(),
-                alpha_withdrawn + protocol_alpha,
-            );
-        });
-    }
-
-	#[ignore]
-    #[test]
-    fn test_add_liquidity_out_of_bounds() {
-        let protocol_tao = 1_000_000_000;
-        let protocol_alpha = 2_000_000_000;
-        let user_tao = 100_000_000_000;
-        let user_alpha = 100_000_000_000;
-        let account_id = 1;
-
-        [
-            // For our tests, we'll construct TickIndex values that are intentionally
-            // outside the valid range for testing purposes only
-            (
-                TickIndex::new_unchecked(TickIndex::MIN.get() - 1),
-                TickIndex::MAX,
-                1_000_000_000_u64,
-            ),
-            (
-                TickIndex::MIN,
-                TickIndex::new_unchecked(TickIndex::MAX.get() + 1),
-                1_000_000_000_u64,
-            ),
-            (
-                TickIndex::new_unchecked(TickIndex::MIN.get() - 1),
-                TickIndex::new_unchecked(TickIndex::MAX.get() + 1),
-                1_000_000_000_u64,
-            ),
-            (
-                TickIndex::new_unchecked(TickIndex::MIN.get() - 100),
-                TickIndex::new_unchecked(TickIndex::MAX.get() + 100),
-                1_000_000_000_u64,
-            ),
-        ]
-        .iter()
-        .for_each(|(tick_low, tick_high, liquidity)| {
-            // Setup swap
-            let mut mock_ops = MockSwapDataOperations::new();
-            mock_ops.set_tao_reserve(protocol_tao);
-            mock_ops.set_alpha_reserve(protocol_alpha);
-            mock_ops.deposit_balances(&account_id, user_tao, user_alpha);
-            let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
-
-            // Add liquidity
-            assert_eq!(
-                swap.add_liquidity(&account_id, *tick_low, *tick_high, *liquidity, false),
-                Err(SwapError::InvalidTickRange),
-            );
-        });
-    }
-
-	#[ignore]
-    #[test]
-    fn test_add_liquidity_over_balance() {
-        let protocol_tao = 1_000_000_000;
-        let protocol_alpha = 4_000_000_000;
-        let user_tao = 1_000_000_000;
-        let user_alpha = 1_000_000_000;
-        let account_id = 1;
-
-        [
-            // Lower than price (not enough alpha)
-            (0.1, 0.2, 100_000_000_000_u64),
-            // Higher than price (not enough tao)
-            (0.3, 0.4, 100_000_000_000_u64),
-            // Around the price (not enough both)
-            (0.1, 0.4, 100_000_000_000_u64),
-        ]
-        .iter()
-        .for_each(|(price_low, price_high, liquidity)| {
-            // Calculate ticks
-            let tick_low = price_to_tick(*price_low);
-            let tick_high = price_to_tick(*price_high);
-
-            // Setup swap
-            let mut mock_ops = MockSwapDataOperations::new();
-            mock_ops.set_tao_reserve(protocol_tao);
-            mock_ops.set_alpha_reserve(protocol_alpha);
-            mock_ops.deposit_balances(&account_id, user_tao, user_alpha);
-            let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
-
-            // Add liquidity
-            assert_eq!(
-                swap.add_liquidity(&account_id, tick_low, tick_high, *liquidity, false),
-                Err(SwapError::InsufficientBalance),
-            );
-        });
-    }
-
-    // Test removing liquidity
-    #[test]
-    fn test_remove_liquidity_basic() {
-        let protocol_tao = 1_000_000_000;
-        let protocol_alpha = 4_000_000_000;
-        let user_tao = 100_000_000_000;
-        let user_alpha = 100_000_000_000;
-        let account_id = 1;
-        let min_price = tick_to_price(TickIndex::MIN);
-        let max_price = tick_to_price(TickIndex::MAX);
-        let max_tick = price_to_tick(max_price);
-        assert_eq!(max_tick, TickIndex::MAX);
-
-        // As a user add liquidity with all possible corner cases
-        //   - Initial price is 0.25
-        //   - liquidity is expressed in RAO units
-        // Test case is (price_low, price_high, liquidity, tao, alpha)
-        [
-            // Repeat the protocol liquidity at maximum range: Expect all the same values
-            (
-                min_price,
-                max_price,
-                2_000_000_000_u64,
-                1_000_000_000_u64,
-                4_000_000_000_u64,
-            ),
-            // Repeat the protocol liquidity at current to max range: Expect the same alpha
-            (0.25, max_price, 2_000_000_000_u64, 0, 4_000_000_000),
-            // Repeat the protocol liquidity at min to current range: Expect all the same tao
-            (min_price, 0.24999, 2_000_000_000_u64, 1_000_000_000, 0),
-            // Half to double price - just some sane wothdraw amounts
-            (0.125, 0.5, 2_000_000_000_u64, 293_000_000, 1_171_000_000),
-            // Both below price - tao is non-zero, alpha is zero
-            (0.12, 0.13, 2_000_000_000_u64, 28_270_000, 0),
-            // Both above price - tao is zero, alpha is non-zero
-            (0.3, 0.4, 2_000_000_000_u64, 0, 489_200_000),
-        ]
-        .iter()
-        .for_each(|(price_low, price_high, liquidity, tao, alpha)| {
-            // Calculate ticks (assuming tick math is tested separately)
-            let tick_low = price_to_tick(*price_low);
-            let tick_high = price_to_tick(*price_high);
-
-            // Setup swap
-            let mut mock_ops = MockSwapDataOperations::new();
-            mock_ops.set_tao_reserve(protocol_tao);
-            mock_ops.set_alpha_reserve(protocol_alpha);
-            mock_ops.deposit_balances(&account_id, user_tao, user_alpha);
-            let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
-            let liquidity_before = swap.state_ops.get_current_liquidity();
-
-            // Add liquidity
-            assert!(
-                swap.add_liquidity(&account_id, tick_low, tick_high, *liquidity, false)
-                    .is_ok()
-            );
-
-            // Remove liquidity
-            let remove_result = swap.remove_liquidity(&account_id, 0).unwrap();
-            assert_abs_diff_eq!(remove_result.tao, *tao, epsilon = *tao / 1000);
-            assert_abs_diff_eq!(remove_result.alpha, *alpha, epsilon = *alpha / 1000);
-            assert_eq!(remove_result.fee_tao, 0);
-            assert_eq!(remove_result.fee_alpha, 0);
-
-            // Balances are returned
-            let (user_tao_after, user_alpha_after) =
-                swap.state_ops.balances.get(&account_id).unwrap();
-            assert_eq!(user_tao, *user_tao_after);
-            assert_eq!(user_alpha, *user_alpha_after);
-
-            // Liquidity position is removed
-            assert_eq!(swap.state_ops.get_position_count(&account_id), 0);
-            assert!(swap.state_ops.get_position(&account_id, 0).is_none());
-
-            // Current liquidity is updated (back where it was)
-            assert_eq!(swap.state_ops.get_current_liquidity(), liquidity_before);
-
-            // Reserves are updated (back where they were)
-            assert_eq!(swap.state_ops.get_tao_reserve(), protocol_tao,);
-            assert_eq!(swap.state_ops.get_alpha_reserve(), protocol_alpha,);
-        });
-    }
-
-    #[test]
-    fn test_remove_liquidity_nonexisting_position() {
-        let protocol_tao = 1_000_000_000;
-        let protocol_alpha = 4_000_000_000;
-        let user_tao = 100_000_000_000;
-        let user_alpha = 100_000_000_000;
-        let account_id = 1;
-        let min_price = tick_to_price(TickIndex::MIN);
-        let max_price = tick_to_price(TickIndex::MAX);
-        let max_tick = price_to_tick(max_price);
-        assert_eq!(max_tick.get(), TickIndex::MAX.get());
-
-        // Test case is (price_low, price_high, liquidity)
-        [
-            // Repeat the protocol liquidity at maximum range: Expect all the same values
-            (min_price, max_price, 2_000_000_000_u64),
-        ]
-        .iter()
-        .for_each(|(price_low, price_high, liquidity)| {
-            // Calculate ticks (assuming tick math is tested separately)
-            let tick_low = price_to_tick(*price_low);
-            let tick_high = price_to_tick(*price_high);
-
-            // Setup swap
-            let mut mock_ops = MockSwapDataOperations::new();
-            mock_ops.set_tao_reserve(protocol_tao);
-            mock_ops.set_alpha_reserve(protocol_alpha);
-            mock_ops.deposit_balances(&account_id, user_tao, user_alpha);
-            let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
-
-            // Add liquidity
-            assert!(
-                swap.add_liquidity(&account_id, tick_low, tick_high, *liquidity, false)
-                    .is_ok()
-            );
-
-            // Remove liquidity
-            assert_eq!(
-                swap.remove_liquidity(&account_id, 1),
-                Err(SwapError::LiquidityNotFound),
-            );
-        });
-    }
-
     // Test swapping against protocol liquidity only
     #[test]
     fn test_swap_basic() {
diff --git a/pallets/swap/src/tick.rs b/pallets/swap/src/tick.rs
index 9a690cb235..17fe6f9e88 100644
--- a/pallets/swap/src/tick.rs
+++ b/pallets/swap/src/tick.rs
@@ -1415,4 +1415,17 @@ mod tests {
         let max_tick = TickIndex::try_from_sqrt_price(max_price_sqrt).unwrap();
         assert_eq!(max_tick, TickIndex::MAX);
     }
+
+    #[test]
+    fn test_to_sqrt_price_bounded() {
+        assert_eq!(
+            TickIndex::MAX.to_sqrt_price_bounded(),
+            TickIndex::MAX.try_to_sqrt_price().unwrap()
+        );
+
+        assert_eq!(
+            TickIndex::MIN.to_sqrt_price_bounded(),
+            TickIndex::MIN.try_to_sqrt_price().unwrap()
+        );
+    }
 }

From c6db119aed4d15a9f9d0de195f1a12549f990ea4 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Tue, 1 Apr 2025 19:09:38 +0200
Subject: [PATCH 044/418] Port swap tests

---
 pallets/swap/src/pallet/impls.rs | 109 ++++++++++++++++++++++++++++++-
 pallets/swap/src/swap.rs         | 105 -----------------------------
 2 files changed, 108 insertions(+), 106 deletions(-)

diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 1ec4ef645c..965baea88f 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -238,7 +238,7 @@ impl<T: Config> Pallet<T> {
         let delta_out = Self::convert_deltas(netuid, order_type, delta_in);
 
         // TODO (look inside method)
-        Self::update_reserves(netuid, order_type, delta_in, delta_out);
+        // Self::update_reserves(netuid, order_type, delta_in, delta_out);
 
         // Get current tick
         let current_tick_index = TickIndex::current_bounded::<T>(netuid);
@@ -1261,4 +1261,111 @@ mod tests {
             );
         });
     }
+
+    #[test]
+    fn test_swap_basic() {
+        new_test_ext().execute_with(|| {
+            // Current price is 0.25
+            // Test case is (order_type, liquidity, limit_price, output_amount)
+            [(OrderType::Buy, 500_000_000u64, 1000.0_f64, 3990_u64)]
+                .into_iter()
+                .enumerate()
+                .map(|(n, v)| (NetUid::from(n as u16), v.0, v.1, v.2, v.3))
+                .for_each(
+                    |(netuid, order_type, liquidity, limit_price, output_amount)| {
+                        // Consumed liquidity ticks
+                        let tick_low = TickIndex::MIN;
+                        let tick_high = TickIndex::MAX;
+
+                        // Setup swap
+                        assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
+
+                        // Get tick infos before the swap
+                        let tick_low_info_before =
+                            Ticks::<Test>::get(netuid, tick_low).unwrap_or_default();
+                        let tick_high_info_before =
+                            Ticks::<Test>::get(netuid, tick_high).unwrap_or_default();
+                        let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
+
+                        // Swap
+                        let sqrt_limit_price = SqrtPrice::from_num((limit_price).sqrt());
+                        let swap_result =
+                            Pallet::<Test>::swap(netuid, order_type, liquidity, sqrt_limit_price);
+                        // assert_abs_diff_eq!(
+                        //     swap_result.unwrap().amount_paid_out,
+                        //     *output_amount,
+                        //     epsilon = *output_amount/1000
+                        // );
+
+                        // Check that low and high ticks' fees were updated properly, and liquidity values were not updated
+                        let tick_low_info = Ticks::<Test>::get(netuid, tick_low).unwrap();
+                        let tick_high_info = Ticks::<Test>::get(netuid, tick_high).unwrap();
+                        let expected_liquidity_net_low = tick_low_info_before.liquidity_net;
+                        let expected_liquidity_gross_low = tick_low_info_before.liquidity_gross;
+                        let expected_liquidity_net_high = tick_high_info_before.liquidity_net;
+                        let expected_liquidity_gross_high = tick_high_info_before.liquidity_gross;
+                        assert_eq!(tick_low_info.liquidity_net, expected_liquidity_net_low,);
+                        assert_eq!(tick_low_info.liquidity_gross, expected_liquidity_gross_low,);
+                        assert_eq!(tick_high_info.liquidity_net, expected_liquidity_net_high,);
+                        assert_eq!(
+                            tick_high_info.liquidity_gross,
+                            expected_liquidity_gross_high,
+                        );
+
+                        // Expected fee amount
+                        let fee_rate = FeeRate::<Test>::get(netuid) as f64 / u16::MAX as f64;
+                        let expected_fee = output_amount * fee_rate as u64;
+
+                        // Global fees should be updated
+                        let actual_global_fee = match order_type {
+                            OrderType::Buy => FeeGlobalAlpha::<Test>::get(netuid),
+                            OrderType::Sell => FeeGlobalTao::<Test>::get(netuid),
+                        };
+                        println!("actual_global_fee {:?}", actual_global_fee);
+                        assert_eq!(actual_global_fee, expected_fee);
+
+                        // Tick fees should be updated
+
+                        // Liquidity position should not be updated
+                        let protocol_id = Pallet::<Test>::protocol_account_id();
+                        let positions =
+                            Positions::<Test>::iter_prefix_values((netuid, protocol_id))
+                                .collect::<Vec<_>>();
+                        let position = positions.first().unwrap();
+
+                        assert_eq!(
+                            position.liquidity,
+                            helpers_128bit::sqrt(
+                                MockLiquidityProvider::tao_reserve(netuid.into()) as u128
+                                    * MockLiquidityProvider::alpha_reserve(netuid.into()) as u128
+                            ) as u64
+                        );
+                        assert_eq!(position.tick_low, tick_low);
+                        assert_eq!(position.tick_high, tick_high);
+                        assert_eq!(position.fees_alpha, 0);
+                        assert_eq!(position.fees_tao, 0);
+
+                        // // Current liquidity is updated only when price range includes the current price
+                        // if (*price_high >= current_price) && (*price_low <= current_price) {
+                        //     assert_eq!(
+                        //         swap.state_ops.get_current_liquidity(),
+                        //         liquidity_before + *liquidity
+                        //     );
+                        // } else {
+                        //     assert_eq!(swap.state_ops.get_current_liquidity(), liquidity_before);
+                        // }
+
+                        // // Reserves are updated
+                        // assert_eq!(
+                        //     swap.state_ops.get_tao_reserve(),
+                        //     tao_withdrawn + protocol_tao,
+                        // );
+                        // assert_eq!(
+                        //     swap.state_ops.get_alpha_reserve(),
+                        //     alpha_withdrawn + protocol_alpha,
+                        // );
+                    },
+                );
+        });
+    }
 }
diff --git a/pallets/swap/src/swap.rs b/pallets/swap/src/swap.rs
index bc7cee5239..a8ccc6c2f0 100644
--- a/pallets/swap/src/swap.rs
+++ b/pallets/swap/src/swap.rs
@@ -681,111 +681,6 @@ mod tests {
         }
     }
 
-    // Test swapping against protocol liquidity only
-    #[test]
-    fn test_swap_basic() {
-        let protocol_tao = 1_000_000_000;
-        let protocol_alpha = 4_000_000_000;
-
-        // Current price is 0.25
-        // Test case is (order_type, liquidity, limit_price, output_amount)
-        [(OrderType::Buy, 500_000_000u64, 1000.0_f64, 3990_u64)]
-            .iter()
-            .for_each(|(order_type, liquidity, limit_price, output_amount)| {
-                // Consumed liquidity ticks
-                let tick_low = TickIndex::MIN;
-                let tick_high = TickIndex::MAX;
-
-                // Setup swap
-                let mut mock_ops = MockSwapDataOperations::new();
-                mock_ops.set_tao_reserve(protocol_tao);
-                mock_ops.set_alpha_reserve(protocol_alpha);
-                let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
-
-                // Get tick infos before the swap
-                let tick_low_info_before = swap
-                    .state_ops
-                    .get_tick_by_index(tick_low)
-                    .unwrap_or_default();
-                let tick_high_info_before = swap
-                    .state_ops
-                    .get_tick_by_index(tick_high)
-                    .unwrap_or_default();
-                let liquidity_before = swap.state_ops.get_current_liquidity();
-
-                // Swap
-                let sqrt_limit_price: SqrtPrice = SqrtPrice::from_num((*limit_price).sqrt());
-                let swap_result = swap.swap(order_type, *liquidity, sqrt_limit_price);
-                // assert_abs_diff_eq!(
-                //     swap_result.unwrap().amount_paid_out,
-                //     *output_amount,
-                //     epsilon = *output_amount/1000
-                // );
-
-                // Check that low and high ticks' fees were updated properly, and liquidity values were not updated
-                let tick_low_info = swap.state_ops.get_tick_by_index(tick_low).unwrap();
-                let tick_high_info = swap.state_ops.get_tick_by_index(tick_high).unwrap();
-                let expected_liquidity_net_low: i128 = tick_low_info_before.liquidity_net;
-                let expected_liquidity_gross_low: u64 = tick_low_info_before.liquidity_gross;
-                let expected_liquidity_net_high: i128 = tick_high_info_before.liquidity_net;
-                let expected_liquidity_gross_high: u64 = tick_high_info_before.liquidity_gross;
-                assert_eq!(tick_low_info.liquidity_net, expected_liquidity_net_low,);
-                assert_eq!(tick_low_info.liquidity_gross, expected_liquidity_gross_low,);
-                assert_eq!(tick_high_info.liquidity_net, expected_liquidity_net_high,);
-                assert_eq!(
-                    tick_high_info.liquidity_gross,
-                    expected_liquidity_gross_high,
-                );
-
-                // Expected fee amount
-                let fee_rate = swap.state_ops.get_fee_rate() as f64 / u16::MAX as f64;
-                let expected_fee = output_amount * fee_rate as u64;
-
-                // Global fees should be updated
-                let actual_global_fee: U64F64 = match order_type {
-                    OrderType::Buy => swap.state_ops.get_fee_global_alpha(),
-                    OrderType::Sell => swap.state_ops.get_fee_global_tao(),
-                };
-                println!("actual_global_fee {:?}", actual_global_fee);
-                assert_eq!(actual_global_fee, expected_fee);
-
-                // Tick fees should be updated
-
-                // Liquidity position should not be updated
-                let protocol_id = swap.state_ops.get_protocol_account_id();
-
-                let position = swap.state_ops.get_position(&protocol_id, 0).unwrap();
-                assert_eq!(
-                    position.liquidity,
-                    sqrt(protocol_tao as u128 * protocol_alpha as u128) as u64
-                );
-                assert_eq!(position.tick_low, tick_low);
-                assert_eq!(position.tick_high, tick_high);
-                assert_eq!(position.fees_alpha, 0);
-                assert_eq!(position.fees_tao, 0);
-
-                // // Current liquidity is updated only when price range includes the current price
-                // if (*price_high >= current_price) && (*price_low <= current_price) {
-                //     assert_eq!(
-                //         swap.state_ops.get_current_liquidity(),
-                //         liquidity_before + *liquidity
-                //     );
-                // } else {
-                //     assert_eq!(swap.state_ops.get_current_liquidity(), liquidity_before);
-                // }
-
-                // // Reserves are updated
-                // assert_eq!(
-                //     swap.state_ops.get_tao_reserve(),
-                //     tao_withdrawn + protocol_tao,
-                // );
-                // assert_eq!(
-                //     swap.state_ops.get_alpha_reserve(),
-                //     alpha_withdrawn + protocol_alpha,
-                // );
-            });
-    }
-
     // cargo test --package pallet-subtensor-swap --lib -- tests::test_tick_search_basic --exact --show-output
     #[test]
     fn test_tick_search_basic() {

From a3385418d8589b06d9a27023d4adb608f004f6ed Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Tue, 1 Apr 2025 19:46:19 +0200
Subject: [PATCH 045/418] Port active tick index manager tests

---
 pallets/swap/src/lib.rs  |    4 +-
 pallets/swap/src/swap.rs | 1190 --------------------------------------
 pallets/swap/src/tick.rs |  631 ++++++++++++++++++++
 3 files changed, 632 insertions(+), 1193 deletions(-)
 delete mode 100644 pallets/swap/src/swap.rs

diff --git a/pallets/swap/src/lib.rs b/pallets/swap/src/lib.rs
index 047f29dcab..35fae64cff 100644
--- a/pallets/swap/src/lib.rs
+++ b/pallets/swap/src/lib.rs
@@ -14,9 +14,8 @@ use self::tick::{LayerLevel, Tick, TickIndex, TickIndexBitmap};
 use crate::pallet::{Config, Error};
 
 pub mod pallet;
-mod tick;
 mod position;
-pub(crate) mod swap;
+mod tick;
 
 #[cfg(test)]
 pub(crate) mod mock;
@@ -92,4 +91,3 @@ pub enum SwapError {
     /// Too many swap steps
     TooManySwapSteps,
 }
-
diff --git a/pallets/swap/src/swap.rs b/pallets/swap/src/swap.rs
deleted file mode 100644
index a8ccc6c2f0..0000000000
--- a/pallets/swap/src/swap.rs
+++ /dev/null
@@ -1,1190 +0,0 @@
-use core::marker::PhantomData;
-use core::ops::Neg;
-
-use pallet_subtensor_swap_interface::OrderType;
-use safe_math::*;
-use substrate_fixed::types::U64F64;
-
-use crate::{
-    RemoveLiquidityResult, SqrtPrice, SwapError, SwapResult, SwapStepAction, SwapStepResult,
-    position::Position,
-    tick::{LayerLevel, Tick, TickIndex, TickIndexBitmap},
-};
-
-/// This trait implementation depends on Runtime and it needs to be implemented
-/// in the pallet to be able to work with chain state and per subnet. All subnet
-/// swaps are independent and hence netuid is abstracted away from swap implementation.
-///
-pub trait SwapDataOperations<AccountIdType> {
-    /// Tells if v3 swap is initialized in the state. v2 only provides base and quote
-    /// reserves, while v3 also stores ticks and positions, which need to be initialized
-    /// at the first pool creation.
-    fn is_v3_initialized(&self) -> bool;
-    fn set_v3_initialized(&mut self);
-    /// Returns u16::MAX normalized fee rate. For example, 0.3% is approximately 196.
-    fn get_fee_rate(&self) -> u16;
-    /// Minimum liquidity that is safe for rounding and integer math.
-    fn get_minimum_liquidity(&self) -> u64;
-    fn get_tick_by_index(&self, tick_index: TickIndex) -> Option<Tick>;
-    fn insert_tick_by_index(&mut self, tick_index: TickIndex, tick: Tick);
-    fn remove_tick_by_index(&mut self, tick_index: TickIndex);
-    /// Minimum sqrt price across all active ticks
-    fn get_min_sqrt_price(&self) -> SqrtPrice;
-    /// Maximum sqrt price across all active ticks
-    fn get_max_sqrt_price(&self) -> SqrtPrice;
-    fn get_tao_reserve(&self) -> u64;
-    fn set_tao_reserve(&mut self, tao: u64) -> u64;
-    fn get_alpha_reserve(&self) -> u64;
-    fn set_alpha_reserve(&mut self, alpha: u64) -> u64;
-    fn get_alpha_sqrt_price(&self) -> SqrtPrice;
-    fn set_alpha_sqrt_price(&mut self, sqrt_price: SqrtPrice);
-
-    // Getters/setters for global accrued fees in alpha and tao per subnet
-    fn get_fee_global_tao(&self) -> U64F64;
-    fn set_fee_global_tao(&mut self, fee: U64F64);
-    fn get_fee_global_alpha(&self) -> U64F64;
-    fn set_fee_global_alpha(&mut self, fee: U64F64);
-
-    /// Get current tick liquidity
-    fn get_current_liquidity(&self) -> u64;
-    /// Set current tick liquidity
-    fn set_current_liquidity(&mut self, liquidity: u64);
-
-    // User account operations
-    fn get_protocol_account_id(&self) -> AccountIdType;
-    fn get_max_positions(&self) -> u16;
-    fn withdraw_balances(
-        &mut self,
-        account_id: &AccountIdType,
-        tao: u64,
-        alpha: u64,
-    ) -> Result<(u64, u64), SwapError>;
-    fn deposit_balances(&mut self, account_id: &AccountIdType, tao: u64, alpha: u64);
-    fn get_position_count(&self, account_id: &AccountIdType) -> u16;
-    fn get_position(&self, account_id: &AccountIdType, position_id: u16) -> Option<Position>;
-    fn create_position(&mut self, account_id: &AccountIdType, positions: Position) -> u16;
-    fn update_position(
-        &mut self,
-        account_id: &AccountIdType,
-        position_id: u16,
-        positions: Position,
-    );
-    fn remove_position(&mut self, account_id: &AccountIdType, position_id: u16);
-
-    // Tick index storage
-    // Storage is organized in 3 layers:
-    //    Layer 0 consists of one u128 that stores 55 bits. Each bit indicates which layer 1 words are active.
-    //    Layer 1 consists of up to 55 u128's that store 6932 bits for the layer 2 words.
-    //    Layer 2 consists of up to 6932 u128's that store 887272 bits for active/inactive ticks.
-    fn get_layer0_word(&self, word_index: u32) -> u128;
-    fn get_layer1_word(&self, word_index: u32) -> u128;
-    fn get_layer2_word(&self, word_index: u32) -> u128;
-    fn set_layer0_word(&mut self, word_index: u32, word: u128);
-    fn set_layer1_word(&mut self, word_index: u32, word: u128);
-    fn set_layer2_word(&mut self, word_index: u32, word: u128);
-}
-
-/// All main swapping logic abstracted from Runtime implementation is concentrated
-/// in this struct
-///
-#[derive(Debug)]
-pub struct Swap<AccountIdType, Ops>
-where
-    AccountIdType: Eq,
-    Ops: SwapDataOperations<AccountIdType>,
-{
-    pub(crate) state_ops: Ops,
-    phantom_key: PhantomData<AccountIdType>,
-}
-
-impl<AccountIdType, Ops> Swap<AccountIdType, Ops>
-where
-    AccountIdType: Eq,
-    Ops: SwapDataOperations<AccountIdType>,
-{
-    pub fn new(mut ops: Ops) -> Self {
-        todo!("transfered to Pallet::maybe_initialize_v3")
-    }
-
-    /// Auxiliary method to calculate Alpha amount to match given TAO
-    /// amount at the current price for liquidity.
-    ///
-    /// Returns (Alpha, Liquidity) tuple
-    ///
-    pub fn get_tao_based_liquidity(&self, _tao: u64) -> (u64, u64) {
-        // let current_price = self.state_ops.get_alpha_sqrt_price();
-        todo!()
-    }
-
-    /// Auxiliary method to calculate TAO amount to match given Alpha
-    /// amount at the current price for liquidity.
-    ///
-    /// Returns (TAO, Liquidity) tuple
-    ///
-    pub fn get_alpha_based_liquidity(&self, _alpha: u64) -> (u64, u64) {
-        // let current_price = self.state_ops.get_alpha_sqrt_price();
-
-        todo!()
-    }
-
-    /// Add liquidity at tick index. Creates new tick if it doesn't exist
-    ///
-    fn add_liquidity_at_index(&mut self, tick_index: TickIndex, liquidity: u64, upper: bool) {
-        todo!("tranfered to Pallet, but still needed here for code to compile")
-    }
-
-    /// Remove liquidity at tick index.
-    ///
-    fn remove_liquidity_at_index(&mut self, tick_index: TickIndex, liquidity: u64, upper: bool) {
-        todo!("moved to Pallet::remove_liquidity_at_index");
-    }
-
-    /// Adds liquidity to the specified price range.
-    ///
-    /// This function allows an account to provide liquidity to a given range of price ticks.
-    /// The amount of liquidity to be added can be determined using the functions
-    /// [`get_tao_based_liquidity`] and [`get_alpha_based_liquidity`], which compute the
-    /// required liquidity based on TAO and Alpha balances for the current price tick.
-    ///
-    /// ### Behavior:
-    /// - If the `protocol` flag is **not set** (`false`), the function will attempt to
-    ///   **withdraw balances** from the account using `state_ops.withdraw_balances()`.
-    /// - If the `protocol` flag is **set** (`true`), the liquidity is added without modifying balances.
-    ///
-    /// ### Parameters:
-    /// - `account_id`: A reference to the account that is providing liquidity.
-    /// - `tick_low`: The lower bound of the price tick range.
-    /// - `tick_high`: The upper bound of the price tick range.
-    /// - `liquidity`: The amount of liquidity to be added.
-    /// - `protocol`: A boolean flag indicating whether the operation is protocol-managed:
-    ///   - `true` -> Do not use this value outside of this implementation. Liquidity is added **without**
-    ///               withdrawing balances.
-    ///   - `false` -> Use this value for all user transactions. Liquidity is added
-    ///               **after withdrawing balances**.
-    ///
-    /// ### Returns:
-    /// - `Ok(u64)`: The final liquidity amount added.
-    /// - `Err(SwapError)`: If the operation fails due to insufficient balance, invalid tick range,
-    ///   or other swap-related errors.
-    ///
-    /// ### Errors:
-    /// - [`SwapError::InsufficientBalance`] if the account does not have enough balance.
-    /// - [`SwapError::InvalidTickRange`] if `tick_low` is greater than or equal to `tick_high`.
-    /// - Other [`SwapError`] variants as applicable.
-    ///
-    pub fn add_liquidity(
-        &mut self,
-        account_id: &AccountIdType,
-        tick_low: TickIndex,
-        tick_high: TickIndex,
-        liquidity: u64,
-        protocol: bool,
-    ) -> Result<(), SwapError> {
-        todo!("transfered to Pallet::add_liquidity")
-    }
-
-    /// Remove liquidity and credit balances back to account_id
-    ///
-    /// Account ID and Position ID identify position in the storage map
-    ///
-    pub fn remove_liquidity(
-        &mut self,
-        account_id: &AccountIdType,
-        position_id: u16,
-    ) -> Result<RemoveLiquidityResult, SwapError> {
-        todo!("moved to Pallet::remove_liquidity")
-    }
-
-    /// Perform a swap
-    ///
-    /// Returns a tuple (amount, refund), where amount is the resulting paid out amount
-    ///
-    pub fn swap(
-        &mut self,
-        order_type: &OrderType,
-        amount: u64,
-        sqrt_price_limit: SqrtPrice,
-    ) -> Result<SwapResult, SwapError> {
-        todo!("moved to Pallet::swap")
-    }
-
-    fn get_current_tick_index(&mut self) -> TickIndex {
-        todo!("moved to TickIndex::current_bounded")
-    }
-
-    /// Process a single step of a swap
-    ///
-    fn swap_step(
-        &mut self,
-        order_type: &OrderType,
-        delta_in: u64,
-        sqrt_price_final: SqrtPrice,
-        action: SwapStepAction,
-    ) -> Result<SwapStepResult, SwapError> {
-        todo!("moved to Pallet::swap_step")
-    }
-
-    /// Get the square root price at the current tick edge for the given direction (order type)
-    /// If order type is Buy, then price edge is the high tick bound price, otherwise it is
-    /// the low tick bound price.
-    ///
-    /// If anything is wrong with tick math and it returns Err, we just abort the deal, i.e.
-    /// return the edge that is impossible to execute
-    ///
-    fn get_sqrt_price_edge(&self, order_type: &OrderType) -> SqrtPrice {
-        todo!("moved to Pallet::sqrt_price_edge")
-    }
-
-    /// Calculate fee amount
-    ///
-    /// Fee is provided by state ops as u16-normalized value.
-    ///
-    fn get_fee_amount(&self, amount: u64) -> u64 {
-        todo!("moved to Pallet::calculate_fee_amount")
-    }
-
-    /// Here we subtract minimum safe liquidity from current liquidity to stay in the
-    /// safe range
-    ///
-    fn get_safe_current_liquidity(&self) -> U64F64 {
-        todo!("moved to Pallet::current_liquidity_safe")
-    }
-
-    /// Get the target square root price based on the input amount
-    ///
-    fn get_sqrt_price_target(&self, order_type: &OrderType, delta_in: u64) -> SqrtPrice {
-        todo!("moved to Pallet::sqrt_price_target")
-    }
-
-    /// Get the target quantity, which is
-    ///     `1 / (target square root price)` in case of sell order
-    ///     `target square root price` in case of buy order
-    ///
-    /// ...based on the input amount, current liquidity, and current alpha price
-    ///
-    fn get_target_quantity(&self, order_type: &OrderType, delta_in: u64) -> SqrtPrice {
-        todo!("moved to Pallet::target_quantity")
-    }
-
-    /// Get the input amount needed to reach the target price
-    ///
-    fn get_delta_in(&self, order_type: &OrderType, sqrt_price_target: SqrtPrice) -> u64 {
-        todo!("moved to Pallet::delat_in")
-    }
-
-    /// Add fees to the global fee counters
-    fn add_fees(&mut self, order_type: &OrderType, fee: u64) {
-        todo!("moved to Pallet::add_fees")
-    }
-
-    /// Convert input amount (delta_in) to output amount (delta_out)
-    ///
-    /// This is the core method of uniswap V3 that tells how much
-    /// output token is given for an amount of input token within one
-    /// price tick.
-    ///
-    fn convert_deltas(&self, order_type: &OrderType, delta_in: u64) -> u64 {
-        todo!("moved to Pallet::convert_deltas")
-    }
-
-    /// Multiplies a `u64` by a `U64F64` and returns a `u128` result without overflow.
-    // pub fn mul_u64_u64f64(a: u64, b: U64F64) -> u128 {
-    //     // Multiply a by integer part of b in integer math.
-    //     // Result doesn't overflow u128 because both multipliers are 64 bit
-    //     let int_b: u64 = b.saturating_to_num::<u64>();
-    //     let high = (a as u128).saturating_mul(int_b as u128);
-
-    //     // Multiply a by fractional part of b using U64F64
-    //     let frac_b = b.saturating_sub(U64F64::saturating_from_num(int_b));
-    //     let low = U64F64::saturating_from_num(a).saturating_mul(frac_b);
-
-    //     // The only possible overflow (that is cut off by saturating math)
-    //     // is when a is u64::MAX, int_b is u64::MAX, and frac_b is non-zero,
-    //     // which is negligible error if we saturate and return u128::MAX
-    //     high.saturating_add(low).saturating_to_num::<u128>()
-    // }
-
-    /// Update token reserves after a swap
-    ///
-    fn update_reserves(&mut self, order_type: &OrderType, amount_in: u64, amount_out: u64) {
-        let (new_tao_reserve, new_alpha_reserve) = match order_type {
-            OrderType::Sell => (
-                self.state_ops.get_tao_reserve().saturating_add(amount_in),
-                self.state_ops
-                    .get_alpha_reserve()
-                    .saturating_sub(amount_out),
-            ),
-            OrderType::Buy => (
-                self.state_ops.get_tao_reserve().saturating_sub(amount_in),
-                self.state_ops
-                    .get_alpha_reserve()
-                    .saturating_add(amount_out),
-            ),
-        };
-
-        self.state_ops.set_tao_reserve(new_tao_reserve);
-        self.state_ops.set_alpha_reserve(new_alpha_reserve);
-    }
-
-    fn get_liquidity_update_u64(&self, tick: &Tick) -> u64 {
-        todo!("moved to Tick::liquidity_net_as_u64")
-    }
-
-    /// Update liquidity when crossing a tick
-    ///
-    fn update_liquidity_at_crossing(&mut self, order_type: &OrderType) -> Result<(), SwapError> {
-        todo!("moved to Pallet::update_liquidity_at_crossing")
-    }
-
-    /// Collect fees for a position
-    /// Updates the position
-    ///
-    fn collect_fees(&mut self, position: &mut Position) -> (u64, u64) {
-        todo!("moved to Position::collect_fees")
-    }
-
-    /// Get fees in a position's range
-    ///
-    /// If quote flag is true, Tao is returned, otherwise alpha.
-    ///
-    fn get_fees_in_range(&mut self, position: &Position, quote: bool) -> u64 {
-        todo!("moved to Position::fees_in_range")
-    }
-
-    /// Get fees above a tick
-    ///
-    fn get_fees_above(&mut self, tick_index: TickIndex, quote: bool) -> U64F64 {
-        todo!("moved to TickIndex::fees_above")
-    }
-
-    /// Get fees below a tick
-    fn get_fees_below(&mut self, tick_index: TickIndex, quote: bool) -> U64F64 {
-        todo!("moved to TickIndex::fees_below")
-    }
-
-    /// Active tick operations
-    ///
-    /// Data structure:
-    ///    Active ticks are stored in three hash maps, each representing a "Level"
-    ///    Level 0 stores one u128 word, where each bit represents one Level 1 word.
-    ///    Level 1 words each store also a u128 word, where each bit represents one Level 2 word.
-    ///    Level 2 words each store u128 word, where each bit represents a tick.
-    ///
-    /// Insertion: 3 reads, 3 writes
-    /// Search: 3-5 reads
-    /// Deletion: 2 reads, 1-3 writes
-    ///
-
-    // Use TickIndexBitmap::layer_to_index instead
-
-    pub fn insert_active_tick(&mut self, index: TickIndex) {
-        todo!("moved to ActiveTickIndexManager::insert")
-    }
-
-    pub fn remove_active_tick(&mut self, index: TickIndex) {
-        todo!("moved to ActiveTickIndexManager::remove")
-    }
-
-    pub fn find_closest_active_tick_index(
-        &self,
-        index: TickIndex,
-        lower: bool,
-    ) -> Option<TickIndex> {
-        todo!("moved to ActiveTickIndexManager::find_closet")
-    }
-
-    pub fn find_closest_lower_active_tick_index(&self, index: TickIndex) -> Option<TickIndex> {
-        todo!("moved to ActiveTickIndexManager::find_closest_lower")
-    }
-
-    pub fn find_closest_higher_active_tick_index(&self, index: TickIndex) -> Option<TickIndex> {
-        todo!("moved to ActiveTickIndexManager::find_closest_higher")
-    }
-
-    pub fn find_closest_lower_active_tick(&self, index: TickIndex) -> Option<Tick> {
-        todo!("moved to Pallet::find_closest_lower")
-    }
-
-    pub fn find_closest_higher_active_tick(&self, index: TickIndex) -> Option<Tick> {
-        todo!("moved to Pallet::find_closest_higher")
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use approx::assert_abs_diff_eq;
-    use sp_arithmetic::helpers_128bit::sqrt;
-    use std::collections::HashMap;
-
-    #[derive(Debug, Clone)]
-    pub struct MockSwapDataOperations {
-        is_initialized: bool,
-        fee_rate: u16,
-        minimum_liquidity: u64,
-        ticks: HashMap<TickIndex, Tick>,
-        min_sqrt_price: SqrtPrice,
-        max_sqrt_price: SqrtPrice,
-        tao_reserve: u64,
-        alpha_reserve: u64,
-        alpha_sqrt_price: SqrtPrice,
-        fee_global_tao: U64F64,
-        fee_global_alpha: U64F64,
-        current_liquidity: u64,
-        max_positions: u16,
-        balances: HashMap<u16, (u64, u64)>,
-        positions: HashMap<u16, HashMap<u16, Position>>,
-        tick_index_l0: HashMap<u32, u128>,
-        tick_index_l1: HashMap<u32, u128>,
-        tick_index_l2: HashMap<u32, u128>,
-    }
-
-    impl MockSwapDataOperations {
-        pub fn new() -> Self {
-            Self {
-                is_initialized: false,
-                fee_rate: 196,
-                minimum_liquidity: 1000,
-                ticks: HashMap::new(),
-                min_sqrt_price: SqrtPrice::from_num(0.01),
-                max_sqrt_price: SqrtPrice::from_num(10),
-                tao_reserve: 0,
-                alpha_reserve: 0,
-                alpha_sqrt_price: SqrtPrice::from_num(0),
-                fee_global_tao: U64F64::from_num(0),
-                fee_global_alpha: U64F64::from_num(0),
-                current_liquidity: 0,
-                max_positions: 100,
-                balances: HashMap::new(),
-                positions: HashMap::new(),
-                tick_index_l0: HashMap::new(),
-                tick_index_l1: HashMap::new(),
-                tick_index_l2: HashMap::new(),
-            }
-        }
-    }
-
-    impl SwapDataOperations<u16> for MockSwapDataOperations {
-        fn is_v3_initialized(&self) -> bool {
-            self.is_initialized
-        }
-
-        fn set_v3_initialized(&mut self) {
-            self.is_initialized = true;
-        }
-
-        fn get_fee_rate(&self) -> u16 {
-            self.fee_rate
-        }
-
-        fn get_minimum_liquidity(&self) -> u64 {
-            self.minimum_liquidity
-        }
-
-        fn get_tick_by_index(&self, tick_index: TickIndex) -> Option<Tick> {
-            self.ticks.get(&tick_index).cloned()
-        }
-
-        fn insert_tick_by_index(&mut self, tick_index: TickIndex, tick: Tick) {
-            self.ticks.insert(tick_index, tick);
-        }
-
-        fn remove_tick_by_index(&mut self, tick_index: TickIndex) {
-            self.ticks.remove(&tick_index);
-        }
-
-        fn get_min_sqrt_price(&self) -> SqrtPrice {
-            self.min_sqrt_price
-        }
-
-        fn get_max_sqrt_price(&self) -> SqrtPrice {
-            self.max_sqrt_price
-        }
-
-        fn get_tao_reserve(&self) -> u64 {
-            self.tao_reserve
-        }
-
-        fn set_tao_reserve(&mut self, tao: u64) -> u64 {
-            self.tao_reserve = tao;
-            tao
-        }
-
-        fn get_alpha_reserve(&self) -> u64 {
-            self.alpha_reserve
-        }
-
-        fn set_alpha_reserve(&mut self, alpha: u64) -> u64 {
-            self.alpha_reserve = alpha;
-            alpha
-        }
-
-        fn get_alpha_sqrt_price(&self) -> SqrtPrice {
-            self.alpha_sqrt_price
-        }
-
-        fn set_alpha_sqrt_price(&mut self, sqrt_price: SqrtPrice) {
-            self.alpha_sqrt_price = sqrt_price;
-        }
-
-        fn get_fee_global_tao(&self) -> U64F64 {
-            self.fee_global_tao
-        }
-
-        fn set_fee_global_tao(&mut self, fee: U64F64) {
-            self.fee_global_tao = fee;
-        }
-
-        fn get_fee_global_alpha(&self) -> U64F64 {
-            self.fee_global_alpha
-        }
-
-        fn set_fee_global_alpha(&mut self, fee: U64F64) {
-            self.fee_global_alpha = fee;
-        }
-
-        fn get_current_liquidity(&self) -> u64 {
-            self.current_liquidity
-        }
-
-        fn set_current_liquidity(&mut self, liquidity: u64) {
-            self.current_liquidity = liquidity;
-        }
-
-        fn get_max_positions(&self) -> u16 {
-            self.max_positions
-        }
-
-        fn withdraw_balances(
-            &mut self,
-            account_id: &u16,
-            tao: u64,
-            alpha: u64,
-        ) -> Result<(u64, u64), SwapError> {
-            let (current_tao, current_alpha) =
-                self.balances.get(account_id).cloned().unwrap_or((0, 0));
-
-            if (tao > current_tao) || (alpha > current_alpha) {
-                return Err(SwapError::InsufficientBalance);
-            }
-
-            self.balances
-                .insert(*account_id, (current_tao - tao, current_alpha - alpha));
-
-            Ok((tao, alpha))
-        }
-
-        fn deposit_balances(&mut self, account_id: &u16, tao: u64, alpha: u64) {
-            let (current_tao, current_alpha) =
-                self.balances.get(account_id).cloned().unwrap_or((0, 0));
-            self.balances.insert(
-                account_id.clone(),
-                (current_tao + tao, current_alpha + alpha),
-            );
-        }
-
-        fn get_protocol_account_id(&self) -> u16 {
-            0xFFFF
-        }
-
-        fn get_position_count(&self, account_id: &u16) -> u16 {
-            self.positions.get(account_id).map_or(0, |p| p.len() as u16)
-        }
-
-        fn get_position(&self, account_id: &u16, position_id: u16) -> Option<Position> {
-            self.positions
-                .get(account_id)
-                .and_then(|p| p.get(&position_id).cloned())
-        }
-
-        fn create_position(&mut self, account_id: &u16, position: Position) -> u16 {
-            let entry = self
-                .positions
-                .entry(account_id.clone())
-                .or_insert_with(HashMap::new);
-
-            // Find the next available position ID
-            let new_position_id = entry.keys().max().map_or(0, |max_id| max_id + 1);
-
-            entry.insert(new_position_id, position);
-            new_position_id
-        }
-
-        fn update_position(&mut self, account_id: &u16, position_id: u16, position: Position) {
-            if let Some(account_positions) = self.positions.get_mut(account_id) {
-                account_positions.insert(position_id, position);
-            }
-        }
-
-        fn remove_position(&mut self, account_id: &u16, position_id: u16) {
-            if let Some(account_positions) = self.positions.get_mut(account_id) {
-                account_positions.remove(&position_id);
-            }
-        }
-
-        fn get_layer0_word(&self, word_index: u32) -> u128 {
-            *self.tick_index_l0.get(&word_index).unwrap_or(&0_u128)
-        }
-        fn get_layer1_word(&self, word_index: u32) -> u128 {
-            *self.tick_index_l1.get(&word_index).unwrap_or(&0_u128)
-        }
-        fn get_layer2_word(&self, word_index: u32) -> u128 {
-            *self.tick_index_l2.get(&word_index).unwrap_or(&0_u128)
-        }
-        fn set_layer0_word(&mut self, word_index: u32, word: u128) {
-            self.tick_index_l0.insert(word_index, word);
-        }
-        fn set_layer1_word(&mut self, word_index: u32, word: u128) {
-            self.tick_index_l1.insert(word_index, word);
-        }
-        fn set_layer2_word(&mut self, word_index: u32, word: u128) {
-            self.tick_index_l2.insert(word_index, word);
-        }
-    }
-
-    fn price_to_tick(price: f64) -> TickIndex {
-        let price_sqrt: SqrtPrice = SqrtPrice::from_num(price.sqrt());
-        // Handle potential errors in the conversion
-        match TickIndex::try_from_sqrt_price(price_sqrt) {
-            Ok(mut tick) => {
-                // Ensure the tick is within bounds
-                if tick > TickIndex::MAX {
-                    tick = TickIndex::MAX;
-                } else if tick < TickIndex::MIN {
-                    tick = TickIndex::MIN;
-                }
-                tick
-            }
-            // Default to a reasonable value when conversion fails
-            Err(_) => {
-                if price > 1.0 {
-                    TickIndex::MAX
-                } else {
-                    TickIndex::MIN
-                }
-            }
-        }
-    }
-
-    fn tick_to_price(tick: TickIndex) -> f64 {
-        // Handle errors gracefully
-        match tick.try_to_sqrt_price() {
-            Ok(price_sqrt) => (price_sqrt * price_sqrt).to_num::<f64>(),
-            Err(_) => {
-                // Return a sensible default based on whether the tick is above or below the valid range
-                if tick > TickIndex::MAX {
-                    tick_to_price(TickIndex::MAX) // Use the max valid tick price
-                } else {
-                    tick_to_price(TickIndex::MIN) // Use the min valid tick price
-                }
-            }
-        }
-    }
-
-    // cargo test --package pallet-subtensor-swap --lib -- tests::test_tick_search_basic --exact --show-output
-    #[test]
-    fn test_tick_search_basic() {
-        let mock_ops = MockSwapDataOperations::new();
-        let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
-
-        swap.insert_active_tick(TickIndex::MIN);
-        assert_eq!(
-            swap.find_closest_lower_active_tick_index(TickIndex::MIN)
-                .unwrap(),
-            TickIndex::MIN
-        );
-        assert_eq!(
-            swap.find_closest_lower_active_tick_index(TickIndex::MAX)
-                .unwrap(),
-            TickIndex::MIN
-        );
-        assert_eq!(
-            swap.find_closest_lower_active_tick_index(TickIndex::MAX.saturating_div(2))
-                .unwrap(),
-            TickIndex::MIN
-        );
-        assert_eq!(
-            swap.find_closest_lower_active_tick_index(TickIndex::MAX.prev().unwrap())
-                .unwrap(),
-            TickIndex::MIN
-        );
-        assert_eq!(
-            swap.find_closest_lower_active_tick_index(TickIndex::MIN.next().unwrap())
-                .unwrap(),
-            TickIndex::MIN
-        );
-
-        assert_eq!(
-            swap.find_closest_higher_active_tick_index(TickIndex::MIN)
-                .unwrap(),
-            TickIndex::MIN
-        );
-        assert_eq!(
-            swap.find_closest_higher_active_tick_index(TickIndex::MAX),
-            None
-        );
-        assert_eq!(
-            swap.find_closest_higher_active_tick_index(TickIndex::MAX.saturating_div(2)),
-            None
-        );
-        assert_eq!(
-            swap.find_closest_higher_active_tick_index(TickIndex::MAX.prev().unwrap()),
-            None
-        );
-        assert_eq!(
-            swap.find_closest_higher_active_tick_index(TickIndex::MIN.next().unwrap()),
-            None
-        );
-
-        swap.insert_active_tick(TickIndex::MAX);
-        assert_eq!(
-            swap.find_closest_lower_active_tick_index(TickIndex::MIN)
-                .unwrap(),
-            TickIndex::MIN
-        );
-        assert_eq!(
-            swap.find_closest_lower_active_tick_index(TickIndex::MAX)
-                .unwrap(),
-            TickIndex::MAX
-        );
-        assert_eq!(
-            swap.find_closest_lower_active_tick_index(TickIndex::MAX.saturating_div(2))
-                .unwrap(),
-            TickIndex::MIN
-        );
-        assert_eq!(
-            swap.find_closest_lower_active_tick_index(TickIndex::MAX.prev().unwrap())
-                .unwrap(),
-            TickIndex::MIN
-        );
-        assert_eq!(
-            swap.find_closest_lower_active_tick_index(TickIndex::MIN.next().unwrap())
-                .unwrap(),
-            TickIndex::MIN
-        );
-    }
-
-    #[test]
-    fn test_tick_search_sparse_queries() {
-        let mock_ops = MockSwapDataOperations::new();
-        let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
-
-        let active_index = TickIndex::MIN.saturating_add(10);
-        swap.insert_active_tick(active_index);
-        assert_eq!(
-            swap.find_closest_lower_active_tick_index(active_index)
-                .unwrap(),
-            active_index
-        );
-        assert_eq!(
-            swap.find_closest_lower_active_tick_index(TickIndex::MIN.saturating_add(11))
-                .unwrap(),
-            active_index
-        );
-        assert_eq!(
-            swap.find_closest_lower_active_tick_index(TickIndex::MIN.saturating_add(12))
-                .unwrap(),
-            active_index
-        );
-        assert_eq!(
-            swap.find_closest_lower_active_tick_index(TickIndex::MIN),
-            None
-        );
-        assert_eq!(
-            swap.find_closest_lower_active_tick_index(TickIndex::MIN.saturating_add(9)),
-            None
-        );
-
-        assert_eq!(
-            swap.find_closest_higher_active_tick_index(active_index)
-                .unwrap(),
-            active_index
-        );
-        assert_eq!(
-            swap.find_closest_higher_active_tick_index(TickIndex::MIN.saturating_add(11)),
-            None
-        );
-        assert_eq!(
-            swap.find_closest_higher_active_tick_index(TickIndex::MIN.saturating_add(12)),
-            None
-        );
-        assert_eq!(
-            swap.find_closest_higher_active_tick_index(TickIndex::MIN)
-                .unwrap(),
-            active_index
-        );
-        assert_eq!(
-            swap.find_closest_higher_active_tick_index(TickIndex::MIN.saturating_add(9))
-                .unwrap(),
-            active_index
-        );
-    }
-
-    #[test]
-    fn test_tick_search_many_lows() {
-        let mock_ops = MockSwapDataOperations::new();
-        let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
-
-        (0..1000).for_each(|i| {
-            swap.insert_active_tick(TickIndex::MIN.saturating_add(i));
-        });
-
-        for i in 0..1000 {
-            let test_index = TickIndex::MIN.saturating_add(i);
-            assert_eq!(
-                swap.find_closest_lower_active_tick_index(test_index)
-                    .unwrap(),
-                test_index
-            );
-            assert_eq!(
-                swap.find_closest_higher_active_tick_index(test_index)
-                    .unwrap(),
-                test_index
-            );
-        }
-    }
-
-    #[test]
-    fn test_tick_search_many_sparse() {
-        let mock_ops = MockSwapDataOperations::new();
-        let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
-        let count: i32 = 1000;
-
-        for i in 0..=count {
-            swap.insert_active_tick(TickIndex::new_unchecked(i * 10));
-        }
-        for i in 1..count {
-            let tick = TickIndex::new_unchecked(i * 10);
-            assert_eq!(
-                swap.find_closest_lower_active_tick_index(tick).unwrap(),
-                tick
-            );
-            assert_eq!(
-                swap.find_closest_higher_active_tick_index(tick).unwrap(),
-                tick
-            );
-            for j in 1..=9 {
-                let before_tick = TickIndex::new_unchecked(i * 10 - j);
-                let after_tick = TickIndex::new_unchecked(i * 10 + j);
-                let prev_tick = TickIndex::new_unchecked((i - 1) * 10);
-                let next_tick = TickIndex::new_unchecked((i + 1) * 10);
-                assert_eq!(
-                    swap.find_closest_lower_active_tick_index(before_tick)
-                        .unwrap(),
-                    prev_tick
-                );
-                assert_eq!(
-                    swap.find_closest_lower_active_tick_index(after_tick)
-                        .unwrap(),
-                    tick
-                );
-                assert_eq!(
-                    swap.find_closest_higher_active_tick_index(before_tick)
-                        .unwrap(),
-                    tick
-                );
-                assert_eq!(
-                    swap.find_closest_higher_active_tick_index(after_tick)
-                        .unwrap(),
-                    next_tick
-                );
-            }
-        }
-    }
-
-    #[test]
-    fn test_tick_search_many_lows_sparse_reversed() {
-        let mock_ops = MockSwapDataOperations::new();
-        let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
-        let count: i32 = 1000;
-
-        for i in (0..=count).rev() {
-            swap.insert_active_tick(TickIndex::new_unchecked(i * 10));
-        }
-        for i in 1..count {
-            let tick = TickIndex::new_unchecked(i * 10);
-            assert_eq!(
-                swap.find_closest_lower_active_tick_index(tick).unwrap(),
-                tick
-            );
-            assert_eq!(
-                swap.find_closest_higher_active_tick_index(tick).unwrap(),
-                tick
-            );
-            for j in 1..=9 {
-                let before_tick = TickIndex::new_unchecked(i * 10 - j);
-                let after_tick = TickIndex::new_unchecked(i * 10 + j);
-                let prev_tick = TickIndex::new_unchecked((i - 1) * 10);
-                let next_tick = TickIndex::new_unchecked((i + 1) * 10);
-
-                assert_eq!(
-                    swap.find_closest_lower_active_tick_index(before_tick)
-                        .unwrap(),
-                    prev_tick
-                );
-                assert_eq!(
-                    swap.find_closest_lower_active_tick_index(after_tick)
-                        .unwrap(),
-                    tick
-                );
-                assert_eq!(
-                    swap.find_closest_higher_active_tick_index(before_tick)
-                        .unwrap(),
-                    tick
-                );
-                assert_eq!(
-                    swap.find_closest_higher_active_tick_index(after_tick)
-                        .unwrap(),
-                    next_tick
-                );
-            }
-        }
-    }
-
-    #[test]
-    fn test_tick_search_repeated_insertions() {
-        let mock_ops = MockSwapDataOperations::new();
-        let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
-        let count: i32 = 1000;
-
-        for _ in 0..10 {
-            for i in 0..=count {
-                let tick = TickIndex::new_unchecked(i * 10);
-                swap.insert_active_tick(tick);
-            }
-            for i in 1..count {
-                let tick = TickIndex::new_unchecked(i * 10);
-                assert_eq!(
-                    swap.find_closest_lower_active_tick_index(tick).unwrap(),
-                    tick
-                );
-                assert_eq!(
-                    swap.find_closest_higher_active_tick_index(tick).unwrap(),
-                    tick
-                );
-                for j in 1..=9 {
-                    let before_tick = TickIndex::new_unchecked(i * 10 - j);
-                    let after_tick = TickIndex::new_unchecked(i * 10 + j);
-                    let prev_tick = TickIndex::new_unchecked((i - 1) * 10);
-                    let next_tick = TickIndex::new_unchecked((i + 1) * 10);
-
-                    assert_eq!(
-                        swap.find_closest_lower_active_tick_index(before_tick)
-                            .unwrap(),
-                        prev_tick
-                    );
-                    assert_eq!(
-                        swap.find_closest_lower_active_tick_index(after_tick)
-                            .unwrap(),
-                        tick
-                    );
-                    assert_eq!(
-                        swap.find_closest_higher_active_tick_index(before_tick)
-                            .unwrap(),
-                        tick
-                    );
-                    assert_eq!(
-                        swap.find_closest_higher_active_tick_index(after_tick)
-                            .unwrap(),
-                        next_tick
-                    );
-                }
-            }
-        }
-    }
-
-    #[test]
-    fn test_tick_search_full_range() {
-        let mock_ops = MockSwapDataOperations::new();
-        let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
-        let step = 1019;
-        // Get the full valid tick range by subtracting MIN from MAX
-        let count = (TickIndex::MAX.get() - TickIndex::MIN.get()) / step;
-
-        for i in 0..=count {
-            let index = TickIndex::MIN.saturating_add(i * step);
-            swap.insert_active_tick(index);
-        }
-        for i in 1..count {
-            let index = TickIndex::MIN.saturating_add(i * step);
-
-            let prev_index = TickIndex::new_unchecked(index.get() - step);
-            let next_minus_one = TickIndex::new_unchecked(index.get() + step - 1);
-
-            assert_eq!(
-                swap.find_closest_lower_active_tick_index(prev_index)
-                    .unwrap(),
-                prev_index
-            );
-            assert_eq!(
-                swap.find_closest_lower_active_tick_index(index).unwrap(),
-                index
-            );
-            assert_eq!(
-                swap.find_closest_lower_active_tick_index(next_minus_one)
-                    .unwrap(),
-                index
-            );
-
-            let mid_next = TickIndex::new_unchecked(index.get() + step / 2);
-            assert_eq!(
-                swap.find_closest_lower_active_tick_index(mid_next).unwrap(),
-                index
-            );
-
-            assert_eq!(
-                swap.find_closest_higher_active_tick_index(index).unwrap(),
-                index
-            );
-
-            let next_index = TickIndex::new_unchecked(index.get() + step);
-            assert_eq!(
-                swap.find_closest_higher_active_tick_index(next_index)
-                    .unwrap(),
-                next_index
-            );
-
-            let mid_next = TickIndex::new_unchecked(index.get() + step / 2);
-            assert_eq!(
-                swap.find_closest_higher_active_tick_index(mid_next)
-                    .unwrap(),
-                next_index
-            );
-
-            let next_minus_1 = TickIndex::new_unchecked(index.get() + step - 1);
-            assert_eq!(
-                swap.find_closest_higher_active_tick_index(next_minus_1)
-                    .unwrap(),
-                next_index
-            );
-            for j in 1..=9 {
-                let before_index = TickIndex::new_unchecked(index.get() - j);
-                let after_index = TickIndex::new_unchecked(index.get() + j);
-
-                assert_eq!(
-                    swap.find_closest_lower_active_tick_index(before_index)
-                        .unwrap(),
-                    prev_index
-                );
-                assert_eq!(
-                    swap.find_closest_lower_active_tick_index(after_index)
-                        .unwrap(),
-                    index
-                );
-                assert_eq!(
-                    swap.find_closest_higher_active_tick_index(before_index)
-                        .unwrap(),
-                    index
-                );
-                assert_eq!(
-                    swap.find_closest_higher_active_tick_index(after_index)
-                        .unwrap(),
-                    next_index
-                );
-            }
-        }
-    }
-
-    #[test]
-    fn test_tick_remove_basic() {
-        let mock_ops = MockSwapDataOperations::new();
-        let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
-
-        swap.insert_active_tick(TickIndex::MIN);
-        swap.insert_active_tick(TickIndex::MAX);
-        swap.remove_active_tick(TickIndex::MAX);
-
-        assert_eq!(
-            swap.find_closest_lower_active_tick_index(TickIndex::MIN)
-                .unwrap(),
-            TickIndex::MIN
-        );
-        assert_eq!(
-            swap.find_closest_lower_active_tick_index(TickIndex::MAX)
-                .unwrap(),
-            TickIndex::MIN
-        );
-        assert_eq!(
-            swap.find_closest_lower_active_tick_index(TickIndex::MAX.saturating_div(2))
-                .unwrap(),
-            TickIndex::MIN
-        );
-        assert_eq!(
-            swap.find_closest_lower_active_tick_index(TickIndex::MAX.prev().unwrap())
-                .unwrap(),
-            TickIndex::MIN
-        );
-        assert_eq!(
-            swap.find_closest_lower_active_tick_index(TickIndex::MIN.next().unwrap())
-                .unwrap(),
-            TickIndex::MIN
-        );
-
-        assert_eq!(
-            swap.find_closest_higher_active_tick_index(TickIndex::MIN)
-                .unwrap(),
-            TickIndex::MIN
-        );
-        assert_eq!(
-            swap.find_closest_higher_active_tick_index(TickIndex::MAX),
-            None
-        );
-        assert_eq!(
-            swap.find_closest_higher_active_tick_index(TickIndex::MAX.saturating_div(2)),
-            None
-        );
-        assert_eq!(
-            swap.find_closest_higher_active_tick_index(TickIndex::MAX.prev().unwrap()),
-            None
-        );
-        assert_eq!(
-            swap.find_closest_higher_active_tick_index(TickIndex::MIN.next().unwrap()),
-            None
-        );
-    }
-
-    #[test]
-    fn test_tick_remove_full_range() {
-        let mock_ops = MockSwapDataOperations::new();
-        let mut swap = Swap::<u16, MockSwapDataOperations>::new(mock_ops);
-        let step = 1019;
-        // Get the full valid tick range by subtracting MIN from MAX
-        let count = (TickIndex::MAX.get() - TickIndex::MIN.get()) / step;
-        let remove_frequency = 5; // Remove every 5th tick
-
-        // Insert ticks
-        for i in 0..=count {
-            let index = TickIndex::MIN.saturating_add(i * step);
-            swap.insert_active_tick(index);
-        }
-
-        // Remove some ticks
-        for i in 1..count {
-            if i % remove_frequency == 0 {
-                let index = TickIndex::MIN.saturating_add(i * step);
-                swap.remove_active_tick(index);
-            }
-        }
-
-        // Verify
-        for i in 1..count {
-            let index = TickIndex::MIN.saturating_add(i * step);
-
-            if i % remove_frequency == 0 {
-                let lower = swap.find_closest_lower_active_tick_index(index);
-                let higher = swap.find_closest_higher_active_tick_index(index);
-                assert!(lower != Some(index));
-                assert!(higher != Some(index));
-            } else {
-                assert_eq!(
-                    swap.find_closest_lower_active_tick_index(index).unwrap(),
-                    index
-                );
-                assert_eq!(
-                    swap.find_closest_higher_active_tick_index(index).unwrap(),
-                    index
-                );
-            }
-        }
-    }
-}
diff --git a/pallets/swap/src/tick.rs b/pallets/swap/src/tick.rs
index 17fe6f9e88..0476fafd29 100644
--- a/pallets/swap/src/tick.rs
+++ b/pallets/swap/src/tick.rs
@@ -1089,6 +1089,7 @@ mod tests {
     use safe_math::FixedExt;
 
     use super::*;
+    use crate::mock::*;
 
     #[test]
     fn test_get_sqrt_ratio_at_tick_bounds() {
@@ -1428,4 +1429,634 @@ mod tests {
             TickIndex::MIN.try_to_sqrt_price().unwrap()
         );
     }
+
+    mod active_tick_index_manager {
+
+        use super::*;
+
+        #[test]
+        fn test_tick_search_basic() {
+            new_test_ext().execute_with(|| {
+                let netuid = NetUid::from(1);
+
+                ActiveTickIndexManager::insert::<Test>(netuid, TickIndex::MIN);
+
+                assert_eq!(
+                    ActiveTickIndexManager::find_closest_lower::<Test>(netuid, TickIndex::MIN)
+                        .unwrap(),
+                    TickIndex::MIN
+                );
+                assert_eq!(
+                    ActiveTickIndexManager::find_closest_lower::<Test>(netuid, TickIndex::MAX)
+                        .unwrap(),
+                    TickIndex::MIN
+                );
+                assert_eq!(
+                    ActiveTickIndexManager::find_closest_lower::<Test>(
+                        netuid,
+                        TickIndex::MAX.saturating_div(2)
+                    )
+                    .unwrap(),
+                    TickIndex::MIN
+                );
+                assert_eq!(
+                    ActiveTickIndexManager::find_closest_lower::<Test>(
+                        netuid,
+                        TickIndex::MAX.prev().unwrap()
+                    )
+                    .unwrap(),
+                    TickIndex::MIN
+                );
+                assert_eq!(
+                    ActiveTickIndexManager::find_closest_lower::<Test>(
+                        netuid,
+                        TickIndex::MIN.next().unwrap()
+                    )
+                    .unwrap(),
+                    TickIndex::MIN
+                );
+
+                assert_eq!(
+                    ActiveTickIndexManager::find_closest_higher::<Test>(netuid, TickIndex::MIN)
+                        .unwrap(),
+                    TickIndex::MIN
+                );
+                assert!(
+                    ActiveTickIndexManager::find_closest_higher::<Test>(netuid, TickIndex::MAX)
+                        .is_none()
+                );
+                assert!(
+                    ActiveTickIndexManager::find_closest_higher::<Test>(
+                        netuid,
+                        TickIndex::MAX.saturating_div(2)
+                    )
+                    .is_none()
+                );
+                assert!(
+                    ActiveTickIndexManager::find_closest_higher::<Test>(
+                        netuid,
+                        TickIndex::MAX.prev().unwrap()
+                    )
+                    .is_none()
+                );
+                assert!(
+                    ActiveTickIndexManager::find_closest_higher::<Test>(
+                        netuid,
+                        TickIndex::MIN.next().unwrap()
+                    )
+                    .is_none()
+                );
+
+                ActiveTickIndexManager::insert::<Test>(netuid, TickIndex::MAX);
+
+                assert_eq!(
+                    ActiveTickIndexManager::find_closest_lower::<Test>(netuid, TickIndex::MIN)
+                        .unwrap(),
+                    TickIndex::MIN
+                );
+                assert_eq!(
+                    ActiveTickIndexManager::find_closest_lower::<Test>(netuid, TickIndex::MAX)
+                        .unwrap(),
+                    TickIndex::MAX
+                );
+                assert_eq!(
+                    ActiveTickIndexManager::find_closest_lower::<Test>(
+                        netuid,
+                        TickIndex::MAX.saturating_div(2)
+                    )
+                    .unwrap(),
+                    TickIndex::MIN
+                );
+                assert_eq!(
+                    ActiveTickIndexManager::find_closest_lower::<Test>(
+                        netuid,
+                        TickIndex::MAX.prev().unwrap()
+                    )
+                    .unwrap(),
+                    TickIndex::MIN
+                );
+                assert_eq!(
+                    ActiveTickIndexManager::find_closest_lower::<Test>(
+                        netuid,
+                        TickIndex::MIN.next().unwrap()
+                    )
+                    .unwrap(),
+                    TickIndex::MIN
+                );
+            });
+        }
+
+        #[test]
+        fn test_tick_search_sparse_queries() {
+            new_test_ext().execute_with(|| {
+                let active_index = TickIndex::MIN.saturating_add(10);
+                let netuid = NetUid::from(1);
+
+                ActiveTickIndexManager::insert::<Test>(netuid, active_index);
+
+                assert_eq!(
+                    ActiveTickIndexManager::find_closest_lower::<Test>(netuid, active_index)
+                        .unwrap(),
+                    active_index
+                );
+                assert_eq!(
+                    ActiveTickIndexManager::find_closest_lower::<Test>(
+                        netuid,
+                        TickIndex::MIN.saturating_add(11)
+                    )
+                    .unwrap(),
+                    active_index
+                );
+                assert_eq!(
+                    ActiveTickIndexManager::find_closest_lower::<Test>(
+                        netuid,
+                        TickIndex::MIN.saturating_add(12)
+                    )
+                    .unwrap(),
+                    active_index
+                );
+                assert_eq!(
+                    ActiveTickIndexManager::find_closest_lower::<Test>(netuid, TickIndex::MIN),
+                    None
+                );
+                assert_eq!(
+                    ActiveTickIndexManager::find_closest_lower::<Test>(
+                        netuid,
+                        TickIndex::MIN.saturating_add(9)
+                    ),
+                    None
+                );
+
+                assert_eq!(
+                    ActiveTickIndexManager::find_closest_higher::<Test>(netuid, active_index)
+                        .unwrap(),
+                    active_index
+                );
+                assert_eq!(
+                    ActiveTickIndexManager::find_closest_higher::<Test>(
+                        netuid,
+                        TickIndex::MIN.saturating_add(11)
+                    ),
+                    None
+                );
+                assert_eq!(
+                    ActiveTickIndexManager::find_closest_higher::<Test>(
+                        netuid,
+                        TickIndex::MIN.saturating_add(12)
+                    ),
+                    None
+                );
+                assert_eq!(
+                    ActiveTickIndexManager::find_closest_higher::<Test>(netuid, TickIndex::MIN)
+                        .unwrap(),
+                    active_index
+                );
+                assert_eq!(
+                    ActiveTickIndexManager::find_closest_higher::<Test>(
+                        netuid,
+                        TickIndex::MIN.saturating_add(9)
+                    )
+                    .unwrap(),
+                    active_index
+                );
+            });
+        }
+
+        #[test]
+        fn test_tick_search_many_lows() {
+            new_test_ext().execute_with(|| {
+                let netuid = NetUid::from(1);
+
+                (0..1000).for_each(|i| {
+                    ActiveTickIndexManager::insert::<Test>(
+                        netuid,
+                        TickIndex::MIN.saturating_add(i),
+                    );
+                });
+
+                for i in 0..1000 {
+                    let test_index = TickIndex::MIN.saturating_add(i);
+                    assert_eq!(
+                        ActiveTickIndexManager::find_closest_lower::<Test>(netuid, test_index)
+                            .unwrap(),
+                        test_index
+                    );
+                    assert_eq!(
+                        ActiveTickIndexManager::find_closest_higher::<Test>(netuid, test_index)
+                            .unwrap(),
+                        test_index
+                    );
+                }
+            });
+        }
+
+        #[test]
+        fn test_tick_search_many_sparse() {
+            new_test_ext().execute_with(|| {
+                let netuid = NetUid::from(1);
+                let count = 1000;
+
+                for i in 0..=count {
+                    ActiveTickIndexManager::insert::<Test>(
+                        netuid,
+                        TickIndex::new_unchecked(i * 10),
+                    );
+                }
+
+                for i in 1..count {
+                    let tick = TickIndex::new_unchecked(i * 10);
+                    assert_eq!(
+                        ActiveTickIndexManager::find_closest_lower::<Test>(netuid, tick).unwrap(),
+                        tick
+                    );
+                    assert_eq!(
+                        ActiveTickIndexManager::find_closest_higher::<Test>(netuid, tick).unwrap(),
+                        tick
+                    );
+                    for j in 1..=9 {
+                        let before_tick = TickIndex::new_unchecked(i * 10 - j);
+                        let after_tick = TickIndex::new_unchecked(i * 10 + j);
+                        let prev_tick = TickIndex::new_unchecked((i - 1) * 10);
+                        let next_tick = TickIndex::new_unchecked((i + 1) * 10);
+                        assert_eq!(
+                            ActiveTickIndexManager::find_closest_lower::<Test>(netuid, before_tick)
+                                .unwrap(),
+                            prev_tick
+                        );
+                        assert_eq!(
+                            ActiveTickIndexManager::find_closest_lower::<Test>(netuid, after_tick)
+                                .unwrap(),
+                            tick
+                        );
+                        assert_eq!(
+                            ActiveTickIndexManager::find_closest_higher::<Test>(
+                                netuid,
+                                before_tick
+                            )
+                            .unwrap(),
+                            tick
+                        );
+                        assert_eq!(
+                            ActiveTickIndexManager::find_closest_higher::<Test>(netuid, after_tick)
+                                .unwrap(),
+                            next_tick
+                        );
+                    }
+                }
+            });
+        }
+
+        #[test]
+        fn test_tick_search_many_lows_sparse_reversed() {
+            new_test_ext().execute_with(|| {
+                let netuid = NetUid::from(1);
+                let count = 1000;
+
+                for i in (0..=count).rev() {
+                    ActiveTickIndexManager::insert::<Test>(
+                        netuid,
+                        TickIndex::new_unchecked(i * 10),
+                    );
+                }
+
+                for i in 1..count {
+                    let tick = TickIndex::new_unchecked(i * 10);
+                    assert_eq!(
+                        ActiveTickIndexManager::find_closest_lower::<Test>(netuid, tick).unwrap(),
+                        tick
+                    );
+                    assert_eq!(
+                        ActiveTickIndexManager::find_closest_higher::<Test>(netuid, tick).unwrap(),
+                        tick
+                    );
+                    for j in 1..=9 {
+                        let before_tick = TickIndex::new_unchecked(i * 10 - j);
+                        let after_tick = TickIndex::new_unchecked(i * 10 + j);
+                        let prev_tick = TickIndex::new_unchecked((i - 1) * 10);
+                        let next_tick = TickIndex::new_unchecked((i + 1) * 10);
+
+                        assert_eq!(
+                            ActiveTickIndexManager::find_closest_lower::<Test>(netuid, before_tick)
+                                .unwrap(),
+                            prev_tick
+                        );
+                        assert_eq!(
+                            ActiveTickIndexManager::find_closest_lower::<Test>(netuid, after_tick)
+                                .unwrap(),
+                            tick
+                        );
+                        assert_eq!(
+                            ActiveTickIndexManager::find_closest_higher::<Test>(
+                                netuid,
+                                before_tick
+                            )
+                            .unwrap(),
+                            tick
+                        );
+                        assert_eq!(
+                            ActiveTickIndexManager::find_closest_higher::<Test>(netuid, after_tick)
+                                .unwrap(),
+                            next_tick
+                        );
+                    }
+                }
+            });
+        }
+
+        #[test]
+        fn test_tick_search_repeated_insertions() {
+            new_test_ext().execute_with(|| {
+                let netuid = NetUid::from(1);
+                let count = 1000;
+
+                for _ in 0..10 {
+                    for i in 0..=count {
+                        let tick = TickIndex::new_unchecked(i * 10);
+                        ActiveTickIndexManager::insert::<Test>(netuid, tick);
+                    }
+
+                    for i in 1..count {
+                        let tick = TickIndex::new_unchecked(i * 10);
+                        assert_eq!(
+                            ActiveTickIndexManager::find_closest_lower::<Test>(netuid, tick)
+                                .unwrap(),
+                            tick
+                        );
+                        assert_eq!(
+                            ActiveTickIndexManager::find_closest_higher::<Test>(netuid, tick)
+                                .unwrap(),
+                            tick
+                        );
+                        for j in 1..=9 {
+                            let before_tick = TickIndex::new_unchecked(i * 10 - j);
+                            let after_tick = TickIndex::new_unchecked(i * 10 + j);
+                            let prev_tick = TickIndex::new_unchecked((i - 1) * 10);
+                            let next_tick = TickIndex::new_unchecked((i + 1) * 10);
+
+                            assert_eq!(
+                                ActiveTickIndexManager::find_closest_lower::<Test>(
+                                    netuid,
+                                    before_tick
+                                )
+                                .unwrap(),
+                                prev_tick
+                            );
+                            assert_eq!(
+                                ActiveTickIndexManager::find_closest_lower::<Test>(
+                                    netuid, after_tick
+                                )
+                                .unwrap(),
+                                tick
+                            );
+                            assert_eq!(
+                                ActiveTickIndexManager::find_closest_higher::<Test>(
+                                    netuid,
+                                    before_tick
+                                )
+                                .unwrap(),
+                                tick
+                            );
+                            assert_eq!(
+                                ActiveTickIndexManager::find_closest_higher::<Test>(
+                                    netuid, after_tick
+                                )
+                                .unwrap(),
+                                next_tick
+                            );
+                        }
+                    }
+                }
+            });
+        }
+
+        #[test]
+        fn test_tick_search_full_range() {
+            new_test_ext().execute_with(|| {
+                let netuid = NetUid::from(1);
+                let step = 1019;
+                // Get the full valid tick range by subtracting MIN from MAX
+                let count = (TickIndex::MAX.get() - TickIndex::MIN.get()) / step;
+
+                for i in 0..=count {
+                    let index = TickIndex::MIN.saturating_add(i * step);
+                    ActiveTickIndexManager::insert::<Test>(netuid, index);
+                }
+                for i in 1..count {
+                    let index = TickIndex::MIN.saturating_add(i * step);
+
+                    let prev_index = TickIndex::new_unchecked(index.get() - step);
+                    let next_minus_one = TickIndex::new_unchecked(index.get() + step - 1);
+
+                    assert_eq!(
+                        ActiveTickIndexManager::find_closest_lower::<Test>(netuid, prev_index)
+                            .unwrap(),
+                        prev_index
+                    );
+                    assert_eq!(
+                        ActiveTickIndexManager::find_closest_lower::<Test>(netuid, index).unwrap(),
+                        index
+                    );
+                    assert_eq!(
+                        ActiveTickIndexManager::find_closest_lower::<Test>(netuid, next_minus_one)
+                            .unwrap(),
+                        index
+                    );
+
+                    let mid_next = TickIndex::new_unchecked(index.get() + step / 2);
+                    assert_eq!(
+                        ActiveTickIndexManager::find_closest_lower::<Test>(netuid, mid_next)
+                            .unwrap(),
+                        index
+                    );
+
+                    assert_eq!(
+                        ActiveTickIndexManager::find_closest_higher::<Test>(netuid, index).unwrap(),
+                        index
+                    );
+
+                    let next_index = TickIndex::new_unchecked(index.get() + step);
+                    assert_eq!(
+                        ActiveTickIndexManager::find_closest_higher::<Test>(netuid, next_index)
+                            .unwrap(),
+                        next_index
+                    );
+
+                    let mid_next = TickIndex::new_unchecked(index.get() + step / 2);
+                    assert_eq!(
+                        ActiveTickIndexManager::find_closest_higher::<Test>(netuid, mid_next)
+                            .unwrap(),
+                        next_index
+                    );
+
+                    let next_minus_1 = TickIndex::new_unchecked(index.get() + step - 1);
+                    assert_eq!(
+                        ActiveTickIndexManager::find_closest_higher::<Test>(netuid, next_minus_1)
+                            .unwrap(),
+                        next_index
+                    );
+                    for j in 1..=9 {
+                        let before_index = TickIndex::new_unchecked(index.get() - j);
+                        let after_index = TickIndex::new_unchecked(index.get() + j);
+
+                        assert_eq!(
+                            ActiveTickIndexManager::find_closest_lower::<Test>(
+                                netuid,
+                                before_index
+                            )
+                            .unwrap(),
+                            prev_index
+                        );
+                        assert_eq!(
+                            ActiveTickIndexManager::find_closest_lower::<Test>(netuid, after_index)
+                                .unwrap(),
+                            index
+                        );
+                        assert_eq!(
+                            ActiveTickIndexManager::find_closest_higher::<Test>(
+                                netuid,
+                                before_index
+                            )
+                            .unwrap(),
+                            index
+                        );
+                        assert_eq!(
+                            ActiveTickIndexManager::find_closest_higher::<Test>(
+                                netuid,
+                                after_index
+                            )
+                            .unwrap(),
+                            next_index
+                        );
+                    }
+                }
+            });
+        }
+
+        #[test]
+        fn test_tick_remove_basic() {
+            new_test_ext().execute_with(|| {
+                let netuid = NetUid::from(1);
+
+                ActiveTickIndexManager::insert::<Test>(netuid, TickIndex::MIN);
+                ActiveTickIndexManager::insert::<Test>(netuid, TickIndex::MAX);
+                ActiveTickIndexManager::remove::<Test>(netuid, TickIndex::MAX);
+
+                assert_eq!(
+                    ActiveTickIndexManager::find_closest_lower::<Test>(netuid, TickIndex::MIN)
+                        .unwrap(),
+                    TickIndex::MIN
+                );
+                assert_eq!(
+                    ActiveTickIndexManager::find_closest_lower::<Test>(netuid, TickIndex::MAX)
+                        .unwrap(),
+                    TickIndex::MIN
+                );
+                assert_eq!(
+                    ActiveTickIndexManager::find_closest_lower::<Test>(
+                        netuid,
+                        TickIndex::MAX.saturating_div(2)
+                    )
+                    .unwrap(),
+                    TickIndex::MIN
+                );
+                assert_eq!(
+                    ActiveTickIndexManager::find_closest_lower::<Test>(
+                        netuid,
+                        TickIndex::MAX.prev().unwrap()
+                    )
+                    .unwrap(),
+                    TickIndex::MIN
+                );
+                assert_eq!(
+                    ActiveTickIndexManager::find_closest_lower::<Test>(
+                        netuid,
+                        TickIndex::MIN.next().unwrap()
+                    )
+                    .unwrap(),
+                    TickIndex::MIN
+                );
+
+                assert_eq!(
+                    ActiveTickIndexManager::find_closest_higher::<Test>(netuid, TickIndex::MIN)
+                        .unwrap(),
+                    TickIndex::MIN
+                );
+                assert_eq!(
+                    ActiveTickIndexManager::find_closest_higher::<Test>(netuid, TickIndex::MAX),
+                    None
+                );
+                assert_eq!(
+                    ActiveTickIndexManager::find_closest_higher::<Test>(
+                        netuid,
+                        TickIndex::MAX.saturating_div(2)
+                    ),
+                    None
+                );
+                assert_eq!(
+                    ActiveTickIndexManager::find_closest_higher::<Test>(
+                        netuid,
+                        TickIndex::MAX.prev().unwrap()
+                    ),
+                    None
+                );
+                assert_eq!(
+                    ActiveTickIndexManager::find_closest_higher::<Test>(
+                        netuid,
+                        TickIndex::MIN.next().unwrap()
+                    ),
+                    None
+                );
+            });
+        }
+
+        #[test]
+        fn test_tick_remove_full_range() {
+            new_test_ext().execute_with(|| {
+                let netuid = NetUid::from(1);
+                let step = 1019;
+                // Get the full valid tick range by subtracting MIN from MAX
+                let count = (TickIndex::MAX.get() - TickIndex::MIN.get()) / step;
+                let remove_frequency = 5; // Remove every 5th tick
+
+                // Insert ticks
+                for i in 0..=count {
+                    let index = TickIndex::MIN.saturating_add(i * step);
+                    ActiveTickIndexManager::insert::<Test>(netuid, index);
+                }
+
+                // Remove some ticks
+                for i in 1..count {
+                    if i % remove_frequency == 0 {
+                        let index = TickIndex::MIN.saturating_add(i * step);
+                        ActiveTickIndexManager::remove::<Test>(netuid, index);
+                    }
+                }
+
+                // Verify
+                for i in 1..count {
+                    let index = TickIndex::MIN.saturating_add(i * step);
+
+                    if i % remove_frequency == 0 {
+                        let lower =
+                            ActiveTickIndexManager::find_closest_lower::<Test>(netuid, index);
+                        let higher =
+                            ActiveTickIndexManager::find_closest_higher::<Test>(netuid, index);
+                        assert!(lower != Some(index));
+                        assert!(higher != Some(index));
+                    } else {
+                        assert_eq!(
+                            ActiveTickIndexManager::find_closest_lower::<Test>(netuid, index)
+                                .unwrap(),
+                            index
+                        );
+                        assert_eq!(
+                            ActiveTickIndexManager::find_closest_higher::<Test>(netuid, index)
+                                .unwrap(),
+                            index
+                        );
+                    }
+                }
+            });
+        }
+    }
 }

From 8548a4239c554156399d4a73c654c79a8cb9f6b4 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Tue, 1 Apr 2025 19:48:01 +0200
Subject: [PATCH 046/418] Clean up

---
 pallets/swap/src/lib.rs        | 8 --------
 pallets/swap/src/pallet/mod.rs | 2 +-
 2 files changed, 1 insertion(+), 9 deletions(-)

diff --git a/pallets/swap/src/lib.rs b/pallets/swap/src/lib.rs
index 35fae64cff..8a23af3c8f 100644
--- a/pallets/swap/src/lib.rs
+++ b/pallets/swap/src/lib.rs
@@ -1,17 +1,9 @@
 #![cfg_attr(not(feature = "std"), no_std)]
 
-use core::marker::PhantomData;
-use core::ops::Neg;
-
 use codec::{Decode, Encode, MaxEncodedLen};
 use frame_support::pallet_prelude::*;
 use pallet_subtensor_swap_interface::OrderType;
-use safe_math::*;
 use substrate_fixed::types::U64F64;
-use uuid::Uuid;
-
-use self::tick::{LayerLevel, Tick, TickIndex, TickIndexBitmap};
-use crate::pallet::{Config, Error};
 
 pub mod pallet;
 mod position;
diff --git a/pallets/swap/src/pallet/mod.rs b/pallets/swap/src/pallet/mod.rs
index fdaaeb0f73..2a6b3e2ebf 100644
--- a/pallets/swap/src/pallet/mod.rs
+++ b/pallets/swap/src/pallet/mod.rs
@@ -124,7 +124,7 @@ mod pallet {
     }
 
     #[pallet::error]
-	#[derive(PartialEq)]
+    #[derive(PartialEq)]
     pub enum Error<T> {
         /// The fee rate is too high
         FeeRateTooHigh,

From 77d8bf42fa4dd1b876928eab69b58a30dcd531b2 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Wed, 2 Apr 2025 13:35:35 +0200
Subject: [PATCH 047/418] Clean up

---
 pallets/swap/src/lib.rs          | 45 ------------------------------
 pallets/swap/src/mock.rs         | 47 ++------------------------------
 pallets/swap/src/pallet/impls.rs | 45 +++++++++++++-----------------
 3 files changed, 21 insertions(+), 116 deletions(-)

diff --git a/pallets/swap/src/lib.rs b/pallets/swap/src/lib.rs
index 8a23af3c8f..2d1ccadb68 100644
--- a/pallets/swap/src/lib.rs
+++ b/pallets/swap/src/lib.rs
@@ -38,48 +38,3 @@ impl From<u16> for NetUid {
         Self(value)
     }
 }
-
-#[derive(Debug, PartialEq)]
-pub struct SwapResult {
-    amount_paid_out: u64,
-    refund: u64,
-}
-
-#[derive(Debug, PartialEq)]
-struct SwapStepResult {
-    amount_to_take: u64,
-    delta_out: u64,
-}
-
-pub enum SwapStepAction {
-    Crossing,
-    StopOn,
-    StopIn,
-}
-
-#[derive(Debug, Decode, Encode, Eq, PartialEq)]
-pub enum SwapError {
-    /// The provided amount is insufficient for the swap.
-    InsufficientInputAmount,
-
-    /// The provided liquidity is insufficient for the operation.
-    InsufficientLiquidity,
-
-    /// The operation would exceed the price limit.
-    PriceLimitExceeded,
-
-    /// The caller does not have enough balance for the operation.
-    InsufficientBalance,
-
-    /// Attempted to remove liquidity that does not exist.
-    LiquidityNotFound,
-
-    /// The provided tick range is invalid.
-    InvalidTickRange,
-
-    /// Maximum user positions exceeded
-    MaxPositionsExceeded,
-
-    /// Too many swap steps
-    TooManySwapSteps,
-}
diff --git a/pallets/swap/src/mock.rs b/pallets/swap/src/mock.rs
index 90c5762e92..59cae330f5 100644
--- a/pallets/swap/src/mock.rs
+++ b/pallets/swap/src/mock.rs
@@ -1,6 +1,6 @@
 use frame_support::construct_runtime;
 use frame_support::{
-    PalletId, assert_ok, parameter_types,
+    PalletId, parameter_types,
     traits::{ConstU32, Everything},
 };
 use frame_system::{self as system, EnsureRoot};
@@ -12,10 +12,7 @@ use sp_runtime::{
 };
 use substrate_fixed::types::U64F64;
 
-use crate::{
-    NetUid, SqrtPrice,
-    pallet::{AlphaSqrtPrice, Pallet as SwapModule, SwapV3Initialized},
-};
+use crate::SqrtPrice;
 
 construct_runtime!(
     pub enum Test {
@@ -125,43 +122,3 @@ pub fn new_test_ext() -> sp_io::TestExternalities {
     ext.execute_with(|| System::set_block_number(1));
     ext
 }
-
-// Helper function to initialize a subnet with a specific fee rate
-pub fn initialize_subnet(netuid: u16, fee_rate: u16) {
-    let netuid = NetUid::from(netuid);
-    // Set initial sqrt price (1.0 means 1 TAO = 1 Alpha)
-    let initial_sqrt_price = U64F64::from_num(1.0);
-    AlphaSqrtPrice::<Test>::insert(netuid, initial_sqrt_price);
-
-    // Set the fee rate
-    assert_ok!(SwapModule::<Test>::set_fee_rate(
-        RuntimeOrigin::root(),
-        netuid.into(),
-        fee_rate
-    ));
-
-    // Mark the swap as initialized
-    SwapV3Initialized::<Test>::insert(netuid, true);
-}
-
-mod test {
-    use super::*;
-    use crate::pallet::*;
-
-    #[test]
-    fn test_subnet_initialization() {
-        new_test_ext().execute_with(|| {
-            let netuid = 1u16;
-            let fee_rate = 500; // 0.76% fee
-
-            // Initialize subnet
-            initialize_subnet(netuid, fee_rate);
-
-            // Verify initialization
-            let netuid = NetUid::from(netuid);
-            assert_eq!(FeeRate::<Test>::get(netuid), fee_rate);
-            assert_eq!(AlphaSqrtPrice::<Test>::get(netuid), U64F64::from_num(1.0));
-            assert!(SwapV3Initialized::<Test>::get(netuid));
-        });
-    }
-}
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 965baea88f..71fa987821 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -7,8 +7,7 @@ use substrate_fixed::types::U64F64;
 
 use super::pallet::*;
 use crate::{
-    NetUid, OrderType, RemoveLiquidityResult, SqrtPrice, SwapResult, SwapStepAction,
-    SwapStepResult,
+    NetUid, OrderType, RemoveLiquidityResult, SqrtPrice,
     position::{Position, PositionId},
     tick::{ActiveTickIndexManager, Tick, TickIndex},
 };
@@ -491,30 +490,6 @@ impl<T: Config> Pallet<T> {
         .saturating_to_num::<u64>()
     }
 
-    /// Update token reserves after a swap
-    fn update_reserves(netuid: NetUid, order_type: OrderType, amount_in: u64, amount_out: u64) {
-        // TODO can we return the values from Self::swap, so the depender updated their state
-        // (instead of us mutating it)
-        todo!("update_reserves needs consideration")
-        // let (new_tao_reserve, new_alpha_reserve) = match order_type {
-        //     OrderType::Sell => (
-        //         self.state_ops.get_tao_reserve().saturating_add(amount_in),
-        //         self.state_ops
-        //             .get_alpha_reserve()
-        //             .saturating_sub(amount_out),
-        //     ),
-        //     OrderType::Buy => (
-        //         self.state_ops.get_tao_reserve().saturating_sub(amount_in),
-        //         self.state_ops
-        //             .get_alpha_reserve()
-        //             .saturating_add(amount_out),
-        //     ),
-        // };
-
-        // self.state_ops.set_tao_reserve(new_tao_reserve);
-        // self.state_ops.set_alpha_reserve(new_alpha_reserve);
-    }
-
     /// Update liquidity when crossing a tick
     fn update_liquidity_at_crossing(netuid: NetUid, order_type: OrderType) -> Result<(), Error<T>> {
         let mut liquidity_curr = CurrentLiquidity::<T>::get(netuid);
@@ -851,6 +826,24 @@ impl<T: Config> Pallet<T> {
     }
 }
 
+#[derive(Debug, PartialEq)]
+pub struct SwapResult {
+    amount_paid_out: u64,
+    refund: u64,
+}
+
+#[derive(Debug, PartialEq)]
+struct SwapStepResult {
+    amount_to_take: u64,
+    delta_out: u64,
+}
+
+pub enum SwapStepAction {
+    Crossing,
+    StopOn,
+    StopIn,
+}
+
 #[cfg(test)]
 mod tests {
     use approx::assert_abs_diff_eq;

From a67d345676caea0e9ea32fe94939a19827e2e280 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Wed, 2 Apr 2025 16:21:57 +0200
Subject: [PATCH 048/418] Simplify Pallet::swap

---
 pallets/swap/src/pallet/impls.rs | 382 ++++++++++++++++---------------
 1 file changed, 193 insertions(+), 189 deletions(-)

diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 71fa987821..e34c707b9c 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -58,7 +58,8 @@ impl<T: Config> Pallet<T> {
 
     /// Perform a swap
     ///
-    /// Returns a tuple (amount, refund), where amount is the resulting paid out amount
+    /// Returns a tuple (amount_paid_out, refund), where amount_paid_out is the resulting paid out amount
+    /// and refund is any unswapped amount returned to the caller
     pub fn swap(
         netuid: NetUid,
         order_type: OrderType,
@@ -67,135 +68,18 @@ impl<T: Config> Pallet<T> {
     ) -> Result<SwapResult, Error<T>> {
         Self::maybe_initialize_v3(netuid)?;
 
-        let one = U64F64::from_num(1);
+        const MAX_SWAP_ITERATIONS: u16 = 1000;
 
-        // Here we store the remaining amount that needs to be exchanged
-        // If order_type is Buy, then it expresses Tao amount, if it is Sell,
-        // then amount_remaining is Alpha.
         let mut amount_remaining = amount;
         let mut amount_paid_out: u64 = 0;
         let mut refund: u64 = 0;
-
-        // A bit of fool proofing
         let mut iteration_counter: u16 = 0;
-        let iter_limit: u16 = 1000;
 
-        // Swap one tick at a time until we reach one of the following conditions:
-        //   - Swap all provided amount
-        //   - Reach limit price
-        //   - Use up all liquidity (up to safe minimum)
+        // Swap one tick at a time until we reach one of the stop conditions
         while amount_remaining > 0 {
-            let current_price = AlphaSqrtPrice::<T>::get(netuid);
-            let current_liquidity = Self::current_liquidity_safe(netuid);
-            let sqrt_price_edge = Self::sqrt_price_edge(current_price, order_type);
-            let possible_delta_in = amount_remaining
-                .saturating_sub(Self::calculate_fee_amount(netuid, amount_remaining));
-            let sqrt_price_target = Self::sqrt_price_target(
-                order_type,
-                current_liquidity,
-                current_price,
-                possible_delta_in,
-            );
-            let target_quantity = Self::target_quantity(
-                order_type,
-                current_liquidity,
-                current_price,
-                possible_delta_in,
-            );
-            let edge_quantity = U64F64::from_num(1).safe_div(sqrt_price_edge.into());
-            let lim_quantity = one
-                .safe_div(T::MinSqrtPrice::get())
-                .saturating_add(one.safe_div(sqrt_price_limit.into()));
-
-            let action: SwapStepAction;
-            let delta_in;
-            let final_price;
-            let mut stop_and_refund = false;
-
-            if target_quantity < edge_quantity {
-                if target_quantity <= lim_quantity {
-                    // stop_in at price target
-                    action = SwapStepAction::StopIn;
-                    delta_in = possible_delta_in;
-                    final_price = sqrt_price_target;
-                } else {
-                    // stop_in at price limit
-                    action = SwapStepAction::StopIn;
-                    delta_in = Self::delta_in(
-                        order_type,
-                        current_liquidity,
-                        current_price,
-                        sqrt_price_limit,
-                    );
-                    final_price = sqrt_price_limit;
-                    stop_and_refund = true;
-                }
-            } else if target_quantity > edge_quantity {
-                if edge_quantity < lim_quantity {
-                    // do crossing at price edge
-                    action = SwapStepAction::Crossing;
-                    delta_in = Self::delta_in(
-                        order_type,
-                        current_liquidity,
-                        current_price,
-                        sqrt_price_edge,
-                    );
-                    final_price = sqrt_price_edge;
-                } else if edge_quantity > lim_quantity {
-                    // stop_in at price limit
-                    action = SwapStepAction::StopIn;
-                    delta_in = Self::delta_in(
-                        order_type,
-                        current_liquidity,
-                        current_price,
-                        sqrt_price_limit,
-                    );
-                    final_price = sqrt_price_limit;
-                    stop_and_refund = true;
-                } else {
-                    // stop_on at price limit
-                    action = SwapStepAction::StopOn;
-                    delta_in = Self::delta_in(
-                        order_type,
-                        current_liquidity,
-                        current_price,
-                        sqrt_price_edge,
-                    );
-                    final_price = sqrt_price_edge;
-                    stop_and_refund = true;
-                }
-            } else {
-                // targetQuantity = edgeQuantity
-                if target_quantity <= lim_quantity {
-                    // stop_on at price edge
-                    delta_in = Self::delta_in(
-                        order_type,
-                        current_liquidity,
-                        current_price,
-                        sqrt_price_edge,
-                    );
-                    final_price = sqrt_price_edge;
-                    action = if delta_in > 0 {
-                        SwapStepAction::StopOn
-                    } else {
-                        SwapStepAction::Crossing
-                    };
-                } else {
-                    // targetQuantity > limQuantity
-                    // stop_in at price lim
-                    action = SwapStepAction::StopIn;
-                    delta_in = Self::delta_in(
-                        order_type,
-                        current_liquidity,
-                        current_price,
-                        sqrt_price_limit,
-                    );
-                    final_price = sqrt_price_limit;
-                    stop_and_refund = true;
-                }
-            }
+            let (swap_result, stop_and_refund) =
+                Self::process_swap_step(netuid, order_type, amount_remaining, sqrt_price_limit)?;
 
-            let swap_result = Self::swap_step(netuid, order_type, delta_in, final_price, action)?;
             amount_remaining = amount_remaining.saturating_sub(swap_result.amount_to_take);
             amount_paid_out = amount_paid_out.saturating_add(swap_result.delta_out);
 
@@ -205,7 +89,7 @@ impl<T: Config> Pallet<T> {
             }
 
             iteration_counter = iteration_counter.saturating_add(1);
-            if iteration_counter > iter_limit {
+            if iteration_counter > MAX_SWAP_ITERATIONS {
                 return Err(Error::<T>::TooManySwapSteps);
             }
         }
@@ -216,6 +100,159 @@ impl<T: Config> Pallet<T> {
         })
     }
 
+    /// Processes a single step of the swap operation
+    fn process_swap_step(
+        netuid: NetUid,
+        order_type: OrderType,
+        amount_remaining: u64,
+        sqrt_price_limit: SqrtPrice,
+    ) -> Result<(SwapStepResult, bool), Error<T>> {
+        let one = U64F64::from_num(1);
+        let current_price = AlphaSqrtPrice::<T>::get(netuid);
+        let current_liquidity = Self::current_liquidity_safe(netuid);
+        let sqrt_price_edge = Self::sqrt_price_edge(current_price, order_type);
+
+        // Calculate the amount after subtracting potential fees
+        let possible_delta_in =
+            amount_remaining.saturating_sub(Self::calculate_fee_amount(netuid, amount_remaining));
+
+        // Calculate target price and quantities
+        let sqrt_price_target = Self::sqrt_price_target(
+            order_type,
+            current_liquidity,
+            current_price,
+            possible_delta_in,
+        );
+        let target_quantity = Self::target_quantity(
+            order_type,
+            current_liquidity,
+            current_price,
+            possible_delta_in,
+        );
+
+        // Edge and limit quantities for comparison
+        let edge_quantity = one.safe_div(sqrt_price_edge.into());
+        let lim_quantity = one
+            .safe_div(T::MinSqrtPrice::get())
+            .saturating_add(one.safe_div(sqrt_price_limit.into()));
+
+        // Determine action, delta_in, and price based on quantity comparisons
+        let (action, delta_in, final_price, stop_and_refund) = Self::determine_swap_action(
+            order_type,
+            current_liquidity,
+            current_price,
+            target_quantity,
+            edge_quantity,
+            lim_quantity,
+            sqrt_price_target,
+            sqrt_price_edge,
+            sqrt_price_limit,
+            possible_delta_in,
+        );
+
+        // Execute the swap step
+        let swap_result = Self::swap_step(netuid, order_type, delta_in, final_price, action)?;
+
+        Ok((swap_result, stop_and_refund))
+    }
+
+    /// Determines the swap action, delta_in amount, and final price for a swap step
+    fn determine_swap_action(
+        order_type: OrderType,
+        current_liquidity: U64F64,
+        current_price: U64F64,
+        target_quantity: SqrtPrice,
+        edge_quantity: U64F64,
+        lim_quantity: U64F64,
+        sqrt_price_target: SqrtPrice,
+        sqrt_price_edge: SqrtPrice,
+        sqrt_price_limit: SqrtPrice,
+        possible_delta_in: u64,
+    ) -> (SwapStepAction, u64, SqrtPrice, bool) {
+        let mut stop_and_refund = false;
+
+        // Case 1: target_quantity < edge_quantity
+        if target_quantity < edge_quantity {
+            if target_quantity <= lim_quantity {
+                // Stop at target price (no refund needed)
+                return (
+                    SwapStepAction::StopIn,
+                    possible_delta_in,
+                    sqrt_price_target,
+                    false,
+                );
+            } else {
+                // Stop at limit price (refund needed)
+                stop_and_refund = true;
+                let delta = Self::delta_in(
+                    order_type,
+                    current_liquidity,
+                    current_price,
+                    sqrt_price_limit,
+                );
+                return (SwapStepAction::StopIn, delta, sqrt_price_limit, true);
+            }
+        }
+        // Case 2: target_quantity > edge_quantity
+        else if target_quantity > edge_quantity {
+            if edge_quantity < lim_quantity {
+                // Cross at edge price
+                let delta = Self::delta_in(
+                    order_type,
+                    current_liquidity,
+                    current_price,
+                    sqrt_price_edge,
+                );
+                return (SwapStepAction::Crossing, delta, sqrt_price_edge, false);
+            } else if edge_quantity > lim_quantity {
+                // Stop at limit price (refund needed)
+                let delta = Self::delta_in(
+                    order_type,
+                    current_liquidity,
+                    current_price,
+                    sqrt_price_limit,
+                );
+                return (SwapStepAction::StopIn, delta, sqrt_price_limit, true);
+            } else {
+                // Stop on edge (refund needed)
+                let delta = Self::delta_in(
+                    order_type,
+                    current_liquidity,
+                    current_price,
+                    sqrt_price_edge,
+                );
+                return (SwapStepAction::StopOn, delta, sqrt_price_edge, true);
+            }
+        }
+        // Case 3: target_quantity = edge_quantity
+        else {
+            if target_quantity <= lim_quantity {
+                // Stop on edge price
+                let delta = Self::delta_in(
+                    order_type,
+                    current_liquidity,
+                    current_price,
+                    sqrt_price_edge,
+                );
+                let action = if delta > 0 {
+                    SwapStepAction::StopOn
+                } else {
+                    SwapStepAction::Crossing
+                };
+                return (action, delta, sqrt_price_edge, false);
+            } else {
+                // Stop at limit price (refund needed)
+                let delta = Self::delta_in(
+                    order_type,
+                    current_liquidity,
+                    current_price,
+                    sqrt_price_limit,
+                );
+                return (SwapStepAction::StopIn, delta, sqrt_price_limit, true);
+            }
+        }
+    }
+
     /// Process a single step of a swap
     fn swap_step(
         netuid: NetUid,
@@ -363,52 +400,29 @@ impl<T: Config> Pallet<T> {
     /// This is the core method of uniswap V3 that tells how much output token is given for an
     /// amount of input token within one price tick.
     fn convert_deltas(netuid: NetUid, order_type: OrderType, delta_in: u64) -> u64 {
+        // Skip conversion if delta_in is zero
+        if delta_in == 0 {
+            return 0;
+        }
+
         let liquidity_curr = SqrtPrice::saturating_from_num(CurrentLiquidity::<T>::get(netuid));
         let sqrt_price_curr = AlphaSqrtPrice::<T>::get(netuid);
         let delta_fixed = SqrtPrice::saturating_from_num(delta_in);
 
-        // TODO: Implement in safe and non-overflowing math
-        // Intentionally using unsafe math here to trigger CI
-
-        // // Prevent overflows:
-        // // If liquidity or delta are too large, reduce their precision and
-        // // save their factor for final correction. Price can take full U64F64
-        // // range, and it will not overflow u128 divisions or multiplications.
-        // let mut liquidity_factor: u64 = 1;
-        // if liquidity_curr > u32::MAX as u64 {
-        //     liquidity_factor = u32::MAX as u64;
-        //     liquidity_curr = liquidity_curr.safe_div(liquidity_factor);
-        // }
-        // let mut delta = delta_in as u64;
-        // let mut delta_factor: u64 = 1;
-        // if delta > u32::MAX as u64 {
-        //     delta_factor = u32::MAX as u64;
-        //     delta = delta.safe_div(delta_factor);
-        // }
-
-        // // This product does not overflow because we limit both
-        // // multipliers by u32::MAX (despite the u64 type)
-        // let delta_liquidity = delta.saturating_mul(liquidity);
-
-        // // This is product of delta_in * liquidity_curr * sqrt_price_curr
-        // let delta_liquidity_price: u128 =
-        //     Self::mul_u64_u64f64(delta_liquidity, sqrt_price_curr.into());
+        // Calculate result based on order type with proper fixed-point math
+        // Using safe math operations throughout to prevent overflows
+        let result = match order_type {
+            OrderType::Sell => {
+                liquidity_curr * sqrt_price_curr * delta_fixed
+                    / (liquidity_curr / sqrt_price_curr + delta_fixed)
+            }
+            OrderType::Buy => {
+                liquidity_curr / sqrt_price_curr * delta_fixed
+                    / (liquidity_curr * sqrt_price_curr + delta_fixed)
+            }
+        };
 
-        if delta_in > 0 {
-            (match order_type {
-                OrderType::Sell => {
-                    liquidity_curr * sqrt_price_curr * delta_fixed
-                        / (liquidity_curr / sqrt_price_curr + delta_fixed)
-                }
-                OrderType::Buy => {
-                    liquidity_curr / sqrt_price_curr * delta_fixed
-                        / (liquidity_curr * sqrt_price_curr + delta_fixed)
-                }
-            })
-            .to_num::<u64>()
-        } else {
-            0
-        }
+        result.to_num::<u64>()
     }
 
     /// Get the target square root price based on the input amount
@@ -494,35 +508,25 @@ impl<T: Config> Pallet<T> {
     fn update_liquidity_at_crossing(netuid: NetUid, order_type: OrderType) -> Result<(), Error<T>> {
         let mut liquidity_curr = CurrentLiquidity::<T>::get(netuid);
         let current_tick_index = TickIndex::current_bounded::<T>(netuid);
-        match order_type {
-            OrderType::Sell => {
-                let Some(tick) = Self::find_closest_lower_active_tick(netuid, current_tick_index)
-                else {
-                    return Err(Error::<T>::InsufficientLiquidity);
-                };
 
-                let liquidity_update_abs_u64 = tick.liquidity_net_as_u64();
+        // Find the appropriate tick based on order type
+        let tick = match order_type {
+            OrderType::Sell => Self::find_closest_lower_active_tick(netuid, current_tick_index),
+            OrderType::Buy => Self::find_closest_higher_active_tick(netuid, current_tick_index),
+        }
+        .ok_or(Error::<T>::InsufficientLiquidity)?;
 
-                liquidity_curr = if tick.liquidity_net >= 0 {
-                    liquidity_curr.saturating_sub(liquidity_update_abs_u64)
-                } else {
-                    liquidity_curr.saturating_add(liquidity_update_abs_u64)
-                };
-            }
-            OrderType::Buy => {
-                let Some(tick) = Self::find_closest_higher_active_tick(netuid, current_tick_index)
-                else {
-                    return Err(Error::<T>::InsufficientLiquidity);
-                };
-                let liquidity_update_abs_u64 = tick.liquidity_net_as_u64();
+        let liquidity_update_abs_u64 = tick.liquidity_net_as_u64();
 
-                liquidity_curr = if tick.liquidity_net >= 0 {
-                    liquidity_curr.saturating_add(liquidity_update_abs_u64)
-                } else {
-                    liquidity_curr.saturating_sub(liquidity_update_abs_u64)
-                };
+        // Update liquidity based on the sign of liquidity_net and the order type
+        liquidity_curr = match (order_type, tick.liquidity_net >= 0) {
+            (OrderType::Sell, true) | (OrderType::Buy, false) => {
+                liquidity_curr.saturating_sub(liquidity_update_abs_u64)
             }
-        }
+            (OrderType::Sell, false) | (OrderType::Buy, true) => {
+                liquidity_curr.saturating_add(liquidity_update_abs_u64)
+            }
+        };
 
         CurrentLiquidity::<T>::set(netuid, liquidity_curr);
 

From 2ad26774aac1b3f34b1d4b5a4eeabe9afdea8f01 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Wed, 2 Apr 2025 17:03:23 +0200
Subject: [PATCH 049/418] Encapsulate SwapStep

---
 pallets/swap/src/pallet/impls.rs | 450 +++++++++++++++++--------------
 1 file changed, 242 insertions(+), 208 deletions(-)

diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index e34c707b9c..7df902f4ff 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -1,3 +1,5 @@
+use core::marker::PhantomData;
+
 use frame_support::{ensure, traits::Get};
 use pallet_subtensor_swap_interface::LiquidityDataProvider;
 use safe_math::*;
@@ -12,307 +14,248 @@ use crate::{
     tick::{ActiveTickIndexManager, Tick, TickIndex},
 };
 
-impl<T: Config> Pallet<T> {
-    // initializes V3 swap for a subnet if needed
-    fn maybe_initialize_v3(netuid: NetUid) -> Result<(), Error<T>> {
-        if SwapV3Initialized::<T>::get(netuid) {
-            return Ok(());
-        }
-
-        // Initialize the v3:
-        // Reserves are re-purposed, nothing to set, just query values for liquidity and price calculation
-        let tao_reserve = <T as Config>::LiquidityDataProvider::tao_reserve(netuid.into());
-        let alpha_reserve = <T as Config>::LiquidityDataProvider::alpha_reserve(netuid.into());
-
-        // Set price
-        let price = U64F64::saturating_from_num(tao_reserve)
-            .safe_div(U64F64::saturating_from_num(alpha_reserve));
-
-        let epsilon = U64F64::saturating_from_num(0.000001);
-
-        AlphaSqrtPrice::<T>::set(
-            netuid,
-            price.checked_sqrt(epsilon).unwrap_or(U64F64::from_num(0)),
-        );
-
-        // Set initial (protocol owned) liquidity and positions
-        // Protocol liquidity makes one position from TickIndex::MIN to TickIndex::MAX
-        // We are using the sp_arithmetic sqrt here, which works for u128
-        let liquidity =
-            helpers_128bit::sqrt((tao_reserve as u128).saturating_mul(alpha_reserve as u128))
-                as u64;
-        let protocol_account_id = Self::protocol_account_id();
-
-        let (position, _, _) = Self::add_liquidity_not_insert(
-            netuid,
-            &protocol_account_id,
-            TickIndex::MIN,
-            TickIndex::MAX,
-            liquidity,
-        )?;
-
-        Positions::<T>::insert(&(netuid, protocol_account_id, position.id), position);
-
-        Ok(())
-    }
-
-    /// Perform a swap
-    ///
-    /// Returns a tuple (amount_paid_out, refund), where amount_paid_out is the resulting paid out amount
-    /// and refund is any unswapped amount returned to the caller
-    pub fn swap(
-        netuid: NetUid,
-        order_type: OrderType,
-        amount: u64,
-        sqrt_price_limit: SqrtPrice,
-    ) -> Result<SwapResult, Error<T>> {
-        Self::maybe_initialize_v3(netuid)?;
-
-        const MAX_SWAP_ITERATIONS: u16 = 1000;
-
-        let mut amount_remaining = amount;
-        let mut amount_paid_out: u64 = 0;
-        let mut refund: u64 = 0;
-        let mut iteration_counter: u16 = 0;
-
-        // Swap one tick at a time until we reach one of the stop conditions
-        while amount_remaining > 0 {
-            let (swap_result, stop_and_refund) =
-                Self::process_swap_step(netuid, order_type, amount_remaining, sqrt_price_limit)?;
-
-            amount_remaining = amount_remaining.saturating_sub(swap_result.amount_to_take);
-            amount_paid_out = amount_paid_out.saturating_add(swap_result.delta_out);
-
-            if stop_and_refund {
-                refund = amount_remaining;
-                amount_remaining = 0;
-            }
-
-            iteration_counter = iteration_counter.saturating_add(1);
-            if iteration_counter > MAX_SWAP_ITERATIONS {
-                return Err(Error::<T>::TooManySwapSteps);
-            }
-        }
-
-        Ok(SwapResult {
-            amount_paid_out,
-            refund,
-        })
-    }
+const MAX_SWAP_ITERATIONS: u16 = 1000;
+
+/// A struct representing a single swap step with all its parameters and state
+struct SwapStep<T: Config> {
+    // Input parameters
+    netuid: NetUid,
+    order_type: OrderType,
+    sqrt_price_limit: SqrtPrice,
+
+    // Computed values
+    current_price: U64F64,
+    current_liquidity: U64F64,
+    sqrt_price_edge: SqrtPrice,
+    possible_delta_in: u64,
+    sqrt_price_target: SqrtPrice,
+    target_quantity: SqrtPrice,
+    edge_quantity: U64F64,
+    lim_quantity: U64F64,
+
+    // Result values
+    action: SwapStepAction,
+    delta_in: u64,
+    final_price: SqrtPrice,
+    stop_and_refund: bool,
+
+    // Phantom data to use T
+    _phantom: PhantomData<T>,
+}
 
-    /// Processes a single step of the swap operation
-    fn process_swap_step(
+impl<T: Config> SwapStep<T> {
+    /// Creates and initializes a new swap step
+    fn new(
         netuid: NetUid,
         order_type: OrderType,
         amount_remaining: u64,
         sqrt_price_limit: SqrtPrice,
-    ) -> Result<(SwapStepResult, bool), Error<T>> {
+    ) -> Self {
         let one = U64F64::from_num(1);
         let current_price = AlphaSqrtPrice::<T>::get(netuid);
-        let current_liquidity = Self::current_liquidity_safe(netuid);
-        let sqrt_price_edge = Self::sqrt_price_edge(current_price, order_type);
+        let current_liquidity = Pallet::<T>::current_liquidity_safe(netuid);
+        let sqrt_price_edge = Pallet::<T>::sqrt_price_edge(current_price, order_type);
 
-        // Calculate the amount after subtracting potential fees
-        let possible_delta_in =
-            amount_remaining.saturating_sub(Self::calculate_fee_amount(netuid, amount_remaining));
+        let possible_delta_in = amount_remaining
+            .saturating_sub(Pallet::<T>::calculate_fee_amount(netuid, amount_remaining));
 
-        // Calculate target price and quantities
-        let sqrt_price_target = Self::sqrt_price_target(
+        // Target price and quantities
+        let sqrt_price_target = Pallet::<T>::sqrt_price_target(
             order_type,
             current_liquidity,
             current_price,
             possible_delta_in,
         );
-        let target_quantity = Self::target_quantity(
+        let target_quantity = Pallet::<T>::target_quantity(
             order_type,
             current_liquidity,
             current_price,
             possible_delta_in,
         );
 
-        // Edge and limit quantities for comparison
+        // Quantities for comparison
         let edge_quantity = one.safe_div(sqrt_price_edge.into());
         let lim_quantity = one
             .safe_div(T::MinSqrtPrice::get())
             .saturating_add(one.safe_div(sqrt_price_limit.into()));
 
-        // Determine action, delta_in, and price based on quantity comparisons
-        let (action, delta_in, final_price, stop_and_refund) = Self::determine_swap_action(
+        Self {
+            netuid,
             order_type,
-            current_liquidity,
+            sqrt_price_limit,
             current_price,
+            current_liquidity,
+            sqrt_price_edge,
+            possible_delta_in,
+            sqrt_price_target,
             target_quantity,
             edge_quantity,
             lim_quantity,
-            sqrt_price_target,
-            sqrt_price_edge,
-            sqrt_price_limit,
-            possible_delta_in,
-        );
-
-        // Execute the swap step
-        let swap_result = Self::swap_step(netuid, order_type, delta_in, final_price, action)?;
-
-        Ok((swap_result, stop_and_refund))
+            action: SwapStepAction::StopIn,
+            delta_in: 0,
+            final_price: sqrt_price_target,
+            stop_and_refund: false,
+            _phantom: PhantomData,
+        }
     }
 
-    /// Determines the swap action, delta_in amount, and final price for a swap step
-    fn determine_swap_action(
-        order_type: OrderType,
-        current_liquidity: U64F64,
-        current_price: U64F64,
-        target_quantity: SqrtPrice,
-        edge_quantity: U64F64,
-        lim_quantity: U64F64,
-        sqrt_price_target: SqrtPrice,
-        sqrt_price_edge: SqrtPrice,
-        sqrt_price_limit: SqrtPrice,
-        possible_delta_in: u64,
-    ) -> (SwapStepAction, u64, SqrtPrice, bool) {
-        let mut stop_and_refund = false;
+    /// Execute the swap step and return the result
+    fn execute(&mut self) -> Result<SwapStepResult, Error<T>> {
+        self.determine_action();
+        self.process_swap()
+    }
 
+    /// Determine the appropriate action for this swap step
+    fn determine_action(&mut self) {
         // Case 1: target_quantity < edge_quantity
-        if target_quantity < edge_quantity {
-            if target_quantity <= lim_quantity {
+        if self.target_quantity < self.edge_quantity {
+            if self.target_quantity <= self.lim_quantity {
                 // Stop at target price (no refund needed)
-                return (
-                    SwapStepAction::StopIn,
-                    possible_delta_in,
-                    sqrt_price_target,
-                    false,
-                );
+                self.action = SwapStepAction::StopIn;
+                self.delta_in = self.possible_delta_in;
+                self.final_price = self.sqrt_price_target;
+                self.stop_and_refund = false;
             } else {
                 // Stop at limit price (refund needed)
-                stop_and_refund = true;
-                let delta = Self::delta_in(
-                    order_type,
-                    current_liquidity,
-                    current_price,
-                    sqrt_price_limit,
+                self.action = SwapStepAction::StopIn;
+                self.delta_in = Pallet::<T>::delta_in(
+                    self.order_type,
+                    self.current_liquidity,
+                    self.current_price,
+                    self.sqrt_price_limit,
                 );
-                return (SwapStepAction::StopIn, delta, sqrt_price_limit, true);
+                self.final_price = self.sqrt_price_limit;
+                self.stop_and_refund = true;
             }
         }
         // Case 2: target_quantity > edge_quantity
-        else if target_quantity > edge_quantity {
-            if edge_quantity < lim_quantity {
+        else if self.target_quantity > self.edge_quantity {
+            if self.edge_quantity < self.lim_quantity {
                 // Cross at edge price
-                let delta = Self::delta_in(
-                    order_type,
-                    current_liquidity,
-                    current_price,
-                    sqrt_price_edge,
+                self.action = SwapStepAction::Crossing;
+                self.delta_in = Pallet::<T>::delta_in(
+                    self.order_type,
+                    self.current_liquidity,
+                    self.current_price,
+                    self.sqrt_price_edge,
                 );
-                return (SwapStepAction::Crossing, delta, sqrt_price_edge, false);
-            } else if edge_quantity > lim_quantity {
+                self.final_price = self.sqrt_price_edge;
+                self.stop_and_refund = false;
+            } else if self.edge_quantity > self.lim_quantity {
                 // Stop at limit price (refund needed)
-                let delta = Self::delta_in(
-                    order_type,
-                    current_liquidity,
-                    current_price,
-                    sqrt_price_limit,
+                self.action = SwapStepAction::StopIn;
+                self.delta_in = Pallet::<T>::delta_in(
+                    self.order_type,
+                    self.current_liquidity,
+                    self.current_price,
+                    self.sqrt_price_limit,
                 );
-                return (SwapStepAction::StopIn, delta, sqrt_price_limit, true);
+                self.final_price = self.sqrt_price_limit;
+                self.stop_and_refund = true;
             } else {
                 // Stop on edge (refund needed)
-                let delta = Self::delta_in(
-                    order_type,
-                    current_liquidity,
-                    current_price,
-                    sqrt_price_edge,
+                self.action = SwapStepAction::StopOn;
+                self.delta_in = Pallet::<T>::delta_in(
+                    self.order_type,
+                    self.current_liquidity,
+                    self.current_price,
+                    self.sqrt_price_edge,
                 );
-                return (SwapStepAction::StopOn, delta, sqrt_price_edge, true);
+                self.final_price = self.sqrt_price_edge;
+                self.stop_and_refund = true;
             }
         }
         // Case 3: target_quantity = edge_quantity
         else {
-            if target_quantity <= lim_quantity {
+            if self.target_quantity <= self.lim_quantity {
                 // Stop on edge price
-                let delta = Self::delta_in(
-                    order_type,
-                    current_liquidity,
-                    current_price,
-                    sqrt_price_edge,
+                self.delta_in = Pallet::<T>::delta_in(
+                    self.order_type,
+                    self.current_liquidity,
+                    self.current_price,
+                    self.sqrt_price_edge,
                 );
-                let action = if delta > 0 {
+                self.final_price = self.sqrt_price_edge;
+                self.action = if self.delta_in > 0 {
                     SwapStepAction::StopOn
                 } else {
                     SwapStepAction::Crossing
                 };
-                return (action, delta, sqrt_price_edge, false);
+                self.stop_and_refund = false;
             } else {
                 // Stop at limit price (refund needed)
-                let delta = Self::delta_in(
-                    order_type,
-                    current_liquidity,
-                    current_price,
-                    sqrt_price_limit,
+                self.action = SwapStepAction::StopIn;
+                self.delta_in = Pallet::<T>::delta_in(
+                    self.order_type,
+                    self.current_liquidity,
+                    self.current_price,
+                    self.sqrt_price_limit,
                 );
-                return (SwapStepAction::StopIn, delta, sqrt_price_limit, true);
+                self.final_price = self.sqrt_price_limit;
+                self.stop_and_refund = true;
             }
         }
     }
 
     /// Process a single step of a swap
-    fn swap_step(
-        netuid: NetUid,
-        order_type: OrderType,
-        delta_in: u64,
-        sqrt_price_final: SqrtPrice,
-        action: SwapStepAction,
-    ) -> Result<SwapStepResult, Error<T>> {
+    fn process_swap(&self) -> Result<SwapStepResult, Error<T>> {
         // amount_swapped = delta_in / (1 - self.fee_size)
-        let fee_rate = U64F64::saturating_from_num(FeeRate::<T>::get(netuid));
+        let fee_rate = U64F64::saturating_from_num(FeeRate::<T>::get(self.netuid));
         let u16_max = U64F64::saturating_from_num(u16::MAX);
-        let delta_fixed = U64F64::saturating_from_num(delta_in);
+        let delta_fixed = U64F64::saturating_from_num(self.delta_in);
         let amount_swapped =
             delta_fixed.saturating_mul(u16_max.safe_div(u16_max.saturating_sub(fee_rate)));
 
         // Hold the fees
-        let fee = Self::calculate_fee_amount(netuid, amount_swapped.saturating_to_num::<u64>());
-        Self::add_fees(netuid, order_type, fee);
-        let delta_out = Self::convert_deltas(netuid, order_type, delta_in);
+        let fee = Pallet::<T>::calculate_fee_amount(
+            self.netuid,
+            amount_swapped.saturating_to_num::<u64>(),
+        );
+        Pallet::<T>::add_fees(self.netuid, self.order_type, fee);
+        let delta_out = Pallet::<T>::convert_deltas(self.netuid, self.order_type, self.delta_in);
 
         // TODO (look inside method)
         // Self::update_reserves(netuid, order_type, delta_in, delta_out);
 
         // Get current tick
-        let current_tick_index = TickIndex::current_bounded::<T>(netuid);
+        let current_tick_index = TickIndex::current_bounded::<T>(self.netuid);
 
-        match action {
+        match self.action {
             SwapStepAction::Crossing => {
-                let mut tick = match order_type {
+                let mut tick = match self.order_type {
                     OrderType::Sell => {
-                        Self::find_closest_lower_active_tick(netuid, current_tick_index)
-                    }
-                    OrderType::Buy => {
-                        Self::find_closest_higher_active_tick(netuid, current_tick_index)
+                        Pallet::<T>::find_closest_lower_active_tick(self.netuid, current_tick_index)
                     }
+                    OrderType::Buy => Pallet::<T>::find_closest_higher_active_tick(
+                        self.netuid,
+                        current_tick_index,
+                    ),
                 }
                 .ok_or(Error::<T>::InsufficientLiquidity)?;
 
                 tick.fees_out_tao =
-                    FeeGlobalTao::<T>::get(netuid).saturating_sub(tick.fees_out_tao);
+                    FeeGlobalTao::<T>::get(self.netuid).saturating_sub(tick.fees_out_tao);
                 tick.fees_out_alpha =
-                    FeeGlobalAlpha::<T>::get(netuid).saturating_sub(tick.fees_out_alpha);
-                Self::update_liquidity_at_crossing(netuid, order_type)?;
-                Ticks::<T>::insert(netuid, current_tick_index, tick);
+                    FeeGlobalAlpha::<T>::get(self.netuid).saturating_sub(tick.fees_out_alpha);
+                Pallet::<T>::update_liquidity_at_crossing(self.netuid, self.order_type)?;
+                Ticks::<T>::insert(self.netuid, current_tick_index, tick);
             }
 
-            SwapStepAction::StopOn => match order_type {
+            SwapStepAction::StopOn => match self.order_type {
                 OrderType::Buy => {
-                    Self::update_liquidity_at_crossing(netuid, order_type)?;
-                    let Some(mut tick) =
-                        Self::find_closest_higher_active_tick(netuid, current_tick_index)
-                    else {
+                    Pallet::<T>::update_liquidity_at_crossing(self.netuid, self.order_type)?;
+                    let Some(mut tick) = Pallet::<T>::find_closest_higher_active_tick(
+                        self.netuid,
+                        current_tick_index,
+                    ) else {
                         return Err(Error::<T>::InsufficientLiquidity);
                     };
 
                     tick.fees_out_tao =
-                        FeeGlobalTao::<T>::get(netuid).saturating_sub(tick.fees_out_tao);
+                        FeeGlobalTao::<T>::get(self.netuid).saturating_sub(tick.fees_out_tao);
                     tick.fees_out_alpha =
-                        FeeGlobalAlpha::<T>::get(netuid).saturating_sub(tick.fees_out_alpha);
-                    Ticks::<T>::insert(netuid, current_tick_index, tick);
+                        FeeGlobalAlpha::<T>::get(self.netuid).saturating_sub(tick.fees_out_alpha);
+                    Ticks::<T>::insert(self.netuid, current_tick_index, tick);
                 }
                 OrderType::Sell => {}
             },
@@ -321,13 +264,103 @@ impl<T: Config> Pallet<T> {
         }
 
         // Update current price, which effectively updates current tick too
-        AlphaSqrtPrice::<T>::set(netuid, sqrt_price_final);
+        AlphaSqrtPrice::<T>::set(self.netuid, self.final_price);
 
         Ok(SwapStepResult {
             amount_to_take: amount_swapped.saturating_to_num::<u64>(),
             delta_out,
         })
     }
+}
+
+impl<T: Config> Pallet<T> {
+    // initializes V3 swap for a subnet if needed
+    fn maybe_initialize_v3(netuid: NetUid) -> Result<(), Error<T>> {
+        if SwapV3Initialized::<T>::get(netuid) {
+            return Ok(());
+        }
+
+        // Initialize the v3:
+        // Reserves are re-purposed, nothing to set, just query values for liquidity and price calculation
+        let tao_reserve = <T as Config>::LiquidityDataProvider::tao_reserve(netuid.into());
+        let alpha_reserve = <T as Config>::LiquidityDataProvider::alpha_reserve(netuid.into());
+
+        // Set price
+        let price = U64F64::saturating_from_num(tao_reserve)
+            .safe_div(U64F64::saturating_from_num(alpha_reserve));
+
+        let epsilon = U64F64::saturating_from_num(0.000001);
+
+        AlphaSqrtPrice::<T>::set(
+            netuid,
+            price.checked_sqrt(epsilon).unwrap_or(U64F64::from_num(0)),
+        );
+
+        // Set initial (protocol owned) liquidity and positions
+        // Protocol liquidity makes one position from TickIndex::MIN to TickIndex::MAX
+        // We are using the sp_arithmetic sqrt here, which works for u128
+        let liquidity =
+            helpers_128bit::sqrt((tao_reserve as u128).saturating_mul(alpha_reserve as u128))
+                as u64;
+        let protocol_account_id = Self::protocol_account_id();
+
+        let (position, _, _) = Self::add_liquidity_not_insert(
+            netuid,
+            &protocol_account_id,
+            TickIndex::MIN,
+            TickIndex::MAX,
+            liquidity,
+        )?;
+
+        Positions::<T>::insert(&(netuid, protocol_account_id, position.id), position);
+
+        Ok(())
+    }
+
+    /// Perform a swap
+    ///
+    /// Returns a tuple (amount_paid_out, refund), where amount_paid_out is the resulting paid out amount
+    /// and refund is any unswapped amount returned to the caller
+    pub fn swap(
+        netuid: NetUid,
+        order_type: OrderType,
+        amount: u64,
+        sqrt_price_limit: SqrtPrice,
+    ) -> Result<SwapResult, Error<T>> {
+        Self::maybe_initialize_v3(netuid)?;
+
+        let mut amount_remaining = amount;
+        let mut amount_paid_out: u64 = 0;
+        let mut refund: u64 = 0;
+        let mut iteration_counter: u16 = 0;
+
+        // Swap one tick at a time until we reach one of the stop conditions
+        while amount_remaining > 0 {
+            // Create and execute a swap step
+            let mut swap_step =
+                SwapStep::<T>::new(netuid, order_type, amount_remaining, sqrt_price_limit);
+
+            let swap_result = swap_step.execute()?;
+
+            amount_remaining = amount_remaining.saturating_sub(swap_result.amount_to_take);
+            amount_paid_out = amount_paid_out.saturating_add(swap_result.delta_out);
+
+            if swap_step.stop_and_refund {
+                refund = amount_remaining;
+                amount_remaining = 0;
+            }
+
+            iteration_counter = iteration_counter.saturating_add(1);
+            if iteration_counter > MAX_SWAP_ITERATIONS {
+                return Err(Error::<T>::TooManySwapSteps);
+            }
+        }
+
+        Ok(SwapResult {
+            amount_paid_out,
+            refund,
+        })
+    }
 
     /// Get the square root price at the current tick edge for the given direction (order type) If
     /// order type is Buy, then price edge is the high tick bound price, otherwise it is the low
@@ -842,6 +875,7 @@ struct SwapStepResult {
     delta_out: u64,
 }
 
+#[derive(Clone, Copy, Debug, PartialEq)]
 pub enum SwapStepAction {
     Crossing,
     StopOn,

From d115291784693b17fb36acec5323500f16f4b2b2 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Wed, 2 Apr 2025 18:08:37 +0200
Subject: [PATCH 050/418] Setup default fee rate

---
 pallets/swap/src/pallet/impls.rs |  2 +-
 pallets/swap/src/pallet/mod.rs   | 10 +++++++---
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 7df902f4ff..72d4b6be88 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -1345,7 +1345,7 @@ mod tests {
 
                         // Expected fee amount
                         let fee_rate = FeeRate::<Test>::get(netuid) as f64 / u16::MAX as f64;
-                        let expected_fee = output_amount * fee_rate as u64;
+                        let expected_fee = (output_amount as f64 * fee_rate) as u64;
 
                         // Global fees should be updated
                         let actual_global_fee = match order_type {
diff --git a/pallets/swap/src/pallet/mod.rs b/pallets/swap/src/pallet/mod.rs
index 2a6b3e2ebf..d4cbcbefc6 100644
--- a/pallets/swap/src/pallet/mod.rs
+++ b/pallets/swap/src/pallet/mod.rs
@@ -59,11 +59,15 @@ mod pallet {
         type MaxSqrtPrice: Get<SqrtPrice>;
     }
 
+    /// Default fee rate if not set
+    #[pallet::type_value]
+    pub fn DefaultFeeRate() -> u16 {
+        196 // 0.3 %
+    }
+
     /// The fee rate applied to swaps per subnet, normalized value between 0 and u16::MAX
-    ///
-    /// For example, 0.3% is approximately 196
     #[pallet::storage]
-    pub type FeeRate<T> = StorageMap<_, Twox64Concat, NetUid, u16, ValueQuery>;
+    pub type FeeRate<T> = StorageMap<_, Twox64Concat, NetUid, u16, ValueQuery, DefaultFeeRate>;
 
     // Global accrued fees in tao per subnet
     #[pallet::storage]

From ddad9435ccc815e970a6acbb463a283e93d1f7b2 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Thu, 3 Apr 2025 09:25:29 -0400
Subject: [PATCH 051/418] Fix swap_step for basic buy and sell

---
 pallets/swap/src/pallet/impls.rs | 287 ++++++++++++++++++-------------
 1 file changed, 167 insertions(+), 120 deletions(-)

diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 72d4b6be88..fb05293e2b 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -54,7 +54,7 @@ impl<T: Config> SwapStep<T> {
         let one = U64F64::from_num(1);
         let current_price = AlphaSqrtPrice::<T>::get(netuid);
         let current_liquidity = Pallet::<T>::current_liquidity_safe(netuid);
-        let sqrt_price_edge = Pallet::<T>::sqrt_price_edge(current_price, order_type);
+        let sqrt_price_edge = Pallet::<T>::sqrt_price_edge(netuid, current_price, order_type);
 
         let possible_delta_in = amount_remaining
             .saturating_sub(Pallet::<T>::calculate_fee_amount(netuid, amount_remaining));
@@ -74,10 +74,22 @@ impl<T: Config> SwapStep<T> {
         );
 
         // Quantities for comparison
-        let edge_quantity = one.safe_div(sqrt_price_edge.into());
-        let lim_quantity = one
-            .safe_div(T::MinSqrtPrice::get())
-            .saturating_add(one.safe_div(sqrt_price_limit.into()));
+        let edge_quantity = match order_type {
+            OrderType::Buy => sqrt_price_edge.into(),
+            OrderType::Sell => one.safe_div(sqrt_price_edge.into()),
+        };
+        let mut lim_quantity = match order_type {
+            OrderType::Buy => one
+                .safe_div(T::MinSqrtPrice::get())
+                .min(one.safe_div(sqrt_price_limit.into())),
+            OrderType::Sell => T::MaxSqrtPrice::get().min(sqrt_price_limit.into()),
+        };
+        if lim_quantity < one.safe_div(current_price) {
+            lim_quantity = match order_type {
+                OrderType::Buy => one.safe_div(T::MinSqrtPrice::get()),
+                OrderType::Sell => T::MaxSqrtPrice::get(),
+            };
+        }
 
         Self {
             netuid,
@@ -368,24 +380,45 @@ impl<T: Config> Pallet<T> {
     ///
     /// If anything is wrong with tick math and it returns Err, we just abort the deal, i.e. return
     /// the edge that is impossible to execute
-    fn sqrt_price_edge(current_price: U64F64, order_type: OrderType) -> SqrtPrice {
-        let fallback_price_edge_value = (match order_type {
-            OrderType::Buy => TickIndex::MIN.try_to_sqrt_price(),
-            OrderType::Sell => TickIndex::MAX.try_to_sqrt_price(),
-        })
-        .unwrap_or(SqrtPrice::from_num(0));
+    fn sqrt_price_edge(netuid: NetUid, current_price: U64F64, order_type: OrderType) -> SqrtPrice {
+        // Current price falls into a tick that may or may not be active. This tick represents
+        // the set of prices [tick_min_price, tick_max_price) (excluding the tick_max_price point).
+        //
+        // If this tick is active:
+        //    the lower edge (for sell order) is the tick_min_price,
+        //    the higher edge (for buy order) is the tick_max_price
+        //
+        // If this tick is not active:
+        //    the lower edge (for sell order) is the lower active tick low price
+        //    the higher edge (for buy order) is the higher active tick low price
+        //
+
+        let fallback_tick = match order_type {
+            OrderType::Buy => TickIndex::MIN,
+            OrderType::Sell => TickIndex::MAX,
+        };
 
-        TickIndex::try_from_sqrt_price(current_price)
-            .and_then(|current_tick_index| {
-                match order_type {
-                    OrderType::Buy => {
-                        TickIndex::new_unchecked(current_tick_index.get().saturating_add(1))
-                    }
-                    OrderType::Sell => current_tick_index,
+        let current_price_tick =
+            TickIndex::try_from_sqrt_price(current_price).unwrap_or(fallback_tick);
+
+        (match order_type {
+            OrderType::Buy => {
+                let higher_tick =
+                    Pallet::<T>::find_closest_higher_active_tick_index(netuid, current_price_tick)
+                        .unwrap_or(TickIndex::MAX);
+                if higher_tick < TickIndex::MAX {
+                    higher_tick.saturating_add(1)
+                } else {
+                    higher_tick
                 }
-                .try_to_sqrt_price()
-            })
-            .unwrap_or(fallback_price_edge_value)
+            }
+            OrderType::Sell => {
+                Pallet::<T>::find_closest_lower_active_tick_index(netuid, current_price_tick)
+                    .unwrap_or(TickIndex::MIN)
+            }
+        })
+        .try_to_sqrt_price()
+        .unwrap_or(SqrtPrice::from_num(0))
     }
 
     /// Calculate fee amount
@@ -576,6 +609,20 @@ impl<T: Config> Pallet<T> {
             .and_then(|ti| Ticks::<T>::get(netuid, ti))
     }
 
+    pub fn find_closest_lower_active_tick_index(
+        netuid: NetUid,
+        index: TickIndex,
+    ) -> Option<TickIndex> {
+        ActiveTickIndexManager::find_closest_lower::<T>(netuid, index)
+    }
+
+    pub fn find_closest_higher_active_tick_index(
+        netuid: NetUid,
+        index: TickIndex,
+    ) -> Option<TickIndex> {
+        ActiveTickIndexManager::find_closest_higher::<T>(netuid, index)
+    }
+
     /// Here we subtract minimum safe liquidity from current liquidity to stay in the safe range
     fn current_liquidity_safe(netuid: NetUid) -> U64F64 {
         U64F64::saturating_from_num(
@@ -1293,110 +1340,110 @@ mod tests {
         });
     }
 
+    // cargo test --package pallet-subtensor-swap --lib -- pallet::impls::tests::test_swap_basic --exact --show-output
     #[test]
     fn test_swap_basic() {
         new_test_ext().execute_with(|| {
             // Current price is 0.25
             // Test case is (order_type, liquidity, limit_price, output_amount)
-            [(OrderType::Buy, 500_000_000u64, 1000.0_f64, 3990_u64)]
-                .into_iter()
-                .enumerate()
-                .map(|(n, v)| (NetUid::from(n as u16), v.0, v.1, v.2, v.3))
-                .for_each(
-                    |(netuid, order_type, liquidity, limit_price, output_amount)| {
-                        // Consumed liquidity ticks
-                        let tick_low = TickIndex::MIN;
-                        let tick_high = TickIndex::MAX;
-
-                        // Setup swap
-                        assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
-
-                        // Get tick infos before the swap
-                        let tick_low_info_before =
-                            Ticks::<Test>::get(netuid, tick_low).unwrap_or_default();
-                        let tick_high_info_before =
-                            Ticks::<Test>::get(netuid, tick_high).unwrap_or_default();
-                        let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
-
-                        // Swap
-                        let sqrt_limit_price = SqrtPrice::from_num((limit_price).sqrt());
-                        let swap_result =
-                            Pallet::<Test>::swap(netuid, order_type, liquidity, sqrt_limit_price);
-                        // assert_abs_diff_eq!(
-                        //     swap_result.unwrap().amount_paid_out,
-                        //     *output_amount,
-                        //     epsilon = *output_amount/1000
-                        // );
-
-                        // Check that low and high ticks' fees were updated properly, and liquidity values were not updated
-                        let tick_low_info = Ticks::<Test>::get(netuid, tick_low).unwrap();
-                        let tick_high_info = Ticks::<Test>::get(netuid, tick_high).unwrap();
-                        let expected_liquidity_net_low = tick_low_info_before.liquidity_net;
-                        let expected_liquidity_gross_low = tick_low_info_before.liquidity_gross;
-                        let expected_liquidity_net_high = tick_high_info_before.liquidity_net;
-                        let expected_liquidity_gross_high = tick_high_info_before.liquidity_gross;
-                        assert_eq!(tick_low_info.liquidity_net, expected_liquidity_net_low,);
-                        assert_eq!(tick_low_info.liquidity_gross, expected_liquidity_gross_low,);
-                        assert_eq!(tick_high_info.liquidity_net, expected_liquidity_net_high,);
-                        assert_eq!(
-                            tick_high_info.liquidity_gross,
-                            expected_liquidity_gross_high,
-                        );
-
-                        // Expected fee amount
-                        let fee_rate = FeeRate::<Test>::get(netuid) as f64 / u16::MAX as f64;
-                        let expected_fee = (output_amount as f64 * fee_rate) as u64;
-
-                        // Global fees should be updated
-                        let actual_global_fee = match order_type {
-                            OrderType::Buy => FeeGlobalAlpha::<Test>::get(netuid),
-                            OrderType::Sell => FeeGlobalTao::<Test>::get(netuid),
-                        };
-                        println!("actual_global_fee {:?}", actual_global_fee);
-                        assert_eq!(actual_global_fee, expected_fee);
-
-                        // Tick fees should be updated
-
-                        // Liquidity position should not be updated
-                        let protocol_id = Pallet::<Test>::protocol_account_id();
-                        let positions =
-                            Positions::<Test>::iter_prefix_values((netuid, protocol_id))
-                                .collect::<Vec<_>>();
-                        let position = positions.first().unwrap();
-
-                        assert_eq!(
-                            position.liquidity,
-                            helpers_128bit::sqrt(
-                                MockLiquidityProvider::tao_reserve(netuid.into()) as u128
-                                    * MockLiquidityProvider::alpha_reserve(netuid.into()) as u128
-                            ) as u64
-                        );
-                        assert_eq!(position.tick_low, tick_low);
-                        assert_eq!(position.tick_high, tick_high);
-                        assert_eq!(position.fees_alpha, 0);
-                        assert_eq!(position.fees_tao, 0);
-
-                        // // Current liquidity is updated only when price range includes the current price
-                        // if (*price_high >= current_price) && (*price_low <= current_price) {
-                        //     assert_eq!(
-                        //         swap.state_ops.get_current_liquidity(),
-                        //         liquidity_before + *liquidity
-                        //     );
-                        // } else {
-                        //     assert_eq!(swap.state_ops.get_current_liquidity(), liquidity_before);
-                        // }
-
-                        // // Reserves are updated
-                        // assert_eq!(
-                        //     swap.state_ops.get_tao_reserve(),
-                        //     tao_withdrawn + protocol_tao,
-                        // );
-                        // assert_eq!(
-                        //     swap.state_ops.get_alpha_reserve(),
-                        //     alpha_withdrawn + protocol_alpha,
-                        // );
-                    },
-                );
+            [
+                (OrderType::Buy, 1_000u64, 1000.0_f64, 3990_u64),
+                (OrderType::Sell, 1_000u64, 0.0001_f64, 250_u64),
+                (OrderType::Buy, 500_000_000, 1000.0, 1_330_000_000),
+            ]
+            .into_iter()
+            .enumerate()
+            .map(|(n, v)| (NetUid::from(n as u16), v.0, v.1, v.2, v.3))
+            .for_each(
+                |(netuid, order_type, liquidity, limit_price, output_amount)| {
+                    // Consumed liquidity ticks
+                    let tick_low = TickIndex::MIN;
+                    let tick_high = TickIndex::MAX;
+
+                    // Setup swap
+                    assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
+
+                    // Get tick infos before the swap
+                    let tick_low_info_before =
+                        Ticks::<Test>::get(netuid, tick_low).unwrap_or_default();
+                    let tick_high_info_before =
+                        Ticks::<Test>::get(netuid, tick_high).unwrap_or_default();
+                    let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
+
+                    // Swap
+                    let sqrt_limit_price = SqrtPrice::from_num((limit_price).sqrt());
+                    let swap_result =
+                        Pallet::<Test>::swap(netuid, order_type, liquidity, sqrt_limit_price);
+                    assert_abs_diff_eq!(
+                        swap_result.unwrap().amount_paid_out,
+                        output_amount,
+                        epsilon = output_amount / 100
+                    );
+
+                    // Check that low and high ticks' fees were updated properly, and liquidity values were not updated
+                    let tick_low_info = Ticks::<Test>::get(netuid, tick_low).unwrap();
+                    let tick_high_info = Ticks::<Test>::get(netuid, tick_high).unwrap();
+                    let expected_liquidity_net_low = tick_low_info_before.liquidity_net;
+                    let expected_liquidity_gross_low = tick_low_info_before.liquidity_gross;
+                    let expected_liquidity_net_high = tick_high_info_before.liquidity_net;
+                    let expected_liquidity_gross_high = tick_high_info_before.liquidity_gross;
+                    assert_eq!(tick_low_info.liquidity_net, expected_liquidity_net_low,);
+                    assert_eq!(tick_low_info.liquidity_gross, expected_liquidity_gross_low,);
+                    assert_eq!(tick_high_info.liquidity_net, expected_liquidity_net_high,);
+                    assert_eq!(
+                        tick_high_info.liquidity_gross,
+                        expected_liquidity_gross_high,
+                    );
+
+                    // Expected fee amount
+                    let fee_rate = FeeRate::<Test>::get(netuid) as f64 / u16::MAX as f64;
+                    let expected_fee = (liquidity as f64 * fee_rate) as u64;
+
+                    // Global fees should be updated
+                    let actual_global_fee = ((match order_type {
+                        OrderType::Buy => FeeGlobalAlpha::<Test>::get(netuid),
+                        OrderType::Sell => FeeGlobalTao::<Test>::get(netuid),
+                    })
+                    .to_num::<f64>()
+                        * (liquidity_before as f64))
+                        as u64;
+                    assert_eq!(actual_global_fee, expected_fee);
+
+                    // Tick fees should be updated
+
+                    // Liquidity position should not be updated
+                    let protocol_id = Pallet::<Test>::protocol_account_id();
+                    let positions = Positions::<Test>::iter_prefix_values((netuid, protocol_id))
+                        .collect::<Vec<_>>();
+                    let position = positions.first().unwrap();
+
+                    assert_eq!(
+                        position.liquidity,
+                        helpers_128bit::sqrt(
+                            MockLiquidityProvider::tao_reserve(netuid.into()) as u128
+                                * MockLiquidityProvider::alpha_reserve(netuid.into()) as u128
+                        ) as u64
+                    );
+                    assert_eq!(position.tick_low, tick_low);
+                    assert_eq!(position.tick_high, tick_high);
+                    assert_eq!(position.fees_alpha, 0);
+                    assert_eq!(position.fees_tao, 0);
+
+                    // Current liquidity is not updated
+                    assert_eq!(CurrentLiquidity::<Test>::get(netuid), liquidity_before);
+
+                    // Reserves are updated
+                    // TODO: Add the test
+                    // assert_eq!(
+                    //     swap.state_ops.get_tao_reserve(),
+                    //     tao_withdrawn + protocol_tao,
+                    // );
+                    // assert_eq!(
+                    //     swap.state_ops.get_alpha_reserve(),
+                    //     alpha_withdrawn + protocol_alpha,
+                    // );
+                },
+            );
         });
     }
 }

From a4e66e28feb1b3fbbad1926f9b74f894fa0746f7 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Thu, 3 Apr 2025 18:16:40 -0400
Subject: [PATCH 052/418] Test swap within a single provided position

---
 pallets/swap/src/pallet/impls.rs | 257 ++++++++++++++++++++++++++++++-
 1 file changed, 251 insertions(+), 6 deletions(-)

diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index fb05293e2b..b9dad6b564 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -471,6 +471,8 @@ impl<T: Config> Pallet<T> {
             return 0;
         }
 
+        println!("delta_in = {:?}", delta_in);
+
         let liquidity_curr = SqrtPrice::saturating_from_num(CurrentLiquidity::<T>::get(netuid));
         let sqrt_price_curr = AlphaSqrtPrice::<T>::get(netuid);
         let delta_fixed = SqrtPrice::saturating_from_num(delta_in);
@@ -479,12 +481,21 @@ impl<T: Config> Pallet<T> {
         // Using safe math operations throughout to prevent overflows
         let result = match order_type {
             OrderType::Sell => {
-                liquidity_curr * sqrt_price_curr * delta_fixed
-                    / (liquidity_curr / sqrt_price_curr + delta_fixed)
+                // TODO: This needs to be reimplemented in full precision non-overflowing math:
+                let a = liquidity_curr / (liquidity_curr / sqrt_price_curr + delta_fixed);
+                let b = a * sqrt_price_curr;
+                let c = delta_fixed * b;
+                println!("sell c = {:?}", c);
+                c
             }
             OrderType::Buy => {
-                liquidity_curr / sqrt_price_curr * delta_fixed
-                    / (liquidity_curr * sqrt_price_curr + delta_fixed)
+                let a = (liquidity_curr * sqrt_price_curr + delta_fixed) * sqrt_price_curr;
+                println!("a = {:?}", a);
+                let b = liquidity_curr / a;
+                println!("b = {:?}", b);
+                let c = b * delta_fixed;
+                println!("buy c = {:?}", c);
+                c
             }
         };
 
@@ -507,12 +518,12 @@ impl<T: Config> Pallet<T> {
         }
 
         match order_type {
-            OrderType::Buy => one.safe_div(
+            OrderType::Sell => one.safe_div(
                 delta_fixed
                     .safe_div(liquidity_curr)
                     .saturating_add(one.safe_div(sqrt_price_curr)),
             ),
-            OrderType::Sell => delta_fixed
+            OrderType::Buy => delta_fixed
                 .safe_div(liquidity_curr)
                 .saturating_add(sqrt_price_curr),
         }
@@ -1370,6 +1381,10 @@ mod tests {
                         Ticks::<Test>::get(netuid, tick_high).unwrap_or_default();
                     let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
 
+                    // Get current price
+                    let sqrt_current_price = AlphaSqrtPrice::<Test>::get(netuid);
+                    let current_price = (sqrt_current_price * sqrt_current_price).to_num::<f64>();
+
                     // Swap
                     let sqrt_limit_price = SqrtPrice::from_num((limit_price).sqrt());
                     let swap_result =
@@ -1432,6 +1447,15 @@ mod tests {
                     // Current liquidity is not updated
                     assert_eq!(CurrentLiquidity::<Test>::get(netuid), liquidity_before);
 
+                    // Assert that price movement is in correct direction
+                    let sqrt_current_price_after = AlphaSqrtPrice::<Test>::get(netuid);
+                    let current_price_after =
+                        (sqrt_current_price_after * sqrt_current_price_after).to_num::<f64>();
+                    match order_type {
+                        OrderType::Buy => assert!(current_price_after > current_price),
+                        OrderType::Sell => assert!(current_price_after < current_price),
+                    }
+
                     // Reserves are updated
                     // TODO: Add the test
                     // assert_eq!(
@@ -1446,4 +1470,225 @@ mod tests {
             );
         });
     }
+
+    // In this test the swap starts and ends within one (large liquidity) position
+    // SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor-swap --lib -- pallet::impls::tests::test_swap_single_position_step_in --exact --show-output --nocapture
+    #[test]
+    fn test_swap_single_position_step_in() {
+        let min_price = tick_to_price(TickIndex::MIN);
+        let max_price = tick_to_price(TickIndex::MAX);
+        let max_tick = price_to_tick(max_price);
+        let current_price = 0.25;
+        let netuid = NetUid(1);
+        assert_eq!(max_tick, TickIndex::MAX);
+
+        // Current price is 0.25
+        // The test case is based on the current price and position prices are defined as a price
+        // offset from the current price
+        // Outer part of test case is Position: (price_low_offset, price_high_offset, liquidity)
+        [
+            // Very localized position at the current price
+            (0.0, 0.0, 2_000_000_000_u64),
+            // Repeat the protocol liquidity at maximum range
+            (
+                min_price - current_price,
+                max_price - current_price,
+                2_000_000_000_u64,
+            ),
+            // Repeat the protocol liquidity at current to max range
+            (0.0, max_price - current_price, 2_000_000_000_u64),
+            // Repeat the protocol liquidity at min to current range
+            (min_price - current_price, 0.0, 2_000_000_000_u64),
+            // Half to double price
+            (-0.125, 0.25, 2_000_000_000_u64),
+            // A few other price ranges and liquidity volumes
+            (-0.1, 0.1, 2_000_000_000_u64),
+            (-0.1, 0.1, 10_000_000_000_u64),
+            (-0.1, 0.1, 100_000_000_000_u64),
+            (-0.01, 0.01, 100_000_000_000_u64),
+            (-0.001, 0.001, 100_000_000_000_u64),
+        ]
+        .iter()
+        .for_each(
+            |(price_low_offset, price_high_offset, position_liquidity)| {
+                // Inner part of test case is Order: (order_type, order_liquidity, limit_price, output_amount)
+                // order_liquidity is represented as a fraction of position_liquidity
+                [
+                    (OrderType::Buy, 0.001, 1000.0_f64),
+                    (OrderType::Sell, 0.001, 0.0001_f64),
+                    (OrderType::Buy, 0.01, 1000.0_f64),
+                    (OrderType::Sell, 0.01, 0.0001_f64),
+                    (OrderType::Buy, 0.1, 1000.0),
+                    (OrderType::Sell, 0.1, 0.0001),
+                    (OrderType::Buy, 0.2, 1000.0),
+                    (OrderType::Sell, 0.2, 0.0001),
+                    (OrderType::Buy, 0.5, 1000.0),
+                    (OrderType::Sell, 0.5, 0.0001),
+                    (OrderType::Buy, 0.9999, 1000.0),
+                    (OrderType::Sell, 0.9999, 0.0001),
+                    (OrderType::Buy, 1.0, 1000.0),
+                    (OrderType::Sell, 1.0, 0.0001),
+                ]
+                .iter()
+                .for_each(|(order_type, order_liquidity_fraction, limit_price)| {
+                    new_test_ext().execute_with(|| {
+                        //////////////////////////////////////////////
+                        // Initialize pool and add the user position
+                        assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
+                        let tao_reserve = MockLiquidityProvider::tao_reserve(netuid.into());
+                        let alpha_reserve = MockLiquidityProvider::alpha_reserve(netuid.into());
+                        let protocol_liquidity = (tao_reserve as f64 * alpha_reserve as f64).sqrt();
+
+                        // Add liquidity
+                        let sqrt_current_price = AlphaSqrtPrice::<Test>::get(netuid);
+                        let current_price =
+                            (sqrt_current_price * sqrt_current_price).to_num::<f64>();
+
+                        let price_low = *price_low_offset + current_price;
+                        let price_high = *price_high_offset + current_price;
+                        let tick_low = price_to_tick(price_low);
+                        let tick_high = price_to_tick(price_high);
+                        let (_position_id, _tao, _alpha) = Pallet::<Test>::add_liquidity(
+                            netuid,
+                            &OK_ACCOUNT_ID,
+                            tick_low,
+                            tick_high,
+                            *position_liquidity,
+                        )
+                        .unwrap();
+
+                        // Liquidity position at correct ticks
+                        assert_eq!(Pallet::<Test>::count_positions(netuid, &OK_ACCOUNT_ID), 1);
+
+                        // Get tick infos before the swap
+                        let tick_low_info_before =
+                            Ticks::<Test>::get(netuid, tick_low).unwrap_or_default();
+                        let tick_high_info_before =
+                            Ticks::<Test>::get(netuid, tick_high).unwrap_or_default();
+                        let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
+                        assert_abs_diff_eq!(
+                            liquidity_before as f64,
+                            protocol_liquidity + *position_liquidity as f64,
+                            epsilon = liquidity_before as f64 / 10000.
+                        );
+
+                        //////////////////////////////////////////////
+                        // Swap
+
+                        // Calculate the expected output amount for the cornercase of one step
+                        let order_liquidity =
+                            *order_liquidity_fraction * *position_liquidity as f64;
+                        println!("Swap liquidity amount: {:?}", order_liquidity);
+                        let fee_rate = FeeRate::<Test>::get(netuid) as f64 / u16::MAX as f64;
+                        let expected_fee = order_liquidity as f64 * fee_rate;
+                        let output_amount = match order_type {
+                            OrderType::Buy => {
+                                let denom = sqrt_current_price.to_num::<f64>()
+                                    * (sqrt_current_price.to_num::<f64>()
+                                        * liquidity_before as f64
+                                        + order_liquidity);
+                                let per_order_liq = liquidity_before as f64 / denom;
+                                per_order_liq * order_liquidity
+                            }
+                            OrderType::Sell => {
+                                let denom = liquidity_before as f64
+                                    / sqrt_current_price.to_num::<f64>()
+                                    + order_liquidity;
+                                let per_order_liq = sqrt_current_price.to_num::<f64>()
+                                    * liquidity_before as f64
+                                    / denom;
+                                per_order_liq * order_liquidity
+                            }
+                        };
+
+                        // Do the swap
+                        let sqrt_limit_price = SqrtPrice::from_num((limit_price).sqrt());
+                        let swap_result = Pallet::<Test>::swap(
+                            netuid,
+                            *order_type,
+                            order_liquidity as u64,
+                            sqrt_limit_price,
+                        );
+                        assert_abs_diff_eq!(
+                            swap_result.unwrap().amount_paid_out as f64,
+                            output_amount,
+                            epsilon = output_amount / 10.
+                        );
+
+                        // Assert that price movement is in correct direction
+                        let sqrt_current_price_after = AlphaSqrtPrice::<Test>::get(netuid);
+                        let current_price_after =
+                            (sqrt_current_price_after * sqrt_current_price_after).to_num::<f64>();
+                        match order_type {
+                            OrderType::Buy => assert!(current_price_after > current_price),
+                            OrderType::Sell => assert!(current_price_after < current_price),
+                        }
+
+                        println!("current_price_after = {:?}", current_price_after);
+
+                        // Check that low and high ticks' fees were updated properly, and liquidity values were not updated
+                        let tick_low_info = Ticks::<Test>::get(netuid, tick_low).unwrap();
+                        let tick_high_info = Ticks::<Test>::get(netuid, tick_high).unwrap();
+                        let expected_liquidity_net_low = tick_low_info_before.liquidity_net;
+                        let expected_liquidity_gross_low = tick_low_info_before.liquidity_gross;
+                        let expected_liquidity_net_high = tick_high_info_before.liquidity_net;
+                        let expected_liquidity_gross_high = tick_high_info_before.liquidity_gross;
+                        assert_eq!(tick_low_info.liquidity_net, expected_liquidity_net_low,);
+                        assert_eq!(tick_low_info.liquidity_gross, expected_liquidity_gross_low,);
+                        assert_eq!(tick_high_info.liquidity_net, expected_liquidity_net_high,);
+                        assert_eq!(
+                            tick_high_info.liquidity_gross,
+                            expected_liquidity_gross_high,
+                        );
+
+                        // Expected fee amount
+                        let fee_rate = FeeRate::<Test>::get(netuid) as f64 / u16::MAX as f64;
+                        let expected_fee = (order_liquidity as f64 * fee_rate) as u64;
+
+                        // Global fees should be updated
+                        let actual_global_fee = ((match order_type {
+                            OrderType::Buy => FeeGlobalAlpha::<Test>::get(netuid),
+                            OrderType::Sell => FeeGlobalTao::<Test>::get(netuid),
+                        })
+                        .to_num::<f64>()
+                            * (liquidity_before as f64))
+                            as u64;
+                        assert_abs_diff_eq!(
+                            actual_global_fee,
+                            expected_fee,
+                            epsilon = expected_fee / 1_000_000
+                        );
+
+                        // Tick fees should be updated
+
+                        // Liquidity position should not be updated
+                        let positions =
+                            Positions::<Test>::iter_prefix_values((netuid, OK_ACCOUNT_ID))
+                                .collect::<Vec<_>>();
+                        let position = positions.first().unwrap();
+
+                        assert_eq!(position.liquidity, *position_liquidity,);
+                        assert_eq!(position.tick_low, tick_low);
+                        assert_eq!(position.tick_high, tick_high);
+                        assert_eq!(position.fees_alpha, 0);
+                        assert_eq!(position.fees_tao, 0);
+
+                        // Current liquidity is not updated
+                        assert_eq!(CurrentLiquidity::<Test>::get(netuid), liquidity_before);
+
+                        // Reserves are updated
+                        // TODO: Add the test
+                        // assert_eq!(
+                        //     swap.state_ops.get_tao_reserve(),
+                        //     tao_withdrawn + protocol_tao,
+                        // );
+                        // assert_eq!(
+                        //     swap.state_ops.get_alpha_reserve(),
+                        //     alpha_withdrawn + protocol_alpha,
+                        // );
+                    });
+                });
+            },
+        );
+    }
 }

From b9909a8e71bcca134cf8b6e6171b3292c3336138 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Fri, 4 Apr 2025 16:14:42 +0200
Subject: [PATCH 053/418] Fix benchmarks compilation for swap

---
 Cargo.lock                        |  1 +
 pallets/swap-interface/src/lib.rs |  2 +-
 pallets/swap/Cargo.toml           | 38 +++++++++++++++++++------------
 pallets/swap/scripts/benchmark.sh | 11 +++++++++
 pallets/swap/src/benchmarking.rs  | 23 +++++++++++++++++++
 pallets/swap/src/lib.rs           |  4 ++++
 pallets/swap/src/mock.rs          |  2 +-
 pallets/swap/src/pallet/mod.rs    |  7 ++++--
 pallets/swap/src/weights.rs       | 38 +++++++++++++++++++++++++++++++
 9 files changed, 107 insertions(+), 19 deletions(-)
 create mode 100755 pallets/swap/scripts/benchmark.sh
 create mode 100644 pallets/swap/src/benchmarking.rs
 create mode 100644 pallets/swap/src/weights.rs

diff --git a/Cargo.lock b/Cargo.lock
index d6ba6b07f6..dd6c6fdb30 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6840,6 +6840,7 @@ version = "0.1.0"
 dependencies = [
  "alloy-primitives",
  "approx",
+ "frame-benchmarking",
  "frame-support",
  "frame-system",
  "pallet-subtensor-swap-interface",
diff --git a/pallets/swap-interface/src/lib.rs b/pallets/swap-interface/src/lib.rs
index ff79e7f93f..0857a2dc09 100644
--- a/pallets/swap-interface/src/lib.rs
+++ b/pallets/swap-interface/src/lib.rs
@@ -14,7 +14,7 @@ pub enum OrderType {
 pub trait SwapHandler<AccountId> {
     fn swap(order_t: OrderType, amount: u64) -> Result<(), Box<dyn Error>>;
     fn add_liquidity(account_id: AccountId, liquidity: u64) -> Result<(u64, u64), Box<dyn Error>>;
-    fn remove_liquidity(account_id: AccountId) -> Result<(), Box<dyn Error>>;
+    fn remove_liquidity(account_id: AccountId) -> Result<(u64, u64), Box<dyn Error>>;
 }
 
 pub trait LiquidityDataProvider<AccountId> {
diff --git a/pallets/swap/Cargo.toml b/pallets/swap/Cargo.toml
index 6b711754fd..0dac2a0bd3 100644
--- a/pallets/swap/Cargo.toml
+++ b/pallets/swap/Cargo.toml
@@ -7,6 +7,7 @@ edition = { workspace = true }
 alloy-primitives = { workspace = true }
 approx = { workspace = true }
 codec = { workspace = true }
+frame-benchmarking = { workspace = true, optional = true }
 frame-support = { workspace = true }
 frame-system = { workspace = true }
 safe-math = { workspace = true }
@@ -22,25 +23,32 @@ uuid = { workspace = true, features = ["v4"] }
 
 pallet-subtensor-swap-interface = { workspace = true }
 
+
 [lints]
 workspace = true
 
 [features]
 default = ["std"]
 std = [
-	"alloy-primitives/std",
-	"codec/std",
-	"frame-support/std",
-	"frame-system/std",
-	"pallet-subtensor-swap-interface/std",
-	"safe-math/std",
-	"scale-info/std",
-	"serde/std",
-	"sp-arithmetic/std",
-	"sp-core/std",
-	"sp-io/std",
-	"sp-runtime/std",
-	"sp-std/std",
-	"substrate-fixed/std",
-	"uuid/std",
+    "alloy-primitives/std",
+    "codec/std",
+    "frame-benchmarking/std",
+    "frame-support/std",
+    "frame-system/std",
+    "pallet-subtensor-swap-interface/std",
+    "safe-math/std",
+    "scale-info/std",
+    "serde/std",
+    "sp-arithmetic/std",
+    "sp-core/std",
+    "sp-io/std",
+    "sp-runtime/std",
+    "sp-std/std",
+    "substrate-fixed/std",
+    "uuid/std",
+]
+runtime-benchmarks = [
+    "frame-benchmarking/runtime-benchmarks",
+    "frame-support/runtime-benchmarks",
+    "frame-system/runtime-benchmarks",
 ]
diff --git a/pallets/swap/scripts/benchmark.sh b/pallets/swap/scripts/benchmark.sh
new file mode 100755
index 0000000000..20feb6b270
--- /dev/null
+++ b/pallets/swap/scripts/benchmark.sh
@@ -0,0 +1,11 @@
+#!/bin/bash
+
+cargo build --profile production --features runtime-benchmarks
+./target/production/node-subtensor benchmark pallet \
+  --chain=local \
+  --pallet=pallet_subtensor_swap \
+  --extrinsic="*" \
+  --steps 50 \
+  --repeat 20 \
+  --output=pallets/swap/src/weights.rs \
+  --template=./.maintain/frame-weight-template.hbs
\ No newline at end of file
diff --git a/pallets/swap/src/benchmarking.rs b/pallets/swap/src/benchmarking.rs
new file mode 100644
index 0000000000..1bf1b8a95d
--- /dev/null
+++ b/pallets/swap/src/benchmarking.rs
@@ -0,0 +1,23 @@
+//! Benchmarking setup for pallet-subtensor-swap
+#![cfg(feature = "runtime-benchmarks")]
+#![allow(clippy::arithmetic_side_effects)]
+
+use crate::pallet::{Call, Config, Pallet};
+use frame_benchmarking::v2::*;
+use frame_system::RawOrigin;
+
+#[benchmarks(where T: Config)]
+mod benchmarks {
+	use super::*; // Use imports from outer scope
+
+	#[benchmark]
+	fn set_fee_rate() {
+		let netuid: u16 = 1;
+		let rate: u16 = 100;  // Some arbitrary fee rate value
+
+		#[extrinsic_call]
+		set_fee_rate(RawOrigin::Root, netuid, rate);
+	}
+
+	impl_benchmark_test_suite!(Pallet, crate::mock::new_test_ext(), crate::mock::Test);
+}
diff --git a/pallets/swap/src/lib.rs b/pallets/swap/src/lib.rs
index 2d1ccadb68..3d54b425f2 100644
--- a/pallets/swap/src/lib.rs
+++ b/pallets/swap/src/lib.rs
@@ -8,6 +8,10 @@ use substrate_fixed::types::U64F64;
 pub mod pallet;
 mod position;
 mod tick;
+pub mod weights;
+
+#[cfg(feature = "runtime-benchmarks")]
+pub mod benchmarking;
 
 #[cfg(test)]
 pub(crate) mod mock;
diff --git a/pallets/swap/src/mock.rs b/pallets/swap/src/mock.rs
index 59cae330f5..70cf16dac4 100644
--- a/pallets/swap/src/mock.rs
+++ b/pallets/swap/src/mock.rs
@@ -100,7 +100,6 @@ impl LiquidityDataProvider<AccountId> for MockLiquidityProvider {
     }
 }
 
-// Implementations of traits don't support visibility qualifiers
 impl crate::pallet::Config for Test {
     type RuntimeEvent = RuntimeEvent;
     type AdminOrigin = EnsureRoot<AccountId>;
@@ -111,6 +110,7 @@ impl crate::pallet::Config for Test {
     type MinimumLiquidity = MinimumLiquidity;
     type MinSqrtPrice = MinSqrtPrice;
     type MaxSqrtPrice = MaxSqrtPrice;
+    type WeightInfo = ();
 }
 
 // Build genesis storage according to the mock runtime.
diff --git a/pallets/swap/src/pallet/mod.rs b/pallets/swap/src/pallet/mod.rs
index d4cbcbefc6..4996d836c1 100644
--- a/pallets/swap/src/pallet/mod.rs
+++ b/pallets/swap/src/pallet/mod.rs
@@ -4,7 +4,7 @@ use pallet_subtensor_swap_interface::LiquidityDataProvider;
 use substrate_fixed::types::U64F64;
 
 use crate::{
-    NetUid, SqrtPrice,
+    NetUid, SqrtPrice, weights::WeightInfo,
     position::{Position, PositionId},
     tick::{LayerLevel, Tick, TickIndex},
 };
@@ -57,6 +57,9 @@ mod pallet {
         /// Maximum sqrt price across all active ticks
         #[pallet::constant]
         type MaxSqrtPrice: Get<SqrtPrice>;
+
+        /// Weight information for extrinsics in this pallet.
+        type WeightInfo: WeightInfo;
     }
 
     /// Default fee rate if not set
@@ -165,7 +168,7 @@ mod pallet {
         ///
         /// Only callable by the admin origin
         #[pallet::call_index(0)]
-        #[pallet::weight(10_000)]
+        #[pallet::weight(T::WeightInfo::set_fee_rate())]
         pub fn set_fee_rate(origin: OriginFor<T>, netuid: u16, rate: u16) -> DispatchResult {
             T::AdminOrigin::ensure_origin(origin)?;
 
diff --git a/pallets/swap/src/weights.rs b/pallets/swap/src/weights.rs
new file mode 100644
index 0000000000..19fc4e8722
--- /dev/null
+++ b/pallets/swap/src/weights.rs
@@ -0,0 +1,38 @@
+//! Weights for pallet_subtensor_swap
+//!
+//! This is a default weight implementation with conservative estimates
+//! until actual benchmarks are run.
+
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+
+use frame_support::{
+	traits::Get,
+	weights::{Weight, constants::RocksDbWeight},
+};
+use sp_std::marker::PhantomData;
+
+/// Weight functions needed for pallet_subtensor_swap.
+pub trait WeightInfo {
+	fn set_fee_rate() -> Weight;
+}
+
+/// Default weights for pallet_subtensor_swap.
+pub struct DefaultWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for DefaultWeight<T> {
+	fn set_fee_rate() -> Weight {
+		// Conservative weight estimate: one read and one write
+		Weight::from_parts(10_000_000, 0)
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	fn set_fee_rate() -> Weight {
+		Weight::from_parts(10_000_000, 0)
+			.saturating_add(RocksDbWeight::get().reads(1))
+			.saturating_add(RocksDbWeight::get().writes(1))
+	}
+}
\ No newline at end of file

From f7d63afa5a111aa7420f8af59483b6071ca37a3a Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Fri, 4 Apr 2025 17:40:26 +0200
Subject: [PATCH 054/418] Fix pallet-subtensor compilation

---
 pallets/subtensor/src/tests/staking.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pallets/subtensor/src/tests/staking.rs b/pallets/subtensor/src/tests/staking.rs
index a9fa11ba3a..8fe5964311 100644
--- a/pallets/subtensor/src/tests/staking.rs
+++ b/pallets/subtensor/src/tests/staking.rs
@@ -3,7 +3,7 @@
 
 use frame_support::{assert_err, assert_noop, assert_ok, traits::Currency};
 use frame_system::RawOrigin;
-use safe_math::SafeDiv;
+use safe_math::FixedExt;
 use substrate_fixed::traits::FromFixed;
 
 use super::mock::*;

From 5100519b7e0e00c959f60b8c202407eedf4ce8b8 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Mon, 7 Apr 2025 10:20:10 -0400
Subject: [PATCH 055/418] Intra-position test in progress

---
 pallets/swap/src/pallet/impls.rs | 274 +++++++++++++++++++++++++++++--
 1 file changed, 259 insertions(+), 15 deletions(-)

diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index b9dad6b564..2cd28d84c4 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -73,6 +73,10 @@ impl<T: Config> SwapStep<T> {
             possible_delta_in,
         );
 
+        println!("sqrt_price_edge = {:?}", sqrt_price_edge);
+        println!("sqrt_price_target = {:?}", sqrt_price_target);
+        println!("sqrt_price_limit = {:?}", sqrt_price_limit);
+
         // Quantities for comparison
         let edge_quantity = match order_type {
             OrderType::Buy => sqrt_price_edge.into(),
@@ -207,6 +211,8 @@ impl<T: Config> SwapStep<T> {
                 self.stop_and_refund = true;
             }
         }
+
+        println!("self.final_price = {:?}", self.final_price);
     }
 
     /// Process a single step of a swap
@@ -517,6 +523,10 @@ impl<T: Config> Pallet<T> {
             return sqrt_price_curr;
         }
 
+        println!("Calc target price. sqrt_price_curr = {:?}", sqrt_price_curr);
+        println!("Calc target price. liquidity_curr = {:?}", liquidity_curr);
+        println!("Calc target price. delta_in = {:?}", delta_in);
+
         match order_type {
             OrderType::Sell => one.safe_div(
                 delta_fixed
@@ -1488,7 +1498,7 @@ mod tests {
         // Outer part of test case is Position: (price_low_offset, price_high_offset, liquidity)
         [
             // Very localized position at the current price
-            (0.0, 0.0, 2_000_000_000_u64),
+            (-0.1, 0.1, 2_000_000_000_u64),
             // Repeat the protocol liquidity at maximum range
             (
                 min_price - current_price,
@@ -1514,20 +1524,253 @@ mod tests {
                 // Inner part of test case is Order: (order_type, order_liquidity, limit_price, output_amount)
                 // order_liquidity is represented as a fraction of position_liquidity
                 [
-                    (OrderType::Buy, 0.001, 1000.0_f64),
-                    (OrderType::Sell, 0.001, 0.0001_f64),
-                    (OrderType::Buy, 0.01, 1000.0_f64),
-                    (OrderType::Sell, 0.01, 0.0001_f64),
-                    (OrderType::Buy, 0.1, 1000.0),
-                    (OrderType::Sell, 0.1, 0.0001),
-                    (OrderType::Buy, 0.2, 1000.0),
-                    (OrderType::Sell, 0.2, 0.0001),
-                    (OrderType::Buy, 0.5, 1000.0),
-                    (OrderType::Sell, 0.5, 0.0001),
-                    (OrderType::Buy, 0.9999, 1000.0),
-                    (OrderType::Sell, 0.9999, 0.0001),
-                    (OrderType::Buy, 1.0, 1000.0),
-                    (OrderType::Sell, 1.0, 0.0001),
+                    // (OrderType::Buy, 0.001, 1000.0_f64),
+                    // (OrderType::Sell, 0.001, 0.0001_f64),
+                    // (OrderType::Buy, 0.01, 1000.0_f64),
+                    // (OrderType::Sell, 0.01, 0.0001_f64),
+                    // (OrderType::Buy, 0.1, 1000.0),
+                    // (OrderType::Sell, 0.1, 0.0001),
+                    (OrderType::Buy, 0.2, 1000.0_f64),
+                    // (OrderType::Sell, 0.2, 0.0001),
+                    // (OrderType::Buy, 0.5, 1000.0),
+                    // (OrderType::Sell, 0.5, 0.0001),
+                    // (OrderType::Buy, 0.9999, 1000.0),
+                    // (OrderType::Sell, 0.9999, 0.0001),
+                    // (OrderType::Buy, 1.0, 1000.0),
+                    // (OrderType::Sell, 1.0, 0.0001),
+                ]
+                .iter()
+                .for_each(|(order_type, order_liquidity_fraction, limit_price)| {
+                    new_test_ext().execute_with(|| {
+                        //////////////////////////////////////////////
+                        // Initialize pool and add the user position
+                        assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
+                        let tao_reserve = MockLiquidityProvider::tao_reserve(netuid.into());
+                        let alpha_reserve = MockLiquidityProvider::alpha_reserve(netuid.into());
+                        let protocol_liquidity = (tao_reserve as f64 * alpha_reserve as f64).sqrt();
+
+                        // Add liquidity
+                        let sqrt_current_price = AlphaSqrtPrice::<Test>::get(netuid);
+                        let current_price =
+                            (sqrt_current_price * sqrt_current_price).to_num::<f64>();
+
+                        let price_low = *price_low_offset + current_price;
+                        let price_high = *price_high_offset + current_price;
+                        let tick_low = price_to_tick(price_low);
+                        let tick_high = price_to_tick(price_high);
+                        let (_position_id, _tao, _alpha) = Pallet::<Test>::add_liquidity(
+                            netuid,
+                            &OK_ACCOUNT_ID,
+                            tick_low,
+                            tick_high,
+                            *position_liquidity,
+                        )
+                        .unwrap();
+
+                        // Liquidity position at correct ticks
+                        assert_eq!(Pallet::<Test>::count_positions(netuid, &OK_ACCOUNT_ID), 1);
+
+                        // Get tick infos before the swap
+                        let tick_low_info_before =
+                            Ticks::<Test>::get(netuid, tick_low).unwrap_or_default();
+                        let tick_high_info_before =
+                            Ticks::<Test>::get(netuid, tick_high).unwrap_or_default();
+                        let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
+                        assert_abs_diff_eq!(
+                            liquidity_before as f64,
+                            protocol_liquidity + *position_liquidity as f64,
+                            epsilon = liquidity_before as f64 / 10000.
+                        );
+
+                        //////////////////////////////////////////////
+                        // Swap
+
+                        // Calculate the expected output amount for the cornercase of one step
+                        let order_liquidity =
+                            *order_liquidity_fraction * *position_liquidity as f64;
+
+                        let input_amount = match order_type {
+                            OrderType::Buy => order_liquidity * sqrt_current_price.to_num::<f64>(),
+                            OrderType::Sell => order_liquidity / sqrt_current_price.to_num::<f64>(),
+                        };
+                        println!("Swap order amount: {:?}", input_amount);
+                        let fee_rate = FeeRate::<Test>::get(netuid) as f64 / u16::MAX as f64;
+                        let expected_fee = order_liquidity as f64 * fee_rate;
+                        let output_amount = match order_type {
+                            OrderType::Buy => {
+                                let denom = sqrt_current_price.to_num::<f64>()
+                                    * (sqrt_current_price.to_num::<f64>()
+                                        * liquidity_before as f64
+                                        + order_liquidity);
+                                let per_order_liq = liquidity_before as f64 / denom;
+                                per_order_liq * order_liquidity
+                            }
+                            OrderType::Sell => {
+                                let denom = liquidity_before as f64
+                                    / sqrt_current_price.to_num::<f64>()
+                                    + order_liquidity;
+                                let per_order_liq = sqrt_current_price.to_num::<f64>()
+                                    * liquidity_before as f64
+                                    / denom;
+                                per_order_liq * order_liquidity
+                            }
+                        };
+
+                        // Do the swap
+                        let sqrt_limit_price = SqrtPrice::from_num((limit_price).sqrt());
+                        let swap_result = Pallet::<Test>::swap(
+                            netuid,
+                            *order_type,
+                            order_liquidity as u64,
+                            sqrt_limit_price,
+                        );
+                        assert_abs_diff_eq!(
+                            swap_result.unwrap().amount_paid_out as f64,
+                            output_amount,
+                            epsilon = output_amount / 10.
+                        );
+
+                        // Assert that price movement is in correct direction
+                        let sqrt_current_price_after = AlphaSqrtPrice::<Test>::get(netuid);
+                        let current_price_after =
+                            (sqrt_current_price_after * sqrt_current_price_after).to_num::<f64>();
+                        match order_type {
+                            OrderType::Buy => assert!(current_price_after > current_price),
+                            OrderType::Sell => assert!(current_price_after < current_price),
+                        }
+
+                        println!("current_price_after = {:?}", current_price_after);
+
+                        // Assert that price stays within the user position
+                        println!("price_high = {:?}", price_high);
+                        println!("price_low = {:?}", price_low);
+                        assert!(current_price_after <= price_high);
+                        assert!(current_price_after >= price_low);
+
+                        // Check that low and high ticks' fees were updated properly, and liquidity values were not updated
+                        let tick_low_info = Ticks::<Test>::get(netuid, tick_low).unwrap();
+                        let tick_high_info = Ticks::<Test>::get(netuid, tick_high).unwrap();
+                        let expected_liquidity_net_low = tick_low_info_before.liquidity_net;
+                        let expected_liquidity_gross_low = tick_low_info_before.liquidity_gross;
+                        let expected_liquidity_net_high = tick_high_info_before.liquidity_net;
+                        let expected_liquidity_gross_high = tick_high_info_before.liquidity_gross;
+                        assert_eq!(tick_low_info.liquidity_net, expected_liquidity_net_low,);
+                        assert_eq!(tick_low_info.liquidity_gross, expected_liquidity_gross_low,);
+                        assert_eq!(tick_high_info.liquidity_net, expected_liquidity_net_high,);
+                        assert_eq!(
+                            tick_high_info.liquidity_gross,
+                            expected_liquidity_gross_high,
+                        );
+
+                        // Expected fee amount
+                        let fee_rate = FeeRate::<Test>::get(netuid) as f64 / u16::MAX as f64;
+                        let expected_fee = (order_liquidity as f64 * fee_rate) as u64;
+
+                        // Global fees should be updated
+                        let actual_global_fee = ((match order_type {
+                            OrderType::Buy => FeeGlobalAlpha::<Test>::get(netuid),
+                            OrderType::Sell => FeeGlobalTao::<Test>::get(netuid),
+                        })
+                        .to_num::<f64>()
+                            * (liquidity_before as f64))
+                            as u64;
+                        assert_abs_diff_eq!(
+                            actual_global_fee,
+                            expected_fee,
+                            epsilon = expected_fee / 1_000_000
+                        );
+
+                        // Tick fees should be updated
+
+                        // Liquidity position should not be updated
+                        let positions =
+                            Positions::<Test>::iter_prefix_values((netuid, OK_ACCOUNT_ID))
+                                .collect::<Vec<_>>();
+                        let position = positions.first().unwrap();
+
+                        assert_eq!(position.liquidity, *position_liquidity,);
+                        assert_eq!(position.tick_low, tick_low);
+                        assert_eq!(position.tick_high, tick_high);
+                        assert_eq!(position.fees_alpha, 0);
+                        assert_eq!(position.fees_tao, 0);
+
+                        // Current liquidity is not updated
+                        assert_eq!(CurrentLiquidity::<Test>::get(netuid), liquidity_before);
+
+                        // Reserves are updated
+                        // TODO: Add the test
+                        // assert_eq!(
+                        //     swap.state_ops.get_tao_reserve(),
+                        //     tao_withdrawn + protocol_tao,
+                        // );
+                        // assert_eq!(
+                        //     swap.state_ops.get_alpha_reserve(),
+                        //     alpha_withdrawn + protocol_alpha,
+                        // );
+                    });
+                });
+            },
+        );
+    }
+
+    // In this test the swap starts within a user position and ends outside of 
+    // it in protocol liquidity
+    // SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor-swap --lib -- pallet::impls::tests::test_swap_single_position_step_out --exact --show-output --nocapture
+    #[test]
+    fn test_swap_single_position_step_out() {
+        let min_price = tick_to_price(TickIndex::MIN);
+        let max_price = tick_to_price(TickIndex::MAX);
+        let max_tick = price_to_tick(max_price);
+        let current_price = 0.25;
+        let netuid = NetUid(1);
+        assert_eq!(max_tick, TickIndex::MAX);
+
+        // Current price is 0.25
+        // The test case is based on the current price and position prices are defined as a price
+        // offset from the current price
+        // Outer part of test case is Position: (price_low_offset, price_high_offset, liquidity)
+        [
+            // Very localized position at the current price
+            (0.0, 0.0, 2_000_000_000_u64),
+            // // Repeat the protocol liquidity at maximum range
+            // (
+            //     min_price - current_price,
+            //     max_price - current_price,
+            //     2_000_000_000_u64,
+            // ),
+            // // Repeat the protocol liquidity at current to max range
+            // (0.0, max_price - current_price, 2_000_000_000_u64),
+            // // Repeat the protocol liquidity at min to current range
+            // (min_price - current_price, 0.0, 2_000_000_000_u64),
+            // // Half to double price
+            // (-0.125, 0.25, 2_000_000_000_u64),
+            // // A few other price ranges and liquidity volumes
+            // (-0.1, 0.1, 2_000_000_000_u64),
+            // (-0.1, 0.1, 10_000_000_000_u64),
+            // (-0.1, 0.1, 100_000_000_000_u64),
+            // (-0.01, 0.01, 100_000_000_000_u64),
+            // (-0.001, 0.001, 100_000_000_000_u64),
+        ]
+        .iter()
+        .for_each(
+            |(price_low_offset, price_high_offset, position_liquidity)| {
+                // Inner part of test case is Order: (order_type, order_liquidity, limit_price, output_amount)
+                // order_liquidity is represented as a fraction of position_liquidity
+                [
+                    (OrderType::Buy, 2.0, 1000.0_f64),
+                    // (OrderType::Sell, 0.001, 0.0001_f64),
+                    // (OrderType::Buy, 0.01, 1000.0_f64),
+                    // (OrderType::Sell, 0.01, 0.0001_f64),
+                    // (OrderType::Buy, 0.1, 1000.0),
+                    // (OrderType::Sell, 0.1, 0.0001),
+                    // (OrderType::Buy, 0.2, 1000.0),
+                    // (OrderType::Sell, 0.2, 0.0001),
+                    // (OrderType::Buy, 0.5, 1000.0),
+                    // (OrderType::Sell, 0.5, 0.0001),
+                    // (OrderType::Buy, 0.9999, 1000.0),
+                    // (OrderType::Sell, 0.9999, 0.0001),
+                    // (OrderType::Buy, 1.0, 1000.0),
+                    // (OrderType::Sell, 1.0, 0.0001),
                 ]
                 .iter()
                 .for_each(|(order_type, order_liquidity_fraction, limit_price)| {
@@ -1691,4 +1934,5 @@ mod tests {
             },
         );
     }
+
 }

From 00f36862365fbfecfe2c8b6cb75e0975a6474ee1 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Mon, 7 Apr 2025 15:58:17 -0400
Subject: [PATCH 056/418] Test with multiple positions, correct test for single
 position

---
 pallets/swap/src/mock.rs         |   4 +-
 pallets/swap/src/pallet/impls.rs | 427 +++++++++++++------------------
 2 files changed, 177 insertions(+), 254 deletions(-)

diff --git a/pallets/swap/src/mock.rs b/pallets/swap/src/mock.rs
index 59cae330f5..56c0a0ce71 100644
--- a/pallets/swap/src/mock.rs
+++ b/pallets/swap/src/mock.rs
@@ -85,7 +85,7 @@ impl LiquidityDataProvider<AccountId> for MockLiquidityProvider {
 
     fn tao_balance(_: u16, account_id: &AccountId) -> u64 {
         if *account_id == OK_ACCOUNT_ID {
-            100_000_000_000
+            100_000_000_000_000
         } else {
             1_000_000_000
         }
@@ -93,7 +93,7 @@ impl LiquidityDataProvider<AccountId> for MockLiquidityProvider {
 
     fn alpha_balance(_: u16, account_id: &AccountId) -> u64 {
         if *account_id == OK_ACCOUNT_ID {
-            100_000_000_000
+            100_000_000_000_000
         } else {
             1_000_000_000
         }
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 2cd28d84c4..f91ddad072 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -73,10 +73,6 @@ impl<T: Config> SwapStep<T> {
             possible_delta_in,
         );
 
-        println!("sqrt_price_edge = {:?}", sqrt_price_edge);
-        println!("sqrt_price_target = {:?}", sqrt_price_target);
-        println!("sqrt_price_limit = {:?}", sqrt_price_limit);
-
         // Quantities for comparison
         let edge_quantity = match order_type {
             OrderType::Buy => sqrt_price_edge.into(),
@@ -211,8 +207,6 @@ impl<T: Config> SwapStep<T> {
                 self.stop_and_refund = true;
             }
         }
-
-        println!("self.final_price = {:?}", self.final_price);
     }
 
     /// Process a single step of a swap
@@ -477,8 +471,6 @@ impl<T: Config> Pallet<T> {
             return 0;
         }
 
-        println!("delta_in = {:?}", delta_in);
-
         let liquidity_curr = SqrtPrice::saturating_from_num(CurrentLiquidity::<T>::get(netuid));
         let sqrt_price_curr = AlphaSqrtPrice::<T>::get(netuid);
         let delta_fixed = SqrtPrice::saturating_from_num(delta_in);
@@ -491,16 +483,12 @@ impl<T: Config> Pallet<T> {
                 let a = liquidity_curr / (liquidity_curr / sqrt_price_curr + delta_fixed);
                 let b = a * sqrt_price_curr;
                 let c = delta_fixed * b;
-                println!("sell c = {:?}", c);
                 c
             }
             OrderType::Buy => {
                 let a = (liquidity_curr * sqrt_price_curr + delta_fixed) * sqrt_price_curr;
-                println!("a = {:?}", a);
                 let b = liquidity_curr / a;
-                println!("b = {:?}", b);
                 let c = b * delta_fixed;
-                println!("buy c = {:?}", c);
                 c
             }
         };
@@ -523,10 +511,6 @@ impl<T: Config> Pallet<T> {
             return sqrt_price_curr;
         }
 
-        println!("Calc target price. sqrt_price_curr = {:?}", sqrt_price_curr);
-        println!("Calc target price. liquidity_curr = {:?}", liquidity_curr);
-        println!("Calc target price. delta_in = {:?}", delta_in);
-
         match order_type {
             OrderType::Sell => one.safe_div(
                 delta_fixed
@@ -1482,9 +1466,9 @@ mod tests {
     }
 
     // In this test the swap starts and ends within one (large liquidity) position
-    // SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor-swap --lib -- pallet::impls::tests::test_swap_single_position_step_in --exact --show-output --nocapture
+    // SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor-swap --lib -- pallet::impls::tests::test_swap_single_position --exact --show-output --nocapture
     #[test]
-    fn test_swap_single_position_step_in() {
+    fn test_swap_single_position() {
         let min_price = tick_to_price(TickIndex::MIN);
         let max_price = tick_to_price(TickIndex::MAX);
         let max_tick = price_to_tick(max_price);
@@ -1498,7 +1482,7 @@ mod tests {
         // Outer part of test case is Position: (price_low_offset, price_high_offset, liquidity)
         [
             // Very localized position at the current price
-            (-0.1, 0.1, 2_000_000_000_u64),
+            (-0.1, 0.1, 500_000_000_000_u64),
             // Repeat the protocol liquidity at maximum range
             (
                 min_price - current_price,
@@ -1524,20 +1508,22 @@ mod tests {
                 // Inner part of test case is Order: (order_type, order_liquidity, limit_price, output_amount)
                 // order_liquidity is represented as a fraction of position_liquidity
                 [
-                    // (OrderType::Buy, 0.001, 1000.0_f64),
-                    // (OrderType::Sell, 0.001, 0.0001_f64),
-                    // (OrderType::Buy, 0.01, 1000.0_f64),
-                    // (OrderType::Sell, 0.01, 0.0001_f64),
-                    // (OrderType::Buy, 0.1, 1000.0),
-                    // (OrderType::Sell, 0.1, 0.0001),
+                    (OrderType::Buy, 0.0001, 1000.0_f64),
+                    (OrderType::Sell, 0.0001, 0.0001_f64),
+                    (OrderType::Buy, 0.001, 1000.0_f64),
+                    (OrderType::Sell, 0.001, 0.0001_f64),
+                    (OrderType::Buy, 0.01, 1000.0_f64),
+                    (OrderType::Sell, 0.01, 0.0001_f64),
+                    (OrderType::Buy, 0.1, 1000.0),
+                    (OrderType::Sell, 0.1, 0.0001),
                     (OrderType::Buy, 0.2, 1000.0_f64),
-                    // (OrderType::Sell, 0.2, 0.0001),
-                    // (OrderType::Buy, 0.5, 1000.0),
-                    // (OrderType::Sell, 0.5, 0.0001),
-                    // (OrderType::Buy, 0.9999, 1000.0),
-                    // (OrderType::Sell, 0.9999, 0.0001),
-                    // (OrderType::Buy, 1.0, 1000.0),
-                    // (OrderType::Sell, 1.0, 0.0001),
+                    (OrderType::Sell, 0.2, 0.0001),
+                    (OrderType::Buy, 0.5, 1000.0),
+                    (OrderType::Sell, 0.5, 0.0001),
+                    (OrderType::Buy, 0.9999, 1000.0),
+                    (OrderType::Sell, 0.9999, 0.0001),
+                    (OrderType::Buy, 1.0, 1000.0),
+                    (OrderType::Sell, 1.0, 0.0001),
                 ]
                 .iter()
                 .for_each(|(order_type, order_liquidity_fraction, limit_price)| {
@@ -1593,9 +1579,6 @@ mod tests {
                             OrderType::Buy => order_liquidity * sqrt_current_price.to_num::<f64>(),
                             OrderType::Sell => order_liquidity / sqrt_current_price.to_num::<f64>(),
                         };
-                        println!("Swap order amount: {:?}", input_amount);
-                        let fee_rate = FeeRate::<Test>::get(netuid) as f64 / u16::MAX as f64;
-                        let expected_fee = order_liquidity as f64 * fee_rate;
                         let output_amount = match order_type {
                             OrderType::Buy => {
                                 let denom = sqrt_current_price.to_num::<f64>()
@@ -1639,13 +1622,14 @@ mod tests {
                             OrderType::Sell => assert!(current_price_after < current_price),
                         }
 
-                        println!("current_price_after = {:?}", current_price_after);
-
-                        // Assert that price stays within the user position
-                        println!("price_high = {:?}", price_high);
-                        println!("price_low = {:?}", price_low);
-                        assert!(current_price_after <= price_high);
-                        assert!(current_price_after >= price_low);
+                        // Assert that for small amounts price stays within the user position
+                        if (*order_liquidity_fraction <= 0.001)
+                            && (*price_low_offset != 0.0)
+                            && (*price_high_offset != 0.0)
+                        {
+                            assert!(current_price_after <= price_high);
+                            assert!(current_price_after >= price_low);
+                        }
 
                         // Check that low and high ticks' fees were updated properly, and liquidity values were not updated
                         let tick_low_info = Ticks::<Test>::get(netuid, tick_low).unwrap();
@@ -1713,226 +1697,165 @@ mod tests {
         );
     }
 
-    // In this test the swap starts within a user position and ends outside of 
-    // it in protocol liquidity
-    // SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor-swap --lib -- pallet::impls::tests::test_swap_single_position_step_out --exact --show-output --nocapture
+    // This test is a sanity check for swap and multiple positions
+    // SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor-swap --lib -- pallet::impls::tests::test_swap_multiple_positions --exact --show-output --nocapture
     #[test]
-    fn test_swap_single_position_step_out() {
-        let min_price = tick_to_price(TickIndex::MIN);
-        let max_price = tick_to_price(TickIndex::MAX);
-        let max_tick = price_to_tick(max_price);
-        let current_price = 0.25;
-        let netuid = NetUid(1);
-        assert_eq!(max_tick, TickIndex::MAX);
-
-        // Current price is 0.25
-        // The test case is based on the current price and position prices are defined as a price
-        // offset from the current price
-        // Outer part of test case is Position: (price_low_offset, price_high_offset, liquidity)
-        [
-            // Very localized position at the current price
-            (0.0, 0.0, 2_000_000_000_u64),
-            // // Repeat the protocol liquidity at maximum range
-            // (
-            //     min_price - current_price,
-            //     max_price - current_price,
-            //     2_000_000_000_u64,
-            // ),
-            // // Repeat the protocol liquidity at current to max range
-            // (0.0, max_price - current_price, 2_000_000_000_u64),
-            // // Repeat the protocol liquidity at min to current range
-            // (min_price - current_price, 0.0, 2_000_000_000_u64),
-            // // Half to double price
-            // (-0.125, 0.25, 2_000_000_000_u64),
-            // // A few other price ranges and liquidity volumes
-            // (-0.1, 0.1, 2_000_000_000_u64),
-            // (-0.1, 0.1, 10_000_000_000_u64),
-            // (-0.1, 0.1, 100_000_000_000_u64),
-            // (-0.01, 0.01, 100_000_000_000_u64),
-            // (-0.001, 0.001, 100_000_000_000_u64),
-        ]
-        .iter()
-        .for_each(
-            |(price_low_offset, price_high_offset, position_liquidity)| {
-                // Inner part of test case is Order: (order_type, order_liquidity, limit_price, output_amount)
-                // order_liquidity is represented as a fraction of position_liquidity
-                [
-                    (OrderType::Buy, 2.0, 1000.0_f64),
-                    // (OrderType::Sell, 0.001, 0.0001_f64),
-                    // (OrderType::Buy, 0.01, 1000.0_f64),
-                    // (OrderType::Sell, 0.01, 0.0001_f64),
-                    // (OrderType::Buy, 0.1, 1000.0),
-                    // (OrderType::Sell, 0.1, 0.0001),
-                    // (OrderType::Buy, 0.2, 1000.0),
-                    // (OrderType::Sell, 0.2, 0.0001),
-                    // (OrderType::Buy, 0.5, 1000.0),
-                    // (OrderType::Sell, 0.5, 0.0001),
-                    // (OrderType::Buy, 0.9999, 1000.0),
-                    // (OrderType::Sell, 0.9999, 0.0001),
-                    // (OrderType::Buy, 1.0, 1000.0),
-                    // (OrderType::Sell, 1.0, 0.0001),
-                ]
-                .iter()
-                .for_each(|(order_type, order_liquidity_fraction, limit_price)| {
-                    new_test_ext().execute_with(|| {
-                        //////////////////////////////////////////////
-                        // Initialize pool and add the user position
-                        assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
-                        let tao_reserve = MockLiquidityProvider::tao_reserve(netuid.into());
-                        let alpha_reserve = MockLiquidityProvider::alpha_reserve(netuid.into());
-                        let protocol_liquidity = (tao_reserve as f64 * alpha_reserve as f64).sqrt();
-
-                        // Add liquidity
-                        let sqrt_current_price = AlphaSqrtPrice::<Test>::get(netuid);
-                        let current_price =
-                            (sqrt_current_price * sqrt_current_price).to_num::<f64>();
-
-                        let price_low = *price_low_offset + current_price;
-                        let price_high = *price_high_offset + current_price;
-                        let tick_low = price_to_tick(price_low);
-                        let tick_high = price_to_tick(price_high);
-                        let (_position_id, _tao, _alpha) = Pallet::<Test>::add_liquidity(
-                            netuid,
-                            &OK_ACCOUNT_ID,
-                            tick_low,
-                            tick_high,
-                            *position_liquidity,
-                        )
-                        .unwrap();
-
-                        // Liquidity position at correct ticks
-                        assert_eq!(Pallet::<Test>::count_positions(netuid, &OK_ACCOUNT_ID), 1);
-
-                        // Get tick infos before the swap
-                        let tick_low_info_before =
-                            Ticks::<Test>::get(netuid, tick_low).unwrap_or_default();
-                        let tick_high_info_before =
-                            Ticks::<Test>::get(netuid, tick_high).unwrap_or_default();
-                        let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
-                        assert_abs_diff_eq!(
-                            liquidity_before as f64,
-                            protocol_liquidity + *position_liquidity as f64,
-                            epsilon = liquidity_before as f64 / 10000.
-                        );
-
-                        //////////////////////////////////////////////
-                        // Swap
-
-                        // Calculate the expected output amount for the cornercase of one step
-                        let order_liquidity =
-                            *order_liquidity_fraction * *position_liquidity as f64;
-                        println!("Swap liquidity amount: {:?}", order_liquidity);
-                        let fee_rate = FeeRate::<Test>::get(netuid) as f64 / u16::MAX as f64;
-                        let expected_fee = order_liquidity as f64 * fee_rate;
-                        let output_amount = match order_type {
-                            OrderType::Buy => {
-                                let denom = sqrt_current_price.to_num::<f64>()
-                                    * (sqrt_current_price.to_num::<f64>()
-                                        * liquidity_before as f64
-                                        + order_liquidity);
-                                let per_order_liq = liquidity_before as f64 / denom;
-                                per_order_liq * order_liquidity
-                            }
-                            OrderType::Sell => {
-                                let denom = liquidity_before as f64
-                                    / sqrt_current_price.to_num::<f64>()
-                                    + order_liquidity;
-                                let per_order_liq = sqrt_current_price.to_num::<f64>()
-                                    * liquidity_before as f64
-                                    / denom;
-                                per_order_liq * order_liquidity
-                            }
-                        };
-
-                        // Do the swap
-                        let sqrt_limit_price = SqrtPrice::from_num((limit_price).sqrt());
-                        let swap_result = Pallet::<Test>::swap(
-                            netuid,
-                            *order_type,
-                            order_liquidity as u64,
-                            sqrt_limit_price,
-                        );
-                        assert_abs_diff_eq!(
-                            swap_result.unwrap().amount_paid_out as f64,
-                            output_amount,
-                            epsilon = output_amount / 10.
-                        );
+    fn test_swap_multiple_positions() {
+        new_test_ext().execute_with(|| {
+            let min_price = tick_to_price(TickIndex::MIN);
+            let max_price = tick_to_price(TickIndex::MAX);
+            let max_tick = price_to_tick(max_price);
+            let current_price = 0.25;
+            let netuid = NetUid(1);
+            assert_eq!(max_tick, TickIndex::MAX);
 
-                        // Assert that price movement is in correct direction
-                        let sqrt_current_price_after = AlphaSqrtPrice::<Test>::get(netuid);
-                        let current_price_after =
-                            (sqrt_current_price_after * sqrt_current_price_after).to_num::<f64>();
-                        match order_type {
-                            OrderType::Buy => assert!(current_price_after > current_price),
-                            OrderType::Sell => assert!(current_price_after < current_price),
-                        }
+            //////////////////////////////////////////////
+            // Initialize pool and add the user position
+            assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
 
-                        println!("current_price_after = {:?}", current_price_after);
+            // Add liquidity
+            let sqrt_current_price = AlphaSqrtPrice::<Test>::get(netuid);
+            let current_price = (sqrt_current_price * sqrt_current_price).to_num::<f64>();
 
-                        // Check that low and high ticks' fees were updated properly, and liquidity values were not updated
-                        let tick_low_info = Ticks::<Test>::get(netuid, tick_low).unwrap();
-                        let tick_high_info = Ticks::<Test>::get(netuid, tick_high).unwrap();
-                        let expected_liquidity_net_low = tick_low_info_before.liquidity_net;
-                        let expected_liquidity_gross_low = tick_low_info_before.liquidity_gross;
-                        let expected_liquidity_net_high = tick_high_info_before.liquidity_net;
-                        let expected_liquidity_gross_high = tick_high_info_before.liquidity_gross;
-                        assert_eq!(tick_low_info.liquidity_net, expected_liquidity_net_low,);
-                        assert_eq!(tick_low_info.liquidity_gross, expected_liquidity_gross_low,);
-                        assert_eq!(tick_high_info.liquidity_net, expected_liquidity_net_high,);
-                        assert_eq!(
-                            tick_high_info.liquidity_gross,
-                            expected_liquidity_gross_high,
-                        );
+            // Current price is 0.25
+            // All positions below are placed at once
+            [
+                // Very localized position at the current price
+                (-0.1, 0.1, 500_000_000_000_u64),
+                // Repeat the protocol liquidity at maximum range
+                (
+                    min_price - current_price,
+                    max_price - current_price,
+                    2_000_000_000_u64,
+                ),
+                // Repeat the protocol liquidity at current to max range
+                (0.0, max_price - current_price, 2_000_000_000_u64),
+                // Repeat the protocol liquidity at min to current range
+                (min_price - current_price, 0.0, 2_000_000_000_u64),
+                // Half to double price
+                (-0.125, 0.25, 2_000_000_000_u64),
+                // A few other price ranges and liquidity volumes
+                (-0.1, 0.1, 2_000_000_000_u64),
+                (-0.1, 0.1, 10_000_000_000_u64),
+                (-0.1, 0.1, 100_000_000_000_u64),
+                (-0.01, 0.01, 100_000_000_000_u64),
+                (-0.001, 0.001, 100_000_000_000_u64),
+                // A few (overlapping) positions up the range
+                (0.01, 0.02, 100_000_000_000_u64),
+                (0.02, 0.03, 100_000_000_000_u64),
+                (0.03, 0.04, 100_000_000_000_u64),
+                (0.03, 0.05, 100_000_000_000_u64),
+                // A few (overlapping) positions down the range
+                (-0.02, -0.01, 100_000_000_000_u64),
+                (-0.03, -0.02, 100_000_000_000_u64),
+                (-0.04, -0.03, 100_000_000_000_u64),
+                (-0.05, -0.03, 100_000_000_000_u64),
+            ]
+            .iter()
+            .for_each(
+                |(price_low_offset, price_high_offset, position_liquidity)| {
+                    let price_low = *price_low_offset + current_price;
+                    let price_high = *price_high_offset + current_price;
+                    let tick_low = price_to_tick(price_low);
+                    let tick_high = price_to_tick(price_high);
+                    let (_position_id, _tao, _alpha) = Pallet::<Test>::add_liquidity(
+                        netuid,
+                        &OK_ACCOUNT_ID,
+                        tick_low,
+                        tick_high,
+                        *position_liquidity,
+                    )
+                    .unwrap();
+                },
+            );
 
-                        // Expected fee amount
-                        let fee_rate = FeeRate::<Test>::get(netuid) as f64 / u16::MAX as f64;
-                        let expected_fee = (order_liquidity as f64 * fee_rate) as u64;
+            // All these orders are executed without swap reset
+            [
+                (OrderType::Buy, 100_000_u64, 1000.0_f64),
+                (OrderType::Sell, 100_000, 0.0001_f64),
+                (OrderType::Buy, 1_000_000, 1000.0_f64),
+                (OrderType::Sell, 1_000_000, 0.0001_f64),
+                (OrderType::Buy, 10_000_000, 1000.0_f64),
+                (OrderType::Sell, 10_000_000, 0.0001_f64),
+                (OrderType::Buy, 100_000_000, 1000.0),
+                (OrderType::Sell, 100_000_000, 0.0001),
+                (OrderType::Buy, 200_000_000, 1000.0_f64),
+                (OrderType::Sell, 200_000_000, 0.0001),
+                (OrderType::Buy, 500_000_000, 1000.0),
+                (OrderType::Sell, 500_000_000, 0.0001),
+                (OrderType::Buy, 1_000_000_000, 1000.0),
+                (OrderType::Sell, 1_000_000_000, 0.0001),
+                (OrderType::Buy, 10_000_000_000, 1000.0),
+                (OrderType::Sell, 10_000_000_000, 0.0001),
+            ]
+            .iter()
+            .for_each(|(order_type, order_liquidity, limit_price)| {
+                //////////////////////////////////////////////
+                // Swap
+                let sqrt_current_price = AlphaSqrtPrice::<Test>::get(netuid);
+                let current_price = (sqrt_current_price * sqrt_current_price).to_num::<f64>();
+                let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
 
-                        // Global fees should be updated
-                        let actual_global_fee = ((match order_type {
-                            OrderType::Buy => FeeGlobalAlpha::<Test>::get(netuid),
-                            OrderType::Sell => FeeGlobalTao::<Test>::get(netuid),
-                        })
-                        .to_num::<f64>()
-                            * (liquidity_before as f64))
-                            as u64;
-                        assert_abs_diff_eq!(
-                            actual_global_fee,
-                            expected_fee,
-                            epsilon = expected_fee / 1_000_000
-                        );
+                let output_amount = match order_type {
+                    OrderType::Buy => {
+                        let denom = sqrt_current_price.to_num::<f64>()
+                            * (sqrt_current_price.to_num::<f64>() * liquidity_before as f64
+                                + *order_liquidity as f64);
+                        let per_order_liq = liquidity_before as f64 / denom;
+                        per_order_liq * *order_liquidity as f64
+                    }
+                    OrderType::Sell => {
+                        let denom = liquidity_before as f64 / sqrt_current_price.to_num::<f64>()
+                            + *order_liquidity as f64;
+                        let per_order_liq =
+                            sqrt_current_price.to_num::<f64>() * liquidity_before as f64 / denom;
+                        per_order_liq * *order_liquidity as f64
+                    }
+                };
 
-                        // Tick fees should be updated
+                // Do the swap
+                let sqrt_limit_price = SqrtPrice::from_num((limit_price).sqrt());
+                let swap_result =
+                    Pallet::<Test>::swap(netuid, *order_type, *order_liquidity, sqrt_limit_price);
+                assert_abs_diff_eq!(
+                    swap_result.unwrap().amount_paid_out as f64,
+                    output_amount,
+                    epsilon = output_amount / 10.
+                );
 
-                        // Liquidity position should not be updated
-                        let positions =
-                            Positions::<Test>::iter_prefix_values((netuid, OK_ACCOUNT_ID))
-                                .collect::<Vec<_>>();
-                        let position = positions.first().unwrap();
+                // Assert that price movement is in correct direction
+                let sqrt_current_price_after = AlphaSqrtPrice::<Test>::get(netuid);
+                let current_price_after =
+                    (sqrt_current_price_after * sqrt_current_price_after).to_num::<f64>();
+                match order_type {
+                    OrderType::Buy => assert!(current_price_after > current_price),
+                    OrderType::Sell => assert!(current_price_after < current_price),
+                }
 
-                        assert_eq!(position.liquidity, *position_liquidity,);
-                        assert_eq!(position.tick_low, tick_low);
-                        assert_eq!(position.tick_high, tick_high);
-                        assert_eq!(position.fees_alpha, 0);
-                        assert_eq!(position.fees_tao, 0);
+                // Current liquidity is not updated
+                assert_eq!(CurrentLiquidity::<Test>::get(netuid), liquidity_before);
 
-                        // Current liquidity is not updated
-                        assert_eq!(CurrentLiquidity::<Test>::get(netuid), liquidity_before);
+                // Reserves are updated
+                // TODO: Add the test
+                // assert_eq!(
+                //     swap.state_ops.get_tao_reserve(),
+                //     tao_withdrawn + protocol_tao,
+                // );
+                // assert_eq!(
+                //     swap.state_ops.get_alpha_reserve(),
+                //     alpha_withdrawn + protocol_alpha,
+                // );
+            });
 
-                        // Reserves are updated
-                        // TODO: Add the test
-                        // assert_eq!(
-                        //     swap.state_ops.get_tao_reserve(),
-                        //     tao_withdrawn + protocol_tao,
-                        // );
-                        // assert_eq!(
-                        //     swap.state_ops.get_alpha_reserve(),
-                        //     alpha_withdrawn + protocol_alpha,
-                        // );
-                    });
-                });
-            },
-        );
+            // Current price shouldn't be much different from the original
+            let sqrt_current_price_after = AlphaSqrtPrice::<Test>::get(netuid);
+            let current_price_after =
+                (sqrt_current_price_after * sqrt_current_price_after).to_num::<f64>();
+            assert_abs_diff_eq!(
+                current_price,
+                current_price_after,
+                epsilon = current_price / 10.
+            )
+        });
     }
-
 }

From 57981264a319e7531bc0fc63f7922d55308773b1 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Tue, 8 Apr 2025 19:19:33 +0200
Subject: [PATCH 057/418] Calculate reserves update during swap

---
 Cargo.lock                        | 2193 +++++++++++------------------
 Cargo.toml                        |    2 +-
 pallets/subtensor/Cargo.toml      |    4 +-
 pallets/swap-interface/Cargo.toml |    8 +-
 pallets/swap-interface/src/lib.rs |   74 +-
 pallets/swap/Cargo.toml           |    7 +-
 pallets/swap/src/lib.rs           |    2 +-
 pallets/swap/src/mock.rs          |    2 +-
 pallets/swap/src/pallet/impls.rs  |  248 +++-
 pallets/swap/src/pallet/mod.rs    |    9 +-
 pallets/swap/src/position.rs      |   32 +-
 11 files changed, 1122 insertions(+), 1459 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 76e9e93b1e..cdb77c5000 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -23,11 +23,11 @@ dependencies = [
 
 [[package]]
 name = "addr2line"
-version = "0.24.2"
+version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dfbe277e56a376000877090da837660b4427aad530e3028d44e0bffe4f89a1c1"
+checksum = "f5fb1d8e4442bd405fdfd1dacb42792696b0cf9cb15882e5d097b742a676d375"
 dependencies = [
- "gimli 0.31.1",
+ "gimli 0.31.0",
 ]
 
 [[package]]
@@ -106,9 +106,9 @@ dependencies = [
 
 [[package]]
 name = "allocator-api2"
-version = "0.2.21"
+version = "0.2.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
+checksum = "5c6cb57a04249c6480766f7f7cef5467412af1490f8d1e243141daddada3264f"
 
 [[package]]
 name = "alloy-primitives"
@@ -122,7 +122,7 @@ dependencies = [
  "const-hex",
  "derive_more 2.0.1",
  "foldhash",
- "indexmap 2.8.0",
+ "indexmap 2.6.0",
  "itoa",
  "k256",
  "keccak-asm",
@@ -163,9 +163,9 @@ dependencies = [
 
 [[package]]
 name = "anstream"
-version = "0.6.18"
+version = "0.6.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8acc5369981196006228e28809f761875c0327210a891e941f4c683b3a99529b"
+checksum = "64e15c1ab1f89faffbf04a634d5e1962e9074f2741eef6d97f3c4e322426d526"
 dependencies = [
  "anstyle",
  "anstyle-parse",
@@ -178,44 +178,43 @@ dependencies = [
 
 [[package]]
 name = "anstyle"
-version = "1.0.10"
+version = "1.0.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55cc3b69f167a1ef2e161439aa98aed94e6028e5f9a59be9a6ffb47aef1651f9"
+checksum = "1bec1de6f59aedf83baf9ff929c98f2ad654b97c9510f4e70cf6f661d49fd5b1"
 
 [[package]]
 name = "anstyle-parse"
-version = "0.2.6"
+version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b2d16507662817a6a20a9ea92df6652ee4f94f914589377d69f3b21bc5798a9"
+checksum = "eb47de1e80c2b463c735db5b217a0ddc39d612e7ac9e2e96a5aed1f57616c1cb"
 dependencies = [
  "utf8parse",
 ]
 
 [[package]]
 name = "anstyle-query"
-version = "1.1.2"
+version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79947af37f4177cfead1110013d678905c37501914fba0efea834c3fe9a8d60c"
+checksum = "6d36fc52c7f6c869915e99412912f22093507da8d9e942ceaf66fe4b7c14422a"
 dependencies = [
- "windows-sys 0.59.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "anstyle-wincon"
-version = "3.0.7"
+version = "3.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca3534e77181a9cc07539ad51f2141fe32f6c3ffd4df76db8ad92346b003ae4e"
+checksum = "5bf74e1b6e971609db8ca7a9ce79fd5768ab6ae46441c572e46cf596f59e57f8"
 dependencies = [
  "anstyle",
- "once_cell",
- "windows-sys 0.59.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "anyhow"
-version = "1.0.97"
+version = "1.0.89"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dcfed56ad506cb2c684a14971b8861fdc3baaaae314b9e5f9bb532cbe3ba7a4f"
+checksum = "86fdf8605db99b54d3cd748a44c6d04df638eb5dafb219b135d0149bd0db01f6"
 
 [[package]]
 name = "approx"
@@ -237,7 +236,7 @@ dependencies = [
  "proc-macro-error",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -664,7 +663,7 @@ dependencies = [
  "nom",
  "num-traits",
  "rusticata-macros",
- "thiserror 1.0.69",
+ "thiserror",
  "time",
 ]
 
@@ -680,7 +679,7 @@ dependencies = [
  "nom",
  "num-traits",
  "rusticata-macros",
- "thiserror 1.0.69",
+ "thiserror",
  "time",
 ]
 
@@ -704,7 +703,7 @@ checksum = "965c2d33e53cb6b267e148a4cb0760bc01f4904c1cd4bb4002a085bb016d1490"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
  "synstructure 0.13.1",
 ]
 
@@ -727,7 +726,7 @@ checksum = "7b18050c2cd6fe86c3a76584ef5e0baf286d038cda203eb6223df2cc413565f7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -749,9 +748,9 @@ dependencies = [
 
 [[package]]
 name = "async-io"
-version = "2.4.0"
+version = "2.3.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43a2b323ccce0a1d90b449fd71f2a06ca7faa7c54c2751f06c9bd851fc061059"
+checksum = "444b0228950ee6501b3568d3c93bf1176a1fdbc3b758dcd9475046d30f4dc7e8"
 dependencies = [
  "async-lock",
  "cfg-if",
@@ -760,7 +759,7 @@ dependencies = [
  "futures-lite",
  "parking",
  "polling",
- "rustix 0.38.44",
+ "rustix 0.38.37",
  "slab",
  "tracing",
  "windows-sys 0.59.0",
@@ -772,20 +771,20 @@ version = "3.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ff6e472cdea888a4bd64f342f09b3f50e1886d32afe8df3d663c01140b811b18"
 dependencies = [
- "event-listener 5.4.0",
+ "event-listener 5.3.1",
  "event-listener-strategy",
  "pin-project-lite",
 ]
 
 [[package]]
 name = "async-trait"
-version = "0.1.88"
+version = "0.1.83"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e539d3fca749fcee5236ab05e93a52867dd549cc157c8cb7f99595f3cedffdb5"
+checksum = "721cae7de5c34fbb2acd27e21e6d2cf7b886dce0c27388d46c4e6c47ea4318dd"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -829,13 +828,13 @@ dependencies = [
 
 [[package]]
 name = "auto_impl"
-version = "1.2.1"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e12882f59de5360c748c4cbf569a042d5fb0eb515f7bea9c1f470b47f6ffbd73"
+checksum = "3c87f3f15e7794432337fc718554eaa4dc8f04c9677a950ffe366f20a162ae42"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -850,11 +849,11 @@ version = "0.3.74"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8d82cb332cdfaed17ae235a638438ac4d4839913cc2af585c3c6746e8f8bee1a"
 dependencies = [
- "addr2line 0.24.2",
+ "addr2line 0.24.1",
  "cfg-if",
  "libc",
  "miniz_oxide",
- "object 0.36.7",
+ "object 0.36.4",
  "rustc-demangle",
  "windows-targets 0.52.6",
 ]
@@ -891,9 +890,9 @@ checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
 
 [[package]]
 name = "base64ct"
-version = "1.7.3"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89e25b6adfb930f02d1981565a6e5d9c547ac15a96606256d3b59040e5cd4ca3"
+checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"
 
 [[package]]
 name = "bincode"
@@ -916,13 +915,13 @@ dependencies = [
  "lazy_static",
  "lazycell",
  "peeking_take_while",
- "prettyplease 0.2.31",
+ "prettyplease 0.2.22",
  "proc-macro2",
  "quote",
  "regex",
  "rustc-hash 1.1.0",
  "shlex",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -964,9 +963,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bitflags"
-version = "2.9.0"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c8214115b7bf84099f1309324e63141d4c5d7cc26862f97a0a857dbefe165bd"
+checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
 
 [[package]]
 name = "bitvec"
@@ -1003,9 +1002,9 @@ dependencies = [
 
 [[package]]
 name = "blake2b_simd"
-version = "1.0.3"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06e903a20b159e944f91ec8499fe1e55651480c541ea0a584f5d967c49ad9d99"
+checksum = "23285ad32269793932e830392f2fe2f83e26488fd3ec778883a93c8323735780"
 dependencies = [
  "arrayref",
  "arrayvec",
@@ -1014,9 +1013,9 @@ dependencies = [
 
 [[package]]
 name = "blake2s_simd"
-version = "1.0.3"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e90f7deecfac93095eb874a40febd69427776e24e1bd7f87f33ac62d6f0174df"
+checksum = "94230421e395b9920d23df13ea5d77a20e1725331f90fbbf6df6040b33f756ae"
 dependencies = [
  "arrayref",
  "arrayvec",
@@ -1025,9 +1024,9 @@ dependencies = [
 
 [[package]]
 name = "blake3"
-version = "1.8.1"
+version = "1.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "389a099b34312839e16420d499a9cad9650541715937ffbdd40d36f49e77eeb3"
+checksum = "d82033247fd8e890df8f740e407ad4d038debb9eb1f40533fffb32e7d17dc6f7"
 dependencies = [
  "arrayref",
  "arrayvec",
@@ -1056,9 +1055,9 @@ dependencies = [
 
 [[package]]
 name = "bounded-collections"
-version = "0.2.4"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64ad8a0bed7827f0b07a5d23cec2e58cc02038a99e4ca81616cb2bb2025f804d"
+checksum = "d32385ecb91a31bddaf908e8dcf4a15aef1bcd3913cc03ebfad02ff6d568abc1"
 dependencies = [
  "log",
  "parity-scale-codec",
@@ -1092,15 +1091,15 @@ dependencies = [
 
 [[package]]
 name = "bumpalo"
-version = "3.17.0"
+version = "3.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1628fb46dfa0b37568d12e5edd512553eccf6a22a78e8bde00bb4aed84d5bdbf"
+checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c"
 
 [[package]]
 name = "byte-slice-cast"
-version = "1.2.3"
+version = "1.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7575182f7272186991736b70173b0ea045398f984bf5ebbb3804736ce1330c9d"
+checksum = "c3ac9f8b63eca6fd385229b3675f6cc0dc5c8a5c8a54a59d4f52ffd670d87b0c"
 
 [[package]]
 name = "byte-tools"
@@ -1110,9 +1109,9 @@ checksum = "e3b5ca7a04898ad4bcd41c90c5285445ff5b791899bb1b0abdd2a2aa791211d7"
 
 [[package]]
 name = "bytemuck"
-version = "1.22.0"
+version = "1.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6b1fc10dbac614ebc03540c9dbd60e83887fda27794998c6528f1782047d540"
+checksum = "94bbb0ad554ad961ddc5da507a12a29b14e4ae5bda06b19f575a3e6079d2e2ae"
 
 [[package]]
 name = "byteorder"
@@ -1122,17 +1121,18 @@ checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 
 [[package]]
 name = "bytes"
-version = "1.10.1"
+version = "1.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a"
+checksum = "428d9aa8fbc0670b7b8d6030a7fadd0f86151cae55e4dbbece15f3780a3dfaf3"
 
 [[package]]
 name = "bzip2-sys"
-version = "0.1.13+1.0.8"
+version = "0.1.11+1.0.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "225bff33b2141874fe80d71e07d6eec4f85c5c216453dd96388240f96e1acc14"
+checksum = "736a955f3fa7875102d57c82b8cac37ec45224a07fd32d58f9f7a186b6cd4cdc"
 dependencies = [
  "cc",
+ "libc",
  "pkg-config",
 ]
 
@@ -1157,9 +1157,9 @@ dependencies = [
 
 [[package]]
 name = "cargo-platform"
-version = "0.1.9"
+version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e35af189006b9c0f00a064685c727031e3ed2d8020f7ba284d78cc2671bd36ea"
+checksum = "24b1f0365a6c6bb4020cd05806fd0d33c44d38046b8bd7f0e40814b9763cabfc"
 dependencies = [
  "serde",
 ]
@@ -1172,10 +1172,10 @@ checksum = "eee4243f1f26fc7a42710e7439c149e2b10b05472f88090acce52632f231a73a"
 dependencies = [
  "camino",
  "cargo-platform",
- "semver 1.0.26",
+ "semver 1.0.23",
  "serde",
  "serde_json",
- "thiserror 1.0.69",
+ "thiserror",
 ]
 
 [[package]]
@@ -1186,9 +1186,9 @@ checksum = "fd6c0e7b807d60291f42f33f58480c0bfafe28ed08286446f45e463728cf9c1c"
 
 [[package]]
 name = "cc"
-version = "1.2.18"
+version = "1.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "525046617d8376e3db1deffb079e91cef90a89fc3ca5c185bbf8c9ecdd15cd5c"
+checksum = "be714c154be609ec7f5dad223a33bf1482fff90472de28f7362806e6d4832b8c"
 dependencies = [
  "jobserver",
  "libc",
@@ -1261,9 +1261,9 @@ dependencies = [
 
 [[package]]
 name = "chrono"
-version = "0.4.40"
+version = "0.4.38"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a7964611d71df112cb1730f2ee67324fcf4d0fc6606acbbe9bfe06df124637c"
+checksum = "a21f936df1771bf62b77f047b726c4625ff2e8aa607c01ec06e5a05bd8463401"
 dependencies = [
  "android-tzdata",
  "iana-time-zone",
@@ -1271,7 +1271,7 @@ dependencies = [
  "num-traits",
  "serde",
  "wasm-bindgen",
- "windows-link",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -1333,9 +1333,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.35"
+version = "4.5.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8aa86934b44c19c50f87cc2790e19f54f7a67aedb64101c2e1a2e5ecfb73944"
+checksum = "7be5744db7978a28d9df86a214130d106a89ce49644cbc4e3f0c22c3fba30615"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -1343,9 +1343,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.35"
+version = "4.5.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2414dbb2dd0695280da6ea9261e327479e9d37b0630f6b53ba2a11c60c679fd9"
+checksum = "a5fbc17d3ef8278f55b282b2a2e75ae6f6c7d4bb70ed3d0382375104bfafdb4b"
 dependencies = [
  "anstream",
  "anstyle",
@@ -1356,38 +1356,37 @@ dependencies = [
 
 [[package]]
 name = "clap_derive"
-version = "4.5.32"
+version = "4.5.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09176aae279615badda0765c0c0b3f6ed53f4709118af73cf4655d85d1530cd7"
+checksum = "4ac6a0c7b1a9e9a5186361f67dfa1b88213572f427fb9ab038efb2bd8c582dab"
 dependencies = [
  "heck 0.5.0",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
 name = "clap_lex"
-version = "0.7.4"
+version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f46ad14479a25103f283c0f10005961cf086d8dc42205bb44c46ac563475dca6"
+checksum = "1462739cb27611015575c0c11df5df7601141071f07518d56fcc1be504cbec97"
 
 [[package]]
 name = "codespan-reporting"
-version = "0.12.0"
+version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe6d2e5af09e8c8ad56c969f2157a3d4238cebc7c55f0a517728c38f7b200f81"
+checksum = "3538270d33cc669650c4b093848450d380def10c331d38c768e34cac80576e6e"
 dependencies = [
- "serde",
  "termcolor",
  "unicode-width",
 ]
 
 [[package]]
 name = "colorchoice"
-version = "1.0.3"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b63caa9aa9397e2d9480a9b13673856c78d8ac123288526c37d7839f2a86990"
+checksum = "d3fd119d74b830634cea2a0f58bbd0d54540518a14397557951e79340abc28c0"
 
 [[package]]
 name = "combine"
@@ -1401,11 +1400,12 @@ dependencies = [
 
 [[package]]
 name = "comfy-table"
-version = "7.1.4"
+version = "7.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a65ebfec4fb190b6f90e944a817d60499ee0744e582530e2c9900a22e591d9a"
+checksum = "b34115915337defe99b2aff5c2ce6771e5fbc4079f4b506301f5cf394c8452f7"
 dependencies = [
- "unicode-segmentation",
+ "strum 0.26.3",
+ "strum_macros 0.26.4",
  "unicode-width",
 ]
 
@@ -1426,15 +1426,15 @@ dependencies = [
 
 [[package]]
 name = "console"
-version = "0.15.11"
+version = "0.15.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "054ccb5b10f9f2cbf51eb355ca1d05c2d279ce1804688d0db74b4733a5aeafd8"
+checksum = "0e1f83fc076bd6dd27517eacdf25fef6c4dfe5f1d7448bafaaf3a26f13b5e4eb"
 dependencies = [
  "encode_unicode",
+ "lazy_static",
  "libc",
- "once_cell",
  "unicode-width",
- "windows-sys 0.59.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -1476,26 +1476,6 @@ dependencies = [
  "tiny-keccak",
 ]
 
-[[package]]
-name = "const_format"
-version = "0.2.34"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "126f97965c8ad46d6d9163268ff28432e8f6a1196a55578867832e3049df63dd"
-dependencies = [
- "const_format_proc_macros",
-]
-
-[[package]]
-name = "const_format_proc_macros"
-version = "0.2.34"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d57c2eccfb16dbac1f4e61e206105db5820c9d26c3c472bc17c774259ef7744"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-xid",
-]
-
 [[package]]
 name = "constant_time_eq"
 version = "0.3.1"
@@ -1550,9 +1530,9 @@ dependencies = [
 
 [[package]]
 name = "cpufeatures"
-version = "0.2.17"
+version = "0.2.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+checksum = "608697df725056feaccfa42cffdaeeec3fccc4ffc38358ecd19b243e716a78e0"
 dependencies = [
  "libc",
 ]
@@ -1681,9 +1661,9 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-deque"
-version = "0.8.6"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
+checksum = "613f8cc01fe9cf1a3eb3d7f488fd2fa8388403e97039e2f73692932e291a770d"
 dependencies = [
  "crossbeam-epoch",
  "crossbeam-utils",
@@ -1709,15 +1689,15 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-utils"
-version = "0.8.21"
+version = "0.8.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+checksum = "22ec99545bb0ed0ea7bb9b8e1e9122ea386ff8a48c0922e43f36d45ab09e0e80"
 
 [[package]]
 name = "crunchy"
-version = "0.2.3"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43da5946c66ffcc7745f48db692ffbb10a83bfe0afd96235c5c2a4fb23994929"
+checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
 
 [[package]]
 name = "crypto-bigint"
@@ -1739,7 +1719,7 @@ checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
 dependencies = [
  "generic-array 0.14.7",
  "rand_core 0.6.4",
- "typenum 1.18.0",
+ "typenum 1.17.0",
 ]
 
 [[package]]
@@ -1795,73 +1775,58 @@ checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
 name = "cxx"
-version = "1.0.153"
+version = "1.0.128"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b4ab2681454aacfe7ce296ebc6df86791009f237f8020b0c752e8b245ba7c1d"
+checksum = "54ccead7d199d584d139148b04b4a368d1ec7556a1d9ea2548febb1b9d49f9a4"
 dependencies = [
  "cc",
- "cxxbridge-cmd",
  "cxxbridge-flags",
  "cxxbridge-macro",
- "foldhash",
  "link-cplusplus",
 ]
 
 [[package]]
 name = "cxx-build"
-version = "1.0.153"
+version = "1.0.128"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e431f7ba795550f2b11c32509b3b35927d899f0ad13a1d1e030a317a08facbe"
+checksum = "c77953e99f01508f89f55c494bfa867171ef3a6c8cea03d26975368f2121a5c1"
 dependencies = [
  "cc",
  "codespan-reporting",
+ "once_cell",
  "proc-macro2",
  "quote",
  "scratch",
- "syn 2.0.100",
-]
-
-[[package]]
-name = "cxxbridge-cmd"
-version = "1.0.153"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7cbc41933767955d04c2a90151806029b93df5fd8b682ba22a967433347480a9"
-dependencies = [
- "clap",
- "codespan-reporting",
- "proc-macro2",
- "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
 name = "cxxbridge-flags"
-version = "1.0.153"
+version = "1.0.128"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9133547634329a5b76e5f58d1e53c16d627699bbcd421b9007796311165f9667"
+checksum = "65777e06cc48f0cb0152024c77d6cf9e4bdb4408e7b48bea993d42fa0f5b02b6"
 
 [[package]]
 name = "cxxbridge-macro"
-version = "1.0.153"
+version = "1.0.128"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53e89d77ad5fd6066a3d42d94de3f72a2f23f95006da808177624429b5183596"
+checksum = "98532a60dedaebc4848cb2cba5023337cc9ea3af16a5b062633fabfd9f18fb60"
 dependencies = [
  "proc-macro2",
  "quote",
- "rustversion",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
 name = "darling"
-version = "0.20.11"
+version = "0.20.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc7f46116c46ff9ab3eb1597a45688b6715c6e628b5c133e288e709a29bcb4ee"
+checksum = "6f63b86c8a8826a49b8c21f08a2d07338eec8d900540f8630dc76284be802989"
 dependencies = [
  "darling_core",
  "darling_macro",
@@ -1869,27 +1834,27 @@ dependencies = [
 
 [[package]]
 name = "darling_core"
-version = "0.20.11"
+version = "0.20.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d00b9596d185e565c2207a0b01f8bd1a135483d02d9b7b0a54b11da8d53412e"
+checksum = "95133861a8032aaea082871032f5815eb9e98cef03fa916ab4500513994df9e5"
 dependencies = [
  "fnv",
  "ident_case",
  "proc-macro2",
  "quote",
  "strsim",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
 name = "darling_macro"
-version = "0.20.11"
+version = "0.20.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc34b93ccb385b40dc71c6fceac4b2ad23662c7eeb248cf10d529b7e055b6ead"
+checksum = "d336a2a514f6ccccaa3e09b02d41d35330c07ddf03a62165fcec10bb561c7806"
 dependencies = [
  "darling_core",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -1907,15 +1872,15 @@ dependencies = [
 
 [[package]]
 name = "data-encoding"
-version = "2.8.0"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "575f75dfd25738df5b91b8e43e14d44bda14637a58fae779fd2b064f8bf3e010"
+checksum = "e8566979429cf69b49a5c740c60791108e86440e8be149bbea4fe54d2c32d6e2"
 
 [[package]]
 name = "data-encoding-macro"
-version = "0.1.17"
+version = "0.1.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f9724adfcf41f45bf652b3995837669d73c4d49a1b5ac1ff82905ac7d9b5558"
+checksum = "f1559b6cba622276d6d63706db152618eeb15b89b3e4041446b05876e352e639"
 dependencies = [
  "data-encoding",
  "data-encoding-macro-internal",
@@ -1923,12 +1888,12 @@ dependencies = [
 
 [[package]]
 name = "data-encoding-macro-internal"
-version = "0.1.15"
+version = "0.1.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "18e4fdb82bd54a12e42fb58a800dcae6b9e13982238ce2296dc3570b92148e1f"
+checksum = "332d754c0af53bc87c108fed664d121ecf59207ec4196041f04d6ab9002ad33f"
 dependencies = [
  "data-encoding",
- "syn 2.0.100",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -1971,9 +1936,9 @@ dependencies = [
 
 [[package]]
 name = "deranged"
-version = "0.4.1"
+version = "0.3.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28cfac68e08048ae1883171632c2aef3ebc555621ae56fbccce1cbf22dd7f058"
+checksum = "b42b6fa04a440b495c8b04d0e71b707c585f83cb9cb28cf8cd0d976c315e31b4"
 dependencies = [
  "powerfmt",
  "serde",
@@ -1998,29 +1963,20 @@ checksum = "d65d7ce8132b7c0e54497a4d9a55a1c2a0912a0d786cf894472ba818fba45762"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
 name = "derive_more"
-version = "0.99.19"
+version = "0.99.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3da29a38df43d6f156149c9b43ded5e018ddff2a855cf2cfd62e8cd7d079c69f"
+checksum = "5f33878137e4dafd7fa914ad4e259e18a4e8e532b9617a2d0150262bf53abfce"
 dependencies = [
  "convert_case",
  "proc-macro2",
  "quote",
  "rustc_version 0.4.1",
- "syn 2.0.100",
-]
-
-[[package]]
-name = "derive_more"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a9b99b9cbbe49445b21764dc0625032a89b145a2642e67603e1c936f5458d05"
-dependencies = [
- "derive_more-impl 1.0.0",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -2029,18 +1985,7 @@ version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "093242cf7570c207c83073cf82f79706fe7b8317e98620a47d5be7c3d8497678"
 dependencies = [
- "derive_more-impl 2.0.1",
-]
-
-[[package]]
-name = "derive_more-impl"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb7330aeadfbe296029522e6c40f315320aba36fc43a5b3632f3795348f3bd22"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.100",
+ "derive_more-impl",
 ]
 
 [[package]]
@@ -2051,7 +1996,7 @@ checksum = "bda628edc44c4bb645fbe0f758797143e4e07926f7ebf4e9bdfbd3d2ce621df3"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
  "unicode-xid",
 ]
 
@@ -2141,23 +2086,23 @@ checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
 name = "docify"
-version = "0.2.9"
+version = "0.2.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a772b62b1837c8f060432ddcc10b17aae1453ef17617a99bc07789252d2a5896"
+checksum = "43a2f138ad521dc4a2ced1a4576148a6a610b4c5923933b062a263130a6802ce"
 dependencies = [
  "docify_macros",
 ]
 
 [[package]]
 name = "docify_macros"
-version = "0.2.9"
+version = "0.2.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "60e6be249b0a462a14784a99b19bf35a667bb5e09de611738bb7362fa4c95ff7"
+checksum = "1a081e51fb188742f5a7a1164ad752121abcb22874b21e2c3b0dd040c515fdad"
 dependencies = [
  "common-path",
  "derive-syn-parse",
@@ -2165,9 +2110,9 @@ dependencies = [
  "proc-macro2",
  "quote",
  "regex",
- "syn 2.0.100",
+ "syn 2.0.90",
  "termcolor",
- "toml 0.8.20",
+ "toml 0.8.19",
  "walkdir",
 ]
 
@@ -2185,15 +2130,15 @@ checksum = "1435fa1053d8b2fbbe9be7e97eca7f33d37b28409959813daefc1446a14247f1"
 
 [[package]]
 name = "dtoa"
-version = "1.0.10"
+version = "1.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d6add3b8cff394282be81f3fc1a0605db594ed69890078ca6e2cab1c408bcf04"
+checksum = "dcbb2bf8e87535c23f7a8a321e364ce21462d0ff10cb6407820e8e96dfff6653"
 
 [[package]]
 name = "dyn-clonable"
-version = "0.9.2"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a36efbb9bfd58e1723780aa04b61aba95ace6a05d9ffabfdb0b43672552f0805"
+checksum = "4e9232f0e607a262ceb9bd5141a3dfb3e4db6994b31989bbfd845878cba59fd4"
 dependencies = [
  "dyn-clonable-impl",
  "dyn-clone",
@@ -2201,20 +2146,20 @@ dependencies = [
 
 [[package]]
 name = "dyn-clonable-impl"
-version = "0.9.2"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e8671d54058979a37a26f3511fbf8d198ba1aa35ffb202c42587d918d77213a"
+checksum = "558e40ea573c374cf53507fd240b7ee2f5477df7cfebdb97323ec61c719399c5"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 1.0.109",
 ]
 
 [[package]]
 name = "dyn-clone"
-version = "1.0.19"
+version = "1.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c7a8fb8a9fbf66c1f703fe16184d10ca0ee9d23be5b4436400408ba54a95005"
+checksum = "0d6ef0072f8a535281e4876be788938b528e9a1d43900b82c2569af7da799125"
 
 [[package]]
 name = "ecdsa"
@@ -2273,9 +2218,9 @@ dependencies = [
 
 [[package]]
 name = "either"
-version = "1.15.0"
+version = "1.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0"
 dependencies = [
  "serde",
 ]
@@ -2302,9 +2247,9 @@ dependencies = [
 
 [[package]]
 name = "encode_unicode"
-version = "1.0.0"
+version = "0.3.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0"
+checksum = "a357d28ed41a50f9c765dbfe56cbc04a64e53e5fc58ba79fbc34c10ef3df831f"
 
 [[package]]
 name = "enum-as-inner"
@@ -2327,27 +2272,27 @@ dependencies = [
  "heck 0.5.0",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
 name = "enumflags2"
-version = "0.7.11"
+version = "0.7.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba2f4b465f5318854c6f8dd686ede6c0a9dc67d4b1ac241cf0eb51521a309147"
+checksum = "d232db7f5956f3f14313dc2f87985c58bd2c695ce124c8cdd984e08e15ac133d"
 dependencies = [
  "enumflags2_derive",
 ]
 
 [[package]]
 name = "enumflags2_derive"
-version = "0.7.11"
+version = "0.7.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc4caf64a58d7a6d65ab00639b046ff54399a39f5f2554728895ace4b297cd79"
+checksum = "de0d48a183585823424a4ce1aa132d174a6a81bd540895822eb4c8373a8e49e8"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -2371,18 +2316,18 @@ checksum = "e48c92028aaa870e83d51c64e5d4e0b6981b360c522198c23959f219a4e1b15b"
 
 [[package]]
 name = "equivalent"
-version = "1.0.2"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
 
 [[package]]
 name = "errno"
-version = "0.3.11"
+version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "976dd42dc7e85965fe702eb8164f21f450704bdde31faefd6471dba214cb594e"
+checksum = "534c5cf6194dfab3db3242765c03bbe257cf92f22b38f6bc0c58d59108a820ba"
 dependencies = [
  "libc",
- "windows-sys 0.59.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -2393,9 +2338,9 @@ checksum = "c22d4b5885b6aa2fe5e8b9329fb8d232bf739e434e6b87347c63bdd00c120f60"
 dependencies = [
  "crunchy",
  "fixed-hash",
- "impl-codec 0.6.0",
+ "impl-codec",
  "impl-rlp",
- "impl-serde 0.4.0",
+ "impl-serde",
  "scale-info",
  "tiny-keccak",
 ]
@@ -2426,12 +2371,12 @@ checksum = "02d215cbf040552efcbe99a38372fe80ab9d00268e20012b79fcd0f073edd8ee"
 dependencies = [
  "ethbloom",
  "fixed-hash",
- "impl-codec 0.6.0",
+ "impl-codec",
  "impl-rlp",
- "impl-serde 0.4.0",
- "primitive-types 0.12.2",
+ "impl-serde",
+ "primitive-types",
  "scale-info",
- "uint 0.9.5",
+ "uint",
 ]
 
 [[package]]
@@ -2442,9 +2387,9 @@ checksum = "0206175f82b8d6bf6652ff7d71a1e27fd2e4efde587fd368662814d6ec1d9ce0"
 
 [[package]]
 name = "event-listener"
-version = "5.4.0"
+version = "5.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3492acde4c3fc54c845eaab3eed8bd00c7a7d881f78bfc801e43a93dec1331ae"
+checksum = "6032be9bd27023a771701cc49f9f053c751055f71efb2e0ae5c15809093675ba"
 dependencies = [
  "concurrent-queue",
  "parking",
@@ -2453,11 +2398,11 @@ dependencies = [
 
 [[package]]
 name = "event-listener-strategy"
-version = "0.5.4"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8be9f3dfaaffdae2972880079a491a1a8bb7cbed0b8dd7a347f668b4150a3b93"
+checksum = "0f214dc438f977e6d4e3500aaa277f5ad94ca83fbbd9b1a15713ce2344ccc5a1"
 dependencies = [
- "event-listener 5.4.0",
+ "event-listener 5.3.1",
  "pin-project-lite",
 ]
 
@@ -2475,7 +2420,7 @@ dependencies = [
  "evm-runtime",
  "log",
  "parity-scale-codec",
- "primitive-types 0.12.2",
+ "primitive-types",
  "rlp",
  "scale-info",
  "serde",
@@ -2489,7 +2434,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d1da6cedc5cedb4208e59467106db0d1f50db01b920920589f8e672c02fdc04f"
 dependencies = [
  "parity-scale-codec",
- "primitive-types 0.12.2",
+ "primitive-types",
  "scale-info",
  "serde",
 ]
@@ -2503,7 +2448,7 @@ dependencies = [
  "environmental",
  "evm-core",
  "evm-runtime",
- "primitive-types 0.12.2",
+ "primitive-types",
 ]
 
 [[package]]
@@ -2515,7 +2460,7 @@ dependencies = [
  "auto_impl",
  "environmental",
  "evm-core",
- "primitive-types 0.12.2",
+ "primitive-types",
  "sha3",
 ]
 
@@ -2537,10 +2482,10 @@ dependencies = [
  "blake2 0.10.6",
  "file-guard",
  "fs-err",
- "prettyplease 0.2.31",
+ "prettyplease 0.2.22",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -2557,9 +2502,9 @@ checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649"
 
 [[package]]
 name = "fastrand"
-version = "2.3.0"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
+checksum = "e8c02a5121d4ea3eb16a80748c74f5549a5665e4c21333c6098f283870fbdea6"
 
 [[package]]
 name = "fastrlp"
@@ -2608,7 +2553,7 @@ dependencies = [
  "sp-block-builder",
  "sp-consensus",
  "sp-runtime",
- "thiserror 1.0.69",
+ "thiserror",
 ]
 
 [[package]]
@@ -2714,7 +2659,7 @@ dependencies = [
  "sp-storage 21.0.0",
  "sp-timestamp",
  "substrate-prometheus-endpoint",
- "thiserror 1.0.69",
+ "thiserror",
  "tokio",
 ]
 
@@ -2757,14 +2702,14 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e182f7dbc2ef73d9ef67351c5fbbea084729c48362d3ce9dd44c28e32e277fe5"
 dependencies = [
  "libc",
- "thiserror 1.0.69",
+ "thiserror",
 ]
 
 [[package]]
 name = "ff"
-version = "0.13.1"
+version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0b50bfb653653f9ca9095b427bed08ab8d75a137839d9ad64eb11810d5b6393"
+checksum = "ded41244b729663b1e574f1b4fb731469f69f79c17667b5d776b16cda0479449"
 dependencies = [
  "rand_core 0.6.4",
  "subtle 2.6.1",
@@ -2810,9 +2755,9 @@ dependencies = [
 
 [[package]]
 name = "finality-grandpa"
-version = "0.16.3"
+version = "0.16.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4f8f43dc520133541781ec03a8cab158ae8b7f7169cdf22e9050aa6cf0fbdfc"
+checksum = "36530797b9bf31cd4ff126dcfee8170f86b00cfdcea3269d73133cc0415945c3"
 dependencies = [
  "either",
  "futures",
@@ -2913,7 +2858,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8835f84f38484cc86f110a805655697908257fb9a7af005234060891557198e9"
 dependencies = [
  "nonempty",
- "thiserror 1.0.69",
+ "thiserror",
 ]
 
 [[package]]
@@ -2922,7 +2867,7 @@ version = "1.0.0-dev"
 source = "git+https://github.com/opentensor/frontier?rev=635bdac882#635bdac882333afed827053f31ef56ab739f7a2e"
 dependencies = [
  "hex",
- "impl-serde 0.4.0",
+ "impl-serde",
  "libsecp256k1",
  "log",
  "parity-scale-codec",
@@ -3012,9 +2957,9 @@ dependencies = [
 
 [[package]]
 name = "fragile"
-version = "2.0.1"
+version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28dd6caf6059519a65843af8fe2a3ae298b14b80179855aeb4adc2c1934ee619"
+checksum = "6c2141d6d6c8512188a7891b4b01590a45f6dac67afb4f255c4124dbb86d4eaa"
 
 [[package]]
 name = "frame-benchmarking"
@@ -3086,7 +3031,7 @@ dependencies = [
  "sp-storage 21.0.0",
  "sp-trie",
  "sp-wasm-interface 21.0.1",
- "thiserror 1.0.69",
+ "thiserror",
  "thousands",
 ]
 
@@ -3189,11 +3134,11 @@ dependencies = [
  "frame-support-procedural-tools 13.0.0",
  "itertools 0.11.0",
  "macro_magic",
- "proc-macro-warning 1.84.1",
+ "proc-macro-warning 1.0.2",
  "proc-macro2",
  "quote",
  "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409)",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -3203,10 +3148,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3363df38464c47a73eb521a4f648bfcc7537a82d70347ef8af3f73b6d019e910"
 dependencies = [
  "frame-support-procedural-tools-derive 11.0.0",
- "proc-macro-crate 3.3.0",
+ "proc-macro-crate 3.2.0",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -3215,10 +3160,10 @@ version = "13.0.0"
 source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409#87971b3e92721bdf10bf40b410eaae779d494ca0"
 dependencies = [
  "frame-support-procedural-tools-derive 12.0.0",
- "proc-macro-crate 3.3.0",
+ "proc-macro-crate 3.2.0",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -3229,7 +3174,7 @@ checksum = "68672b9ec6fe72d259d3879dc212c5e42e977588cdac830c76f54d9f492aeb58"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -3239,7 +3184,7 @@ source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -3394,9 +3339,9 @@ checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6"
 
 [[package]]
 name = "futures-lite"
-version = "2.6.0"
+version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f5edaec856126859abb19ed65f39e90fea3a9574b9707f13539acf4abf7eb532"
+checksum = "52527eb5074e35e9339c6b4e8d12600c7128b68fb25dcb9fa9dec18f7c25f3a5"
 dependencies = [
  "futures-core",
  "pin-project-lite",
@@ -3410,7 +3355,7 @@ checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -3474,7 +3419,7 @@ version = "0.12.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ffdf9f34f1447443d37393cc6c2b8313aebddcd96906caf34e54c68d8e57d7bd"
 dependencies = [
- "typenum 1.18.0",
+ "typenum 1.17.0",
 ]
 
 [[package]]
@@ -3483,7 +3428,7 @@ version = "0.14.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
 dependencies = [
- "typenum 1.18.0",
+ "typenum 1.17.0",
  "version_check",
  "zeroize",
 ]
@@ -3564,15 +3509,15 @@ dependencies = [
 
 [[package]]
 name = "gimli"
-version = "0.31.1"
+version = "0.31.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07e28edb80900c19c28f1072f2e8aeca7fa06b23cd4169cefe1af5aa3260783f"
+checksum = "32085ea23f3234fc7846555e85283ba4de91e21016dc0455a16286d87a292d64"
 
 [[package]]
 name = "glob"
-version = "0.3.2"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8d1add55171497b4705a648c6b583acafb01d58050a51727785f0b2c8e0a2b2"
+checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"
 
 [[package]]
 name = "governor"
@@ -3617,7 +3562,7 @@ dependencies = [
  "futures-sink",
  "futures-util",
  "http 0.2.12",
- "indexmap 2.8.0",
+ "indexmap 2.6.0",
  "slab",
  "tokio",
  "tokio-util",
@@ -3626,17 +3571,17 @@ dependencies = [
 
 [[package]]
 name = "h2"
-version = "0.4.8"
+version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5017294ff4bb30944501348f6f8e42e6ad28f42c8bbef7a74029aff064a4e3c2"
+checksum = "524e8ac6999421f49a846c2d4411f337e53497d8ec55d67753beffa43c5d9205"
 dependencies = [
  "atomic-waker",
  "bytes",
  "fnv",
  "futures-core",
  "futures-sink",
- "http 1.3.1",
- "indexmap 2.8.0",
+ "http 1.1.0",
+ "indexmap 2.6.0",
  "slab",
  "tokio",
  "tokio-util",
@@ -3660,7 +3605,7 @@ dependencies = [
  "pest_derive",
  "serde",
  "serde_json",
- "thiserror 1.0.69",
+ "thiserror",
 ]
 
 [[package]]
@@ -3728,11 +3673,11 @@ dependencies = [
 
 [[package]]
 name = "hashlink"
-version = "0.10.0"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7382cf6263419f2d8df38c55d7da83da5c18aef87fc7a7fc1fb1e344edfe14c1"
+checksum = "6ba4ff7128dee98c7dc9794b6a411377e1404dba1c97deb8d1a55297bd25d8af"
 dependencies = [
- "hashbrown 0.15.2",
+ "hashbrown 0.14.5",
 ]
 
 [[package]]
@@ -3759,12 +3704,6 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fbf6a919d6cf397374f7dfeeea91d974c7c0a7221d0d0f4f20d859d329e53fcc"
 
-[[package]]
-name = "hermit-abi"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fbd780fe5cc30f81464441920d82ac8740e2e46b29a6fad543ddd075229ce37e"
-
 [[package]]
 name = "hex"
 version = "0.4.3"
@@ -3827,22 +3766,22 @@ dependencies = [
 
 [[package]]
 name = "home"
-version = "0.5.11"
+version = "0.5.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "589533453244b0995c858700322199b2becb13b627df2851f64a2775d024abcf"
+checksum = "e3d1354bf6b7235cb4a0576c2619fd4ed18183f689b12b006a0ee7329eeff9a5"
 dependencies = [
- "windows-sys 0.59.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "hostname"
-version = "0.4.0"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f9c7c7c8ac16c798734b8a24560c1362120597c40d5e1459f09498f8f6c8f2ba"
+checksum = "3c731c3e10504cc8ed35cfe2f1db4c9274c3d35fa486e3b31df46f068ef3e867"
 dependencies = [
- "cfg-if",
  "libc",
- "windows 0.52.0",
+ "match_cfg",
+ "winapi",
 ]
 
 [[package]]
@@ -3858,9 +3797,9 @@ dependencies = [
 
 [[package]]
 name = "http"
-version = "1.3.1"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4a85d31aea989eead29a3aaf9e1115a180df8282431156e533de47660892565"
+checksum = "21b9ddb458710bc376481b842f5da65cdf31522de232c1ca8146abce2a358258"
 dependencies = [
  "bytes",
  "fnv",
@@ -3885,27 +3824,27 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184"
 dependencies = [
  "bytes",
- "http 1.3.1",
+ "http 1.1.0",
 ]
 
 [[package]]
 name = "http-body-util"
-version = "0.1.3"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b021d93e26becf5dc7e1b75b1bed1fd93124b374ceb73f43d4d4eafec896a64a"
+checksum = "793429d76616a256bcb62c2a2ec2bed781c8307e797e2598c50010f2bee2544f"
 dependencies = [
  "bytes",
- "futures-core",
- "http 1.3.1",
+ "futures-util",
+ "http 1.1.0",
  "http-body 1.0.1",
  "pin-project-lite",
 ]
 
 [[package]]
 name = "httparse"
-version = "1.10.1"
+version = "1.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
+checksum = "7d71d3574edd2771538b901e6549113b4006ece66150fb69c0fb6d9a2adae946"
 
 [[package]]
 name = "httpdate"
@@ -3915,15 +3854,15 @@ checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
 
 [[package]]
 name = "humantime"
-version = "2.2.0"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b112acc8b3adf4b107a8ec20977da0273a8c386765a3ec0229bd500a1443f9f"
+checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
 
 [[package]]
 name = "hyper"
-version = "0.14.32"
+version = "0.14.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41dfc780fdec9373c01bae43289ea34c972e40ee3c9f6b3c8801a35f35586ce7"
+checksum = "a152ddd61dfaec7273fe8419ab357f33aee0d914c5f4efbf0d96fa749eea5ec9"
 dependencies = [
  "bytes",
  "futures-channel",
@@ -3936,7 +3875,7 @@ dependencies = [
  "httpdate",
  "itoa",
  "pin-project-lite",
- "socket2 0.5.9",
+ "socket2 0.5.7",
  "tokio",
  "tower-service",
  "tracing",
@@ -3945,15 +3884,15 @@ dependencies = [
 
 [[package]]
 name = "hyper"
-version = "1.6.0"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc2b571658e38e0c01b1fdca3bbbe93c00d3d71693ff2770043f8c29bc7d6f80"
+checksum = "bbbff0a806a4728c99295b254c8838933b5b082d75e3cb70c8dab21fdfbcfa9a"
 dependencies = [
  "bytes",
  "futures-channel",
  "futures-util",
- "h2 0.4.8",
- "http 1.3.1",
+ "h2 0.4.6",
+ "http 1.1.0",
  "http-body 1.0.1",
  "httparse",
  "httpdate",
@@ -3971,7 +3910,7 @@ checksum = "ec3efd23720e2049821a693cbc7e65ea87c72f1c58ff2f9522ff332b1491e590"
 dependencies = [
  "futures-util",
  "http 0.2.12",
- "hyper 0.14.32",
+ "hyper 0.14.30",
  "log",
  "rustls 0.21.12",
  "rustls-native-certs",
@@ -3981,15 +3920,15 @@ dependencies = [
 
 [[package]]
 name = "hyper-util"
-version = "0.1.11"
+version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "497bbc33a26fdd4af9ed9c70d63f61cf56a938375fbb32df34db9b1cd6d643f2"
+checksum = "df2dcfbe0677734ab2f3ffa7fa7bfd4706bfdc1ef393f2ee30184aed67e631b4"
 dependencies = [
  "bytes",
  "futures-util",
- "http 1.3.1",
+ "http 1.1.0",
  "http-body 1.0.1",
- "hyper 1.6.0",
+ "hyper 1.5.0",
  "pin-project-lite",
  "tokio",
  "tower-service",
@@ -3997,17 +3936,16 @@ dependencies = [
 
 [[package]]
 name = "iana-time-zone"
-version = "0.1.63"
+version = "0.1.61"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0c919e5debc312ad217002b8048a17b7d83f80703865bbfcfebb0458b0b27d8"
+checksum = "235e081f3925a06703c2d0117ea8b91f042756fd6e7a6e5d901e8ca1a996b220"
 dependencies = [
  "android_system_properties",
  "core-foundation-sys",
  "iana-time-zone-haiku",
  "js-sys",
- "log",
  "wasm-bindgen",
- "windows-core 0.61.0",
+ "windows-core 0.52.0",
 ]
 
 [[package]]
@@ -4019,124 +3957,6 @@ dependencies = [
  "cc",
 ]
 
-[[package]]
-name = "icu_collections"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db2fa452206ebee18c4b5c2274dbf1de17008e874b4dc4f0aea9d01ca79e4526"
-dependencies = [
- "displaydoc",
- "yoke",
- "zerofrom",
- "zerovec",
-]
-
-[[package]]
-name = "icu_locid"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13acbb8371917fc971be86fc8057c41a64b521c184808a698c02acc242dbf637"
-dependencies = [
- "displaydoc",
- "litemap",
- "tinystr",
- "writeable",
- "zerovec",
-]
-
-[[package]]
-name = "icu_locid_transform"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "01d11ac35de8e40fdeda00d9e1e9d92525f3f9d887cdd7aa81d727596788b54e"
-dependencies = [
- "displaydoc",
- "icu_locid",
- "icu_locid_transform_data",
- "icu_provider",
- "tinystr",
- "zerovec",
-]
-
-[[package]]
-name = "icu_locid_transform_data"
-version = "1.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7515e6d781098bf9f7205ab3fc7e9709d34554ae0b21ddbcb5febfa4bc7df11d"
-
-[[package]]
-name = "icu_normalizer"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19ce3e0da2ec68599d193c93d088142efd7f9c5d6fc9b803774855747dc6a84f"
-dependencies = [
- "displaydoc",
- "icu_collections",
- "icu_normalizer_data",
- "icu_properties",
- "icu_provider",
- "smallvec",
- "utf16_iter",
- "utf8_iter",
- "write16",
- "zerovec",
-]
-
-[[package]]
-name = "icu_normalizer_data"
-version = "1.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c5e8338228bdc8ab83303f16b797e177953730f601a96c25d10cb3ab0daa0cb7"
-
-[[package]]
-name = "icu_properties"
-version = "1.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93d6020766cfc6302c15dbbc9c8778c37e62c14427cb7f6e601d849e092aeef5"
-dependencies = [
- "displaydoc",
- "icu_collections",
- "icu_locid_transform",
- "icu_properties_data",
- "icu_provider",
- "tinystr",
- "zerovec",
-]
-
-[[package]]
-name = "icu_properties_data"
-version = "1.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85fb8799753b75aee8d2a21d7c14d9f38921b54b3dbda10f5a3c7a7b82dba5e2"
-
-[[package]]
-name = "icu_provider"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ed421c8a8ef78d3e2dbc98a973be2f3770cb42b606e3ab18d6237c4dfde68d9"
-dependencies = [
- "displaydoc",
- "icu_locid",
- "icu_provider_macros",
- "stable_deref_trait",
- "tinystr",
- "writeable",
- "yoke",
- "zerofrom",
- "zerovec",
-]
-
-[[package]]
-name = "icu_provider_macros"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ec89e9337638ecdc08744df490b221a7399bf8d164eb52a665454e60e075ad6"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.100",
-]
-
 [[package]]
 name = "ident_case"
 version = "1.0.1"
@@ -4166,23 +3986,12 @@ dependencies = [
 
 [[package]]
 name = "idna"
-version = "1.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "686f825264d630750a544639377bae737628043f20d38bbc029e8f29ea968a7e"
-dependencies = [
- "idna_adapter",
- "smallvec",
- "utf8_iter",
-]
-
-[[package]]
-name = "idna_adapter"
-version = "1.2.0"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "daca1df1c957320b2cf139ac61e7bd64fed304c5040df000a745aa1de3b4ef71"
+checksum = "634d9b1461af396cad843f47fdba5597a4f9e6ddd4bfb6ff5d85028c25cb12f6"
 dependencies = [
- "icu_normalizer",
- "icu_properties",
+ "unicode-bidi",
+ "unicode-normalization",
 ]
 
 [[package]]
@@ -4197,9 +4006,9 @@ dependencies = [
 
 [[package]]
 name = "if-watch"
-version = "3.2.1"
+version = "3.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cdf9d64cfcf380606e64f9a0bcf493616b65331199f984151a6fa11a7b3cde38"
+checksum = "d6b0422c86d7ce0e97169cc42e04ae643caf278874a7a3c87b8150a220dc7e1e"
 dependencies = [
  "async-io",
  "core-foundation",
@@ -4208,14 +4017,10 @@ dependencies = [
  "if-addrs",
  "ipnet",
  "log",
- "netlink-packet-core",
- "netlink-packet-route",
- "netlink-proto",
- "netlink-sys",
  "rtnetlink",
  "system-configuration",
  "tokio",
- "windows 0.53.0",
+ "windows",
 ]
 
 [[package]]
@@ -4229,7 +4034,7 @@ dependencies = [
  "bytes",
  "futures",
  "http 0.2.12",
- "hyper 0.14.32",
+ "hyper 0.14.30",
  "log",
  "rand 0.8.5",
  "tokio",
@@ -4246,26 +4051,6 @@ dependencies = [
  "parity-scale-codec",
 ]
 
-[[package]]
-name = "impl-codec"
-version = "0.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2d40b9d5e17727407e55028eafc22b2dc68781786e6d7eb8a21103f5058e3a14"
-dependencies = [
- "parity-scale-codec",
-]
-
-[[package]]
-name = "impl-num-traits"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "803d15461ab0dcc56706adf266158acbc44ccf719bf7d0af30705f58b90a4b8c"
-dependencies = [
- "integer-sqrt",
- "num-traits",
- "uint 0.10.0",
-]
-
 [[package]]
 name = "impl-rlp"
 version = "0.3.0"
@@ -4284,24 +4069,15 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "impl-serde"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a143eada6a1ec4aefa5049037a26a6d597bfd64f8c026d07b77133e02b7dd0b"
-dependencies = [
- "serde",
-]
-
 [[package]]
 name = "impl-trait-for-tuples"
-version = "0.2.3"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a0eb5a3343abf848c0984fe4604b2b105da9539376e24fc0a3b0007411ae4fd9"
+checksum = "11d7a9f6330b71fea57921c9b61c47ee6e84f72d394754eff6163ae67e7395eb"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -4336,9 +4112,9 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "2.8.0"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3954d50fe15b02142bf25d3b8bdadb634ec3948f103d04ffe3031bc8fe9d7058"
+checksum = "707907fe3c25f5424cce2cb7e1cbcafee6bdbe735ca90ef77c29e84591e5b9da"
 dependencies = [
  "equivalent",
  "hashbrown 0.15.2",
@@ -4346,9 +4122,9 @@ dependencies = [
 
 [[package]]
 name = "inout"
-version = "0.1.4"
+version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01"
+checksum = "a0c10553d664a4d0bcff9f4215d0aac67a639cc68ef660840afe309b807bc9f5"
 dependencies = [
  "generic-array 0.14.7",
 ]
@@ -4394,7 +4170,7 @@ version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b58db92f96b720de98181bbbe63c831e87005ab460c1bf306eb2622b4707997f"
 dependencies = [
- "socket2 0.5.9",
+ "socket2 0.5.7",
  "widestring",
  "windows-sys 0.48.0",
  "winreg",
@@ -4402,19 +4178,19 @@ dependencies = [
 
 [[package]]
 name = "ipnet"
-version = "2.11.0"
+version = "2.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "469fb0b9cefa57e3ef31275ee7cacb78f2fdca44e4765491884a2b119d4eb130"
+checksum = "187674a687eed5fe42285b40c6291f9a01517d415fad1c3cbc6a9f778af7fcd4"
 
 [[package]]
 name = "is-terminal"
-version = "0.4.16"
+version = "0.4.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e04d7f318608d35d4b61ddd75cbdaee86b023ebe2bd5a66ee0915f0bf93095a9"
+checksum = "261f68e344040fbd0edea105bef17c66edf46f984ddb1115b775ce31be948f4b"
 dependencies = [
- "hermit-abi 0.5.0",
+ "hermit-abi 0.4.0",
  "libc",
- "windows-sys 0.59.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -4452,35 +4228,33 @@ dependencies = [
 
 [[package]]
 name = "itoa"
-version = "1.0.15"
+version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
+checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
 
 [[package]]
 name = "jobserver"
-version = "0.1.33"
+version = "0.1.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38f262f097c174adebe41eb73d66ae9c06b2844fb0da69969647bbddd9b0538a"
+checksum = "48d1dbcbbeb6a7fec7e059840aa538bd62aaccf972c7346c4d9d2059312853d0"
 dependencies = [
- "getrandom 0.3.2",
  "libc",
 ]
 
 [[package]]
 name = "js-sys"
-version = "0.3.77"
+version = "0.3.70"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1cfaf33c695fc6e08064efbc1f72ec937429614f25eef83af942d0e227c3a28f"
+checksum = "1868808506b929d7b0cfa8f75951347aa71bb21144b7791bae35d9bccfcfe37a"
 dependencies = [
- "once_cell",
  "wasm-bindgen",
 ]
 
 [[package]]
 name = "jsonrpsee"
-version = "0.24.9"
+version = "0.24.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37b26c20e2178756451cfeb0661fb74c47dd5988cb7e3939de7e9241fd604d42"
+checksum = "c5c71d8c1a731cc4227c2f698d377e7848ca12c8a48866fc5e6951c43a4db843"
 dependencies = [
  "jsonrpsee-core",
  "jsonrpsee-proc-macros",
@@ -4492,14 +4266,14 @@ dependencies = [
 
 [[package]]
 name = "jsonrpsee-core"
-version = "0.24.9"
+version = "0.24.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "456196007ca3a14db478346f58c7238028d55ee15c1df15115596e411ff27925"
+checksum = "f2882f6f8acb9fdaec7cefc4fd607119a9bd709831df7d7672a1d3b644628280"
 dependencies = [
  "async-trait",
  "bytes",
  "futures-util",
- "http 1.3.1",
+ "http 1.1.0",
  "http-body 1.0.1",
  "http-body-util",
  "jsonrpsee-types",
@@ -4508,35 +4282,35 @@ dependencies = [
  "rustc-hash 2.1.1",
  "serde",
  "serde_json",
- "thiserror 1.0.69",
+ "thiserror",
  "tokio",
  "tracing",
 ]
 
 [[package]]
 name = "jsonrpsee-proc-macros"
-version = "0.24.9"
+version = "0.24.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e65763c942dfc9358146571911b0cd1c361c2d63e2d2305622d40d36376ca80"
+checksum = "c06c01ae0007548e73412c08e2285ffe5d723195bf268bce67b1b77c3bb2a14d"
 dependencies = [
  "heck 0.5.0",
- "proc-macro-crate 3.3.0",
+ "proc-macro-crate 3.2.0",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
 name = "jsonrpsee-server"
-version = "0.24.9"
+version = "0.24.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55e363146da18e50ad2b51a0a7925fc423137a0b1371af8235b1c231a0647328"
+checksum = "82ad8ddc14be1d4290cd68046e7d1d37acd408efed6d3ca08aefcc3ad6da069c"
 dependencies = [
  "futures-util",
- "http 1.3.1",
+ "http 1.1.0",
  "http-body 1.0.1",
  "http-body-util",
- "hyper 1.6.0",
+ "hyper 1.5.0",
  "hyper-util",
  "jsonrpsee-core",
  "jsonrpsee-types",
@@ -4545,7 +4319,7 @@ dependencies = [
  "serde",
  "serde_json",
  "soketto",
- "thiserror 1.0.69",
+ "thiserror",
  "tokio",
  "tokio-stream",
  "tokio-util",
@@ -4555,14 +4329,14 @@ dependencies = [
 
 [[package]]
 name = "jsonrpsee-types"
-version = "0.24.9"
+version = "0.24.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08a8e70baf945b6b5752fc8eb38c918a48f1234daf11355e07106d963f860089"
+checksum = "a178c60086f24cc35bb82f57c651d0d25d99c4742b4d335de04e97fa1f08a8a1"
 dependencies = [
- "http 1.3.1",
+ "http 1.1.0",
  "serde",
  "serde_json",
- "thiserror 1.0.69",
+ "thiserror",
 ]
 
 [[package]]
@@ -4651,15 +4425,15 @@ checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
 
 [[package]]
 name = "libc"
-version = "0.2.171"
+version = "0.2.159"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c19937216e9d3aa9956d9bb8dfc0b0c8beb6058fc4f7a4dc4d850edf86a237d6"
+checksum = "561d97a539a36e26a9a5fad1ea11a3039a67714694aaa379433e580854bc3dc5"
 
 [[package]]
 name = "libloading"
-version = "0.8.6"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc2f4eb4bc735547cfed7c0a4922cbd04a4655978c09b54f1f7b228750664c34"
+checksum = "4979f22fdb869068da03c9f7528f8297c6fd2606bc3a4affe42e6a823fdb8da4"
 dependencies = [
  "cfg-if",
  "windows-targets 0.52.6",
@@ -4667,9 +4441,9 @@ dependencies = [
 
 [[package]]
 name = "libm"
-version = "0.2.11"
+version = "0.2.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8355be11b20d696c8f18f6cc018c4e372165b1fa8126cef092399c9951984ffa"
+checksum = "4ec2a862134d2a7d32d7983ddcdd1c4923530833c9f2ea1a44fc5fa473989058"
 
 [[package]]
 name = "libp2p"
@@ -4705,7 +4479,7 @@ dependencies = [
  "multiaddr 0.18.2",
  "pin-project",
  "rw-stream-sink",
- "thiserror 1.0.69",
+ "thiserror",
 ]
 
 [[package]]
@@ -4746,7 +4520,7 @@ dependencies = [
  "libp2p-identity",
  "log",
  "multiaddr 0.18.2",
- "multihash 0.19.3",
+ "multihash 0.19.2",
  "multistream-select",
  "once_cell",
  "parking_lot 0.12.3",
@@ -4755,7 +4529,7 @@ dependencies = [
  "rand 0.8.5",
  "rw-stream-sink",
  "smallvec",
- "thiserror 1.0.69",
+ "thiserror",
  "unsigned-varint 0.7.2",
  "void",
 ]
@@ -4795,24 +4569,24 @@ dependencies = [
  "quick-protobuf",
  "quick-protobuf-codec",
  "smallvec",
- "thiserror 1.0.69",
+ "thiserror",
  "void",
 ]
 
 [[package]]
 name = "libp2p-identity"
-version = "0.2.10"
+version = "0.2.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "257b5621d159b32282eac446bed6670c39c7dc68a200a992d8f056afa0066f6d"
+checksum = "55cca1eb2bc1fd29f099f3daaab7effd01e1a54b7c577d0ed082521034d912e8"
 dependencies = [
  "bs58 0.5.1",
  "ed25519-dalek",
  "hkdf",
- "multihash 0.19.3",
+ "multihash 0.19.2",
  "quick-protobuf",
  "rand 0.8.5",
  "sha2 0.10.8",
- "thiserror 1.0.69",
+ "thiserror",
  "tracing",
  "zeroize",
 ]
@@ -4840,8 +4614,8 @@ dependencies = [
  "rand 0.8.5",
  "sha2 0.10.8",
  "smallvec",
- "thiserror 1.0.69",
- "uint 0.9.5",
+ "thiserror",
+ "uint",
  "unsigned-varint 0.7.2",
  "void",
 ]
@@ -4861,7 +4635,7 @@ dependencies = [
  "log",
  "rand 0.8.5",
  "smallvec",
- "socket2 0.5.9",
+ "socket2 0.5.7",
  "tokio",
  "trust-dns-proto 0.22.0",
  "void",
@@ -4897,14 +4671,14 @@ dependencies = [
  "libp2p-identity",
  "log",
  "multiaddr 0.18.2",
- "multihash 0.19.3",
+ "multihash 0.19.2",
  "once_cell",
  "quick-protobuf",
  "rand 0.8.5",
  "sha2 0.10.8",
  "snow",
  "static_assertions",
- "thiserror 1.0.69",
+ "thiserror",
  "x25519-dalek",
  "zeroize",
 ]
@@ -4946,8 +4720,8 @@ dependencies = [
  "rand 0.8.5",
  "ring 0.16.20",
  "rustls 0.21.12",
- "socket2 0.5.9",
- "thiserror 1.0.69",
+ "socket2 0.5.7",
+ "thiserror",
  "tokio",
 ]
 
@@ -5002,7 +4776,7 @@ dependencies = [
  "proc-macro-warning 0.4.2",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -5018,7 +4792,7 @@ dependencies = [
  "libp2p-core",
  "libp2p-identity",
  "log",
- "socket2 0.5.9",
+ "socket2 0.5.7",
  "tokio",
 ]
 
@@ -5036,7 +4810,7 @@ dependencies = [
  "ring 0.16.20",
  "rustls 0.21.12",
  "rustls-webpki",
- "thiserror 1.0.69",
+ "thiserror",
  "x509-parser 0.15.1",
  "yasna",
 ]
@@ -5087,7 +4861,7 @@ dependencies = [
  "pin-project-lite",
  "rw-stream-sink",
  "soketto",
- "thiserror 1.0.69",
+ "thiserror",
  "url",
  "webpki-roots",
 ]
@@ -5101,7 +4875,7 @@ dependencies = [
  "futures",
  "libp2p-core",
  "log",
- "thiserror 1.0.69",
+ "thiserror",
  "yamux",
 ]
 
@@ -5111,9 +4885,9 @@ version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.6.0",
  "libc",
- "redox_syscall 0.5.10",
+ "redox_syscall 0.5.7",
 ]
 
 [[package]]
@@ -5147,7 +4921,7 @@ dependencies = [
  "rand 0.8.5",
  "serde",
  "sha2 0.9.9",
- "typenum 1.18.0",
+ "typenum 1.17.0",
 ]
 
 [[package]]
@@ -5192,9 +4966,9 @@ dependencies = [
 
 [[package]]
 name = "libz-sys"
-version = "1.1.22"
+version = "1.1.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b70e7a7df205e92a1a4cd9aaae7898dac0aa555503cc0a649494d0d60e7651d"
+checksum = "d2d16453e800a8cf6dd2fc3eb4bc99b786a9b90c663b8559a5b1a041bf89e472"
 dependencies = [
  "cc",
  "pkg-config",
@@ -5203,9 +4977,9 @@ dependencies = [
 
 [[package]]
 name = "link-cplusplus"
-version = "1.0.10"
+version = "1.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a6f6da007f968f9def0d65a05b187e2960183de70c160204ecfccf0ee330212"
+checksum = "9d240c6f7e1ba3a28b0249f774e6a9dd0175054b52dfbb61b16eb8505c3785c9"
 dependencies = [
  "cc",
 ]
@@ -5218,18 +4992,18 @@ checksum = "0717cef1bc8b636c6e1c1bbdefc09e6322da8a9321966e8928ef80d20f7f770f"
 
 [[package]]
 name = "linked_hash_set"
-version = "0.1.5"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bae85b5be22d9843c80e5fc80e9b64c8a3b1f98f867c709956eca3efff4e92e2"
+checksum = "47186c6da4d81ca383c7c47c1bfc80f4b95f4720514d860a5407aaf4233f9588"
 dependencies = [
  "linked-hash-map",
 ]
 
 [[package]]
 name = "linregress"
-version = "0.5.4"
+version = "0.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9eda9dcf4f2a99787827661f312ac3219292549c2ee992bf9a6248ffb066bf7"
+checksum = "4de04dcecc58d366391f9920245b85ffa684558a5ef6e7736e754347c3aea9c2"
 dependencies = [
  "nalgebra",
 ]
@@ -5242,15 +5016,9 @@ checksum = "f051f77a7c8e6957c0696eac88f26b0117e54f52d3fc682ab19397a8812846a4"
 
 [[package]]
 name = "linux-raw-sys"
-version = "0.4.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab"
-
-[[package]]
-name = "linux-raw-sys"
-version = "0.9.3"
+version = "0.4.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe7db12097d22ec582439daf8618b8fdd1a7bef6270e9af3b1ebcd30893cf413"
+checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89"
 
 [[package]]
 name = "lioness"
@@ -5264,12 +5032,6 @@ dependencies = [
  "keystream",
 ]
 
-[[package]]
-name = "litemap"
-version = "0.7.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23fb14cb19457329c82206317a5663005a4d404783dc74f4252769b0d5f42856"
-
 [[package]]
 name = "litep2p"
 version = "0.6.2"
@@ -5284,7 +5046,7 @@ dependencies = [
  "futures",
  "futures-timer",
  "hex-literal",
- "indexmap 2.8.0",
+ "indexmap 2.6.0",
  "libc",
  "mockall 0.12.1",
  "multiaddr 0.17.1",
@@ -5305,17 +5067,17 @@ dependencies = [
  "simple-dns",
  "smallvec",
  "snow",
- "socket2 0.5.9",
+ "socket2 0.5.7",
  "static_assertions",
  "str0m",
- "thiserror 1.0.69",
+ "thiserror",
  "tokio",
  "tokio-stream",
  "tokio-tungstenite",
  "tokio-util",
  "tracing",
  "trust-dns-resolver",
- "uint 0.9.5",
+ "uint",
  "unsigned-varint 0.8.0",
  "url",
  "webpki",
@@ -5337,9 +5099,9 @@ dependencies = [
 
 [[package]]
 name = "log"
-version = "0.4.27"
+version = "0.4.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"
+checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
 
 [[package]]
 name = "lru"
@@ -5370,9 +5132,9 @@ dependencies = [
 
 [[package]]
 name = "lz4"
-version = "1.28.1"
+version = "1.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a20b523e860d03443e98350ceaac5e71c6ba89aea7d960769ec3ce37f4de5af4"
+checksum = "4d1febb2b4a79ddd1980eede06a8f7902197960aa0383ffcfdd62fe723036725"
 dependencies = [
  "lz4-sys",
 ]
@@ -5405,7 +5167,7 @@ dependencies = [
  "macro_magic_core",
  "macro_magic_macros",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -5419,7 +5181,7 @@ dependencies = [
  "macro_magic_core_macros",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -5430,7 +5192,7 @@ checksum = "b02abfe41815b5bd98dbd4260173db2c116dda171dc0fe7838cb206333b83308"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -5441,9 +5203,15 @@ checksum = "73ea28ee64b88876bf45277ed9a5817c1817df061a74f2b988971a12570e5869"
 dependencies = [
  "macro_magic_core",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
+[[package]]
+name = "match_cfg"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ffbee8634e0d45d258acb448e7eaab3fce7a0a467395d4d9f228e3c1f01fb2e4"
+
 [[package]]
 name = "matchers"
 version = "0.1.0"
@@ -5481,7 +5249,7 @@ version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b2cffa4ad52c6f791f4f8b15f0c05f9824b2ced1160e88cc393d64fff9a8ac64"
 dependencies = [
- "rustix 0.38.44",
+ "rustix 0.38.37",
 ]
 
 [[package]]
@@ -5554,19 +5322,20 @@ checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
 
 [[package]]
 name = "miniz_oxide"
-version = "0.8.7"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff70ce3e48ae43fa075863cef62e8b43b71a4f2382229920e0df362592919430"
+checksum = "e2d80299ef12ff69b16a84bb182e3b9df68b5a91574d3d4fa6e41b65deec4df1"
 dependencies = [
  "adler2",
 ]
 
 [[package]]
 name = "mio"
-version = "1.0.3"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2886843bf800fba2e3377cff24abf6379b4c4d5c6681eaf9ea5b0d15090450bd"
+checksum = "80e04d1dcff3aae0704555fe5fee3bcfaf3d1fdf8a7e521d5b9d2b42acb52cec"
 dependencies = [
+ "hermit-abi 0.3.9",
  "libc",
  "wasi 0.11.0+wasi-snapshot-preview1",
  "windows-sys 0.52.0",
@@ -5593,7 +5362,7 @@ dependencies = [
  "rand_chacha 0.3.1",
  "rand_distr",
  "subtle 2.6.1",
- "thiserror 1.0.69",
+ "thiserror",
  "zeroize",
 ]
 
@@ -5623,7 +5392,7 @@ dependencies = [
  "fragile",
  "lazy_static",
  "mockall_derive 0.12.1",
- "predicates 3.1.3",
+ "predicates 3.1.2",
  "predicates-tree",
 ]
 
@@ -5648,7 +5417,7 @@ dependencies = [
  "cfg-if",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -5681,7 +5450,7 @@ dependencies = [
  "data-encoding",
  "libp2p-identity",
  "multibase",
- "multihash 0.19.3",
+ "multihash 0.19.2",
  "percent-encoding",
  "serde",
  "static_assertions",
@@ -5736,9 +5505,9 @@ dependencies = [
 
 [[package]]
 name = "multihash"
-version = "0.19.3"
+version = "0.19.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b430e7953c29dd6a09afc29ff0bb69c6e306329ee6794700aee27b76a1aea8d"
+checksum = "cc41f430805af9d1cf4adae4ed2149c759b877b01d909a1f40256188d09345d2"
 dependencies = [
  "core2",
  "unsigned-varint 0.8.0",
@@ -5764,12 +5533,6 @@ version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e5ce46fe64a9d73be07dcbe690a38ce1b293be448fd8ce1e6c1b8062c9f72c6a"
 
-[[package]]
-name = "multimap"
-version = "0.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "defc4c55412d89136f966bbb339008b474350e5e6e78d2714439c386b3137a03"
-
 [[package]]
 name = "multistream-select"
 version = "0.13.0"
@@ -5786,17 +5549,29 @@ dependencies = [
 
 [[package]]
 name = "nalgebra"
-version = "0.33.2"
+version = "0.32.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26aecdf64b707efd1310e3544d709c5c0ac61c13756046aaaba41be5c4f66a3b"
+checksum = "7b5c17de023a86f59ed79891b2e5d5a94c705dbe904a5b5c9c952ea6221b03e4"
 dependencies = [
  "approx",
  "matrixmultiply",
+ "nalgebra-macros",
  "num-complex",
  "num-rational",
  "num-traits",
  "simba",
- "typenum 1.18.0",
+ "typenum 1.17.0",
+]
+
+[[package]]
+name = "nalgebra-macros"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "254a5372af8fc138e36684761d3c0cdb758a4410e938babcff1c860ce14ddbfc"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -5810,9 +5585,9 @@ dependencies = [
 
 [[package]]
 name = "native-tls"
-version = "0.2.14"
+version = "0.2.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87de3442987e9dbec73158d5c715e7ad9072fda936bb03d19d7fa10e00520f0e"
+checksum = "a8614eb2c83d59d1c8cc974dd3f920198647674a0a035e1af1fa58707e317466"
 dependencies = [
  "libc",
  "log",
@@ -5840,20 +5615,21 @@ dependencies = [
 
 [[package]]
 name = "netlink-packet-core"
-version = "0.7.0"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72724faf704479d67b388da142b186f916188505e7e0b26719019c525882eda4"
+checksum = "345b8ab5bd4e71a2986663e88c56856699d060e78e152e6e9d7966fcd5491297"
 dependencies = [
  "anyhow",
  "byteorder",
+ "libc",
  "netlink-packet-utils",
 ]
 
 [[package]]
 name = "netlink-packet-route"
-version = "0.17.1"
+version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "053998cea5a306971f88580d0829e90f270f940befd7cf928da179d4187a5a66"
+checksum = "d9ea4302b9759a7a88242299225ea3688e63c85ea136371bb6cf94fd674efaab"
 dependencies = [
  "anyhow",
  "bitflags 1.3.2",
@@ -5872,28 +5648,29 @@ dependencies = [
  "anyhow",
  "byteorder",
  "paste",
- "thiserror 1.0.69",
+ "thiserror",
 ]
 
 [[package]]
 name = "netlink-proto"
-version = "0.11.5"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72452e012c2f8d612410d89eea01e2d9b56205274abb35d53f60200b2ec41d60"
+checksum = "65b4b14489ab424703c092062176d52ba55485a89c076b4f9db05092b7223aa6"
 dependencies = [
  "bytes",
  "futures",
  "log",
  "netlink-packet-core",
  "netlink-sys",
- "thiserror 2.0.12",
+ "thiserror",
+ "tokio",
 ]
 
 [[package]]
 name = "netlink-sys"
-version = "0.8.7"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16c903aa70590cb93691bf97a767c8d1d6122d2cc9070433deb3bbf36ce8bd23"
+checksum = "416060d346fbaf1f23f9512963e3e878f1a78e707cb699ba9215761754244307"
 dependencies = [
  "bytes",
  "futures",
@@ -5910,15 +5687,15 @@ checksum = "a4a43439bf756eed340bdf8feba761e2d50c7d47175d87545cd5cbe4a137c4d1"
 dependencies = [
  "cc",
  "libc",
- "thiserror 1.0.69",
+ "thiserror",
  "winapi",
 ]
 
 [[package]]
 name = "nix"
-version = "0.26.4"
+version = "0.24.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "598beaf3cc6fdd9a5dfb1630c2800c7acd31df7aaf0f565796fba2b53ca1af1b"
+checksum = "fa52e972a9a719cecb6864fb88568781eb706bac2cd1d4f04a648542dbf78069"
 dependencies = [
  "bitflags 1.3.2",
  "cfg-if",
@@ -6010,7 +5787,7 @@ dependencies = [
  "subtensor-custom-rpc",
  "subtensor-custom-rpc-runtime-api",
  "subtensor-runtime-common",
- "thiserror 1.0.69",
+ "thiserror",
 ]
 
 [[package]]
@@ -6253,10 +6030,10 @@ version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "af1844ef2428cc3e1cb900be36181049ef3d3193c63e43026cfe202983b27a56"
 dependencies = [
- "proc-macro-crate 3.3.0",
+ "proc-macro-crate 3.2.0",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -6282,9 +6059,9 @@ dependencies = [
 
 [[package]]
 name = "object"
-version = "0.36.7"
+version = "0.36.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62948e14d923ea95ea2c7c86c71013138b66525b86bdc08d2dcc262bdb497b87"
+checksum = "084f1a5821ac4c651660a94a7153d27ac9d8a53736203f58b31945ded098070a"
 dependencies = [
  "memchr",
 ]
@@ -6309,9 +6086,12 @@ dependencies = [
 
 [[package]]
 name = "once_cell"
-version = "1.21.3"
+version = "1.20.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
+checksum = "82881c4be219ab5faaf2ad5e5e5ecdff8c66bd7402ca3160975c93b24961afd1"
+dependencies = [
+ "portable-atomic",
+]
 
 [[package]]
 name = "opaque-debug"
@@ -6327,11 +6107,11 @@ checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381"
 
 [[package]]
 name = "openssl"
-version = "0.10.72"
+version = "0.10.70"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fedfea7d58a1f73118430a55da6a286e7b044961736ce96a16a17068ea25e5da"
+checksum = "61cfb4e166a8bb8c9b55c500bc2308550148ece889be90f609377e58140f42c6"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.6.0",
  "cfg-if",
  "foreign-types",
  "libc",
@@ -6348,29 +6128,29 @@ checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
 name = "openssl-probe"
-version = "0.1.6"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d05e27ee213611ffe7d6348b942e8f942b37114c00cc03cec254295a4a17852e"
+checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf"
 
 [[package]]
 name = "openssl-src"
-version = "300.4.2+3.4.1"
+version = "300.4.0+3.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "168ce4e058f975fe43e89d9ccf78ca668601887ae736090aacc23ae353c298e2"
+checksum = "a709e02f2b4aca747929cca5ed248880847c650233cf8b8cdc48f40aaf4898a6"
 dependencies = [
  "cc",
 ]
 
 [[package]]
 name = "openssl-sys"
-version = "0.9.107"
+version = "0.9.105"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8288979acd84749c744a9014b4382d42b8f7b2592847b5afb2ed29e5d16ede07"
+checksum = "8b22d5b84be05a8d6947c7cb71f7c849aa0f112acd4bf51c2a7c1c988ac0a9dc"
 dependencies = [
  "cc",
  "libc",
@@ -6898,6 +6678,7 @@ dependencies = [
  "sp-version",
  "substrate-fixed",
  "subtensor-macros",
+ "subtensor-swap-interface",
  "tle",
  "w3f-bls",
 ]
@@ -6911,7 +6692,6 @@ dependencies = [
  "frame-benchmarking",
  "frame-support",
  "frame-system",
- "pallet-subtensor-swap-interface",
  "parity-scale-codec",
  "safe-math",
  "scale-info",
@@ -6922,13 +6702,9 @@ dependencies = [
  "sp-runtime",
  "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409)",
  "substrate-fixed",
- "uuid",
+ "subtensor-swap-interface",
 ]
 
-[[package]]
-name = "pallet-subtensor-swap-interface"
-version = "0.1.0"
-
 [[package]]
 name = "pallet-sudo"
 version = "38.0.0"
@@ -7076,31 +6852,29 @@ dependencies = [
 
 [[package]]
 name = "parity-scale-codec"
-version = "3.7.4"
+version = "3.6.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c9fde3d0718baf5bc92f577d652001da0f8d54cd03a7974e118d04fc888dc23d"
+checksum = "306800abfa29c7f16596b5970a588435e3d5b3149683d00c12b699cc19f895ee"
 dependencies = [
  "arrayvec",
  "bitvec",
  "byte-slice-cast",
  "bytes",
- "const_format",
  "impl-trait-for-tuples",
  "parity-scale-codec-derive",
- "rustversion",
  "serde",
 ]
 
 [[package]]
 name = "parity-scale-codec-derive"
-version = "3.7.4"
+version = "3.6.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "581c837bb6b9541ce7faa9377c20616e4fb7650f6b0f68bc93c827ee504fb7b3"
+checksum = "d830939c76d294956402033aee57a6da7b438f2294eb94864c37b0569053a42c"
 dependencies = [
- "proc-macro-crate 3.3.0",
+ "proc-macro-crate 3.2.0",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -7116,7 +6890,7 @@ dependencies = [
  "lru 0.8.1",
  "parity-util-mem-derive",
  "parking_lot 0.12.3",
- "primitive-types 0.12.2",
+ "primitive-types",
  "smallvec",
  "winapi",
 ]
@@ -7187,7 +6961,7 @@ checksum = "1e401f977ab385c9e4e3ab30627d6f26d00e2c73eef317493c4ec6d468726cf8"
 dependencies = [
  "cfg-if",
  "libc",
- "redox_syscall 0.5.10",
+ "redox_syscall 0.5.7",
  "smallvec",
  "windows-targets 0.52.6",
 ]
@@ -7248,20 +7022,20 @@ checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e"
 
 [[package]]
 name = "pest"
-version = "2.8.0"
+version = "2.7.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "198db74531d58c70a361c42201efde7e2591e976d518caf7662a47dc5720e7b6"
+checksum = "fdbef9d1d47087a895abd220ed25eb4ad973a5e26f6a4367b038c25e28dfc2d9"
 dependencies = [
  "memchr",
- "thiserror 2.0.12",
+ "thiserror",
  "ucd-trie",
 ]
 
 [[package]]
 name = "pest_derive"
-version = "2.8.0"
+version = "2.7.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d725d9cfd79e87dccc9341a2ef39d1b6f6353d68c4b33c177febbe1a402c97c5"
+checksum = "4d3a6e3394ec80feb3b6393c725571754c6188490265c61aaf260810d6b95aa0"
 dependencies = [
  "pest",
  "pest_generator",
@@ -7269,22 +7043,22 @@ dependencies = [
 
 [[package]]
 name = "pest_generator"
-version = "2.8.0"
+version = "2.7.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db7d01726be8ab66ab32f9df467ae8b1148906685bbe75c82d1e65d7f5b3f841"
+checksum = "94429506bde1ca69d1b5601962c73f4172ab4726571a59ea95931218cb0e930e"
 dependencies = [
  "pest",
  "pest_meta",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
 name = "pest_meta"
-version = "2.8.0"
+version = "2.7.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f9f832470494906d1fca5329f8ab5791cc60beb230c74815dff541cbd2b5ca0"
+checksum = "ac8a071862e93690b6e34e9a5fb8e33ff3734473ac0245b27232222c4906a33f"
 dependencies = [
  "once_cell",
  "pest",
@@ -7298,34 +7072,34 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b4c5cc86750666a3ed20bdaf5ca2a0344f9c67674cae0515bec2da16fbaa47db"
 dependencies = [
  "fixedbitset",
- "indexmap 2.8.0",
+ "indexmap 2.6.0",
 ]
 
 [[package]]
 name = "pin-project"
-version = "1.1.10"
+version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "677f1add503faace112b9f1373e43e9e054bfdd22ff1a63c1bc485eaec6a6a8a"
+checksum = "b6bf43b791c5b9e34c3d182969b4abb522f9343702850a2e57f460d00d09b4b3"
 dependencies = [
  "pin-project-internal",
 ]
 
 [[package]]
 name = "pin-project-internal"
-version = "1.1.10"
+version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e918e4ff8c4549eb882f14b3a4bc8c8bc93de829416eacf579f1207a8fbf861"
+checksum = "2f38a4412a78282e09a2cf38d195ea5420d15ba0602cb375210efbc877243965"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
 name = "pin-project-lite"
-version = "0.2.16"
+version = "0.2.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b"
+checksum = "bda66fc9667c18cb2758a2ac84d1167245054bcf85d5d1aaa6923f45801bdd02"
 
 [[package]]
 name = "pin-utils"
@@ -7345,9 +7119,9 @@ dependencies = [
 
 [[package]]
 name = "pkg-config"
-version = "0.3.32"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c"
+checksum = "953ec861398dccce10c670dfeaf3ec4911ca479e9c02154b3a215178c5f566f2"
 
 [[package]]
 name = "polkavm"
@@ -7358,7 +7132,7 @@ dependencies = [
  "libc",
  "log",
  "polkavm-assembler",
- "polkavm-common 0.9.0",
+ "polkavm-common",
  "polkavm-linux-raw",
 ]
 
@@ -7380,28 +7154,13 @@ dependencies = [
  "log",
 ]
 
-[[package]]
-name = "polkavm-common"
-version = "0.18.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "31ff33982a807d8567645d4784b9b5d7ab87bcb494f534a57cadd9012688e102"
-
 [[package]]
 name = "polkavm-derive"
 version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ae8c4bea6f3e11cd89bb18bcdddac10bd9a24015399bd1c485ad68a985a19606"
 dependencies = [
- "polkavm-derive-impl-macro 0.9.0",
-]
-
-[[package]]
-name = "polkavm-derive"
-version = "0.18.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2eb703f3b6404c13228402e98a5eae063fd16b8f58afe334073ec105ee4117e"
-dependencies = [
- "polkavm-derive-impl-macro 0.18.0",
+ "polkavm-derive-impl-macro",
 ]
 
 [[package]]
@@ -7410,22 +7169,10 @@ version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5c4fdfc49717fb9a196e74a5d28e0bc764eb394a2c803eb11133a31ac996c60c"
 dependencies = [
- "polkavm-common 0.9.0",
- "proc-macro2",
- "quote",
- "syn 2.0.100",
-]
-
-[[package]]
-name = "polkavm-derive-impl"
-version = "0.18.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f2116a92e6e96220a398930f4c8a6cda1264206f3e2034fc9982bfd93f261f7"
-dependencies = [
- "polkavm-common 0.18.0",
+ "polkavm-common",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -7434,18 +7181,8 @@ version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8ba81f7b5faac81e528eb6158a6f3c9e0bb1008e0ffa19653bc8dea925ecb429"
 dependencies = [
- "polkavm-derive-impl 0.9.0",
- "syn 2.0.100",
-]
-
-[[package]]
-name = "polkavm-derive-impl-macro"
-version = "0.18.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48c16669ddc7433e34c1007d31080b80901e3e8e523cb9d4b441c3910cf9294b"
-dependencies = [
- "polkavm-derive-impl 0.18.1",
- "syn 2.0.100",
+ "polkavm-derive-impl",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -7458,7 +7195,7 @@ dependencies = [
  "hashbrown 0.14.5",
  "log",
  "object 0.32.2",
- "polkavm-common 0.9.0",
+ "polkavm-common",
  "regalloc2 0.9.3",
  "rustc-demangle",
 ]
@@ -7471,15 +7208,15 @@ checksum = "26e85d3456948e650dff0cfc85603915847faf893ed1e66b020bb82ef4557120"
 
 [[package]]
 name = "polling"
-version = "3.7.4"
+version = "3.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a604568c3202727d1507653cb121dbd627a58684eb09a820fd746bee38b4442f"
+checksum = "cc2790cd301dec6cd3b7a025e4815cf825724a51c98dccfe6a3e55f05ffb6511"
 dependencies = [
  "cfg-if",
  "concurrent-queue",
  "hermit-abi 0.4.0",
  "pin-project-lite",
- "rustix 0.38.44",
+ "rustix 0.38.37",
  "tracing",
  "windows-sys 0.59.0",
 ]
@@ -7509,9 +7246,9 @@ dependencies = [
 
 [[package]]
 name = "portable-atomic"
-version = "1.11.0"
+version = "1.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "350e9b48cbc6b0e028b0473b114454c6316e57336ee184ceab6e53f72c178b3e"
+checksum = "cc9c68a3f6da06753e9335d63e27f6b9754dd1920d941135b7ea8224f141adb2"
 
 [[package]]
 name = "powerfmt"
@@ -7521,11 +7258,11 @@ checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
 
 [[package]]
 name = "ppv-lite86"
-version = "0.2.21"
+version = "0.2.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
+checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04"
 dependencies = [
- "zerocopy 0.8.24",
+ "zerocopy 0.7.35",
 ]
 
 [[package]]
@@ -7559,7 +7296,7 @@ source = "git+https://github.com/opentensor/frontier?rev=635bdac882#635bdac88233
 dependencies = [
  "case",
  "num_enum",
- "prettyplease 0.2.31",
+ "prettyplease 0.2.22",
  "proc-macro2",
  "quote",
  "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409)",
@@ -7582,9 +7319,9 @@ dependencies = [
 
 [[package]]
 name = "predicates"
-version = "3.1.3"
+version = "3.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5d19ee57562043d37e82899fade9a22ebab7be9cef5026b07fda9cdd4293573"
+checksum = "7e9086cc7640c29a356d1a29fd134380bee9d8f79a17410aa76e7ad295f42c97"
 dependencies = [
  "anstyle",
  "predicates-core",
@@ -7592,15 +7329,15 @@ dependencies = [
 
 [[package]]
 name = "predicates-core"
-version = "1.0.9"
+version = "1.0.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "727e462b119fe9c93fd0eb1429a5f7647394014cf3c04ab2c0350eeb09095ffa"
+checksum = "ae8177bee8e75d6846599c6b9ff679ed51e882816914eec639944d7c9aa11931"
 
 [[package]]
 name = "predicates-tree"
-version = "1.0.12"
+version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72dd2d6d381dfb73a193c7fca536518d7caee39fc8503f74e7dc0be0531b425c"
+checksum = "41b740d195ed3166cd147c8047ec98db0e22ec019eb8eeb76d343b795304fb13"
 dependencies = [
  "predicates-core",
  "termtree",
@@ -7618,12 +7355,12 @@ dependencies = [
 
 [[package]]
 name = "prettyplease"
-version = "0.2.31"
+version = "0.2.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5316f57387668042f561aae71480de936257848f9c43ce528e311d89a07cadeb"
+checksum = "479cf940fbbb3426c32c5d5176f62ad57549a0bb84773423ba8be9d089f5faba"
 dependencies = [
  "proc-macro2",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -7633,23 +7370,11 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b34d9fd68ae0b74a41b21c03c2f62847aa0ffea044eee893b4c140b37e244e2"
 dependencies = [
  "fixed-hash",
- "impl-codec 0.6.0",
+ "impl-codec",
  "impl-rlp",
- "impl-serde 0.4.0",
+ "impl-serde",
  "scale-info",
- "uint 0.9.5",
-]
-
-[[package]]
-name = "primitive-types"
-version = "0.13.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d15600a7d856470b7d278b3fe0e311fe28c2526348549f8ef2ff7db3299c87f5"
-dependencies = [
- "fixed-hash",
- "impl-codec 0.7.1",
- "impl-num-traits",
- "uint 0.10.0",
+ "uint",
 ]
 
 [[package]]
@@ -7658,15 +7383,15 @@ version = "1.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e17d47ce914bf4de440332250b0edd23ce48c005f59fab39d3335866b114f11a"
 dependencies = [
- "thiserror 1.0.69",
+ "thiserror",
  "toml 0.5.11",
 ]
 
 [[package]]
 name = "proc-macro-crate"
-version = "3.3.0"
+version = "3.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "edce586971a4dfaa28950c6f18ed55e0406c1ab88bbce2c6f6293a7aaba73d35"
+checksum = "8ecf48c7ca261d60b74ab1a7b20da18bede46776b2e55535cb958eb595c5fa7b"
 dependencies = [
  "toml_edit",
 ]
@@ -7703,25 +7428,25 @@ checksum = "3d1eaa7fa0aa1929ffdf7eeb6eac234dde6268914a14ad44d23521ab6a9b258e"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
 name = "proc-macro-warning"
-version = "1.84.1"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75eea531cfcd120e0851a3f8aed42c4841f78c889eefafd96339c72677ae42c3"
+checksum = "834da187cfe638ae8abb0203f0b33e5ccdb02a28e7199f2f47b3e2754f50edca"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.94"
+version = "1.0.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a31971752e70b8b2686d7e46ec17fb38dad4051d94024c88df49b667caea9c84"
+checksum = "37d3544b3f2748c54e147655edb5025752e2303145b5aefb3c3ea2c78b973bb0"
 dependencies = [
  "unicode-ident",
 ]
@@ -7737,12 +7462,12 @@ dependencies = [
  "frame-support-procedural-tools 10.0.0",
  "itertools 0.10.5",
  "macro_magic",
- "proc-macro-warning 1.84.1",
+ "proc-macro-warning 1.0.2",
  "proc-macro2",
  "quote",
  "regex",
  "sp-crypto-hashing 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -7756,7 +7481,7 @@ dependencies = [
  "lazy_static",
  "memchr",
  "parking_lot 0.12.3",
- "thiserror 1.0.69",
+ "thiserror",
 ]
 
 [[package]]
@@ -7779,7 +7504,7 @@ checksum = "440f724eba9f6996b75d63681b0a92b06947f1457076d503a4d2e2c8f56442b8"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -7790,7 +7515,7 @@ checksum = "14cae93065090804185d3b75f0bf93b8eeda30c7a9b4a33d3bdb3988d6229e50"
 dependencies = [
  "bit-set",
  "bit-vec",
- "bitflags 2.9.0",
+ "bitflags 2.6.0",
  "lazy_static",
  "num-traits",
  "rand 0.8.5",
@@ -7833,7 +7558,7 @@ dependencies = [
  "itertools 0.10.5",
  "lazy_static",
  "log",
- "multimap 0.8.3",
+ "multimap",
  "petgraph",
  "prettyplease 0.1.25",
  "prost 0.11.9",
@@ -7854,14 +7579,14 @@ dependencies = [
  "heck 0.5.0",
  "itertools 0.12.1",
  "log",
- "multimap 0.10.0",
+ "multimap",
  "once_cell",
  "petgraph",
- "prettyplease 0.2.31",
+ "prettyplease 0.2.22",
  "prost 0.12.6",
  "prost-types 0.12.6",
  "regex",
- "syn 2.0.100",
+ "syn 2.0.90",
  "tempfile",
 ]
 
@@ -7888,7 +7613,7 @@ dependencies = [
  "itertools 0.12.1",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -7911,18 +7636,18 @@ dependencies = [
 
 [[package]]
 name = "psm"
-version = "0.1.25"
+version = "0.1.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f58e5423e24c18cc840e1c98370b3993c6649cd1678b4d24318bcf0a083cbe88"
+checksum = "aa37f80ca58604976033fae9515a8a2989fc13797d953f7c04fb8fa36a11f205"
 dependencies = [
  "cc",
 ]
 
 [[package]]
 name = "quanta"
-version = "0.12.5"
+version = "0.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3bd1fe6824cea6538803de3ff1bc0cf3949024db3d43c9643024bfb33a807c0e"
+checksum = "8e5167a477619228a0b284fac2674e3c388cba90631d7b7de620e6f1fcd08da5"
 dependencies = [
  "crossbeam-utils",
  "libc",
@@ -7957,7 +7682,7 @@ dependencies = [
  "asynchronous-codec",
  "bytes",
  "quick-protobuf",
- "thiserror 1.0.69",
+ "thiserror",
  "unsigned-varint 0.7.2",
 ]
 
@@ -7973,7 +7698,7 @@ dependencies = [
  "quinn-udp 0.3.2",
  "rustc-hash 1.1.0",
  "rustls 0.20.9",
- "thiserror 1.0.69",
+ "thiserror",
  "tokio",
  "tracing",
  "webpki",
@@ -7992,7 +7717,7 @@ dependencies = [
  "quinn-udp 0.4.1",
  "rustc-hash 1.1.0",
  "rustls 0.21.12",
- "thiserror 1.0.69",
+ "thiserror",
  "tokio",
  "tracing",
 ]
@@ -8009,7 +7734,7 @@ dependencies = [
  "rustc-hash 1.1.0",
  "rustls 0.20.9",
  "slab",
- "thiserror 1.0.69",
+ "thiserror",
  "tinyvec",
  "tracing",
  "webpki",
@@ -8027,7 +7752,7 @@ dependencies = [
  "rustc-hash 1.1.0",
  "rustls 0.21.12",
  "slab",
- "thiserror 1.0.69",
+ "thiserror",
  "tinyvec",
  "tracing",
 ]
@@ -8053,16 +7778,16 @@ checksum = "055b4e778e8feb9f93c4e439f71dc2156ef13360b432b799e179a8c4cdf0b1d7"
 dependencies = [
  "bytes",
  "libc",
- "socket2 0.5.9",
+ "socket2 0.5.7",
  "tracing",
  "windows-sys 0.48.0",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.40"
+version = "1.0.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d"
+checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
 dependencies = [
  "proc-macro2",
 ]
@@ -8169,11 +7894,11 @@ dependencies = [
 
 [[package]]
 name = "raw-cpuid"
-version = "11.5.0"
+version = "11.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c6df7ab838ed27997ba19a4664507e6f82b41fe6e20be42929332156e5e85146"
+checksum = "1ab240315c661615f2ee9f0f2cd32d5a7343a84d5ebcccb99d46e6637565e7b0"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.6.0",
 ]
 
 [[package]]
@@ -8225,11 +7950,11 @@ dependencies = [
 
 [[package]]
 name = "redox_syscall"
-version = "0.5.10"
+version = "0.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b8c0c260b63a8219631167be35e6a988e9554dbd323f8bd08439c8ed1302bd1"
+checksum = "9b6dfecf2c74bce2466cabf93f6664d6998a69eb21e39f4207930065b27b771f"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.6.0",
 ]
 
 [[package]]
@@ -8240,27 +7965,27 @@ checksum = "ba009ff324d1fc1b900bd1fdb31564febe58a8ccc8a6fdbb93b543d33b13ca43"
 dependencies = [
  "getrandom 0.2.15",
  "libredox",
- "thiserror 1.0.69",
+ "thiserror",
 ]
 
 [[package]]
 name = "ref-cast"
-version = "1.0.24"
+version = "1.0.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a0ae411dbe946a674d89546582cea4ba2bb8defac896622d6496f14c23ba5cf"
+checksum = "ccf0a6f84d5f1d581da8b41b47ec8600871962f2a528115b542b362d4b744931"
 dependencies = [
  "ref-cast-impl",
 ]
 
 [[package]]
 name = "ref-cast-impl"
-version = "1.0.24"
+version = "1.0.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1165225c21bff1f3bbce98f5a1f889949bc902d3575308cc7b0de30b4f6d27c7"
+checksum = "bcc303e793d3734489387d205e9b186fac9c6cfacedd98cbb2e8a5943595f3e6"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -8290,13 +8015,13 @@ dependencies = [
 
 [[package]]
 name = "regex"
-version = "1.11.1"
+version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
+checksum = "38200e5ee88914975b69f657f0801b6f6dccafd44fd9326302a4aaeecfacb1d8"
 dependencies = [
  "aho-corasick",
  "memchr",
- "regex-automata 0.4.9",
+ "regex-automata 0.4.8",
  "regex-syntax 0.8.5",
 ]
 
@@ -8311,9 +8036,9 @@ dependencies = [
 
 [[package]]
 name = "regex-automata"
-version = "0.4.9"
+version = "0.4.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908"
+checksum = "368758f23274712b504848e9d5a6f010445cc8b87a7cdb4d7cbee666c1288da3"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -8334,11 +8059,12 @@ checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
 [[package]]
 name = "resolv-conf"
-version = "0.7.1"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48375394603e3dd4b2d64371f7148fd8c7baa2680e28741f2cb8d23b59e3d4c4"
+checksum = "52e44394d2086d010551b14b53b1f24e31647570cd1deb0379e2c21b329aba00"
 dependencies = [
  "hostname",
+ "quick-error",
 ]
 
 [[package]]
@@ -8368,9 +8094,9 @@ dependencies = [
 
 [[package]]
 name = "ring"
-version = "0.17.14"
+version = "0.17.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7"
+checksum = "70ac5d832aa16abd7d1def883a8545280c20a60f523a370aa3a9617c2b8550ee"
 dependencies = [
  "cc",
  "cfg-if",
@@ -8440,19 +8166,16 @@ dependencies = [
 
 [[package]]
 name = "rtnetlink"
-version = "0.13.1"
+version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a552eb82d19f38c3beed3f786bd23aa434ceb9ac43ab44419ca6d67a7e186c0"
+checksum = "322c53fd76a18698f1c27381d58091de3a043d356aa5bd0d510608b565f469a0"
 dependencies = [
  "futures",
  "log",
- "netlink-packet-core",
  "netlink-packet-route",
- "netlink-packet-utils",
  "netlink-proto",
- "netlink-sys",
  "nix",
- "thiserror 1.0.69",
+ "thiserror",
  "tokio",
 ]
 
@@ -8482,7 +8205,7 @@ dependencies = [
  "num-integer",
  "num-traits",
  "parity-scale-codec",
- "primitive-types 0.12.2",
+ "primitive-types",
  "proptest",
  "rand 0.8.5",
  "rand 0.9.0",
@@ -8547,7 +8270,7 @@ version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
 dependencies = [
- "semver 1.0.26",
+ "semver 1.0.23",
 ]
 
 [[package]]
@@ -8575,28 +8298,15 @@ dependencies = [
 
 [[package]]
 name = "rustix"
-version = "0.38.44"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fdb5bc1ae2baa591800df16c9ca78619bf65c0488b41b96ccec5d11220d8c154"
-dependencies = [
- "bitflags 2.9.0",
- "errno",
- "libc",
- "linux-raw-sys 0.4.15",
- "windows-sys 0.59.0",
-]
-
-[[package]]
-name = "rustix"
-version = "1.0.5"
+version = "0.38.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d97817398dd4bb2e6da002002db259209759911da105da92bec29ccb12cf58bf"
+checksum = "8acb788b847c24f28525660c4d7758620a7210875711f79e7f663cc152726811"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.6.0",
  "errno",
  "libc",
- "linux-raw-sys 0.9.3",
- "windows-sys 0.59.0",
+ "linux-raw-sys 0.4.14",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -8617,7 +8327,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3f56a14d1f48b391359b22f731fd4bd7e43c97f3c50eee276f3aa09c94784d3e"
 dependencies = [
  "log",
- "ring 0.17.14",
+ "ring 0.17.13",
  "rustls-webpki",
  "sct",
 ]
@@ -8649,15 +8359,15 @@ version = "0.101.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8b6275d1ee7a1cd780b64aca7726599a1dbc893b1e64144529e55c3c2f745765"
 dependencies = [
- "ring 0.17.14",
+ "ring 0.17.13",
  "untrusted 0.9.0",
 ]
 
 [[package]]
 name = "rustversion"
-version = "1.0.20"
+version = "1.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eded382c5f5f786b989652c49544c4877d9f015cc22e145a5ea8ea66c2921cd2"
+checksum = "955d28af4278de8121b7ebeb796b6a45735dc01436d898801014aced2773a3d6"
 
 [[package]]
 name = "rusty-fork"
@@ -8684,9 +8394,9 @@ dependencies = [
 
 [[package]]
 name = "ryu"
-version = "1.0.20"
+version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f"
+checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
 
 [[package]]
 name = "safe-math"
@@ -8709,9 +8419,9 @@ dependencies = [
 
 [[package]]
 name = "safe_arch"
-version = "0.7.4"
+version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96b02de82ddbe1b636e6170c21be622223aea188ef2e139be0a5b219ec215323"
+checksum = "c3460605018fdc9612bce72735cba0d27efbcd9904780d44c7e3a9948f96148a"
 dependencies = [
  "bytemuck",
 ]
@@ -8733,7 +8443,7 @@ dependencies = [
  "log",
  "sp-core",
  "sp-wasm-interface 21.0.1",
- "thiserror 1.0.69",
+ "thiserror",
 ]
 
 [[package]]
@@ -8805,10 +8515,10 @@ name = "sc-chain-spec-derive"
 version = "12.0.0"
 source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409#87971b3e92721bdf10bf40b410eaae779d494ca0"
 dependencies = [
- "proc-macro-crate 3.3.0",
+ "proc-macro-crate 3.2.0",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -8848,7 +8558,7 @@ dependencies = [
  "sp-panic-handler",
  "sp-runtime",
  "sp-version",
- "thiserror 1.0.69",
+ "thiserror",
  "tokio",
 ]
 
@@ -8926,7 +8636,7 @@ dependencies = [
  "sp-runtime",
  "sp-state-machine",
  "substrate-prometheus-endpoint",
- "thiserror 1.0.69",
+ "thiserror",
 ]
 
 [[package]]
@@ -8955,7 +8665,7 @@ dependencies = [
  "sp-keystore",
  "sp-runtime",
  "substrate-prometheus-endpoint",
- "thiserror 1.0.69",
+ "thiserror",
 ]
 
 [[package]]
@@ -8991,7 +8701,7 @@ dependencies = [
  "sp-keystore",
  "sp-runtime",
  "substrate-prometheus-endpoint",
- "thiserror 1.0.69",
+ "thiserror",
 ]
 
 [[package]]
@@ -9048,7 +8758,7 @@ dependencies = [
  "sp-keystore",
  "sp-runtime",
  "substrate-prometheus-endpoint",
- "thiserror 1.0.69",
+ "thiserror",
 ]
 
 [[package]]
@@ -9068,7 +8778,7 @@ dependencies = [
  "sp-blockchain",
  "sp-core",
  "sp-runtime",
- "thiserror 1.0.69",
+ "thiserror",
 ]
 
 [[package]]
@@ -9103,7 +8813,7 @@ dependencies = [
  "sp-runtime",
  "sp-timestamp",
  "substrate-prometheus-endpoint",
- "thiserror 1.0.69",
+ "thiserror",
 ]
 
 [[package]]
@@ -9161,7 +8871,7 @@ dependencies = [
  "sc-allocator",
  "sp-maybe-compressed-blob",
  "sp-wasm-interface 21.0.1",
- "thiserror 1.0.69",
+ "thiserror",
  "wasm-instrument",
 ]
 
@@ -9222,7 +8932,7 @@ dependencies = [
  "sp-application-crypto",
  "sp-core",
  "sp-keystore",
- "thiserror 1.0.69",
+ "thiserror",
 ]
 
 [[package]]
@@ -9251,7 +8961,7 @@ dependencies = [
  "sp-keystore",
  "sp-mixnet",
  "sp-runtime",
- "thiserror 1.0.69",
+ "thiserror",
 ]
 
 [[package]]
@@ -9296,7 +9006,7 @@ dependencies = [
  "sp-core",
  "sp-runtime",
  "substrate-prometheus-endpoint",
- "thiserror 1.0.69",
+ "thiserror",
  "tokio",
  "tokio-stream",
  "unsigned-varint 0.7.2",
@@ -9360,7 +9070,7 @@ dependencies = [
  "sp-blockchain",
  "sp-core",
  "sp-runtime",
- "thiserror 1.0.69",
+ "thiserror",
 ]
 
 [[package]]
@@ -9395,7 +9105,7 @@ dependencies = [
  "sp-core",
  "sp-runtime",
  "substrate-prometheus-endpoint",
- "thiserror 1.0.69",
+ "thiserror",
  "tokio",
  "tokio-stream",
 ]
@@ -9430,9 +9140,9 @@ dependencies = [
  "litep2p",
  "log",
  "multiaddr 0.18.2",
- "multihash 0.19.3",
+ "multihash 0.19.2",
  "rand 0.8.5",
- "thiserror 1.0.69",
+ "thiserror",
  "zeroize",
 ]
 
@@ -9446,7 +9156,7 @@ dependencies = [
  "fnv",
  "futures",
  "futures-timer",
- "hyper 0.14.32",
+ "hyper 0.14.30",
  "hyper-rustls",
  "log",
  "num_cpus",
@@ -9528,7 +9238,7 @@ dependencies = [
  "sp-rpc",
  "sp-runtime",
  "sp-version",
- "thiserror 1.0.69",
+ "thiserror",
 ]
 
 [[package]]
@@ -9540,9 +9250,9 @@ dependencies = [
  "forwarded-header-value",
  "futures",
  "governor",
- "http 1.3.1",
+ "http 1.1.0",
  "http-body-util",
- "hyper 1.6.0",
+ "hyper 1.5.0",
  "ip_network",
  "jsonrpsee",
  "log",
@@ -9582,7 +9292,7 @@ dependencies = [
  "sp-rpc",
  "sp-runtime",
  "sp-version",
- "thiserror 1.0.69",
+ "thiserror",
  "tokio",
  "tokio-stream",
 ]
@@ -9645,7 +9355,7 @@ dependencies = [
  "static_init",
  "substrate-prometheus-endpoint",
  "tempfile",
- "thiserror 1.0.69",
+ "thiserror",
  "tokio",
  "tracing",
  "tracing-futures",
@@ -9667,7 +9377,7 @@ name = "sc-sysinfo"
 version = "38.0.0"
 source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409#87971b3e92721bdf10bf40b410eaae779d494ca0"
 dependencies = [
- "derive_more 0.99.19",
+ "derive_more 0.99.18",
  "futures",
  "libc",
  "log",
@@ -9699,7 +9409,7 @@ dependencies = [
  "sc-utils",
  "serde",
  "serde_json",
- "thiserror 1.0.69",
+ "thiserror",
  "wasm-timer",
 ]
 
@@ -9726,10 +9436,10 @@ dependencies = [
  "sp-rpc",
  "sp-runtime",
  "sp-tracing 17.0.1",
- "thiserror 1.0.69",
+ "thiserror",
  "tracing",
  "tracing-log",
- "tracing-subscriber 0.3.19",
+ "tracing-subscriber 0.3.18",
 ]
 
 [[package]]
@@ -9737,10 +9447,10 @@ name = "sc-tracing-proc-macro"
 version = "11.0.0"
 source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409#87971b3e92721bdf10bf40b410eaae779d494ca0"
 dependencies = [
- "proc-macro-crate 3.3.0",
+ "proc-macro-crate 3.2.0",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -9767,7 +9477,7 @@ dependencies = [
  "sp-tracing 17.0.1",
  "sp-transaction-pool",
  "substrate-prometheus-endpoint",
- "thiserror 1.0.69",
+ "thiserror",
 ]
 
 [[package]]
@@ -9783,7 +9493,7 @@ dependencies = [
  "sp-blockchain",
  "sp-core",
  "sp-runtime",
- "thiserror 1.0.69",
+ "thiserror",
 ]
 
 [[package]]
@@ -9817,7 +9527,7 @@ version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e98f3262c250d90e700bb802eb704e1f841e03331c2eb815e46516c4edbf5b27"
 dependencies = [
- "derive_more 0.99.19",
+ "derive_more 0.99.18",
  "parity-scale-codec",
  "scale-bits",
  "scale-type-resolver",
@@ -9826,13 +9536,13 @@ dependencies = [
 
 [[package]]
 name = "scale-info"
-version = "2.11.6"
+version = "2.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "346a3b32eba2640d17a9cb5927056b08f3de90f65b72fe09402c2ad07d684d0b"
+checksum = "eca070c12893629e2cc820a9761bedf6ce1dcddc9852984d1dc734b8bd9bd024"
 dependencies = [
  "bitvec",
  "cfg-if",
- "derive_more 1.0.0",
+ "derive_more 0.99.18",
  "parity-scale-codec",
  "scale-info-derive",
  "serde",
@@ -9840,14 +9550,14 @@ dependencies = [
 
 [[package]]
 name = "scale-info-derive"
-version = "2.11.6"
+version = "2.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c6630024bf739e2179b91fb424b28898baf819414262c5d376677dbff1fe7ebf"
+checksum = "2d35494501194174bda522a32605929eefc9ecf7e0a326c26db1fdd85881eb62"
 dependencies = [
- "proc-macro-crate 3.3.0",
+ "proc-macro-crate 3.2.0",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -9858,18 +9568,18 @@ checksum = "f0cded6518aa0bd6c1be2b88ac81bf7044992f0f154bfbabd5ad34f43512abcb"
 
 [[package]]
 name = "schannel"
-version = "0.1.27"
+version = "0.1.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f29ebaa345f945cec9fbbc532eb307f0fdad8161f281b6369539c8d84876b3d"
+checksum = "e9aaafd5a2b6e3d657ff009d82fbd630b6bd54dd4eb06f21693925cdf80f9b8b"
 dependencies = [
  "windows-sys 0.59.0",
 ]
 
 [[package]]
 name = "schnellru"
-version = "0.2.4"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "356285bbf17bea63d9e52e96bd18f039672ac92b55b8cb997d6162a2a37d1649"
+checksum = "c9a8ef13a93c54d20580de1e5c413e624e53121d42fc7e2c11d10ef7f8b02367"
 dependencies = [
  "ahash 0.8.11",
  "cfg-if",
@@ -9903,9 +9613,9 @@ checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
 [[package]]
 name = "scratch"
-version = "1.0.8"
+version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f6280af86e5f559536da57a45ebc84948833b3bee313a7dd25232e09c878a52"
+checksum = "a3cf7c11c38cb994f3d40e8a8cde3bbd1f72a435e4c49e85d6553d8312306152"
 
 [[package]]
 name = "sct"
@@ -9913,7 +9623,7 @@ version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "da046153aa2352493d6cb7da4b6e5c0c057d8a1d0a9aa8560baffdd945acd414"
 dependencies = [
- "ring 0.17.14",
+ "ring 0.17.13",
  "untrusted 0.9.0",
 ]
 
@@ -9929,7 +9639,7 @@ dependencies = [
  "log",
  "rand 0.8.5",
  "slab",
- "thiserror 1.0.69",
+ "thiserror",
 ]
 
 [[package]]
@@ -9980,7 +9690,7 @@ version = "2.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.6.0",
  "core-foundation",
  "core-foundation-sys",
  "libc",
@@ -9989,9 +9699,9 @@ dependencies = [
 
 [[package]]
 name = "security-framework-sys"
-version = "2.14.0"
+version = "2.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49db231d56a190491cb4aeda9527f1ad45345af50b0851622a7adb8c03b01c32"
+checksum = "ea4a292869320c0272d7bc55a5a6aafaff59b4f63404a003887b679a2e05b4b6"
 dependencies = [
  "core-foundation-sys",
  "libc",
@@ -10026,9 +9736,9 @@ dependencies = [
 
 [[package]]
 name = "semver"
-version = "1.0.26"
+version = "1.0.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56e6fa9c48d24d85fb3de5ad847117517440f6beceb7798af16b4a87d616b8d0"
+checksum = "61697e0a1c7e512e84a621326239844a24d8207b4669b41bc18b32ea5cbf988b"
 dependencies = [
  "serde",
 ]
@@ -10056,9 +9766,9 @@ checksum = "cd0b0ec5f1c1ca621c432a25813d8d60c88abe6d3e08a3eb9cf37d97a0fe3d73"
 
 [[package]]
 name = "serde"
-version = "1.0.219"
+version = "1.0.216"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f0e2c6ed6606019b4e29e69dbaba95b11854410e5347d525002456dbbb786b6"
+checksum = "0b9781016e935a97e8beecf0c933758c97a5520d32930e460142b4cd80c6338e"
 dependencies = [
  "serde_derive",
 ]
@@ -10074,9 +9784,9 @@ dependencies = [
 
 [[package]]
 name = "serde_bytes"
-version = "0.11.17"
+version = "0.11.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8437fd221bde2d4ca316d61b90e337e9e702b3820b87d63caa9ba6c02bd06d96"
+checksum = "387cc504cb06bb40a96c8e04e951fe01854cf6bc921053c954e4a606d9675c6a"
 dependencies = [
  "serde",
 ]
@@ -10093,20 +9803,20 @@ dependencies = [
 
 [[package]]
 name = "serde_derive"
-version = "1.0.219"
+version = "1.0.216"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00"
+checksum = "46f859dbbf73865c6627ed570e78961cd3ac92407a2d117204c49232485da55e"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
 name = "serde_json"
-version = "1.0.140"
+version = "1.0.128"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "20068b6e96dc6c9bd23e01df8827e6c7e1f2fddd43c21810382803c136b99373"
+checksum = "6ff5456707a1de34e7e37f2a6fd3d3f808c318259cbd01ab6377795054b483d8"
 dependencies = [
  "itoa",
  "memchr",
@@ -10160,7 +9870,7 @@ dependencies = [
  "darling",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -10294,9 +10004,9 @@ dependencies = [
 
 [[package]]
 name = "simba"
-version = "0.9.0"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b3a386a501cd104797982c15ae17aafe8b9261315b5d07e3ec803f2ea26be0fa"
+checksum = "061507c94fc6ab4ba1c9a0305018408e312e17c041eb63bef8aa726fa33aceae"
 dependencies = [
  "approx",
  "num-complex",
@@ -10311,7 +10021,7 @@ version = "0.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cae9a3fcdadafb6d97f4c0e007e4247b114ee0f119f650c3cbf3a8b3a1479694"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.6.0",
 ]
 
 [[package]]
@@ -10343,9 +10053,9 @@ checksum = "826167069c09b99d56f31e9ae5c99049e932a98c9dc2dac47645b08dbbf76ba7"
 
 [[package]]
 name = "smallvec"
-version = "1.14.0"
+version = "1.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fcf8323ef1faaee30a44a340193b1ac6814fd9b7b4e88e9d4519a3e4abe1cfd"
+checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
 
 [[package]]
 name = "snap"
@@ -10364,7 +10074,7 @@ dependencies = [
  "chacha20poly1305",
  "curve25519-dalek",
  "rand_core 0.6.4",
- "ring 0.17.14",
+ "ring 0.17.13",
  "rustc_version 0.4.1",
  "sha2 0.10.8",
  "subtle 2.6.1",
@@ -10382,9 +10092,9 @@ dependencies = [
 
 [[package]]
 name = "socket2"
-version = "0.5.9"
+version = "0.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4f5fd57c80058a56cf5c777ab8a126398ece8e442983605d280a44ce79d0edef"
+checksum = "ce305eb0b4296696835b71df73eb912e0f1ffd2556a501fcede6e0c50349191c"
 dependencies = [
  "libc",
  "windows-sys 0.52.0",
@@ -10392,14 +10102,14 @@ dependencies = [
 
 [[package]]
 name = "soketto"
-version = "0.8.1"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e859df029d160cb88608f5d7df7fb4753fd20fdfb4de5644f3d8b8440841721"
+checksum = "37468c595637c10857701c990f93a40ce0e357cedb0953d1c26c8d8027f9bb53"
 dependencies = [
  "base64 0.22.1",
  "bytes",
  "futures",
- "http 1.3.1",
+ "http 1.1.0",
  "httparse",
  "log",
  "rand 0.8.5",
@@ -10425,7 +10135,7 @@ dependencies = [
  "sp-state-machine",
  "sp-trie",
  "sp-version",
- "thiserror 1.0.69",
+ "thiserror",
 ]
 
 [[package]]
@@ -10436,10 +10146,10 @@ dependencies = [
  "Inflector",
  "blake2 0.10.6",
  "expander",
- "proc-macro-crate 3.3.0",
+ "proc-macro-crate 3.2.0",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -10471,7 +10181,7 @@ dependencies = [
 [[package]]
 name = "sp-ark-bls12-381"
 version = "0.4.2"
-source = "git+https://github.com/paritytech/substrate-curves#f08093a5f7c32778eae1295430ec064dccd062a6"
+source = "git+https://github.com/paritytech/substrate-curves#caa2eed74beb885dd07c7db5f916f2281dad818f"
 dependencies = [
  "ark-bls12-381-ext",
  "sp-crypto-ec-utils 0.10.0",
@@ -10502,7 +10212,7 @@ dependencies = [
  "sp-database",
  "sp-runtime",
  "sp-state-machine",
- "thiserror 1.0.69",
+ "thiserror",
  "tracing",
 ]
 
@@ -10518,7 +10228,7 @@ dependencies = [
  "sp-inherents",
  "sp-runtime",
  "sp-state-machine",
- "thiserror 1.0.69",
+ "thiserror",
 ]
 
 [[package]]
@@ -10598,7 +10308,7 @@ dependencies = [
  "futures",
  "hash-db",
  "hash256-std-hasher",
- "impl-serde 0.4.0",
+ "impl-serde",
  "itertools 0.11.0",
  "k256",
  "libsecp256k1",
@@ -10608,7 +10318,7 @@ dependencies = [
  "parity-scale-codec",
  "parking_lot 0.12.3",
  "paste",
- "primitive-types 0.12.2",
+ "primitive-types",
  "rand 0.8.5",
  "scale-info",
  "schnorrkel",
@@ -10623,7 +10333,7 @@ dependencies = [
  "sp-storage 21.0.0",
  "ss58-registry",
  "substrate-bip39",
- "thiserror 1.0.69",
+ "thiserror",
  "tracing",
  "w3f-bls",
  "zeroize",
@@ -10632,7 +10342,7 @@ dependencies = [
 [[package]]
 name = "sp-crypto-ec-utils"
 version = "0.10.0"
-source = "git+https://github.com/paritytech/polkadot-sdk#610ea007aa46a5b12aaef202092ed5a26f699c84"
+source = "git+https://github.com/paritytech/polkadot-sdk#8614dc0e055d06de4a3774ac1da0a422b33f34e2"
 dependencies = [
  "ark-bls12-377",
  "ark-bls12-377-ext",
@@ -10703,7 +10413,7 @@ source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable
 dependencies = [
  "quote",
  "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409)",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -10722,23 +10432,23 @@ source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
 name = "sp-debug-derive"
 version = "14.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk#610ea007aa46a5b12aaef202092ed5a26f699c84"
+source = "git+https://github.com/paritytech/polkadot-sdk#8614dc0e055d06de4a3774ac1da0a422b33f34e2"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
 name = "sp-externalities"
 version = "0.25.0"
-source = "git+https://github.com/paritytech/polkadot-sdk#610ea007aa46a5b12aaef202092ed5a26f699c84"
+source = "git+https://github.com/paritytech/polkadot-sdk#8614dc0e055d06de4a3774ac1da0a422b33f34e2"
 dependencies = [
  "environmental",
  "parity-scale-codec",
@@ -10777,7 +10487,7 @@ dependencies = [
  "parity-scale-codec",
  "scale-info",
  "sp-runtime",
- "thiserror 1.0.69",
+ "thiserror",
 ]
 
 [[package]]
@@ -10791,7 +10501,7 @@ dependencies = [
  "libsecp256k1",
  "log",
  "parity-scale-codec",
- "polkavm-derive 0.9.1",
+ "polkavm-derive",
  "rustversion",
  "secp256k1",
  "sp-core",
@@ -10832,7 +10542,7 @@ name = "sp-maybe-compressed-blob"
 version = "11.0.0"
 source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409#87971b3e92721bdf10bf40b410eaae779d494ca0"
 dependencies = [
- "thiserror 1.0.69",
+ "thiserror",
  "zstd 0.12.4",
 ]
 
@@ -10916,13 +10626,13 @@ dependencies = [
 [[package]]
 name = "sp-runtime-interface"
 version = "24.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk#610ea007aa46a5b12aaef202092ed5a26f699c84"
+source = "git+https://github.com/paritytech/polkadot-sdk#8614dc0e055d06de4a3774ac1da0a422b33f34e2"
 dependencies = [
  "bytes",
  "impl-trait-for-tuples",
  "parity-scale-codec",
- "polkavm-derive 0.18.0",
- "primitive-types 0.13.1",
+ "polkavm-derive",
+ "primitive-types",
  "sp-externalities 0.25.0",
  "sp-runtime-interface-proc-macro 17.0.0",
  "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk)",
@@ -10940,8 +10650,8 @@ dependencies = [
  "bytes",
  "impl-trait-for-tuples",
  "parity-scale-codec",
- "polkavm-derive 0.9.1",
- "primitive-types 0.12.2",
+ "polkavm-derive",
+ "primitive-types",
  "sp-externalities 0.29.0",
  "sp-runtime-interface-proc-macro 18.0.0",
  "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409)",
@@ -10954,14 +10664,14 @@ dependencies = [
 [[package]]
 name = "sp-runtime-interface-proc-macro"
 version = "17.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk#610ea007aa46a5b12aaef202092ed5a26f699c84"
+source = "git+https://github.com/paritytech/polkadot-sdk#8614dc0e055d06de4a3774ac1da0a422b33f34e2"
 dependencies = [
  "Inflector",
  "expander",
- "proc-macro-crate 3.3.0",
+ "proc-macro-crate 3.2.0",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -10971,10 +10681,10 @@ source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable
 dependencies = [
  "Inflector",
  "expander",
- "proc-macro-crate 3.3.0",
+ "proc-macro-crate 3.2.0",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -11019,7 +10729,7 @@ dependencies = [
  "sp-externalities 0.29.0",
  "sp-panic-handler",
  "sp-trie",
- "thiserror 1.0.69",
+ "thiserror",
  "tracing",
  "trie-db",
 ]
@@ -11044,7 +10754,7 @@ dependencies = [
  "sp-externalities 0.29.0",
  "sp-runtime",
  "sp-runtime-interface 28.0.0",
- "thiserror 1.0.69",
+ "thiserror",
  "x25519-dalek",
 ]
 
@@ -11056,14 +10766,14 @@ source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable
 [[package]]
 name = "sp-std"
 version = "14.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk#610ea007aa46a5b12aaef202092ed5a26f699c84"
+source = "git+https://github.com/paritytech/polkadot-sdk#8614dc0e055d06de4a3774ac1da0a422b33f34e2"
 
 [[package]]
 name = "sp-storage"
 version = "19.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk#610ea007aa46a5b12aaef202092ed5a26f699c84"
+source = "git+https://github.com/paritytech/polkadot-sdk#8614dc0e055d06de4a3774ac1da0a422b33f34e2"
 dependencies = [
- "impl-serde 0.5.0",
+ "impl-serde",
  "parity-scale-codec",
  "ref-cast",
  "serde",
@@ -11075,7 +10785,7 @@ name = "sp-storage"
 version = "21.0.0"
 source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409#87971b3e92721bdf10bf40b410eaae779d494ca0"
 dependencies = [
- "impl-serde 0.4.0",
+ "impl-serde",
  "parity-scale-codec",
  "ref-cast",
  "serde",
@@ -11091,18 +10801,18 @@ dependencies = [
  "parity-scale-codec",
  "sp-inherents",
  "sp-runtime",
- "thiserror 1.0.69",
+ "thiserror",
 ]
 
 [[package]]
 name = "sp-tracing"
 version = "16.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk#610ea007aa46a5b12aaef202092ed5a26f699c84"
+source = "git+https://github.com/paritytech/polkadot-sdk#8614dc0e055d06de4a3774ac1da0a422b33f34e2"
 dependencies = [
  "parity-scale-codec",
  "tracing",
  "tracing-core",
- "tracing-subscriber 0.3.19",
+ "tracing-subscriber 0.3.18",
 ]
 
 [[package]]
@@ -11113,7 +10823,7 @@ dependencies = [
  "parity-scale-codec",
  "tracing",
  "tracing-core",
- "tracing-subscriber 0.3.19",
+ "tracing-subscriber 0.3.18",
 ]
 
 [[package]]
@@ -11156,7 +10866,7 @@ dependencies = [
  "schnellru",
  "sp-core",
  "sp-externalities 0.29.0",
- "thiserror 1.0.69",
+ "thiserror",
  "tracing",
  "trie-db",
  "trie-root",
@@ -11167,7 +10877,7 @@ name = "sp-version"
 version = "37.0.0"
 source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409#87971b3e92721bdf10bf40b410eaae779d494ca0"
 dependencies = [
- "impl-serde 0.4.0",
+ "impl-serde",
  "parity-scale-codec",
  "parity-wasm",
  "scale-info",
@@ -11176,7 +10886,7 @@ dependencies = [
  "sp-runtime",
  "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409)",
  "sp-version-proc-macro",
- "thiserror 1.0.69",
+ "thiserror",
 ]
 
 [[package]]
@@ -11187,13 +10897,13 @@ dependencies = [
  "parity-scale-codec",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
 name = "sp-wasm-interface"
 version = "20.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk#610ea007aa46a5b12aaef202092ed5a26f699c84"
+source = "git+https://github.com/paritytech/polkadot-sdk#8614dc0e055d06de4a3774ac1da0a422b33f34e2"
 dependencies = [
  "anyhow",
  "impl-trait-for-tuples",
@@ -11261,11 +10971,21 @@ dependencies = [
  "der",
 ]
 
+[[package]]
+name = "sqlformat"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7bba3a93db0cc4f7bdece8bb09e77e2e785c20bfebf79eb8340ed80708048790"
+dependencies = [
+ "nom",
+ "unicode_categories",
+]
+
 [[package]]
 name = "sqlx"
-version = "0.8.3"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4410e73b3c0d8442c5f99b425d7a435b5ee0ae4167b3196771dd3f7a01be745f"
+checksum = "93334716a037193fac19df402f8571269c84a00852f6a7066b5d2616dcd64d3e"
 dependencies = [
  "sqlx-core",
  "sqlx-macros",
@@ -11274,31 +10994,37 @@ dependencies = [
 
 [[package]]
 name = "sqlx-core"
-version = "0.8.3"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a007b6936676aa9ab40207cde35daab0a04b823be8ae004368c0793b96a61e0"
+checksum = "d4d8060b456358185f7d50c55d9b5066ad956956fddec42ee2e8567134a8936e"
 dependencies = [
+ "atoi",
+ "byteorder",
  "bytes",
  "crc",
  "crossbeam-queue",
  "either",
- "event-listener 5.4.0",
+ "event-listener 5.3.1",
+ "futures-channel",
  "futures-core",
  "futures-intrusive",
  "futures-io",
  "futures-util",
- "hashbrown 0.15.2",
- "hashlink 0.10.0",
- "indexmap 2.8.0",
+ "hashbrown 0.14.5",
+ "hashlink 0.9.1",
+ "hex",
+ "indexmap 2.6.0",
  "log",
  "memchr",
  "native-tls",
  "once_cell",
+ "paste",
  "percent-encoding",
  "serde",
  "sha2 0.10.8",
  "smallvec",
- "thiserror 2.0.12",
+ "sqlformat",
+ "thiserror",
  "tokio",
  "tokio-stream",
  "tracing",
@@ -11307,22 +11033,22 @@ dependencies = [
 
 [[package]]
 name = "sqlx-macros"
-version = "0.8.3"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3112e2ad78643fef903618d78cf0aec1cb3134b019730edb039b69eaf531f310"
+checksum = "cac0692bcc9de3b073e8d747391827297e075c7710ff6276d9f7a1f3d58c6657"
 dependencies = [
  "proc-macro2",
  "quote",
  "sqlx-core",
  "sqlx-macros-core",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
 name = "sqlx-macros-core"
-version = "0.8.3"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e9f90acc5ab146a99bf5061a7eb4976b573f560bc898ef3bf8435448dd5e7ad"
+checksum = "1804e8a7c7865599c9c79be146dc8a9fd8cc86935fa641d3ea58e5f0688abaa5"
 dependencies = [
  "dotenvy",
  "either",
@@ -11336,7 +11062,7 @@ dependencies = [
  "sha2 0.10.8",
  "sqlx-core",
  "sqlx-sqlite",
- "syn 2.0.100",
+ "syn 2.0.90",
  "tempfile",
  "tokio",
  "url",
@@ -11344,9 +11070,9 @@ dependencies = [
 
 [[package]]
 name = "sqlx-sqlite"
-version = "0.8.3"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f85ca71d3a5b24e64e1d08dd8fe36c6c95c339a896cc33068148906784620540"
+checksum = "d5b2cf34a45953bfd3daaf3db0f7a7878ab9b7a6b91b422d24a7a9e4c857b680"
 dependencies = [
  "atoi",
  "flume",
@@ -11367,9 +11093,9 @@ dependencies = [
 
 [[package]]
 name = "ss58-registry"
-version = "1.51.0"
+version = "1.50.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19409f13998e55816d1c728395af0b52ec066206341d939e22e7766df9b494b8"
+checksum = "43fce22ed1df64d04b262351c8f9d5c6da4f76f79f25ad15529792f893fad25d"
 dependencies = [
  "Inflector",
  "num-format",
@@ -11428,9 +11154,9 @@ dependencies = [
 
 [[package]]
 name = "static_init_macro"
-version = "1.0.4"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1389c88ddd739ec6d3f8f83343764a0e944cd23cfbf126a9796a714b0b6edd6f"
+checksum = "70a2595fc3aa78f2d0e45dd425b22282dd863273761cc77780914b2cf3003acf"
 dependencies = [
  "cfg_aliases",
  "memchr",
@@ -11455,7 +11181,7 @@ dependencies = [
  "sctp-proto",
  "serde",
  "sha-1",
- "thiserror 1.0.69",
+ "thiserror",
  "tracing",
 ]
 
@@ -11503,7 +11229,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "rustversion",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -11560,11 +11286,11 @@ version = "0.17.0"
 source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409#87971b3e92721bdf10bf40b410eaae779d494ca0"
 dependencies = [
  "http-body-util",
- "hyper 1.6.0",
+ "hyper 1.5.0",
  "hyper-util",
  "log",
  "prometheus",
- "thiserror 1.0.69",
+ "thiserror",
  "tokio",
 ]
 
@@ -11592,7 +11318,7 @@ dependencies = [
  "sp-version",
  "strum 0.26.3",
  "tempfile",
- "toml 0.8.20",
+ "toml 0.8.19",
  "walkdir",
  "wasm-opt",
 ]
@@ -11607,7 +11333,7 @@ dependencies = [
  "quote",
  "rayon",
  "subtensor-linting",
- "syn 2.0.100",
+ "syn 2.0.90",
  "walkdir",
 ]
 
@@ -11645,7 +11371,7 @@ dependencies = [
  "proc-macro2",
  "procedural-fork",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -11655,7 +11381,7 @@ dependencies = [
  "ahash 0.8.11",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -11693,13 +11419,23 @@ dependencies = [
  "sp-runtime",
 ]
 
+[[package]]
+name = "subtensor-swap-interface"
+version = "0.1.0"
+dependencies = [
+ "frame-support",
+ "parity-scale-codec",
+ "scale-info",
+ "uuid",
+]
+
 [[package]]
 name = "subtensor-tools"
 version = "0.1.0"
 dependencies = [
  "anyhow",
  "clap",
- "semver 1.0.26",
+ "semver 1.0.23",
  "toml_edit",
 ]
 
@@ -11728,9 +11464,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.100"
+version = "2.0.90"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b09a44accad81e1ba1cd74a32461ba89dee89095ba17b32f5d03683b1b1fc2a0"
+checksum = "919d3b74a5dd0ccd15aeb8f93e7006bd9e14c295087c9896a110f490752bcf31"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -11757,25 +11493,25 @@ checksum = "c8af7666ab7b6390ab78131fb5b0fce11d6b7a6951602017c35fa82800708971"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
 name = "system-configuration"
-version = "0.6.1"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c879d448e9d986b661742763247d3693ed13609438cf3d006f51f5368a5ba6b"
+checksum = "ba3a3adc5c275d719af8cb4272ea1c4a6d668a777f37e115f6d11ddbc1c8e0e7"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 1.3.2",
  "core-foundation",
  "system-configuration-sys",
 ]
 
 [[package]]
 name = "system-configuration-sys"
-version = "0.6.0"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e1d1b10ced5ca923a1fcb8d03e96b8d3268065d724548c0211415ff6ac6bac4"
+checksum = "a75fb188eb626b924683e3b95e3a48e63551fcfb51949de2f06a9d91dbee93c9"
 dependencies = [
  "core-foundation-sys",
  "libc",
@@ -11795,14 +11531,14 @@ checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
 
 [[package]]
 name = "tempfile"
-version = "3.19.1"
+version = "3.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7437ac7763b9b123ccf33c338a5cc1bac6f69b45a136c19bdd8a65e3916435bf"
+checksum = "f0f2c9fc62d0beef6951ccffd757e241266a2c833136efbe35af6cd2567dca5b"
 dependencies = [
+ "cfg-if",
  "fastrand",
- "getrandom 0.3.2",
  "once_cell",
- "rustix 1.0.5",
+ "rustix 0.38.37",
  "windows-sys 0.59.0",
 ]
 
@@ -11817,58 +11553,38 @@ dependencies = [
 
 [[package]]
 name = "terminal_size"
-version = "0.4.2"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "45c6481c4829e4cc63825e62c49186a34538b7b2750b73b266581ffb612fb5ed"
+checksum = "4f599bd7ca042cfdf8f4512b277c02ba102247820f9d9d4a9f521f496751a6ef"
 dependencies = [
- "rustix 1.0.5",
+ "rustix 0.38.37",
  "windows-sys 0.59.0",
 ]
 
 [[package]]
 name = "termtree"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f50febec83f5ee1df3015341d8bd429f2d1cc62bcba7ea2076759d315084683"
-
-[[package]]
-name = "thiserror"
-version = "1.0.69"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
-dependencies = [
- "thiserror-impl 1.0.69",
-]
+checksum = "3369f5ac52d5eb6ab48c6b4ffdc8efbcad6b89c765749064ba298f2c68a16a76"
 
 [[package]]
 name = "thiserror"
-version = "2.0.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "567b8a2dae586314f7be2a752ec7474332959c6460e02bde30d702a66d488708"
-dependencies = [
- "thiserror-impl 2.0.12",
-]
-
-[[package]]
-name = "thiserror-impl"
-version = "1.0.69"
+version = "1.0.64"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
+checksum = "d50af8abc119fb8bb6dbabcfa89656f46f84aa0ac7688088608076ad2b459a84"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.100",
+ "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "2.0.12"
+version = "1.0.64"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f7cf42b4507d8ea322120659672cf1b9dbb93f8f2d4ecfd6e51350ff5b17a1d"
+checksum = "08904e7672f5eb876eaaf87e0ce17857500934f4981c4a0ab2b4aa98baac7fc3"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -11908,9 +11624,9 @@ dependencies = [
 
 [[package]]
 name = "time"
-version = "0.3.41"
+version = "0.3.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a7619e19bc266e0f9c5e6686659d394bc57973859340060a69221e57dbc0c40"
+checksum = "5dfd88e563464686c916c7e46e623e520ddc6d79fa6641390f2e3fa86e83e885"
 dependencies = [
  "deranged",
  "itoa",
@@ -11923,15 +11639,15 @@ dependencies = [
 
 [[package]]
 name = "time-core"
-version = "0.1.4"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c9e9a38711f559d9e3ce1cdb06dd7c5b8ea546bc90052da6d06bb76da74bb07c"
+checksum = "ef927ca75afb808a4d64dd374f00a2adf8d0fcff8e7b184af886c3c87ec4a3f3"
 
 [[package]]
 name = "time-macros"
-version = "0.2.22"
+version = "0.2.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3526739392ec93fd8b359c8e98514cb3e8e021beb4e5f597b00a0221f8ed8a49"
+checksum = "3f252a68540fde3a3877aeea552b832b40ab9a69e318efd078774a01ddee1ccf"
 dependencies = [
  "num-conv",
  "time-core",
@@ -11946,21 +11662,11 @@ dependencies = [
  "crunchy",
 ]
 
-[[package]]
-name = "tinystr"
-version = "0.7.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9117f5d4db391c1cf6927e7bea3db74b9a1c1add8f7eda9ffd5364f40f57b82f"
-dependencies = [
- "displaydoc",
- "zerovec",
-]
-
 [[package]]
 name = "tinyvec"
-version = "1.9.0"
+version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09b3661f17e86524eccd4371ab0429194e0d7c008abb45f7a7495b1719463c71"
+checksum = "445e881f4f6d382d5f27c034e25eb92edd7c784ceab92a0937db7f2e9471b938"
 dependencies = [
  "tinyvec_macros",
 ]
@@ -12001,9 +11707,9 @@ dependencies = [
 
 [[package]]
 name = "tokio"
-version = "1.44.1"
+version = "1.40.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f382da615b842244d4b8738c82ed1275e6c5dd90c459a30941cd07080b06c91a"
+checksum = "e2b070231665d27ad9ec9b8df639893f46727666c6767db40317fbe920a5d998"
 dependencies = [
  "backtrace",
  "bytes",
@@ -12012,20 +11718,20 @@ dependencies = [
  "parking_lot 0.12.3",
  "pin-project-lite",
  "signal-hook-registry",
- "socket2 0.5.9",
+ "socket2 0.5.7",
  "tokio-macros",
  "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "tokio-macros"
-version = "2.5.0"
+version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e06d43f1345a3bcd39f6a56dbb7dcab2ba47e68e8ac134855e7e2bdbaf8cab8"
+checksum = "693d596312e88961bc67d7f1f97af8a70227d9f90c31bba5806eec004978d752"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -12040,9 +11746,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-stream"
-version = "0.1.17"
+version = "0.1.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eca58d7bba4a75707817a2c44174253f9236b2d5fbd055602e9d5c07c139a047"
+checksum = "4f4e6ce100d0eb49a2734f8c0812bcd324cf357d21810932c5df6b96ef2b86f1"
 dependencies = [
  "futures-core",
  "pin-project-lite",
@@ -12067,9 +11773,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-util"
-version = "0.7.14"
+version = "0.7.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b9590b93e6fcc1739458317cccd391ad3955e2bde8913edf6f95f9e65a8f034"
+checksum = "61e7c3654c13bcd040d4a03abee2c75b1d14a37b423cf5a813ceae1cc903ec6a"
 dependencies = [
  "bytes",
  "futures-core",
@@ -12090,9 +11796,9 @@ dependencies = [
 
 [[package]]
 name = "toml"
-version = "0.8.20"
+version = "0.8.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd87a5cdd6ffab733b2f74bc4fd7ee5fff6634124999ac278c35fc78c6120148"
+checksum = "a1ed1f98e3fdc28d6d910e6737ae6ab1a93bf1985935a1193e68f93eeb68d24e"
 dependencies = [
  "serde",
  "serde_spanned",
@@ -12111,11 +11817,11 @@ dependencies = [
 
 [[package]]
 name = "toml_edit"
-version = "0.22.24"
+version = "0.22.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "17b4795ff5edd201c7cd6dca065ae59972ce77d1b80fa0a84d94950ece7d1474"
+checksum = "4ae48d6208a266e853d946088ed816055e556cc6028c5e8e2b84d9fa5dd7c7f5"
 dependencies = [
- "indexmap 2.8.0",
+ "indexmap 2.6.0",
  "serde",
  "serde_spanned",
  "toml_datetime",
@@ -12143,9 +11849,9 @@ version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1e9cd434a998747dd2c4276bc96ee2e0c7a2eadf3cae88e52be55a05fa9053f5"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.6.0",
  "bytes",
- "http 1.3.1",
+ "http 1.1.0",
  "http-body 1.0.1",
  "http-body-util",
  "pin-project-lite",
@@ -12167,9 +11873,9 @@ checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3"
 
 [[package]]
 name = "tracing"
-version = "0.1.41"
+version = "0.1.40"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "784e0ac535deb450455cbfa28a6f0df145ea1bb7ae51b821cf5e7927fdcfbdd0"
+checksum = "c3523ab5a71916ccf420eebdf5521fcef02141234bbc0b8a49f2fdc4544364ef"
 dependencies = [
  "log",
  "pin-project-lite",
@@ -12179,20 +11885,20 @@ dependencies = [
 
 [[package]]
 name = "tracing-attributes"
-version = "0.1.28"
+version = "0.1.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "395ae124c09f9e6918a2310af6038fba074bcf474ac352496d5910dd59a2226d"
+checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
 name = "tracing-core"
-version = "0.1.33"
+version = "0.1.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e672c95779cf947c5311f83787af4fa8fffd12fb27e4993211a84bdfd9610f9c"
+checksum = "c06d3da6113f116aaee68e4d601191614c9053067f9ab7f6edbcb161237daa54"
 dependencies = [
  "once_cell",
  "valuable",
@@ -12230,9 +11936,9 @@ dependencies = [
 
 [[package]]
 name = "tracing-subscriber"
-version = "0.3.19"
+version = "0.3.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8189decb5ac0fa7bc8b96b7cb9b2701d60d48805aca84a238004d665fcc4008"
+checksum = "ad0f048c97dbd9faa9b7df56362b8ebcaa52adb06b498c050d2f4e32f90a7a8b"
 dependencies = [
  "matchers",
  "nu-ansi-term",
@@ -12288,7 +11994,7 @@ dependencies = [
  "rand 0.8.5",
  "smallvec",
  "socket2 0.4.10",
- "thiserror 1.0.69",
+ "thiserror",
  "tinyvec",
  "tokio",
  "tracing",
@@ -12313,7 +12019,7 @@ dependencies = [
  "once_cell",
  "rand 0.8.5",
  "smallvec",
- "thiserror 1.0.69",
+ "thiserror",
  "tinyvec",
  "tokio",
  "tracing",
@@ -12335,7 +12041,7 @@ dependencies = [
  "rand 0.8.5",
  "resolv-conf",
  "smallvec",
- "thiserror 1.0.69",
+ "thiserror",
  "tokio",
  "tracing",
  "trust-dns-proto 0.23.2",
@@ -12368,7 +12074,7 @@ dependencies = [
  "rand 0.8.5",
  "rustls 0.21.12",
  "sha1",
- "thiserror 1.0.69",
+ "thiserror",
  "url",
  "utf-8",
 ]
@@ -12396,9 +12102,9 @@ dependencies = [
 
 [[package]]
 name = "typenum"
-version = "1.18.0"
+version = "1.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1dccffe3ce07af9386bfd29e80c0ab1a8205a2fc34e4bcd40364df902cfa8f3f"
+checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
 
 [[package]]
 name = "ucd-trie"
@@ -12418,18 +12124,6 @@ dependencies = [
  "static_assertions",
 ]
 
-[[package]]
-name = "uint"
-version = "0.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "909988d098b2f738727b161a106cfc7cab00c539c2687a8836f8e565976fb53e"
-dependencies = [
- "byteorder",
- "crunchy",
- "hex",
- "static_assertions",
-]
-
 [[package]]
 name = "unarray"
 version = "0.1.4"
@@ -12438,15 +12132,15 @@ checksum = "eaea85b334db583fe3274d12b4cd1880032beab409c0d774be044d4480ab9a94"
 
 [[package]]
 name = "unicode-bidi"
-version = "0.3.18"
+version = "0.3.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c1cb5db39152898a79168971543b1cb5020dff7fe43c8dc468b0885f5e29df5"
+checksum = "5ab17db44d7388991a428b2ee655ce0c212e862eff1768a455c58f9aad6e7893"
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.18"
+version = "1.0.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"
+checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe"
 
 [[package]]
 name = "unicode-normalization"
@@ -12457,17 +12151,11 @@ dependencies = [
  "tinyvec",
 ]
 
-[[package]]
-name = "unicode-segmentation"
-version = "1.12.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493"
-
 [[package]]
 name = "unicode-width"
-version = "0.2.0"
+version = "0.1.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fc81956842c57dac11422a97c3b8195a1ff727f06e85c84ed2e8aa277c9a0fd"
+checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af"
 
 [[package]]
 name = "unicode-xid"
@@ -12475,6 +12163,12 @@ version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
 
+[[package]]
+name = "unicode_categories"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39ec24b3121d976906ece63c9daad25b85969647682eee313cb5779fdd69e14e"
+
 [[package]]
 name = "universal-hash"
 version = "0.5.1"
@@ -12521,12 +12215,12 @@ checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
 
 [[package]]
 name = "url"
-version = "2.5.4"
+version = "2.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32f8b686cadd1473f4bd0117a5d28d36b1ade384ea9b5069a1c40aefed7fda60"
+checksum = "22784dbdf76fdde8af1aeda5622b546b422b6fc585325248a2bf9f5e41e94d6c"
 dependencies = [
  "form_urlencoded",
- "idna 1.0.3",
+ "idna 0.5.0",
  "percent-encoding",
 ]
 
@@ -12536,18 +12230,6 @@ version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9"
 
-[[package]]
-name = "utf16_iter"
-version = "1.0.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c8232dd3cdaed5356e0f716d285e4b40b932ac434100fe9b7e0e8e935b9e6246"
-
-[[package]]
-name = "utf8_iter"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
-
 [[package]]
 name = "utf8parse"
 version = "0.2.2"
@@ -12565,9 +12247,9 @@ dependencies = [
 
 [[package]]
 name = "valuable"
-version = "0.1.1"
+version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65"
+checksum = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d"
 
 [[package]]
 name = "vcpkg"
@@ -12607,7 +12289,7 @@ dependencies = [
  "rand_core 0.6.4",
  "sha2 0.10.8",
  "sha3",
- "thiserror 1.0.69",
+ "thiserror",
  "zeroize",
 ]
 
@@ -12656,48 +12338,47 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.100"
+version = "0.2.93"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1edc8929d7499fc4e8f0be2262a241556cfc54a0bea223790e71446f2aab1ef5"
+checksum = "a82edfc16a6c469f5f44dc7b571814045d60404b55a0ee849f9bcfa2e63dd9b5"
 dependencies = [
  "cfg-if",
  "once_cell",
- "rustversion",
  "wasm-bindgen-macro",
 ]
 
 [[package]]
 name = "wasm-bindgen-backend"
-version = "0.2.100"
+version = "0.2.93"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f0a0651a5c2bc21487bde11ee802ccaf4c51935d0d3d42a6101f98161700bc6"
+checksum = "9de396da306523044d3302746f1208fa71d7532227f15e347e2d93e4145dd77b"
 dependencies = [
  "bumpalo",
  "log",
+ "once_cell",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-futures"
-version = "0.4.50"
+version = "0.4.43"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "555d470ec0bc3bb57890405e5d4322cc9ea83cebb085523ced7be4144dac1e61"
+checksum = "61e9300f63a621e96ed275155c108eb6f843b6a26d053f122ab69724559dc8ed"
 dependencies = [
  "cfg-if",
  "js-sys",
- "once_cell",
  "wasm-bindgen",
  "web-sys",
 ]
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.100"
+version = "0.2.93"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fe63fc6d09ed3792bd0897b314f53de8e16568c2b3f7982f468c0bf9bd0b407"
+checksum = "585c4c91a46b072c92e908d99cb1dcdf95c5218eeb6f3bf1efa991ee7a68cccf"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -12705,25 +12386,22 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.100"
+version = "0.2.93"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de"
+checksum = "afc340c74d9005395cf9dd098506f7f44e38f2b4a21c6aaacf9a105ea5e1e836"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
  "wasm-bindgen-backend",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.100"
+version = "0.2.93"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a05d73b933a847d6cccdda8f838a22ff101ad9bf93e33684f39c1f5f0eece3d"
-dependencies = [
- "unicode-ident",
-]
+checksum = "c62a0a307cb4a311d3a07867860911ca130c3494e8c2719593806c08bc5d0484"
 
 [[package]]
 name = "wasm-instrument"
@@ -12745,7 +12423,7 @@ dependencies = [
  "strum 0.24.1",
  "strum_macros 0.24.3",
  "tempfile",
- "thiserror 1.0.69",
+ "thiserror",
  "wasm-opt-cxx-sys",
  "wasm-opt-sys",
 ]
@@ -12872,7 +12550,7 @@ dependencies = [
  "log",
  "object 0.30.4",
  "target-lexicon",
- "thiserror 1.0.69",
+ "thiserror",
  "wasmparser",
  "wasmtime-cranelift-shared",
  "wasmtime-environ",
@@ -12907,7 +12585,7 @@ dependencies = [
  "object 0.30.4",
  "serde",
  "target-lexicon",
- "thiserror 1.0.69",
+ "thiserror",
  "wasmparser",
  "wasmtime-types",
 ]
@@ -12990,15 +12668,15 @@ checksum = "a4f6fffd2a1011887d57f07654dd112791e872e3ff4a2e626aee8059ee17f06f"
 dependencies = [
  "cranelift-entity",
  "serde",
- "thiserror 1.0.69",
+ "thiserror",
  "wasmparser",
 ]
 
 [[package]]
 name = "web-sys"
-version = "0.3.77"
+version = "0.3.70"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33b6dd2ef9186f1f2072e409e99cd22a975331a6b3591b12c764e0e55c60d5d2"
+checksum = "26fdeaafd9bd129f65e7c031593c24d62186301e0c72c8978fa1678be7d532c0"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
@@ -13010,7 +12688,7 @@ version = "0.22.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ed63aea5ce73d0ff405984102c42de94fc55a6b75765d621c65262469b3c9b53"
 dependencies = [
- "ring 0.17.14",
+ "ring 0.17.13",
  "untrusted 0.9.0",
 ]
 
@@ -13029,14 +12707,14 @@ dependencies = [
  "either",
  "home",
  "once_cell",
- "rustix 0.38.44",
+ "rustix 0.38.37",
 ]
 
 [[package]]
 name = "wide"
-version = "0.7.32"
+version = "0.7.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41b5576b9a81633f3e8df296ce0063042a73507636cbe956c61133dd7034ab22"
+checksum = "b828f995bf1e9622031f8009f8481a85406ce1f4d4588ff746d872043e855690"
 dependencies = [
  "bytemuck",
  "safe_arch",
@@ -13044,9 +12722,9 @@ dependencies = [
 
 [[package]]
 name = "widestring"
-version = "1.2.0"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd7cf3379ca1aac9eea11fba24fd7e315d621f8dfe35c8d7d2be8b793726e07d"
+checksum = "7219d36b6eac893fa81e84ebe06485e7dcbb616177469b142df14f1f4deb1311"
 
 [[package]]
 name = "winapi"
@@ -13081,22 +12759,21 @@ checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
 [[package]]
 name = "windows"
-version = "0.52.0"
+version = "0.51.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e48a53791691ab099e5e2ad123536d0fff50652600abaf43bbf952894110d0be"
+checksum = "ca229916c5ee38c2f2bc1e9d8f04df975b4bd93f9955dc69fabb5d91270045c9"
 dependencies = [
- "windows-core 0.52.0",
- "windows-targets 0.52.6",
+ "windows-core 0.51.1",
+ "windows-targets 0.48.5",
 ]
 
 [[package]]
-name = "windows"
-version = "0.53.0"
+name = "windows-core"
+version = "0.51.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "efc5cf48f83140dcaab716eeaea345f9e93d0018fb81162753a3f76c3397b538"
+checksum = "f1f8cf84f35d2db49a46868f947758c7a1138116f7fac3bc844f43ade1292e64"
 dependencies = [
- "windows-core 0.53.0",
- "windows-targets 0.52.6",
+ "windows-targets 0.48.5",
 ]
 
 [[package]]
@@ -13108,84 +12785,6 @@ dependencies = [
  "windows-targets 0.52.6",
 ]
 
-[[package]]
-name = "windows-core"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9dcc5b895a6377f1ab9fa55acedab1fd5ac0db66ad1e6c7f47e28a22e446a5dd"
-dependencies = [
- "windows-result 0.1.2",
- "windows-targets 0.52.6",
-]
-
-[[package]]
-name = "windows-core"
-version = "0.61.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4763c1de310c86d75a878046489e2e5ba02c649d185f21c67d4cf8a56d098980"
-dependencies = [
- "windows-implement",
- "windows-interface",
- "windows-link",
- "windows-result 0.3.2",
- "windows-strings",
-]
-
-[[package]]
-name = "windows-implement"
-version = "0.60.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a47fddd13af08290e67f4acabf4b459f647552718f683a7b415d290ac744a836"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.100",
-]
-
-[[package]]
-name = "windows-interface"
-version = "0.59.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd9211b69f8dcdfa817bfd14bf1c97c9188afa36f4750130fcdf3f400eca9fa8"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.100",
-]
-
-[[package]]
-name = "windows-link"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76840935b766e1b0a05c0066835fb9ec80071d4c09a16f6bd5f7e655e3c14c38"
-
-[[package]]
-name = "windows-result"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e383302e8ec8515204254685643de10811af0ed97ea37210dc26fb0032647f8"
-dependencies = [
- "windows-targets 0.52.6",
-]
-
-[[package]]
-name = "windows-result"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c64fd11a4fd95df68efcfee5f44a294fe71b8bc6a91993e2791938abcc712252"
-dependencies = [
- "windows-link",
-]
-
-[[package]]
-name = "windows-strings"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a2ba9642430ee452d5a7aa78d72907ebe8cfda358e8cb7918a2050581322f97"
-dependencies = [
- "windows-link",
-]
-
 [[package]]
 name = "windows-sys"
 version = "0.42.0"
@@ -13417,9 +13016,9 @@ checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 
 [[package]]
 name = "winnow"
-version = "0.7.4"
+version = "0.6.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e97b544156e9bebe1a0ffbc03484fc1ffe3100cbce3ffb17eac35f7cdd7ab36"
+checksum = "36c1fec1a2bb5866f07c25f68c26e565c4c200aebb96d7e55710c19d3e8ac49b"
 dependencies = [
  "memchr",
 ]
@@ -13440,21 +13039,9 @@ version = "0.39.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6f42320e61fe2cfd34354ecb597f86f413484a798ba44a8ca1165c58d42da6c1"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.6.0",
 ]
 
-[[package]]
-name = "write16"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d1890f4022759daae28ed4fe62859b1236caebfc61ede2f63ed4e695f3f6d936"
-
-[[package]]
-name = "writeable"
-version = "0.5.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e9df38ee2d2c3c5948ea468a8406ff0db0b29ae1ffde1bcf20ef305bcc95c51"
-
 [[package]]
 name = "wyz"
 version = "0.5.1"
@@ -13489,7 +13076,7 @@ dependencies = [
  "nom",
  "oid-registry 0.6.1",
  "rusticata-macros",
- "thiserror 1.0.69",
+ "thiserror",
  "time",
 ]
 
@@ -13506,7 +13093,7 @@ dependencies = [
  "nom",
  "oid-registry 0.7.1",
  "rusticata-macros",
- "thiserror 1.0.69",
+ "thiserror",
  "time",
 ]
 
@@ -13518,14 +13105,14 @@ dependencies = [
  "Inflector",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
 name = "xml-rs"
-version = "0.8.25"
+version = "0.8.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c5b940ebc25896e71dd073bad2dbaa2abfe97b0a391415e22ad1326d9c54e3c4"
+checksum = "af4e2e2f7cba5a093896c1e150fbfe177d1883e7448200efb81d40b9d339ef26"
 
 [[package]]
 name = "xmltree"
@@ -13560,36 +13147,13 @@ dependencies = [
  "time",
 ]
 
-[[package]]
-name = "yoke"
-version = "0.7.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "120e6aef9aa629e3d4f52dc8cc43a015c7724194c97dfaf45180d2daf2b77f40"
-dependencies = [
- "serde",
- "stable_deref_trait",
- "yoke-derive",
- "zerofrom",
-]
-
-[[package]]
-name = "yoke-derive"
-version = "0.7.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2380878cad4ac9aac1e2435f3eb4020e8374b5f13c296cb75b4620ff8e229154"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.100",
- "synstructure 0.13.1",
-]
-
 [[package]]
 name = "zerocopy"
 version = "0.7.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
 dependencies = [
+ "byteorder",
  "zerocopy-derive 0.7.35",
 ]
 
@@ -13610,7 +13174,7 @@ checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -13621,28 +13185,7 @@ checksum = "a996a8f63c5c4448cd959ac1bab0aaa3306ccfd060472f85943ee0750f0169be"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
-]
-
-[[package]]
-name = "zerofrom"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5"
-dependencies = [
- "zerofrom-derive",
-]
-
-[[package]]
-name = "zerofrom-derive"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.100",
- "synstructure 0.13.1",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -13662,29 +13205,7 @@ checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
-]
-
-[[package]]
-name = "zerovec"
-version = "0.10.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aa2b893d79df23bfb12d5461018d408ea19dfafe76c2c7ef6d4eba614f8ff079"
-dependencies = [
- "yoke",
- "zerofrom",
- "zerovec-derive",
-]
-
-[[package]]
-name = "zerovec-derive"
-version = "0.10.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6eafa6dfb17584ea3e2bd6e76e0cc15ad7af12b09abdd1ca55961bed9b1063c6"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.100",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -13727,9 +13248,9 @@ dependencies = [
 
 [[package]]
 name = "zstd-sys"
-version = "2.0.15+zstd.1.5.7"
+version = "2.0.13+zstd.1.5.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb81183ddd97d0c74cedf1d50d85c8d08c1b8b68ee863bdee9e706eedba1a237"
+checksum = "38ff0f21cfee8f97d94cef41359e0c89aa6113028ab0291aa8ca0038995a95aa"
 dependencies = [
  "cc",
  "pkg-config",
diff --git a/Cargo.toml b/Cargo.toml
index 3b9663e842..d8fc8026ff 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -56,7 +56,7 @@ subtensor-custom-rpc = { default-features = false, path = "pallets/subtensor/rpc
 subtensor-custom-rpc-runtime-api = { default-features = false, path = "pallets/subtensor/runtime-api" }
 subtensor-precompiles = { default-features = false, path = "precompiles" }
 subtensor-runtime-common = { default-features = false, path = "common" }
-pallet-subtensor-swap-interface = { default-features = false, path = "pallets/swap-interface" }
+subtensor-swap-interface = { default-features = false, path = "pallets/swap-interface" }
 
 async-trait = "0.1"
 cargo-husky = { version = "1", default-features = false }
diff --git a/pallets/subtensor/Cargo.toml b/pallets/subtensor/Cargo.toml
index ab17cf5bdc..60d83dd59a 100644
--- a/pallets/subtensor/Cargo.toml
+++ b/pallets/subtensor/Cargo.toml
@@ -44,6 +44,7 @@ hex = { workspace = true }
 share-pool = { default-features = false, path = "../../primitives/share-pool" }
 safe-math = { default-features = false, path = "../../primitives/safe-math" }
 approx = { workspace = true }
+subtensor-swap-interface = { workspace = true }
 
 pallet-collective = { version = "4.0.0-dev", default-features = false, path = "../collective" }
 pallet-drand = { path = "../drand", default-features = false }
@@ -109,7 +110,8 @@ std = [
 	"rand_chacha/std",
 	"safe-math/std",
 	"sha2/std",
-	"share-pool/std"
+	"share-pool/std",
+	"subtensor-swap-interface/std",
 ]
 runtime-benchmarks = [
 	"frame-benchmarking/runtime-benchmarks",
diff --git a/pallets/swap-interface/Cargo.toml b/pallets/swap-interface/Cargo.toml
index 28c05cac3e..e401d7e548 100644
--- a/pallets/swap-interface/Cargo.toml
+++ b/pallets/swap-interface/Cargo.toml
@@ -1,13 +1,17 @@
 [package]
-name = "pallet-subtensor-swap-interface"
+name = "subtensor-swap-interface"
 version = "0.1.0"
 edition.workspace = true
 
 [dependencies]
+codec = { workspace = true }
+frame-support = { workspace = true }
+scale-info = { workspace = true }
+uuid = { workspace = true, features = ["v4"] }
 
 [lints]
 workspace = true
 
 [features]
 default = ["std"]
-std = []
+std = ["codec/std", "frame-support/std", "scale-info/std", "uuid/std"]
diff --git a/pallets/swap-interface/src/lib.rs b/pallets/swap-interface/src/lib.rs
index 0857a2dc09..e05ec1293f 100644
--- a/pallets/swap-interface/src/lib.rs
+++ b/pallets/swap-interface/src/lib.rs
@@ -1,9 +1,8 @@
 #![cfg_attr(not(feature = "std"), no_std)]
 
-extern crate alloc;
-
-use alloc::boxed::Box;
-use core::error::Error;
+use codec::{Decode, Encode, MaxEncodedLen};
+use frame_support::pallet_prelude::*;
+use uuid::Uuid;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum OrderType {
@@ -11,10 +10,39 @@ pub enum OrderType {
     Buy,
 }
 
-pub trait SwapHandler<AccountId> {
-    fn swap(order_t: OrderType, amount: u64) -> Result<(), Box<dyn Error>>;
-    fn add_liquidity(account_id: AccountId, liquidity: u64) -> Result<(u64, u64), Box<dyn Error>>;
-    fn remove_liquidity(account_id: AccountId) -> Result<(u64, u64), Box<dyn Error>>;
+pub trait SwapHandler<AccountId, Error>
+where
+    Error: Into<DispatchError>,
+{
+    fn swap(
+        netuid: u16,
+        order_t: OrderType,
+        amount: u64,
+        price_limit: u64,
+    ) -> Result<SwapResult, Error>;
+    fn add_liquidity(
+        netuid: u16,
+        account_id: &AccountId,
+        tick_low: i32,
+        tick_high: i32,
+        liquidity: u64,
+    ) -> Result<(u64, u64), Error>;
+    fn remove_liquidity(
+        netuid: u16,
+        account_id: &AccountId,
+        position_id: PositionId,
+    ) -> Result<(u64, u64), Error>;
+    fn max_price() -> u64;
+    fn min_price() -> u64;
+}
+
+#[derive(Debug, PartialEq)]
+pub struct SwapResult {
+    pub amount_paid_out: u64,
+    pub refund: u64,
+    // calculated new tao/alpha reserves
+    pub new_tao_reserve: u64,
+    pub new_alpha_reserve: u64,
 }
 
 pub trait LiquidityDataProvider<AccountId> {
@@ -23,3 +51,33 @@ pub trait LiquidityDataProvider<AccountId> {
     fn tao_balance(netuid: u16, account_id: &AccountId) -> u64;
     fn alpha_balance(netuid: u16, account_id: &AccountId) -> u64;
 }
+
+#[derive(
+    Clone, Copy, Decode, Default, Encode, Eq, MaxEncodedLen, PartialEq, RuntimeDebug, TypeInfo,
+)]
+pub struct PositionId([u8; 16]);
+
+impl PositionId {
+    /// Create a new position ID using UUID v4
+    pub fn new() -> Self {
+        Self(Uuid::new_v4().into_bytes())
+    }
+}
+
+impl From<Uuid> for PositionId {
+    fn from(value: Uuid) -> Self {
+        Self(value.into_bytes())
+    }
+}
+
+impl From<PositionId> for Uuid {
+    fn from(value: PositionId) -> Self {
+        Uuid::from_bytes(value.0)
+    }
+}
+
+impl From<[u8; 16]> for PositionId {
+    fn from(value: [u8; 16]) -> Self {
+        Self(value)
+    }
+}
diff --git a/pallets/swap/Cargo.toml b/pallets/swap/Cargo.toml
index 0dac2a0bd3..b99619ecc4 100644
--- a/pallets/swap/Cargo.toml
+++ b/pallets/swap/Cargo.toml
@@ -19,10 +19,8 @@ sp-io = { workspace = true }
 sp-runtime = { workspace = true }
 sp-std = { workspace = true }
 substrate-fixed = { workspace = true }
-uuid = { workspace = true, features = ["v4"] }
-
-pallet-subtensor-swap-interface = { workspace = true }
 
+subtensor-swap-interface = { workspace = true }
 
 [lints]
 workspace = true
@@ -35,7 +33,7 @@ std = [
     "frame-benchmarking/std",
     "frame-support/std",
     "frame-system/std",
-    "pallet-subtensor-swap-interface/std",
+    "subtensor-swap-interface/std",
     "safe-math/std",
     "scale-info/std",
     "serde/std",
@@ -45,7 +43,6 @@ std = [
     "sp-runtime/std",
     "sp-std/std",
     "substrate-fixed/std",
-    "uuid/std",
 ]
 runtime-benchmarks = [
     "frame-benchmarking/runtime-benchmarks",
diff --git a/pallets/swap/src/lib.rs b/pallets/swap/src/lib.rs
index 3d54b425f2..5e52f97cfb 100644
--- a/pallets/swap/src/lib.rs
+++ b/pallets/swap/src/lib.rs
@@ -2,7 +2,7 @@
 
 use codec::{Decode, Encode, MaxEncodedLen};
 use frame_support::pallet_prelude::*;
-use pallet_subtensor_swap_interface::OrderType;
+use subtensor_swap_interface::OrderType;
 use substrate_fixed::types::U64F64;
 
 pub mod pallet;
diff --git a/pallets/swap/src/mock.rs b/pallets/swap/src/mock.rs
index ad4b6fa53d..fea01a52c0 100644
--- a/pallets/swap/src/mock.rs
+++ b/pallets/swap/src/mock.rs
@@ -4,7 +4,7 @@ use frame_support::{
     traits::{ConstU32, Everything},
 };
 use frame_system::{self as system, EnsureRoot};
-use pallet_subtensor_swap_interface::LiquidityDataProvider;
+use subtensor_swap_interface::LiquidityDataProvider;
 use sp_core::H256;
 use sp_runtime::{
     BuildStorage,
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index f91ddad072..aa5726bbc4 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -1,16 +1,16 @@
 use core::marker::PhantomData;
 
 use frame_support::{ensure, traits::Get};
-use pallet_subtensor_swap_interface::LiquidityDataProvider;
 use safe_math::*;
 use sp_arithmetic::helpers_128bit;
 use sp_runtime::traits::AccountIdConversion;
 use substrate_fixed::types::U64F64;
+use subtensor_swap_interface::{LiquidityDataProvider, PositionId, SwapHandler, SwapResult};
 
 use super::pallet::*;
 use crate::{
     NetUid, OrderType, RemoveLiquidityResult, SqrtPrice,
-    position::{Position, PositionId},
+    position::Position,
     tick::{ActiveTickIndexManager, Tick, TickIndex},
 };
 
@@ -227,7 +227,7 @@ impl<T: Config> SwapStep<T> {
         let delta_out = Pallet::<T>::convert_deltas(self.netuid, self.order_type, self.delta_in);
 
         // TODO (look inside method)
-        // Self::update_reserves(netuid, order_type, delta_in, delta_out);
+        // Self::update_reserves(netuid, order_type, self.delta_in, delta_out);
 
         // Get current tick
         let current_tick_index = TickIndex::current_bounded::<T>(self.netuid);
@@ -280,6 +280,7 @@ impl<T: Config> SwapStep<T> {
 
         Ok(SwapStepResult {
             amount_to_take: amount_swapped.saturating_to_num::<u64>(),
+            delat_in: self.delta_in,
             delta_out,
         })
     }
@@ -345,6 +346,7 @@ impl<T: Config> Pallet<T> {
         let mut amount_paid_out: u64 = 0;
         let mut refund: u64 = 0;
         let mut iteration_counter: u16 = 0;
+        let mut in_acc: u64 = 0;
 
         // Swap one tick at a time until we reach one of the stop conditions
         while amount_remaining > 0 {
@@ -354,6 +356,7 @@ impl<T: Config> Pallet<T> {
 
             let swap_result = swap_step.execute()?;
 
+            in_acc = in_acc.saturating_add(swap_result.delat_in);
             amount_remaining = amount_remaining.saturating_sub(swap_result.amount_to_take);
             amount_paid_out = amount_paid_out.saturating_add(swap_result.delta_out);
 
@@ -368,9 +371,25 @@ impl<T: Config> Pallet<T> {
             }
         }
 
+        let tao_reserve = T::LiquidityDataProvider::tao_reserve(netuid.into());
+        let alpha_reserve = T::LiquidityDataProvider::alpha_reserve(netuid.into());
+
+        let (new_tao_reserve, new_alpha_reserve) = match order_type {
+            OrderType::Buy => (
+                tao_reserve.saturating_add(in_acc),
+                alpha_reserve.saturating_sub(amount_paid_out),
+            ),
+            OrderType::Sell => (
+                tao_reserve.saturating_sub(amount_paid_out),
+                alpha_reserve.saturating_add(in_acc),
+            ),
+        };
+
         Ok(SwapResult {
             amount_paid_out,
             refund,
+            new_tao_reserve,
+            new_alpha_reserve,
         })
     }
 
@@ -729,7 +748,7 @@ impl<T: Config> Pallet<T> {
         // If this is a user transaction, withdraw balances and update reserves
         // TODO this should be returned (tao, alpha) from this function to prevent
         // mutation of outside storage - the logic should be passed to the user of
-        // pallet_subtensor_swap_interface
+        // subtensor_swap_interface
         // if !protocol {
         //     let current_price = self.state_ops.get_alpha_sqrt_price();
         //     let (tao, alpha) = position.to_token_amounts(current_price)?;
@@ -915,15 +934,60 @@ impl<T: Config> Pallet<T> {
     }
 }
 
-#[derive(Debug, PartialEq)]
-pub struct SwapResult {
-    amount_paid_out: u64,
-    refund: u64,
+impl<T: Config> SwapHandler<T::AccountId, Error<T>> for Pallet<T> {
+    fn swap(
+        netuid: u16,
+        order_t: OrderType,
+        amount: u64,
+        price_limit: u64,
+    ) -> Result<SwapResult, Error<T>> {
+        let sqrt_price_limit = SqrtPrice::saturating_from_num(price_limit)
+            .checked_sqrt(SqrtPrice::saturating_from_num(2))
+            .ok_or(Error::<T>::PriceLimitExceeded)?;
+
+        Self::swap(NetUid::from(netuid), order_t, amount, sqrt_price_limit)
+    }
+
+    fn add_liquidity(
+        netuid: u16,
+        account_id: &T::AccountId,
+        tick_low: i32,
+        tick_high: i32,
+        liquidity: u64,
+    ) -> Result<(u64, u64), Error<T>> {
+        let tick_low = TickIndex::new(tick_low).map_err(|_| Error::<T>::InvalidTickRange)?;
+        let tick_high = TickIndex::new(tick_high).map_err(|_| Error::<T>::InvalidTickRange)?;
+
+        Self::add_liquidity(netuid.into(), account_id, tick_low, tick_high, liquidity)
+            .map(|(_, tao, alpha)| (tao, alpha))
+    }
+
+    fn remove_liquidity(
+        netuid: u16,
+        account_id: &T::AccountId,
+        position_id: PositionId,
+    ) -> Result<(u64, u64), Error<T>> {
+        Self::remove_liquidity(netuid.into(), account_id, position_id)
+            .map(|result| (result.tao, result.alpha))
+    }
+
+    fn min_price() -> u64 {
+        T::MinSqrtPrice::get()
+            .saturating_mul(T::MinSqrtPrice::get())
+            .saturating_to_num()
+    }
+
+    fn max_price() -> u64 {
+        T::MaxSqrtPrice::get()
+            .saturating_mul(T::MaxSqrtPrice::get())
+            .saturating_to_num()
+    }
 }
 
 #[derive(Debug, PartialEq)]
 struct SwapStepResult {
     amount_to_take: u64,
+    delat_in: u64,
     delta_out: u64,
 }
 
@@ -1382,13 +1446,36 @@ mod tests {
                     // Swap
                     let sqrt_limit_price = SqrtPrice::from_num((limit_price).sqrt());
                     let swap_result =
-                        Pallet::<Test>::swap(netuid, order_type, liquidity, sqrt_limit_price);
+                        Pallet::<Test>::swap(netuid, order_type, liquidity, sqrt_limit_price)
+                            .unwrap();
                     assert_abs_diff_eq!(
-                        swap_result.unwrap().amount_paid_out,
+                        swap_result.amount_paid_out,
                         output_amount,
                         epsilon = output_amount / 100
                     );
 
+                    let (tao_expected, alpha_expected) = match order_type {
+                        OrderType::Buy => (
+                            MockLiquidityProvider::tao_reserve(netuid.into()) + liquidity,
+                            MockLiquidityProvider::alpha_reserve(netuid.into()) - output_amount,
+                        ),
+                        OrderType::Sell => (
+                            MockLiquidityProvider::tao_reserve(netuid.into()) + output_amount,
+                            MockLiquidityProvider::alpha_reserve(netuid.into()) - liquidity,
+                        ),
+                    };
+
+                    assert_abs_diff_eq!(
+                        swap_result.new_alpha_reserve,
+                        alpha_expected,
+                        epsilon = alpha_expected / 100
+                    );
+                    assert_abs_diff_eq!(
+                        swap_result.new_tao_reserve,
+                        tao_expected,
+                        epsilon = tao_expected / 100
+                    );
+
                     // Check that low and high ticks' fees were updated properly, and liquidity values were not updated
                     let tick_low_info = Ticks::<Test>::get(netuid, tick_low).unwrap();
                     let tick_high_info = Ticks::<Test>::get(netuid, tick_high).unwrap();
@@ -1449,17 +1536,6 @@ mod tests {
                         OrderType::Buy => assert!(current_price_after > current_price),
                         OrderType::Sell => assert!(current_price_after < current_price),
                     }
-
-                    // Reserves are updated
-                    // TODO: Add the test
-                    // assert_eq!(
-                    //     swap.state_ops.get_tao_reserve(),
-                    //     tao_withdrawn + protocol_tao,
-                    // );
-                    // assert_eq!(
-                    //     swap.state_ops.get_alpha_reserve(),
-                    //     alpha_withdrawn + protocol_alpha,
-                    // );
                 },
             );
         });
@@ -1502,7 +1578,7 @@ mod tests {
             (-0.01, 0.01, 100_000_000_000_u64),
             (-0.001, 0.001, 100_000_000_000_u64),
         ]
-        .iter()
+        .into_iter()
         .for_each(
             |(price_low_offset, price_high_offset, position_liquidity)| {
                 // Inner part of test case is Order: (order_type, order_liquidity, limit_price, output_amount)
@@ -1525,7 +1601,7 @@ mod tests {
                     (OrderType::Buy, 1.0, 1000.0),
                     (OrderType::Sell, 1.0, 0.0001),
                 ]
-                .iter()
+                .into_iter()
                 .for_each(|(order_type, order_liquidity_fraction, limit_price)| {
                     new_test_ext().execute_with(|| {
                         //////////////////////////////////////////////
@@ -1540,8 +1616,8 @@ mod tests {
                         let current_price =
                             (sqrt_current_price * sqrt_current_price).to_num::<f64>();
 
-                        let price_low = *price_low_offset + current_price;
-                        let price_high = *price_high_offset + current_price;
+                        let price_low = price_low_offset + current_price;
+                        let price_high = price_high_offset + current_price;
                         let tick_low = price_to_tick(price_low);
                         let tick_high = price_to_tick(price_high);
                         let (_position_id, _tao, _alpha) = Pallet::<Test>::add_liquidity(
@@ -1549,7 +1625,7 @@ mod tests {
                             &OK_ACCOUNT_ID,
                             tick_low,
                             tick_high,
-                            *position_liquidity,
+                            position_liquidity,
                         )
                         .unwrap();
 
@@ -1564,7 +1640,7 @@ mod tests {
                         let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
                         assert_abs_diff_eq!(
                             liquidity_before as f64,
-                            protocol_liquidity + *position_liquidity as f64,
+                            protocol_liquidity + position_liquidity as f64,
                             epsilon = liquidity_before as f64 / 10000.
                         );
 
@@ -1572,8 +1648,7 @@ mod tests {
                         // Swap
 
                         // Calculate the expected output amount for the cornercase of one step
-                        let order_liquidity =
-                            *order_liquidity_fraction * *position_liquidity as f64;
+                        let order_liquidity = order_liquidity_fraction * position_liquidity as f64;
 
                         let input_amount = match order_type {
                             OrderType::Buy => order_liquidity * sqrt_current_price.to_num::<f64>(),
@@ -1603,16 +1678,45 @@ mod tests {
                         let sqrt_limit_price = SqrtPrice::from_num((limit_price).sqrt());
                         let swap_result = Pallet::<Test>::swap(
                             netuid,
-                            *order_type,
+                            order_type,
                             order_liquidity as u64,
                             sqrt_limit_price,
-                        );
+                        )
+                        .unwrap();
                         assert_abs_diff_eq!(
-                            swap_result.unwrap().amount_paid_out as f64,
+                            swap_result.amount_paid_out as f64,
                             output_amount,
                             epsilon = output_amount / 10.
                         );
 
+                        if (order_liquidity_fraction <= 0.001)
+                            && (price_low_offset != 0.0)
+                            && (price_high_offset != 0.0)
+                        {
+                            let tao_reserve_f64 = tao_reserve as f64;
+                            let alpha_reserve_f64 = alpha_reserve as f64;
+                            let (tao_expected, alpha_expected) = match order_type {
+                                OrderType::Buy => (
+                                    tao_reserve_f64 + order_liquidity,
+                                    alpha_reserve_f64 - output_amount,
+                                ),
+                                OrderType::Sell => (
+                                    tao_reserve_f64 - output_amount,
+                                    alpha_reserve_f64 + order_liquidity,
+                                ),
+                            };
+                            assert_abs_diff_eq!(
+                                swap_result.new_alpha_reserve as f64,
+                                alpha_expected,
+                                epsilon = alpha_expected / 10.0
+                            );
+                            assert_abs_diff_eq!(
+                                swap_result.new_tao_reserve as f64,
+                                tao_expected,
+                                epsilon = tao_expected / 10.0
+                            );
+                        }
+
                         // Assert that price movement is in correct direction
                         let sqrt_current_price_after = AlphaSqrtPrice::<Test>::get(netuid);
                         let current_price_after =
@@ -1623,9 +1727,9 @@ mod tests {
                         }
 
                         // Assert that for small amounts price stays within the user position
-                        if (*order_liquidity_fraction <= 0.001)
-                            && (*price_low_offset != 0.0)
-                            && (*price_high_offset != 0.0)
+                        if (order_liquidity_fraction <= 0.001)
+                            && (price_low_offset != 0.0)
+                            && (price_high_offset != 0.0)
                         {
                             assert!(current_price_after <= price_high);
                             assert!(current_price_after >= price_low);
@@ -1672,7 +1776,7 @@ mod tests {
                                 .collect::<Vec<_>>();
                         let position = positions.first().unwrap();
 
-                        assert_eq!(position.liquidity, *position_liquidity,);
+                        assert_eq!(position.liquidity, position_liquidity,);
                         assert_eq!(position.tick_low, tick_low);
                         assert_eq!(position.tick_high, tick_high);
                         assert_eq!(position.fees_alpha, 0);
@@ -1680,17 +1784,6 @@ mod tests {
 
                         // Current liquidity is not updated
                         assert_eq!(CurrentLiquidity::<Test>::get(netuid), liquidity_before);
-
-                        // Reserves are updated
-                        // TODO: Add the test
-                        // assert_eq!(
-                        //     swap.state_ops.get_tao_reserve(),
-                        //     tao_withdrawn + protocol_tao,
-                        // );
-                        // assert_eq!(
-                        //     swap.state_ops.get_alpha_reserve(),
-                        //     alpha_withdrawn + protocol_alpha,
-                        // );
                     });
                 });
             },
@@ -1751,11 +1844,11 @@ mod tests {
                 (-0.04, -0.03, 100_000_000_000_u64),
                 (-0.05, -0.03, 100_000_000_000_u64),
             ]
-            .iter()
+            .into_iter()
             .for_each(
                 |(price_low_offset, price_high_offset, position_liquidity)| {
-                    let price_low = *price_low_offset + current_price;
-                    let price_high = *price_high_offset + current_price;
+                    let price_low = price_low_offset + current_price;
+                    let price_high = price_high_offset + current_price;
                     let tick_low = price_to_tick(price_low);
                     let tick_high = price_to_tick(price_high);
                     let (_position_id, _tao, _alpha) = Pallet::<Test>::add_liquidity(
@@ -1763,7 +1856,7 @@ mod tests {
                         &OK_ACCOUNT_ID,
                         tick_low,
                         tick_high,
-                        *position_liquidity,
+                        position_liquidity,
                     )
                     .unwrap();
                 },
@@ -1788,7 +1881,7 @@ mod tests {
                 (OrderType::Buy, 10_000_000_000, 1000.0),
                 (OrderType::Sell, 10_000_000_000, 0.0001),
             ]
-            .iter()
+            .into_iter()
             .for_each(|(order_type, order_liquidity, limit_price)| {
                 //////////////////////////////////////////////
                 // Swap
@@ -1800,29 +1893,57 @@ mod tests {
                     OrderType::Buy => {
                         let denom = sqrt_current_price.to_num::<f64>()
                             * (sqrt_current_price.to_num::<f64>() * liquidity_before as f64
-                                + *order_liquidity as f64);
+                                + order_liquidity as f64);
                         let per_order_liq = liquidity_before as f64 / denom;
-                        per_order_liq * *order_liquidity as f64
+                        per_order_liq * order_liquidity as f64
                     }
                     OrderType::Sell => {
                         let denom = liquidity_before as f64 / sqrt_current_price.to_num::<f64>()
-                            + *order_liquidity as f64;
+                            + order_liquidity as f64;
                         let per_order_liq =
                             sqrt_current_price.to_num::<f64>() * liquidity_before as f64 / denom;
-                        per_order_liq * *order_liquidity as f64
+                        per_order_liq * order_liquidity as f64
                     }
                 };
 
                 // Do the swap
                 let sqrt_limit_price = SqrtPrice::from_num((limit_price).sqrt());
                 let swap_result =
-                    Pallet::<Test>::swap(netuid, *order_type, *order_liquidity, sqrt_limit_price);
+                    Pallet::<Test>::swap(netuid, order_type, order_liquidity, sqrt_limit_price)
+                        .unwrap();
                 assert_abs_diff_eq!(
-                    swap_result.unwrap().amount_paid_out as f64,
+                    swap_result.amount_paid_out as f64,
                     output_amount,
                     epsilon = output_amount / 10.
                 );
 
+                let tao_reserve = MockLiquidityProvider::tao_reserve(netuid.into());
+                let alpha_reserve = MockLiquidityProvider::alpha_reserve(netuid.into());
+                let output_amount = output_amount as u64;
+
+                assert!(output_amount > 0);
+
+                if alpha_reserve > order_liquidity && tao_reserve > order_liquidity {
+                    let (tao_expected, alpha_expected) = match order_type {
+                        OrderType::Buy => {
+                            (tao_reserve + order_liquidity, alpha_reserve - output_amount)
+                        }
+                        OrderType::Sell => {
+                            (tao_reserve - output_amount, alpha_reserve + order_liquidity)
+                        }
+                    };
+                    assert_abs_diff_eq!(
+                        swap_result.new_alpha_reserve,
+                        alpha_expected,
+                        epsilon = alpha_expected / 100
+                    );
+                    assert_abs_diff_eq!(
+                        swap_result.new_tao_reserve,
+                        tao_expected,
+                        epsilon = tao_expected / 100
+                    );
+                }
+
                 // Assert that price movement is in correct direction
                 let sqrt_current_price_after = AlphaSqrtPrice::<Test>::get(netuid);
                 let current_price_after =
@@ -1834,17 +1955,6 @@ mod tests {
 
                 // Current liquidity is not updated
                 assert_eq!(CurrentLiquidity::<Test>::get(netuid), liquidity_before);
-
-                // Reserves are updated
-                // TODO: Add the test
-                // assert_eq!(
-                //     swap.state_ops.get_tao_reserve(),
-                //     tao_withdrawn + protocol_tao,
-                // );
-                // assert_eq!(
-                //     swap.state_ops.get_alpha_reserve(),
-                //     alpha_withdrawn + protocol_alpha,
-                // );
             });
 
             // Current price shouldn't be much different from the original
diff --git a/pallets/swap/src/pallet/mod.rs b/pallets/swap/src/pallet/mod.rs
index 4996d836c1..3b1eaf33d4 100644
--- a/pallets/swap/src/pallet/mod.rs
+++ b/pallets/swap/src/pallet/mod.rs
@@ -1,12 +1,13 @@
 use frame_support::{PalletId, pallet_prelude::*, traits::Get};
 use frame_system::pallet_prelude::*;
-use pallet_subtensor_swap_interface::LiquidityDataProvider;
 use substrate_fixed::types::U64F64;
+use subtensor_swap_interface::{LiquidityDataProvider, PositionId};
 
 use crate::{
-    NetUid, SqrtPrice, weights::WeightInfo,
-    position::{Position, PositionId},
+    NetUid, SqrtPrice,
+    position::Position,
     tick::{LayerLevel, Tick, TickIndex},
+    weights::WeightInfo,
 };
 
 pub use pallet::*;
@@ -31,7 +32,7 @@ mod pallet {
         type AdminOrigin: EnsureOrigin<Self::RuntimeOrigin>;
 
         /// Implementor of
-        /// [`LiquidityDataProvider`](pallet_subtensor_swap_interface::LiquidityDataProvider).
+        /// [`LiquidityDataProvider`](subtensor_swap_interface::LiquidityDataProvider).
         type LiquidityDataProvider: LiquidityDataProvider<Self::AccountId>;
 
         /// This type is used to derive protocol accoun ID.
diff --git a/pallets/swap/src/position.rs b/pallets/swap/src/position.rs
index 2d4e2c77ed..26c1d4d981 100644
--- a/pallets/swap/src/position.rs
+++ b/pallets/swap/src/position.rs
@@ -2,7 +2,7 @@ use codec::{Decode, Encode, MaxEncodedLen};
 use frame_support::pallet_prelude::*;
 use safe_math::*;
 use substrate_fixed::types::U64F64;
-use uuid::Uuid;
+use subtensor_swap_interface::PositionId;
 
 use crate::pallet::{Config, Error, FeeGlobalAlpha, FeeGlobalTao};
 use crate::tick::TickIndex;
@@ -122,33 +122,3 @@ impl Position {
         .saturating_to_num::<u64>()
     }
 }
-
-#[derive(
-    Clone, Copy, Decode, Default, Encode, Eq, MaxEncodedLen, PartialEq, RuntimeDebug, TypeInfo,
-)]
-pub struct PositionId([u8; 16]);
-
-impl PositionId {
-    /// Create a new position ID using UUID v4
-    pub fn new() -> Self {
-        Self(Uuid::new_v4().into_bytes())
-    }
-}
-
-impl From<Uuid> for PositionId {
-    fn from(value: Uuid) -> Self {
-        Self(value.into_bytes())
-    }
-}
-
-impl From<PositionId> for Uuid {
-    fn from(value: PositionId) -> Self {
-        Uuid::from_bytes(value.0)
-    }
-}
-
-impl From<[u8; 16]> for PositionId {
-    fn from(value: [u8; 16]) -> Self {
-        Self(value)
-    }
-}

From 7938582499f2c674056f5ef47bf8b98420de31cd Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Wed, 9 Apr 2025 15:34:06 +0200
Subject: [PATCH 058/418] Configure swap in subtensor module mock

---
 Cargo.lock                             |  1 +
 Cargo.toml                             |  1 +
 pallets/subtensor/Cargo.toml           | 57 ++++++++++++++------------
 pallets/subtensor/src/macros/config.rs |  6 +++
 pallets/subtensor/src/tests/mock.rs    | 46 +++++++++++++++++++++
 pallets/swap-interface/src/lib.rs      | 13 +++---
 pallets/swap/src/lib.rs                |  2 +
 pallets/swap/src/mock.rs               |  4 +-
 pallets/swap/src/pallet/impls.rs       | 15 ++++---
 9 files changed, 103 insertions(+), 42 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index cdb77c5000..4f32fb735d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6655,6 +6655,7 @@ dependencies = [
  "pallet-membership",
  "pallet-preimage",
  "pallet-scheduler",
+ "pallet-subtensor-swap",
  "pallet-transaction-payment",
  "pallet-utility 38.0.0",
  "parity-scale-codec",
diff --git a/Cargo.toml b/Cargo.toml
index d8fc8026ff..56aaaa8368 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -51,6 +51,7 @@ pallet-collective = { default-features = false, path = "pallets/collective" }
 pallet-commitments = { default-features = false, path = "pallets/commitments" }
 pallet-registry = { default-features = false, path = "pallets/registry" }
 pallet-subtensor = { default-features = false, path = "pallets/subtensor" }
+pallet-subtensor-swap = { default-features = false, path = "pallets/swap" }
 safe-math = { default-features = false, path = "primitives/safe-math" }
 subtensor-custom-rpc = { default-features = false, path = "pallets/subtensor/rpc" }
 subtensor-custom-rpc-runtime-api = { default-features = false, path = "pallets/subtensor/runtime-api" }
diff --git a/pallets/subtensor/Cargo.toml b/pallets/subtensor/Cargo.toml
index 60d83dd59a..0024991ee1 100644
--- a/pallets/subtensor/Cargo.toml
+++ b/pallets/subtensor/Cargo.toml
@@ -50,7 +50,9 @@ pallet-collective = { version = "4.0.0-dev", default-features = false, path = ".
 pallet-drand = { path = "../drand", default-features = false }
 pallet-membership = { workspace = true }
 hex-literal = { workspace = true }
-num-traits = { version = "0.2.19", default-features = false, features = ["libm"] }
+num-traits = { version = "0.2.19", default-features = false, features = [
+	"libm",
+] }
 tle = { workspace = true, default-features = false }
 ark-bls12-381 = { workspace = true, default-features = false }
 ark-serialize = { workspace = true, default-features = false }
@@ -61,6 +63,7 @@ rand_chacha = { workspace = true }
 [dev-dependencies]
 pallet-balances = { workspace = true, features = ["std"] }
 pallet-scheduler = { workspace = true }
+pallet-subtensor-swap = { workspace = true }
 sp-version = { workspace = true }
 # Substrate
 sp-tracing = { workspace = true }
@@ -73,58 +76,60 @@ pallet-preimage = { workspace = true }
 [features]
 default = ["std"]
 std = [
+	"ark-bls12-381/std",
+	"ark-serialize/std",
 	"codec/std",
 	"frame-benchmarking/std",
 	"frame-support/std",
 	"frame-system/std",
-	"scale-info/std",
+	"hex/std",
+	"libsecp256k1/std",
+	"log/std",
+	"ndarray/std",
+	"num-traits/std",
+	"pallet-balances/std",
 	"pallet-collective/std",
+	"pallet-drand/std",
 	"pallet-membership/std",
-	"substrate-fixed/std",
-	"pallet-balances/std",
 	"pallet-preimage/std",
 	"pallet-scheduler/std",
+	"pallet-subtensor-swap/std",
 	"pallet-transaction-payment/std",
 	"pallet-utility/std",
+	"rand_chacha/std",
+	"safe-math/std",
+	"scale-info/std",
+	"serde/std",
+	"serde_bytes/std",
+	"serde_json/std",
+	"serde_with/std",
+	"sha2/std",
+	"share-pool/std",
 	"sp-core/std",
 	"sp-io/std",
 	"sp-runtime/std",
 	"sp-std/std",
 	"sp-tracing/std",
 	"sp-version/std",
-	"hex/std",
-	"libsecp256k1/std",
-	"log/std",
-	"ndarray/std",
-	"serde/std",
-	"serde_bytes/std",
-	"serde_with/std",
 	"substrate-fixed/std",
-	"num-traits/std",
-	"serde_json/std",
+	"substrate-fixed/std",
+	"subtensor-swap-interface/std",
 	"tle/std",
-	"pallet-drand/std",
-	"ark-bls12-381/std",
-	"ark-serialize/std",
 	"w3f-bls/std",
-	"rand_chacha/std",
-	"safe-math/std",
-	"sha2/std",
-	"share-pool/std",
-	"subtensor-swap-interface/std",
 ]
 runtime-benchmarks = [
 	"frame-benchmarking/runtime-benchmarks",
 	"frame-support/runtime-benchmarks",
 	"frame-system/runtime-benchmarks",
 	"pallet-balances/runtime-benchmarks",
-	"pallet-membership/runtime-benchmarks",
-	"pallet-utility/runtime-benchmarks",
-	"sp-runtime/runtime-benchmarks",
 	"pallet-collective/runtime-benchmarks",
+	"pallet-drand/runtime-benchmarks",
+	"pallet-membership/runtime-benchmarks",
 	"pallet-preimage/runtime-benchmarks",
 	"pallet-scheduler/runtime-benchmarks",
-	"pallet-drand/runtime-benchmarks"
+	"pallet-subtensor-swap/runtime-benchmarks",
+	"pallet-utility/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
 ]
 try-runtime = [
 	"frame-support/try-runtime",
@@ -137,7 +142,7 @@ try-runtime = [
 	"pallet-utility/try-runtime",
 	"sp-runtime/try-runtime",
 	"pallet-collective/try-runtime",
-	"pallet-drand/try-runtime"
+	"pallet-drand/try-runtime",
 ]
 pow-faucet = []
 fast-blocks = []
diff --git a/pallets/subtensor/src/macros/config.rs b/pallets/subtensor/src/macros/config.rs
index cf4d97b65b..23f117522c 100644
--- a/pallets/subtensor/src/macros/config.rs
+++ b/pallets/subtensor/src/macros/config.rs
@@ -5,6 +5,9 @@ use frame_support::pallet_macros::pallet_section;
 /// This can later be imported into the pallet using [`import_section`].
 #[pallet_section]
 mod config {
+    use frame_support::pallet_prelude::*;
+    use subtensor_swap_interface::SwapHandler;
+
     /// Configure the pallet by specifying the parameters and types on which it depends.
     #[pallet::config]
     pub trait Config: frame_system::Config + pallet_drand::Config {
@@ -47,6 +50,9 @@ mod config {
         /// the preimage to store the call data.
         type Preimages: QueryPreimage<H = Self::Hashing> + StorePreimage;
 
+        /// Swap interface.
+        type SwapInterface: SwapHandler<Self::AccountId>;
+
         /// =================================
         /// ==== Initial Value Constants ====
         /// =================================
diff --git a/pallets/subtensor/src/tests/mock.rs b/pallets/subtensor/src/tests/mock.rs
index 9729d55d1a..bcdb166d1e 100644
--- a/pallets/subtensor/src/tests/mock.rs
+++ b/pallets/subtensor/src/tests/mock.rs
@@ -18,6 +18,9 @@ use sp_runtime::{
     traits::{BlakeTwo256, IdentityLookup},
 };
 use sp_std::cmp::Ordering;
+use subtensor_swap_interface::LiquidityDataProvider;
+use substrate_fixed::types::U64F64;
+use frame_support::PalletId;
 
 use crate::*;
 
@@ -38,6 +41,7 @@ frame_support::construct_runtime!(
         Scheduler: pallet_scheduler::{Pallet, Call, Storage, Event<T>} = 9,
         Preimage: pallet_preimage::{Pallet, Call, Storage, Event<T>} = 10,
         Drand: pallet_drand::{Pallet, Call, Storage, Event<T>} = 11,
+        Swap: pallet_subtensor_swap::{Pallet, Call, Storage, Event<T>} = 12,
     }
 );
 
@@ -410,6 +414,48 @@ impl crate::Config for Test {
     type InitialTaoWeight = InitialTaoWeight;
     type InitialEmaPriceHalvingPeriod = InitialEmaPriceHalvingPeriod;
     type DurationOfStartCall = DurationOfStartCall;
+	type SwapInterface = Swap;
+}
+
+impl LiquidityDataProvider<AccountId> for SubtensorModule {
+    fn tao_reserve(netuid: u16) -> u64 {
+        SubnetTAO::<Test>::get(netuid)
+    }
+
+    fn alpha_reserve(netuid: u16) -> u64 {
+        SubnetAlphaIn::<Test>::get(netuid)
+    }
+
+    fn tao_balance(account_id: &AccountId) -> u64 {
+        Balances::free_balance(account_id)
+    }
+
+    fn alpha_balance(netuid: u16, account_id: &AccountId) -> u64 {
+        TotalHotkeyAlpha::<Test>::get(account_id, netuid)
+    }
+}
+
+// Swap-related parameter types
+parameter_types! {
+	pub const SwapProtocolId: PalletId = PalletId(*b"ten/swap");
+	pub const SwapMaxFeeRate: u16 = 10000; // 15.26%
+	pub const SwapMaxPositions: u32 = 100;
+	pub const SwapMinimumLiquidity: u64 = 1_000;
+	pub SwapMinSqrtPrice: U64F64 = U64F64::from_num(0.001);
+	pub SwapMaxSqrtPrice: U64F64 = U64F64::from_num(10.0);
+}
+
+impl pallet_subtensor_swap::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type AdminOrigin = EnsureRoot<AccountId>;
+	type LiquidityDataProvider = SubtensorModule;
+	type ProtocolId = SwapProtocolId;
+	type MaxFeeRate = SwapMaxFeeRate;
+	type MaxPositions = SwapMaxPositions;
+	type MinimumLiquidity = SwapMinimumLiquidity;
+	type MinSqrtPrice = SwapMinSqrtPrice;
+	type MaxSqrtPrice = SwapMaxSqrtPrice;
+	type WeightInfo = ();
 }
 
 pub struct OriginPrivilegeCmp;
diff --git a/pallets/swap-interface/src/lib.rs b/pallets/swap-interface/src/lib.rs
index e05ec1293f..df0aacd0d7 100644
--- a/pallets/swap-interface/src/lib.rs
+++ b/pallets/swap-interface/src/lib.rs
@@ -10,28 +10,25 @@ pub enum OrderType {
     Buy,
 }
 
-pub trait SwapHandler<AccountId, Error>
-where
-    Error: Into<DispatchError>,
-{
+pub trait SwapHandler<AccountId> {
     fn swap(
         netuid: u16,
         order_t: OrderType,
         amount: u64,
         price_limit: u64,
-    ) -> Result<SwapResult, Error>;
+    ) -> Result<SwapResult, DispatchError>;
     fn add_liquidity(
         netuid: u16,
         account_id: &AccountId,
         tick_low: i32,
         tick_high: i32,
         liquidity: u64,
-    ) -> Result<(u64, u64), Error>;
+    ) -> Result<(u64, u64), DispatchError>;
     fn remove_liquidity(
         netuid: u16,
         account_id: &AccountId,
         position_id: PositionId,
-    ) -> Result<(u64, u64), Error>;
+    ) -> Result<(u64, u64), DispatchError>;
     fn max_price() -> u64;
     fn min_price() -> u64;
 }
@@ -48,7 +45,7 @@ pub struct SwapResult {
 pub trait LiquidityDataProvider<AccountId> {
     fn tao_reserve(netuid: u16) -> u64;
     fn alpha_reserve(netuid: u16) -> u64;
-    fn tao_balance(netuid: u16, account_id: &AccountId) -> u64;
+    fn tao_balance(account_id: &AccountId) -> u64;
     fn alpha_balance(netuid: u16, account_id: &AccountId) -> u64;
 }
 
diff --git a/pallets/swap/src/lib.rs b/pallets/swap/src/lib.rs
index 5e52f97cfb..e25daae60d 100644
--- a/pallets/swap/src/lib.rs
+++ b/pallets/swap/src/lib.rs
@@ -10,6 +10,8 @@ mod position;
 mod tick;
 pub mod weights;
 
+pub use pallet::*;
+
 #[cfg(feature = "runtime-benchmarks")]
 pub mod benchmarking;
 
diff --git a/pallets/swap/src/mock.rs b/pallets/swap/src/mock.rs
index fea01a52c0..83a15b004d 100644
--- a/pallets/swap/src/mock.rs
+++ b/pallets/swap/src/mock.rs
@@ -4,13 +4,13 @@ use frame_support::{
     traits::{ConstU32, Everything},
 };
 use frame_system::{self as system, EnsureRoot};
-use subtensor_swap_interface::LiquidityDataProvider;
 use sp_core::H256;
 use sp_runtime::{
     BuildStorage,
     traits::{BlakeTwo256, IdentityLookup},
 };
 use substrate_fixed::types::U64F64;
+use subtensor_swap_interface::LiquidityDataProvider;
 
 use crate::SqrtPrice;
 
@@ -83,7 +83,7 @@ impl LiquidityDataProvider<AccountId> for MockLiquidityProvider {
         4_000_000_000
     }
 
-    fn tao_balance(_: u16, account_id: &AccountId) -> u64 {
+    fn tao_balance(account_id: &AccountId) -> u64 {
         if *account_id == OK_ACCOUNT_ID {
             100_000_000_000_000
         } else {
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index aa5726bbc4..d6b8d029ac 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -1,6 +1,6 @@
 use core::marker::PhantomData;
 
-use frame_support::{ensure, traits::Get};
+use frame_support::{ensure, traits::Get, pallet_prelude::DispatchError};
 use safe_math::*;
 use sp_arithmetic::helpers_128bit;
 use sp_runtime::traits::AccountIdConversion;
@@ -694,7 +694,7 @@ impl<T: Config> Pallet<T> {
         let position_id = position.id;
 
         ensure!(
-            T::LiquidityDataProvider::tao_balance(netuid.into(), account_id) >= tao
+            T::LiquidityDataProvider::tao_balance(account_id) >= tao
                 && T::LiquidityDataProvider::alpha_balance(netuid.into(), account_id) >= alpha,
             Error::<T>::InsufficientBalance
         );
@@ -934,18 +934,19 @@ impl<T: Config> Pallet<T> {
     }
 }
 
-impl<T: Config> SwapHandler<T::AccountId, Error<T>> for Pallet<T> {
+impl<T: Config> SwapHandler<T::AccountId> for Pallet<T> {
     fn swap(
         netuid: u16,
         order_t: OrderType,
         amount: u64,
         price_limit: u64,
-    ) -> Result<SwapResult, Error<T>> {
+    ) -> Result<SwapResult, DispatchError> {
         let sqrt_price_limit = SqrtPrice::saturating_from_num(price_limit)
             .checked_sqrt(SqrtPrice::saturating_from_num(2))
             .ok_or(Error::<T>::PriceLimitExceeded)?;
 
         Self::swap(NetUid::from(netuid), order_t, amount, sqrt_price_limit)
+            .map_err(Into::into)
     }
 
     fn add_liquidity(
@@ -954,21 +955,23 @@ impl<T: Config> SwapHandler<T::AccountId, Error<T>> for Pallet<T> {
         tick_low: i32,
         tick_high: i32,
         liquidity: u64,
-    ) -> Result<(u64, u64), Error<T>> {
+    ) -> Result<(u64, u64), DispatchError> {
         let tick_low = TickIndex::new(tick_low).map_err(|_| Error::<T>::InvalidTickRange)?;
         let tick_high = TickIndex::new(tick_high).map_err(|_| Error::<T>::InvalidTickRange)?;
 
         Self::add_liquidity(netuid.into(), account_id, tick_low, tick_high, liquidity)
             .map(|(_, tao, alpha)| (tao, alpha))
+            .map_err(Into::into)
     }
 
     fn remove_liquidity(
         netuid: u16,
         account_id: &T::AccountId,
         position_id: PositionId,
-    ) -> Result<(u64, u64), Error<T>> {
+    ) -> Result<(u64, u64), DispatchError> {
         Self::remove_liquidity(netuid.into(), account_id, position_id)
             .map(|result| (result.tao, result.alpha))
+            .map_err(Into::into)
     }
 
     fn min_price() -> u64 {

From afc595ff0094b2fb218ae00176c720489e097c49 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Wed, 9 Apr 2025 16:21:21 +0200
Subject: [PATCH 059/418] Fix TickIndex bounded price calculation

---
 pallets/swap/src/tick.rs | 42 +++++++++++++++++++++++++++++-----------
 1 file changed, 31 insertions(+), 11 deletions(-)

diff --git a/pallets/swap/src/tick.rs b/pallets/swap/src/tick.rs
index 0476fafd29..45f6ce810a 100644
--- a/pallets/swap/src/tick.rs
+++ b/pallets/swap/src/tick.rs
@@ -184,6 +184,16 @@ impl TickIndex {
     /// so that tick indexes are positive, which simplifies bit logic
     const OFFSET: Self = Self(MAX_TICK);
 
+    /// The MIN sqrt price, which is caclculated at Self::MIN
+    pub fn min_sqrt_price() -> SqrtPrice {
+        SqrtPrice::saturating_from_num(0.0000000002328350195)
+    }
+
+    /// The MAX sqrt price, which is calculated at Self::MAX
+    pub fn max_sqrt_price() -> SqrtPrice {
+        SqrtPrice::saturating_from_num(4294886577.20989222513899790805)
+    }
+
     /// Get fees above a tick
     pub fn fees_above<T: Config>(&self, netuid: NetUid, quote: bool) -> U64F64 {
         let current_tick = Self::current_bounded::<T>(netuid);
@@ -251,9 +261,7 @@ impl TickIndex {
         match Self::try_from_sqrt_price(sqrt_price) {
             Ok(index) => index,
             Err(_) => {
-                let max_price = Self::MAX
-                    .try_to_sqrt_price()
-                    .unwrap_or(SqrtPrice::saturating_from_num(1000));
+                let max_price = Self::MAX.to_sqrt_price_bounded();
 
                 if sqrt_price > max_price {
                     Self::MAX
@@ -274,9 +282,9 @@ impl TickIndex {
     pub fn to_sqrt_price_bounded(&self) -> SqrtPrice {
         self.try_to_sqrt_price().unwrap_or_else(|_| {
             if *self >= Self::MAX {
-                SqrtPrice::saturating_from_num(1000)
+                Self::max_sqrt_price()
             } else {
-                SqrtPrice::saturating_from_num(0.000001)
+                Self::min_sqrt_price()
             }
         })
     }
@@ -687,7 +695,7 @@ impl BitmapLayer {
 
 /// A bitmap representation of a tick index position across the three-layer structure
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct TickIndexBitmap {
+pub(crate) struct TickIndexBitmap {
     /// The position in layer 0 (top layer)
     layer0: BitmapLayer,
     /// The position in layer 1 (middle layer)
@@ -710,12 +718,12 @@ impl TickIndexBitmap {
 
     /// Converts a position (word, bit) within a layer to a word index in the next layer down
     /// Note: This returns a bitmap navigation index, NOT a tick index
-    pub fn layer_to_index(layer: BitmapLayer) -> u32 {
+    pub(crate) fn layer_to_index(layer: BitmapLayer) -> u32 {
         layer.word.saturating_mul(128).saturating_add(layer.bit)
     }
 
     /// Get the mask for a bit in the specified layer
-    pub fn bit_mask(&self, layer: LayerLevel) -> u128 {
+    pub(crate) fn bit_mask(&self, layer: LayerLevel) -> u128 {
         match layer {
             LayerLevel::Top => 1u128 << self.layer0.bit,
             LayerLevel::Middle => 1u128 << self.layer1.bit,
@@ -724,7 +732,7 @@ impl TickIndexBitmap {
     }
 
     /// Get the word for the specified layer
-    pub fn word_at(&self, layer: LayerLevel) -> u32 {
+    pub(crate) fn word_at(&self, layer: LayerLevel) -> u32 {
         match layer {
             LayerLevel::Top => self.layer0.word,
             LayerLevel::Middle => self.layer1.word,
@@ -733,7 +741,7 @@ impl TickIndexBitmap {
     }
 
     /// Get the bit for the specified layer
-    pub fn bit_at(&self, layer: LayerLevel) -> u32 {
+    pub(crate) fn bit_at(&self, layer: LayerLevel) -> u32 {
         match layer {
             LayerLevel::Top => self.layer0.bit,
             LayerLevel::Middle => self.layer1.bit,
@@ -754,7 +762,7 @@ impl TickIndexBitmap {
     /// * Exact match: Vec with [next_bit, bit]
     /// * Non-exact match: Vec with [closest_bit]
     /// * No match: Empty Vec
-    pub fn find_closest_active_bit_candidates(word: u128, bit: u32, lower: bool) -> Vec<u32> {
+    pub(crate) fn find_closest_active_bit_candidates(word: u128, bit: u32, lower: bool) -> Vec<u32> {
         let mut result = vec![];
         let mut mask: u128 = 1_u128.wrapping_shl(bit);
         let mut active_bit: u32 = bit;
@@ -1295,6 +1303,18 @@ mod tests {
             Err(TickMathError::TickOutOfBounds),
         );
 
+        assert!(
+            TickIndex::MAX.try_to_sqrt_price().unwrap().abs_diff(
+                TickIndex::new_unchecked(TickIndex::MAX.get() + 1).to_sqrt_price_bounded()
+            ) < SqrtPrice::from_num(1e-6)
+        );
+
+        assert!(
+            TickIndex::MIN.try_to_sqrt_price().unwrap().abs_diff(
+                TickIndex::new_unchecked(TickIndex::MIN.get() - 1).to_sqrt_price_bounded()
+            ) < SqrtPrice::from_num(1e-6)
+        );
+
         // At tick index 0, the sqrt price should be 1.0
         let sqrt_price = TickIndex(0).try_to_sqrt_price().unwrap();
         assert_eq!(sqrt_price, SqrtPrice::from_num(1.0));

From cb73353e80e79e5879885577cd782c4ecda01a6b Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Wed, 9 Apr 2025 16:45:28 +0200
Subject: [PATCH 060/418] Remove Min/MaxSqrtPrice from swap Config

---
 pallets/subtensor/src/staking/add_stake.rs    |  5 ++-
 pallets/subtensor/src/staking/move_stake.rs   |  2 +
 pallets/subtensor/src/staking/remove_stake.rs |  3 +-
 pallets/subtensor/src/staking/stake_utils.rs  | 10 +----
 pallets/subtensor/src/tests/mock.rs           | 34 +++++++---------
 pallets/swap/src/mock.rs                      |  4 --
 pallets/swap/src/pallet/impls.rs              | 39 ++++++-------------
 pallets/swap/src/pallet/mod.rs                |  8 ----
 pallets/swap/src/tick.rs                      |  6 ++-
 9 files changed, 41 insertions(+), 70 deletions(-)

diff --git a/pallets/subtensor/src/staking/add_stake.rs b/pallets/subtensor/src/staking/add_stake.rs
index e599262cef..ee7cde7e46 100644
--- a/pallets/subtensor/src/staking/add_stake.rs
+++ b/pallets/subtensor/src/staking/add_stake.rs
@@ -1,5 +1,6 @@
 use super::*;
 use substrate_fixed::types::I96F32;
+use subtensor_swap_interface::SwapHandler;
 
 impl<T: Config> Pallet<T> {
     /// ---- The implementation for the extrinsic add_stake: Adds stake to a hotkey account.
@@ -63,13 +64,12 @@ impl<T: Config> Pallet<T> {
 
         // 4. Swap the stake into alpha on the subnet and increase counters.
         // Emit the staking event.
-        let fee = DefaultStakingFee::<T>::get();
         Self::stake_into_subnet(
             &hotkey,
             &coldkey,
             netuid,
             tao_staked.saturating_to_num::<u64>(),
-            fee,
+            T::SwapInterface::max_price(),
         );
 
         // Ok and return.
@@ -165,6 +165,7 @@ impl<T: Config> Pallet<T> {
             &coldkey,
             netuid,
             tao_staked.saturating_to_num::<u64>(),
+            limit_price,
             fee,
         );
 
diff --git a/pallets/subtensor/src/staking/move_stake.rs b/pallets/subtensor/src/staking/move_stake.rs
index 4198d29efc..68c681ef03 100644
--- a/pallets/subtensor/src/staking/move_stake.rs
+++ b/pallets/subtensor/src/staking/move_stake.rs
@@ -2,6 +2,7 @@ use super::*;
 use safe_math::*;
 use sp_core::Get;
 use substrate_fixed::types::{U64F64, U96F32};
+use subtensor_swap_interface::SwapHandler;
 
 impl<T: Config> Pallet<T> {
     /// Moves stake from one hotkey to another across subnets.
@@ -369,6 +370,7 @@ impl<T: Config> Pallet<T> {
                 destination_coldkey,
                 destination_netuid,
                 tao_unstaked,
+				T::SwapInterface::max_price(),
                 fee,
             );
         }
diff --git a/pallets/subtensor/src/staking/remove_stake.rs b/pallets/subtensor/src/staking/remove_stake.rs
index 842e9d0b9d..5ff490b01b 100644
--- a/pallets/subtensor/src/staking/remove_stake.rs
+++ b/pallets/subtensor/src/staking/remove_stake.rs
@@ -1,5 +1,6 @@
 use super::*;
 use substrate_fixed::types::U96F32;
+use subtensor_swap_interface::SwapHandler;
 
 impl<T: Config> Pallet<T> {
     /// ---- The implementation for the extrinsic remove_stake: Removes stake from a hotkey account and adds it onto a coldkey.
@@ -269,7 +270,7 @@ impl<T: Config> Pallet<T> {
             &coldkey,
             Self::get_root_netuid(),
             total_tao_unstaked,
-            0, // no fee for restaking
+            T::SwapInterface::max_price(),
         );
 
         // 5. Done and ok.
diff --git a/pallets/subtensor/src/staking/stake_utils.rs b/pallets/subtensor/src/staking/stake_utils.rs
index d00c478444..b11db6d531 100644
--- a/pallets/subtensor/src/staking/stake_utils.rs
+++ b/pallets/subtensor/src/staking/stake_utils.rs
@@ -829,16 +829,10 @@ impl<T: Config> Pallet<T> {
         coldkey: &T::AccountId,
         netuid: u16,
         tao: u64,
-        fee: u64,
+		price_limit: u64,
     ) -> u64 {
-        // Step 1. Reduce tao amount by staking fee and credit this fee to SubnetTAO
-        // At this point tao was already withdrawn from the user balance and is considered
-        // available
-        let tao_staked = tao.saturating_sub(fee);
-        let actual_fee = tao.saturating_sub(tao_staked);
-
         // Step 2. Swap the tao to alpha.
-        let alpha: u64 = Self::swap_tao_for_alpha(netuid, tao_staked);
+        let alpha = Self::swap_tao_for_alpha(netuid, tao_staked);
         let mut actual_alpha = 0;
         if (tao_staked > 0) && (alpha > 0) {
             // Step 3: Increase the alpha on the hotkey account.
diff --git a/pallets/subtensor/src/tests/mock.rs b/pallets/subtensor/src/tests/mock.rs
index bcdb166d1e..c4fb5a5f29 100644
--- a/pallets/subtensor/src/tests/mock.rs
+++ b/pallets/subtensor/src/tests/mock.rs
@@ -1,5 +1,6 @@
 #![allow(clippy::arithmetic_side_effects, clippy::unwrap_used)]
 use crate::utils::rate_limiting::TransactionType;
+use frame_support::PalletId;
 use frame_support::derive_impl;
 use frame_support::dispatch::DispatchResultWithPostInfo;
 use frame_support::weights::Weight;
@@ -18,9 +19,8 @@ use sp_runtime::{
     traits::{BlakeTwo256, IdentityLookup},
 };
 use sp_std::cmp::Ordering;
-use subtensor_swap_interface::LiquidityDataProvider;
 use substrate_fixed::types::U64F64;
-use frame_support::PalletId;
+use subtensor_swap_interface::LiquidityDataProvider;
 
 use crate::*;
 
@@ -414,7 +414,7 @@ impl crate::Config for Test {
     type InitialTaoWeight = InitialTaoWeight;
     type InitialEmaPriceHalvingPeriod = InitialEmaPriceHalvingPeriod;
     type DurationOfStartCall = DurationOfStartCall;
-	type SwapInterface = Swap;
+    type SwapInterface = Swap;
 }
 
 impl LiquidityDataProvider<AccountId> for SubtensorModule {
@@ -437,25 +437,21 @@ impl LiquidityDataProvider<AccountId> for SubtensorModule {
 
 // Swap-related parameter types
 parameter_types! {
-	pub const SwapProtocolId: PalletId = PalletId(*b"ten/swap");
-	pub const SwapMaxFeeRate: u16 = 10000; // 15.26%
-	pub const SwapMaxPositions: u32 = 100;
-	pub const SwapMinimumLiquidity: u64 = 1_000;
-	pub SwapMinSqrtPrice: U64F64 = U64F64::from_num(0.001);
-	pub SwapMaxSqrtPrice: U64F64 = U64F64::from_num(10.0);
+    pub const SwapProtocolId: PalletId = PalletId(*b"ten/swap");
+    pub const SwapMaxFeeRate: u16 = 10000; // 15.26%
+    pub const SwapMaxPositions: u32 = 100;
+    pub const SwapMinimumLiquidity: u64 = 1_000;
 }
 
 impl pallet_subtensor_swap::Config for Test {
-	type RuntimeEvent = RuntimeEvent;
-	type AdminOrigin = EnsureRoot<AccountId>;
-	type LiquidityDataProvider = SubtensorModule;
-	type ProtocolId = SwapProtocolId;
-	type MaxFeeRate = SwapMaxFeeRate;
-	type MaxPositions = SwapMaxPositions;
-	type MinimumLiquidity = SwapMinimumLiquidity;
-	type MinSqrtPrice = SwapMinSqrtPrice;
-	type MaxSqrtPrice = SwapMaxSqrtPrice;
-	type WeightInfo = ();
+    type RuntimeEvent = RuntimeEvent;
+    type AdminOrigin = EnsureRoot<AccountId>;
+    type LiquidityDataProvider = SubtensorModule;
+    type ProtocolId = SwapProtocolId;
+    type MaxFeeRate = SwapMaxFeeRate;
+    type MaxPositions = SwapMaxPositions;
+    type MinimumLiquidity = SwapMinimumLiquidity;
+    type WeightInfo = ();
 }
 
 pub struct OriginPrivilegeCmp;
diff --git a/pallets/swap/src/mock.rs b/pallets/swap/src/mock.rs
index 83a15b004d..5732152e34 100644
--- a/pallets/swap/src/mock.rs
+++ b/pallets/swap/src/mock.rs
@@ -67,8 +67,6 @@ parameter_types! {
     pub const MaxFeeRate: u16 = 10000; // 15.26%
     pub const MaxPositions: u32 = 100;
     pub const MinimumLiquidity: u64 = 1_000;
-    pub MinSqrtPrice: SqrtPrice = U64F64::from_num(0.001);
-    pub MaxSqrtPrice: SqrtPrice = U64F64::from_num(10.0);
 }
 
 // Mock implementor of LiquidityDataProvider trait
@@ -108,8 +106,6 @@ impl crate::pallet::Config for Test {
     type MaxFeeRate = MaxFeeRate;
     type MaxPositions = MaxPositions;
     type MinimumLiquidity = MinimumLiquidity;
-    type MinSqrtPrice = MinSqrtPrice;
-    type MaxSqrtPrice = MaxSqrtPrice;
     type WeightInfo = ();
 }
 
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index d6b8d029ac..c7ee5e4b1f 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -1,6 +1,6 @@
 use core::marker::PhantomData;
 
-use frame_support::{ensure, traits::Get, pallet_prelude::DispatchError};
+use frame_support::{ensure, pallet_prelude::DispatchError, traits::Get};
 use safe_math::*;
 use sp_arithmetic::helpers_128bit;
 use sp_runtime::traits::AccountIdConversion;
@@ -80,14 +80,14 @@ impl<T: Config> SwapStep<T> {
         };
         let mut lim_quantity = match order_type {
             OrderType::Buy => one
-                .safe_div(T::MinSqrtPrice::get())
+                .safe_div(TickIndex::min_sqrt_price())
                 .min(one.safe_div(sqrt_price_limit.into())),
-            OrderType::Sell => T::MaxSqrtPrice::get().min(sqrt_price_limit.into()),
+            OrderType::Sell => TickIndex::max_sqrt_price().min(sqrt_price_limit.into()),
         };
         if lim_quantity < one.safe_div(current_price) {
             lim_quantity = match order_type {
-                OrderType::Buy => one.safe_div(T::MinSqrtPrice::get()),
-                OrderType::Sell => T::MaxSqrtPrice::get(),
+                OrderType::Buy => one.safe_div(TickIndex::min_sqrt_price()),
+                OrderType::Sell => TickIndex::max_sqrt_price(),
             };
         }
 
@@ -423,7 +423,7 @@ impl<T: Config> Pallet<T> {
         (match order_type {
             OrderType::Buy => {
                 let higher_tick =
-                    Pallet::<T>::find_closest_higher_active_tick_index(netuid, current_price_tick)
+                    ActiveTickIndexManager::find_closest_higher::<T>(netuid, current_price_tick)
                         .unwrap_or(TickIndex::MAX);
                 if higher_tick < TickIndex::MAX {
                     higher_tick.saturating_add(1)
@@ -432,7 +432,7 @@ impl<T: Config> Pallet<T> {
                 }
             }
             OrderType::Sell => {
-                Pallet::<T>::find_closest_lower_active_tick_index(netuid, current_price_tick)
+                ActiveTickIndexManager::find_closest_lower::<T>(netuid, current_price_tick)
                     .unwrap_or(TickIndex::MIN)
             }
         })
@@ -633,20 +633,6 @@ impl<T: Config> Pallet<T> {
             .and_then(|ti| Ticks::<T>::get(netuid, ti))
     }
 
-    pub fn find_closest_lower_active_tick_index(
-        netuid: NetUid,
-        index: TickIndex,
-    ) -> Option<TickIndex> {
-        ActiveTickIndexManager::find_closest_lower::<T>(netuid, index)
-    }
-
-    pub fn find_closest_higher_active_tick_index(
-        netuid: NetUid,
-        index: TickIndex,
-    ) -> Option<TickIndex> {
-        ActiveTickIndexManager::find_closest_higher::<T>(netuid, index)
-    }
-
     /// Here we subtract minimum safe liquidity from current liquidity to stay in the safe range
     fn current_liquidity_safe(netuid: NetUid) -> U64F64 {
         U64F64::saturating_from_num(
@@ -945,8 +931,7 @@ impl<T: Config> SwapHandler<T::AccountId> for Pallet<T> {
             .checked_sqrt(SqrtPrice::saturating_from_num(2))
             .ok_or(Error::<T>::PriceLimitExceeded)?;
 
-        Self::swap(NetUid::from(netuid), order_t, amount, sqrt_price_limit)
-            .map_err(Into::into)
+        Self::swap(NetUid::from(netuid), order_t, amount, sqrt_price_limit).map_err(Into::into)
     }
 
     fn add_liquidity(
@@ -975,14 +960,14 @@ impl<T: Config> SwapHandler<T::AccountId> for Pallet<T> {
     }
 
     fn min_price() -> u64 {
-        T::MinSqrtPrice::get()
-            .saturating_mul(T::MinSqrtPrice::get())
+        TickIndex::min_sqrt_price()
+            .saturating_mul(TickIndex::min_sqrt_price())
             .saturating_to_num()
     }
 
     fn max_price() -> u64 {
-        T::MaxSqrtPrice::get()
-            .saturating_mul(T::MaxSqrtPrice::get())
+        TickIndex::max_sqrt_price()
+            .saturating_mul(TickIndex::max_sqrt_price())
             .saturating_to_num()
     }
 }
diff --git a/pallets/swap/src/pallet/mod.rs b/pallets/swap/src/pallet/mod.rs
index 3b1eaf33d4..4a259dc794 100644
--- a/pallets/swap/src/pallet/mod.rs
+++ b/pallets/swap/src/pallet/mod.rs
@@ -51,14 +51,6 @@ mod pallet {
         #[pallet::constant]
         type MinimumLiquidity: Get<u64>;
 
-        /// Minimum sqrt price across all active ticks
-        #[pallet::constant]
-        type MinSqrtPrice: Get<SqrtPrice>;
-
-        /// Maximum sqrt price across all active ticks
-        #[pallet::constant]
-        type MaxSqrtPrice: Get<SqrtPrice>;
-
         /// Weight information for extrinsics in this pallet.
         type WeightInfo: WeightInfo;
     }
diff --git a/pallets/swap/src/tick.rs b/pallets/swap/src/tick.rs
index 45f6ce810a..6e6d4ab5bf 100644
--- a/pallets/swap/src/tick.rs
+++ b/pallets/swap/src/tick.rs
@@ -762,7 +762,11 @@ impl TickIndexBitmap {
     /// * Exact match: Vec with [next_bit, bit]
     /// * Non-exact match: Vec with [closest_bit]
     /// * No match: Empty Vec
-    pub(crate) fn find_closest_active_bit_candidates(word: u128, bit: u32, lower: bool) -> Vec<u32> {
+    pub(crate) fn find_closest_active_bit_candidates(
+        word: u128,
+        bit: u32,
+        lower: bool,
+    ) -> Vec<u32> {
         let mut result = vec![];
         let mut mask: u128 = 1_u128.wrapping_shl(bit);
         let mut active_bit: u32 = bit;

From 00b7044ab58ccff0f7a96399fcafa4fedb58d0cb Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Thu, 10 Apr 2025 19:05:19 +0200
Subject: [PATCH 061/418] Adapt stake_into_subnet to swap v3

---
 pallets/subtensor/src/macros/events.rs        |  2 +-
 pallets/subtensor/src/staking/add_stake.rs    |  6 +-
 pallets/subtensor/src/staking/move_stake.rs   |  7 +-
 pallets/subtensor/src/staking/remove_stake.rs |  2 +-
 pallets/subtensor/src/staking/stake_utils.rs  | 64 ++++++++++---------
 pallets/swap/src/pallet/impls.rs              | 57 ++++++++---------
 6 files changed, 68 insertions(+), 70 deletions(-)

diff --git a/pallets/subtensor/src/macros/events.rs b/pallets/subtensor/src/macros/events.rs
index 8c2e863d0e..e4f3a6abd8 100644
--- a/pallets/subtensor/src/macros/events.rs
+++ b/pallets/subtensor/src/macros/events.rs
@@ -14,7 +14,7 @@ mod events {
         /// a network is removed.
         NetworkRemoved(u16),
         /// stake has been transferred from the a coldkey account onto the hotkey staking account.
-        StakeAdded(T::AccountId, T::AccountId, u64, u64, u16, u64),
+        StakeAdded(T::AccountId, T::AccountId, u64, u64, u16),
         /// stake has been removed from the hotkey staking account onto the coldkey account.
         StakeRemoved(T::AccountId, T::AccountId, u64, u64, u16, u64),
         /// stake has been moved from origin (hotkey, subnet ID) to destination (hotkey, subnet ID) of this amount (in TAO).
diff --git a/pallets/subtensor/src/staking/add_stake.rs b/pallets/subtensor/src/staking/add_stake.rs
index ee7cde7e46..55bafb2771 100644
--- a/pallets/subtensor/src/staking/add_stake.rs
+++ b/pallets/subtensor/src/staking/add_stake.rs
@@ -70,7 +70,7 @@ impl<T: Config> Pallet<T> {
             netuid,
             tao_staked.saturating_to_num::<u64>(),
             T::SwapInterface::max_price(),
-        );
+        )?;
 
         // Ok and return.
         Ok(())
@@ -159,15 +159,13 @@ impl<T: Config> Pallet<T> {
 
         // 6. Swap the stake into alpha on the subnet and increase counters.
         // Emit the staking event.
-        let fee = DefaultStakingFee::<T>::get();
         Self::stake_into_subnet(
             &hotkey,
             &coldkey,
             netuid,
             tao_staked.saturating_to_num::<u64>(),
             limit_price,
-            fee,
-        );
+        )?;
 
         // Ok and return.
         Ok(())
diff --git a/pallets/subtensor/src/staking/move_stake.rs b/pallets/subtensor/src/staking/move_stake.rs
index 68c681ef03..77ba296e21 100644
--- a/pallets/subtensor/src/staking/move_stake.rs
+++ b/pallets/subtensor/src/staking/move_stake.rs
@@ -309,7 +309,7 @@ impl<T: Config> Pallet<T> {
         maybe_limit_price: Option<u64>,
         maybe_allow_partial: Option<bool>,
         check_transfer_toggle: bool,
-    ) -> Result<u64, Error<T>> {
+    ) -> Result<u64, DispatchError> {
         // Calculate the maximum amount that can be executed
         let max_amount = if let Some(limit_price) = maybe_limit_price {
             Self::get_max_amount_move(origin_netuid, destination_netuid, limit_price)
@@ -370,9 +370,8 @@ impl<T: Config> Pallet<T> {
                 destination_coldkey,
                 destination_netuid,
                 tao_unstaked,
-				T::SwapInterface::max_price(),
-                fee,
-            );
+                T::SwapInterface::max_price(),
+            )?;
         }
 
         Ok(tao_unstaked.saturating_sub(fee))
diff --git a/pallets/subtensor/src/staking/remove_stake.rs b/pallets/subtensor/src/staking/remove_stake.rs
index 5ff490b01b..5449e48d61 100644
--- a/pallets/subtensor/src/staking/remove_stake.rs
+++ b/pallets/subtensor/src/staking/remove_stake.rs
@@ -271,7 +271,7 @@ impl<T: Config> Pallet<T> {
             Self::get_root_netuid(),
             total_tao_unstaked,
             T::SwapInterface::max_price(),
-        );
+        )?;
 
         // 5. Done and ok.
         Ok(())
diff --git a/pallets/subtensor/src/staking/stake_utils.rs b/pallets/subtensor/src/staking/stake_utils.rs
index b11db6d531..c4b102fa6b 100644
--- a/pallets/subtensor/src/staking/stake_utils.rs
+++ b/pallets/subtensor/src/staking/stake_utils.rs
@@ -3,6 +3,7 @@ use safe_math::*;
 use share_pool::{SharePool, SharePoolDataOperations};
 use sp_std::ops::Neg;
 use substrate_fixed::types::{I64F64, I96F32, U64F64, U96F32, U110F18};
+use subtensor_swap_interface::{OrderType, SwapHandler};
 
 impl<T: Config> Pallet<T> {
     /// Retrieves the total alpha issuance for a given subnet.
@@ -829,55 +830,58 @@ impl<T: Config> Pallet<T> {
         coldkey: &T::AccountId,
         netuid: u16,
         tao: u64,
-		price_limit: u64,
-    ) -> u64 {
-        // Step 2. Swap the tao to alpha.
-        let alpha = Self::swap_tao_for_alpha(netuid, tao_staked);
-        let mut actual_alpha = 0;
-        if (tao_staked > 0) && (alpha > 0) {
-            // Step 3: Increase the alpha on the hotkey account.
-            actual_alpha = Self::increase_stake_for_hotkey_and_coldkey_on_subnet(
-                hotkey, coldkey, netuid, alpha,
-            );
+        price_limit: u64,
+    ) -> Result<u64, DispatchError> {
+        // Swap the tao to alpha.
+        let swap_result = T::SwapInterface::swap(netuid, OrderType::Buy, tao, price_limit)?;
 
-            // Step 4: Update the list of hotkeys staking for this coldkey
-            let mut staking_hotkeys = StakingHotkeys::<T>::get(coldkey);
-            if !staking_hotkeys.contains(hotkey) {
-                staking_hotkeys.push(hotkey.clone());
-                StakingHotkeys::<T>::insert(coldkey, staking_hotkeys.clone());
-            }
+        // Increase the alpha on the hotkey account.
+        if Self::increase_stake_for_hotkey_and_coldkey_on_subnet(
+            hotkey,
+            coldkey,
+            netuid,
+            swap_result.amount_paid_out,
+        ) == 0
+            || swap_result.amount_paid_out == 0
+        {
+            return Ok(0);
+        }
+
+        // Step 4: Update the list of hotkeys staking for this coldkey
+        let mut staking_hotkeys = StakingHotkeys::<T>::get(coldkey);
+        if !staking_hotkeys.contains(hotkey) {
+            staking_hotkeys.push(hotkey.clone());
+            StakingHotkeys::<T>::insert(coldkey, staking_hotkeys.clone());
         }
 
-        // Step 5. Increase Tao reserves by the fee amount.
+        // Update TAO reserves
         SubnetTAO::<T>::mutate(netuid, |total| {
-            *total = total.saturating_add(actual_fee);
+            *total = swap_result.new_tao_reserve;
         });
-        TotalStake::<T>::mutate(|total| {
-            *total = total.saturating_add(actual_fee);
+        SubnetAlphaIn::<T>::mutate(netuid, |total| {
+            *total = swap_result.new_alpha_reserve;
         });
         LastColdkeyHotkeyStakeBlock::<T>::insert(coldkey, hotkey, Self::get_current_block_as_u64());
 
-        // Step 6. Deposit and log the staking event.
+        // Deposit and log the staking event.
         Self::deposit_event(Event::StakeAdded(
             coldkey.clone(),
             hotkey.clone(),
-            tao_staked,
-            actual_alpha,
+            tao,
+            swap_result.amount_paid_out,
             netuid,
-            actual_fee,
         ));
+
         log::debug!(
-            "StakeAdded( coldkey: {:?}, hotkey:{:?}, tao: {:?}, alpha:{:?}, netuid: {:?}, fee: {:?} )",
+            "StakeAdded( coldkey: {:?}, hotkey:{:?}, tao: {:?}, alpha:{:?}, netuid: {:?} )",
             coldkey.clone(),
             hotkey.clone(),
-            tao_staked,
-            actual_alpha,
+            tao,
+            swap_result.amount_paid_out,
             netuid,
-            actual_fee
         );
 
-        // Step 7: Return the amount of alpha staked
-        actual_alpha
+        Ok(swap_result.amount_paid_out)
     }
 
     pub fn get_alpha_share_pool(
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index c7ee5e4b1f..42a66062ba 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -130,7 +130,7 @@ impl<T: Config> SwapStep<T> {
             } else {
                 // Stop at limit price (refund needed)
                 self.action = SwapStepAction::StopIn;
-                self.delta_in = Pallet::<T>::delta_in(
+                self.delta_in = Self::delta_in(
                     self.order_type,
                     self.current_liquidity,
                     self.current_price,
@@ -145,7 +145,7 @@ impl<T: Config> SwapStep<T> {
             if self.edge_quantity < self.lim_quantity {
                 // Cross at edge price
                 self.action = SwapStepAction::Crossing;
-                self.delta_in = Pallet::<T>::delta_in(
+                self.delta_in = Self::delta_in(
                     self.order_type,
                     self.current_liquidity,
                     self.current_price,
@@ -156,7 +156,7 @@ impl<T: Config> SwapStep<T> {
             } else if self.edge_quantity > self.lim_quantity {
                 // Stop at limit price (refund needed)
                 self.action = SwapStepAction::StopIn;
-                self.delta_in = Pallet::<T>::delta_in(
+                self.delta_in = Self::delta_in(
                     self.order_type,
                     self.current_liquidity,
                     self.current_price,
@@ -167,7 +167,7 @@ impl<T: Config> SwapStep<T> {
             } else {
                 // Stop on edge (refund needed)
                 self.action = SwapStepAction::StopOn;
-                self.delta_in = Pallet::<T>::delta_in(
+                self.delta_in = Self::delta_in(
                     self.order_type,
                     self.current_liquidity,
                     self.current_price,
@@ -181,7 +181,7 @@ impl<T: Config> SwapStep<T> {
         else {
             if self.target_quantity <= self.lim_quantity {
                 // Stop on edge price
-                self.delta_in = Pallet::<T>::delta_in(
+                self.delta_in = Self::delta_in(
                     self.order_type,
                     self.current_liquidity,
                     self.current_price,
@@ -197,7 +197,7 @@ impl<T: Config> SwapStep<T> {
             } else {
                 // Stop at limit price (refund needed)
                 self.action = SwapStepAction::StopIn;
-                self.delta_in = Pallet::<T>::delta_in(
+                self.delta_in = Self::delta_in(
                     self.order_type,
                     self.current_liquidity,
                     self.current_price,
@@ -226,9 +226,6 @@ impl<T: Config> SwapStep<T> {
         Pallet::<T>::add_fees(self.netuid, self.order_type, fee);
         let delta_out = Pallet::<T>::convert_deltas(self.netuid, self.order_type, self.delta_in);
 
-        // TODO (look inside method)
-        // Self::update_reserves(netuid, order_type, self.delta_in, delta_out);
-
         // Get current tick
         let current_tick_index = TickIndex::current_bounded::<T>(self.netuid);
 
@@ -284,6 +281,27 @@ impl<T: Config> SwapStep<T> {
             delta_out,
         })
     }
+
+    /// Get the input amount needed to reach the target price
+    fn delta_in(
+        order_type: OrderType,
+        liquidity_curr: U64F64,
+        sqrt_price_curr: U64F64,
+        sqrt_price_target: SqrtPrice,
+    ) -> u64 {
+        let one = U64F64::saturating_from_num(1);
+
+        (match order_type {
+            OrderType::Sell => liquidity_curr.saturating_mul(
+                one.safe_div(sqrt_price_target.into())
+                    .saturating_sub(one.safe_div(sqrt_price_curr)),
+            ),
+            OrderType::Buy => {
+                liquidity_curr.saturating_mul(sqrt_price_target.saturating_sub(sqrt_price_curr))
+            }
+        })
+        .saturating_to_num::<u64>()
+    }
 }
 
 impl<T: Config> Pallet<T> {
@@ -573,27 +591,6 @@ impl<T: Config> Pallet<T> {
         }
     }
 
-    /// Get the input amount needed to reach the target price
-    fn delta_in(
-        order_type: OrderType,
-        liquidity_curr: U64F64,
-        sqrt_price_curr: U64F64,
-        sqrt_price_target: SqrtPrice,
-    ) -> u64 {
-        let one = U64F64::saturating_from_num(1);
-
-        (match order_type {
-            OrderType::Sell => liquidity_curr.saturating_mul(
-                one.safe_div(sqrt_price_target.into())
-                    .saturating_sub(one.safe_div(sqrt_price_curr)),
-            ),
-            OrderType::Buy => {
-                liquidity_curr.saturating_mul(sqrt_price_target.saturating_sub(sqrt_price_curr))
-            }
-        })
-        .saturating_to_num::<u64>()
-    }
-
     /// Update liquidity when crossing a tick
     fn update_liquidity_at_crossing(netuid: NetUid, order_type: OrderType) -> Result<(), Error<T>> {
         let mut liquidity_curr = CurrentLiquidity::<T>::get(netuid);

From 9dd3320230459972269c68e81fb461ed079461b6 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Thu, 10 Apr 2025 18:46:41 -0400
Subject: [PATCH 062/418] Add modify_position method to swap

---
 pallets/admin-utils/src/tests/mock.rs |  21 +++++
 pallets/swap/src/pallet/impls.rs      | 110 ++++++++++++++++++++++++++
 pallets/swap/src/pallet/mod.rs        |   3 +
 3 files changed, 134 insertions(+)

diff --git a/pallets/admin-utils/src/tests/mock.rs b/pallets/admin-utils/src/tests/mock.rs
index 99c11b7165..d18ecac12d 100644
--- a/pallets/admin-utils/src/tests/mock.rs
+++ b/pallets/admin-utils/src/tests/mock.rs
@@ -32,6 +32,7 @@ frame_support::construct_runtime!(
         Drand: pallet_drand::{Pallet, Call, Storage, Event<T>} = 6,
         Grandpa: pallet_grandpa = 7,
         EVMChainId: pallet_evm_chain_id = 8,
+        Swap: pallet_subtensor_swap::{Pallet, Call, Storage, Event<T>} = 9,
     }
 );
 
@@ -201,6 +202,7 @@ impl pallet_subtensor::Config for Test {
     type InitialTaoWeight = InitialTaoWeight;
     type InitialEmaPriceHalvingPeriod = InitialEmaPriceHalvingPeriod;
     type DurationOfStartCall = DurationOfStartCall;
+    type SwapInterface = Swap;
 }
 
 #[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
@@ -259,6 +261,25 @@ impl pallet_balances::Config for Test {
     type RuntimeHoldReason = ();
 }
 
+// Swap-related parameter types
+parameter_types! {
+    pub const SwapProtocolId: PalletId = PalletId(*b"ten/swap");
+    pub const SwapMaxFeeRate: u16 = 10000; // 15.26%
+    pub const SwapMaxPositions: u32 = 100;
+    pub const SwapMinimumLiquidity: u64 = 1_000;
+}
+
+impl pallet_subtensor_swap::Config for Test {
+    type RuntimeEvent = RuntimeEvent;
+    type AdminOrigin = EnsureRoot<AccountId>;
+    type LiquidityDataProvider = SubtensorModule;
+    type ProtocolId = SwapProtocolId;
+    type MaxFeeRate = SwapMaxFeeRate;
+    type MaxPositions = SwapMaxPositions;
+    type MinimumLiquidity = SwapMinimumLiquidity;
+    type WeightInfo = ();
+}
+
 pub struct OriginPrivilegeCmp;
 
 impl PrivilegeCmp<OriginCaller> for OriginPrivilegeCmp {
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 42a66062ba..151d2a8757 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -682,6 +682,12 @@ impl<T: Config> Pallet<T> {
             Error::<T>::InsufficientBalance
         );
 
+        // Small delta is not allowed
+        ensure!(
+            liquidity >= T::MinimumLiquidity::get(),
+            Error::<T>::InvalidLiquidityValue
+        );
+
         Positions::<T>::insert(&(netuid, account_id, position.id), position);
 
         Ok((position_id, tao, alpha))
@@ -805,6 +811,110 @@ impl<T: Config> Pallet<T> {
         })
     }
 
+    fn modify_position(
+        netuid: NetUid,
+        account_id: &T::AccountId,
+        position_id: PositionId,
+        liquidity_delta: i64,
+    ) -> Result<RemoveLiquidityResult, Error<T>> {
+        // Find the position
+        let Some(mut position) = Positions::<T>::get((netuid, account_id, position_id)) else {
+            return Err(Error::<T>::LiquidityNotFound);
+        };
+
+        // Small delta is not allowed
+        ensure!(
+            liquidity_delta.abs() >= T::MinimumLiquidity::get() as i64,
+            Error::<T>::InvalidLiquidityValue
+        );
+        let mut delta_liquidity_abs = liquidity_delta.abs() as u64;
+
+        // Determine the effective price for token calculations
+        let current_price = AlphaSqrtPrice::<T>::get(netuid);
+        let sqrt_pa: SqrtPrice = position
+            .tick_low
+            .try_to_sqrt_price()
+            .map_err(|_| Error::<T>::InvalidTickRange)?;
+        let sqrt_pb: SqrtPrice = position
+            .tick_high
+            .try_to_sqrt_price()
+            .map_err(|_| Error::<T>::InvalidTickRange)?;
+        let sqrt_price_box = if current_price < sqrt_pa {
+            sqrt_pa
+        } else if current_price > sqrt_pb {
+            sqrt_pb
+        } else {
+            // Update current liquidity if price is in range
+            let new_liquidity_curr = if liquidity_delta > 0 {
+                CurrentLiquidity::<T>::get(netuid).saturating_add(delta_liquidity_abs)
+            } else {
+                CurrentLiquidity::<T>::get(netuid).saturating_sub(delta_liquidity_abs)
+            };
+            CurrentLiquidity::<T>::set(netuid, new_liquidity_curr);
+            current_price
+        };
+
+        // Calculate token amounts for the liquidity change
+        // TODO: Rewrite in non-overflowing math
+        let alpha = SqrtPrice::from_num(delta_liquidity_abs)
+            * (SqrtPrice::from_num(1) / sqrt_price_box - SqrtPrice::from_num(1) / sqrt_pb);
+        let tao = SqrtPrice::from_num(delta_liquidity_abs) * (sqrt_price_box - sqrt_pa);
+
+        // Validate delta
+        if liquidity_delta > 0 {
+            // Check that user has enough balances
+            ensure!(
+                T::LiquidityDataProvider::tao_balance(account_id) >= tao
+                    && T::LiquidityDataProvider::alpha_balance(netuid.into(), account_id) >= alpha,
+                Error::<T>::InsufficientBalance
+            );
+        } else {
+            // Check that position has enough liquidity
+            ensure!(
+                position.liquidity >= delta_liquidity_abs,
+                Error::<T>::InsufficientLiquidity
+            );
+        }
+
+        // Collect fees
+        let (fee_tao, fee_alpha) = position.collect_fees::<T>();
+
+        // If delta brings the position liquidity below MinimumLiquidity, eliminate position and withdraw full amounts
+        if (liquidity_delta < 0)
+            && (position.liquidity.saturating_sub(delta_liquidity_abs)
+                < T::MinimumLiquidity::get())
+        {
+            delta_liquidity_abs = position.liquidity;
+        }
+
+        // Adjust liquidity at the ticks based on the delta sign
+        if liquidity_delta > 0 {
+            // Add liquidity at tick
+            Self::add_liquidity_at_index(netuid, position.tick_low, delta_liquidity_abs, false);
+            Self::add_liquidity_at_index(netuid, position.tick_high, delta_liquidity_abs, true);
+
+            // Add liquidity to user position
+            position.liquidity = position.liquidity.saturating_add(delta_liquidity_abs);
+        } else {
+            // Remove liquidity at tick
+            Self::remove_liquidity_at_index(netuid, position.tick_low, position.liquidity, false);
+            Self::remove_liquidity_at_index(netuid, position.tick_high, position.liquidity, true);
+
+            // Remove liquidity from user position
+            position.liquidity = position.liquidity.saturating_sub(delta_liquidity_abs);
+        }
+        Positions::<T>::insert(&(netuid, account_id, position.id), position);
+
+        // TODO: Withdraw balances and update pool reserves
+
+        Ok(RemoveLiquidityResult {
+            tao: tao.saturating_to_num::<u64>(),
+            alpha: alpha.saturating_to_num::<u64>(),
+            fee_tao,
+            fee_alpha,
+        })
+    }
+
     /// Adds or updates liquidity at a specific tick index for a subnet
     ///
     /// # Arguments
diff --git a/pallets/swap/src/pallet/mod.rs b/pallets/swap/src/pallet/mod.rs
index 4a259dc794..ec0925fabf 100644
--- a/pallets/swap/src/pallet/mod.rs
+++ b/pallets/swap/src/pallet/mod.rs
@@ -152,6 +152,9 @@ mod pallet {
 
         /// Too many swap steps
         TooManySwapSteps,
+
+        /// Provided liquidity parameter is invalid (likely too small)
+        InvalidLiquidityValue,
     }
 
     #[pallet::call]

From 195b9c817168c43aa7eb654cd5524f51dfb70349 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Fri, 11 Apr 2025 14:18:18 +0200
Subject: [PATCH 063/418] Fix typo

---
 pallets/swap/src/pallet/impls.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 42a66062ba..9ae5f29aed 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -277,7 +277,7 @@ impl<T: Config> SwapStep<T> {
 
         Ok(SwapStepResult {
             amount_to_take: amount_swapped.saturating_to_num::<u64>(),
-            delat_in: self.delta_in,
+            delta_in: self.delta_in,
             delta_out,
         })
     }
@@ -374,7 +374,7 @@ impl<T: Config> Pallet<T> {
 
             let swap_result = swap_step.execute()?;
 
-            in_acc = in_acc.saturating_add(swap_result.delat_in);
+            in_acc = in_acc.saturating_add(swap_result.delta_in);
             amount_remaining = amount_remaining.saturating_sub(swap_result.amount_to_take);
             amount_paid_out = amount_paid_out.saturating_add(swap_result.delta_out);
 
@@ -972,7 +972,7 @@ impl<T: Config> SwapHandler<T::AccountId> for Pallet<T> {
 #[derive(Debug, PartialEq)]
 struct SwapStepResult {
     amount_to_take: u64,
-    delat_in: u64,
+    delta_in: u64,
     delta_out: u64,
 }
 

From ee2c8a21958e3c1c417acd09851dcc265914fca0 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Fri, 11 Apr 2025 17:28:46 +0200
Subject: [PATCH 064/418] Integrate swap with pallet-subtensor

---
 Cargo.lock                                    | 2049 ++++++++++-------
 pallets/subtensor/src/coinbase/block_step.rs  |    2 +-
 .../subtensor/src/coinbase/run_coinbase.rs    |   12 +-
 pallets/subtensor/src/macros/events.rs        |    2 +-
 pallets/subtensor/src/rpc_info/stake_info.rs  |   22 +-
 pallets/subtensor/src/staking/helpers.rs      |   19 +-
 pallets/subtensor/src/staking/move_stake.rs   |   18 +-
 pallets/subtensor/src/staking/remove_stake.rs |   70 +-
 pallets/subtensor/src/staking/stake_utils.rs  |  357 +--
 pallets/subtensor/src/subnets/registration.rs |    5 +-
 pallets/swap/src/mock.rs                      |    7 +-
 pallets/swap/src/pallet/impls.rs              |   21 +-
 12 files changed, 1350 insertions(+), 1234 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 4f32fb735d..91fef075c8 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -23,11 +23,11 @@ dependencies = [
 
 [[package]]
 name = "addr2line"
-version = "0.24.1"
+version = "0.24.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f5fb1d8e4442bd405fdfd1dacb42792696b0cf9cb15882e5d097b742a676d375"
+checksum = "dfbe277e56a376000877090da837660b4427aad530e3028d44e0bffe4f89a1c1"
 dependencies = [
- "gimli 0.31.0",
+ "gimli 0.31.1",
 ]
 
 [[package]]
@@ -92,7 +92,7 @@ dependencies = [
  "getrandom 0.2.15",
  "once_cell",
  "version_check",
- "zerocopy 0.7.35",
+ "zerocopy",
 ]
 
 [[package]]
@@ -106,15 +106,15 @@ dependencies = [
 
 [[package]]
 name = "allocator-api2"
-version = "0.2.18"
+version = "0.2.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c6cb57a04249c6480766f7f7cef5467412af1490f8d1e243141daddada3264f"
+checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
 
 [[package]]
 name = "alloy-primitives"
-version = "0.8.25"
+version = "0.8.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c77490fe91a0ce933a1f219029521f20fc28c2c0ca95d53fa4da9c00b8d9d4e"
+checksum = "eacedba97e65cdc7ab592f2b22ef5d3ab8d60b2056bc3a6e6363577e8270ec6f"
 dependencies = [
  "alloy-rlp",
  "bytes",
@@ -122,15 +122,15 @@ dependencies = [
  "const-hex",
  "derive_more 2.0.1",
  "foldhash",
- "indexmap 2.6.0",
+ "indexmap 2.7.1",
  "itoa",
  "k256",
  "keccak-asm",
  "paste",
  "proptest",
- "rand 0.8.5",
+ "rand",
  "ruint",
- "rustc-hash 2.1.1",
+ "rustc-hash 2.1.0",
  "serde",
  "sha3",
  "tiny-keccak",
@@ -163,9 +163,9 @@ dependencies = [
 
 [[package]]
 name = "anstream"
-version = "0.6.15"
+version = "0.6.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64e15c1ab1f89faffbf04a634d5e1962e9074f2741eef6d97f3c4e322426d526"
+checksum = "8acc5369981196006228e28809f761875c0327210a891e941f4c683b3a99529b"
 dependencies = [
  "anstyle",
  "anstyle-parse",
@@ -178,43 +178,44 @@ dependencies = [
 
 [[package]]
 name = "anstyle"
-version = "1.0.8"
+version = "1.0.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bec1de6f59aedf83baf9ff929c98f2ad654b97c9510f4e70cf6f661d49fd5b1"
+checksum = "55cc3b69f167a1ef2e161439aa98aed94e6028e5f9a59be9a6ffb47aef1651f9"
 
 [[package]]
 name = "anstyle-parse"
-version = "0.2.5"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb47de1e80c2b463c735db5b217a0ddc39d612e7ac9e2e96a5aed1f57616c1cb"
+checksum = "3b2d16507662817a6a20a9ea92df6652ee4f94f914589377d69f3b21bc5798a9"
 dependencies = [
  "utf8parse",
 ]
 
 [[package]]
 name = "anstyle-query"
-version = "1.1.1"
+version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d36fc52c7f6c869915e99412912f22093507da8d9e942ceaf66fe4b7c14422a"
+checksum = "79947af37f4177cfead1110013d678905c37501914fba0efea834c3fe9a8d60c"
 dependencies = [
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
 name = "anstyle-wincon"
-version = "3.0.4"
+version = "3.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5bf74e1b6e971609db8ca7a9ce79fd5768ab6ae46441c572e46cf596f59e57f8"
+checksum = "ca3534e77181a9cc07539ad51f2141fe32f6c3ffd4df76db8ad92346b003ae4e"
 dependencies = [
  "anstyle",
- "windows-sys 0.52.0",
+ "once_cell",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
 name = "anyhow"
-version = "1.0.89"
+version = "1.0.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86fdf8605db99b54d3cd748a44c6d04df638eb5dafb219b135d0149bd0db01f6"
+checksum = "34ac096ce696dc2fcabef30516bb13c0a68a11d30131d3df6f04711467681b04"
 
 [[package]]
 name = "approx"
@@ -236,7 +237,7 @@ dependencies = [
  "proc-macro-error",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -619,7 +620,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1df2c09229cbc5a028b1d70e00fdb2acee28b1055dfb5ca73eea49c5a25c4e7c"
 dependencies = [
  "num-traits",
- "rand 0.8.5",
+ "rand",
 ]
 
 [[package]]
@@ -629,7 +630,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "94893f1e0c6eeab764ade8dc4c0db24caf4fe7cbbaafc0eba0a9030f447b5185"
 dependencies = [
  "num-traits",
- "rand 0.8.5",
+ "rand",
  "rayon",
 ]
 
@@ -663,7 +664,7 @@ dependencies = [
  "nom",
  "num-traits",
  "rusticata-macros",
- "thiserror",
+ "thiserror 1.0.69",
  "time",
 ]
 
@@ -679,7 +680,7 @@ dependencies = [
  "nom",
  "num-traits",
  "rusticata-macros",
- "thiserror",
+ "thiserror 1.0.69",
  "time",
 ]
 
@@ -703,7 +704,7 @@ checksum = "965c2d33e53cb6b267e148a4cb0760bc01f4904c1cd4bb4002a085bb016d1490"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
  "synstructure 0.13.1",
 ]
 
@@ -726,7 +727,7 @@ checksum = "7b18050c2cd6fe86c3a76584ef5e0baf286d038cda203eb6223df2cc413565f7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -748,9 +749,9 @@ dependencies = [
 
 [[package]]
 name = "async-io"
-version = "2.3.4"
+version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "444b0228950ee6501b3568d3c93bf1176a1fdbc3b758dcd9475046d30f4dc7e8"
+checksum = "43a2b323ccce0a1d90b449fd71f2a06ca7faa7c54c2751f06c9bd851fc061059"
 dependencies = [
  "async-lock",
  "cfg-if",
@@ -759,7 +760,7 @@ dependencies = [
  "futures-lite",
  "parking",
  "polling",
- "rustix 0.38.37",
+ "rustix 0.38.44",
  "slab",
  "tracing",
  "windows-sys 0.59.0",
@@ -771,20 +772,20 @@ version = "3.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ff6e472cdea888a4bd64f342f09b3f50e1886d32afe8df3d663c01140b811b18"
 dependencies = [
- "event-listener 5.3.1",
+ "event-listener 5.4.0",
  "event-listener-strategy",
  "pin-project-lite",
 ]
 
 [[package]]
 name = "async-trait"
-version = "0.1.83"
+version = "0.1.85"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "721cae7de5c34fbb2acd27e21e6d2cf7b886dce0c27388d46c4e6c47ea4318dd"
+checksum = "3f934833b4b7233644e5848f235df3f57ed8c80f1528a26c3dfa13d2147fa056"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -828,13 +829,13 @@ dependencies = [
 
 [[package]]
 name = "auto_impl"
-version = "1.2.0"
+version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c87f3f15e7794432337fc718554eaa4dc8f04c9677a950ffe366f20a162ae42"
+checksum = "e12882f59de5360c748c4cbf569a042d5fb0eb515f7bea9c1f470b47f6ffbd73"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -849,11 +850,11 @@ version = "0.3.74"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8d82cb332cdfaed17ae235a638438ac4d4839913cc2af585c3c6746e8f8bee1a"
 dependencies = [
- "addr2line 0.24.1",
+ "addr2line 0.24.2",
  "cfg-if",
  "libc",
  "miniz_oxide",
- "object 0.36.4",
+ "object 0.36.7",
  "rustc-demangle",
  "windows-targets 0.52.6",
 ]
@@ -915,13 +916,13 @@ dependencies = [
  "lazy_static",
  "lazycell",
  "peeking_take_while",
- "prettyplease 0.2.22",
+ "prettyplease 0.2.29",
  "proc-macro2",
  "quote",
  "regex",
  "rustc-hash 1.1.0",
  "shlex",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -963,9 +964,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bitflags"
-version = "2.6.0"
+version = "2.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
+checksum = "8f68f53c83ab957f72c32642f3868eec03eb974d1fb82e453128456482613d36"
 
 [[package]]
 name = "bitvec"
@@ -1024,9 +1025,9 @@ dependencies = [
 
 [[package]]
 name = "blake3"
-version = "1.5.4"
+version = "1.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d82033247fd8e890df8f740e407ad4d038debb9eb1f40533fffb32e7d17dc6f7"
+checksum = "b8ee0c1824c4dea5b5f81736aff91bae041d2c07ee1192bec91054e10e3e601e"
 dependencies = [
  "arrayref",
  "arrayvec",
@@ -1055,9 +1056,9 @@ dependencies = [
 
 [[package]]
 name = "bounded-collections"
-version = "0.2.0"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d32385ecb91a31bddaf908e8dcf4a15aef1bcd3913cc03ebfad02ff6d568abc1"
+checksum = "3d077619e9c237a5d1875166f5e8033e8f6bff0c96f8caf81e1c2d7738c431bf"
 dependencies = [
  "log",
  "parity-scale-codec",
@@ -1091,9 +1092,9 @@ dependencies = [
 
 [[package]]
 name = "bumpalo"
-version = "3.16.0"
+version = "3.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c"
+checksum = "1628fb46dfa0b37568d12e5edd512553eccf6a22a78e8bde00bb4aed84d5bdbf"
 
 [[package]]
 name = "byte-slice-cast"
@@ -1109,9 +1110,9 @@ checksum = "e3b5ca7a04898ad4bcd41c90c5285445ff5b791899bb1b0abdd2a2aa791211d7"
 
 [[package]]
 name = "bytemuck"
-version = "1.18.0"
+version = "1.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94bbb0ad554ad961ddc5da507a12a29b14e4ae5bda06b19f575a3e6079d2e2ae"
+checksum = "ef657dfab802224e671f5818e9a4935f9b1957ed18e58292690cc39e7a4092a3"
 
 [[package]]
 name = "byteorder"
@@ -1121,9 +1122,9 @@ checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 
 [[package]]
 name = "bytes"
-version = "1.7.2"
+version = "1.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "428d9aa8fbc0670b7b8d6030a7fadd0f86151cae55e4dbbece15f3780a3dfaf3"
+checksum = "325918d6fe32f23b19878fe4b34794ae41fc19ddbe53b10571a4874d44ffd39b"
 
 [[package]]
 name = "bzip2-sys"
@@ -1157,9 +1158,9 @@ dependencies = [
 
 [[package]]
 name = "cargo-platform"
-version = "0.1.8"
+version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24b1f0365a6c6bb4020cd05806fd0d33c44d38046b8bd7f0e40814b9763cabfc"
+checksum = "e35af189006b9c0f00a064685c727031e3ed2d8020f7ba284d78cc2671bd36ea"
 dependencies = [
  "serde",
 ]
@@ -1172,10 +1173,10 @@ checksum = "eee4243f1f26fc7a42710e7439c149e2b10b05472f88090acce52632f231a73a"
 dependencies = [
  "camino",
  "cargo-platform",
- "semver 1.0.23",
+ "semver 1.0.25",
  "serde",
  "serde_json",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
@@ -1186,9 +1187,9 @@ checksum = "fd6c0e7b807d60291f42f33f58480c0bfafe28ed08286446f45e463728cf9c1c"
 
 [[package]]
 name = "cc"
-version = "1.2.16"
+version = "1.2.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be714c154be609ec7f5dad223a33bf1482fff90472de28f7362806e6d4832b8c"
+checksum = "13208fcbb66eaeffe09b99fffbe1af420f00a7b35aa99ad683dfc1aa76145229"
 dependencies = [
  "jobserver",
  "libc",
@@ -1261,9 +1262,9 @@ dependencies = [
 
 [[package]]
 name = "chrono"
-version = "0.4.38"
+version = "0.4.39"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a21f936df1771bf62b77f047b726c4625ff2e8aa607c01ec06e5a05bd8463401"
+checksum = "7e36cc9d416881d2e24f9a963be5fb1cd90966419ac844274161d10488b3e825"
 dependencies = [
  "android-tzdata",
  "iana-time-zone",
@@ -1333,9 +1334,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.19"
+version = "4.5.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7be5744db7978a28d9df86a214130d106a89ce49644cbc4e3f0c22c3fba30615"
+checksum = "769b0145982b4b48713e01ec42d61614425f27b7058bda7180a3a41f30104796"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -1343,9 +1344,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.19"
+version = "4.5.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5fbc17d3ef8278f55b282b2a2e75ae6f6c7d4bb70ed3d0382375104bfafdb4b"
+checksum = "1b26884eb4b57140e4d2d93652abfa49498b938b3c9179f9fc487b0acc3edad7"
 dependencies = [
  "anstream",
  "anstyle",
@@ -1356,21 +1357,21 @@ dependencies = [
 
 [[package]]
 name = "clap_derive"
-version = "4.5.18"
+version = "4.5.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ac6a0c7b1a9e9a5186361f67dfa1b88213572f427fb9ab038efb2bd8c582dab"
+checksum = "54b755194d6389280185988721fffba69495eed5ee9feeee9a599b53db80318c"
 dependencies = [
  "heck 0.5.0",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
 name = "clap_lex"
-version = "0.7.2"
+version = "0.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1462739cb27611015575c0c11df5df7601141071f07518d56fcc1be504cbec97"
+checksum = "f46ad14479a25103f283c0f10005961cf086d8dc42205bb44c46ac563475dca6"
 
 [[package]]
 name = "codespan-reporting"
@@ -1379,14 +1380,14 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3538270d33cc669650c4b093848450d380def10c331d38c768e34cac80576e6e"
 dependencies = [
  "termcolor",
- "unicode-width",
+ "unicode-width 0.1.14",
 ]
 
 [[package]]
 name = "colorchoice"
-version = "1.0.2"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3fd119d74b830634cea2a0f58bbd0d54540518a14397557951e79340abc28c0"
+checksum = "5b63caa9aa9397e2d9480a9b13673856c78d8ac123288526c37d7839f2a86990"
 
 [[package]]
 name = "combine"
@@ -1400,13 +1401,13 @@ dependencies = [
 
 [[package]]
 name = "comfy-table"
-version = "7.1.1"
+version = "7.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b34115915337defe99b2aff5c2ce6771e5fbc4079f4b506301f5cf394c8452f7"
+checksum = "24f165e7b643266ea80cb858aed492ad9280e3e05ce24d4a99d7d7b889b6a4d9"
 dependencies = [
  "strum 0.26.3",
  "strum_macros 0.26.4",
- "unicode-width",
+ "unicode-width 0.2.0",
 ]
 
 [[package]]
@@ -1426,15 +1427,15 @@ dependencies = [
 
 [[package]]
 name = "console"
-version = "0.15.8"
+version = "0.15.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e1f83fc076bd6dd27517eacdf25fef6c4dfe5f1d7448bafaaf3a26f13b5e4eb"
+checksum = "ea3c6ecd8059b57859df5c69830340ed3c41d30e3da0c1cbed90a96ac853041b"
 dependencies = [
  "encode_unicode",
- "lazy_static",
  "libc",
- "unicode-width",
- "windows-sys 0.52.0",
+ "once_cell",
+ "unicode-width 0.2.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -1530,9 +1531,9 @@ dependencies = [
 
 [[package]]
 name = "cpufeatures"
-version = "0.2.14"
+version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "608697df725056feaccfa42cffdaeeec3fccc4ffc38358ecd19b243e716a78e0"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
 dependencies = [
  "libc",
 ]
@@ -1661,9 +1662,9 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-deque"
-version = "0.8.5"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "613f8cc01fe9cf1a3eb3d7f488fd2fa8388403e97039e2f73692932e291a770d"
+checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
 dependencies = [
  "crossbeam-epoch",
  "crossbeam-utils",
@@ -1689,15 +1690,15 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-utils"
-version = "0.8.20"
+version = "0.8.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22ec99545bb0ed0ea7bb9b8e1e9122ea386ff8a48c0922e43f36d45ab09e0e80"
+checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
 [[package]]
 name = "crunchy"
-version = "0.2.2"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
+checksum = "43da5946c66ffcc7745f48db692ffbb10a83bfe0afd96235c5c2a4fb23994929"
 
 [[package]]
 name = "crypto-bigint"
@@ -1706,7 +1707,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76"
 dependencies = [
  "generic-array 0.14.7",
- "rand_core 0.6.4",
+ "rand_core",
  "subtle 2.6.1",
  "zeroize",
 ]
@@ -1718,7 +1719,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
 dependencies = [
  "generic-array 0.14.7",
- "rand_core 0.6.4",
+ "rand_core",
  "typenum 1.17.0",
 ]
 
@@ -1775,51 +1776,66 @@ checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
 name = "cxx"
-version = "1.0.128"
+version = "1.0.137"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "54ccead7d199d584d139148b04b4a368d1ec7556a1d9ea2548febb1b9d49f9a4"
+checksum = "0fc894913dccfed0f84106062c284fa021c3ba70cb1d78797d6f5165d4492e45"
 dependencies = [
  "cc",
+ "cxxbridge-cmd",
  "cxxbridge-flags",
  "cxxbridge-macro",
+ "foldhash",
  "link-cplusplus",
 ]
 
 [[package]]
 name = "cxx-build"
-version = "1.0.128"
+version = "1.0.137"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c77953e99f01508f89f55c494bfa867171ef3a6c8cea03d26975368f2121a5c1"
+checksum = "503b2bfb6b3e8ce7f95d865a67419451832083d3186958290cee6c53e39dfcfe"
 dependencies = [
  "cc",
  "codespan-reporting",
- "once_cell",
  "proc-macro2",
  "quote",
  "scratch",
- "syn 2.0.90",
+ "syn 2.0.96",
+]
+
+[[package]]
+name = "cxxbridge-cmd"
+version = "1.0.137"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e0d2cb64a95b4b5a381971482235c4db2e0208302a962acdbe314db03cbbe2fb"
+dependencies = [
+ "clap",
+ "codespan-reporting",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.96",
 ]
 
 [[package]]
 name = "cxxbridge-flags"
-version = "1.0.128"
+version = "1.0.137"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "65777e06cc48f0cb0152024c77d6cf9e4bdb4408e7b48bea993d42fa0f5b02b6"
+checksum = "5f797b0206463c9c2a68ed605ab28892cca784f1ef066050f4942e3de26ad885"
 
 [[package]]
 name = "cxxbridge-macro"
-version = "1.0.128"
+version = "1.0.137"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "98532a60dedaebc4848cb2cba5023337cc9ea3af16a5b062633fabfd9f18fb60"
+checksum = "e79010a2093848e65a3e0f7062d3f02fb2ef27f866416dfe436fccfa73d3bb59"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "rustversion",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -1843,7 +1859,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "strsim",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -1854,7 +1870,7 @@ checksum = "d336a2a514f6ccccaa3e09b02d41d35330c07ddf03a62165fcec10bb561c7806"
 dependencies = [
  "darling_core",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -1872,15 +1888,15 @@ dependencies = [
 
 [[package]]
 name = "data-encoding"
-version = "2.6.0"
+version = "2.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8566979429cf69b49a5c740c60791108e86440e8be149bbea4fe54d2c32d6e2"
+checksum = "0e60eed09d8c01d3cee5b7d30acb059b76614c918fa0f992e0dd6eeb10daad6f"
 
 [[package]]
 name = "data-encoding-macro"
-version = "0.1.15"
+version = "0.1.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1559b6cba622276d6d63706db152618eeb15b89b3e4041446b05876e352e639"
+checksum = "5b16d9d0d88a5273d830dac8b78ceb217ffc9b1d5404e5597a3542515329405b"
 dependencies = [
  "data-encoding",
  "data-encoding-macro-internal",
@@ -1888,12 +1904,12 @@ dependencies = [
 
 [[package]]
 name = "data-encoding-macro-internal"
-version = "0.1.13"
+version = "0.1.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "332d754c0af53bc87c108fed664d121ecf59207ec4196041f04d6ab9002ad33f"
+checksum = "1145d32e826a7748b69ee8fc62d3e6355ff7f1051df53141e7048162fc90481b"
 dependencies = [
  "data-encoding",
- "syn 1.0.109",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -1963,7 +1979,7 @@ checksum = "d65d7ce8132b7c0e54497a4d9a55a1c2a0912a0d786cf894472ba818fba45762"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -1976,7 +1992,16 @@ dependencies = [
  "proc-macro2",
  "quote",
  "rustc_version 0.4.1",
- "syn 2.0.90",
+ "syn 2.0.96",
+]
+
+[[package]]
+name = "derive_more"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a9b99b9cbbe49445b21764dc0625032a89b145a2642e67603e1c936f5458d05"
+dependencies = [
+ "derive_more-impl 1.0.0",
 ]
 
 [[package]]
@@ -1985,7 +2010,18 @@ version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "093242cf7570c207c83073cf82f79706fe7b8317e98620a47d5be7c3d8497678"
 dependencies = [
- "derive_more-impl",
+ "derive_more-impl 2.0.1",
+]
+
+[[package]]
+name = "derive_more-impl"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb7330aeadfbe296029522e6c40f315320aba36fc43a5b3632f3795348f3bd22"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -1996,7 +2032,7 @@ checksum = "bda628edc44c4bb645fbe0f758797143e4e07926f7ebf4e9bdfbd3d2ce621df3"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
  "unicode-xid",
 ]
 
@@ -2086,23 +2122,23 @@ checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
 name = "docify"
-version = "0.2.8"
+version = "0.2.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43a2f138ad521dc4a2ced1a4576148a6a610b4c5923933b062a263130a6802ce"
+checksum = "a772b62b1837c8f060432ddcc10b17aae1453ef17617a99bc07789252d2a5896"
 dependencies = [
  "docify_macros",
 ]
 
 [[package]]
 name = "docify_macros"
-version = "0.2.8"
+version = "0.2.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a081e51fb188742f5a7a1164ad752121abcb22874b21e2c3b0dd040c515fdad"
+checksum = "60e6be249b0a462a14784a99b19bf35a667bb5e09de611738bb7362fa4c95ff7"
 dependencies = [
  "common-path",
  "derive-syn-parse",
@@ -2110,7 +2146,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "regex",
- "syn 2.0.90",
+ "syn 2.0.96",
  "termcolor",
  "toml 0.8.19",
  "walkdir",
@@ -2136,9 +2172,9 @@ checksum = "dcbb2bf8e87535c23f7a8a321e364ce21462d0ff10cb6407820e8e96dfff6653"
 
 [[package]]
 name = "dyn-clonable"
-version = "0.9.0"
+version = "0.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e9232f0e607a262ceb9bd5141a3dfb3e4db6994b31989bbfd845878cba59fd4"
+checksum = "a36efbb9bfd58e1723780aa04b61aba95ace6a05d9ffabfdb0b43672552f0805"
 dependencies = [
  "dyn-clonable-impl",
  "dyn-clone",
@@ -2146,13 +2182,13 @@ dependencies = [
 
 [[package]]
 name = "dyn-clonable-impl"
-version = "0.9.0"
+version = "0.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "558e40ea573c374cf53507fd240b7ee2f5477df7cfebdb97323ec61c719399c5"
+checksum = "7e8671d54058979a37a26f3511fbf8d198ba1aa35ffb202c42587d918d77213a"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -2194,7 +2230,7 @@ checksum = "4a3daa8e81a3963a60642bcc1f90a670680bd4a77535faa384e9d1c79d620871"
 dependencies = [
  "curve25519-dalek",
  "ed25519",
- "rand_core 0.6.4",
+ "rand_core",
  "serde",
  "sha2 0.10.8",
  "subtle 2.6.1",
@@ -2211,7 +2247,7 @@ dependencies = [
  "ed25519",
  "hashbrown 0.14.5",
  "hex",
- "rand_core 0.6.4",
+ "rand_core",
  "sha2 0.10.8",
  "zeroize",
 ]
@@ -2238,7 +2274,7 @@ dependencies = [
  "generic-array 0.14.7",
  "group",
  "pkcs8",
- "rand_core 0.6.4",
+ "rand_core",
  "sec1",
  "serdect",
  "subtle 2.6.1",
@@ -2247,9 +2283,9 @@ dependencies = [
 
 [[package]]
 name = "encode_unicode"
-version = "0.3.6"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a357d28ed41a50f9c765dbfe56cbc04a64e53e5fc58ba79fbc34c10ef3df831f"
+checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0"
 
 [[package]]
 name = "enum-as-inner"
@@ -2272,27 +2308,27 @@ dependencies = [
  "heck 0.5.0",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
 name = "enumflags2"
-version = "0.7.10"
+version = "0.7.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d232db7f5956f3f14313dc2f87985c58bd2c695ce124c8cdd984e08e15ac133d"
+checksum = "ba2f4b465f5318854c6f8dd686ede6c0a9dc67d4b1ac241cf0eb51521a309147"
 dependencies = [
  "enumflags2_derive",
 ]
 
 [[package]]
 name = "enumflags2_derive"
-version = "0.7.10"
+version = "0.7.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de0d48a183585823424a4ce1aa132d174a6a81bd540895822eb4c8373a8e49e8"
+checksum = "fc4caf64a58d7a6d65ab00639b046ff54399a39f5f2554728895ace4b297cd79"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -2322,12 +2358,12 @@ checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
 
 [[package]]
 name = "errno"
-version = "0.3.9"
+version = "0.3.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "534c5cf6194dfab3db3242765c03bbe257cf92f22b38f6bc0c58d59108a820ba"
+checksum = "33d852cb9b869c2a9b3df2f71a3074817f01e1844f839a144f5fcef059a4eb5d"
 dependencies = [
  "libc",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -2338,9 +2374,9 @@ checksum = "c22d4b5885b6aa2fe5e8b9329fb8d232bf739e434e6b87347c63bdd00c120f60"
 dependencies = [
  "crunchy",
  "fixed-hash",
- "impl-codec",
+ "impl-codec 0.6.0",
  "impl-rlp",
- "impl-serde",
+ "impl-serde 0.4.0",
  "scale-info",
  "tiny-keccak",
 ]
@@ -2371,12 +2407,12 @@ checksum = "02d215cbf040552efcbe99a38372fe80ab9d00268e20012b79fcd0f073edd8ee"
 dependencies = [
  "ethbloom",
  "fixed-hash",
- "impl-codec",
+ "impl-codec 0.6.0",
  "impl-rlp",
- "impl-serde",
- "primitive-types",
+ "impl-serde 0.4.0",
+ "primitive-types 0.12.2",
  "scale-info",
- "uint",
+ "uint 0.9.5",
 ]
 
 [[package]]
@@ -2387,9 +2423,9 @@ checksum = "0206175f82b8d6bf6652ff7d71a1e27fd2e4efde587fd368662814d6ec1d9ce0"
 
 [[package]]
 name = "event-listener"
-version = "5.3.1"
+version = "5.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6032be9bd27023a771701cc49f9f053c751055f71efb2e0ae5c15809093675ba"
+checksum = "3492acde4c3fc54c845eaab3eed8bd00c7a7d881f78bfc801e43a93dec1331ae"
 dependencies = [
  "concurrent-queue",
  "parking",
@@ -2398,11 +2434,11 @@ dependencies = [
 
 [[package]]
 name = "event-listener-strategy"
-version = "0.5.2"
+version = "0.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0f214dc438f977e6d4e3500aaa277f5ad94ca83fbbd9b1a15713ce2344ccc5a1"
+checksum = "3c3e4e0dd3673c1139bf041f3008816d9cf2946bbfac2945c09e523b8d7b05b2"
 dependencies = [
- "event-listener 5.3.1",
+ "event-listener 5.4.0",
  "pin-project-lite",
 ]
 
@@ -2420,7 +2456,7 @@ dependencies = [
  "evm-runtime",
  "log",
  "parity-scale-codec",
- "primitive-types",
+ "primitive-types 0.12.2",
  "rlp",
  "scale-info",
  "serde",
@@ -2434,7 +2470,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d1da6cedc5cedb4208e59467106db0d1f50db01b920920589f8e672c02fdc04f"
 dependencies = [
  "parity-scale-codec",
- "primitive-types",
+ "primitive-types 0.12.2",
  "scale-info",
  "serde",
 ]
@@ -2448,7 +2484,7 @@ dependencies = [
  "environmental",
  "evm-core",
  "evm-runtime",
- "primitive-types",
+ "primitive-types 0.12.2",
 ]
 
 [[package]]
@@ -2460,7 +2496,7 @@ dependencies = [
  "auto_impl",
  "environmental",
  "evm-core",
- "primitive-types",
+ "primitive-types 0.12.2",
  "sha3",
 ]
 
@@ -2482,10 +2518,10 @@ dependencies = [
  "blake2 0.10.6",
  "file-guard",
  "fs-err",
- "prettyplease 0.2.22",
+ "prettyplease 0.2.29",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -2502,9 +2538,9 @@ checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649"
 
 [[package]]
 name = "fastrand"
-version = "2.1.1"
+version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8c02a5121d4ea3eb16a80748c74f5549a5665e4c21333c6098f283870fbdea6"
+checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
 
 [[package]]
 name = "fastrlp"
@@ -2553,7 +2589,7 @@ dependencies = [
  "sp-block-builder",
  "sp-consensus",
  "sp-runtime",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
@@ -2632,7 +2668,7 @@ dependencies = [
  "pallet-evm",
  "parity-scale-codec",
  "prometheus",
- "rand 0.8.5",
+ "rand",
  "rlp",
  "sc-client-api",
  "sc-consensus-aura",
@@ -2659,7 +2695,7 @@ dependencies = [
  "sp-storage 21.0.0",
  "sp-timestamp",
  "substrate-prometheus-endpoint",
- "thiserror",
+ "thiserror 1.0.69",
  "tokio",
 ]
 
@@ -2702,7 +2738,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e182f7dbc2ef73d9ef67351c5fbbea084729c48362d3ce9dd44c28e32e277fe5"
 dependencies = [
  "libc",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
@@ -2711,7 +2747,7 @@ version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ded41244b729663b1e574f1b4fb731469f69f79c17667b5d776b16cda0479449"
 dependencies = [
- "rand_core 0.6.4",
+ "rand_core",
  "subtle 2.6.1",
 ]
 
@@ -2776,7 +2812,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "835c052cb0c08c1acf6ffd71c022172e18723949c8282f2b9f27efbc51e64534"
 dependencies = [
  "byteorder",
- "rand 0.8.5",
+ "rand",
  "rustc-hex",
  "static_assertions",
 ]
@@ -2815,9 +2851,9 @@ checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 
 [[package]]
 name = "foldhash"
-version = "0.1.5"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
+checksum = "a0d2fde1f7b3d48b8395d5f2de76c18a528bd6a9cdde438df747bfcba3e05d6f"
 
 [[package]]
 name = "foreign-types"
@@ -2858,7 +2894,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8835f84f38484cc86f110a805655697908257fb9a7af005234060891557198e9"
 dependencies = [
  "nonempty",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
@@ -2867,7 +2903,7 @@ version = "1.0.0-dev"
 source = "git+https://github.com/opentensor/frontier?rev=635bdac882#635bdac882333afed827053f31ef56ab739f7a2e"
 dependencies = [
  "hex",
- "impl-serde",
+ "impl-serde 0.4.0",
  "libsecp256k1",
  "log",
  "parity-scale-codec",
@@ -3005,7 +3041,7 @@ dependencies = [
  "linked-hash-map",
  "log",
  "parity-scale-codec",
- "rand 0.8.5",
+ "rand",
  "rand_pcg",
  "sc-block-builder",
  "sc-chain-spec",
@@ -3031,7 +3067,7 @@ dependencies = [
  "sp-storage 21.0.0",
  "sp-trie",
  "sp-wasm-interface 21.0.1",
- "thiserror",
+ "thiserror 1.0.69",
  "thousands",
 ]
 
@@ -3138,7 +3174,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409)",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -3151,7 +3187,7 @@ dependencies = [
  "proc-macro-crate 3.2.0",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -3163,7 +3199,7 @@ dependencies = [
  "proc-macro-crate 3.2.0",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -3174,7 +3210,7 @@ checksum = "68672b9ec6fe72d259d3879dc212c5e42e977588cdac830c76f54d9f492aeb58"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -3184,7 +3220,7 @@ source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -3339,9 +3375,9 @@ checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6"
 
 [[package]]
 name = "futures-lite"
-version = "2.3.0"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52527eb5074e35e9339c6b4e8d12600c7128b68fb25dcb9fa9dec18f7c25f3a5"
+checksum = "f5edaec856126859abb19ed65f39e90fea3a9574b9707f13539acf4abf7eb532"
 dependencies = [
  "futures-core",
  "pin-project-lite",
@@ -3355,7 +3391,7 @@ checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -3456,14 +3492,14 @@ dependencies = [
 
 [[package]]
 name = "getrandom"
-version = "0.3.2"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73fea8450eea4bac3940448fb7ae50d91f034f941199fcd9d909a5a07aa455f0"
+checksum = "43a49c392881ce6d5c3b8cb70f98717b7c07aabbdff06687b9030dbfbe2725f8"
 dependencies = [
  "cfg-if",
  "libc",
- "r-efi",
- "wasi 0.14.2+wasi-0.2.4",
+ "wasi 0.13.3+wasi-0.2.2",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -3472,8 +3508,8 @@ version = "0.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6ea1015b5a70616b688dc230cfe50c8af89d972cb132d5a622814d29773b10b9"
 dependencies = [
- "rand 0.8.5",
- "rand_core 0.6.4",
+ "rand",
+ "rand_core",
 ]
 
 [[package]]
@@ -3509,15 +3545,15 @@ dependencies = [
 
 [[package]]
 name = "gimli"
-version = "0.31.0"
+version = "0.31.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32085ea23f3234fc7846555e85283ba4de91e21016dc0455a16286d87a292d64"
+checksum = "07e28edb80900c19c28f1072f2e8aeca7fa06b23cd4169cefe1af5aa3260783f"
 
 [[package]]
 name = "glob"
-version = "0.3.1"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"
+checksum = "a8d1add55171497b4705a648c6b583acafb01d58050a51727785f0b2c8e0a2b2"
 
 [[package]]
 name = "governor"
@@ -3534,7 +3570,7 @@ dependencies = [
  "parking_lot 0.12.3",
  "portable-atomic",
  "quanta",
- "rand 0.8.5",
+ "rand",
  "smallvec",
  "spinning_top",
 ]
@@ -3546,7 +3582,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63"
 dependencies = [
  "ff",
- "rand_core 0.6.4",
+ "rand_core",
  "subtle 2.6.1",
 ]
 
@@ -3562,7 +3598,7 @@ dependencies = [
  "futures-sink",
  "futures-util",
  "http 0.2.12",
- "indexmap 2.6.0",
+ "indexmap 2.7.1",
  "slab",
  "tokio",
  "tokio-util",
@@ -3571,17 +3607,17 @@ dependencies = [
 
 [[package]]
 name = "h2"
-version = "0.4.6"
+version = "0.4.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "524e8ac6999421f49a846c2d4411f337e53497d8ec55d67753beffa43c5d9205"
+checksum = "ccae279728d634d083c00f6099cb58f01cc99c145b84b8be2f6c74618d79922e"
 dependencies = [
  "atomic-waker",
  "bytes",
  "fnv",
  "futures-core",
  "futures-sink",
- "http 1.1.0",
- "indexmap 2.6.0",
+ "http 1.2.0",
+ "indexmap 2.7.1",
  "slab",
  "tokio",
  "tokio-util",
@@ -3605,7 +3641,7 @@ dependencies = [
  "pest_derive",
  "serde",
  "serde_json",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
@@ -3673,11 +3709,11 @@ dependencies = [
 
 [[package]]
 name = "hashlink"
-version = "0.9.1"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ba4ff7128dee98c7dc9794b6a411377e1404dba1c97deb8d1a55297bd25d8af"
+checksum = "7382cf6263419f2d8df38c55d7da83da5c18aef87fc7a7fc1fb1e344edfe14c1"
 dependencies = [
- "hashbrown 0.14.5",
+ "hashbrown 0.15.2",
 ]
 
 [[package]]
@@ -3766,11 +3802,11 @@ dependencies = [
 
 [[package]]
 name = "home"
-version = "0.5.9"
+version = "0.5.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3d1354bf6b7235cb4a0576c2619fd4ed18183f689b12b006a0ee7329eeff9a5"
+checksum = "589533453244b0995c858700322199b2becb13b627df2851f64a2775d024abcf"
 dependencies = [
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -3797,9 +3833,9 @@ dependencies = [
 
 [[package]]
 name = "http"
-version = "1.1.0"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21b9ddb458710bc376481b842f5da65cdf31522de232c1ca8146abce2a358258"
+checksum = "f16ca2af56261c99fba8bac40a10251ce8188205a4c448fbb745a2e4daa76fea"
 dependencies = [
  "bytes",
  "fnv",
@@ -3824,7 +3860,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184"
 dependencies = [
  "bytes",
- "http 1.1.0",
+ "http 1.2.0",
 ]
 
 [[package]]
@@ -3835,16 +3871,16 @@ checksum = "793429d76616a256bcb62c2a2ec2bed781c8307e797e2598c50010f2bee2544f"
 dependencies = [
  "bytes",
  "futures-util",
- "http 1.1.0",
+ "http 1.2.0",
  "http-body 1.0.1",
  "pin-project-lite",
 ]
 
 [[package]]
 name = "httparse"
-version = "1.9.5"
+version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d71d3574edd2771538b901e6549113b4006ece66150fb69c0fb6d9a2adae946"
+checksum = "f2d708df4e7140240a16cd6ab0ab65c972d7433ab77819ea693fde9c43811e2a"
 
 [[package]]
 name = "httpdate"
@@ -3860,9 +3896,9 @@ checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
 
 [[package]]
 name = "hyper"
-version = "0.14.30"
+version = "0.14.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a152ddd61dfaec7273fe8419ab357f33aee0d914c5f4efbf0d96fa749eea5ec9"
+checksum = "41dfc780fdec9373c01bae43289ea34c972e40ee3c9f6b3c8801a35f35586ce7"
 dependencies = [
  "bytes",
  "futures-channel",
@@ -3875,7 +3911,7 @@ dependencies = [
  "httpdate",
  "itoa",
  "pin-project-lite",
- "socket2 0.5.7",
+ "socket2 0.5.8",
  "tokio",
  "tower-service",
  "tracing",
@@ -3884,15 +3920,15 @@ dependencies = [
 
 [[package]]
 name = "hyper"
-version = "1.5.0"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbbff0a806a4728c99295b254c8838933b5b082d75e3cb70c8dab21fdfbcfa9a"
+checksum = "cc2b571658e38e0c01b1fdca3bbbe93c00d3d71693ff2770043f8c29bc7d6f80"
 dependencies = [
  "bytes",
  "futures-channel",
  "futures-util",
- "h2 0.4.6",
- "http 1.1.0",
+ "h2 0.4.7",
+ "http 1.2.0",
  "http-body 1.0.1",
  "httparse",
  "httpdate",
@@ -3910,7 +3946,7 @@ checksum = "ec3efd23720e2049821a693cbc7e65ea87c72f1c58ff2f9522ff332b1491e590"
 dependencies = [
  "futures-util",
  "http 0.2.12",
- "hyper 0.14.30",
+ "hyper 0.14.32",
  "log",
  "rustls 0.21.12",
  "rustls-native-certs",
@@ -3926,9 +3962,9 @@ checksum = "df2dcfbe0677734ab2f3ffa7fa7bfd4706bfdc1ef393f2ee30184aed67e631b4"
 dependencies = [
  "bytes",
  "futures-util",
- "http 1.1.0",
+ "http 1.2.0",
  "http-body 1.0.1",
- "hyper 1.5.0",
+ "hyper 1.6.0",
  "pin-project-lite",
  "tokio",
  "tower-service",
@@ -3957,6 +3993,124 @@ dependencies = [
  "cc",
 ]
 
+[[package]]
+name = "icu_collections"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db2fa452206ebee18c4b5c2274dbf1de17008e874b4dc4f0aea9d01ca79e4526"
+dependencies = [
+ "displaydoc",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locid"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13acbb8371917fc971be86fc8057c41a64b521c184808a698c02acc242dbf637"
+dependencies = [
+ "displaydoc",
+ "litemap",
+ "tinystr",
+ "writeable",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locid_transform"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "01d11ac35de8e40fdeda00d9e1e9d92525f3f9d887cdd7aa81d727596788b54e"
+dependencies = [
+ "displaydoc",
+ "icu_locid",
+ "icu_locid_transform_data",
+ "icu_provider",
+ "tinystr",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locid_transform_data"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fdc8ff3388f852bede6b579ad4e978ab004f139284d7b28715f773507b946f6e"
+
+[[package]]
+name = "icu_normalizer"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19ce3e0da2ec68599d193c93d088142efd7f9c5d6fc9b803774855747dc6a84f"
+dependencies = [
+ "displaydoc",
+ "icu_collections",
+ "icu_normalizer_data",
+ "icu_properties",
+ "icu_provider",
+ "smallvec",
+ "utf16_iter",
+ "utf8_iter",
+ "write16",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer_data"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8cafbf7aa791e9b22bec55a167906f9e1215fd475cd22adfcf660e03e989516"
+
+[[package]]
+name = "icu_properties"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93d6020766cfc6302c15dbbc9c8778c37e62c14427cb7f6e601d849e092aeef5"
+dependencies = [
+ "displaydoc",
+ "icu_collections",
+ "icu_locid_transform",
+ "icu_properties_data",
+ "icu_provider",
+ "tinystr",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_properties_data"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67a8effbc3dd3e4ba1afa8ad918d5684b8868b3b26500753effea8d2eed19569"
+
+[[package]]
+name = "icu_provider"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ed421c8a8ef78d3e2dbc98a973be2f3770cb42b606e3ab18d6237c4dfde68d9"
+dependencies = [
+ "displaydoc",
+ "icu_locid",
+ "icu_provider_macros",
+ "stable_deref_trait",
+ "tinystr",
+ "writeable",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_provider_macros"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ec89e9337638ecdc08744df490b221a7399bf8d164eb52a665454e60e075ad6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.96",
+]
+
 [[package]]
 name = "ident_case"
 version = "1.0.1"
@@ -3986,12 +4140,23 @@ dependencies = [
 
 [[package]]
 name = "idna"
-version = "0.5.0"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "634d9b1461af396cad843f47fdba5597a4f9e6ddd4bfb6ff5d85028c25cb12f6"
+checksum = "686f825264d630750a544639377bae737628043f20d38bbc029e8f29ea968a7e"
 dependencies = [
- "unicode-bidi",
- "unicode-normalization",
+ "idna_adapter",
+ "smallvec",
+ "utf8_iter",
+]
+
+[[package]]
+name = "idna_adapter"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "daca1df1c957320b2cf139ac61e7bd64fed304c5040df000a745aa1de3b4ef71"
+dependencies = [
+ "icu_normalizer",
+ "icu_properties",
 ]
 
 [[package]]
@@ -4006,9 +4171,9 @@ dependencies = [
 
 [[package]]
 name = "if-watch"
-version = "3.2.0"
+version = "3.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d6b0422c86d7ce0e97169cc42e04ae643caf278874a7a3c87b8150a220dc7e1e"
+checksum = "cdf9d64cfcf380606e64f9a0bcf493616b65331199f984151a6fa11a7b3cde38"
 dependencies = [
  "async-io",
  "core-foundation",
@@ -4017,6 +4182,10 @@ dependencies = [
  "if-addrs",
  "ipnet",
  "log",
+ "netlink-packet-core",
+ "netlink-packet-route",
+ "netlink-proto",
+ "netlink-sys",
  "rtnetlink",
  "system-configuration",
  "tokio",
@@ -4034,9 +4203,9 @@ dependencies = [
  "bytes",
  "futures",
  "http 0.2.12",
- "hyper 0.14.30",
+ "hyper 0.14.32",
  "log",
- "rand 0.8.5",
+ "rand",
  "tokio",
  "url",
  "xmltree",
@@ -4051,6 +4220,26 @@ dependencies = [
  "parity-scale-codec",
 ]
 
+[[package]]
+name = "impl-codec"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b67aa010c1e3da95bf151bd8b4c059b2ed7e75387cdb969b4f8f2723a43f9941"
+dependencies = [
+ "parity-scale-codec",
+]
+
+[[package]]
+name = "impl-num-traits"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "803d15461ab0dcc56706adf266158acbc44ccf719bf7d0af30705f58b90a4b8c"
+dependencies = [
+ "integer-sqrt",
+ "num-traits",
+ "uint 0.10.0",
+]
+
 [[package]]
 name = "impl-rlp"
 version = "0.3.0"
@@ -4069,15 +4258,24 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "impl-serde"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a143eada6a1ec4aefa5049037a26a6d597bfd64f8c026d07b77133e02b7dd0b"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "impl-trait-for-tuples"
-version = "0.2.2"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "11d7a9f6330b71fea57921c9b61c47ee6e84f72d394754eff6163ae67e7395eb"
+checksum = "a0eb5a3343abf848c0984fe4604b2b105da9539376e24fc0a3b0007411ae4fd9"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -4112,9 +4310,9 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "2.6.0"
+version = "2.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "707907fe3c25f5424cce2cb7e1cbcafee6bdbe735ca90ef77c29e84591e5b9da"
+checksum = "8c9c992b02b5b4c94ea26e32fe5bccb7aa7d9f390ab5c1221ff895bc7ea8b652"
 dependencies = [
  "equivalent",
  "hashbrown 0.15.2",
@@ -4170,7 +4368,7 @@ version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b58db92f96b720de98181bbbe63c831e87005ab460c1bf306eb2622b4707997f"
 dependencies = [
- "socket2 0.5.7",
+ "socket2 0.5.8",
  "widestring",
  "windows-sys 0.48.0",
  "winreg",
@@ -4178,19 +4376,19 @@ dependencies = [
 
 [[package]]
 name = "ipnet"
-version = "2.10.0"
+version = "2.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "187674a687eed5fe42285b40c6291f9a01517d415fad1c3cbc6a9f778af7fcd4"
+checksum = "469fb0b9cefa57e3ef31275ee7cacb78f2fdca44e4765491884a2b119d4eb130"
 
 [[package]]
 name = "is-terminal"
-version = "0.4.13"
+version = "0.4.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "261f68e344040fbd0edea105bef17c66edf46f984ddb1115b775ce31be948f4b"
+checksum = "e19b23d53f35ce9f56aebc7d1bb4e6ac1e9c0db7ac85c8d1760c04379edced37"
 dependencies = [
  "hermit-abi 0.4.0",
  "libc",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -4228,9 +4426,9 @@ dependencies = [
 
 [[package]]
 name = "itoa"
-version = "1.0.11"
+version = "1.0.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
+checksum = "d75a2a4b1b190afb6f5425f10f6a8f959d2ea0b9c2b1d79553551850539e4674"
 
 [[package]]
 name = "jobserver"
@@ -4243,18 +4441,19 @@ dependencies = [
 
 [[package]]
 name = "js-sys"
-version = "0.3.70"
+version = "0.3.77"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1868808506b929d7b0cfa8f75951347aa71bb21144b7791bae35d9bccfcfe37a"
+checksum = "1cfaf33c695fc6e08064efbc1f72ec937429614f25eef83af942d0e227c3a28f"
 dependencies = [
+ "once_cell",
  "wasm-bindgen",
 ]
 
 [[package]]
 name = "jsonrpsee"
-version = "0.24.7"
+version = "0.24.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c5c71d8c1a731cc4227c2f698d377e7848ca12c8a48866fc5e6951c43a4db843"
+checksum = "834af00800e962dee8f7bfc0f60601de215e73e78e5497d733a2919da837d3c8"
 dependencies = [
  "jsonrpsee-core",
  "jsonrpsee-proc-macros",
@@ -4266,51 +4465,51 @@ dependencies = [
 
 [[package]]
 name = "jsonrpsee-core"
-version = "0.24.7"
+version = "0.24.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2882f6f8acb9fdaec7cefc4fd607119a9bd709831df7d7672a1d3b644628280"
+checksum = "76637f6294b04e747d68e69336ef839a3493ca62b35bf488ead525f7da75c5bb"
 dependencies = [
  "async-trait",
  "bytes",
  "futures-util",
- "http 1.1.0",
+ "http 1.2.0",
  "http-body 1.0.1",
  "http-body-util",
  "jsonrpsee-types",
  "parking_lot 0.12.3",
- "rand 0.8.5",
- "rustc-hash 2.1.1",
+ "rand",
+ "rustc-hash 2.1.0",
  "serde",
  "serde_json",
- "thiserror",
+ "thiserror 1.0.69",
  "tokio",
  "tracing",
 ]
 
 [[package]]
 name = "jsonrpsee-proc-macros"
-version = "0.24.7"
+version = "0.24.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c06c01ae0007548e73412c08e2285ffe5d723195bf268bce67b1b77c3bb2a14d"
+checksum = "6fcae0c6c159e11541080f1f829873d8f374f81eda0abc67695a13fc8dc1a580"
 dependencies = [
  "heck 0.5.0",
  "proc-macro-crate 3.2.0",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
 name = "jsonrpsee-server"
-version = "0.24.7"
+version = "0.24.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "82ad8ddc14be1d4290cd68046e7d1d37acd408efed6d3ca08aefcc3ad6da069c"
+checksum = "66b7a3df90a1a60c3ed68e7ca63916b53e9afa928e33531e87f61a9c8e9ae87b"
 dependencies = [
  "futures-util",
- "http 1.1.0",
+ "http 1.2.0",
  "http-body 1.0.1",
  "http-body-util",
- "hyper 1.5.0",
+ "hyper 1.6.0",
  "hyper-util",
  "jsonrpsee-core",
  "jsonrpsee-types",
@@ -4319,7 +4518,7 @@ dependencies = [
  "serde",
  "serde_json",
  "soketto",
- "thiserror",
+ "thiserror 1.0.69",
  "tokio",
  "tokio-stream",
  "tokio-util",
@@ -4329,14 +4528,14 @@ dependencies = [
 
 [[package]]
 name = "jsonrpsee-types"
-version = "0.24.7"
+version = "0.24.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a178c60086f24cc35bb82f57c651d0d25d99c4742b4d335de04e97fa1f08a8a1"
+checksum = "ddb81adb1a5ae9182df379e374a79e24e992334e7346af4d065ae5b2acb8d4c6"
 dependencies = [
- "http 1.1.0",
+ "http 1.2.0",
  "serde",
  "serde_json",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
@@ -4425,15 +4624,15 @@ checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
 
 [[package]]
 name = "libc"
-version = "0.2.159"
+version = "0.2.169"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "561d97a539a36e26a9a5fad1ea11a3039a67714694aaa379433e580854bc3dc5"
+checksum = "b5aba8db14291edd000dfcc4d620c7ebfb122c613afb886ca8803fa4e128a20a"
 
 [[package]]
 name = "libloading"
-version = "0.8.5"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4979f22fdb869068da03c9f7528f8297c6fd2606bc3a4affe42e6a823fdb8da4"
+checksum = "fc2f4eb4bc735547cfed7c0a4922cbd04a4655978c09b54f1f7b228750664c34"
 dependencies = [
  "cfg-if",
  "windows-targets 0.52.6",
@@ -4441,9 +4640,9 @@ dependencies = [
 
 [[package]]
 name = "libm"
-version = "0.2.8"
+version = "0.2.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ec2a862134d2a7d32d7983ddcdd1c4923530833c9f2ea1a44fc5fa473989058"
+checksum = "8355be11b20d696c8f18f6cc018c4e372165b1fa8126cef092399c9951984ffa"
 
 [[package]]
 name = "libp2p"
@@ -4479,7 +4678,7 @@ dependencies = [
  "multiaddr 0.18.2",
  "pin-project",
  "rw-stream-sink",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
@@ -4520,16 +4719,16 @@ dependencies = [
  "libp2p-identity",
  "log",
  "multiaddr 0.18.2",
- "multihash 0.19.2",
+ "multihash 0.19.3",
  "multistream-select",
  "once_cell",
  "parking_lot 0.12.3",
  "pin-project",
  "quick-protobuf",
- "rand 0.8.5",
+ "rand",
  "rw-stream-sink",
  "smallvec",
- "thiserror",
+ "thiserror 1.0.69",
  "unsigned-varint 0.7.2",
  "void",
 ]
@@ -4569,24 +4768,24 @@ dependencies = [
  "quick-protobuf",
  "quick-protobuf-codec",
  "smallvec",
- "thiserror",
+ "thiserror 1.0.69",
  "void",
 ]
 
 [[package]]
 name = "libp2p-identity"
-version = "0.2.9"
+version = "0.2.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55cca1eb2bc1fd29f099f3daaab7effd01e1a54b7c577d0ed082521034d912e8"
+checksum = "257b5621d159b32282eac446bed6670c39c7dc68a200a992d8f056afa0066f6d"
 dependencies = [
  "bs58 0.5.1",
  "ed25519-dalek",
  "hkdf",
- "multihash 0.19.2",
+ "multihash 0.19.3",
  "quick-protobuf",
- "rand 0.8.5",
+ "rand",
  "sha2 0.10.8",
- "thiserror",
+ "thiserror 1.0.69",
  "tracing",
  "zeroize",
 ]
@@ -4611,11 +4810,11 @@ dependencies = [
  "log",
  "quick-protobuf",
  "quick-protobuf-codec",
- "rand 0.8.5",
+ "rand",
  "sha2 0.10.8",
  "smallvec",
- "thiserror",
- "uint",
+ "thiserror 1.0.69",
+ "uint 0.9.5",
  "unsigned-varint 0.7.2",
  "void",
 ]
@@ -4633,9 +4832,9 @@ dependencies = [
  "libp2p-identity",
  "libp2p-swarm",
  "log",
- "rand 0.8.5",
+ "rand",
  "smallvec",
- "socket2 0.5.7",
+ "socket2 0.5.8",
  "tokio",
  "trust-dns-proto 0.22.0",
  "void",
@@ -4671,14 +4870,14 @@ dependencies = [
  "libp2p-identity",
  "log",
  "multiaddr 0.18.2",
- "multihash 0.19.2",
+ "multihash 0.19.3",
  "once_cell",
  "quick-protobuf",
- "rand 0.8.5",
+ "rand",
  "sha2 0.10.8",
  "snow",
  "static_assertions",
- "thiserror",
+ "thiserror 1.0.69",
  "x25519-dalek",
  "zeroize",
 ]
@@ -4697,7 +4896,7 @@ dependencies = [
  "libp2p-identity",
  "libp2p-swarm",
  "log",
- "rand 0.8.5",
+ "rand",
  "void",
 ]
 
@@ -4717,11 +4916,11 @@ dependencies = [
  "log",
  "parking_lot 0.12.3",
  "quinn 0.10.2",
- "rand 0.8.5",
+ "rand",
  "ring 0.16.20",
  "rustls 0.21.12",
- "socket2 0.5.7",
- "thiserror",
+ "socket2 0.5.8",
+ "thiserror 1.0.69",
  "tokio",
 ]
 
@@ -4738,7 +4937,7 @@ dependencies = [
  "libp2p-identity",
  "libp2p-swarm",
  "log",
- "rand 0.8.5",
+ "rand",
  "smallvec",
  "void",
 ]
@@ -4760,7 +4959,7 @@ dependencies = [
  "log",
  "multistream-select",
  "once_cell",
- "rand 0.8.5",
+ "rand",
  "smallvec",
  "tokio",
  "void",
@@ -4776,7 +4975,7 @@ dependencies = [
  "proc-macro-warning 0.4.2",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -4792,7 +4991,7 @@ dependencies = [
  "libp2p-core",
  "libp2p-identity",
  "log",
- "socket2 0.5.7",
+ "socket2 0.5.8",
  "tokio",
 ]
 
@@ -4810,7 +5009,7 @@ dependencies = [
  "ring 0.16.20",
  "rustls 0.21.12",
  "rustls-webpki",
- "thiserror",
+ "thiserror 1.0.69",
  "x509-parser 0.15.1",
  "yasna",
 ]
@@ -4861,7 +5060,7 @@ dependencies = [
  "pin-project-lite",
  "rw-stream-sink",
  "soketto",
- "thiserror",
+ "thiserror 1.0.69",
  "url",
  "webpki-roots",
 ]
@@ -4875,7 +5074,7 @@ dependencies = [
  "futures",
  "libp2p-core",
  "log",
- "thiserror",
+ "thiserror 1.0.69",
  "yamux",
 ]
 
@@ -4885,9 +5084,9 @@ version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
 dependencies = [
- "bitflags 2.6.0",
+ "bitflags 2.8.0",
  "libc",
- "redox_syscall 0.5.7",
+ "redox_syscall 0.5.8",
 ]
 
 [[package]]
@@ -4918,7 +5117,7 @@ dependencies = [
  "libsecp256k1-core",
  "libsecp256k1-gen-ecmult",
  "libsecp256k1-gen-genmult",
- "rand 0.8.5",
+ "rand",
  "serde",
  "sha2 0.9.9",
  "typenum 1.17.0",
@@ -4966,9 +5165,9 @@ dependencies = [
 
 [[package]]
 name = "libz-sys"
-version = "1.1.20"
+version = "1.1.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2d16453e800a8cf6dd2fc3eb4bc99b786a9b90c663b8559a5b1a041bf89e472"
+checksum = "df9b68e50e6e0b26f672573834882eb57759f6db9b3be2ea3c35c91188bb4eaa"
 dependencies = [
  "cc",
  "pkg-config",
@@ -4992,18 +5191,18 @@ checksum = "0717cef1bc8b636c6e1c1bbdefc09e6322da8a9321966e8928ef80d20f7f770f"
 
 [[package]]
 name = "linked_hash_set"
-version = "0.1.4"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "47186c6da4d81ca383c7c47c1bfc80f4b95f4720514d860a5407aaf4233f9588"
+checksum = "bae85b5be22d9843c80e5fc80e9b64c8a3b1f98f867c709956eca3efff4e92e2"
 dependencies = [
  "linked-hash-map",
 ]
 
 [[package]]
 name = "linregress"
-version = "0.5.3"
+version = "0.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4de04dcecc58d366391f9920245b85ffa684558a5ef6e7736e754347c3aea9c2"
+checksum = "a9eda9dcf4f2a99787827661f312ac3219292549c2ee992bf9a6248ffb066bf7"
 dependencies = [
  "nalgebra",
 ]
@@ -5016,9 +5215,9 @@ checksum = "f051f77a7c8e6957c0696eac88f26b0117e54f52d3fc682ab19397a8812846a4"
 
 [[package]]
 name = "linux-raw-sys"
-version = "0.4.14"
+version = "0.4.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89"
+checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab"
 
 [[package]]
 name = "lioness"
@@ -5032,6 +5231,12 @@ dependencies = [
  "keystream",
 ]
 
+[[package]]
+name = "litemap"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ee93343901ab17bd981295f2cf0026d4ad018c7c31ba84549a4ddbb47a45104"
+
 [[package]]
 name = "litep2p"
 version = "0.6.2"
@@ -5046,7 +5251,7 @@ dependencies = [
  "futures",
  "futures-timer",
  "hex-literal",
- "indexmap 2.6.0",
+ "indexmap 2.7.1",
  "libc",
  "mockall 0.12.1",
  "multiaddr 0.17.1",
@@ -5058,7 +5263,7 @@ dependencies = [
  "prost 0.12.6",
  "prost-build 0.11.9",
  "quinn 0.9.4",
- "rand 0.8.5",
+ "rand",
  "rcgen",
  "ring 0.16.20",
  "rustls 0.20.9",
@@ -5067,17 +5272,17 @@ dependencies = [
  "simple-dns",
  "smallvec",
  "snow",
- "socket2 0.5.7",
+ "socket2 0.5.8",
  "static_assertions",
  "str0m",
- "thiserror",
+ "thiserror 1.0.69",
  "tokio",
  "tokio-stream",
  "tokio-tungstenite",
  "tokio-util",
  "tracing",
  "trust-dns-resolver",
- "uint",
+ "uint 0.9.5",
  "unsigned-varint 0.8.0",
  "url",
  "webpki",
@@ -5099,9 +5304,9 @@ dependencies = [
 
 [[package]]
 name = "log"
-version = "0.4.22"
+version = "0.4.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
+checksum = "04cbf5b083de1c7e0222a7a51dbfdba1cbe1c6ab0b15e29fff3f6c077fd9cd9f"
 
 [[package]]
 name = "lru"
@@ -5132,9 +5337,9 @@ dependencies = [
 
 [[package]]
 name = "lz4"
-version = "1.28.0"
+version = "1.28.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d1febb2b4a79ddd1980eede06a8f7902197960aa0383ffcfdd62fe723036725"
+checksum = "a20b523e860d03443e98350ceaac5e71c6ba89aea7d960769ec3ce37f4de5af4"
 dependencies = [
  "lz4-sys",
 ]
@@ -5167,7 +5372,7 @@ dependencies = [
  "macro_magic_core",
  "macro_magic_macros",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -5181,7 +5386,7 @@ dependencies = [
  "macro_magic_core_macros",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -5192,7 +5397,7 @@ checksum = "b02abfe41815b5bd98dbd4260173db2c116dda171dc0fe7838cb206333b83308"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -5203,7 +5408,7 @@ checksum = "73ea28ee64b88876bf45277ed9a5817c1817df061a74f2b988971a12570e5869"
 dependencies = [
  "macro_magic_core",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -5249,7 +5454,7 @@ version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b2cffa4ad52c6f791f4f8b15f0c05f9824b2ced1160e88cc393d64fff9a8ac64"
 dependencies = [
- "rustix 0.38.37",
+ "rustix 0.38.44",
 ]
 
 [[package]]
@@ -5310,7 +5515,7 @@ checksum = "58c38e2799fc0978b65dfff8023ec7843e2330bb462f19198840b34b6582397d"
 dependencies = [
  "byteorder",
  "keccak",
- "rand_core 0.6.4",
+ "rand_core",
  "zeroize",
 ]
 
@@ -5322,20 +5527,19 @@ checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
 
 [[package]]
 name = "miniz_oxide"
-version = "0.8.0"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2d80299ef12ff69b16a84bb182e3b9df68b5a91574d3d4fa6e41b65deec4df1"
+checksum = "b8402cab7aefae129c6977bb0ff1b8fd9a04eb5b51efc50a70bea51cda0c7924"
 dependencies = [
  "adler2",
 ]
 
 [[package]]
 name = "mio"
-version = "1.0.2"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "80e04d1dcff3aae0704555fe5fee3bcfaf3d1fdf8a7e521d5b9d2b42acb52cec"
+checksum = "2886843bf800fba2e3377cff24abf6379b4c4d5c6681eaf9ea5b0d15090450bd"
 dependencies = [
- "hermit-abi 0.3.9",
  "libc",
  "wasi 0.11.0+wasi-snapshot-preview1",
  "windows-sys 0.52.0",
@@ -5358,11 +5562,11 @@ dependencies = [
  "lioness",
  "log",
  "parking_lot 0.12.3",
- "rand 0.8.5",
- "rand_chacha 0.3.1",
+ "rand",
+ "rand_chacha",
  "rand_distr",
  "subtle 2.6.1",
- "thiserror",
+ "thiserror 1.0.69",
  "zeroize",
 ]
 
@@ -5392,7 +5596,7 @@ dependencies = [
  "fragile",
  "lazy_static",
  "mockall_derive 0.12.1",
- "predicates 3.1.2",
+ "predicates 3.1.3",
  "predicates-tree",
 ]
 
@@ -5417,7 +5621,7 @@ dependencies = [
  "cfg-if",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -5450,7 +5654,7 @@ dependencies = [
  "data-encoding",
  "libp2p-identity",
  "multibase",
- "multihash 0.19.2",
+ "multihash 0.19.3",
  "percent-encoding",
  "serde",
  "static_assertions",
@@ -5505,9 +5709,9 @@ dependencies = [
 
 [[package]]
 name = "multihash"
-version = "0.19.2"
+version = "0.19.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc41f430805af9d1cf4adae4ed2149c759b877b01d909a1f40256188d09345d2"
+checksum = "6b430e7953c29dd6a09afc29ff0bb69c6e306329ee6794700aee27b76a1aea8d"
 dependencies = [
  "core2",
  "unsigned-varint 0.8.0",
@@ -5533,6 +5737,12 @@ version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e5ce46fe64a9d73be07dcbe690a38ce1b293be448fd8ce1e6c1b8062c9f72c6a"
 
+[[package]]
+name = "multimap"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "defc4c55412d89136f966bbb339008b474350e5e6e78d2714439c386b3137a03"
+
 [[package]]
 name = "multistream-select"
 version = "0.13.0"
@@ -5549,13 +5759,12 @@ dependencies = [
 
 [[package]]
 name = "nalgebra"
-version = "0.32.6"
+version = "0.33.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b5c17de023a86f59ed79891b2e5d5a94c705dbe904a5b5c9c952ea6221b03e4"
+checksum = "26aecdf64b707efd1310e3544d709c5c0ac61c13756046aaaba41be5c4f66a3b"
 dependencies = [
  "approx",
  "matrixmultiply",
- "nalgebra-macros",
  "num-complex",
  "num-rational",
  "num-traits",
@@ -5563,31 +5772,20 @@ dependencies = [
  "typenum 1.17.0",
 ]
 
-[[package]]
-name = "nalgebra-macros"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "254a5372af8fc138e36684761d3c0cdb758a4410e938babcff1c860ce14ddbfc"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.90",
-]
-
 [[package]]
 name = "names"
 version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7bddcd3bf5144b6392de80e04c347cd7fab2508f6df16a85fc496ecd5cec39bc"
 dependencies = [
- "rand 0.8.5",
+ "rand",
 ]
 
 [[package]]
 name = "native-tls"
-version = "0.2.12"
+version = "0.2.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8614eb2c83d59d1c8cc974dd3f920198647674a0a035e1af1fa58707e317466"
+checksum = "0dab59f8e050d5df8e4dd87d9206fb6f65a483e20ac9fda365ade4fab353196c"
 dependencies = [
  "libc",
  "log",
@@ -5615,21 +5813,20 @@ dependencies = [
 
 [[package]]
 name = "netlink-packet-core"
-version = "0.4.2"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "345b8ab5bd4e71a2986663e88c56856699d060e78e152e6e9d7966fcd5491297"
+checksum = "72724faf704479d67b388da142b186f916188505e7e0b26719019c525882eda4"
 dependencies = [
  "anyhow",
  "byteorder",
- "libc",
  "netlink-packet-utils",
 ]
 
 [[package]]
 name = "netlink-packet-route"
-version = "0.12.0"
+version = "0.17.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9ea4302b9759a7a88242299225ea3688e63c85ea136371bb6cf94fd674efaab"
+checksum = "053998cea5a306971f88580d0829e90f270f940befd7cf928da179d4187a5a66"
 dependencies = [
  "anyhow",
  "bitflags 1.3.2",
@@ -5648,29 +5845,28 @@ dependencies = [
  "anyhow",
  "byteorder",
  "paste",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
 name = "netlink-proto"
-version = "0.10.0"
+version = "0.11.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "65b4b14489ab424703c092062176d52ba55485a89c076b4f9db05092b7223aa6"
+checksum = "72452e012c2f8d612410d89eea01e2d9b56205274abb35d53f60200b2ec41d60"
 dependencies = [
  "bytes",
  "futures",
  "log",
  "netlink-packet-core",
  "netlink-sys",
- "thiserror",
- "tokio",
+ "thiserror 2.0.11",
 ]
 
 [[package]]
 name = "netlink-sys"
-version = "0.8.6"
+version = "0.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "416060d346fbaf1f23f9512963e3e878f1a78e707cb699ba9215761754244307"
+checksum = "16c903aa70590cb93691bf97a767c8d1d6122d2cc9070433deb3bbf36ce8bd23"
 dependencies = [
  "bytes",
  "futures",
@@ -5687,15 +5883,15 @@ checksum = "a4a43439bf756eed340bdf8feba761e2d50c7d47175d87545cd5cbe4a137c4d1"
 dependencies = [
  "cc",
  "libc",
- "thiserror",
+ "thiserror 1.0.69",
  "winapi",
 ]
 
 [[package]]
 name = "nix"
-version = "0.24.3"
+version = "0.26.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa52e972a9a719cecb6864fb88568781eb706bac2cd1d4f04a648542dbf78069"
+checksum = "598beaf3cc6fdd9a5dfb1630c2800c7acd31df7aaf0f565796fba2b53ca1af1b"
 dependencies = [
  "bitflags 1.3.2",
  "cfg-if",
@@ -5787,7 +5983,7 @@ dependencies = [
  "subtensor-custom-rpc",
  "subtensor-custom-rpc-runtime-api",
  "subtensor-runtime-common",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
@@ -5842,7 +6038,7 @@ dependencies = [
  "pallet-utility 38.0.0",
  "parity-scale-codec",
  "precompile-utils",
- "rand_chacha 0.3.1",
+ "rand_chacha",
  "scale-info",
  "serde_json",
  "sha2 0.10.8",
@@ -6033,7 +6229,7 @@ dependencies = [
  "proc-macro-crate 3.2.0",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -6059,9 +6255,9 @@ dependencies = [
 
 [[package]]
 name = "object"
-version = "0.36.4"
+version = "0.36.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "084f1a5821ac4c651660a94a7153d27ac9d8a53736203f58b31945ded098070a"
+checksum = "62948e14d923ea95ea2c7c86c71013138b66525b86bdc08d2dcc262bdb497b87"
 dependencies = [
  "memchr",
 ]
@@ -6086,12 +6282,9 @@ dependencies = [
 
 [[package]]
 name = "once_cell"
-version = "1.20.1"
+version = "1.20.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "82881c4be219ab5faaf2ad5e5e5ecdff8c66bd7402ca3160975c93b24961afd1"
-dependencies = [
- "portable-atomic",
-]
+checksum = "1261fe7e33c73b354eab43b1273a57c8f967d0391e80353e51f764ac02cf6775"
 
 [[package]]
 name = "opaque-debug"
@@ -6111,7 +6304,7 @@ version = "0.10.70"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "61cfb4e166a8bb8c9b55c500bc2308550148ece889be90f609377e58140f42c6"
 dependencies = [
- "bitflags 2.6.0",
+ "bitflags 2.8.0",
  "cfg-if",
  "foreign-types",
  "libc",
@@ -6128,20 +6321,20 @@ checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
 name = "openssl-probe"
-version = "0.1.5"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf"
+checksum = "d05e27ee213611ffe7d6348b942e8f942b37114c00cc03cec254295a4a17852e"
 
 [[package]]
 name = "openssl-src"
-version = "300.4.0+3.4.0"
+version = "300.4.1+3.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a709e02f2b4aca747929cca5ed248880847c650233cf8b8cdc48f40aaf4898a6"
+checksum = "faa4eac4138c62414b5622d1b31c5c304f34b406b013c079c2bbc652fdd6678c"
 dependencies = [
  "cc",
 ]
@@ -6289,7 +6482,7 @@ dependencies = [
  "pallet-drand",
  "pallet-subtensor",
  "parity-scale-codec",
- "rand_chacha 0.3.1",
+ "rand_chacha",
  "scale-info",
  "sha2 0.10.8",
  "sp-core",
@@ -6660,8 +6853,8 @@ dependencies = [
  "pallet-utility 38.0.0",
  "parity-scale-codec",
  "parity-util-mem",
- "rand 0.8.5",
- "rand_chacha 0.3.1",
+ "rand",
+ "rand_chacha",
  "safe-math",
  "scale-info",
  "serde",
@@ -6824,8 +7017,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4e69bf016dc406eff7d53a7d3f7cf1c2e72c82b9088aac1118591e36dd2cd3e9"
 dependencies = [
  "bitcoin_hashes",
- "rand 0.8.5",
- "rand_core 0.6.4",
+ "rand",
+ "rand_core",
  "serde",
  "unicode-normalization",
 ]
@@ -6845,7 +7038,7 @@ dependencies = [
  "lz4",
  "memmap2 0.5.10",
  "parking_lot 0.12.3",
- "rand 0.8.5",
+ "rand",
  "siphasher",
  "snap",
  "winapi",
@@ -6891,7 +7084,7 @@ dependencies = [
  "lru 0.8.1",
  "parity-util-mem-derive",
  "parking_lot 0.12.3",
- "primitive-types",
+ "primitive-types 0.12.2",
  "smallvec",
  "winapi",
 ]
@@ -6962,7 +7155,7 @@ checksum = "1e401f977ab385c9e4e3ab30627d6f26d00e2c73eef317493c4ec6d468726cf8"
 dependencies = [
  "cfg-if",
  "libc",
- "redox_syscall 0.5.7",
+ "redox_syscall 0.5.8",
  "smallvec",
  "windows-targets 0.52.6",
 ]
@@ -6980,7 +7173,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "346f04948ba92c43e8469c1ee6736c7563d71012b17d40745260fe106aac2166"
 dependencies = [
  "base64ct",
- "rand_core 0.6.4",
+ "rand_core",
  "subtle 2.6.1",
 ]
 
@@ -7023,20 +7216,20 @@ checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e"
 
 [[package]]
 name = "pest"
-version = "2.7.13"
+version = "2.7.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fdbef9d1d47087a895abd220ed25eb4ad973a5e26f6a4367b038c25e28dfc2d9"
+checksum = "8b7cafe60d6cf8e62e1b9b2ea516a089c008945bb5a275416789e7db0bc199dc"
 dependencies = [
  "memchr",
- "thiserror",
+ "thiserror 2.0.11",
  "ucd-trie",
 ]
 
 [[package]]
 name = "pest_derive"
-version = "2.7.13"
+version = "2.7.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d3a6e3394ec80feb3b6393c725571754c6188490265c61aaf260810d6b95aa0"
+checksum = "816518421cfc6887a0d62bf441b6ffb4536fcc926395a69e1a85852d4363f57e"
 dependencies = [
  "pest",
  "pest_generator",
@@ -7044,22 +7237,22 @@ dependencies = [
 
 [[package]]
 name = "pest_generator"
-version = "2.7.13"
+version = "2.7.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94429506bde1ca69d1b5601962c73f4172ab4726571a59ea95931218cb0e930e"
+checksum = "7d1396fd3a870fc7838768d171b4616d5c91f6cc25e377b673d714567d99377b"
 dependencies = [
  "pest",
  "pest_meta",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
 name = "pest_meta"
-version = "2.7.13"
+version = "2.7.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac8a071862e93690b6e34e9a5fb8e33ff3734473ac0245b27232222c4906a33f"
+checksum = "e1e58089ea25d717bfd31fb534e4f3afcc2cc569c70de3e239778991ea3b7dea"
 dependencies = [
  "once_cell",
  "pest",
@@ -7073,34 +7266,34 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b4c5cc86750666a3ed20bdaf5ca2a0344f9c67674cae0515bec2da16fbaa47db"
 dependencies = [
  "fixedbitset",
- "indexmap 2.6.0",
+ "indexmap 2.7.1",
 ]
 
 [[package]]
 name = "pin-project"
-version = "1.1.5"
+version = "1.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6bf43b791c5b9e34c3d182969b4abb522f9343702850a2e57f460d00d09b4b3"
+checksum = "1e2ec53ad785f4d35dac0adea7f7dc6f1bb277ad84a680c7afefeae05d1f5916"
 dependencies = [
  "pin-project-internal",
 ]
 
 [[package]]
 name = "pin-project-internal"
-version = "1.1.5"
+version = "1.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f38a4412a78282e09a2cf38d195ea5420d15ba0602cb375210efbc877243965"
+checksum = "d56a66c0c55993aa927429d0f8a0abfd74f084e4d9c192cffed01e418d83eefb"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
 name = "pin-project-lite"
-version = "0.2.14"
+version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bda66fc9667c18cb2758a2ac84d1167245054bcf85d5d1aaa6923f45801bdd02"
+checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b"
 
 [[package]]
 name = "pin-utils"
@@ -7133,7 +7326,7 @@ dependencies = [
  "libc",
  "log",
  "polkavm-assembler",
- "polkavm-common",
+ "polkavm-common 0.9.0",
  "polkavm-linux-raw",
 ]
 
@@ -7155,13 +7348,28 @@ dependencies = [
  "log",
 ]
 
+[[package]]
+name = "polkavm-common"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "31ff33982a807d8567645d4784b9b5d7ab87bcb494f534a57cadd9012688e102"
+
 [[package]]
 name = "polkavm-derive"
 version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ae8c4bea6f3e11cd89bb18bcdddac10bd9a24015399bd1c485ad68a985a19606"
 dependencies = [
- "polkavm-derive-impl-macro",
+ "polkavm-derive-impl-macro 0.9.0",
+]
+
+[[package]]
+name = "polkavm-derive"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2eb703f3b6404c13228402e98a5eae063fd16b8f58afe334073ec105ee4117e"
+dependencies = [
+ "polkavm-derive-impl-macro 0.18.0",
 ]
 
 [[package]]
@@ -7170,10 +7378,22 @@ version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5c4fdfc49717fb9a196e74a5d28e0bc764eb394a2c803eb11133a31ac996c60c"
 dependencies = [
- "polkavm-common",
+ "polkavm-common 0.9.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.96",
+]
+
+[[package]]
+name = "polkavm-derive-impl"
+version = "0.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f2116a92e6e96220a398930f4c8a6cda1264206f3e2034fc9982bfd93f261f7"
+dependencies = [
+ "polkavm-common 0.18.0",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -7182,8 +7402,18 @@ version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8ba81f7b5faac81e528eb6158a6f3c9e0bb1008e0ffa19653bc8dea925ecb429"
 dependencies = [
- "polkavm-derive-impl",
- "syn 2.0.90",
+ "polkavm-derive-impl 0.9.0",
+ "syn 2.0.96",
+]
+
+[[package]]
+name = "polkavm-derive-impl-macro"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48c16669ddc7433e34c1007d31080b80901e3e8e523cb9d4b441c3910cf9294b"
+dependencies = [
+ "polkavm-derive-impl 0.18.1",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -7196,7 +7426,7 @@ dependencies = [
  "hashbrown 0.14.5",
  "log",
  "object 0.32.2",
- "polkavm-common",
+ "polkavm-common 0.9.0",
  "regalloc2 0.9.3",
  "rustc-demangle",
 ]
@@ -7209,15 +7439,15 @@ checksum = "26e85d3456948e650dff0cfc85603915847faf893ed1e66b020bb82ef4557120"
 
 [[package]]
 name = "polling"
-version = "3.7.3"
+version = "3.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc2790cd301dec6cd3b7a025e4815cf825724a51c98dccfe6a3e55f05ffb6511"
+checksum = "a604568c3202727d1507653cb121dbd627a58684eb09a820fd746bee38b4442f"
 dependencies = [
  "cfg-if",
  "concurrent-queue",
  "hermit-abi 0.4.0",
  "pin-project-lite",
- "rustix 0.38.37",
+ "rustix 0.38.44",
  "tracing",
  "windows-sys 0.59.0",
 ]
@@ -7247,9 +7477,9 @@ dependencies = [
 
 [[package]]
 name = "portable-atomic"
-version = "1.9.0"
+version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc9c68a3f6da06753e9335d63e27f6b9754dd1920d941135b7ea8224f141adb2"
+checksum = "280dc24453071f1b63954171985a0b0d30058d287960968b9b2aca264c8d4ee6"
 
 [[package]]
 name = "powerfmt"
@@ -7263,7 +7493,7 @@ version = "0.2.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04"
 dependencies = [
- "zerocopy 0.7.35",
+ "zerocopy",
 ]
 
 [[package]]
@@ -7297,7 +7527,7 @@ source = "git+https://github.com/opentensor/frontier?rev=635bdac882#635bdac88233
 dependencies = [
  "case",
  "num_enum",
- "prettyplease 0.2.22",
+ "prettyplease 0.2.29",
  "proc-macro2",
  "quote",
  "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409)",
@@ -7320,9 +7550,9 @@ dependencies = [
 
 [[package]]
 name = "predicates"
-version = "3.1.2"
+version = "3.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e9086cc7640c29a356d1a29fd134380bee9d8f79a17410aa76e7ad295f42c97"
+checksum = "a5d19ee57562043d37e82899fade9a22ebab7be9cef5026b07fda9cdd4293573"
 dependencies = [
  "anstyle",
  "predicates-core",
@@ -7330,15 +7560,15 @@ dependencies = [
 
 [[package]]
 name = "predicates-core"
-version = "1.0.8"
+version = "1.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae8177bee8e75d6846599c6b9ff679ed51e882816914eec639944d7c9aa11931"
+checksum = "727e462b119fe9c93fd0eb1429a5f7647394014cf3c04ab2c0350eeb09095ffa"
 
 [[package]]
 name = "predicates-tree"
-version = "1.0.11"
+version = "1.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41b740d195ed3166cd147c8047ec98db0e22ec019eb8eeb76d343b795304fb13"
+checksum = "72dd2d6d381dfb73a193c7fca536518d7caee39fc8503f74e7dc0be0531b425c"
 dependencies = [
  "predicates-core",
  "termtree",
@@ -7356,12 +7586,12 @@ dependencies = [
 
 [[package]]
 name = "prettyplease"
-version = "0.2.22"
+version = "0.2.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "479cf940fbbb3426c32c5d5176f62ad57549a0bb84773423ba8be9d089f5faba"
+checksum = "6924ced06e1f7dfe3fa48d57b9f74f55d8915f5036121bef647ef4b204895fac"
 dependencies = [
  "proc-macro2",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -7371,11 +7601,23 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b34d9fd68ae0b74a41b21c03c2f62847aa0ffea044eee893b4c140b37e244e2"
 dependencies = [
  "fixed-hash",
- "impl-codec",
+ "impl-codec 0.6.0",
  "impl-rlp",
- "impl-serde",
+ "impl-serde 0.4.0",
  "scale-info",
- "uint",
+ "uint 0.9.5",
+]
+
+[[package]]
+name = "primitive-types"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d15600a7d856470b7d278b3fe0e311fe28c2526348549f8ef2ff7db3299c87f5"
+dependencies = [
+ "fixed-hash",
+ "impl-codec 0.7.0",
+ "impl-num-traits",
+ "uint 0.10.0",
 ]
 
 [[package]]
@@ -7384,7 +7626,7 @@ version = "1.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e17d47ce914bf4de440332250b0edd23ce48c005f59fab39d3335866b114f11a"
 dependencies = [
- "thiserror",
+ "thiserror 1.0.69",
  "toml 0.5.11",
 ]
 
@@ -7429,7 +7671,7 @@ checksum = "3d1eaa7fa0aa1929ffdf7eeb6eac234dde6268914a14ad44d23521ab6a9b258e"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -7440,14 +7682,14 @@ checksum = "834da187cfe638ae8abb0203f0b33e5ccdb02a28e7199f2f47b3e2754f50edca"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.92"
+version = "1.0.93"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37d3544b3f2748c54e147655edb5025752e2303145b5aefb3c3ea2c78b973bb0"
+checksum = "60946a68e5f9d28b0dc1c21bb8a97ee7d018a8b322fa57838ba31cc878e22d99"
 dependencies = [
  "unicode-ident",
 ]
@@ -7468,7 +7710,7 @@ dependencies = [
  "quote",
  "regex",
  "sp-crypto-hashing 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -7482,7 +7724,7 @@ dependencies = [
  "lazy_static",
  "memchr",
  "parking_lot 0.12.3",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
@@ -7505,7 +7747,7 @@ checksum = "440f724eba9f6996b75d63681b0a92b06947f1457076d503a4d2e2c8f56442b8"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -7516,11 +7758,11 @@ checksum = "14cae93065090804185d3b75f0bf93b8eeda30c7a9b4a33d3bdb3988d6229e50"
 dependencies = [
  "bit-set",
  "bit-vec",
- "bitflags 2.6.0",
+ "bitflags 2.8.0",
  "lazy_static",
  "num-traits",
- "rand 0.8.5",
- "rand_chacha 0.3.1",
+ "rand",
+ "rand_chacha",
  "rand_xorshift",
  "regex-syntax 0.8.5",
  "rusty-fork",
@@ -7559,7 +7801,7 @@ dependencies = [
  "itertools 0.10.5",
  "lazy_static",
  "log",
- "multimap",
+ "multimap 0.8.3",
  "petgraph",
  "prettyplease 0.1.25",
  "prost 0.11.9",
@@ -7580,14 +7822,14 @@ dependencies = [
  "heck 0.5.0",
  "itertools 0.12.1",
  "log",
- "multimap",
+ "multimap 0.10.0",
  "once_cell",
  "petgraph",
- "prettyplease 0.2.22",
+ "prettyplease 0.2.29",
  "prost 0.12.6",
  "prost-types 0.12.6",
  "regex",
- "syn 2.0.90",
+ "syn 2.0.96",
  "tempfile",
 ]
 
@@ -7614,7 +7856,7 @@ dependencies = [
  "itertools 0.12.1",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -7637,18 +7879,18 @@ dependencies = [
 
 [[package]]
 name = "psm"
-version = "0.1.23"
+version = "0.1.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aa37f80ca58604976033fae9515a8a2989fc13797d953f7c04fb8fa36a11f205"
+checksum = "200b9ff220857e53e184257720a14553b2f4aa02577d2ed9842d45d4b9654810"
 dependencies = [
  "cc",
 ]
 
 [[package]]
 name = "quanta"
-version = "0.12.3"
+version = "0.12.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e5167a477619228a0b284fac2674e3c388cba90631d7b7de620e6f1fcd08da5"
+checksum = "3bd1fe6824cea6538803de3ff1bc0cf3949024db3d43c9643024bfb33a807c0e"
 dependencies = [
  "crossbeam-utils",
  "libc",
@@ -7683,7 +7925,7 @@ dependencies = [
  "asynchronous-codec",
  "bytes",
  "quick-protobuf",
- "thiserror",
+ "thiserror 1.0.69",
  "unsigned-varint 0.7.2",
 ]
 
@@ -7699,7 +7941,7 @@ dependencies = [
  "quinn-udp 0.3.2",
  "rustc-hash 1.1.0",
  "rustls 0.20.9",
- "thiserror",
+ "thiserror 1.0.69",
  "tokio",
  "tracing",
  "webpki",
@@ -7718,7 +7960,7 @@ dependencies = [
  "quinn-udp 0.4.1",
  "rustc-hash 1.1.0",
  "rustls 0.21.12",
- "thiserror",
+ "thiserror 1.0.69",
  "tokio",
  "tracing",
 ]
@@ -7730,12 +7972,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "94b0b33c13a79f669c85defaf4c275dc86a0c0372807d0ca3d78e0bb87274863"
 dependencies = [
  "bytes",
- "rand 0.8.5",
+ "rand",
  "ring 0.16.20",
  "rustc-hash 1.1.0",
  "rustls 0.20.9",
  "slab",
- "thiserror",
+ "thiserror 1.0.69",
  "tinyvec",
  "tracing",
  "webpki",
@@ -7748,12 +7990,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "141bf7dfde2fbc246bfd3fe12f2455aa24b0fbd9af535d8c86c7bd1381ff2b1a"
 dependencies = [
  "bytes",
- "rand 0.8.5",
+ "rand",
  "ring 0.16.20",
  "rustc-hash 1.1.0",
  "rustls 0.21.12",
  "slab",
- "thiserror",
+ "thiserror 1.0.69",
  "tinyvec",
  "tracing",
 ]
@@ -7779,26 +8021,20 @@ checksum = "055b4e778e8feb9f93c4e439f71dc2156ef13360b432b799e179a8c4cdf0b1d7"
 dependencies = [
  "bytes",
  "libc",
- "socket2 0.5.7",
+ "socket2 0.5.8",
  "tracing",
  "windows-sys 0.48.0",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.37"
+version = "1.0.38"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
+checksum = "0e4dccaaaf89514f546c693ddc140f729f958c247918a13380cccc6078391acc"
 dependencies = [
  "proc-macro2",
 ]
 
-[[package]]
-name = "r-efi"
-version = "5.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74765f6d916ee2faa39bc8e68e4f3ed8949b48cccdac59983d287a7cb71ce9c5"
-
 [[package]]
 name = "radium"
 version = "0.7.0"
@@ -7812,19 +8048,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
 dependencies = [
  "libc",
- "rand_chacha 0.3.1",
- "rand_core 0.6.4",
-]
-
-[[package]]
-name = "rand"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3779b94aeb87e8bd4e834cee3650289ee9e0d5677f976ecdb6d219e5f4f6cd94"
-dependencies = [
- "rand_chacha 0.9.0",
- "rand_core 0.9.3",
- "zerocopy 0.8.24",
+ "rand_chacha",
+ "rand_core",
 ]
 
 [[package]]
@@ -7834,17 +8059,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
 dependencies = [
  "ppv-lite86",
- "rand_core 0.6.4",
-]
-
-[[package]]
-name = "rand_chacha"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
-dependencies = [
- "ppv-lite86",
- "rand_core 0.9.3",
+ "rand_core",
 ]
 
 [[package]]
@@ -7856,15 +8071,6 @@ dependencies = [
  "getrandom 0.2.15",
 ]
 
-[[package]]
-name = "rand_core"
-version = "0.9.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38"
-dependencies = [
- "getrandom 0.3.2",
-]
-
 [[package]]
 name = "rand_distr"
 version = "0.4.3"
@@ -7872,7 +8078,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32cb0b9bc82b0a0876c2dd994a7e7a2683d3e7390ca40e6886785ef0c7e3ee31"
 dependencies = [
  "num-traits",
- "rand 0.8.5",
+ "rand",
 ]
 
 [[package]]
@@ -7881,7 +8087,7 @@ version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "59cad018caf63deb318e5a4586d99a24424a364f40f1e5778c29aca23f4fc73e"
 dependencies = [
- "rand_core 0.6.4",
+ "rand_core",
 ]
 
 [[package]]
@@ -7890,16 +8096,16 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d25bf25ec5ae4a3f1b92f929810509a2f53d7dca2f50b794ff57e3face536c8f"
 dependencies = [
- "rand_core 0.6.4",
+ "rand_core",
 ]
 
 [[package]]
 name = "raw-cpuid"
-version = "11.2.0"
+version = "11.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ab240315c661615f2ee9f0f2cd32d5a7343a84d5ebcccb99d46e6637565e7b0"
+checksum = "c6928fa44c097620b706542d428957635951bade7143269085389d42c8a4927e"
 dependencies = [
- "bitflags 2.6.0",
+ "bitflags 2.8.0",
 ]
 
 [[package]]
@@ -7951,11 +8157,11 @@ dependencies = [
 
 [[package]]
 name = "redox_syscall"
-version = "0.5.7"
+version = "0.5.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b6dfecf2c74bce2466cabf93f6664d6998a69eb21e39f4207930065b27b771f"
+checksum = "03a862b389f93e68874fbf580b9de08dd02facb9a788ebadaf4a3fd33cf58834"
 dependencies = [
- "bitflags 2.6.0",
+ "bitflags 2.8.0",
 ]
 
 [[package]]
@@ -7966,7 +8172,7 @@ checksum = "ba009ff324d1fc1b900bd1fdb31564febe58a8ccc8a6fdbb93b543d33b13ca43"
 dependencies = [
  "getrandom 0.2.15",
  "libredox",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
@@ -7986,7 +8192,7 @@ checksum = "bcc303e793d3734489387d205e9b186fac9c6cfacedd98cbb2e8a5943595f3e6"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -8016,13 +8222,13 @@ dependencies = [
 
 [[package]]
 name = "regex"
-version = "1.11.0"
+version = "1.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38200e5ee88914975b69f657f0801b6f6dccafd44fd9326302a4aaeecfacb1d8"
+checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
 dependencies = [
  "aho-corasick",
  "memchr",
- "regex-automata 0.4.8",
+ "regex-automata 0.4.9",
  "regex-syntax 0.8.5",
 ]
 
@@ -8037,9 +8243,9 @@ dependencies = [
 
 [[package]]
 name = "regex-automata"
-version = "0.4.8"
+version = "0.4.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "368758f23274712b504848e9d5a6f010445cc8b87a7cdb4d7cbee666c1288da3"
+checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -8095,14 +8301,15 @@ dependencies = [
 
 [[package]]
 name = "ring"
-version = "0.17.13"
+version = "0.17.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70ac5d832aa16abd7d1def883a8545280c20a60f523a370aa3a9617c2b8550ee"
+checksum = "c17fa4cb658e3583423e915b9f3acc01cceaee1860e33d59ebae66adc3a2dc0d"
 dependencies = [
  "cc",
  "cfg-if",
  "getrandom 0.2.15",
  "libc",
+ "spin 0.9.8",
  "untrusted 0.9.0",
  "windows-sys 0.52.0",
 ]
@@ -8167,16 +8374,19 @@ dependencies = [
 
 [[package]]
 name = "rtnetlink"
-version = "0.10.1"
+version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "322c53fd76a18698f1c27381d58091de3a043d356aa5bd0d510608b565f469a0"
+checksum = "7a552eb82d19f38c3beed3f786bd23aa434ceb9ac43ab44419ca6d67a7e186c0"
 dependencies = [
  "futures",
  "log",
+ "netlink-packet-core",
  "netlink-packet-route",
+ "netlink-packet-utils",
  "netlink-proto",
+ "netlink-sys",
  "nix",
- "thiserror",
+ "thiserror 1.0.69",
  "tokio",
 ]
 
@@ -8192,9 +8402,9 @@ dependencies = [
 
 [[package]]
 name = "ruint"
-version = "1.14.0"
+version = "1.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78a46eb779843b2c4f21fac5773e25d6d5b7c8f0922876c91541790d2ca27eef"
+checksum = "825df406ec217a8116bd7b06897c6cc8f65ffefc15d030ae2c9540acc9ed50b6"
 dependencies = [
  "alloy-rlp",
  "ark-ff 0.3.0",
@@ -8206,10 +8416,9 @@ dependencies = [
  "num-integer",
  "num-traits",
  "parity-scale-codec",
- "primitive-types",
+ "primitive-types 0.12.2",
  "proptest",
- "rand 0.8.5",
- "rand 0.9.0",
+ "rand",
  "rlp",
  "ruint-macro",
  "serde",
@@ -8237,9 +8446,9 @@ checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 
 [[package]]
 name = "rustc-hash"
-version = "2.1.1"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
+checksum = "c7fb8039b3032c191086b10f11f319a6e99e1e82889c5cc6046f515c9db1d497"
 
 [[package]]
 name = "rustc-hex"
@@ -8271,7 +8480,7 @@ version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
 dependencies = [
- "semver 1.0.23",
+ "semver 1.0.25",
 ]
 
 [[package]]
@@ -8299,15 +8508,15 @@ dependencies = [
 
 [[package]]
 name = "rustix"
-version = "0.38.37"
+version = "0.38.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8acb788b847c24f28525660c4d7758620a7210875711f79e7f663cc152726811"
+checksum = "fdb5bc1ae2baa591800df16c9ca78619bf65c0488b41b96ccec5d11220d8c154"
 dependencies = [
- "bitflags 2.6.0",
+ "bitflags 2.8.0",
  "errno",
  "libc",
- "linux-raw-sys 0.4.14",
- "windows-sys 0.52.0",
+ "linux-raw-sys 0.4.15",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -8328,7 +8537,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3f56a14d1f48b391359b22f731fd4bd7e43c97f3c50eee276f3aa09c94784d3e"
 dependencies = [
  "log",
- "ring 0.17.13",
+ "ring 0.17.8",
  "rustls-webpki",
  "sct",
 ]
@@ -8360,15 +8569,15 @@ version = "0.101.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8b6275d1ee7a1cd780b64aca7726599a1dbc893b1e64144529e55c3c2f745765"
 dependencies = [
- "ring 0.17.13",
+ "ring 0.17.8",
  "untrusted 0.9.0",
 ]
 
 [[package]]
 name = "rustversion"
-version = "1.0.17"
+version = "1.0.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "955d28af4278de8121b7ebeb796b6a45735dc01436d898801014aced2773a3d6"
+checksum = "f7c45b9784283f1b2e7fb61b42047c2fd678ef0960d4f6f1eba131594cc369d4"
 
 [[package]]
 name = "rusty-fork"
@@ -8395,9 +8604,9 @@ dependencies = [
 
 [[package]]
 name = "ryu"
-version = "1.0.18"
+version = "1.0.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
+checksum = "6ea1a2d0a644769cc99faa24c3ad26b379b786fe7c36fd3c546254801650e6dd"
 
 [[package]]
 name = "safe-math"
@@ -8420,9 +8629,9 @@ dependencies = [
 
 [[package]]
 name = "safe_arch"
-version = "0.7.2"
+version = "0.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3460605018fdc9612bce72735cba0d27efbcd9904780d44c7e3a9948f96148a"
+checksum = "96b02de82ddbe1b636e6170c21be622223aea188ef2e139be0a5b219ec215323"
 dependencies = [
  "bytemuck",
 ]
@@ -8444,7 +8653,7 @@ dependencies = [
  "log",
  "sp-core",
  "sp-wasm-interface 21.0.1",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
@@ -8519,7 +8728,7 @@ dependencies = [
  "proc-macro-crate 3.2.0",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -8538,7 +8747,7 @@ dependencies = [
  "names",
  "parity-bip39",
  "parity-scale-codec",
- "rand 0.8.5",
+ "rand",
  "regex",
  "rpassword",
  "sc-client-api",
@@ -8559,7 +8768,7 @@ dependencies = [
  "sp-panic-handler",
  "sp-runtime",
  "sp-version",
- "thiserror",
+ "thiserror 1.0.69",
  "tokio",
 ]
 
@@ -8637,7 +8846,7 @@ dependencies = [
  "sp-runtime",
  "sp-state-machine",
  "substrate-prometheus-endpoint",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
@@ -8666,7 +8875,7 @@ dependencies = [
  "sp-keystore",
  "sp-runtime",
  "substrate-prometheus-endpoint",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
@@ -8702,7 +8911,7 @@ dependencies = [
  "sp-keystore",
  "sp-runtime",
  "substrate-prometheus-endpoint",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
@@ -8734,7 +8943,7 @@ dependencies = [
  "log",
  "parity-scale-codec",
  "parking_lot 0.12.3",
- "rand 0.8.5",
+ "rand",
  "sc-block-builder",
  "sc-chain-spec",
  "sc-client-api",
@@ -8759,7 +8968,7 @@ dependencies = [
  "sp-keystore",
  "sp-runtime",
  "substrate-prometheus-endpoint",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
@@ -8779,7 +8988,7 @@ dependencies = [
  "sp-blockchain",
  "sp-core",
  "sp-runtime",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
@@ -8814,7 +9023,7 @@ dependencies = [
  "sp-runtime",
  "sp-timestamp",
  "substrate-prometheus-endpoint",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
@@ -8872,7 +9081,7 @@ dependencies = [
  "sc-allocator",
  "sp-maybe-compressed-blob",
  "sp-wasm-interface 21.0.1",
- "thiserror",
+ "thiserror 1.0.69",
  "wasm-instrument",
 ]
 
@@ -8933,7 +9142,7 @@ dependencies = [
  "sp-application-crypto",
  "sp-core",
  "sp-keystore",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
@@ -8962,7 +9171,7 @@ dependencies = [
  "sp-keystore",
  "sp-mixnet",
  "sp-runtime",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
@@ -8993,7 +9202,7 @@ dependencies = [
  "pin-project",
  "prost 0.12.6",
  "prost-build 0.12.6",
- "rand 0.8.5",
+ "rand",
  "sc-client-api",
  "sc-network-common",
  "sc-network-types",
@@ -9007,7 +9216,7 @@ dependencies = [
  "sp-core",
  "sp-runtime",
  "substrate-prometheus-endpoint",
- "thiserror",
+ "thiserror 1.0.69",
  "tokio",
  "tokio-stream",
  "unsigned-varint 0.7.2",
@@ -9071,7 +9280,7 @@ dependencies = [
  "sp-blockchain",
  "sp-core",
  "sp-runtime",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
@@ -9106,7 +9315,7 @@ dependencies = [
  "sp-core",
  "sp-runtime",
  "substrate-prometheus-endpoint",
- "thiserror",
+ "thiserror 1.0.69",
  "tokio",
  "tokio-stream",
 ]
@@ -9141,9 +9350,9 @@ dependencies = [
  "litep2p",
  "log",
  "multiaddr 0.18.2",
- "multihash 0.19.2",
- "rand 0.8.5",
- "thiserror",
+ "multihash 0.19.3",
+ "rand",
+ "thiserror 1.0.69",
  "zeroize",
 ]
 
@@ -9157,14 +9366,14 @@ dependencies = [
  "fnv",
  "futures",
  "futures-timer",
- "hyper 0.14.30",
+ "hyper 0.14.32",
  "hyper-rustls",
  "log",
  "num_cpus",
  "once_cell",
  "parity-scale-codec",
  "parking_lot 0.12.3",
- "rand 0.8.5",
+ "rand",
  "sc-client-api",
  "sc-network",
  "sc-network-common",
@@ -9239,7 +9448,7 @@ dependencies = [
  "sp-rpc",
  "sp-runtime",
  "sp-version",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
@@ -9251,9 +9460,9 @@ dependencies = [
  "forwarded-header-value",
  "futures",
  "governor",
- "http 1.1.0",
+ "http 1.2.0",
  "http-body-util",
- "hyper 1.5.0",
+ "hyper 1.6.0",
  "ip_network",
  "jsonrpsee",
  "log",
@@ -9279,7 +9488,7 @@ dependencies = [
  "log",
  "parity-scale-codec",
  "parking_lot 0.12.3",
- "rand 0.8.5",
+ "rand",
  "sc-chain-spec",
  "sc-client-api",
  "sc-rpc",
@@ -9293,7 +9502,7 @@ dependencies = [
  "sp-rpc",
  "sp-runtime",
  "sp-version",
- "thiserror",
+ "thiserror 1.0.69",
  "tokio",
  "tokio-stream",
 ]
@@ -9313,7 +9522,7 @@ dependencies = [
  "parity-scale-codec",
  "parking_lot 0.12.3",
  "pin-project",
- "rand 0.8.5",
+ "rand",
  "sc-chain-spec",
  "sc-client-api",
  "sc-client-db",
@@ -9356,7 +9565,7 @@ dependencies = [
  "static_init",
  "substrate-prometheus-endpoint",
  "tempfile",
- "thiserror",
+ "thiserror 1.0.69",
  "tokio",
  "tracing",
  "tracing-futures",
@@ -9382,7 +9591,7 @@ dependencies = [
  "futures",
  "libc",
  "log",
- "rand 0.8.5",
+ "rand",
  "rand_pcg",
  "regex",
  "sc-telemetry",
@@ -9405,12 +9614,12 @@ dependencies = [
  "log",
  "parking_lot 0.12.3",
  "pin-project",
- "rand 0.8.5",
+ "rand",
  "sc-network",
  "sc-utils",
  "serde",
  "serde_json",
- "thiserror",
+ "thiserror 1.0.69",
  "wasm-timer",
 ]
 
@@ -9437,10 +9646,10 @@ dependencies = [
  "sp-rpc",
  "sp-runtime",
  "sp-tracing 17.0.1",
- "thiserror",
+ "thiserror 1.0.69",
  "tracing",
  "tracing-log",
- "tracing-subscriber 0.3.18",
+ "tracing-subscriber 0.3.19",
 ]
 
 [[package]]
@@ -9451,7 +9660,7 @@ dependencies = [
  "proc-macro-crate 3.2.0",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -9478,7 +9687,7 @@ dependencies = [
  "sp-tracing 17.0.1",
  "sp-transaction-pool",
  "substrate-prometheus-endpoint",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
@@ -9494,7 +9703,7 @@ dependencies = [
  "sp-blockchain",
  "sp-core",
  "sp-runtime",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
@@ -9537,13 +9746,13 @@ dependencies = [
 
 [[package]]
 name = "scale-info"
-version = "2.11.3"
+version = "2.11.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eca070c12893629e2cc820a9761bedf6ce1dcddc9852984d1dc734b8bd9bd024"
+checksum = "346a3b32eba2640d17a9cb5927056b08f3de90f65b72fe09402c2ad07d684d0b"
 dependencies = [
  "bitvec",
  "cfg-if",
- "derive_more 0.99.18",
+ "derive_more 1.0.0",
  "parity-scale-codec",
  "scale-info-derive",
  "serde",
@@ -9551,14 +9760,14 @@ dependencies = [
 
 [[package]]
 name = "scale-info-derive"
-version = "2.11.3"
+version = "2.11.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2d35494501194174bda522a32605929eefc9ecf7e0a326c26db1fdd85881eb62"
+checksum = "c6630024bf739e2179b91fb424b28898baf819414262c5d376677dbff1fe7ebf"
 dependencies = [
  "proc-macro-crate 3.2.0",
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -9569,18 +9778,18 @@ checksum = "f0cded6518aa0bd6c1be2b88ac81bf7044992f0f154bfbabd5ad34f43512abcb"
 
 [[package]]
 name = "schannel"
-version = "0.1.24"
+version = "0.1.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e9aaafd5a2b6e3d657ff009d82fbd630b6bd54dd4eb06f21693925cdf80f9b8b"
+checksum = "1f29ebaa345f945cec9fbbc532eb307f0fdad8161f281b6369539c8d84876b3d"
 dependencies = [
  "windows-sys 0.59.0",
 ]
 
 [[package]]
 name = "schnellru"
-version = "0.2.3"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c9a8ef13a93c54d20580de1e5c413e624e53121d42fc7e2c11d10ef7f8b02367"
+checksum = "356285bbf17bea63d9e52e96bd18f039672ac92b55b8cb997d6162a2a37d1649"
 dependencies = [
  "ahash 0.8.11",
  "cfg-if",
@@ -9599,7 +9808,7 @@ dependencies = [
  "curve25519-dalek",
  "getrandom_or_panic",
  "merlin",
- "rand_core 0.6.4",
+ "rand_core",
  "serde_bytes",
  "sha2 0.10.8",
  "subtle 2.6.1",
@@ -9624,7 +9833,7 @@ version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "da046153aa2352493d6cb7da4b6e5c0c057d8a1d0a9aa8560baffdd945acd414"
 dependencies = [
- "ring 0.17.13",
+ "ring 0.17.8",
  "untrusted 0.9.0",
 ]
 
@@ -9638,9 +9847,9 @@ dependencies = [
  "crc",
  "fxhash",
  "log",
- "rand 0.8.5",
+ "rand",
  "slab",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
@@ -9691,7 +9900,7 @@ version = "2.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02"
 dependencies = [
- "bitflags 2.6.0",
+ "bitflags 2.8.0",
  "core-foundation",
  "core-foundation-sys",
  "libc",
@@ -9700,9 +9909,9 @@ dependencies = [
 
 [[package]]
 name = "security-framework-sys"
-version = "2.12.0"
+version = "2.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ea4a292869320c0272d7bc55a5a6aafaff59b4f63404a003887b679a2e05b4b6"
+checksum = "49db231d56a190491cb4aeda9527f1ad45345af50b0851622a7adb8c03b01c32"
 dependencies = [
  "core-foundation-sys",
  "libc",
@@ -9737,9 +9946,9 @@ dependencies = [
 
 [[package]]
 name = "semver"
-version = "1.0.23"
+version = "1.0.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61697e0a1c7e512e84a621326239844a24d8207b4669b41bc18b32ea5cbf988b"
+checksum = "f79dfe2d285b0488816f30e700a7438c5a73d816b5b7d3ac72fbc48b0d185e03"
 dependencies = [
  "serde",
 ]
@@ -9767,9 +9976,9 @@ checksum = "cd0b0ec5f1c1ca621c432a25813d8d60c88abe6d3e08a3eb9cf37d97a0fe3d73"
 
 [[package]]
 name = "serde"
-version = "1.0.216"
+version = "1.0.217"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b9781016e935a97e8beecf0c933758c97a5520d32930e460142b4cd80c6338e"
+checksum = "02fc4265df13d6fa1d00ecff087228cc0a2b5f3c0e87e258d8b94a156e984c70"
 dependencies = [
  "serde_derive",
 ]
@@ -9804,20 +10013,20 @@ dependencies = [
 
 [[package]]
 name = "serde_derive"
-version = "1.0.216"
+version = "1.0.217"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46f859dbbf73865c6627ed570e78961cd3ac92407a2d117204c49232485da55e"
+checksum = "5a9bf7cf98d04a2b28aead066b7496853d4779c9cc183c440dbac457641e19a0"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
 name = "serde_json"
-version = "1.0.128"
+version = "1.0.138"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ff5456707a1de34e7e37f2a6fd3d3f808c318259cbd01ab6377795054b483d8"
+checksum = "d434192e7da787e94a6ea7e9670b26a036d0ca41e0b7efb2676dd32bae872949"
 dependencies = [
  "itoa",
  "memchr",
@@ -9871,7 +10080,7 @@ dependencies = [
  "darling",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -10000,14 +10209,14 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
 dependencies = [
  "digest 0.10.7",
- "rand_core 0.6.4",
+ "rand_core",
 ]
 
 [[package]]
 name = "simba"
-version = "0.8.1"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "061507c94fc6ab4ba1c9a0305018408e312e17c041eb63bef8aa726fa33aceae"
+checksum = "b3a386a501cd104797982c15ae17aafe8b9261315b5d07e3ec803f2ea26be0fa"
 dependencies = [
  "approx",
  "num-complex",
@@ -10022,7 +10231,7 @@ version = "0.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cae9a3fcdadafb6d97f4c0e007e4247b114ee0f119f650c3cbf3a8b3a1479694"
 dependencies = [
- "bitflags 2.6.0",
+ "bitflags 2.8.0",
 ]
 
 [[package]]
@@ -10074,8 +10283,8 @@ dependencies = [
  "blake2 0.10.6",
  "chacha20poly1305",
  "curve25519-dalek",
- "rand_core 0.6.4",
- "ring 0.17.13",
+ "rand_core",
+ "ring 0.17.8",
  "rustc_version 0.4.1",
  "sha2 0.10.8",
  "subtle 2.6.1",
@@ -10093,9 +10302,9 @@ dependencies = [
 
 [[package]]
 name = "socket2"
-version = "0.5.7"
+version = "0.5.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce305eb0b4296696835b71df73eb912e0f1ffd2556a501fcede6e0c50349191c"
+checksum = "c970269d99b64e60ec3bd6ad27270092a5394c4e309314b18ae3fe575695fbe8"
 dependencies = [
  "libc",
  "windows-sys 0.52.0",
@@ -10103,17 +10312,17 @@ dependencies = [
 
 [[package]]
 name = "soketto"
-version = "0.8.0"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37468c595637c10857701c990f93a40ce0e357cedb0953d1c26c8d8027f9bb53"
+checksum = "2e859df029d160cb88608f5d7df7fb4753fd20fdfb4de5644f3d8b8440841721"
 dependencies = [
  "base64 0.22.1",
  "bytes",
  "futures",
- "http 1.1.0",
+ "http 1.2.0",
  "httparse",
  "log",
- "rand 0.8.5",
+ "rand",
  "sha1",
 ]
 
@@ -10136,7 +10345,7 @@ dependencies = [
  "sp-state-machine",
  "sp-trie",
  "sp-version",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
@@ -10150,7 +10359,7 @@ dependencies = [
  "proc-macro-crate 3.2.0",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -10213,7 +10422,7 @@ dependencies = [
  "sp-database",
  "sp-runtime",
  "sp-state-machine",
- "thiserror",
+ "thiserror 1.0.69",
  "tracing",
 ]
 
@@ -10229,7 +10438,7 @@ dependencies = [
  "sp-inherents",
  "sp-runtime",
  "sp-state-machine",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
@@ -10309,7 +10518,7 @@ dependencies = [
  "futures",
  "hash-db",
  "hash256-std-hasher",
- "impl-serde",
+ "impl-serde 0.4.0",
  "itertools 0.11.0",
  "k256",
  "libsecp256k1",
@@ -10319,8 +10528,8 @@ dependencies = [
  "parity-scale-codec",
  "parking_lot 0.12.3",
  "paste",
- "primitive-types",
- "rand 0.8.5",
+ "primitive-types 0.12.2",
+ "rand",
  "scale-info",
  "schnorrkel",
  "secp256k1",
@@ -10334,7 +10543,7 @@ dependencies = [
  "sp-storage 21.0.0",
  "ss58-registry",
  "substrate-bip39",
- "thiserror",
+ "thiserror 1.0.69",
  "tracing",
  "w3f-bls",
  "zeroize",
@@ -10343,7 +10552,7 @@ dependencies = [
 [[package]]
 name = "sp-crypto-ec-utils"
 version = "0.10.0"
-source = "git+https://github.com/paritytech/polkadot-sdk#8614dc0e055d06de4a3774ac1da0a422b33f34e2"
+source = "git+https://github.com/paritytech/polkadot-sdk#80e30ec3cdccae8e9099bd67840ff8737b043496"
 dependencies = [
  "ark-bls12-377",
  "ark-bls12-377-ext",
@@ -10414,7 +10623,7 @@ source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable
 dependencies = [
  "quote",
  "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409)",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -10433,23 +10642,23 @@ source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
 name = "sp-debug-derive"
 version = "14.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk#8614dc0e055d06de4a3774ac1da0a422b33f34e2"
+source = "git+https://github.com/paritytech/polkadot-sdk#80e30ec3cdccae8e9099bd67840ff8737b043496"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
 name = "sp-externalities"
 version = "0.25.0"
-source = "git+https://github.com/paritytech/polkadot-sdk#8614dc0e055d06de4a3774ac1da0a422b33f34e2"
+source = "git+https://github.com/paritytech/polkadot-sdk#80e30ec3cdccae8e9099bd67840ff8737b043496"
 dependencies = [
  "environmental",
  "parity-scale-codec",
@@ -10488,7 +10697,7 @@ dependencies = [
  "parity-scale-codec",
  "scale-info",
  "sp-runtime",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
@@ -10502,7 +10711,7 @@ dependencies = [
  "libsecp256k1",
  "log",
  "parity-scale-codec",
- "polkavm-derive",
+ "polkavm-derive 0.9.1",
  "rustversion",
  "secp256k1",
  "sp-core",
@@ -10543,7 +10752,7 @@ name = "sp-maybe-compressed-blob"
 version = "11.0.0"
 source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409#87971b3e92721bdf10bf40b410eaae779d494ca0"
 dependencies = [
- "thiserror",
+ "thiserror 1.0.69",
  "zstd 0.12.4",
 ]
 
@@ -10611,7 +10820,7 @@ dependencies = [
  "num-traits",
  "parity-scale-codec",
  "paste",
- "rand 0.8.5",
+ "rand",
  "scale-info",
  "serde",
  "simple-mermaid",
@@ -10627,13 +10836,13 @@ dependencies = [
 [[package]]
 name = "sp-runtime-interface"
 version = "24.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk#8614dc0e055d06de4a3774ac1da0a422b33f34e2"
+source = "git+https://github.com/paritytech/polkadot-sdk#80e30ec3cdccae8e9099bd67840ff8737b043496"
 dependencies = [
  "bytes",
  "impl-trait-for-tuples",
  "parity-scale-codec",
- "polkavm-derive",
- "primitive-types",
+ "polkavm-derive 0.18.0",
+ "primitive-types 0.13.1",
  "sp-externalities 0.25.0",
  "sp-runtime-interface-proc-macro 17.0.0",
  "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk)",
@@ -10651,8 +10860,8 @@ dependencies = [
  "bytes",
  "impl-trait-for-tuples",
  "parity-scale-codec",
- "polkavm-derive",
- "primitive-types",
+ "polkavm-derive 0.9.1",
+ "primitive-types 0.12.2",
  "sp-externalities 0.29.0",
  "sp-runtime-interface-proc-macro 18.0.0",
  "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409)",
@@ -10665,14 +10874,14 @@ dependencies = [
 [[package]]
 name = "sp-runtime-interface-proc-macro"
 version = "17.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk#8614dc0e055d06de4a3774ac1da0a422b33f34e2"
+source = "git+https://github.com/paritytech/polkadot-sdk#80e30ec3cdccae8e9099bd67840ff8737b043496"
 dependencies = [
  "Inflector",
  "expander",
  "proc-macro-crate 3.2.0",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -10685,7 +10894,7 @@ dependencies = [
  "proc-macro-crate 3.2.0",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -10724,13 +10933,13 @@ dependencies = [
  "log",
  "parity-scale-codec",
  "parking_lot 0.12.3",
- "rand 0.8.5",
+ "rand",
  "smallvec",
  "sp-core",
  "sp-externalities 0.29.0",
  "sp-panic-handler",
  "sp-trie",
- "thiserror",
+ "thiserror 1.0.69",
  "tracing",
  "trie-db",
 ]
@@ -10745,7 +10954,7 @@ dependencies = [
  "ed25519-dalek",
  "hkdf",
  "parity-scale-codec",
- "rand 0.8.5",
+ "rand",
  "scale-info",
  "sha2 0.10.8",
  "sp-api",
@@ -10755,7 +10964,7 @@ dependencies = [
  "sp-externalities 0.29.0",
  "sp-runtime",
  "sp-runtime-interface 28.0.0",
- "thiserror",
+ "thiserror 1.0.69",
  "x25519-dalek",
 ]
 
@@ -10767,14 +10976,14 @@ source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable
 [[package]]
 name = "sp-std"
 version = "14.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk#8614dc0e055d06de4a3774ac1da0a422b33f34e2"
+source = "git+https://github.com/paritytech/polkadot-sdk#80e30ec3cdccae8e9099bd67840ff8737b043496"
 
 [[package]]
 name = "sp-storage"
 version = "19.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk#8614dc0e055d06de4a3774ac1da0a422b33f34e2"
+source = "git+https://github.com/paritytech/polkadot-sdk#80e30ec3cdccae8e9099bd67840ff8737b043496"
 dependencies = [
- "impl-serde",
+ "impl-serde 0.5.0",
  "parity-scale-codec",
  "ref-cast",
  "serde",
@@ -10786,7 +10995,7 @@ name = "sp-storage"
 version = "21.0.0"
 source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409#87971b3e92721bdf10bf40b410eaae779d494ca0"
 dependencies = [
- "impl-serde",
+ "impl-serde 0.4.0",
  "parity-scale-codec",
  "ref-cast",
  "serde",
@@ -10802,18 +11011,18 @@ dependencies = [
  "parity-scale-codec",
  "sp-inherents",
  "sp-runtime",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
 name = "sp-tracing"
 version = "16.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk#8614dc0e055d06de4a3774ac1da0a422b33f34e2"
+source = "git+https://github.com/paritytech/polkadot-sdk#80e30ec3cdccae8e9099bd67840ff8737b043496"
 dependencies = [
  "parity-scale-codec",
  "tracing",
  "tracing-core",
- "tracing-subscriber 0.3.18",
+ "tracing-subscriber 0.3.19",
 ]
 
 [[package]]
@@ -10824,7 +11033,7 @@ dependencies = [
  "parity-scale-codec",
  "tracing",
  "tracing-core",
- "tracing-subscriber 0.3.18",
+ "tracing-subscriber 0.3.19",
 ]
 
 [[package]]
@@ -10862,12 +11071,12 @@ dependencies = [
  "nohash-hasher",
  "parity-scale-codec",
  "parking_lot 0.12.3",
- "rand 0.8.5",
+ "rand",
  "scale-info",
  "schnellru",
  "sp-core",
  "sp-externalities 0.29.0",
- "thiserror",
+ "thiserror 1.0.69",
  "tracing",
  "trie-db",
  "trie-root",
@@ -10878,7 +11087,7 @@ name = "sp-version"
 version = "37.0.0"
 source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409#87971b3e92721bdf10bf40b410eaae779d494ca0"
 dependencies = [
- "impl-serde",
+ "impl-serde 0.4.0",
  "parity-scale-codec",
  "parity-wasm",
  "scale-info",
@@ -10887,7 +11096,7 @@ dependencies = [
  "sp-runtime",
  "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409)",
  "sp-version-proc-macro",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
@@ -10898,13 +11107,13 @@ dependencies = [
  "parity-scale-codec",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
 name = "sp-wasm-interface"
 version = "20.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk#8614dc0e055d06de4a3774ac1da0a422b33f34e2"
+source = "git+https://github.com/paritytech/polkadot-sdk#80e30ec3cdccae8e9099bd67840ff8737b043496"
 dependencies = [
  "anyhow",
  "impl-trait-for-tuples",
@@ -10972,21 +11181,11 @@ dependencies = [
  "der",
 ]
 
-[[package]]
-name = "sqlformat"
-version = "0.2.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7bba3a93db0cc4f7bdece8bb09e77e2e785c20bfebf79eb8340ed80708048790"
-dependencies = [
- "nom",
- "unicode_categories",
-]
-
 [[package]]
 name = "sqlx"
-version = "0.8.2"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93334716a037193fac19df402f8571269c84a00852f6a7066b5d2616dcd64d3e"
+checksum = "4410e73b3c0d8442c5f99b425d7a435b5ee0ae4167b3196771dd3f7a01be745f"
 dependencies = [
  "sqlx-core",
  "sqlx-macros",
@@ -10995,37 +11194,31 @@ dependencies = [
 
 [[package]]
 name = "sqlx-core"
-version = "0.8.2"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4d8060b456358185f7d50c55d9b5066ad956956fddec42ee2e8567134a8936e"
+checksum = "6a007b6936676aa9ab40207cde35daab0a04b823be8ae004368c0793b96a61e0"
 dependencies = [
- "atoi",
- "byteorder",
  "bytes",
  "crc",
  "crossbeam-queue",
  "either",
- "event-listener 5.3.1",
- "futures-channel",
+ "event-listener 5.4.0",
  "futures-core",
  "futures-intrusive",
  "futures-io",
  "futures-util",
- "hashbrown 0.14.5",
- "hashlink 0.9.1",
- "hex",
- "indexmap 2.6.0",
+ "hashbrown 0.15.2",
+ "hashlink 0.10.0",
+ "indexmap 2.7.1",
  "log",
  "memchr",
  "native-tls",
  "once_cell",
- "paste",
  "percent-encoding",
  "serde",
  "sha2 0.10.8",
  "smallvec",
- "sqlformat",
- "thiserror",
+ "thiserror 2.0.11",
  "tokio",
  "tokio-stream",
  "tracing",
@@ -11034,22 +11227,22 @@ dependencies = [
 
 [[package]]
 name = "sqlx-macros"
-version = "0.8.2"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cac0692bcc9de3b073e8d747391827297e075c7710ff6276d9f7a1f3d58c6657"
+checksum = "3112e2ad78643fef903618d78cf0aec1cb3134b019730edb039b69eaf531f310"
 dependencies = [
  "proc-macro2",
  "quote",
  "sqlx-core",
  "sqlx-macros-core",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
 name = "sqlx-macros-core"
-version = "0.8.2"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1804e8a7c7865599c9c79be146dc8a9fd8cc86935fa641d3ea58e5f0688abaa5"
+checksum = "4e9f90acc5ab146a99bf5061a7eb4976b573f560bc898ef3bf8435448dd5e7ad"
 dependencies = [
  "dotenvy",
  "either",
@@ -11063,7 +11256,7 @@ dependencies = [
  "sha2 0.10.8",
  "sqlx-core",
  "sqlx-sqlite",
- "syn 2.0.90",
+ "syn 2.0.96",
  "tempfile",
  "tokio",
  "url",
@@ -11071,9 +11264,9 @@ dependencies = [
 
 [[package]]
 name = "sqlx-sqlite"
-version = "0.8.2"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d5b2cf34a45953bfd3daaf3db0f7a7878ab9b7a6b91b422d24a7a9e4c857b680"
+checksum = "f85ca71d3a5b24e64e1d08dd8fe36c6c95c339a896cc33068148906784620540"
 dependencies = [
  "atoi",
  "flume",
@@ -11094,9 +11287,9 @@ dependencies = [
 
 [[package]]
 name = "ss58-registry"
-version = "1.50.0"
+version = "1.51.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43fce22ed1df64d04b262351c8f9d5c6da4f76f79f25ad15529792f893fad25d"
+checksum = "19409f13998e55816d1c728395af0b52ec066206341d939e22e7766df9b494b8"
 dependencies = [
  "Inflector",
  "num-format",
@@ -11155,9 +11348,9 @@ dependencies = [
 
 [[package]]
 name = "static_init_macro"
-version = "1.0.2"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70a2595fc3aa78f2d0e45dd425b22282dd863273761cc77780914b2cf3003acf"
+checksum = "1389c88ddd739ec6d3f8f83343764a0e944cd23cfbf126a9796a714b0b6edd6f"
 dependencies = [
  "cfg_aliases",
  "memchr",
@@ -11182,7 +11375,7 @@ dependencies = [
  "sctp-proto",
  "serde",
  "sha-1",
- "thiserror",
+ "thiserror 1.0.69",
  "tracing",
 ]
 
@@ -11230,7 +11423,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "rustversion",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -11287,11 +11480,11 @@ version = "0.17.0"
 source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409#87971b3e92721bdf10bf40b410eaae779d494ca0"
 dependencies = [
  "http-body-util",
- "hyper 1.5.0",
+ "hyper 1.6.0",
  "hyper-util",
  "log",
  "prometheus",
- "thiserror",
+ "thiserror 1.0.69",
  "tokio",
 ]
 
@@ -11334,7 +11527,7 @@ dependencies = [
  "quote",
  "rayon",
  "subtensor-linting",
- "syn 2.0.90",
+ "syn 2.0.96",
  "walkdir",
 ]
 
@@ -11372,7 +11565,7 @@ dependencies = [
  "proc-macro2",
  "procedural-fork",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -11382,7 +11575,7 @@ dependencies = [
  "ahash 0.8.11",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -11436,7 +11629,7 @@ version = "0.1.0"
 dependencies = [
  "anyhow",
  "clap",
- "semver 1.0.23",
+ "semver 1.0.25",
  "toml_edit",
 ]
 
@@ -11465,9 +11658,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.90"
+version = "2.0.96"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "919d3b74a5dd0ccd15aeb8f93e7006bd9e14c295087c9896a110f490752bcf31"
+checksum = "d5d0adab1ae378d7f53bdebc67a39f1f151407ef230f0ce2883572f5d8985c80"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -11494,25 +11687,25 @@ checksum = "c8af7666ab7b6390ab78131fb5b0fce11d6b7a6951602017c35fa82800708971"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
 name = "system-configuration"
-version = "0.5.1"
+version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba3a3adc5c275d719af8cb4272ea1c4a6d668a777f37e115f6d11ddbc1c8e0e7"
+checksum = "3c879d448e9d986b661742763247d3693ed13609438cf3d006f51f5368a5ba6b"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags 2.8.0",
  "core-foundation",
  "system-configuration-sys",
 ]
 
 [[package]]
 name = "system-configuration-sys"
-version = "0.5.0"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a75fb188eb626b924683e3b95e3a48e63551fcfb51949de2f06a9d91dbee93c9"
+checksum = "8e1d1b10ced5ca923a1fcb8d03e96b8d3268065d724548c0211415ff6ac6bac4"
 dependencies = [
  "core-foundation-sys",
  "libc",
@@ -11532,14 +11725,15 @@ checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
 
 [[package]]
 name = "tempfile"
-version = "3.13.0"
+version = "3.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0f2c9fc62d0beef6951ccffd757e241266a2c833136efbe35af6cd2567dca5b"
+checksum = "38c246215d7d24f48ae091a2902398798e05d978b24315d6efbc00ede9a8bb91"
 dependencies = [
  "cfg-if",
  "fastrand",
+ "getrandom 0.3.1",
  "once_cell",
- "rustix 0.38.37",
+ "rustix 0.38.44",
  "windows-sys 0.59.0",
 ]
 
@@ -11554,38 +11748,58 @@ dependencies = [
 
 [[package]]
 name = "terminal_size"
-version = "0.4.0"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4f599bd7ca042cfdf8f4512b277c02ba102247820f9d9d4a9f521f496751a6ef"
+checksum = "5352447f921fda68cf61b4101566c0bdb5104eff6804d0678e5227580ab6a4e9"
 dependencies = [
- "rustix 0.38.37",
+ "rustix 0.38.44",
  "windows-sys 0.59.0",
 ]
 
 [[package]]
 name = "termtree"
-version = "0.4.1"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f50febec83f5ee1df3015341d8bd429f2d1cc62bcba7ea2076759d315084683"
+
+[[package]]
+name = "thiserror"
+version = "1.0.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3369f5ac52d5eb6ab48c6b4ffdc8efbcad6b89c765749064ba298f2c68a16a76"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
+dependencies = [
+ "thiserror-impl 1.0.69",
+]
 
 [[package]]
 name = "thiserror"
-version = "1.0.64"
+version = "2.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d452f284b73e6d76dd36758a0c8684b1d5be31f92b89d07fd5822175732206fc"
+dependencies = [
+ "thiserror-impl 2.0.11",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d50af8abc119fb8bb6dbabcfa89656f46f84aa0ac7688088608076ad2b459a84"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
 dependencies = [
- "thiserror-impl",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.96",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.64"
+version = "2.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08904e7672f5eb876eaaf87e0ce17857500934f4981c4a0ab2b4aa98baac7fc3"
+checksum = "26afc1baea8a989337eeb52b6e72a039780ce45c3edfcc9c5b9d112feeb173c2"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -11625,9 +11839,9 @@ dependencies = [
 
 [[package]]
 name = "time"
-version = "0.3.36"
+version = "0.3.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5dfd88e563464686c916c7e46e623e520ddc6d79fa6641390f2e3fa86e83e885"
+checksum = "35e7868883861bd0e56d9ac6efcaaca0d6d5d82a2a7ec8209ff492c07cf37b21"
 dependencies = [
  "deranged",
  "itoa",
@@ -11646,9 +11860,9 @@ checksum = "ef927ca75afb808a4d64dd374f00a2adf8d0fcff8e7b184af886c3c87ec4a3f3"
 
 [[package]]
 name = "time-macros"
-version = "0.2.18"
+version = "0.2.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f252a68540fde3a3877aeea552b832b40ab9a69e318efd078774a01ddee1ccf"
+checksum = "2834e6017e3e5e4b9834939793b282bc03b37a3336245fa820e35e233e2a85de"
 dependencies = [
  "num-conv",
  "time-core",
@@ -11663,11 +11877,21 @@ dependencies = [
  "crunchy",
 ]
 
+[[package]]
+name = "tinystr"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9117f5d4db391c1cf6927e7bea3db74b9a1c1add8f7eda9ffd5364f40f57b82f"
+dependencies = [
+ "displaydoc",
+ "zerovec",
+]
+
 [[package]]
 name = "tinyvec"
-version = "1.8.0"
+version = "1.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "445e881f4f6d382d5f27c034e25eb92edd7c784ceab92a0937db7f2e9471b938"
+checksum = "022db8904dfa342efe721985167e9fcd16c29b226db4397ed752a761cfce81e8"
 dependencies = [
  "tinyvec_macros",
 ]
@@ -11695,8 +11919,8 @@ dependencies = [
  "chacha20poly1305",
  "generic-array 0.14.7",
  "parity-scale-codec",
- "rand_chacha 0.3.1",
- "rand_core 0.6.4",
+ "rand_chacha",
+ "rand_core",
  "scale-info",
  "serde",
  "serde_cbor",
@@ -11708,9 +11932,9 @@ dependencies = [
 
 [[package]]
 name = "tokio"
-version = "1.40.0"
+version = "1.43.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2b070231665d27ad9ec9b8df639893f46727666c6767db40317fbe920a5d998"
+checksum = "3d61fa4ffa3de412bfea335c6ecff681de2b609ba3c77ef3e00e521813a9ed9e"
 dependencies = [
  "backtrace",
  "bytes",
@@ -11719,20 +11943,20 @@ dependencies = [
  "parking_lot 0.12.3",
  "pin-project-lite",
  "signal-hook-registry",
- "socket2 0.5.7",
+ "socket2 0.5.8",
  "tokio-macros",
  "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "tokio-macros"
-version = "2.4.0"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "693d596312e88961bc67d7f1f97af8a70227d9f90c31bba5806eec004978d752"
+checksum = "6e06d43f1345a3bcd39f6a56dbb7dcab2ba47e68e8ac134855e7e2bdbaf8cab8"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
@@ -11747,9 +11971,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-stream"
-version = "0.1.16"
+version = "0.1.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4f4e6ce100d0eb49a2734f8c0812bcd324cf357d21810932c5df6b96ef2b86f1"
+checksum = "eca58d7bba4a75707817a2c44174253f9236b2d5fbd055602e9d5c07c139a047"
 dependencies = [
  "futures-core",
  "pin-project-lite",
@@ -11774,9 +11998,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-util"
-version = "0.7.12"
+version = "0.7.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61e7c3654c13bcd040d4a03abee2c75b1d14a37b423cf5a813ceae1cc903ec6a"
+checksum = "d7fcaa8d55a2bdd6b83ace262b016eca0d79ee02818c5c1bcdf0305114081078"
 dependencies = [
  "bytes",
  "futures-core",
@@ -11822,7 +12046,7 @@ version = "0.22.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4ae48d6208a266e853d946088ed816055e556cc6028c5e8e2b84d9fa5dd7c7f5"
 dependencies = [
- "indexmap 2.6.0",
+ "indexmap 2.7.1",
  "serde",
  "serde_spanned",
  "toml_datetime",
@@ -11850,9 +12074,9 @@ version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1e9cd434a998747dd2c4276bc96ee2e0c7a2eadf3cae88e52be55a05fa9053f5"
 dependencies = [
- "bitflags 2.6.0",
+ "bitflags 2.8.0",
  "bytes",
- "http 1.1.0",
+ "http 1.2.0",
  "http-body 1.0.1",
  "http-body-util",
  "pin-project-lite",
@@ -11874,9 +12098,9 @@ checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3"
 
 [[package]]
 name = "tracing"
-version = "0.1.40"
+version = "0.1.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3523ab5a71916ccf420eebdf5521fcef02141234bbc0b8a49f2fdc4544364ef"
+checksum = "784e0ac535deb450455cbfa28a6f0df145ea1bb7ae51b821cf5e7927fdcfbdd0"
 dependencies = [
  "log",
  "pin-project-lite",
@@ -11886,20 +12110,20 @@ dependencies = [
 
 [[package]]
 name = "tracing-attributes"
-version = "0.1.27"
+version = "0.1.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"
+checksum = "395ae124c09f9e6918a2310af6038fba074bcf474ac352496d5910dd59a2226d"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
 name = "tracing-core"
-version = "0.1.32"
+version = "0.1.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c06d3da6113f116aaee68e4d601191614c9053067f9ab7f6edbcb161237daa54"
+checksum = "e672c95779cf947c5311f83787af4fa8fffd12fb27e4993211a84bdfd9610f9c"
 dependencies = [
  "once_cell",
  "valuable",
@@ -11937,9 +12161,9 @@ dependencies = [
 
 [[package]]
 name = "tracing-subscriber"
-version = "0.3.18"
+version = "0.3.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad0f048c97dbd9faa9b7df56362b8ebcaa52adb06b498c050d2f4e32f90a7a8b"
+checksum = "e8189decb5ac0fa7bc8b96b7cb9b2701d60d48805aca84a238004d665fcc4008"
 dependencies = [
  "matchers",
  "nu-ansi-term",
@@ -11992,10 +12216,10 @@ dependencies = [
  "idna 0.2.3",
  "ipnet",
  "lazy_static",
- "rand 0.8.5",
+ "rand",
  "smallvec",
  "socket2 0.4.10",
- "thiserror",
+ "thiserror 1.0.69",
  "tinyvec",
  "tokio",
  "tracing",
@@ -12018,9 +12242,9 @@ dependencies = [
  "idna 0.4.0",
  "ipnet",
  "once_cell",
- "rand 0.8.5",
+ "rand",
  "smallvec",
- "thiserror",
+ "thiserror 1.0.69",
  "tinyvec",
  "tokio",
  "tracing",
@@ -12039,10 +12263,10 @@ dependencies = [
  "lru-cache",
  "once_cell",
  "parking_lot 0.12.3",
- "rand 0.8.5",
+ "rand",
  "resolv-conf",
  "smallvec",
- "thiserror",
+ "thiserror 1.0.69",
  "tokio",
  "tracing",
  "trust-dns-proto 0.23.2",
@@ -12072,10 +12296,10 @@ dependencies = [
  "http 0.2.12",
  "httparse",
  "log",
- "rand 0.8.5",
+ "rand",
  "rustls 0.21.12",
  "sha1",
- "thiserror",
+ "thiserror 1.0.69",
  "url",
  "utf-8",
 ]
@@ -12088,7 +12312,7 @@ checksum = "97fee6b57c6a41524a810daee9286c02d7752c4253064d0b05472833a438f675"
 dependencies = [
  "cfg-if",
  "digest 0.10.7",
- "rand 0.8.5",
+ "rand",
  "static_assertions",
 ]
 
@@ -12125,6 +12349,18 @@ dependencies = [
  "static_assertions",
 ]
 
+[[package]]
+name = "uint"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "909988d098b2f738727b161a106cfc7cab00c539c2687a8836f8e565976fb53e"
+dependencies = [
+ "byteorder",
+ "crunchy",
+ "hex",
+ "static_assertions",
+]
+
 [[package]]
 name = "unarray"
 version = "0.1.4"
@@ -12133,15 +12369,15 @@ checksum = "eaea85b334db583fe3274d12b4cd1880032beab409c0d774be044d4480ab9a94"
 
 [[package]]
 name = "unicode-bidi"
-version = "0.3.17"
+version = "0.3.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ab17db44d7388991a428b2ee655ce0c212e862eff1768a455c58f9aad6e7893"
+checksum = "5c1cb5db39152898a79168971543b1cb5020dff7fe43c8dc468b0885f5e29df5"
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.13"
+version = "1.0.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe"
+checksum = "a210d160f08b701c8721ba1c726c11662f877ea6b7094007e1ca9a1041945034"
 
 [[package]]
 name = "unicode-normalization"
@@ -12159,16 +12395,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af"
 
 [[package]]
-name = "unicode-xid"
-version = "0.2.6"
+name = "unicode-width"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
+checksum = "1fc81956842c57dac11422a97c3b8195a1ff727f06e85c84ed2e8aa277c9a0fd"
 
 [[package]]
-name = "unicode_categories"
-version = "0.1.1"
+name = "unicode-xid"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "39ec24b3121d976906ece63c9daad25b85969647682eee313cb5779fdd69e14e"
+checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
 
 [[package]]
 name = "universal-hash"
@@ -12216,12 +12452,12 @@ checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
 
 [[package]]
 name = "url"
-version = "2.5.2"
+version = "2.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22784dbdf76fdde8af1aeda5622b546b422b6fc585325248a2bf9f5e41e94d6c"
+checksum = "32f8b686cadd1473f4bd0117a5d28d36b1ade384ea9b5069a1c40aefed7fda60"
 dependencies = [
  "form_urlencoded",
- "idna 0.5.0",
+ "idna 1.0.3",
  "percent-encoding",
 ]
 
@@ -12231,6 +12467,18 @@ version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9"
 
+[[package]]
+name = "utf16_iter"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8232dd3cdaed5356e0f716d285e4b40b932ac434100fe9b7e0e8e935b9e6246"
+
+[[package]]
+name = "utf8_iter"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
+
 [[package]]
 name = "utf8parse"
 version = "0.2.2"
@@ -12243,14 +12491,14 @@ version = "1.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "458f7a779bf54acc9f347480ac654f68407d3aab21269a6e3c9f922acd9e2da9"
 dependencies = [
- "getrandom 0.3.2",
+ "getrandom 0.3.1",
 ]
 
 [[package]]
 name = "valuable"
-version = "0.1.0"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d"
+checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65"
 
 [[package]]
 name = "vcpkg"
@@ -12285,12 +12533,12 @@ dependencies = [
  "arrayref",
  "constcat",
  "digest 0.10.7",
- "rand 0.8.5",
- "rand_chacha 0.3.1",
- "rand_core 0.6.4",
+ "rand",
+ "rand_chacha",
+ "rand_core",
  "sha2 0.10.8",
  "sha3",
- "thiserror",
+ "thiserror 1.0.69",
  "zeroize",
 ]
 
@@ -12330,56 +12578,57 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
 [[package]]
 name = "wasi"
-version = "0.14.2+wasi-0.2.4"
+version = "0.13.3+wasi-0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9683f9a5a998d873c0d21fcbe3c083009670149a8fab228644b8bd36b2c48cb3"
+checksum = "26816d2e1a4a36a2940b96c5296ce403917633dff8f3440e9b236ed6f6bacad2"
 dependencies = [
  "wit-bindgen-rt",
 ]
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.93"
+version = "0.2.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a82edfc16a6c469f5f44dc7b571814045d60404b55a0ee849f9bcfa2e63dd9b5"
+checksum = "1edc8929d7499fc4e8f0be2262a241556cfc54a0bea223790e71446f2aab1ef5"
 dependencies = [
  "cfg-if",
  "once_cell",
+ "rustversion",
  "wasm-bindgen-macro",
 ]
 
 [[package]]
 name = "wasm-bindgen-backend"
-version = "0.2.93"
+version = "0.2.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9de396da306523044d3302746f1208fa71d7532227f15e347e2d93e4145dd77b"
+checksum = "2f0a0651a5c2bc21487bde11ee802ccaf4c51935d0d3d42a6101f98161700bc6"
 dependencies = [
  "bumpalo",
  "log",
- "once_cell",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-futures"
-version = "0.4.43"
+version = "0.4.50"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61e9300f63a621e96ed275155c108eb6f843b6a26d053f122ab69724559dc8ed"
+checksum = "555d470ec0bc3bb57890405e5d4322cc9ea83cebb085523ced7be4144dac1e61"
 dependencies = [
  "cfg-if",
  "js-sys",
+ "once_cell",
  "wasm-bindgen",
  "web-sys",
 ]
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.93"
+version = "0.2.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "585c4c91a46b072c92e908d99cb1dcdf95c5218eeb6f3bf1efa991ee7a68cccf"
+checksum = "7fe63fc6d09ed3792bd0897b314f53de8e16568c2b3f7982f468c0bf9bd0b407"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -12387,22 +12636,25 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.93"
+version = "0.2.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "afc340c74d9005395cf9dd098506f7f44e38f2b4a21c6aaacf9a105ea5e1e836"
+checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
  "wasm-bindgen-backend",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.93"
+version = "0.2.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c62a0a307cb4a311d3a07867860911ca130c3494e8c2719593806c08bc5d0484"
+checksum = "1a05d73b933a847d6cccdda8f838a22ff101ad9bf93e33684f39c1f5f0eece3d"
+dependencies = [
+ "unicode-ident",
+]
 
 [[package]]
 name = "wasm-instrument"
@@ -12424,7 +12676,7 @@ dependencies = [
  "strum 0.24.1",
  "strum_macros 0.24.3",
  "tempfile",
- "thiserror",
+ "thiserror 1.0.69",
  "wasm-opt-cxx-sys",
  "wasm-opt-sys",
 ]
@@ -12551,7 +12803,7 @@ dependencies = [
  "log",
  "object 0.30.4",
  "target-lexicon",
- "thiserror",
+ "thiserror 1.0.69",
  "wasmparser",
  "wasmtime-cranelift-shared",
  "wasmtime-environ",
@@ -12586,7 +12838,7 @@ dependencies = [
  "object 0.30.4",
  "serde",
  "target-lexicon",
- "thiserror",
+ "thiserror 1.0.69",
  "wasmparser",
  "wasmtime-types",
 ]
@@ -12653,7 +12905,7 @@ dependencies = [
  "memfd",
  "memoffset",
  "paste",
- "rand 0.8.5",
+ "rand",
  "rustix 0.36.17",
  "wasmtime-asm-macros",
  "wasmtime-environ",
@@ -12669,15 +12921,15 @@ checksum = "a4f6fffd2a1011887d57f07654dd112791e872e3ff4a2e626aee8059ee17f06f"
 dependencies = [
  "cranelift-entity",
  "serde",
- "thiserror",
+ "thiserror 1.0.69",
  "wasmparser",
 ]
 
 [[package]]
 name = "web-sys"
-version = "0.3.70"
+version = "0.3.77"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26fdeaafd9bd129f65e7c031593c24d62186301e0c72c8978fa1678be7d532c0"
+checksum = "33b6dd2ef9186f1f2072e409e99cd22a975331a6b3591b12c764e0e55c60d5d2"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
@@ -12689,7 +12941,7 @@ version = "0.22.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ed63aea5ce73d0ff405984102c42de94fc55a6b75765d621c65262469b3c9b53"
 dependencies = [
- "ring 0.17.13",
+ "ring 0.17.8",
  "untrusted 0.9.0",
 ]
 
@@ -12708,14 +12960,14 @@ dependencies = [
  "either",
  "home",
  "once_cell",
- "rustix 0.38.37",
+ "rustix 0.38.44",
 ]
 
 [[package]]
 name = "wide"
-version = "0.7.28"
+version = "0.7.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b828f995bf1e9622031f8009f8481a85406ce1f4d4588ff746d872043e855690"
+checksum = "41b5576b9a81633f3e8df296ce0063042a73507636cbe956c61133dd7034ab22"
 dependencies = [
  "bytemuck",
  "safe_arch",
@@ -12760,28 +13012,38 @@ checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
 [[package]]
 name = "windows"
-version = "0.51.1"
+version = "0.53.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca229916c5ee38c2f2bc1e9d8f04df975b4bd93f9955dc69fabb5d91270045c9"
+checksum = "efc5cf48f83140dcaab716eeaea345f9e93d0018fb81162753a3f76c3397b538"
 dependencies = [
- "windows-core 0.51.1",
- "windows-targets 0.48.5",
+ "windows-core 0.53.0",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
 name = "windows-core"
-version = "0.51.1"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1f8cf84f35d2db49a46868f947758c7a1138116f7fac3bc844f43ade1292e64"
+checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
 dependencies = [
- "windows-targets 0.48.5",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
 name = "windows-core"
-version = "0.52.0"
+version = "0.53.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
+checksum = "9dcc5b895a6377f1ab9fa55acedab1fd5ac0db66ad1e6c7f47e28a22e446a5dd"
+dependencies = [
+ "windows-result",
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-result"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e383302e8ec8515204254685643de10811af0ed97ea37210dc26fb0032647f8"
 dependencies = [
  "windows-targets 0.52.6",
 ]
@@ -13017,9 +13279,9 @@ checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 
 [[package]]
 name = "winnow"
-version = "0.6.20"
+version = "0.6.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "36c1fec1a2bb5866f07c25f68c26e565c4c200aebb96d7e55710c19d3e8ac49b"
+checksum = "ad699df48212c6cc6eb4435f35500ac6fd3b9913324f938aea302022ce19d310"
 dependencies = [
  "memchr",
 ]
@@ -13036,13 +13298,25 @@ dependencies = [
 
 [[package]]
 name = "wit-bindgen-rt"
-version = "0.39.0"
+version = "0.33.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f42320e61fe2cfd34354ecb597f86f413484a798ba44a8ca1165c58d42da6c1"
+checksum = "3268f3d866458b787f390cf61f4bbb563b922d091359f9608842999eaee3943c"
 dependencies = [
- "bitflags 2.6.0",
+ "bitflags 2.8.0",
 ]
 
+[[package]]
+name = "write16"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d1890f4022759daae28ed4fe62859b1236caebfc61ede2f63ed4e695f3f6d936"
+
+[[package]]
+name = "writeable"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e9df38ee2d2c3c5948ea468a8406ff0db0b29ae1ffde1bcf20ef305bcc95c51"
+
 [[package]]
 name = "wyz"
 version = "0.5.1"
@@ -13059,7 +13333,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c7e468321c81fb07fa7f4c636c3972b9100f0346e5b6a9f2bd0603a52f7ed277"
 dependencies = [
  "curve25519-dalek",
- "rand_core 0.6.4",
+ "rand_core",
  "serde",
  "zeroize",
 ]
@@ -13077,7 +13351,7 @@ dependencies = [
  "nom",
  "oid-registry 0.6.1",
  "rusticata-macros",
- "thiserror",
+ "thiserror 1.0.69",
  "time",
 ]
 
@@ -13094,7 +13368,7 @@ dependencies = [
  "nom",
  "oid-registry 0.7.1",
  "rusticata-macros",
- "thiserror",
+ "thiserror 1.0.69",
  "time",
 ]
 
@@ -13106,14 +13380,14 @@ dependencies = [
  "Inflector",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
 name = "xml-rs"
-version = "0.8.22"
+version = "0.8.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af4e2e2f7cba5a093896c1e150fbfe177d1883e7448200efb81d40b9d339ef26"
+checksum = "c5b940ebc25896e71dd073bad2dbaa2abfe97b0a391415e22ad1326d9c54e3c4"
 
 [[package]]
 name = "xmltree"
@@ -13135,7 +13409,7 @@ dependencies = [
  "nohash-hasher",
  "parking_lot 0.12.3",
  "pin-project",
- "rand 0.8.5",
+ "rand",
  "static_assertions",
 ]
 
@@ -13149,22 +13423,37 @@ dependencies = [
 ]
 
 [[package]]
-name = "zerocopy"
-version = "0.7.35"
+name = "yoke"
+version = "0.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
+checksum = "120e6aef9aa629e3d4f52dc8cc43a015c7724194c97dfaf45180d2daf2b77f40"
 dependencies = [
- "byteorder",
- "zerocopy-derive 0.7.35",
+ "serde",
+ "stable_deref_trait",
+ "yoke-derive",
+ "zerofrom",
+]
+
+[[package]]
+name = "yoke-derive"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2380878cad4ac9aac1e2435f3eb4020e8374b5f13c296cb75b4620ff8e229154"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.96",
+ "synstructure 0.13.1",
 ]
 
 [[package]]
 name = "zerocopy"
-version = "0.8.24"
+version = "0.7.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2586fea28e186957ef732a5f8b3be2da217d65c5969d4b1e17f973ebbe876879"
+checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
 dependencies = [
- "zerocopy-derive 0.8.24",
+ "byteorder",
+ "zerocopy-derive",
 ]
 
 [[package]]
@@ -13175,18 +13464,28 @@ checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
 
 [[package]]
-name = "zerocopy-derive"
-version = "0.8.24"
+name = "zerofrom"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cff3ee08c995dee1859d998dea82f7374f2826091dd9cd47def953cae446cd2e"
+dependencies = [
+ "zerofrom-derive",
+]
+
+[[package]]
+name = "zerofrom-derive"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a996a8f63c5c4448cd959ac1bab0aaa3306ccfd060472f85943ee0750f0169be"
+checksum = "595eed982f7d355beb85837f651fa22e90b3c044842dc7f2c2842c086f295808"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
+ "synstructure 0.13.1",
 ]
 
 [[package]]
@@ -13206,7 +13505,29 @@ checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
+]
+
+[[package]]
+name = "zerovec"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa2b893d79df23bfb12d5461018d408ea19dfafe76c2c7ef6d4eba614f8ff079"
+dependencies = [
+ "yoke",
+ "zerofrom",
+ "zerovec-derive",
+]
+
+[[package]]
+name = "zerovec-derive"
+version = "0.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6eafa6dfb17584ea3e2bd6e76e0cc15ad7af12b09abdd1ca55961bed9b1063c6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.96",
 ]
 
 [[package]]
diff --git a/pallets/subtensor/src/coinbase/block_step.rs b/pallets/subtensor/src/coinbase/block_step.rs
index a7e658e89a..e28bcb597f 100644
--- a/pallets/subtensor/src/coinbase/block_step.rs
+++ b/pallets/subtensor/src/coinbase/block_step.rs
@@ -15,7 +15,7 @@ impl<T: Config + pallet_drand::Config> Pallet<T> {
             U96F32::saturating_from_num(Self::get_block_emission().unwrap_or(0));
         log::debug!("Block emission: {:?}", block_emission);
         // --- 3. Run emission through network.
-        Self::run_coinbase(block_emission);
+        Self::run_coinbase(block_emission).map_err(Into::<&'static str>::into)?;
         // --- 4. Set pending children on the epoch; but only after the coinbase has been run.
         Self::try_set_pending_children(block_number);
         // Return ok.
diff --git a/pallets/subtensor/src/coinbase/run_coinbase.rs b/pallets/subtensor/src/coinbase/run_coinbase.rs
index 00b0c2fa55..eb7ea4b5b9 100644
--- a/pallets/subtensor/src/coinbase/run_coinbase.rs
+++ b/pallets/subtensor/src/coinbase/run_coinbase.rs
@@ -2,6 +2,7 @@ use super::*;
 use alloc::collections::BTreeMap;
 use safe_math::*;
 use substrate_fixed::types::U96F32;
+use subtensor_swap_interface::SwapHandler;
 use tle::stream_ciphers::AESGCMStreamCipherProvider;
 use tle::tlock::tld;
 
@@ -32,7 +33,7 @@ macro_rules! tou64 {
 }
 
 impl<T: Config> Pallet<T> {
-    pub fn run_coinbase(block_emission: U96F32) {
+    pub fn run_coinbase(block_emission: U96F32) -> DispatchResult {
         // --- 0. Get current block.
         let current_block: u64 = Self::get_current_block_as_u64();
         log::debug!("Current block: {:?}", current_block);
@@ -191,7 +192,12 @@ impl<T: Config> Pallet<T> {
             let pending_alpha: U96F32 = alpha_out_i.saturating_sub(root_alpha);
             log::debug!("pending_alpha: {:?}", pending_alpha);
             // Sell root emission through the pool.
-            let root_tao: u64 = Self::swap_alpha_for_tao(*netuid_i, tou64!(root_alpha));
+            let root_tao: u64 = Self::swap_alpha_for_tao(
+                *netuid_i,
+                tou64!(root_alpha),
+                T::SwapInterface::max_price(),
+            )?
+            .amount_paid_out;
             log::debug!("root_tao: {:?}", root_tao);
             // Accumulate alpha emission in pending.
             PendingAlphaSwapped::<T>::mutate(*netuid_i, |total| {
@@ -260,6 +266,8 @@ impl<T: Config> Pallet<T> {
                 BlocksSinceLastStep::<T>::mutate(netuid, |total| *total = total.saturating_add(1));
             }
         }
+
+		Ok(())
     }
 
     pub fn calculate_dividends_and_incentives(
diff --git a/pallets/subtensor/src/macros/events.rs b/pallets/subtensor/src/macros/events.rs
index e4f3a6abd8..20ef9968a7 100644
--- a/pallets/subtensor/src/macros/events.rs
+++ b/pallets/subtensor/src/macros/events.rs
@@ -16,7 +16,7 @@ mod events {
         /// stake has been transferred from the a coldkey account onto the hotkey staking account.
         StakeAdded(T::AccountId, T::AccountId, u64, u64, u16),
         /// stake has been removed from the hotkey staking account onto the coldkey account.
-        StakeRemoved(T::AccountId, T::AccountId, u64, u64, u16, u64),
+        StakeRemoved(T::AccountId, T::AccountId, u64, u64, u16),
         /// stake has been moved from origin (hotkey, subnet ID) to destination (hotkey, subnet ID) of this amount (in TAO).
         StakeMoved(T::AccountId, T::AccountId, u16, T::AccountId, u16, u64),
         /// a caller successfully sets their weights on a subnetwork.
diff --git a/pallets/subtensor/src/rpc_info/stake_info.rs b/pallets/subtensor/src/rpc_info/stake_info.rs
index 8a3888061f..14deb60324 100644
--- a/pallets/subtensor/src/rpc_info/stake_info.rs
+++ b/pallets/subtensor/src/rpc_info/stake_info.rs
@@ -114,6 +114,7 @@ impl<T: Config> Pallet<T> {
         })
     }
 
+    #[deprecated = "The fee is now calculated in Swap pallet"]
     pub fn get_stake_fee(
         origin: Option<(T::AccountId, u16)>,
         origin_coldkey_account: T::AccountId,
@@ -121,25 +122,6 @@ impl<T: Config> Pallet<T> {
         destination_coldkey_account: T::AccountId,
         amount: u64,
     ) -> u64 {
-        let origin_: Option<(&T::AccountId, u16)> =
-            if let Some((ref origin_hotkey, origin_netuid)) = origin {
-                Some((origin_hotkey, origin_netuid))
-            } else {
-                None
-            };
-
-        let destination_ = if let Some((ref destination_hotkey, destination_netuid)) = destination {
-            Some((destination_hotkey, destination_netuid))
-        } else {
-            None
-        };
-
-        Self::calculate_staking_fee(
-            origin_,
-            &origin_coldkey_account,
-            destination_,
-            &destination_coldkey_account,
-            U96F32::saturating_from_num(amount),
-        )
+        DefaultStakingFee::<T>::get()
     }
 }
diff --git a/pallets/subtensor/src/staking/helpers.rs b/pallets/subtensor/src/staking/helpers.rs
index 9ee04f36a8..433f925a17 100644
--- a/pallets/subtensor/src/staking/helpers.rs
+++ b/pallets/subtensor/src/staking/helpers.rs
@@ -1,6 +1,7 @@
 use super::*;
 use safe_math::*;
 use substrate_fixed::types::U96F32;
+use subtensor_swap_interface::SwapHandler;
 
 use frame_support::traits::{
     Imbalance,
@@ -166,7 +167,7 @@ impl<T: Config> Pallet<T> {
         hotkey: &T::AccountId,
         coldkey: &T::AccountId,
         netuid: u16,
-    ) {
+    ) -> DispatchResult {
         // Verify if the account is a nominator account by checking ownership of the hotkey by the coldkey.
         if !Self::coldkey_owns_hotkey(coldkey, hotkey) {
             // If the stake is below the minimum required, it's considered a small nomination and needs to be cleared.
@@ -178,22 +179,32 @@ impl<T: Config> Pallet<T> {
                 // Remove the stake from the nominator account. (this is a more forceful unstake operation which )
                 // Actually deletes the staking account.
                 // Do not apply any fees
-                let cleared_stake = Self::unstake_from_subnet(hotkey, coldkey, netuid, stake, 0);
+                let cleared_stake = Self::unstake_from_subnet(
+                    hotkey,
+                    coldkey,
+                    netuid,
+                    stake,
+                    T::SwapInterface::max_price(),
+                )?;
                 // Add the stake to the coldkey account.
                 Self::add_balance_to_coldkey_account(coldkey, cleared_stake);
             }
         }
+
+        Ok(())
     }
 
     /// Clears small nominations for all accounts.
     ///
     /// WARN: This is an O(N) operation, where N is the number of staking accounts. It should be
     /// used with caution.
-    pub fn clear_small_nominations() {
+    pub fn clear_small_nominations() -> DispatchResult {
         // Loop through all staking accounts to identify and clear nominations below the minimum stake.
         for ((hotkey, coldkey, netuid), _) in Alpha::<T>::iter() {
-            Self::clear_small_nomination_if_required(&hotkey, &coldkey, netuid);
+            Self::clear_small_nomination_if_required(&hotkey, &coldkey, netuid)?;
         }
+
+		Ok(())
     }
 
     pub fn add_balance_to_coldkey_account(
diff --git a/pallets/subtensor/src/staking/move_stake.rs b/pallets/subtensor/src/staking/move_stake.rs
index 77ba296e21..d2f9ccc913 100644
--- a/pallets/subtensor/src/staking/move_stake.rs
+++ b/pallets/subtensor/src/staking/move_stake.rs
@@ -338,28 +338,18 @@ impl<T: Config> Pallet<T> {
             max_amount
         };
 
-        // Unstake from the origin subnet, returning TAO (or a 1:1 equivalent).
-        let fee = Self::calculate_staking_fee(
-            Some((origin_hotkey, origin_netuid)),
-            origin_coldkey,
-            Some((destination_hotkey, destination_netuid)),
-            destination_coldkey,
-            U96F32::saturating_from_num(alpha_amount),
-        )
-        .safe_div(2);
-
         let tao_unstaked = Self::unstake_from_subnet(
             origin_hotkey,
             origin_coldkey,
             origin_netuid,
             move_amount,
-            fee,
-        );
+			T::SwapInterface::max_price(),
+        )?;
 
         // Stake the unstaked amount into the destination.
         // Because of the fee, the tao_unstaked may be too low if initial stake is low. In that case,
         // do not restake.
-        if tao_unstaked >= DefaultMinStake::<T>::get().saturating_add(fee) {
+        if tao_unstaked >= DefaultMinStake::<T>::get() {
             // If the coldkey is not the owner, make the hotkey a delegate.
             if Self::get_owning_coldkey_for_hotkey(destination_hotkey) != *destination_coldkey {
                 Self::maybe_become_delegate(destination_hotkey);
@@ -374,7 +364,7 @@ impl<T: Config> Pallet<T> {
             )?;
         }
 
-        Ok(tao_unstaked.saturating_sub(fee))
+        Ok(tao_unstaked)
     }
 
     /// Returns the maximum amount of origin netuid Alpha that can be executed before we cross
diff --git a/pallets/subtensor/src/staking/remove_stake.rs b/pallets/subtensor/src/staking/remove_stake.rs
index 5449e48d61..d4c0ed64f0 100644
--- a/pallets/subtensor/src/staking/remove_stake.rs
+++ b/pallets/subtensor/src/staking/remove_stake.rs
@@ -59,21 +59,19 @@ impl<T: Config> Pallet<T> {
         )?;
 
         // 3. Swap the alpba to tao and update counters for this subnet.
-        let fee = Self::calculate_staking_fee(
-            Some((&hotkey, netuid)),
-            &coldkey,
-            None,
+        let tao_unstaked: u64 = Self::unstake_from_subnet(
+            &hotkey,
             &coldkey,
-            U96F32::saturating_from_num(alpha_unstaked),
-        );
-        let tao_unstaked: u64 =
-            Self::unstake_from_subnet(&hotkey, &coldkey, netuid, alpha_unstaked, fee);
+            netuid,
+            alpha_unstaked,
+            T::SwapInterface::max_price(),
+        )?;
 
         // 4. We add the balance to the coldkey. If the above fails we will not credit this coldkey.
         Self::add_balance_to_coldkey_account(&coldkey, tao_unstaked);
 
         // 5. If the stake is below the minimum, we clear the nomination from storage.
-        Self::clear_small_nomination_if_required(&hotkey, &coldkey, netuid);
+        Self::clear_small_nomination_if_required(&hotkey, &coldkey, netuid)?;
 
         // 6. Check if stake lowered below MinStake and remove Pending children if it did
         if Self::get_total_stake_for_hotkey(&hotkey) < StakeThreshold::<T>::get() {
@@ -150,24 +148,21 @@ impl<T: Config> Pallet<T> {
                 continue;
             }
 
-            let fee = Self::calculate_staking_fee(
-                Some((&hotkey, netuid)),
-                &coldkey,
-                None,
-                &coldkey,
-                U96F32::saturating_from_num(alpha_unstaked),
-            );
-
             if alpha_unstaked > 0 {
                 // Swap the alpha to tao and update counters for this subnet.
-                let tao_unstaked: u64 =
-                    Self::unstake_from_subnet(&hotkey, &coldkey, netuid, alpha_unstaked, fee);
+                let tao_unstaked: u64 = Self::unstake_from_subnet(
+                    &hotkey,
+                    &coldkey,
+                    netuid,
+                    alpha_unstaked,
+                    T::SwapInterface::max_price(),
+                )?;
 
                 // Add the balance to the coldkey. If the above fails we will not credit this coldkey.
                 Self::add_balance_to_coldkey_account(&coldkey, tao_unstaked);
 
                 // If the stake is below the minimum, we clear the nomination from storage.
-                Self::clear_small_nomination_if_required(&hotkey, &coldkey, netuid);
+                Self::clear_small_nomination_if_required(&hotkey, &coldkey, netuid)?;
             }
         }
 
@@ -242,24 +237,21 @@ impl<T: Config> Pallet<T> {
                     continue;
                 }
 
-                let fee = Self::calculate_staking_fee(
-                    Some((&hotkey, netuid)),
-                    &coldkey,
-                    None,
-                    &coldkey,
-                    U96F32::saturating_from_num(alpha_unstaked),
-                );
-
                 if alpha_unstaked > 0 {
                     // Swap the alpha to tao and update counters for this subnet.
-                    let tao_unstaked =
-                        Self::unstake_from_subnet(&hotkey, &coldkey, netuid, alpha_unstaked, fee);
+                    let tao_unstaked = Self::unstake_from_subnet(
+                        &hotkey,
+                        &coldkey,
+                        netuid,
+                        alpha_unstaked,
+                        T::SwapInterface::max_price(),
+                    )?;
 
                     // Increment total
                     total_tao_unstaked = total_tao_unstaked.saturating_add(tao_unstaked);
 
                     // If the stake is below the minimum, we clear the nomination from storage.
-                    Self::clear_small_nomination_if_required(&hotkey, &coldkey, netuid);
+                    Self::clear_small_nomination_if_required(&hotkey, &coldkey, netuid)?;
                 }
             }
         }
@@ -351,21 +343,19 @@ impl<T: Config> Pallet<T> {
         )?;
 
         // 4. Swap the alpha to tao and update counters for this subnet.
-        let fee = Self::calculate_staking_fee(
-            Some((&hotkey, netuid)),
-            &coldkey,
-            None,
+        let tao_unstaked = Self::unstake_from_subnet(
+            &hotkey,
             &coldkey,
-            U96F32::saturating_from_num(alpha_unstaked),
-        );
-        let tao_unstaked =
-            Self::unstake_from_subnet(&hotkey, &coldkey, netuid, possible_alpha, fee);
+            netuid,
+            possible_alpha,
+            T::SwapInterface::max_price(),
+        )?;
 
         // 5. We add the balance to the coldkey. If the above fails we will not credit this coldkey.
         Self::add_balance_to_coldkey_account(&coldkey, tao_unstaked);
 
         // 6. If the stake is below the minimum, we clear the nomination from storage.
-        Self::clear_small_nomination_if_required(&hotkey, &coldkey, netuid);
+        Self::clear_small_nomination_if_required(&hotkey, &coldkey, netuid)?;
 
         // 7. Check if stake lowered below MinStake and remove Pending children if it did
         if Self::get_total_stake_for_hotkey(&hotkey) < StakeThreshold::<T>::get() {
diff --git a/pallets/subtensor/src/staking/stake_utils.rs b/pallets/subtensor/src/staking/stake_utils.rs
index c4b102fa6b..0429f5b2ea 100644
--- a/pallets/subtensor/src/staking/stake_utils.rs
+++ b/pallets/subtensor/src/staking/stake_utils.rs
@@ -3,7 +3,7 @@ use safe_math::*;
 use share_pool::{SharePool, SharePoolDataOperations};
 use sp_std::ops::Neg;
 use substrate_fixed::types::{I64F64, I96F32, U64F64, U96F32, U110F18};
-use subtensor_swap_interface::{OrderType, SwapHandler};
+use subtensor_swap_interface::{OrderType, SwapHandler, SwapResult};
 
 impl<T: Config> Pallet<T> {
     /// Retrieves the total alpha issuance for a given subnet.
@@ -620,147 +620,74 @@ impl<T: Config> Pallet<T> {
         actual_alpha.neg().max(0).unsigned_abs()
     }
 
-    /// Calculates Some(Alpha) returned from pool by staking operation
-    /// if liquidity allows that. If not, returns None.
-    ///
-    /// If new alpha_reserve is about to drop below DefaultMinimumPoolLiquidity,
-    /// then don't do it.
-    ///
-    pub fn sim_swap_tao_for_alpha(netuid: u16, tao: u64) -> Option<u64> {
-        // Step 1: Get the mechanism type for the subnet (0 for Stable, 1 for Dynamic)
-        let mechanism_id: u16 = SubnetMechanism::<T>::get(netuid);
-        // Step 2: Initialized vars.
-        if mechanism_id == 1 {
-            // Step 3.a.1: Dynamic mechanism calculations
-            let tao_reserves: U110F18 = U110F18::saturating_from_num(SubnetTAO::<T>::get(netuid));
-            let alpha_reserves: U110F18 =
-                U110F18::saturating_from_num(SubnetAlphaIn::<T>::get(netuid));
-            // Step 3.a.2: Compute constant product k = alpha * tao
-            let k: U110F18 = alpha_reserves.saturating_mul(tao_reserves);
-
-            // Calculate new alpha reserve
-            let new_alpha_reserves: U110F18 =
-                k.safe_div(tao_reserves.saturating_add(U110F18::saturating_from_num(tao)));
-
-            // Step 3.a.3: Calculate alpha staked using the constant product formula
-            // alpha_stake_recieved = current_alpha - (k / (current_tao + new_tao))
-            if new_alpha_reserves >= DefaultMinimumPoolLiquidity::<T>::get() {
-                Some(
-                    alpha_reserves
-                        .saturating_sub(new_alpha_reserves)
-                        .saturating_to_num::<u64>(),
-                )
-            } else {
-                None
-            }
-        } else {
-            // Step 3.b.1: Stable mechanism, just return the value 1:1
-            Some(tao)
-        }
-    }
-
-    /// Calculates Some(Tao) returned from pool by unstaking operation
-    /// if liquidity allows that. If not, returns None.
-    ///
-    /// If new tao_reserve is about to drop below DefaultMinimumPoolLiquidity,
-    /// then don't do it.
-    ///
-    pub fn sim_swap_alpha_for_tao(netuid: u16, alpha: u64) -> Option<u64> {
-        // Step 1: Get the mechanism type for the subnet (0 for Stable, 1 for Dynamic)
-        let mechanism_id: u16 = SubnetMechanism::<T>::get(netuid);
-        // Step 2: Swap alpha and attain tao
-        if mechanism_id == 1 {
-            // Step 3.a.1: Dynamic mechanism calculations
-            let tao_reserves: U110F18 = U110F18::saturating_from_num(SubnetTAO::<T>::get(netuid));
-            let alpha_reserves: U110F18 =
-                U110F18::saturating_from_num(SubnetAlphaIn::<T>::get(netuid));
-            // Step 3.a.2: Compute constant product k = alpha * tao
-            let k: U110F18 = alpha_reserves.saturating_mul(tao_reserves);
-
-            // Calculate new tao reserve
-            let new_tao_reserves: U110F18 = k
-                .checked_div(alpha_reserves.saturating_add(U110F18::saturating_from_num(alpha)))
-                .unwrap_or(U110F18::saturating_from_num(0));
-
-            // Step 3.a.3: Calculate alpha staked using the constant product formula
-            // tao_recieved = tao_reserves - (k / (alpha_reserves + new_tao))
-            if new_tao_reserves >= DefaultMinimumPoolLiquidity::<T>::get() {
-                Some(
-                    tao_reserves
-                        .saturating_sub(new_tao_reserves)
-                        .saturating_to_num::<u64>(),
-                )
-            } else {
-                None
-            }
-        } else {
-            // Step 3.b.1: Stable mechanism, just return the value 1:1
-            Some(alpha)
-        }
-    }
-
     /// Swaps TAO for the alpha token on the subnet.
     ///
     /// Updates TaoIn, AlphaIn, and AlphaOut
-    pub fn swap_tao_for_alpha(netuid: u16, tao: u64) -> u64 {
-        if let Some(alpha) = Self::sim_swap_tao_for_alpha(netuid, tao) {
-            // Step 4. Decrease Alpha reserves.
-            SubnetAlphaIn::<T>::mutate(netuid, |total| {
-                *total = total.saturating_sub(alpha);
-            });
-            // Step 5: Increase Alpha outstanding.
-            SubnetAlphaOut::<T>::mutate(netuid, |total| {
-                *total = total.saturating_add(alpha);
-            });
-            // Step 6: Increase Tao reserves.
-            SubnetTAO::<T>::mutate(netuid, |total| {
-                *total = total.saturating_add(tao);
-            });
-            // Step 7: Increase Total Tao reserves.
-            TotalStake::<T>::mutate(|total| {
-                *total = total.saturating_add(tao);
-            });
-            // Step 8. Increase total subnet TAO volume.
-            SubnetVolume::<T>::mutate(netuid, |total| {
-                *total = total.saturating_add(tao.into());
-            });
-            // Step 9. Return the alpha received.
-            alpha
-        } else {
-            0
-        }
+    pub fn swap_tao_for_alpha(
+        netuid: u16,
+        tao: u64,
+        price_limit: u64,
+    ) -> Result<SwapResult, DispatchError> {
+        let swap_result = T::SwapInterface::swap(netuid, OrderType::Buy, tao, price_limit)?;
+
+        // update Alpha reserves.
+        SubnetAlphaIn::<T>::set(netuid, swap_result.new_alpha_reserve);
+
+        // Increase Alpha outstanding.
+        SubnetAlphaOut::<T>::mutate(netuid, |total| {
+            *total = total.saturating_add(swap_result.amount_paid_out);
+        });
+
+        // update Tao reserves.
+        SubnetTAO::<T>::set(netuid, swap_result.new_tao_reserve);
+
+        // Increase Total Tao reserves.
+        TotalStake::<T>::mutate(|total| {
+            *total = total.saturating_add(tao);
+        });
+
+        // Increase total subnet TAO volume.
+        SubnetVolume::<T>::mutate(netuid, |total| {
+            *total = total.saturating_add(tao.into());
+        });
+
+        // Return the alpha received.
+        Ok(swap_result)
     }
 
     /// Swaps a subnet's Alpba token for TAO.
     ///
     /// Updates TaoIn, AlphaIn, and AlphaOut
-    pub fn swap_alpha_for_tao(netuid: u16, alpha: u64) -> u64 {
-        if let Some(tao) = Self::sim_swap_alpha_for_tao(netuid, alpha) {
-            // Step 4: Increase Alpha reserves.
-            SubnetAlphaIn::<T>::mutate(netuid, |total| {
-                *total = total.saturating_add(alpha);
-            });
-            // Step 5: Decrease Alpha outstanding.
-            SubnetAlphaOut::<T>::mutate(netuid, |total| {
-                *total = total.saturating_sub(alpha);
-            });
-            // Step 6: Decrease tao reserves.
-            SubnetTAO::<T>::mutate(netuid, |total| {
-                *total = total.saturating_sub(tao);
-            });
-            // Step 7: Reduce total TAO reserves.
-            TotalStake::<T>::mutate(|total| {
-                *total = total.saturating_sub(tao);
-            });
-            // Step 8. Increase total subnet TAO volume.
-            SubnetVolume::<T>::mutate(netuid, |total| {
-                *total = total.saturating_add(tao.into());
-            });
-            // Step 9. Return the tao received.
-            tao
-        } else {
-            0
-        }
+    pub fn swap_alpha_for_tao(
+        netuid: u16,
+        alpha: u64,
+        price_limit: u64,
+    ) -> Result<SwapResult, DispatchError> {
+        let swap_result = T::SwapInterface::swap(netuid, OrderType::Sell, alpha, price_limit)?;
+
+        // Increase Alpha reserves.
+        SubnetAlphaIn::<T>::set(netuid, swap_result.new_alpha_reserve);
+
+        // Decrease Alpha outstanding.
+        SubnetAlphaOut::<T>::mutate(netuid, |total| {
+            *total = total.saturating_sub(alpha);
+        });
+
+        // Decrease tao reserves.
+        SubnetTAO::<T>::set(netuid, swap_result.new_tao_reserve);
+
+        // Reduce total TAO reserves.
+        TotalStake::<T>::mutate(|total| {
+            *total = total.saturating_sub(swap_result.amount_paid_out);
+        });
+
+        // Increase total subnet TAO volume.
+        SubnetVolume::<T>::mutate(netuid, |total| {
+            *total = total.saturating_add(swap_result.amount_paid_out.into());
+        });
+
+        // Return the tao received.
+        Ok(swap_result)
     }
 
     /// Unstakes alpha from a subnet for a given hotkey and coldkey pair.
@@ -771,14 +698,14 @@ impl<T: Config> Pallet<T> {
         coldkey: &T::AccountId,
         netuid: u16,
         alpha: u64,
-        fee: u64,
-    ) -> u64 {
-        // Step 1: Decrease alpha on subneet
+        price_limit: u64,
+    ) -> Result<u64, DispatchError> {
+        //  Decrease alpha on subneet
         let actual_alpha_decrease =
             Self::decrease_stake_for_hotkey_and_coldkey_on_subnet(hotkey, coldkey, netuid, alpha);
 
-        // Step 2: Swap the alpha for TAO.
-        let tao: u64 = Self::swap_alpha_for_tao(netuid, actual_alpha_decrease);
+        // Swap the alpha for TAO.
+        let swap_result = Self::swap_alpha_for_tao(netuid, actual_alpha_decrease, price_limit)?;
 
         // Step 3: Update StakingHotkeys if the hotkey's total alpha, across all subnets, is zero
         // TODO const: fix.
@@ -788,38 +715,27 @@ impl<T: Config> Pallet<T> {
         //     });
         // }
 
-        // Step 4. Reduce tao amount by staking fee and credit this fee to SubnetTAO
-        let tao_unstaked = tao.saturating_sub(fee);
-        let actual_fee = tao.saturating_sub(tao_unstaked);
-        SubnetTAO::<T>::mutate(netuid, |total| {
-            *total = total.saturating_add(actual_fee);
-        });
-        TotalStake::<T>::mutate(|total| {
-            *total = total.saturating_add(actual_fee);
-        });
         LastColdkeyHotkeyStakeBlock::<T>::insert(coldkey, hotkey, Self::get_current_block_as_u64());
 
-        // Step 5. Deposit and log the unstaking event.
+        // Deposit and log the unstaking event.
         Self::deposit_event(Event::StakeRemoved(
             coldkey.clone(),
             hotkey.clone(),
-            tao_unstaked,
+            swap_result.amount_paid_out,
             actual_alpha_decrease,
             netuid,
-            actual_fee,
         ));
+
         log::debug!(
-            "StakeRemoved( coldkey: {:?}, hotkey:{:?}, tao: {:?}, alpha:{:?}, netuid: {:?}, fee: {:?} )",
+            "StakeRemoved( coldkey: {:?}, hotkey:{:?}, tao: {:?}, alpha:{:?}, netuid: {:?} )",
             coldkey.clone(),
             hotkey.clone(),
-            tao_unstaked,
+            swap_result.amount_paid_out,
             actual_alpha_decrease,
             netuid,
-            actual_fee
         );
 
-        // Step 6: Return the amount of TAO unstaked.
-        tao_unstaked
+        Ok(swap_result.amount_paid_out)
     }
 
     /// Stakes TAO into a subnet for a given hotkey and coldkey pair.
@@ -833,7 +749,16 @@ impl<T: Config> Pallet<T> {
         price_limit: u64,
     ) -> Result<u64, DispatchError> {
         // Swap the tao to alpha.
-        let swap_result = T::SwapInterface::swap(netuid, OrderType::Buy, tao, price_limit)?;
+        let swap_result = Self::swap_tao_for_alpha(netuid, tao, price_limit)?;
+
+        ensure!(
+            Self::try_increase_stake_for_hotkey_and_coldkey_on_subnet(
+                hotkey,
+                netuid,
+                swap_result.amount_paid_out,
+            ),
+            Error::<T>::InsufficientLiquidity
+        );
 
         // Increase the alpha on the hotkey account.
         if Self::increase_stake_for_hotkey_and_coldkey_on_subnet(
@@ -854,13 +779,6 @@ impl<T: Config> Pallet<T> {
             StakingHotkeys::<T>::insert(coldkey, staking_hotkeys.clone());
         }
 
-        // Update TAO reserves
-        SubnetTAO::<T>::mutate(netuid, |total| {
-            *total = swap_result.new_tao_reserve;
-        });
-        SubnetAlphaIn::<T>::mutate(netuid, |total| {
-            *total = swap_result.new_alpha_reserve;
-        });
         LastColdkeyHotkeyStakeBlock::<T>::insert(coldkey, hotkey, Self::get_current_block_as_u64());
 
         // Deposit and log the staking event.
@@ -893,7 +811,6 @@ impl<T: Config> Pallet<T> {
     }
 
     /// Validate add_stake user input
-    ///
     pub fn validate_add_stake(
         coldkey: &T::AccountId,
         hotkey: &T::AccountId,
@@ -929,19 +846,6 @@ impl<T: Config> Pallet<T> {
             Error::<T>::HotKeyAccountNotExists
         );
 
-        let expected_alpha = Self::sim_swap_tao_for_alpha(netuid, stake_to_be_added);
-
-        // Ensure that we have adequate liquidity
-        ensure!(expected_alpha.is_some(), Error::<T>::InsufficientLiquidity);
-
-        // Ensure hotkey pool is precise enough
-        let try_stake_result = Self::try_increase_stake_for_hotkey_and_coldkey_on_subnet(
-            hotkey,
-            netuid,
-            expected_alpha.unwrap_or(0),
-        );
-        ensure!(try_stake_result, Error::<T>::InsufficientLiquidity);
-
         Ok(())
     }
 
@@ -958,16 +862,6 @@ impl<T: Config> Pallet<T> {
         // Ensure that the subnet exists.
         ensure!(Self::if_subnet_exist(netuid), Error::<T>::SubnetNotExists);
 
-        // Ensure that the stake amount to be removed is above the minimum in tao equivalent.
-        if let Some(tao_equivalent) = Self::sim_swap_alpha_for_tao(netuid, alpha_unstaked) {
-            ensure!(
-                tao_equivalent > DefaultMinStake::<T>::get(),
-                Error::<T>::AmountTooLow
-            );
-        } else {
-            return Err(Error::<T>::InsufficientLiquidity);
-        };
-
         // Ensure that if partial execution is not allowed, the amount will not cause
         // slippage over desired
         if !allow_partial {
@@ -1039,17 +933,6 @@ impl<T: Config> Pallet<T> {
             Error::<T>::NotEnoughStakeToWithdraw
         );
 
-        // Ensure that the stake amount to be removed is above the minimum in tao equivalent.
-        let tao_equivalent_result = Self::sim_swap_alpha_for_tao(origin_netuid, alpha_amount);
-        if let Some(tao_equivalent) = tao_equivalent_result {
-            ensure!(
-                tao_equivalent > DefaultMinStake::<T>::get(),
-                Error::<T>::AmountTooLow
-            );
-        } else {
-            return Err(Error::<T>::InsufficientLiquidity);
-        }
-
         // Ensure that if partial execution is not allowed, the amount will not cause
         // slippage over desired
         if let Some(allow_partial) = maybe_allow_partial {
@@ -1058,18 +941,6 @@ impl<T: Config> Pallet<T> {
             }
         }
 
-        let expected_alpha =
-            Self::sim_swap_tao_for_alpha(destination_netuid, tao_equivalent_result.unwrap_or(0))
-                .unwrap_or(0);
-
-        // Ensure that the amount being staked to the new hotkey is precise enough
-        let try_stake_result = Self::try_increase_stake_for_hotkey_and_coldkey_on_subnet(
-            destination_hotkey,
-            destination_netuid,
-            expected_alpha,
-        );
-        ensure!(try_stake_result, Error::<T>::InsufficientLiquidity);
-
         if check_transfer_toggle {
             // Ensure transfer is toggled.
             ensure!(
@@ -1084,70 +955,6 @@ impl<T: Config> Pallet<T> {
 
         Ok(())
     }
-
-    pub(crate) fn calculate_staking_fee(
-        origin: Option<(&T::AccountId, u16)>,
-        _origin_coldkey: &T::AccountId,
-        destination: Option<(&T::AccountId, u16)>,
-        _destination_coldkey: &T::AccountId,
-        alpha_estimate: U96F32,
-    ) -> u64 {
-        match origin {
-            // If origin is defined, we are removing/moving stake
-            Some((origin_hotkey, origin_netuid)) => {
-                if let Some((_destination_hotkey, destination_netuid)) = destination {
-                    // This is a stake move/swap/transfer
-                    if destination_netuid == origin_netuid {
-                        // If destination is on the same subnet, use the default fee
-                        return DefaultStakingFee::<T>::get();
-                    }
-                }
-
-                if origin_netuid == Self::get_root_netuid()
-                    || SubnetMechanism::<T>::get(origin_netuid) == 0
-                {
-                    // If the origin netuid is root, or the subnet mechanism is 0, use the default fee
-                    DefaultStakingFee::<T>::get()
-                } else {
-                    // Otherwise, calculate the fee based on the alpha estimate
-                    // Here we are using TotalHotkeyAlphaLastEpoch, which is exactly the value that
-                    // was used to calculate AlphaDividendsPerSubnet
-                    let tao_estimate = U96F32::saturating_from_num(
-                        Self::sim_swap_alpha_for_tao(
-                            origin_netuid,
-                            alpha_estimate.saturating_to_num::<u64>(),
-                        )
-                        .unwrap_or(0),
-                    );
-                    let mut fee = tao_estimate
-                        .saturating_mul(
-                            U96F32::saturating_from_num(AlphaDividendsPerSubnet::<T>::get(
-                                origin_netuid,
-                                &origin_hotkey,
-                            ))
-                            .safe_div(U96F32::saturating_from_num(
-                                TotalHotkeyAlphaLastEpoch::<T>::get(&origin_hotkey, origin_netuid),
-                            )),
-                        )
-                        .saturating_to_num::<u64>();
-
-                    // 0.005% per epoch matches to 44% annual in compound interest. Do not allow the fee
-                    // to be lower than that. (1.00005^(365*20) ~= 1.44)
-                    let apr_20_percent = U96F32::saturating_from_num(0.00005);
-                    fee = fee.max(
-                        tao_estimate
-                            .saturating_mul(apr_20_percent)
-                            .saturating_to_num::<u64>(),
-                    );
-
-                    // We should at least get DefaultStakingFee anyway
-                    fee.max(DefaultStakingFee::<T>::get())
-                }
-            }
-            // If origin is not defined, we are adding stake; use default fee
-            None => DefaultStakingFee::<T>::get(),
-        }
-    }
 }
 
 ///////////////////////////////////////////
diff --git a/pallets/subtensor/src/subnets/registration.rs b/pallets/subtensor/src/subnets/registration.rs
index 5c698c1b33..d27a79b649 100644
--- a/pallets/subtensor/src/subnets/registration.rs
+++ b/pallets/subtensor/src/subnets/registration.rs
@@ -3,6 +3,7 @@ use sp_core::{H256, U256};
 use sp_io::hashing::{keccak_256, sha2_256};
 use sp_runtime::Saturating;
 use system::pallet_prelude::BlockNumberFor;
+use subtensor_swap_interface::SwapHandler;
 
 const LOG_TARGET: &str = "runtime::subtensor::registration";
 
@@ -139,7 +140,9 @@ impl<T: Config> Pallet<T> {
             Self::remove_balance_from_coldkey_account(&coldkey, registration_cost)?;
 
         // Tokens are swapped and then burned.
-        let burned_alpha: u64 = Self::swap_tao_for_alpha(netuid, actual_burn_amount);
+        let burned_alpha: u64 =
+            Self::swap_tao_for_alpha(netuid, actual_burn_amount, T::SwapInterface::max_price())?
+                .amount_paid_out;
         SubnetAlphaOut::<T>::mutate(netuid, |total| *total = total.saturating_sub(burned_alpha));
 
         // Actually perform the registration.
diff --git a/pallets/swap/src/mock.rs b/pallets/swap/src/mock.rs
index 5732152e34..b9bac41fd2 100644
--- a/pallets/swap/src/mock.rs
+++ b/pallets/swap/src/mock.rs
@@ -9,11 +9,8 @@ use sp_runtime::{
     BuildStorage,
     traits::{BlakeTwo256, IdentityLookup},
 };
-use substrate_fixed::types::U64F64;
 use subtensor_swap_interface::LiquidityDataProvider;
 
-use crate::SqrtPrice;
-
 construct_runtime!(
     pub enum Test {
         System: frame_system,
@@ -74,11 +71,11 @@ pub struct MockLiquidityProvider;
 
 impl LiquidityDataProvider<AccountId> for MockLiquidityProvider {
     fn tao_reserve(_: u16) -> u64 {
-        1_000_000_000
+        1_000_000_000_000
     }
 
     fn alpha_reserve(_: u16) -> u64 {
-        4_000_000_000
+        4_000_000_000_000
     }
 
     fn tao_balance(account_id: &AccountId) -> u64 {
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 3dcf0595d3..220ac817af 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -392,6 +392,16 @@ impl<T: Config> Pallet<T> {
         let tao_reserve = T::LiquidityDataProvider::tao_reserve(netuid.into());
         let alpha_reserve = T::LiquidityDataProvider::alpha_reserve(netuid.into());
 
+        let checked_reserve = match order_type {
+            OrderType::Buy => alpha_reserve,
+            OrderType::Sell => tao_reserve,
+        };
+
+        ensure!(
+            checked_reserve >= amount_paid_out,
+            Error::<T>::InsufficientLiquidity
+        );
+
         let (new_tao_reserve, new_alpha_reserve) = match order_type {
             OrderType::Buy => (
                 tao_reserve.saturating_add(in_acc),
@@ -881,8 +891,7 @@ impl<T: Config> Pallet<T> {
 
         // If delta brings the position liquidity below MinimumLiquidity, eliminate position and withdraw full amounts
         if (liquidity_delta < 0)
-            && (position.liquidity.saturating_sub(delta_liquidity_abs)
-                < T::MinimumLiquidity::get())
+            && (position.liquidity.saturating_sub(delta_liquidity_abs) < T::MinimumLiquidity::get())
         {
             delta_liquidity_abs = position.liquidity;
         }
@@ -1096,7 +1105,7 @@ pub enum SwapStepAction {
 #[cfg(test)]
 mod tests {
     use approx::assert_abs_diff_eq;
-    use frame_support::{assert_err, assert_ok};
+    use frame_support::{assert_err, assert_noop, assert_ok};
     use sp_arithmetic::helpers_128bit;
 
     use super::*;
@@ -1261,8 +1270,6 @@ mod tests {
                     )
                     .unwrap();
 
-                    // dbg!((tao, expected_tao), (alpha, expected_alpha));
-
                     assert_abs_diff_eq!(tao, expected_tao, epsilon = tao / 1000);
                     assert_abs_diff_eq!(alpha, expected_alpha, epsilon = alpha / 1000);
 
@@ -1513,7 +1520,7 @@ mod tests {
             [
                 (OrderType::Buy, 1_000u64, 1000.0_f64, 3990_u64),
                 (OrderType::Sell, 1_000u64, 0.0001_f64, 250_u64),
-                (OrderType::Buy, 500_000_000, 1000.0, 1_330_000_000),
+                (OrderType::Buy, 500_000_000, 1000.0, 2_000_000_000),
             ]
             .into_iter()
             .enumerate()
@@ -1598,7 +1605,7 @@ mod tests {
                     .to_num::<f64>()
                         * (liquidity_before as f64))
                         as u64;
-                    assert_eq!(actual_global_fee, expected_fee);
+                    assert!((actual_global_fee as i64 - expected_fee as i64).abs() <= 1);
 
                     // Tick fees should be updated
 

From 04315762b92f48593a2e6d81a120567ddc6e84dc Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Mon, 14 Apr 2025 14:34:21 +0200
Subject: [PATCH 065/418] Add rollback flag to swap function

---
 pallets/subtensor/src/rpc_info/stake_info.rs |  2 +-
 pallets/swap-interface/src/lib.rs            |  2 +
 pallets/swap/src/pallet/impls.rs             | 72 ++++++++++++++++----
 3 files changed, 63 insertions(+), 13 deletions(-)

diff --git a/pallets/subtensor/src/rpc_info/stake_info.rs b/pallets/subtensor/src/rpc_info/stake_info.rs
index 14deb60324..efe679306b 100644
--- a/pallets/subtensor/src/rpc_info/stake_info.rs
+++ b/pallets/subtensor/src/rpc_info/stake_info.rs
@@ -122,6 +122,6 @@ impl<T: Config> Pallet<T> {
         destination_coldkey_account: T::AccountId,
         amount: u64,
     ) -> u64 {
-        DefaultStakingFee::<T>::get()
+		todo!()
     }
 }
diff --git a/pallets/swap-interface/src/lib.rs b/pallets/swap-interface/src/lib.rs
index df0aacd0d7..b902172d94 100644
--- a/pallets/swap-interface/src/lib.rs
+++ b/pallets/swap-interface/src/lib.rs
@@ -16,6 +16,7 @@ pub trait SwapHandler<AccountId> {
         order_t: OrderType,
         amount: u64,
         price_limit: u64,
+        should_rollback: bool,
     ) -> Result<SwapResult, DispatchError>;
     fn add_liquidity(
         netuid: u16,
@@ -29,6 +30,7 @@ pub trait SwapHandler<AccountId> {
         account_id: &AccountId,
         position_id: PositionId,
     ) -> Result<(u64, u64), DispatchError>;
+    fn approx_fee_amount(netuid: u16, amount: u64) -> u64;
     fn max_price() -> u64;
     fn min_price() -> u64;
 }
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 220ac817af..d21a076a7b 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -1,5 +1,6 @@
 use core::marker::PhantomData;
 
+use frame_support::storage::{TransactionOutcome, transactional};
 use frame_support::{ensure, pallet_prelude::DispatchError, traits::Get};
 use safe_math::*;
 use sp_arithmetic::helpers_128bit;
@@ -350,13 +351,35 @@ impl<T: Config> Pallet<T> {
 
     /// Perform a swap
     ///
-    /// Returns a tuple (amount_paid_out, refund), where amount_paid_out is the resulting paid out amount
-    /// and refund is any unswapped amount returned to the caller
+    /// Returns a tuple (amount_paid_out, refund), where amount_paid_out is the resulting paid out
+    /// amount and refund is any unswapped amount returned to the caller
+    ///
+    /// The function can be used without writing into the storage by setting `should_rollback` to
+    /// `true`.
     pub fn swap(
         netuid: NetUid,
         order_type: OrderType,
         amount: u64,
         sqrt_price_limit: SqrtPrice,
+        should_rollback: bool,
+    ) -> Result<SwapResult, DispatchError> {
+        transactional::with_transaction(|| {
+            let result =
+                Self::swap_inner(netuid, order_type, amount, sqrt_price_limit).map_err(Into::into);
+
+            if should_rollback || result.is_err() {
+                TransactionOutcome::Rollback(result)
+            } else {
+                TransactionOutcome::Commit(result)
+            }
+        })
+    }
+
+    fn swap_inner(
+        netuid: NetUid,
+        order_type: OrderType,
+        amount: u64,
+        sqrt_price_limit: SqrtPrice,
     ) -> Result<SwapResult, Error<T>> {
         Self::maybe_initialize_v3(netuid)?;
 
@@ -384,9 +407,11 @@ impl<T: Config> Pallet<T> {
             }
 
             iteration_counter = iteration_counter.saturating_add(1);
-            if iteration_counter > MAX_SWAP_ITERATIONS {
-                return Err(Error::<T>::TooManySwapSteps);
-            }
+
+            ensure!(
+                iteration_counter <= MAX_SWAP_ITERATIONS,
+                Error::<T>::TooManySwapSteps
+            );
         }
 
         let tao_reserve = T::LiquidityDataProvider::tao_reserve(netuid.into());
@@ -1042,12 +1067,20 @@ impl<T: Config> SwapHandler<T::AccountId> for Pallet<T> {
         order_t: OrderType,
         amount: u64,
         price_limit: u64,
+        should_rollback: bool,
     ) -> Result<SwapResult, DispatchError> {
         let sqrt_price_limit = SqrtPrice::saturating_from_num(price_limit)
             .checked_sqrt(SqrtPrice::saturating_from_num(2))
             .ok_or(Error::<T>::PriceLimitExceeded)?;
 
-        Self::swap(NetUid::from(netuid), order_t, amount, sqrt_price_limit).map_err(Into::into)
+        Self::swap(
+            NetUid::from(netuid),
+            order_t,
+            amount,
+            sqrt_price_limit,
+            should_rollback,
+        )
+        .map_err(Into::into)
     }
 
     fn add_liquidity(
@@ -1075,6 +1108,10 @@ impl<T: Config> SwapHandler<T::AccountId> for Pallet<T> {
             .map_err(Into::into)
     }
 
+    fn approx_fee_amount(netuid: u16, amount: u64) -> u64 {
+        Self::calculate_fee_amount(netuid.into(), amount)
+    }
+
     fn min_price() -> u64 {
         TickIndex::min_sqrt_price()
             .saturating_mul(TickIndex::min_sqrt_price())
@@ -1547,9 +1584,14 @@ mod tests {
 
                     // Swap
                     let sqrt_limit_price = SqrtPrice::from_num((limit_price).sqrt());
-                    let swap_result =
-                        Pallet::<Test>::swap(netuid, order_type, liquidity, sqrt_limit_price)
-                            .unwrap();
+                    let swap_result = Pallet::<Test>::swap(
+                        netuid,
+                        order_type,
+                        liquidity,
+                        sqrt_limit_price,
+                        false,
+                    )
+                    .unwrap();
                     assert_abs_diff_eq!(
                         swap_result.amount_paid_out,
                         output_amount,
@@ -1783,6 +1825,7 @@ mod tests {
                             order_type,
                             order_liquidity as u64,
                             sqrt_limit_price,
+                            false,
                         )
                         .unwrap();
                         assert_abs_diff_eq!(
@@ -2010,9 +2053,14 @@ mod tests {
 
                 // Do the swap
                 let sqrt_limit_price = SqrtPrice::from_num((limit_price).sqrt());
-                let swap_result =
-                    Pallet::<Test>::swap(netuid, order_type, order_liquidity, sqrt_limit_price)
-                        .unwrap();
+                let swap_result = Pallet::<Test>::swap(
+                    netuid,
+                    order_type,
+                    order_liquidity,
+                    sqrt_limit_price,
+                    false,
+                )
+                .unwrap();
                 assert_abs_diff_eq!(
                     swap_result.amount_paid_out as f64,
                     output_amount,

From a1bc97adf0ff76a1fcb2c39a6b301a57a06bcb73 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Mon, 14 Apr 2025 16:11:01 +0200
Subject: [PATCH 066/418] Add fee in swap result

---
 pallets/subtensor/src/macros/events.rs       |  4 +-
 pallets/subtensor/src/rpc_info/stake_info.rs |  3 +-
 pallets/subtensor/src/staking/stake_utils.rs |  8 +++-
 pallets/swap-interface/src/lib.rs            | 13 +------
 pallets/swap/src/pallet/impls.rs             | 39 +++++++-------------
 5 files changed, 24 insertions(+), 43 deletions(-)

diff --git a/pallets/subtensor/src/macros/events.rs b/pallets/subtensor/src/macros/events.rs
index 20ef9968a7..8c2e863d0e 100644
--- a/pallets/subtensor/src/macros/events.rs
+++ b/pallets/subtensor/src/macros/events.rs
@@ -14,9 +14,9 @@ mod events {
         /// a network is removed.
         NetworkRemoved(u16),
         /// stake has been transferred from the a coldkey account onto the hotkey staking account.
-        StakeAdded(T::AccountId, T::AccountId, u64, u64, u16),
+        StakeAdded(T::AccountId, T::AccountId, u64, u64, u16, u64),
         /// stake has been removed from the hotkey staking account onto the coldkey account.
-        StakeRemoved(T::AccountId, T::AccountId, u64, u64, u16),
+        StakeRemoved(T::AccountId, T::AccountId, u64, u64, u16, u64),
         /// stake has been moved from origin (hotkey, subnet ID) to destination (hotkey, subnet ID) of this amount (in TAO).
         StakeMoved(T::AccountId, T::AccountId, u16, T::AccountId, u16, u64),
         /// a caller successfully sets their weights on a subnetwork.
diff --git a/pallets/subtensor/src/rpc_info/stake_info.rs b/pallets/subtensor/src/rpc_info/stake_info.rs
index efe679306b..b77122b1ec 100644
--- a/pallets/subtensor/src/rpc_info/stake_info.rs
+++ b/pallets/subtensor/src/rpc_info/stake_info.rs
@@ -114,7 +114,6 @@ impl<T: Config> Pallet<T> {
         })
     }
 
-    #[deprecated = "The fee is now calculated in Swap pallet"]
     pub fn get_stake_fee(
         origin: Option<(T::AccountId, u16)>,
         origin_coldkey_account: T::AccountId,
@@ -122,6 +121,6 @@ impl<T: Config> Pallet<T> {
         destination_coldkey_account: T::AccountId,
         amount: u64,
     ) -> u64 {
-		todo!()
+        T::SwapInterface::approx_fee_amount(destination.1, amount)
     }
 }
diff --git a/pallets/subtensor/src/staking/stake_utils.rs b/pallets/subtensor/src/staking/stake_utils.rs
index 0429f5b2ea..52d6314ff0 100644
--- a/pallets/subtensor/src/staking/stake_utils.rs
+++ b/pallets/subtensor/src/staking/stake_utils.rs
@@ -724,15 +724,17 @@ impl<T: Config> Pallet<T> {
             swap_result.amount_paid_out,
             actual_alpha_decrease,
             netuid,
+            swap_result.fee_paid,
         ));
 
         log::debug!(
-            "StakeRemoved( coldkey: {:?}, hotkey:{:?}, tao: {:?}, alpha:{:?}, netuid: {:?} )",
+            "StakeRemoved( coldkey: {:?}, hotkey:{:?}, tao: {:?}, alpha:{:?}, netuid: {:?}, fee {} )",
             coldkey.clone(),
             hotkey.clone(),
             swap_result.amount_paid_out,
             actual_alpha_decrease,
             netuid,
+            swap_result.fee_paid
         );
 
         Ok(swap_result.amount_paid_out)
@@ -788,15 +790,17 @@ impl<T: Config> Pallet<T> {
             tao,
             swap_result.amount_paid_out,
             netuid,
+            swap_result.fee_paid,
         ));
 
         log::debug!(
-            "StakeAdded( coldkey: {:?}, hotkey:{:?}, tao: {:?}, alpha:{:?}, netuid: {:?} )",
+            "StakeAdded( coldkey: {:?}, hotkey:{:?}, tao: {:?}, alpha:{:?}, netuid: {:?}, fee {} )",
             coldkey.clone(),
             hotkey.clone(),
             tao,
             swap_result.amount_paid_out,
             netuid,
+            swap_result.fee_paid,
         );
 
         Ok(swap_result.amount_paid_out)
diff --git a/pallets/swap-interface/src/lib.rs b/pallets/swap-interface/src/lib.rs
index b902172d94..dfbd25d271 100644
--- a/pallets/swap-interface/src/lib.rs
+++ b/pallets/swap-interface/src/lib.rs
@@ -18,18 +18,6 @@ pub trait SwapHandler<AccountId> {
         price_limit: u64,
         should_rollback: bool,
     ) -> Result<SwapResult, DispatchError>;
-    fn add_liquidity(
-        netuid: u16,
-        account_id: &AccountId,
-        tick_low: i32,
-        tick_high: i32,
-        liquidity: u64,
-    ) -> Result<(u64, u64), DispatchError>;
-    fn remove_liquidity(
-        netuid: u16,
-        account_id: &AccountId,
-        position_id: PositionId,
-    ) -> Result<(u64, u64), DispatchError>;
     fn approx_fee_amount(netuid: u16, amount: u64) -> u64;
     fn max_price() -> u64;
     fn min_price() -> u64;
@@ -38,6 +26,7 @@ pub trait SwapHandler<AccountId> {
 #[derive(Debug, PartialEq)]
 pub struct SwapResult {
     pub amount_paid_out: u64,
+	pub fee_paid: u64,
     pub refund: u64,
     // calculated new tao/alpha reserves
     pub new_tao_reserve: u64,
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index d21a076a7b..3a3db6e349 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -388,6 +388,7 @@ impl<T: Config> Pallet<T> {
         let mut refund: u64 = 0;
         let mut iteration_counter: u16 = 0;
         let mut in_acc: u64 = 0;
+        let liquidity_before = CurrentLiquidity::<T>::get(netuid);
 
         // Swap one tick at a time until we reach one of the stop conditions
         while amount_remaining > 0 {
@@ -438,8 +439,18 @@ impl<T: Config> Pallet<T> {
             ),
         };
 
+        let global_fee = match order_type {
+            OrderType::Sell => FeeGlobalTao::<T>::get(netuid),
+            OrderType::Buy => FeeGlobalAlpha::<T>::get(netuid),
+        };
+        let fee_paid = global_fee
+            .saturating_mul(SqrtPrice::saturating_from_num(liquidity_before))
+            .saturating_round()
+            .saturating_to_num::<u64>();
+
         Ok(SwapResult {
             amount_paid_out,
+            fee_paid,
             refund,
             new_tao_reserve,
             new_alpha_reserve,
@@ -1083,31 +1094,6 @@ impl<T: Config> SwapHandler<T::AccountId> for Pallet<T> {
         .map_err(Into::into)
     }
 
-    fn add_liquidity(
-        netuid: u16,
-        account_id: &T::AccountId,
-        tick_low: i32,
-        tick_high: i32,
-        liquidity: u64,
-    ) -> Result<(u64, u64), DispatchError> {
-        let tick_low = TickIndex::new(tick_low).map_err(|_| Error::<T>::InvalidTickRange)?;
-        let tick_high = TickIndex::new(tick_high).map_err(|_| Error::<T>::InvalidTickRange)?;
-
-        Self::add_liquidity(netuid.into(), account_id, tick_low, tick_high, liquidity)
-            .map(|(_, tao, alpha)| (tao, alpha))
-            .map_err(Into::into)
-    }
-
-    fn remove_liquidity(
-        netuid: u16,
-        account_id: &T::AccountId,
-        position_id: PositionId,
-    ) -> Result<(u64, u64), DispatchError> {
-        Self::remove_liquidity(netuid.into(), account_id, position_id)
-            .map(|result| (result.tao, result.alpha))
-            .map_err(Into::into)
-    }
-
     fn approx_fee_amount(netuid: u16, amount: u64) -> u64 {
         Self::calculate_fee_amount(netuid.into(), amount)
     }
@@ -1647,6 +1633,8 @@ mod tests {
                     .to_num::<f64>()
                         * (liquidity_before as f64))
                         as u64;
+
+                    assert!((swap_result.fee_paid as i64 - expected_fee as i64).abs() <= 1);
                     assert!((actual_global_fee as i64 - expected_fee as i64).abs() <= 1);
 
                     // Tick fees should be updated
@@ -1907,6 +1895,7 @@ mod tests {
                         .to_num::<f64>()
                             * (liquidity_before as f64))
                             as u64;
+                        assert!((swap_result.fee_paid as i64 - expected_fee as i64).abs() <= 1);
                         assert_abs_diff_eq!(
                             actual_global_fee,
                             expected_fee,

From 53912ff2e0181c1fa9b62f52c41ab92965d2ac57 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Mon, 14 Apr 2025 16:30:51 +0200
Subject: [PATCH 067/418] Implemet get_stake_fee rpc

---
 pallets/subtensor/src/rpc_info/stake_info.rs | 14 +++++++++-----
 pallets/subtensor/src/staking/stake_utils.rs |  5 +++--
 2 files changed, 12 insertions(+), 7 deletions(-)

diff --git a/pallets/subtensor/src/rpc_info/stake_info.rs b/pallets/subtensor/src/rpc_info/stake_info.rs
index b77122b1ec..f879856006 100644
--- a/pallets/subtensor/src/rpc_info/stake_info.rs
+++ b/pallets/subtensor/src/rpc_info/stake_info.rs
@@ -1,8 +1,11 @@
-use super::*;
-use frame_support::pallet_prelude::{Decode, Encode};
 extern crate alloc;
+
 use codec::Compact;
+use frame_support::pallet_prelude::{Decode, Encode};
 use substrate_fixed::types::U96F32;
+use subtensor_swap_interface::SwapHandler;
+
+use super::*;
 
 #[freeze_struct("5cfb3c84c3af3116")]
 #[derive(Decode, Encode, PartialEq, Eq, Clone, Debug, TypeInfo)]
@@ -116,11 +119,12 @@ impl<T: Config> Pallet<T> {
 
     pub fn get_stake_fee(
         origin: Option<(T::AccountId, u16)>,
-        origin_coldkey_account: T::AccountId,
+        _origin_coldkey_account: T::AccountId,
         destination: Option<(T::AccountId, u16)>,
-        destination_coldkey_account: T::AccountId,
+        _destination_coldkey_account: T::AccountId,
         amount: u64,
     ) -> u64 {
-        T::SwapInterface::approx_fee_amount(destination.1, amount)
+        let netuid = origin.or(destination).map(|v| v.1).unwrap_or_default();
+        T::SwapInterface::approx_fee_amount(netuid, amount)
     }
 }
diff --git a/pallets/subtensor/src/staking/stake_utils.rs b/pallets/subtensor/src/staking/stake_utils.rs
index 52d6314ff0..8d2e3e98bb 100644
--- a/pallets/subtensor/src/staking/stake_utils.rs
+++ b/pallets/subtensor/src/staking/stake_utils.rs
@@ -628,7 +628,7 @@ impl<T: Config> Pallet<T> {
         tao: u64,
         price_limit: u64,
     ) -> Result<SwapResult, DispatchError> {
-        let swap_result = T::SwapInterface::swap(netuid, OrderType::Buy, tao, price_limit)?;
+        let swap_result = T::SwapInterface::swap(netuid, OrderType::Buy, tao, price_limit, false)?;
 
         // update Alpha reserves.
         SubnetAlphaIn::<T>::set(netuid, swap_result.new_alpha_reserve);
@@ -663,7 +663,8 @@ impl<T: Config> Pallet<T> {
         alpha: u64,
         price_limit: u64,
     ) -> Result<SwapResult, DispatchError> {
-        let swap_result = T::SwapInterface::swap(netuid, OrderType::Sell, alpha, price_limit)?;
+        let swap_result =
+            T::SwapInterface::swap(netuid, OrderType::Sell, alpha, price_limit, false)?;
 
         // Increase Alpha reserves.
         SubnetAlphaIn::<T>::set(netuid, swap_result.new_alpha_reserve);

From 55cff57520f9ba7f776bdff26400e70c8fe7e38f Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Mon, 14 Apr 2025 20:22:36 +0200
Subject: [PATCH 068/418] Configure pallet-subtensor-swap for runtime

---
 Cargo.lock                        |  12 +---
 Cargo.toml                        |   1 -
 pallets/admin-utils/src/lib.rs    |   2 +-
 pallets/subtensor/src/lib.rs      |  20 ++++++
 pallets/swap-interface/Cargo.toml |   3 +-
 pallets/swap-interface/src/lib.rs |  33 +--------
 pallets/swap/src/pallet/impls.rs  |  28 ++++----
 pallets/swap/src/pallet/mod.rs    | 109 +++++++++++++++++++++++++++++-
 pallets/swap/src/position.rs      |  24 ++++++-
 pallets/swap/src/tick.rs          |   4 +-
 pallets/swap/src/weights.rs       |  28 ++++++++
 runtime/Cargo.toml                |   5 ++
 runtime/src/lib.rs                |  21 ++++++
 13 files changed, 225 insertions(+), 65 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 91fef075c8..6da09570b2 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6031,6 +6031,7 @@ dependencies = [
  "pallet-safe-mode",
  "pallet-scheduler",
  "pallet-subtensor",
+ "pallet-subtensor-swap",
  "pallet-sudo",
  "pallet-timestamp",
  "pallet-transaction-payment",
@@ -6063,6 +6064,7 @@ dependencies = [
  "subtensor-macros",
  "subtensor-precompiles",
  "subtensor-runtime-common",
+ "subtensor-swap-interface",
  "tle",
  "w3f-bls",
 ]
@@ -11620,7 +11622,6 @@ dependencies = [
  "frame-support",
  "parity-scale-codec",
  "scale-info",
- "uuid",
 ]
 
 [[package]]
@@ -12485,15 +12486,6 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 
-[[package]]
-name = "uuid"
-version = "1.16.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "458f7a779bf54acc9f347480ac654f68407d3aab21269a6e3c9f922acd9e2da9"
-dependencies = [
- "getrandom 0.3.1",
-]
-
 [[package]]
 name = "valuable"
 version = "0.1.1"
diff --git a/Cargo.toml b/Cargo.toml
index 56aaaa8368..747d3a9c17 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -103,7 +103,6 @@ thiserror = "1.0"
 walkdir = "2"
 approx = "0.5"
 alloy-primitives = { version = "0.8.23", default-features = false }
-uuid = { version = "1.16.0", default-features = false }
 
 subtensor-macros = { path = "support/macros" }
 
diff --git a/pallets/admin-utils/src/lib.rs b/pallets/admin-utils/src/lib.rs
index 19bbbee73b..32c96fb213 100644
--- a/pallets/admin-utils/src/lib.rs
+++ b/pallets/admin-utils/src/lib.rs
@@ -1017,7 +1017,7 @@ pub mod pallet {
             pallet_subtensor::Pallet::<T>::set_nominator_min_required_stake(min_stake);
             if min_stake > prev_min_stake {
                 log::trace!("Clearing small nominations");
-                pallet_subtensor::Pallet::<T>::clear_small_nominations();
+                pallet_subtensor::Pallet::<T>::clear_small_nominations()?;
                 log::trace!("Small nominations cleared");
             }
             Ok(())
diff --git a/pallets/subtensor/src/lib.rs b/pallets/subtensor/src/lib.rs
index e360c307e1..ca0be1c6e7 100644
--- a/pallets/subtensor/src/lib.rs
+++ b/pallets/subtensor/src/lib.rs
@@ -2432,3 +2432,23 @@ impl<T, H, P> CollectiveInterface<T, H, P> for () {
         Ok(true)
     }
 }
+
+impl<T: Config + pallet_balances::Config<Balance = u64>>
+    subtensor_swap_interface::LiquidityDataProvider<T::AccountId> for Pallet<T>
+{
+    fn tao_reserve(netuid: u16) -> u64 {
+        SubnetTAO::<T>::get(netuid)
+    }
+
+    fn alpha_reserve(netuid: u16) -> u64 {
+        SubnetAlphaIn::<T>::get(netuid)
+    }
+
+    fn tao_balance(account_id: &T::AccountId) -> u64 {
+        pallet_balances::Pallet::<T>::free_balance(account_id)
+    }
+
+    fn alpha_balance(netuid: u16, account_id: &T::AccountId) -> u64 {
+        TotalHotkeyAlpha::<T>::get(account_id, netuid)
+    }
+}
diff --git a/pallets/swap-interface/Cargo.toml b/pallets/swap-interface/Cargo.toml
index e401d7e548..6b52737588 100644
--- a/pallets/swap-interface/Cargo.toml
+++ b/pallets/swap-interface/Cargo.toml
@@ -7,11 +7,10 @@ edition.workspace = true
 codec = { workspace = true }
 frame-support = { workspace = true }
 scale-info = { workspace = true }
-uuid = { workspace = true, features = ["v4"] }
 
 [lints]
 workspace = true
 
 [features]
 default = ["std"]
-std = ["codec/std", "frame-support/std", "scale-info/std", "uuid/std"]
+std = ["codec/std", "frame-support/std", "scale-info/std"]
diff --git a/pallets/swap-interface/src/lib.rs b/pallets/swap-interface/src/lib.rs
index dfbd25d271..a3814887cc 100644
--- a/pallets/swap-interface/src/lib.rs
+++ b/pallets/swap-interface/src/lib.rs
@@ -2,7 +2,6 @@
 
 use codec::{Decode, Encode, MaxEncodedLen};
 use frame_support::pallet_prelude::*;
-use uuid::Uuid;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum OrderType {
@@ -26,7 +25,7 @@ pub trait SwapHandler<AccountId> {
 #[derive(Debug, PartialEq)]
 pub struct SwapResult {
     pub amount_paid_out: u64,
-	pub fee_paid: u64,
+    pub fee_paid: u64,
     pub refund: u64,
     // calculated new tao/alpha reserves
     pub new_tao_reserve: u64,
@@ -39,33 +38,3 @@ pub trait LiquidityDataProvider<AccountId> {
     fn tao_balance(account_id: &AccountId) -> u64;
     fn alpha_balance(netuid: u16, account_id: &AccountId) -> u64;
 }
-
-#[derive(
-    Clone, Copy, Decode, Default, Encode, Eq, MaxEncodedLen, PartialEq, RuntimeDebug, TypeInfo,
-)]
-pub struct PositionId([u8; 16]);
-
-impl PositionId {
-    /// Create a new position ID using UUID v4
-    pub fn new() -> Self {
-        Self(Uuid::new_v4().into_bytes())
-    }
-}
-
-impl From<Uuid> for PositionId {
-    fn from(value: Uuid) -> Self {
-        Self(value.into_bytes())
-    }
-}
-
-impl From<PositionId> for Uuid {
-    fn from(value: PositionId) -> Self {
-        Uuid::from_bytes(value.0)
-    }
-}
-
-impl From<[u8; 16]> for PositionId {
-    fn from(value: [u8; 16]) -> Self {
-        Self(value)
-    }
-}
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 3a3db6e349..45e603638a 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -6,12 +6,12 @@ use safe_math::*;
 use sp_arithmetic::helpers_128bit;
 use sp_runtime::traits::AccountIdConversion;
 use substrate_fixed::types::U64F64;
-use subtensor_swap_interface::{LiquidityDataProvider, PositionId, SwapHandler, SwapResult};
+use subtensor_swap_interface::{LiquidityDataProvider, SwapHandler, SwapResult};
 
 use super::pallet::*;
 use crate::{
     NetUid, OrderType, RemoveLiquidityResult, SqrtPrice,
-    position::Position,
+    position::{Position, PositionId},
     tick::{ActiveTickIndexManager, Tick, TickIndex},
 };
 
@@ -711,7 +711,7 @@ impl<T: Config> Pallet<T> {
     /// - [`SwapError::InsufficientBalance`] if the account does not have enough balance.
     /// - [`SwapError::InvalidTickRange`] if `tick_low` is greater than or equal to `tick_high`.
     /// - Other [`SwapError`] variants as applicable.
-    pub fn add_liquidity(
+    pub fn do_add_liquidity(
         netuid: NetUid,
         account_id: &T::AccountId,
         tick_low: TickIndex,
@@ -766,7 +766,7 @@ impl<T: Config> Pallet<T> {
         Self::update_liquidity_if_needed(netuid, tick_low, tick_high, liquidity as i128);
 
         // New position
-        let position_id = PositionId::new();
+        let position_id = PositionId::new::<T>();
         let position = Position {
             id: position_id,
             netuid,
@@ -804,7 +804,7 @@ impl<T: Config> Pallet<T> {
     /// Remove liquidity and credit balances back to account_id
     ///
     /// Account ID and Position ID identify position in the storage map
-    pub fn remove_liquidity(
+    pub fn do_remove_liquidity(
         netuid: NetUid,
         account_id: &T::AccountId,
         position_id: PositionId,
@@ -1284,7 +1284,7 @@ mod tests {
                     let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
 
                     // Add liquidity
-                    let (position_id, tao, alpha) = Pallet::<Test>::add_liquidity(
+                    let (position_id, tao, alpha) = Pallet::<Test>::do_add_liquidity(
                         netuid,
                         &OK_ACCOUNT_ID,
                         tick_low,
@@ -1381,7 +1381,7 @@ mod tests {
 
                 // Add liquidity
                 assert_err!(
-                    Swap::add_liquidity(netuid, &OK_ACCOUNT_ID, tick_low, tick_high, liquidity),
+                    Swap::do_add_liquidity(netuid, &OK_ACCOUNT_ID, tick_low, tick_high, liquidity),
                     Error::<Test>::InvalidTickRange,
                 );
             });
@@ -1413,7 +1413,7 @@ mod tests {
 
                 // Add liquidity
                 assert_err!(
-                    Pallet::<Test>::add_liquidity(
+                    Pallet::<Test>::do_add_liquidity(
                         netuid,
                         &account_id,
                         tick_low,
@@ -1470,7 +1470,7 @@ mod tests {
                 let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
 
                 // Add liquidity
-                let (position_id, _, _) = Pallet::<Test>::add_liquidity(
+                let (position_id, _, _) = Pallet::<Test>::do_add_liquidity(
                     netuid,
                     &OK_ACCOUNT_ID,
                     tick_low,
@@ -1481,7 +1481,7 @@ mod tests {
 
                 // Remove liquidity
                 let remove_result =
-                    Pallet::<Test>::remove_liquidity(netuid, &OK_ACCOUNT_ID, position_id).unwrap();
+                    Pallet::<Test>::do_remove_liquidity(netuid, &OK_ACCOUNT_ID, position_id).unwrap();
                 assert_abs_diff_eq!(remove_result.tao, tao, epsilon = tao / 1000);
                 assert_abs_diff_eq!(remove_result.alpha, alpha, epsilon = alpha / 1000);
                 assert_eq!(remove_result.fee_tao, 0);
@@ -1516,7 +1516,7 @@ mod tests {
             assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
 
             // Add liquidity
-            assert_ok!(Pallet::<Test>::add_liquidity(
+            assert_ok!(Pallet::<Test>::do_add_liquidity(
                 netuid,
                 &OK_ACCOUNT_ID,
                 tick_low,
@@ -1528,7 +1528,7 @@ mod tests {
 
             // Remove liquidity
             assert_err!(
-                Pallet::<Test>::remove_liquidity(netuid, &OK_ACCOUNT_ID, PositionId::new()),
+                Pallet::<Test>::do_remove_liquidity(netuid, &OK_ACCOUNT_ID, PositionId::new::<Test>()),
                 Error::<Test>::LiquidityNotFound,
             );
         });
@@ -1752,7 +1752,7 @@ mod tests {
                         let price_high = price_high_offset + current_price;
                         let tick_low = price_to_tick(price_low);
                         let tick_high = price_to_tick(price_high);
-                        let (_position_id, _tao, _alpha) = Pallet::<Test>::add_liquidity(
+                        let (_position_id, _tao, _alpha) = Pallet::<Test>::do_add_liquidity(
                             netuid,
                             &OK_ACCOUNT_ID,
                             tick_low,
@@ -1985,7 +1985,7 @@ mod tests {
                     let price_high = price_high_offset + current_price;
                     let tick_low = price_to_tick(price_low);
                     let tick_high = price_to_tick(price_high);
-                    let (_position_id, _tao, _alpha) = Pallet::<Test>::add_liquidity(
+                    let (_position_id, _tao, _alpha) = Pallet::<Test>::do_add_liquidity(
                         netuid,
                         &OK_ACCOUNT_ID,
                         tick_low,
diff --git a/pallets/swap/src/pallet/mod.rs b/pallets/swap/src/pallet/mod.rs
index ec0925fabf..c1349f098b 100644
--- a/pallets/swap/src/pallet/mod.rs
+++ b/pallets/swap/src/pallet/mod.rs
@@ -1,11 +1,11 @@
 use frame_support::{PalletId, pallet_prelude::*, traits::Get};
 use frame_system::pallet_prelude::*;
 use substrate_fixed::types::U64F64;
-use subtensor_swap_interface::{LiquidityDataProvider, PositionId};
+use subtensor_swap_interface::LiquidityDataProvider;
 
 use crate::{
     NetUid, SqrtPrice,
-    position::Position,
+    position::{Position, PositionId},
     tick::{LayerLevel, Tick, TickIndex},
     weights::WeightInfo,
 };
@@ -103,6 +103,10 @@ mod pallet {
         OptionQuery,
     >;
 
+    /// Position ID counter.
+    #[pallet::storage]
+    pub type NextPositionId<T> = StorageValue<_, u128, ValueQuery>;
+
     /// Tick index bitmap words storage
     #[pallet::storage]
     pub type TickIndexBitmapWords<T: Config> = StorageNMap<
@@ -121,6 +125,27 @@ mod pallet {
     pub enum Event<T: Config> {
         /// Event emitted when the fee rate has been updated for a subnet
         FeeRateSet { netuid: NetUid, rate: u16 },
+
+        /// Event emitted when liquidity is added
+        LiquidityAdded {
+            account_id: T::AccountId,
+            netuid: NetUid,
+            position_id: PositionId,
+            liquidity: u64,
+            tao: u64,
+            alpha: u64,
+        },
+
+        /// Event emitted when liquidity is removed
+        LiquidityRemoved {
+            account_id: T::AccountId,
+            netuid: NetUid,
+            position_id: PositionId,
+            tao: u64,
+            alpha: u64,
+            fee_tao: u64,
+            fee_alpha: u64,
+        },
     }
 
     #[pallet::error]
@@ -179,6 +204,86 @@ mod pallet {
 
             Ok(())
         }
+
+        /// Add liquidity to a specific price range for a subnet.
+        ///
+        /// Parameters:
+        /// - origin: The origin of the transaction
+        /// - netuid: Subnet ID
+        /// - tick_low: Lower bound of the price range
+        /// - tick_high: Upper bound of the price range
+        /// - liquidity: Amount of liquidity to add
+        ///
+        /// Emits `Event::LiquidityAdded` on success
+        #[pallet::call_index(1)]
+        #[pallet::weight(T::WeightInfo::add_liquidity())]
+        pub fn add_liquidity(
+            origin: OriginFor<T>,
+            netuid: u16,
+            tick_low: i32,
+            tick_high: i32,
+            liquidity: u64,
+        ) -> DispatchResult {
+            let account_id = ensure_signed(origin)?;
+            let netuid = netuid.into();
+            let tick_low_index =
+                TickIndex::new(tick_low).map_err(|_| Error::<T>::InvalidTickRange)?;
+            let tick_high_index =
+                TickIndex::new(tick_high).map_err(|_| Error::<T>::InvalidTickRange)?;
+
+            let (position_id, tao, alpha) = Self::do_add_liquidity(
+                netuid,
+                &account_id,
+                tick_low_index,
+                tick_high_index,
+                liquidity,
+            )?;
+
+            Self::deposit_event(Event::LiquidityAdded {
+                account_id,
+                netuid,
+                position_id,
+                liquidity,
+                tao,
+                alpha,
+            });
+
+            Ok(())
+        }
+
+        /// Remove liquidity from a specific position.
+        ///
+        /// Parameters:
+        /// - origin: The origin of the transaction
+        /// - netuid: Subnet ID
+        /// - position_id: ID of the position to remove
+        ///
+        /// Emits `Event::LiquidityRemoved` on success
+        #[pallet::call_index(2)]
+        #[pallet::weight(T::WeightInfo::remove_liquidity())]
+        pub fn remove_liquidity(
+            origin: OriginFor<T>,
+            netuid: u16,
+            position_id: u128,
+        ) -> DispatchResult {
+            let account_id = ensure_signed(origin)?;
+            let netuid = netuid.into();
+            let position_id = PositionId::from(position_id);
+
+            let result = Self::do_remove_liquidity(netuid, &account_id, position_id)?;
+
+            Self::deposit_event(Event::LiquidityRemoved {
+                account_id,
+                netuid,
+                position_id,
+                tao: result.tao,
+                alpha: result.alpha,
+                fee_tao: result.fee_tao,
+                fee_alpha: result.fee_alpha,
+            });
+
+            Ok(())
+        }
     }
 }
 
diff --git a/pallets/swap/src/position.rs b/pallets/swap/src/position.rs
index 26c1d4d981..c903218f32 100644
--- a/pallets/swap/src/position.rs
+++ b/pallets/swap/src/position.rs
@@ -2,9 +2,8 @@ use codec::{Decode, Encode, MaxEncodedLen};
 use frame_support::pallet_prelude::*;
 use safe_math::*;
 use substrate_fixed::types::U64F64;
-use subtensor_swap_interface::PositionId;
 
-use crate::pallet::{Config, Error, FeeGlobalAlpha, FeeGlobalTao};
+use crate::pallet::{Config, Error, FeeGlobalAlpha, FeeGlobalTao, NextPositionId};
 use crate::tick::TickIndex;
 use crate::{NetUid, SqrtPrice};
 
@@ -122,3 +121,24 @@ impl Position {
         .saturating_to_num::<u64>()
     }
 }
+
+#[derive(
+    Clone, Copy, Decode, Default, Encode, Eq, MaxEncodedLen, PartialEq, RuntimeDebug, TypeInfo,
+)]
+pub struct PositionId(u128);
+
+impl PositionId {
+    /// Create a new position ID
+    pub fn new<T: Config>() -> Self {
+        let new = NextPositionId::<T>::get().saturating_add(1);
+        NextPositionId::<T>::put(new);
+
+        Self(new)
+    }
+}
+
+impl From<u128> for PositionId {
+    fn from(value: u128) -> Self {
+        Self(value)
+    }
+}
diff --git a/pallets/swap/src/tick.rs b/pallets/swap/src/tick.rs
index 6e6d4ab5bf..1e2a48cb7e 100644
--- a/pallets/swap/src/tick.rs
+++ b/pallets/swap/src/tick.rs
@@ -9,6 +9,8 @@ use alloy_primitives::{I256, U256};
 use codec::{Decode, Encode, MaxEncodedLen};
 use frame_support::pallet_prelude::*;
 use safe_math::*;
+use sp_std::vec;
+use sp_std::vec::Vec;
 use substrate_fixed::types::U64F64;
 
 use crate::pallet::{
@@ -1081,7 +1083,7 @@ pub enum TickMathError {
 }
 
 impl fmt::Display for TickMathError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> fmt::Result {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> fmt::Result {
         match self {
 			Self::TickOutOfBounds => f.write_str("The given tick is outside of the minimum/maximum values."),
 			Self::SqrtPriceOutOfBounds =>f.write_str("Second inequality must be < because the price can never reach the price at the max tick"),
diff --git a/pallets/swap/src/weights.rs b/pallets/swap/src/weights.rs
index 19fc4e8722..821727e838 100644
--- a/pallets/swap/src/weights.rs
+++ b/pallets/swap/src/weights.rs
@@ -15,6 +15,8 @@ use sp_std::marker::PhantomData;
 /// Weight functions needed for pallet_subtensor_swap.
 pub trait WeightInfo {
 	fn set_fee_rate() -> Weight;
+	fn add_liquidity() -> Weight;
+	fn remove_liquidity() -> Weight;
 }
 
 /// Default weights for pallet_subtensor_swap.
@@ -26,6 +28,20 @@ impl<T: frame_system::Config> WeightInfo for DefaultWeight<T> {
 			.saturating_add(T::DbWeight::get().reads(1))
 			.saturating_add(T::DbWeight::get().writes(1))
 	}
+	
+	fn add_liquidity() -> Weight {
+		// Conservative weight estimate
+		Weight::from_parts(50_000_000, 0)
+			.saturating_add(T::DbWeight::get().reads(5))
+			.saturating_add(T::DbWeight::get().writes(4))
+	}
+	
+	fn remove_liquidity() -> Weight {
+		// Conservative weight estimate
+		Weight::from_parts(50_000_000, 0)
+			.saturating_add(T::DbWeight::get().reads(4))
+			.saturating_add(T::DbWeight::get().writes(4))
+	}
 }
 
 // For backwards compatibility and tests
@@ -35,4 +51,16 @@ impl WeightInfo for () {
 			.saturating_add(RocksDbWeight::get().reads(1))
 			.saturating_add(RocksDbWeight::get().writes(1))
 	}
+	
+	fn add_liquidity() -> Weight {
+		Weight::from_parts(50_000_000, 0)
+			.saturating_add(RocksDbWeight::get().reads(5))
+			.saturating_add(RocksDbWeight::get().writes(4))
+	}
+	
+	fn remove_liquidity() -> Weight {
+		Weight::from_parts(50_000_000, 0)
+			.saturating_add(RocksDbWeight::get().reads(4))
+			.saturating_add(RocksDbWeight::get().writes(4))
+	}
 }
\ No newline at end of file
diff --git a/runtime/Cargo.toml b/runtime/Cargo.toml
index 67add266a4..a1e26e5ac3 100644
--- a/runtime/Cargo.toml
+++ b/runtime/Cargo.toml
@@ -32,6 +32,8 @@ serde_json = { workspace = true, features = ["alloc"] }
 pallet-aura = { workspace = true }
 pallet-balances = { workspace = true }
 pallet-subtensor = { workspace = true }
+pallet-subtensor-swap = { workspace = true }
+subtensor-swap-interface = { workspace = true }
 frame-support = { workspace = true }
 pallet-grandpa = { workspace = true }
 pallet-insecure-randomness-collective-flip = { workspace = true }
@@ -150,6 +152,8 @@ std = [
 	"frame-system/std",
 	"frame-try-runtime/std",
 	"pallet-subtensor/std",
+	"pallet-subtensor-swap/std",
+	"subtensor-swap-interface/std",
 	"pallet-aura/std",
 	"pallet-balances/std",
 	"pallet-grandpa/std",
@@ -226,6 +230,7 @@ runtime-benchmarks = [
 	"sp-runtime/runtime-benchmarks",
 	"pallet-safe-mode/runtime-benchmarks",
 	"pallet-subtensor/runtime-benchmarks",
+	"pallet-subtensor-swap/runtime-benchmarks",
 	"pallet-collective/runtime-benchmarks",
 	"pallet-membership/runtime-benchmarks",
 	"pallet-proxy/runtime-benchmarks",
diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index 5b87dbf03d..b43d25d108 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -14,6 +14,7 @@ mod migrations;
 use codec::{Compact, Decode, Encode};
 use frame_support::traits::Imbalance;
 use frame_support::{
+    PalletId,
     dispatch::DispatchResultWithPostInfo,
     genesis_builder_helper::{build_state, get_preset},
     pallet_prelude::Get,
@@ -1114,6 +1115,25 @@ impl pallet_subtensor::Config for Runtime {
     type InitialDissolveNetworkScheduleDuration = InitialDissolveNetworkScheduleDuration;
     type InitialEmaPriceHalvingPeriod = InitialEmaPriceHalvingPeriod;
     type DurationOfStartCall = DurationOfStartCall;
+    type SwapInterface = Swap;
+}
+
+parameter_types! {
+    pub const SwapProtocolId: PalletId = PalletId(*b"ten/swap");
+    pub const SwapMaxFeeRate: u16 = 10000; // 15.26%
+    pub const SwapMaxPositions: u32 = 100;
+    pub const SwapMinimumLiquidity: u64 = 1_000;
+}
+
+impl pallet_subtensor_swap::Config for Runtime {
+    type RuntimeEvent = RuntimeEvent;
+    type AdminOrigin = EnsureRoot<AccountId>;
+    type LiquidityDataProvider = SubtensorModule;
+    type ProtocolId = SwapProtocolId;
+    type MaxFeeRate = SwapMaxFeeRate;
+    type MaxPositions = SwapMaxPositions;
+    type MinimumLiquidity = SwapMinimumLiquidity;
+    type WeightInfo = ();
 }
 
 use sp_runtime::BoundedVec;
@@ -1432,6 +1452,7 @@ construct_runtime!(
         BaseFee: pallet_base_fee = 25,
 
         Drand: pallet_drand = 26,
+        Swap: pallet_subtensor_swap = 27,
     }
 );
 

From cf236c31527bdd3d1a6e3dfc47cbcc67c6f1a884 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Tue, 15 Apr 2025 17:47:15 +0200
Subject: [PATCH 069/418] Fix free-struct and admin-utils tests

---
 Cargo.lock                            |  2 ++
 pallets/admin-utils/Cargo.toml        |  2 ++
 pallets/admin-utils/src/tests/mock.rs |  2 +-
 pallets/swap-interface/src/lib.rs     |  1 -
 pallets/swap/Cargo.toml               | 37 ++++++++++++++-------------
 pallets/swap/src/lib.rs               |  2 ++
 pallets/swap/src/mock.rs              |  4 +--
 pallets/swap/src/position.rs          |  3 +++
 pallets/swap/src/tick.rs              |  4 +++
 9 files changed, 35 insertions(+), 22 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 6da09570b2..78de54f3a4 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6380,6 +6380,7 @@ dependencies = [
  "pallet-grandpa",
  "pallet-scheduler",
  "pallet-subtensor",
+ "pallet-subtensor-swap",
  "parity-scale-codec",
  "scale-info",
  "sp-consensus-aura",
@@ -6898,6 +6899,7 @@ dependencies = [
  "sp-runtime",
  "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409)",
  "substrate-fixed",
+ "subtensor-macros",
  "subtensor-swap-interface",
 ]
 
diff --git a/pallets/admin-utils/Cargo.toml b/pallets/admin-utils/Cargo.toml
index b3c1410cca..c45f2648d7 100644
--- a/pallets/admin-utils/Cargo.toml
+++ b/pallets/admin-utils/Cargo.toml
@@ -42,6 +42,7 @@ pallet-balances = { workspace = true, features = ["std"] }
 pallet-scheduler = { workspace = true }
 pallet-grandpa = { workspace = true }
 sp-std = { workspace = true }
+pallet-subtensor-swap = { workspace = true }
 
 [features]
 default = ["std"]
@@ -67,6 +68,7 @@ std = [
 	"sp-tracing/std",
 	"sp-weights/std",
 	"substrate-fixed/std",
+	"pallet-subtensor-swap/std",
 ]
 runtime-benchmarks = [
 	"frame-benchmarking/runtime-benchmarks",
diff --git a/pallets/admin-utils/src/tests/mock.rs b/pallets/admin-utils/src/tests/mock.rs
index d18ecac12d..c5ff6acda7 100644
--- a/pallets/admin-utils/src/tests/mock.rs
+++ b/pallets/admin-utils/src/tests/mock.rs
@@ -1,7 +1,7 @@
 #![allow(clippy::arithmetic_side_effects, clippy::unwrap_used)]
 
 use frame_support::{
-    assert_ok, derive_impl, parameter_types,
+    PalletId, assert_ok, derive_impl, parameter_types,
     traits::{Everything, Hooks, PrivilegeCmp},
     weights,
 };
diff --git a/pallets/swap-interface/src/lib.rs b/pallets/swap-interface/src/lib.rs
index a3814887cc..b6602c5c98 100644
--- a/pallets/swap-interface/src/lib.rs
+++ b/pallets/swap-interface/src/lib.rs
@@ -1,6 +1,5 @@
 #![cfg_attr(not(feature = "std"), no_std)]
 
-use codec::{Decode, Encode, MaxEncodedLen};
 use frame_support::pallet_prelude::*;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
diff --git a/pallets/swap/Cargo.toml b/pallets/swap/Cargo.toml
index b99619ecc4..7be8c6aa6f 100644
--- a/pallets/swap/Cargo.toml
+++ b/pallets/swap/Cargo.toml
@@ -21,6 +21,7 @@ sp-std = { workspace = true }
 substrate-fixed = { workspace = true }
 
 subtensor-swap-interface = { workspace = true }
+subtensor-macros = { workspace = true }
 
 [lints]
 workspace = true
@@ -28,24 +29,24 @@ workspace = true
 [features]
 default = ["std"]
 std = [
-    "alloy-primitives/std",
-    "codec/std",
-    "frame-benchmarking/std",
-    "frame-support/std",
-    "frame-system/std",
-    "subtensor-swap-interface/std",
-    "safe-math/std",
-    "scale-info/std",
-    "serde/std",
-    "sp-arithmetic/std",
-    "sp-core/std",
-    "sp-io/std",
-    "sp-runtime/std",
-    "sp-std/std",
-    "substrate-fixed/std",
+	"alloy-primitives/std",
+	"codec/std",
+	"frame-benchmarking/std",
+	"frame-support/std",
+	"frame-system/std",
+	"safe-math/std",
+	"scale-info/std",
+	"serde/std",
+	"sp-arithmetic/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+	"substrate-fixed/std",
+	"subtensor-swap-interface/std",
 ]
 runtime-benchmarks = [
-    "frame-benchmarking/runtime-benchmarks",
-    "frame-support/runtime-benchmarks",
-    "frame-system/runtime-benchmarks",
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
 ]
diff --git a/pallets/swap/src/lib.rs b/pallets/swap/src/lib.rs
index e25daae60d..320a906d05 100644
--- a/pallets/swap/src/lib.rs
+++ b/pallets/swap/src/lib.rs
@@ -4,6 +4,7 @@ use codec::{Decode, Encode, MaxEncodedLen};
 use frame_support::pallet_prelude::*;
 use subtensor_swap_interface::OrderType;
 use substrate_fixed::types::U64F64;
+use subtensor_macros::freeze_struct;
 
 pub mod pallet;
 mod position;
@@ -28,6 +29,7 @@ pub struct RemoveLiquidityResult {
     fee_alpha: u64,
 }
 
+#[freeze_struct("2a62496e31bbcddc")]
 #[derive(
     Clone, Copy, Decode, Default, Encode, Eq, MaxEncodedLen, PartialEq, RuntimeDebug, TypeInfo,
 )]
diff --git a/pallets/swap/src/mock.rs b/pallets/swap/src/mock.rs
index b9bac41fd2..b925d9258d 100644
--- a/pallets/swap/src/mock.rs
+++ b/pallets/swap/src/mock.rs
@@ -13,8 +13,8 @@ use subtensor_swap_interface::LiquidityDataProvider;
 
 construct_runtime!(
     pub enum Test {
-        System: frame_system,
-        Swap: crate::pallet,
+        System: frame_system = 0,
+        Swap: crate::pallet = 1,
     }
 );
 
diff --git a/pallets/swap/src/position.rs b/pallets/swap/src/position.rs
index c903218f32..210f1533e5 100644
--- a/pallets/swap/src/position.rs
+++ b/pallets/swap/src/position.rs
@@ -2,6 +2,7 @@ use codec::{Decode, Encode, MaxEncodedLen};
 use frame_support::pallet_prelude::*;
 use safe_math::*;
 use substrate_fixed::types::U64F64;
+use subtensor_macros::freeze_struct;
 
 use crate::pallet::{Config, Error, FeeGlobalAlpha, FeeGlobalTao, NextPositionId};
 use crate::tick::TickIndex;
@@ -17,6 +18,7 @@ use crate::{NetUid, SqrtPrice};
 /// liquidity - position liquidity
 /// fees_tao - fees accrued by the position in quote currency (TAO)
 /// fees_alpha - fees accrued by the position in base currency (Alpha)
+#[freeze_struct("fef7b4de3c0df37d")]
 #[derive(Clone, Encode, Decode, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen, Default)]
 pub struct Position {
     pub id: PositionId,
@@ -122,6 +124,7 @@ impl Position {
     }
 }
 
+#[freeze_struct("1f02550d787d80da")]
 #[derive(
     Clone, Copy, Decode, Default, Encode, Eq, MaxEncodedLen, PartialEq, RuntimeDebug, TypeInfo,
 )]
diff --git a/pallets/swap/src/tick.rs b/pallets/swap/src/tick.rs
index 1e2a48cb7e..a13a8051eb 100644
--- a/pallets/swap/src/tick.rs
+++ b/pallets/swap/src/tick.rs
@@ -12,6 +12,7 @@ use safe_math::*;
 use sp_std::vec;
 use sp_std::vec::Vec;
 use substrate_fixed::types::U64F64;
+use subtensor_macros::freeze_struct;
 
 use crate::pallet::{
     AlphaSqrtPrice, Config, FeeGlobalAlpha, FeeGlobalTao, TickIndexBitmapWords, Ticks,
@@ -76,6 +77,7 @@ const TICK_HIGH: I256 = I256::from_raw(U256::from_limbs([
 ///  - Net liquidity
 ///  - Gross liquidity
 ///  - Fees (above global) in both currencies
+#[freeze_struct("a73c75ea32eb04ed")]
 #[derive(Debug, Default, Clone, Encode, Decode, TypeInfo, MaxEncodedLen, PartialEq, Eq)]
 pub struct Tick {
     pub liquidity_net: i128,
@@ -91,6 +93,7 @@ impl Tick {
 }
 
 /// Struct representing a tick index
+#[freeze_struct("cdd46795662dcc43")]
 #[derive(
     Debug,
     Default,
@@ -683,6 +686,7 @@ pub enum LayerLevel {
     Bottom = 2,
 }
 
+#[freeze_struct("183175773f3f92e0")]
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Encode, Decode, TypeInfo, MaxEncodedLen)]
 struct BitmapLayer {
     word: u32,

From 86dd44f809fd515d51fd7e21f7cda10ff87ed3fa Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Tue, 15 Apr 2025 18:01:06 +0200
Subject: [PATCH 070/418] Fix subtensor-module mock

---
 pallets/subtensor/src/tests/mock.rs | 18 ------------------
 1 file changed, 18 deletions(-)

diff --git a/pallets/subtensor/src/tests/mock.rs b/pallets/subtensor/src/tests/mock.rs
index c4fb5a5f29..1fb4d06d01 100644
--- a/pallets/subtensor/src/tests/mock.rs
+++ b/pallets/subtensor/src/tests/mock.rs
@@ -417,24 +417,6 @@ impl crate::Config for Test {
     type SwapInterface = Swap;
 }
 
-impl LiquidityDataProvider<AccountId> for SubtensorModule {
-    fn tao_reserve(netuid: u16) -> u64 {
-        SubnetTAO::<Test>::get(netuid)
-    }
-
-    fn alpha_reserve(netuid: u16) -> u64 {
-        SubnetAlphaIn::<Test>::get(netuid)
-    }
-
-    fn tao_balance(account_id: &AccountId) -> u64 {
-        Balances::free_balance(account_id)
-    }
-
-    fn alpha_balance(netuid: u16, account_id: &AccountId) -> u64 {
-        TotalHotkeyAlpha::<Test>::get(account_id, netuid)
-    }
-}
-
 // Swap-related parameter types
 parameter_types! {
     pub const SwapProtocolId: PalletId = PalletId(*b"ten/swap");

From 748727d2991164f130dc30b7f600c603f5440573 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Tue, 15 Apr 2025 16:38:13 -0400
Subject: [PATCH 071/418] Fix balance updates for add/remove liquidity

---
 Cargo.lock                          |   1 +
 pallets/subtensor/src/lib.rs        |   4 +-
 pallets/subtensor/src/tests/mock.rs |   4 +-
 pallets/swap-interface/src/lib.rs   |   2 +-
 pallets/swap/Cargo.toml             |   2 +
 pallets/swap/src/mock.rs            |  23 +++--
 pallets/swap/src/pallet/impls.rs    | 151 ++++++++++++++++++----------
 pallets/swap/src/pallet/mod.rs      |  74 +++++++++++---
 8 files changed, 183 insertions(+), 78 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 6da09570b2..1d7a62bf25 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6888,6 +6888,7 @@ dependencies = [
  "frame-benchmarking",
  "frame-support",
  "frame-system",
+ "pallet-subtensor",
  "parity-scale-codec",
  "safe-math",
  "scale-info",
diff --git a/pallets/subtensor/src/lib.rs b/pallets/subtensor/src/lib.rs
index ca0be1c6e7..5fdb82a92c 100644
--- a/pallets/subtensor/src/lib.rs
+++ b/pallets/subtensor/src/lib.rs
@@ -2448,7 +2448,7 @@ impl<T: Config + pallet_balances::Config<Balance = u64>>
         pallet_balances::Pallet::<T>::free_balance(account_id)
     }
 
-    fn alpha_balance(netuid: u16, account_id: &T::AccountId) -> u64 {
-        TotalHotkeyAlpha::<T>::get(account_id, netuid)
+    fn alpha_balance(netuid: u16, coldkey: &T::AccountId, hotkey: &T::AccountId) -> u64 {
+        Self::get_stake_for_hotkey_and_coldkey_on_subnet(hotkey, coldkey, netuid)
     }
 }
diff --git a/pallets/subtensor/src/tests/mock.rs b/pallets/subtensor/src/tests/mock.rs
index c4fb5a5f29..177a9dbc6e 100644
--- a/pallets/subtensor/src/tests/mock.rs
+++ b/pallets/subtensor/src/tests/mock.rs
@@ -430,8 +430,8 @@ impl LiquidityDataProvider<AccountId> for SubtensorModule {
         Balances::free_balance(account_id)
     }
 
-    fn alpha_balance(netuid: u16, account_id: &AccountId) -> u64 {
-        TotalHotkeyAlpha::<Test>::get(account_id, netuid)
+    fn alpha_balance(netuid: u16, coldkey: &AccountId, hotkey: &AccountId) -> u64 {
+        SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(hotkey, coldkey, netuid)
     }
 }
 
diff --git a/pallets/swap-interface/src/lib.rs b/pallets/swap-interface/src/lib.rs
index a3814887cc..d155536da3 100644
--- a/pallets/swap-interface/src/lib.rs
+++ b/pallets/swap-interface/src/lib.rs
@@ -36,5 +36,5 @@ pub trait LiquidityDataProvider<AccountId> {
     fn tao_reserve(netuid: u16) -> u64;
     fn alpha_reserve(netuid: u16) -> u64;
     fn tao_balance(account_id: &AccountId) -> u64;
-    fn alpha_balance(netuid: u16, account_id: &AccountId) -> u64;
+    fn alpha_balance(netuid: u16, coldkey_account_id: &AccountId, hotkey_account_id: &AccountId) -> u64;
 }
diff --git a/pallets/swap/Cargo.toml b/pallets/swap/Cargo.toml
index b99619ecc4..d1439db916 100644
--- a/pallets/swap/Cargo.toml
+++ b/pallets/swap/Cargo.toml
@@ -21,6 +21,7 @@ sp-std = { workspace = true }
 substrate-fixed = { workspace = true }
 
 subtensor-swap-interface = { workspace = true }
+pallet-subtensor = { version = "4.0.0-dev", default-features = false, path = "../subtensor" }
 
 [lints]
 workspace = true
@@ -33,6 +34,7 @@ std = [
     "frame-benchmarking/std",
     "frame-support/std",
     "frame-system/std",
+    "pallet-subtensor/std",
     "subtensor-swap-interface/std",
     "safe-math/std",
     "scale-info/std",
diff --git a/pallets/swap/src/mock.rs b/pallets/swap/src/mock.rs
index b9bac41fd2..248c70a7bc 100644
--- a/pallets/swap/src/mock.rs
+++ b/pallets/swap/src/mock.rs
@@ -20,7 +20,8 @@ construct_runtime!(
 
 pub type Block = frame_system::mocking::MockBlock<Test>;
 pub type AccountId = u32;
-pub const OK_ACCOUNT_ID: AccountId = 1;
+pub const OK_COLDKEY_ACCOUNT_ID: AccountId = 1;
+pub const OK_HOTKEY_ACCOUNT_ID: AccountId = 1000;
 
 parameter_types! {
     pub const BlockHashCount: u64 = 250;
@@ -70,24 +71,30 @@ parameter_types! {
 pub struct MockLiquidityProvider;
 
 impl LiquidityDataProvider<AccountId> for MockLiquidityProvider {
-    fn tao_reserve(_: u16) -> u64 {
-        1_000_000_000_000
+    fn tao_reserve(netuid: u16) -> u64 {
+        match netuid {
+            123 => 1_000,
+            _ => 1_000_000_000_000
+        }
     }
 
-    fn alpha_reserve(_: u16) -> u64 {
-        4_000_000_000_000
+    fn alpha_reserve(netuid: u16) -> u64 {
+        match netuid {
+            123 => 1,
+            _ => 4_000_000_000_000
+        }
     }
 
     fn tao_balance(account_id: &AccountId) -> u64 {
-        if *account_id == OK_ACCOUNT_ID {
+        if *account_id == OK_COLDKEY_ACCOUNT_ID {
             100_000_000_000_000
         } else {
             1_000_000_000
         }
     }
 
-    fn alpha_balance(_: u16, account_id: &AccountId) -> u64 {
-        if *account_id == OK_ACCOUNT_ID {
+    fn alpha_balance(_: u16, coldkey_account_id: &AccountId, hotkey_account_id: &AccountId) -> u64 {
+        if (*coldkey_account_id == OK_COLDKEY_ACCOUNT_ID) && (*hotkey_account_id == OK_HOTKEY_ACCOUNT_ID) {
             100_000_000_000_000
         } else {
             1_000_000_000
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 45e603638a..2b7850e402 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -18,7 +18,7 @@ use crate::{
 const MAX_SWAP_ITERATIONS: u16 = 1000;
 
 /// A struct representing a single swap step with all its parameters and state
-struct SwapStep<T: Config> {
+struct SwapStep<T: frame_system::Config> {
     // Input parameters
     netuid: NetUid,
     order_type: OrderType,
@@ -697,7 +697,8 @@ impl<T: Config> Pallet<T> {
     /// - If swap V3 was not initialized before, updates the value in storage.
     ///
     /// ### Parameters:
-    /// - `account_id`: A reference to the account that is providing liquidity.
+    /// - `coldkey_account_id`: A reference to the account coldkey that is providing liquidity.
+    /// - `hotkey_account_id`: A reference to the account hotkey that is providing liquidity.
     /// - `tick_low`: The lower bound of the price tick range.
     /// - `tick_high`: The upper bound of the price tick range.
     /// - `liquidity`: The amount of liquidity to be added.
@@ -713,18 +714,19 @@ impl<T: Config> Pallet<T> {
     /// - Other [`SwapError`] variants as applicable.
     pub fn do_add_liquidity(
         netuid: NetUid,
-        account_id: &T::AccountId,
+        coldkey_account_id: &T::AccountId,
+        hotkey_account_id: &T::AccountId,
         tick_low: TickIndex,
         tick_high: TickIndex,
         liquidity: u64,
     ) -> Result<(PositionId, u64, u64), Error<T>> {
         let (position, tao, alpha) =
-            Self::add_liquidity_not_insert(netuid, account_id, tick_low, tick_high, liquidity)?;
+            Self::add_liquidity_not_insert(netuid, coldkey_account_id, tick_low, tick_high, liquidity)?;
         let position_id = position.id;
 
         ensure!(
-            T::LiquidityDataProvider::tao_balance(account_id) >= tao
-                && T::LiquidityDataProvider::alpha_balance(netuid.into(), account_id) >= alpha,
+            T::LiquidityDataProvider::tao_balance(coldkey_account_id) >= tao
+                && T::LiquidityDataProvider::alpha_balance(netuid.into(), coldkey_account_id, hotkey_account_id) >= alpha,
             Error::<T>::InsufficientBalance
         );
 
@@ -734,7 +736,7 @@ impl<T: Config> Pallet<T> {
             Error::<T>::InvalidLiquidityValue
         );
 
-        Positions::<T>::insert(&(netuid, account_id, position.id), position);
+        Positions::<T>::insert(&(netuid, coldkey_account_id, position.id), position);
 
         Ok((position_id, tao, alpha))
     }
@@ -745,13 +747,13 @@ impl<T: Config> Pallet<T> {
     // the public interface is [`Self::add_liquidity`]
     fn add_liquidity_not_insert(
         netuid: NetUid,
-        account_id: &T::AccountId,
+        coldkey_account_id: &T::AccountId,
         tick_low: TickIndex,
         tick_high: TickIndex,
         liquidity: u64,
     ) -> Result<(Position, u64, u64), Error<T>> {
         ensure!(
-            Self::count_positions(netuid, account_id) <= T::MaxPositions::get() as usize,
+            Self::count_positions(netuid, coldkey_account_id) <= T::MaxPositions::get() as usize,
             Error::<T>::MaxPositionsExceeded
         );
 
@@ -787,7 +789,7 @@ impl<T: Config> Pallet<T> {
         // if !protocol {
         //     let current_price = self.state_ops.get_alpha_sqrt_price();
         //     let (tao, alpha) = position.to_token_amounts(current_price)?;
-        //     self.state_ops.withdraw_balances(account_id, tao, alpha)?;
+        //     self.state_ops.withdraw_balances(coldkey_account_id, tao, alpha)?;
 
         //     // Update reserves
         //     let new_tao_reserve = self.state_ops.get_tao_reserve().saturating_add(tao);
@@ -801,15 +803,15 @@ impl<T: Config> Pallet<T> {
         Ok((position, tao, alpha))
     }
 
-    /// Remove liquidity and credit balances back to account_id
+    /// Remove liquidity and credit balances back to (coldkey_account_id, hotkey_account_id) stake
     ///
     /// Account ID and Position ID identify position in the storage map
     pub fn do_remove_liquidity(
         netuid: NetUid,
-        account_id: &T::AccountId,
+        coldkey_account_id: &T::AccountId,
         position_id: PositionId,
     ) -> Result<RemoveLiquidityResult, Error<T>> {
-        let Some(mut position) = Positions::<T>::get((netuid, account_id, position_id)) else {
+        let Some(mut position) = Positions::<T>::get((netuid, coldkey_account_id, position_id)) else {
             return Err(Error::<T>::LiquidityNotFound);
         };
 
@@ -831,7 +833,7 @@ impl<T: Config> Pallet<T> {
         );
 
         // Remove user position
-        Positions::<T>::remove((netuid, account_id, position_id));
+        Positions::<T>::remove((netuid, coldkey_account_id, position_id));
 
         {
             // TODO we move this logic to the outside depender to prevent mutating its state
@@ -859,12 +861,13 @@ impl<T: Config> Pallet<T> {
 
     fn modify_position(
         netuid: NetUid,
-        account_id: &T::AccountId,
+        coldkey_account_id: &T::AccountId,
+        hotkey_account_id: &T::AccountId,
         position_id: PositionId,
         liquidity_delta: i64,
     ) -> Result<RemoveLiquidityResult, Error<T>> {
         // Find the position
-        let Some(mut position) = Positions::<T>::get((netuid, account_id, position_id)) else {
+        let Some(mut position) = Positions::<T>::get((netuid, coldkey_account_id, position_id)) else {
             return Err(Error::<T>::LiquidityNotFound);
         };
 
@@ -910,8 +913,8 @@ impl<T: Config> Pallet<T> {
         if liquidity_delta > 0 {
             // Check that user has enough balances
             ensure!(
-                T::LiquidityDataProvider::tao_balance(account_id) >= tao
-                    && T::LiquidityDataProvider::alpha_balance(netuid.into(), account_id) >= alpha,
+                T::LiquidityDataProvider::tao_balance(coldkey_account_id) >= tao
+                    && T::LiquidityDataProvider::alpha_balance(netuid.into(), coldkey_account_id, hotkey_account_id) >= alpha,
                 Error::<T>::InsufficientBalance
             );
         } else {
@@ -948,7 +951,7 @@ impl<T: Config> Pallet<T> {
             // Remove liquidity from user position
             position.liquidity = position.liquidity.saturating_sub(delta_liquidity_abs);
         }
-        Positions::<T>::insert(&(netuid, account_id, position.id), position);
+        Positions::<T>::insert(&(netuid, coldkey_account_id, position.id), position);
 
         // TODO: Withdraw balances and update pool reserves
 
@@ -1125,6 +1128,7 @@ pub enum SwapStepAction {
     StopIn,
 }
 
+// cargo test --package pallet-subtensor-swap --lib -- pallet::impls::tests --show-output
 #[cfg(test)]
 mod tests {
     use approx::assert_abs_diff_eq;
@@ -1286,7 +1290,8 @@ mod tests {
                     // Add liquidity
                     let (position_id, tao, alpha) = Pallet::<Test>::do_add_liquidity(
                         netuid,
-                        &OK_ACCOUNT_ID,
+                        &OK_COLDKEY_ACCOUNT_ID,
+                        &OK_HOTKEY_ACCOUNT_ID,
                         tick_low,
                         tick_high,
                         liquidity,
@@ -1322,10 +1327,10 @@ mod tests {
                     );
 
                     // Liquidity position at correct ticks
-                    assert_eq!(Pallet::<Test>::count_positions(netuid, &OK_ACCOUNT_ID), 1);
+                    assert_eq!(Pallet::<Test>::count_positions(netuid, &OK_COLDKEY_ACCOUNT_ID), 1);
 
                     let position =
-                        Positions::<Test>::get(&(netuid, OK_ACCOUNT_ID, position_id)).unwrap();
+                        Positions::<Test>::get(&(netuid, OK_COLDKEY_ACCOUNT_ID, position_id)).unwrap();
                     assert_eq!(position.liquidity, liquidity);
                     assert_eq!(position.tick_low, tick_low);
                     assert_eq!(position.tick_high, tick_high);
@@ -1381,7 +1386,7 @@ mod tests {
 
                 // Add liquidity
                 assert_err!(
-                    Swap::do_add_liquidity(netuid, &OK_ACCOUNT_ID, tick_low, tick_high, liquidity),
+                    Swap::do_add_liquidity(netuid, &OK_COLDKEY_ACCOUNT_ID, &OK_HOTKEY_ACCOUNT_ID, tick_low, tick_high, liquidity),
                     Error::<Test>::InvalidTickRange,
                 );
             });
@@ -1391,7 +1396,8 @@ mod tests {
     #[test]
     fn test_add_liquidity_over_balance() {
         new_test_ext().execute_with(|| {
-            let account_id = 2;
+            let coldkey_account_id = 2;
+            let hotkey_account_id = 3;
 
             [
                 // Lower than price (not enough alpha)
@@ -1415,7 +1421,8 @@ mod tests {
                 assert_err!(
                     Pallet::<Test>::do_add_liquidity(
                         netuid,
-                        &account_id,
+                        &coldkey_account_id,
+                        &hotkey_account_id,
                         tick_low,
                         tick_high,
                         liquidity
@@ -1439,24 +1446,24 @@ mod tests {
             //   - liquidity is expressed in RAO units
             // Test case is (price_low, price_high, liquidity, tao, alpha)
             [
-                // Repeat the protocol liquidity at maximum range: Expect all the same values
-                (
-                    min_price,
-                    max_price,
-                    2_000_000_000_u64,
-                    1_000_000_000_u64,
-                    4_000_000_000_u64,
-                ),
-                // Repeat the protocol liquidity at current to max range: Expect the same alpha
-                (0.25, max_price, 2_000_000_000_u64, 0, 4_000_000_000),
+                // // Repeat the protocol liquidity at maximum range: Expect all the same values
+                // (
+                //     min_price,
+                //     max_price,
+                //     2_000_000_000_u64,
+                //     1_000_000_000_u64,
+                //     4_000_000_000_u64,
+                // ),
+                // // Repeat the protocol liquidity at current to max range: Expect the same alpha
+                // (0.25, max_price, 2_000_000_000_u64, 0, 4_000_000_000),
                 // Repeat the protocol liquidity at min to current range: Expect all the same tao
                 (min_price, 0.24999, 2_000_000_000_u64, 1_000_000_000, 0),
-                // Half to double price - just some sane wothdraw amounts
-                (0.125, 0.5, 2_000_000_000_u64, 293_000_000, 1_171_000_000),
-                // Both below price - tao is non-zero, alpha is zero
-                (0.12, 0.13, 2_000_000_000_u64, 28_270_000, 0),
-                // Both above price - tao is zero, alpha is non-zero
-                (0.3, 0.4, 2_000_000_000_u64, 0, 489_200_000),
+                // // Half to double price - just some sane wothdraw amounts
+                // (0.125, 0.5, 2_000_000_000_u64, 293_000_000, 1_171_000_000),
+                // // Both below price - tao is non-zero, alpha is zero
+                // (0.12, 0.13, 2_000_000_000_u64, 28_270_000, 0),
+                // // Both above price - tao is zero, alpha is non-zero
+                // (0.3, 0.4, 2_000_000_000_u64, 0, 489_200_000),
             ]
             .into_iter()
             .enumerate()
@@ -1472,7 +1479,8 @@ mod tests {
                 // Add liquidity
                 let (position_id, _, _) = Pallet::<Test>::do_add_liquidity(
                     netuid,
-                    &OK_ACCOUNT_ID,
+                    &OK_COLDKEY_ACCOUNT_ID,
+                    &OK_HOTKEY_ACCOUNT_ID,
                     tick_low,
                     tick_high,
                     liquidity,
@@ -1481,15 +1489,15 @@ mod tests {
 
                 // Remove liquidity
                 let remove_result =
-                    Pallet::<Test>::do_remove_liquidity(netuid, &OK_ACCOUNT_ID, position_id).unwrap();
+                    Pallet::<Test>::do_remove_liquidity(netuid, &OK_COLDKEY_ACCOUNT_ID, position_id).unwrap();
                 assert_abs_diff_eq!(remove_result.tao, tao, epsilon = tao / 1000);
                 assert_abs_diff_eq!(remove_result.alpha, alpha, epsilon = alpha / 1000);
                 assert_eq!(remove_result.fee_tao, 0);
                 assert_eq!(remove_result.fee_alpha, 0);
 
                 // Liquidity position is removed
-                assert_eq!(Pallet::<Test>::count_positions(netuid, &OK_ACCOUNT_ID), 0);
-                assert!(Positions::<Test>::get((netuid, OK_ACCOUNT_ID, position_id)).is_none());
+                assert_eq!(Pallet::<Test>::count_positions(netuid, &OK_COLDKEY_ACCOUNT_ID), 0);
+                assert!(Positions::<Test>::get((netuid, OK_COLDKEY_ACCOUNT_ID, position_id)).is_none());
 
                 // Current liquidity is updated (back where it was)
                 assert_eq!(CurrentLiquidity::<Test>::get(netuid), liquidity_before);
@@ -1518,17 +1526,18 @@ mod tests {
             // Add liquidity
             assert_ok!(Pallet::<Test>::do_add_liquidity(
                 netuid,
-                &OK_ACCOUNT_ID,
+                &OK_COLDKEY_ACCOUNT_ID,
+                &OK_HOTKEY_ACCOUNT_ID,
                 tick_low,
                 tick_high,
                 liquidity,
             ));
 
-            assert!(Pallet::<Test>::count_positions(netuid, &OK_ACCOUNT_ID) > 0);
+            assert!(Pallet::<Test>::count_positions(netuid, &OK_COLDKEY_ACCOUNT_ID) > 0);
 
             // Remove liquidity
             assert_err!(
-                Pallet::<Test>::do_remove_liquidity(netuid, &OK_ACCOUNT_ID, PositionId::new::<Test>()),
+                Pallet::<Test>::do_remove_liquidity(netuid, &OK_COLDKEY_ACCOUNT_ID, PositionId::new::<Test>()),
                 Error::<Test>::LiquidityNotFound,
             );
         });
@@ -1754,7 +1763,8 @@ mod tests {
                         let tick_high = price_to_tick(price_high);
                         let (_position_id, _tao, _alpha) = Pallet::<Test>::do_add_liquidity(
                             netuid,
-                            &OK_ACCOUNT_ID,
+                            &OK_COLDKEY_ACCOUNT_ID,
+                            &OK_HOTKEY_ACCOUNT_ID,
                             tick_low,
                             tick_high,
                             position_liquidity,
@@ -1762,7 +1772,7 @@ mod tests {
                         .unwrap();
 
                         // Liquidity position at correct ticks
-                        assert_eq!(Pallet::<Test>::count_positions(netuid, &OK_ACCOUNT_ID), 1);
+                        assert_eq!(Pallet::<Test>::count_positions(netuid, &OK_COLDKEY_ACCOUNT_ID), 1);
 
                         // Get tick infos before the swap
                         let tick_low_info_before =
@@ -1906,7 +1916,7 @@ mod tests {
 
                         // Liquidity position should not be updated
                         let positions =
-                            Positions::<Test>::iter_prefix_values((netuid, OK_ACCOUNT_ID))
+                            Positions::<Test>::iter_prefix_values((netuid, OK_COLDKEY_ACCOUNT_ID))
                                 .collect::<Vec<_>>();
                         let position = positions.first().unwrap();
 
@@ -1987,7 +1997,8 @@ mod tests {
                     let tick_high = price_to_tick(price_high);
                     let (_position_id, _tao, _alpha) = Pallet::<Test>::do_add_liquidity(
                         netuid,
-                        &OK_ACCOUNT_ID,
+                        &OK_COLDKEY_ACCOUNT_ID,
+                        &OK_HOTKEY_ACCOUNT_ID,
                         tick_low,
                         tick_high,
                         position_liquidity,
@@ -2107,4 +2118,40 @@ mod tests {
             )
         });
     }
+
+    // cargo test --package pallet-subtensor-swap --lib -- pallet::impls::tests::test_swap_precision_edge_case --exact --show-output
+    #[test]
+    fn test_swap_precision_edge_case() {
+        new_test_ext().execute_with(|| {
+            let netuid = NetUid::from(123); // 123 is netuid with low edge case liquidity
+            let order_type = OrderType::Sell;
+            let liquidity = 1000000000000000000;
+            let tick_low = TickIndex::MIN;
+            let tick_high = TickIndex::MAX;
+
+            let sqrt_limit_price: SqrtPrice = tick_low
+                .try_to_sqrt_price().unwrap();
+
+            // Setup swap
+            assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
+
+            // Get tick infos before the swap
+            let tick_low_info_before =
+                Ticks::<Test>::get(netuid, tick_low).unwrap_or_default();
+            let tick_high_info_before =
+                Ticks::<Test>::get(netuid, tick_high).unwrap_or_default();
+            let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
+
+            // Get current price
+            let sqrt_current_price = AlphaSqrtPrice::<Test>::get(netuid);
+            let current_price = (sqrt_current_price * sqrt_current_price).to_num::<f64>();
+
+            // Swap
+            let swap_result =
+                Pallet::<Test>::swap(netuid, order_type, liquidity, sqrt_limit_price, true)
+                    .unwrap();
+
+            assert!(swap_result.amount_paid_out > 0);
+        });
+    }    
 }
diff --git a/pallets/swap/src/pallet/mod.rs b/pallets/swap/src/pallet/mod.rs
index c1349f098b..b7fc5ead84 100644
--- a/pallets/swap/src/pallet/mod.rs
+++ b/pallets/swap/src/pallet/mod.rs
@@ -24,7 +24,10 @@ mod pallet {
 
     /// Configure the pallet by specifying the parameters and types on which it depends.
     #[pallet::config]
-    pub trait Config: frame_system::Config {
+    pub trait Config:
+        frame_system::Config
+        + pallet_subtensor::pallet::Config
+    {
         /// Because this pallet emits events, it depends on the runtime's definition of an event.
         type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
 
@@ -128,7 +131,8 @@ mod pallet {
 
         /// Event emitted when liquidity is added
         LiquidityAdded {
-            account_id: T::AccountId,
+            coldkey: T::AccountId,
+            hotkey: T::AccountId,
             netuid: NetUid,
             position_id: PositionId,
             liquidity: u64,
@@ -138,7 +142,7 @@ mod pallet {
 
         /// Event emitted when liquidity is removed
         LiquidityRemoved {
-            account_id: T::AccountId,
+            coldkey: T::AccountId,
             netuid: NetUid,
             position_id: PositionId,
             tao: u64,
@@ -180,6 +184,12 @@ mod pallet {
 
         /// Provided liquidity parameter is invalid (likely too small)
         InvalidLiquidityValue,
+
+        /// Subnet does not exist
+        SubnetDoesNotExist,
+
+        /// Hotkey account does not exist
+        HotKeyAccountDoesNotExist
     }
 
     #[pallet::call]
@@ -189,7 +199,7 @@ mod pallet {
         ///
         /// Only callable by the admin origin
         #[pallet::call_index(0)]
-        #[pallet::weight(T::WeightInfo::set_fee_rate())]
+        #[pallet::weight(<T as pallet::Config>::WeightInfo::set_fee_rate())]
         pub fn set_fee_rate(origin: OriginFor<T>, netuid: u16, rate: u16) -> DispatchResult {
             T::AdminOrigin::ensure_origin(origin)?;
 
@@ -216,15 +226,20 @@ mod pallet {
         ///
         /// Emits `Event::LiquidityAdded` on success
         #[pallet::call_index(1)]
-        #[pallet::weight(T::WeightInfo::add_liquidity())]
+        #[pallet::weight(<T as pallet::Config>::WeightInfo::add_liquidity())]
         pub fn add_liquidity(
             origin: OriginFor<T>,
+            hotkey: T::AccountId,
             netuid: u16,
             tick_low: i32,
             tick_high: i32,
             liquidity: u64,
         ) -> DispatchResult {
-            let account_id = ensure_signed(origin)?;
+            let coldkey = ensure_signed(origin)?;
+
+            // Ensure that the subnet exists.
+            ensure!(pallet_subtensor::Pallet::<T>::if_subnet_exist(netuid), Error::<T>::SubnetDoesNotExist);
+
             let netuid = netuid.into();
             let tick_low_index =
                 TickIndex::new(tick_low).map_err(|_| Error::<T>::InvalidTickRange)?;
@@ -233,14 +248,31 @@ mod pallet {
 
             let (position_id, tao, alpha) = Self::do_add_liquidity(
                 netuid,
-                &account_id,
+                &coldkey,
+                &hotkey,
                 tick_low_index,
                 tick_high_index,
                 liquidity,
             )?;
 
+            // Remove TAO and Alpha balances or fail transaction if they can't be removed exactly
+            let tao_provided =
+                pallet_subtensor::Pallet::<T>::remove_balance_from_coldkey_account(&coldkey, tao)?;
+            ensure!(
+                tao_provided == tao,
+                Error::<T>::InsufficientBalance
+            );
+
+            let alpha_provided = pallet_subtensor::Pallet::<T>::decrease_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid.into(), alpha);
+            ensure!(
+                alpha_provided == alpha,
+                Error::<T>::InsufficientBalance
+            );
+
+            // Emit an event
             Self::deposit_event(Event::LiquidityAdded {
-                account_id,
+                coldkey,
+                hotkey,
                 netuid,
                 position_id,
                 liquidity,
@@ -260,21 +292,37 @@ mod pallet {
         ///
         /// Emits `Event::LiquidityRemoved` on success
         #[pallet::call_index(2)]
-        #[pallet::weight(T::WeightInfo::remove_liquidity())]
+        #[pallet::weight(<T as pallet::Config>::WeightInfo::remove_liquidity())]
         pub fn remove_liquidity(
             origin: OriginFor<T>,
+            hotkey: T::AccountId,
             netuid: u16,
             position_id: u128,
         ) -> DispatchResult {
-            let account_id = ensure_signed(origin)?;
+            let coldkey = ensure_signed(origin)?;
             let netuid = netuid.into();
             let position_id = PositionId::from(position_id);
 
-            let result = Self::do_remove_liquidity(netuid, &account_id, position_id)?;
+            // Ensure that the subnet exists.
+            ensure!(pallet_subtensor::Pallet::<T>::if_subnet_exist(netuid), Error::<T>::SubnetDoesNotExist);
+
+            // Ensure the hotkey account exists
+            ensure!(
+                pallet_subtensor::Pallet::<T>::hotkey_account_exists(&hotkey),
+                Error::<T>::HotKeyAccountDoesNotExist
+            );
+
+            // Remove liquidity
+            let result = Self::do_remove_liquidity(netuid.into(), &coldkey, position_id)?;
+
+            // Credit the returned tao and alpha to the account
+            pallet_subtensor::Pallet::<T>::add_balance_to_coldkey_account(&coldkey, result.tao.saturating_add(result.fee_tao));
+            pallet_subtensor::Pallet::<T>::increase_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid, result.alpha.saturating_add(result.fee_alpha));
 
+            // Emit an event
             Self::deposit_event(Event::LiquidityRemoved {
-                account_id,
-                netuid,
+                coldkey,
+                netuid: netuid.into(),
                 position_id,
                 tao: result.tao,
                 alpha: result.alpha,

From 4d45e96d5a3a98b286cfcf282243a00770115b8e Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Wed, 16 Apr 2025 13:52:58 +0200
Subject: [PATCH 072/418] Update api in some tests

---
 Cargo.lock                                   |   1 -
 pallets/subtensor/src/rpc_info/stake_info.rs |   2 +-
 pallets/subtensor/src/tests/staking2.rs      | 183 +++++--------------
 pallets/swap/Cargo.toml                      |   2 -
 4 files changed, 47 insertions(+), 141 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index f463610db3..78de54f3a4 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6889,7 +6889,6 @@ dependencies = [
  "frame-benchmarking",
  "frame-support",
  "frame-system",
- "pallet-subtensor",
  "parity-scale-codec",
  "safe-math",
  "scale-info",
diff --git a/pallets/subtensor/src/rpc_info/stake_info.rs b/pallets/subtensor/src/rpc_info/stake_info.rs
index f879856006..a387fa0473 100644
--- a/pallets/subtensor/src/rpc_info/stake_info.rs
+++ b/pallets/subtensor/src/rpc_info/stake_info.rs
@@ -124,7 +124,7 @@ impl<T: Config> Pallet<T> {
         _destination_coldkey_account: T::AccountId,
         amount: u64,
     ) -> u64 {
-        let netuid = origin.or(destination).map(|v| v.1).unwrap_or_default();
+        let netuid = destination.or(origin).map(|v| v.1).unwrap_or_default();
         T::SwapInterface::approx_fee_amount(netuid, amount)
     }
 }
diff --git a/pallets/subtensor/src/tests/staking2.rs b/pallets/subtensor/src/tests/staking2.rs
index 6fbabf83b2..9dffa2fef3 100644
--- a/pallets/subtensor/src/tests/staking2.rs
+++ b/pallets/subtensor/src/tests/staking2.rs
@@ -7,6 +7,7 @@ use frame_support::{
 };
 use sp_core::U256;
 use substrate_fixed::types::{I96F32, U96F32};
+use subtensor_swap_interface::SwapHandler;
 
 // SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --workspace --test staking2 -- test_swap_tao_for_alpha_dynamic_mechanism --exact --nocapture
 #[test]
@@ -668,13 +669,8 @@ fn test_stake_fee_api() {
             coldkey1,
             stake_amount,
         );
-        let dynamic_fee_0 = SubtensorModule::calculate_staking_fee(
-            None,
-            &coldkey1,
-            Some((&hotkey1, netuid0)),
-            &coldkey1,
-            U96F32::saturating_from_num(stake_amount),
-        );
+        let dynamic_fee_0 =
+            <SubtensorModule as Config>::SwapInterface::approx_fee_amount(netuid0, stake_amount);
         assert_eq!(stake_fee_0, dynamic_fee_0);
 
         // Test stake fee for remove on root
@@ -685,12 +681,9 @@ fn test_stake_fee_api() {
             coldkey1,
             stake_amount,
         );
-        let dynamic_fee_1 = SubtensorModule::calculate_staking_fee(
-            Some((&hotkey1, root_netuid)),
-            &coldkey1,
-            None,
-            &coldkey1,
-            U96F32::saturating_from_num(stake_amount),
+        let dynamic_fee_1 = <SubtensorModule as Config>::SwapInterface::approx_fee_amount(
+            root_netuid,
+            stake_amount,
         );
         assert_eq!(stake_fee_1, dynamic_fee_1);
 
@@ -702,13 +695,8 @@ fn test_stake_fee_api() {
             coldkey1,
             stake_amount,
         );
-        let dynamic_fee_2 = SubtensorModule::calculate_staking_fee(
-            Some((&hotkey1, root_netuid)),
-            &coldkey1,
-            Some((&hotkey1, netuid0)),
-            &coldkey1,
-            U96F32::saturating_from_num(stake_amount),
-        );
+        let dynamic_fee_2 =
+            <SubtensorModule as Config>::SwapInterface::approx_fee_amount(netuid0, stake_amount);
         assert_eq!(stake_fee_2, dynamic_fee_2);
 
         // Test stake fee for move between hotkeys on root
@@ -719,12 +707,9 @@ fn test_stake_fee_api() {
             coldkey1,
             stake_amount,
         );
-        let dynamic_fee_3 = SubtensorModule::calculate_staking_fee(
-            Some((&hotkey1, root_netuid)),
-            &coldkey1,
-            Some((&hotkey2, root_netuid)),
-            &coldkey1,
-            U96F32::saturating_from_num(stake_amount),
+        let dynamic_fee_3 = <SubtensorModule as Config>::SwapInterface::approx_fee_amount(
+            root_netuid,
+            stake_amount,
         );
         assert_eq!(stake_fee_3, dynamic_fee_3);
 
@@ -736,12 +721,9 @@ fn test_stake_fee_api() {
             coldkey2,
             stake_amount,
         );
-        let dynamic_fee_4 = SubtensorModule::calculate_staking_fee(
-            Some((&hotkey1, root_netuid)),
-            &coldkey1,
-            Some((&hotkey1, root_netuid)),
-            &coldkey2,
-            U96F32::saturating_from_num(stake_amount),
+        let dynamic_fee_4 = <SubtensorModule as Config>::SwapInterface::approx_fee_amount(
+            root_netuid,
+            stake_amount,
         );
         assert_eq!(stake_fee_4, dynamic_fee_4);
 
@@ -753,12 +735,9 @@ fn test_stake_fee_api() {
             coldkey1,
             stake_amount,
         );
-        let dynamic_fee_5 = SubtensorModule::calculate_staking_fee(
-            Some((&hotkey1, netuid0)),
-            &coldkey1,
-            Some((&hotkey1, root_netuid)),
-            &coldkey1,
-            U96F32::saturating_from_num(stake_amount),
+        let dynamic_fee_5 = <SubtensorModule as Config>::SwapInterface::approx_fee_amount(
+            root_netuid,
+            stake_amount,
         );
         assert_eq!(stake_fee_5, dynamic_fee_5);
 
@@ -770,13 +749,8 @@ fn test_stake_fee_api() {
             coldkey1,
             stake_amount,
         );
-        let dynamic_fee_6 = SubtensorModule::calculate_staking_fee(
-            Some((&hotkey1, netuid0)),
-            &coldkey1,
-            Some((&hotkey2, netuid0)),
-            &coldkey1,
-            U96F32::saturating_from_num(stake_amount),
-        );
+        let dynamic_fee_6 =
+            <SubtensorModule as Config>::SwapInterface::approx_fee_amount(netuid0, stake_amount);
         assert_eq!(stake_fee_6, dynamic_fee_6);
 
         // Test stake fee for move between coldkeys on non-root
@@ -787,13 +761,8 @@ fn test_stake_fee_api() {
             coldkey2,
             stake_amount,
         );
-        let dynamic_fee_7 = SubtensorModule::calculate_staking_fee(
-            Some((&hotkey1, netuid0)),
-            &coldkey1,
-            Some((&hotkey1, netuid0)),
-            &coldkey2,
-            U96F32::saturating_from_num(stake_amount),
-        );
+        let dynamic_fee_7 =
+            <SubtensorModule as Config>::SwapInterface::approx_fee_amount(netuid0, stake_amount);
         assert_eq!(stake_fee_7, dynamic_fee_7);
 
         // Test stake fee for *swap* from non-root to non-root
@@ -804,13 +773,8 @@ fn test_stake_fee_api() {
             coldkey1,
             stake_amount,
         );
-        let dynamic_fee_8 = SubtensorModule::calculate_staking_fee(
-            Some((&hotkey1, netuid0)),
-            &coldkey1,
-            Some((&hotkey1, netuid1)),
-            &coldkey1,
-            U96F32::saturating_from_num(stake_amount),
-        );
+        let dynamic_fee_8 =
+            <SubtensorModule as Config>::SwapInterface::approx_fee_amount(netuid1, stake_amount);
         assert_eq!(stake_fee_8, dynamic_fee_8);
     });
 }
@@ -856,93 +820,38 @@ fn test_stake_fee_calculation() {
         TotalHotkeyAlpha::<Test>::insert(hotkey1, netuid1, total_hotkey_alpha);
 
         // Test stake fee for add_stake
-        let stake_fee_0 = SubtensorModule::calculate_staking_fee(
-            None,
-            &coldkey1,
-            Some((&hotkey1, netuid0)),
-            &coldkey1,
-            U96F32::from_num(stake_amount),
-        ); // Default for adding stake
-        assert_eq!(stake_fee_0, default_fee);
+
+        // Default for adding stake
+        let stake_fee =
+            <SubtensorModule as Config>::SwapInterface::approx_fee_amount(netuid0, stake_amount);
+        assert_eq!(stake_fee, default_fee);
 
         // Test stake fee for remove on root
-        let stake_fee_1 = SubtensorModule::calculate_staking_fee(
-            Some((&hotkey1, root_netuid)),
-            &coldkey1,
-            None,
-            &coldkey1,
-            U96F32::from_num(stake_amount),
+        let stake_fee = <SubtensorModule as Config>::SwapInterface::approx_fee_amount(
+            root_netuid,
+            stake_amount,
         ); // Default for removing stake from root
-        assert_eq!(stake_fee_1, default_fee);
+        assert_eq!(stake_fee, default_fee);
 
         // Test stake fee for move from root to non-root
-        let stake_fee_2 = SubtensorModule::calculate_staking_fee(
-            Some((&hotkey1, root_netuid)),
-            &coldkey1,
-            Some((&hotkey1, netuid0)),
-            &coldkey1,
-            U96F32::from_num(stake_amount),
-        ); // Default for moving stake from root to non-root
-        assert_eq!(stake_fee_2, default_fee);
+
+        // Default for moving stake from root to non-root
+        let stake_fee =
+            <SubtensorModule as Config>::SwapInterface::approx_fee_amount(netuid0, stake_amount);
+        assert_eq!(stake_fee, default_fee);
 
         // Test stake fee for move between hotkeys on root
-        let stake_fee_3 = SubtensorModule::calculate_staking_fee(
-            Some((&hotkey1, root_netuid)),
-            &coldkey1,
-            Some((&hotkey2, root_netuid)),
-            &coldkey1,
-            U96F32::from_num(stake_amount),
+        let stake_fee = <SubtensorModule as Config>::SwapInterface::approx_fee_amount(
+            root_netuid,
+            stake_amount,
         ); // Default for moving stake between hotkeys on root
-        assert_eq!(stake_fee_3, default_fee);
-
-        // Test stake fee for move between coldkeys on root
-        let stake_fee_4 = SubtensorModule::calculate_staking_fee(
-            Some((&hotkey1, root_netuid)),
-            &coldkey1,
-            Some((&hotkey1, root_netuid)),
-            &coldkey2,
-            U96F32::from_num(stake_amount),
-        ); // Default for moving stake between coldkeys on root
-        assert_eq!(stake_fee_4, default_fee);
-
-        // Test stake fee for *swap* from non-root to root
-        let stake_fee_5 = SubtensorModule::calculate_staking_fee(
-            Some((&hotkey1, netuid0)),
-            &coldkey1,
-            Some((&hotkey1, root_netuid)),
-            &coldkey1,
-            U96F32::from_num(stake_amount),
-        ); // Charged a dynamic fee
-        assert_ne!(stake_fee_5, default_fee);
-
-        // Test stake fee for move between hotkeys on non-root
-        let stake_fee_6 = SubtensorModule::calculate_staking_fee(
-            Some((&hotkey1, netuid0)),
-            &coldkey1,
-            Some((&hotkey2, netuid0)),
-            &coldkey1,
-            U96F32::from_num(stake_amount),
-        ); // Charge the default fee
-        assert_eq!(stake_fee_6, default_fee);
-
-        // Test stake fee for move between coldkeys on non-root
-        let stake_fee_7 = SubtensorModule::calculate_staking_fee(
-            Some((&hotkey1, netuid0)),
-            &coldkey1,
-            Some((&hotkey1, netuid0)),
-            &coldkey2,
-            U96F32::from_num(stake_amount),
-        ); // Charge the default fee; stake did not leave the subnet.
-        assert_eq!(stake_fee_7, default_fee);
+        assert_eq!(stake_fee, default_fee);
 
         // Test stake fee for *swap* from non-root to non-root
-        let stake_fee_8 = SubtensorModule::calculate_staking_fee(
-            Some((&hotkey1, netuid0)),
-            &coldkey1,
-            Some((&hotkey1, netuid1)),
-            &coldkey1,
-            U96F32::from_num(stake_amount),
-        ); // Charged a dynamic fee
-        assert_ne!(stake_fee_8, default_fee);
+
+        // Charged a dynamic fee
+        let stake_fee =
+            <SubtensorModule as Config>::SwapInterface::approx_fee_amount(netuid1, stake_amount);
+        assert_ne!(stake_fee, default_fee);
     });
 }
diff --git a/pallets/swap/Cargo.toml b/pallets/swap/Cargo.toml
index eed6dc1fc2..7be8c6aa6f 100644
--- a/pallets/swap/Cargo.toml
+++ b/pallets/swap/Cargo.toml
@@ -22,7 +22,6 @@ substrate-fixed = { workspace = true }
 
 subtensor-swap-interface = { workspace = true }
 subtensor-macros = { workspace = true }
-pallet-subtensor = { version = "4.0.0-dev", default-features = false, path = "../subtensor" }
 
 [lints]
 workspace = true
@@ -45,7 +44,6 @@ std = [
 	"sp-std/std",
 	"substrate-fixed/std",
 	"subtensor-swap-interface/std",
-	"pallet-subtensor/std",
 ]
 runtime-benchmarks = [
 	"frame-benchmarking/runtime-benchmarks",

From 4cda8b1ec391c8403160421c732e404e532516b2 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Wed, 16 Apr 2025 15:26:53 +0200
Subject: [PATCH 073/418] Move add/remove liquidity extrinsics to
 pallet-subtensor

---
 pallets/subtensor/src/macros/config.rs        |   2 +-
 pallets/subtensor/src/macros/dispatches.rs    | 126 +++++++++++++++
 pallets/subtensor/src/macros/errors.rs        |   2 +
 pallets/subtensor/src/macros/events.rs        |  36 +++++
 pallets/subtensor/src/rpc_info/stake_info.rs  |   1 -
 pallets/subtensor/src/staking/move_stake.rs   |   2 +-
 pallets/subtensor/src/staking/remove_stake.rs |   1 -
 pallets/subtensor/src/staking/stake_utils.rs  |   2 +-
 pallets/swap-interface/src/lib.rs             |  27 +++-
 pallets/swap/src/lib.rs                       |   8 -
 pallets/swap/src/pallet/impls.rs              | 132 +++++++++++----
 pallets/swap/src/pallet/mod.rs                | 151 +-----------------
 pallets/swap/src/position.rs                  |   8 +
 pallets/swap/src/weights.rs                   |  30 +---
 14 files changed, 304 insertions(+), 224 deletions(-)

diff --git a/pallets/subtensor/src/macros/config.rs b/pallets/subtensor/src/macros/config.rs
index 23f117522c..ffe3f50fa4 100644
--- a/pallets/subtensor/src/macros/config.rs
+++ b/pallets/subtensor/src/macros/config.rs
@@ -5,7 +5,7 @@ use frame_support::pallet_macros::pallet_section;
 /// This can later be imported into the pallet using [`import_section`].
 #[pallet_section]
 mod config {
-    use frame_support::pallet_prelude::*;
+    
     use subtensor_swap_interface::SwapHandler;
 
     /// Configure the pallet by specifying the parameters and types on which it depends.
diff --git a/pallets/subtensor/src/macros/dispatches.rs b/pallets/subtensor/src/macros/dispatches.rs
index 4ea03c957b..732335f2b7 100644
--- a/pallets/subtensor/src/macros/dispatches.rs
+++ b/pallets/subtensor/src/macros/dispatches.rs
@@ -2023,5 +2023,131 @@ mod dispatches {
         ) -> DispatchResult {
             Self::do_burn_alpha(origin, hotkey, amount, netuid)
         }
+
+        /// Add liquidity to a specific price range for a subnet.
+        ///
+        /// Parameters:
+        /// - origin: The origin of the transaction
+        /// - netuid: Subnet ID
+        /// - tick_low: Lower bound of the price range
+        /// - tick_high: Upper bound of the price range
+        /// - liquidity: Amount of liquidity to add
+        ///
+        /// Emits `Event::LiquidityAdded` on success
+        #[pallet::call_index(103)]
+        #[pallet::weight((
+		Weight::from_parts(50_000_000, 0)
+			.saturating_add(T::DbWeight::get().reads(5))
+			.saturating_add(T::DbWeight::get().writes(4)),
+            DispatchClass::Operational,
+            Pays::Yes
+        ))]
+        pub fn add_liquidity(
+            origin: OriginFor<T>,
+            hotkey: T::AccountId,
+            netuid: u16,
+            tick_low: i32,
+            tick_high: i32,
+            liquidity: u64,
+        ) -> DispatchResult {
+            let coldkey = ensure_signed(origin)?;
+
+            // Ensure that the subnet exists.
+            ensure!(
+                Self::if_subnet_exist(netuid),
+                Error::<T>::SubNetworkDoesNotExist
+            );
+
+            let (position_id, tao, alpha) = T::SwapInterface::add_liquidity(
+                netuid, &coldkey, &hotkey, tick_low, tick_high, liquidity,
+            )?;
+
+            // Remove TAO and Alpha balances or fail transaction if they can't be removed exactly
+            let tao_provided = Self::remove_balance_from_coldkey_account(&coldkey, tao)?;
+            ensure!(tao_provided == tao, Error::<T>::InsufficientBalance);
+
+            let alpha_provided = Self::decrease_stake_for_hotkey_and_coldkey_on_subnet(
+                &hotkey, &coldkey, netuid, alpha,
+            );
+            ensure!(alpha_provided == alpha, Error::<T>::InsufficientBalance);
+
+            // Emit an event
+            Self::deposit_event(Event::LiquidityAdded {
+                coldkey,
+                hotkey,
+                netuid,
+                position_id,
+                liquidity,
+                tao,
+                alpha,
+            });
+
+            Ok(())
+        }
+
+        /// Remove liquidity from a specific position.
+        ///
+        /// Parameters:
+        /// - origin: The origin of the transaction
+        /// - netuid: Subnet ID
+        /// - position_id: ID of the position to remove
+        ///
+        /// Emits `Event::LiquidityRemoved` on success
+        #[pallet::call_index(104)]
+        #[pallet::weight((
+		Weight::from_parts(50_000_000, 0)
+			.saturating_add(T::DbWeight::get().reads(4))
+			.saturating_add(T::DbWeight::get().writes(4)),
+            DispatchClass::Operational,
+            Pays::Yes
+        ))]
+        pub fn remove_liquidity(
+            origin: OriginFor<T>,
+            hotkey: T::AccountId,
+            netuid: u16,
+            position_id: u128,
+        ) -> DispatchResult {
+            let coldkey = ensure_signed(origin)?;
+
+            // Ensure that the subnet exists.
+            ensure!(
+                Self::if_subnet_exist(netuid),
+                Error::<T>::SubNetworkDoesNotExist
+            );
+
+            // Ensure the hotkey account exists
+            ensure!(
+                Self::hotkey_account_exists(&hotkey),
+                Error::<T>::HotKeyAccountNotExists
+            );
+
+            // Remove liquidity
+            let result = T::SwapInterface::remove_liquidity(netuid, &coldkey, position_id)?;
+
+            // Credit the returned tao and alpha to the account
+            Self::add_balance_to_coldkey_account(
+                &coldkey,
+                result.tao.saturating_add(result.fee_tao),
+            );
+            Self::increase_stake_for_hotkey_and_coldkey_on_subnet(
+                &hotkey,
+                &coldkey,
+                netuid,
+                result.alpha.saturating_add(result.fee_alpha),
+            );
+
+            // Emit an event
+            Self::deposit_event(Event::LiquidityRemoved {
+                coldkey,
+                netuid: netuid.into(),
+                position_id,
+                tao: result.tao,
+                alpha: result.alpha,
+                fee_tao: result.fee_tao,
+                fee_alpha: result.fee_alpha,
+            });
+
+            Ok(())
+        }
     }
 }
diff --git a/pallets/subtensor/src/macros/errors.rs b/pallets/subtensor/src/macros/errors.rs
index 052b15d5e6..8ecd29f7e8 100644
--- a/pallets/subtensor/src/macros/errors.rs
+++ b/pallets/subtensor/src/macros/errors.rs
@@ -207,5 +207,7 @@ mod errors {
         UnableToRecoverPublicKey,
         /// Recovered public key is invalid.
         InvalidRecoveredPublicKey,
+        /// The caller does not have enough balance for the operation.
+        InsufficientBalance,
     }
 }
diff --git a/pallets/subtensor/src/macros/events.rs b/pallets/subtensor/src/macros/events.rs
index 8c2e863d0e..90d68ed8ea 100644
--- a/pallets/subtensor/src/macros/events.rs
+++ b/pallets/subtensor/src/macros/events.rs
@@ -323,5 +323,41 @@ mod events {
         /// - **netuid**: The network identifier.
         /// - **Enabled**: Is Commit-Reveal enabled.
         CommitRevealEnabled(u16, bool),
+
+        /// Event emitted when liquidity is added to a subnet's liquidity pool.
+        LiquidityAdded {
+            /// The coldkey account that owns the position
+            coldkey: T::AccountId,
+            /// The hotkey account associated with the position
+            hotkey: T::AccountId,
+            /// The subnet identifier
+            netuid: u16,
+            /// Unique identifier for the liquidity position
+            position_id: u128,
+            /// The amount of liquidity added to the position
+            liquidity: u64,
+            /// The amount of TAO tokens committed to the position
+            tao: u64,
+            /// The amount of Alpha tokens committed to the position
+            alpha: u64,
+        },
+
+        /// Event emitted when liquidity is removed from a subnet's liquidity pool.
+        LiquidityRemoved {
+            /// The coldkey account that owns the position
+            coldkey: T::AccountId,
+            /// The subnet identifier
+            netuid: u16,
+            /// Unique identifier for the liquidity position
+            position_id: u128,
+            /// The amount of TAO tokens returned to the user
+            tao: u64,
+            /// The amount of Alpha tokens returned to the user
+            alpha: u64,
+            /// The amount of TAO fees earned from the position
+            fee_tao: u64,
+            /// The amount of Alpha fees earned from the position
+            fee_alpha: u64,
+        },
     }
 }
diff --git a/pallets/subtensor/src/rpc_info/stake_info.rs b/pallets/subtensor/src/rpc_info/stake_info.rs
index a387fa0473..26877c2fe2 100644
--- a/pallets/subtensor/src/rpc_info/stake_info.rs
+++ b/pallets/subtensor/src/rpc_info/stake_info.rs
@@ -2,7 +2,6 @@ extern crate alloc;
 
 use codec::Compact;
 use frame_support::pallet_prelude::{Decode, Encode};
-use substrate_fixed::types::U96F32;
 use subtensor_swap_interface::SwapHandler;
 
 use super::*;
diff --git a/pallets/subtensor/src/staking/move_stake.rs b/pallets/subtensor/src/staking/move_stake.rs
index d2f9ccc913..50c22fd9b0 100644
--- a/pallets/subtensor/src/staking/move_stake.rs
+++ b/pallets/subtensor/src/staking/move_stake.rs
@@ -1,7 +1,7 @@
 use super::*;
 use safe_math::*;
 use sp_core::Get;
-use substrate_fixed::types::{U64F64, U96F32};
+use substrate_fixed::types::U64F64;
 use subtensor_swap_interface::SwapHandler;
 
 impl<T: Config> Pallet<T> {
diff --git a/pallets/subtensor/src/staking/remove_stake.rs b/pallets/subtensor/src/staking/remove_stake.rs
index d4c0ed64f0..39d6f925c5 100644
--- a/pallets/subtensor/src/staking/remove_stake.rs
+++ b/pallets/subtensor/src/staking/remove_stake.rs
@@ -1,5 +1,4 @@
 use super::*;
-use substrate_fixed::types::U96F32;
 use subtensor_swap_interface::SwapHandler;
 
 impl<T: Config> Pallet<T> {
diff --git a/pallets/subtensor/src/staking/stake_utils.rs b/pallets/subtensor/src/staking/stake_utils.rs
index 8d2e3e98bb..a151ebc83f 100644
--- a/pallets/subtensor/src/staking/stake_utils.rs
+++ b/pallets/subtensor/src/staking/stake_utils.rs
@@ -2,7 +2,7 @@ use super::*;
 use safe_math::*;
 use share_pool::{SharePool, SharePoolDataOperations};
 use sp_std::ops::Neg;
-use substrate_fixed::types::{I64F64, I96F32, U64F64, U96F32, U110F18};
+use substrate_fixed::types::{I64F64, I96F32, U64F64, U96F32};
 use subtensor_swap_interface::{OrderType, SwapHandler, SwapResult};
 
 impl<T: Config> Pallet<T> {
diff --git a/pallets/swap-interface/src/lib.rs b/pallets/swap-interface/src/lib.rs
index 689483d8f8..d77edd57b5 100644
--- a/pallets/swap-interface/src/lib.rs
+++ b/pallets/swap-interface/src/lib.rs
@@ -16,6 +16,19 @@ pub trait SwapHandler<AccountId> {
         price_limit: u64,
         should_rollback: bool,
     ) -> Result<SwapResult, DispatchError>;
+    fn add_liquidity(
+        netuid: u16,
+        coldkey_account_id: &AccountId,
+        hotkey_account_id: &AccountId,
+        tick_low: i32,
+        tick_high: i32,
+        liquidity: u64,
+    ) -> Result<(u128, u64, u64), DispatchError>;
+    fn remove_liquidity(
+        netuid: u16,
+        coldkey_account_id: &AccountId,
+        position_id: u128,
+    ) -> Result<RemoveLiquidityResult, DispatchError>;
     fn approx_fee_amount(netuid: u16, amount: u64) -> u64;
     fn max_price() -> u64;
     fn min_price() -> u64;
@@ -31,9 +44,21 @@ pub struct SwapResult {
     pub new_alpha_reserve: u64,
 }
 
+#[derive(Debug, PartialEq)]
+pub struct RemoveLiquidityResult {
+    pub tao: u64,
+    pub alpha: u64,
+    pub fee_tao: u64,
+    pub fee_alpha: u64,
+}
+
 pub trait LiquidityDataProvider<AccountId> {
     fn tao_reserve(netuid: u16) -> u64;
     fn alpha_reserve(netuid: u16) -> u64;
     fn tao_balance(account_id: &AccountId) -> u64;
-    fn alpha_balance(netuid: u16, coldkey_account_id: &AccountId, hotkey_account_id: &AccountId) -> u64;
+    fn alpha_balance(
+        netuid: u16,
+        coldkey_account_id: &AccountId,
+        hotkey_account_id: &AccountId,
+    ) -> u64;
 }
diff --git a/pallets/swap/src/lib.rs b/pallets/swap/src/lib.rs
index 320a906d05..8bfdcbf3b0 100644
--- a/pallets/swap/src/lib.rs
+++ b/pallets/swap/src/lib.rs
@@ -21,14 +21,6 @@ pub(crate) mod mock;
 
 type SqrtPrice = U64F64;
 
-#[derive(Debug, PartialEq)]
-pub struct RemoveLiquidityResult {
-    tao: u64,
-    alpha: u64,
-    fee_tao: u64,
-    fee_alpha: u64,
-}
-
 #[freeze_struct("2a62496e31bbcddc")]
 #[derive(
     Clone, Copy, Decode, Default, Encode, Eq, MaxEncodedLen, PartialEq, RuntimeDebug, TypeInfo,
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 2b7850e402..4636df575b 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -6,11 +6,13 @@ use safe_math::*;
 use sp_arithmetic::helpers_128bit;
 use sp_runtime::traits::AccountIdConversion;
 use substrate_fixed::types::U64F64;
-use subtensor_swap_interface::{LiquidityDataProvider, SwapHandler, SwapResult};
+use subtensor_swap_interface::{
+    LiquidityDataProvider, RemoveLiquidityResult, SwapHandler, SwapResult,
+};
 
 use super::pallet::*;
 use crate::{
-    NetUid, OrderType, RemoveLiquidityResult, SqrtPrice,
+    NetUid, OrderType, SqrtPrice,
     position::{Position, PositionId},
     tick::{ActiveTickIndexManager, Tick, TickIndex},
 };
@@ -712,7 +714,7 @@ impl<T: Config> Pallet<T> {
     /// - [`SwapError::InsufficientBalance`] if the account does not have enough balance.
     /// - [`SwapError::InvalidTickRange`] if `tick_low` is greater than or equal to `tick_high`.
     /// - Other [`SwapError`] variants as applicable.
-    pub fn do_add_liquidity(
+    pub fn add_liquidity(
         netuid: NetUid,
         coldkey_account_id: &T::AccountId,
         hotkey_account_id: &T::AccountId,
@@ -720,13 +722,22 @@ impl<T: Config> Pallet<T> {
         tick_high: TickIndex,
         liquidity: u64,
     ) -> Result<(PositionId, u64, u64), Error<T>> {
-        let (position, tao, alpha) =
-            Self::add_liquidity_not_insert(netuid, coldkey_account_id, tick_low, tick_high, liquidity)?;
+        let (position, tao, alpha) = Self::add_liquidity_not_insert(
+            netuid,
+            coldkey_account_id,
+            tick_low,
+            tick_high,
+            liquidity,
+        )?;
         let position_id = position.id;
 
         ensure!(
             T::LiquidityDataProvider::tao_balance(coldkey_account_id) >= tao
-                && T::LiquidityDataProvider::alpha_balance(netuid.into(), coldkey_account_id, hotkey_account_id) >= alpha,
+                && T::LiquidityDataProvider::alpha_balance(
+                    netuid.into(),
+                    coldkey_account_id,
+                    hotkey_account_id
+                ) >= alpha,
             Error::<T>::InsufficientBalance
         );
 
@@ -806,12 +817,13 @@ impl<T: Config> Pallet<T> {
     /// Remove liquidity and credit balances back to (coldkey_account_id, hotkey_account_id) stake
     ///
     /// Account ID and Position ID identify position in the storage map
-    pub fn do_remove_liquidity(
+    pub fn remove_liquidity(
         netuid: NetUid,
         coldkey_account_id: &T::AccountId,
         position_id: PositionId,
     ) -> Result<RemoveLiquidityResult, Error<T>> {
-        let Some(mut position) = Positions::<T>::get((netuid, coldkey_account_id, position_id)) else {
+        let Some(mut position) = Positions::<T>::get((netuid, coldkey_account_id, position_id))
+        else {
             return Err(Error::<T>::LiquidityNotFound);
         };
 
@@ -867,7 +879,8 @@ impl<T: Config> Pallet<T> {
         liquidity_delta: i64,
     ) -> Result<RemoveLiquidityResult, Error<T>> {
         // Find the position
-        let Some(mut position) = Positions::<T>::get((netuid, coldkey_account_id, position_id)) else {
+        let Some(mut position) = Positions::<T>::get((netuid, coldkey_account_id, position_id))
+        else {
             return Err(Error::<T>::LiquidityNotFound);
         };
 
@@ -914,7 +927,11 @@ impl<T: Config> Pallet<T> {
             // Check that user has enough balances
             ensure!(
                 T::LiquidityDataProvider::tao_balance(coldkey_account_id) >= tao
-                    && T::LiquidityDataProvider::alpha_balance(netuid.into(), coldkey_account_id, hotkey_account_id) >= alpha,
+                    && T::LiquidityDataProvider::alpha_balance(
+                        netuid.into(),
+                        coldkey_account_id,
+                        hotkey_account_id
+                    ) >= alpha,
                 Error::<T>::InsufficientBalance
             );
         } else {
@@ -1097,6 +1114,38 @@ impl<T: Config> SwapHandler<T::AccountId> for Pallet<T> {
         .map_err(Into::into)
     }
 
+    fn add_liquidity(
+        netuid: u16,
+        coldkey_account_id: &T::AccountId,
+        hotkey_account_id: &T::AccountId,
+        tick_low: i32,
+        tick_high: i32,
+        liquidity: u64,
+    ) -> Result<(u128, u64, u64), DispatchError> {
+        let tick_low = TickIndex::new(tick_low).map_err(|_| Error::<T>::InvalidTickRange)?;
+        let tick_high = TickIndex::new(tick_high).map_err(|_| Error::<T>::InvalidTickRange)?;
+
+        Self::add_liquidity(
+            NetUid::from(netuid),
+            coldkey_account_id,
+            hotkey_account_id,
+            tick_low,
+            tick_high,
+            liquidity,
+        )
+        .map(|(pid, t, a)| (pid.into(), t, a))
+        .map_err(Into::into)
+    }
+
+    fn remove_liquidity(
+        netuid: u16,
+        coldkey_account_id: &T::AccountId,
+        position_id: u128,
+    ) -> Result<RemoveLiquidityResult, DispatchError> {
+        Self::remove_liquidity(netuid.into(), coldkey_account_id, position_id.into())
+            .map_err(Into::into)
+    }
+
     fn approx_fee_amount(netuid: u16, amount: u64) -> u64 {
         Self::calculate_fee_amount(netuid.into(), amount)
     }
@@ -1288,7 +1337,7 @@ mod tests {
                     let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
 
                     // Add liquidity
-                    let (position_id, tao, alpha) = Pallet::<Test>::do_add_liquidity(
+                    let (position_id, tao, alpha) = Pallet::<Test>::add_liquidity(
                         netuid,
                         &OK_COLDKEY_ACCOUNT_ID,
                         &OK_HOTKEY_ACCOUNT_ID,
@@ -1327,10 +1376,14 @@ mod tests {
                     );
 
                     // Liquidity position at correct ticks
-                    assert_eq!(Pallet::<Test>::count_positions(netuid, &OK_COLDKEY_ACCOUNT_ID), 1);
+                    assert_eq!(
+                        Pallet::<Test>::count_positions(netuid, &OK_COLDKEY_ACCOUNT_ID),
+                        1
+                    );
 
                     let position =
-                        Positions::<Test>::get(&(netuid, OK_COLDKEY_ACCOUNT_ID, position_id)).unwrap();
+                        Positions::<Test>::get(&(netuid, OK_COLDKEY_ACCOUNT_ID, position_id))
+                            .unwrap();
                     assert_eq!(position.liquidity, liquidity);
                     assert_eq!(position.tick_low, tick_low);
                     assert_eq!(position.tick_high, tick_high);
@@ -1386,7 +1439,14 @@ mod tests {
 
                 // Add liquidity
                 assert_err!(
-                    Swap::do_add_liquidity(netuid, &OK_COLDKEY_ACCOUNT_ID, &OK_HOTKEY_ACCOUNT_ID, tick_low, tick_high, liquidity),
+                    Swap::add_liquidity(
+                        netuid,
+                        &OK_COLDKEY_ACCOUNT_ID,
+                        &OK_HOTKEY_ACCOUNT_ID,
+                        tick_low,
+                        tick_high,
+                        liquidity
+                    ),
                     Error::<Test>::InvalidTickRange,
                 );
             });
@@ -1419,7 +1479,7 @@ mod tests {
 
                 // Add liquidity
                 assert_err!(
-                    Pallet::<Test>::do_add_liquidity(
+                    Pallet::<Test>::add_liquidity(
                         netuid,
                         &coldkey_account_id,
                         &hotkey_account_id,
@@ -1477,7 +1537,7 @@ mod tests {
                 let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
 
                 // Add liquidity
-                let (position_id, _, _) = Pallet::<Test>::do_add_liquidity(
+                let (position_id, _, _) = Pallet::<Test>::add_liquidity(
                     netuid,
                     &OK_COLDKEY_ACCOUNT_ID,
                     &OK_HOTKEY_ACCOUNT_ID,
@@ -1489,15 +1549,21 @@ mod tests {
 
                 // Remove liquidity
                 let remove_result =
-                    Pallet::<Test>::do_remove_liquidity(netuid, &OK_COLDKEY_ACCOUNT_ID, position_id).unwrap();
+                    Pallet::<Test>::remove_liquidity(netuid, &OK_COLDKEY_ACCOUNT_ID, position_id)
+                        .unwrap();
                 assert_abs_diff_eq!(remove_result.tao, tao, epsilon = tao / 1000);
                 assert_abs_diff_eq!(remove_result.alpha, alpha, epsilon = alpha / 1000);
                 assert_eq!(remove_result.fee_tao, 0);
                 assert_eq!(remove_result.fee_alpha, 0);
 
                 // Liquidity position is removed
-                assert_eq!(Pallet::<Test>::count_positions(netuid, &OK_COLDKEY_ACCOUNT_ID), 0);
-                assert!(Positions::<Test>::get((netuid, OK_COLDKEY_ACCOUNT_ID, position_id)).is_none());
+                assert_eq!(
+                    Pallet::<Test>::count_positions(netuid, &OK_COLDKEY_ACCOUNT_ID),
+                    0
+                );
+                assert!(
+                    Positions::<Test>::get((netuid, OK_COLDKEY_ACCOUNT_ID, position_id)).is_none()
+                );
 
                 // Current liquidity is updated (back where it was)
                 assert_eq!(CurrentLiquidity::<Test>::get(netuid), liquidity_before);
@@ -1524,7 +1590,7 @@ mod tests {
             assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
 
             // Add liquidity
-            assert_ok!(Pallet::<Test>::do_add_liquidity(
+            assert_ok!(Pallet::<Test>::add_liquidity(
                 netuid,
                 &OK_COLDKEY_ACCOUNT_ID,
                 &OK_HOTKEY_ACCOUNT_ID,
@@ -1537,7 +1603,11 @@ mod tests {
 
             // Remove liquidity
             assert_err!(
-                Pallet::<Test>::do_remove_liquidity(netuid, &OK_COLDKEY_ACCOUNT_ID, PositionId::new::<Test>()),
+                Pallet::<Test>::remove_liquidity(
+                    netuid,
+                    &OK_COLDKEY_ACCOUNT_ID,
+                    PositionId::new::<Test>()
+                ),
                 Error::<Test>::LiquidityNotFound,
             );
         });
@@ -1761,7 +1831,7 @@ mod tests {
                         let price_high = price_high_offset + current_price;
                         let tick_low = price_to_tick(price_low);
                         let tick_high = price_to_tick(price_high);
-                        let (_position_id, _tao, _alpha) = Pallet::<Test>::do_add_liquidity(
+                        let (_position_id, _tao, _alpha) = Pallet::<Test>::add_liquidity(
                             netuid,
                             &OK_COLDKEY_ACCOUNT_ID,
                             &OK_HOTKEY_ACCOUNT_ID,
@@ -1772,7 +1842,10 @@ mod tests {
                         .unwrap();
 
                         // Liquidity position at correct ticks
-                        assert_eq!(Pallet::<Test>::count_positions(netuid, &OK_COLDKEY_ACCOUNT_ID), 1);
+                        assert_eq!(
+                            Pallet::<Test>::count_positions(netuid, &OK_COLDKEY_ACCOUNT_ID),
+                            1
+                        );
 
                         // Get tick infos before the swap
                         let tick_low_info_before =
@@ -1995,7 +2068,7 @@ mod tests {
                     let price_high = price_high_offset + current_price;
                     let tick_low = price_to_tick(price_low);
                     let tick_high = price_to_tick(price_high);
-                    let (_position_id, _tao, _alpha) = Pallet::<Test>::do_add_liquidity(
+                    let (_position_id, _tao, _alpha) = Pallet::<Test>::add_liquidity(
                         netuid,
                         &OK_COLDKEY_ACCOUNT_ID,
                         &OK_HOTKEY_ACCOUNT_ID,
@@ -2129,17 +2202,14 @@ mod tests {
             let tick_low = TickIndex::MIN;
             let tick_high = TickIndex::MAX;
 
-            let sqrt_limit_price: SqrtPrice = tick_low
-                .try_to_sqrt_price().unwrap();
+            let sqrt_limit_price: SqrtPrice = tick_low.try_to_sqrt_price().unwrap();
 
             // Setup swap
             assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
 
             // Get tick infos before the swap
-            let tick_low_info_before =
-                Ticks::<Test>::get(netuid, tick_low).unwrap_or_default();
-            let tick_high_info_before =
-                Ticks::<Test>::get(netuid, tick_high).unwrap_or_default();
+            let tick_low_info_before = Ticks::<Test>::get(netuid, tick_low).unwrap_or_default();
+            let tick_high_info_before = Ticks::<Test>::get(netuid, tick_high).unwrap_or_default();
             let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
 
             // Get current price
@@ -2153,5 +2223,5 @@ mod tests {
 
             assert!(swap_result.amount_paid_out > 0);
         });
-    }    
+    }
 }
diff --git a/pallets/swap/src/pallet/mod.rs b/pallets/swap/src/pallet/mod.rs
index b7fc5ead84..66e7d35091 100644
--- a/pallets/swap/src/pallet/mod.rs
+++ b/pallets/swap/src/pallet/mod.rs
@@ -24,10 +24,7 @@ mod pallet {
 
     /// Configure the pallet by specifying the parameters and types on which it depends.
     #[pallet::config]
-    pub trait Config:
-        frame_system::Config
-        + pallet_subtensor::pallet::Config
-    {
+    pub trait Config: frame_system::Config {
         /// Because this pallet emits events, it depends on the runtime's definition of an event.
         type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
 
@@ -128,28 +125,6 @@ mod pallet {
     pub enum Event<T: Config> {
         /// Event emitted when the fee rate has been updated for a subnet
         FeeRateSet { netuid: NetUid, rate: u16 },
-
-        /// Event emitted when liquidity is added
-        LiquidityAdded {
-            coldkey: T::AccountId,
-            hotkey: T::AccountId,
-            netuid: NetUid,
-            position_id: PositionId,
-            liquidity: u64,
-            tao: u64,
-            alpha: u64,
-        },
-
-        /// Event emitted when liquidity is removed
-        LiquidityRemoved {
-            coldkey: T::AccountId,
-            netuid: NetUid,
-            position_id: PositionId,
-            tao: u64,
-            alpha: u64,
-            fee_tao: u64,
-            fee_alpha: u64,
-        },
     }
 
     #[pallet::error]
@@ -184,12 +159,6 @@ mod pallet {
 
         /// Provided liquidity parameter is invalid (likely too small)
         InvalidLiquidityValue,
-
-        /// Subnet does not exist
-        SubnetDoesNotExist,
-
-        /// Hotkey account does not exist
-        HotKeyAccountDoesNotExist
     }
 
     #[pallet::call]
@@ -214,124 +183,6 @@ mod pallet {
 
             Ok(())
         }
-
-        /// Add liquidity to a specific price range for a subnet.
-        ///
-        /// Parameters:
-        /// - origin: The origin of the transaction
-        /// - netuid: Subnet ID
-        /// - tick_low: Lower bound of the price range
-        /// - tick_high: Upper bound of the price range
-        /// - liquidity: Amount of liquidity to add
-        ///
-        /// Emits `Event::LiquidityAdded` on success
-        #[pallet::call_index(1)]
-        #[pallet::weight(<T as pallet::Config>::WeightInfo::add_liquidity())]
-        pub fn add_liquidity(
-            origin: OriginFor<T>,
-            hotkey: T::AccountId,
-            netuid: u16,
-            tick_low: i32,
-            tick_high: i32,
-            liquidity: u64,
-        ) -> DispatchResult {
-            let coldkey = ensure_signed(origin)?;
-
-            // Ensure that the subnet exists.
-            ensure!(pallet_subtensor::Pallet::<T>::if_subnet_exist(netuid), Error::<T>::SubnetDoesNotExist);
-
-            let netuid = netuid.into();
-            let tick_low_index =
-                TickIndex::new(tick_low).map_err(|_| Error::<T>::InvalidTickRange)?;
-            let tick_high_index =
-                TickIndex::new(tick_high).map_err(|_| Error::<T>::InvalidTickRange)?;
-
-            let (position_id, tao, alpha) = Self::do_add_liquidity(
-                netuid,
-                &coldkey,
-                &hotkey,
-                tick_low_index,
-                tick_high_index,
-                liquidity,
-            )?;
-
-            // Remove TAO and Alpha balances or fail transaction if they can't be removed exactly
-            let tao_provided =
-                pallet_subtensor::Pallet::<T>::remove_balance_from_coldkey_account(&coldkey, tao)?;
-            ensure!(
-                tao_provided == tao,
-                Error::<T>::InsufficientBalance
-            );
-
-            let alpha_provided = pallet_subtensor::Pallet::<T>::decrease_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid.into(), alpha);
-            ensure!(
-                alpha_provided == alpha,
-                Error::<T>::InsufficientBalance
-            );
-
-            // Emit an event
-            Self::deposit_event(Event::LiquidityAdded {
-                coldkey,
-                hotkey,
-                netuid,
-                position_id,
-                liquidity,
-                tao,
-                alpha,
-            });
-
-            Ok(())
-        }
-
-        /// Remove liquidity from a specific position.
-        ///
-        /// Parameters:
-        /// - origin: The origin of the transaction
-        /// - netuid: Subnet ID
-        /// - position_id: ID of the position to remove
-        ///
-        /// Emits `Event::LiquidityRemoved` on success
-        #[pallet::call_index(2)]
-        #[pallet::weight(<T as pallet::Config>::WeightInfo::remove_liquidity())]
-        pub fn remove_liquidity(
-            origin: OriginFor<T>,
-            hotkey: T::AccountId,
-            netuid: u16,
-            position_id: u128,
-        ) -> DispatchResult {
-            let coldkey = ensure_signed(origin)?;
-            let netuid = netuid.into();
-            let position_id = PositionId::from(position_id);
-
-            // Ensure that the subnet exists.
-            ensure!(pallet_subtensor::Pallet::<T>::if_subnet_exist(netuid), Error::<T>::SubnetDoesNotExist);
-
-            // Ensure the hotkey account exists
-            ensure!(
-                pallet_subtensor::Pallet::<T>::hotkey_account_exists(&hotkey),
-                Error::<T>::HotKeyAccountDoesNotExist
-            );
-
-            // Remove liquidity
-            let result = Self::do_remove_liquidity(netuid.into(), &coldkey, position_id)?;
-
-            // Credit the returned tao and alpha to the account
-            pallet_subtensor::Pallet::<T>::add_balance_to_coldkey_account(&coldkey, result.tao.saturating_add(result.fee_tao));
-            pallet_subtensor::Pallet::<T>::increase_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid, result.alpha.saturating_add(result.fee_alpha));
-
-            // Emit an event
-            Self::deposit_event(Event::LiquidityRemoved {
-                coldkey,
-                netuid: netuid.into(),
-                position_id,
-                tao: result.tao,
-                alpha: result.alpha,
-                fee_tao: result.fee_tao,
-                fee_alpha: result.fee_alpha,
-            });
-
-            Ok(())
-        }
     }
 }
 
diff --git a/pallets/swap/src/position.rs b/pallets/swap/src/position.rs
index 210f1533e5..7558d55c0b 100644
--- a/pallets/swap/src/position.rs
+++ b/pallets/swap/src/position.rs
@@ -145,3 +145,11 @@ impl From<u128> for PositionId {
         Self(value)
     }
 }
+
+impl From<PositionId> for u128 {
+    fn from(value: PositionId) -> Self {
+        value.0
+    }
+}
+
+
diff --git a/pallets/swap/src/weights.rs b/pallets/swap/src/weights.rs
index 821727e838..d630ff661d 100644
--- a/pallets/swap/src/weights.rs
+++ b/pallets/swap/src/weights.rs
@@ -15,8 +15,6 @@ use sp_std::marker::PhantomData;
 /// Weight functions needed for pallet_subtensor_swap.
 pub trait WeightInfo {
 	fn set_fee_rate() -> Weight;
-	fn add_liquidity() -> Weight;
-	fn remove_liquidity() -> Weight;
 }
 
 /// Default weights for pallet_subtensor_swap.
@@ -28,20 +26,6 @@ impl<T: frame_system::Config> WeightInfo for DefaultWeight<T> {
 			.saturating_add(T::DbWeight::get().reads(1))
 			.saturating_add(T::DbWeight::get().writes(1))
 	}
-	
-	fn add_liquidity() -> Weight {
-		// Conservative weight estimate
-		Weight::from_parts(50_000_000, 0)
-			.saturating_add(T::DbWeight::get().reads(5))
-			.saturating_add(T::DbWeight::get().writes(4))
-	}
-	
-	fn remove_liquidity() -> Weight {
-		// Conservative weight estimate
-		Weight::from_parts(50_000_000, 0)
-			.saturating_add(T::DbWeight::get().reads(4))
-			.saturating_add(T::DbWeight::get().writes(4))
-	}
 }
 
 // For backwards compatibility and tests
@@ -51,16 +35,4 @@ impl WeightInfo for () {
 			.saturating_add(RocksDbWeight::get().reads(1))
 			.saturating_add(RocksDbWeight::get().writes(1))
 	}
-	
-	fn add_liquidity() -> Weight {
-		Weight::from_parts(50_000_000, 0)
-			.saturating_add(RocksDbWeight::get().reads(5))
-			.saturating_add(RocksDbWeight::get().writes(4))
-	}
-	
-	fn remove_liquidity() -> Weight {
-		Weight::from_parts(50_000_000, 0)
-			.saturating_add(RocksDbWeight::get().reads(4))
-			.saturating_add(RocksDbWeight::get().writes(4))
-	}
-}
\ No newline at end of file
+}

From f8f760c3b53042cc096a311e98a4a1e04a97bd65 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Wed, 16 Apr 2025 16:24:49 +0200
Subject: [PATCH 074/418] Update api in tests

---
 .../subtensor/src/coinbase/run_coinbase.rs    |   2 +-
 pallets/subtensor/src/macros/config.rs        |   2 +-
 pallets/subtensor/src/staking/helpers.rs      |   2 +-
 pallets/subtensor/src/staking/move_stake.rs   |   2 +-
 pallets/subtensor/src/subnets/registration.rs |   2 +-
 pallets/subtensor/src/tests/children.rs       |  70 +++--
 pallets/subtensor/src/tests/coinbase.rs       |  34 +--
 pallets/subtensor/src/tests/mock.rs           |  30 +-
 pallets/subtensor/src/tests/move_stake.rs     | 274 +++++++++++++++---
 pallets/subtensor/src/tests/staking.rs        |  75 +++--
 pallets/subtensor/src/tests/staking2.rs       |  63 ++--
 pallets/subtensor/src/tests/swap_coldkey.rs   |  25 +-
 pallets/swap/src/benchmarking.rs              |  18 +-
 pallets/swap/src/lib.rs                       |   2 +-
 pallets/swap/src/mock.rs                      |   8 +-
 pallets/swap/src/pallet/impls.rs              |  12 +-
 pallets/swap/src/position.rs                  |   2 -
 pallets/swap/src/weights.rs                   |  28 +-
 18 files changed, 433 insertions(+), 218 deletions(-)

diff --git a/pallets/subtensor/src/coinbase/run_coinbase.rs b/pallets/subtensor/src/coinbase/run_coinbase.rs
index eb7ea4b5b9..c0f890784c 100644
--- a/pallets/subtensor/src/coinbase/run_coinbase.rs
+++ b/pallets/subtensor/src/coinbase/run_coinbase.rs
@@ -267,7 +267,7 @@ impl<T: Config> Pallet<T> {
             }
         }
 
-		Ok(())
+        Ok(())
     }
 
     pub fn calculate_dividends_and_incentives(
diff --git a/pallets/subtensor/src/macros/config.rs b/pallets/subtensor/src/macros/config.rs
index ffe3f50fa4..8641344fba 100644
--- a/pallets/subtensor/src/macros/config.rs
+++ b/pallets/subtensor/src/macros/config.rs
@@ -5,7 +5,7 @@ use frame_support::pallet_macros::pallet_section;
 /// This can later be imported into the pallet using [`import_section`].
 #[pallet_section]
 mod config {
-    
+
     use subtensor_swap_interface::SwapHandler;
 
     /// Configure the pallet by specifying the parameters and types on which it depends.
diff --git a/pallets/subtensor/src/staking/helpers.rs b/pallets/subtensor/src/staking/helpers.rs
index 433f925a17..2d103fa17f 100644
--- a/pallets/subtensor/src/staking/helpers.rs
+++ b/pallets/subtensor/src/staking/helpers.rs
@@ -204,7 +204,7 @@ impl<T: Config> Pallet<T> {
             Self::clear_small_nomination_if_required(&hotkey, &coldkey, netuid)?;
         }
 
-		Ok(())
+        Ok(())
     }
 
     pub fn add_balance_to_coldkey_account(
diff --git a/pallets/subtensor/src/staking/move_stake.rs b/pallets/subtensor/src/staking/move_stake.rs
index 50c22fd9b0..db3cd33e97 100644
--- a/pallets/subtensor/src/staking/move_stake.rs
+++ b/pallets/subtensor/src/staking/move_stake.rs
@@ -343,7 +343,7 @@ impl<T: Config> Pallet<T> {
             origin_coldkey,
             origin_netuid,
             move_amount,
-			T::SwapInterface::max_price(),
+            T::SwapInterface::max_price(),
         )?;
 
         // Stake the unstaked amount into the destination.
diff --git a/pallets/subtensor/src/subnets/registration.rs b/pallets/subtensor/src/subnets/registration.rs
index d27a79b649..a240e009ab 100644
--- a/pallets/subtensor/src/subnets/registration.rs
+++ b/pallets/subtensor/src/subnets/registration.rs
@@ -2,8 +2,8 @@ use super::*;
 use sp_core::{H256, U256};
 use sp_io::hashing::{keccak_256, sha2_256};
 use sp_runtime::Saturating;
-use system::pallet_prelude::BlockNumberFor;
 use subtensor_swap_interface::SwapHandler;
+use system::pallet_prelude::BlockNumberFor;
 
 const LOG_TARGET: &str = "runtime::subtensor::registration";
 
diff --git a/pallets/subtensor/src/tests/children.rs b/pallets/subtensor/src/tests/children.rs
index 34c7b5459b..9d31c8ab1a 100644
--- a/pallets/subtensor/src/tests/children.rs
+++ b/pallets/subtensor/src/tests/children.rs
@@ -5,6 +5,7 @@ use super::mock::*;
 use approx::assert_abs_diff_eq;
 use frame_support::{assert_err, assert_noop, assert_ok};
 use substrate_fixed::types::{I64F64, I96F32, U96F32};
+use subtensor_swap_interface::SwapHandler;
 
 use crate::{utils::rate_limiting::TransactionType, *};
 use sp_core::U256;
@@ -2955,10 +2956,15 @@ fn test_parent_child_chain_emission() {
         let stake_b = 100_000_000_000_u64;
         let stake_c = 50_000_000_000_u64;
         let total_tao: I96F32 = I96F32::from_num(stake_a + stake_b + stake_c);
-        let total_alpha: I96F32 = I96F32::from_num(SubtensorModule::swap_tao_for_alpha(
-            netuid,
-            total_tao.to_num::<u64>(),
-        ));
+        let total_alpha: I96F32 = I96F32::from_num(
+            SubtensorModule::swap_tao_for_alpha(
+                netuid,
+                total_tao.to_num::<u64>(),
+                <Test as Config>::SwapInterface::max_price(),
+            )
+            .unwrap()
+            .amount_paid_out,
+        );
 
         // Set the stakes directly
         // This avoids needing to swap tao to alpha, impacting the initial stake distribution.
@@ -3033,7 +3039,7 @@ fn test_parent_child_chain_emission() {
         PendingEmission::<Test>::insert(netuid, 0);
 
         // Run epoch with emission value
-        SubtensorModule::run_coinbase(emission);
+        SubtensorModule::run_coinbase(emission).unwrap();
 
         // Log new stake
         let stake_a_new: u64 = SubtensorModule::get_total_stake_for_hotkey(&hotkey_a);
@@ -3156,10 +3162,15 @@ fn test_parent_child_chain_epoch() {
 
         // Swap to alpha
         let total_tao: I96F32 = I96F32::from_num(300_000 + 100_000 + 50_000);
-        let total_alpha: I96F32 = I96F32::from_num(SubtensorModule::swap_tao_for_alpha(
-            netuid,
-            total_tao.saturating_to_num::<u64>(),
-        ));
+        let total_alpha = I96F32::from_num(
+            SubtensorModule::swap_tao_for_alpha(
+                netuid,
+                total_tao.saturating_to_num::<u64>(),
+                <Test as Config>::SwapInterface::max_price(),
+            )
+            .unwrap()
+            .amount_paid_out,
+        );
 
         // Set the stakes directly
         // This avoids needing to swap tao to alpha, impacting the initial stake distribution.
@@ -3287,10 +3298,15 @@ fn test_dividend_distribution_with_children() {
 
         // Swap to alpha
         let total_tao: I96F32 = I96F32::from_num(300_000 + 100_000 + 50_000);
-        let total_alpha: I96F32 = I96F32::from_num(SubtensorModule::swap_tao_for_alpha(
-            netuid,
-            total_tao.saturating_to_num::<u64>(),
-        ));
+        let total_alpha = I96F32::from_num(
+            SubtensorModule::swap_tao_for_alpha(
+                netuid,
+                total_tao.saturating_to_num::<u64>(),
+                <Test as Config>::SwapInterface::max_price(),
+            )
+            .unwrap()
+            .amount_paid_out,
+        );
 
         // Set the stakes directly
         // This avoids needing to swap tao to alpha, impacting the initial stake distribution.
@@ -3514,11 +3530,16 @@ fn test_dynamic_parent_child_relationships() {
         SubtensorModule::add_balance_to_coldkey_account(&coldkey_child2, 30_000 + 1_000);
 
         // Swap to alpha
-        let total_tao: I96F32 = I96F32::from_num(500_000 + 50_000 + 30_000);
-        let total_alpha: I96F32 = I96F32::from_num(SubtensorModule::swap_tao_for_alpha(
-            netuid,
-            total_tao.saturating_to_num::<u64>(),
-        ));
+        let total_tao = I96F32::from_num(500_000 + 50_000 + 30_000);
+        let total_alpha = I96F32::from_num(
+            SubtensorModule::swap_tao_for_alpha(
+                netuid,
+                total_tao.saturating_to_num::<u64>(),
+                <Test as Config>::SwapInterface::max_price(),
+            )
+            .unwrap()
+            .amount_paid_out,
+        );
         log::info!("total_alpha: {:?}", total_alpha);
 
         // Set the stakes directly
@@ -3807,10 +3828,15 @@ fn test_dividend_distribution_with_children_same_coldkey_owner() {
 
         // Swap to alpha
         let total_tao: I96F32 = I96F32::from_num(300_000 + 100_000);
-        let total_alpha: I96F32 = I96F32::from_num(SubtensorModule::swap_tao_for_alpha(
-            netuid,
-            total_tao.saturating_to_num::<u64>(),
-        ));
+        let total_alpha: I96F32 = I96F32::from_num(
+            SubtensorModule::swap_tao_for_alpha(
+                netuid,
+                total_tao.saturating_to_num::<u64>(),
+                <Test as Config>::SwapInterface::max_price(),
+            )
+            .unwrap()
+            .amount_paid_out,
+        );
 
         // Set the stakes directly
         // This avoids needing to swap tao to alpha, impacting the initial stake distribution.
diff --git a/pallets/subtensor/src/tests/coinbase.rs b/pallets/subtensor/src/tests/coinbase.rs
index 1345f36b7d..c8bd50f47f 100644
--- a/pallets/subtensor/src/tests/coinbase.rs
+++ b/pallets/subtensor/src/tests/coinbase.rs
@@ -73,7 +73,7 @@ fn test_dynamic_function_various_values() {
 #[test]
 fn test_coinbase_basecase() {
     new_test_ext(1).execute_with(|| {
-        SubtensorModule::run_coinbase(U96F32::from_num(0.0));
+        SubtensorModule::run_coinbase(U96F32::from_num(0.0)).unwrap();
     });
 }
 
@@ -90,7 +90,7 @@ fn test_coinbase_tao_issuance_base() {
         let emission: u64 = 1_234_567;
         add_network(netuid, 1, 0);
         assert_eq!(SubnetTAO::<Test>::get(netuid), 0);
-        SubtensorModule::run_coinbase(U96F32::from_num(emission));
+        SubtensorModule::run_coinbase(U96F32::from_num(emission)).unwrap();
         assert_eq!(SubnetTAO::<Test>::get(netuid), emission);
         assert_eq!(TotalIssuance::<Test>::get(), emission);
         assert_eq!(TotalStake::<Test>::get(), emission);
@@ -105,7 +105,7 @@ fn test_coinbase_tao_issuance_base_low() {
         let emission: u64 = 1;
         add_network(netuid, 1, 0);
         assert_eq!(SubnetTAO::<Test>::get(netuid), 0);
-        SubtensorModule::run_coinbase(U96F32::from_num(emission));
+        SubtensorModule::run_coinbase(U96F32::from_num(emission)).unwrap();
         assert_eq!(SubnetTAO::<Test>::get(netuid), emission);
         assert_eq!(TotalIssuance::<Test>::get(), emission);
         assert_eq!(TotalStake::<Test>::get(), emission);
@@ -132,7 +132,7 @@ fn test_coinbase_tao_issuance_multiple() {
         assert_eq!(SubnetTAO::<Test>::get(netuid1), 0);
         assert_eq!(SubnetTAO::<Test>::get(netuid2), 0);
         assert_eq!(SubnetTAO::<Test>::get(netuid3), 0);
-        SubtensorModule::run_coinbase(U96F32::from_num(emission));
+        SubtensorModule::run_coinbase(U96F32::from_num(emission)).unwrap();
         assert_eq!(SubnetTAO::<Test>::get(netuid1), emission / 3);
         assert_eq!(SubnetTAO::<Test>::get(netuid2), emission / 3);
         assert_eq!(SubnetTAO::<Test>::get(netuid3), emission / 3);
@@ -165,7 +165,7 @@ fn test_coinbase_tao_issuance_different_prices() {
         assert_eq!(SubnetTAO::<Test>::get(netuid1), 0);
         assert_eq!(SubnetTAO::<Test>::get(netuid2), 0);
         // Run the coinbase with the emission amount.
-        SubtensorModule::run_coinbase(U96F32::from_num(emission));
+        SubtensorModule::run_coinbase(U96F32::from_num(emission)).unwrap();
         // Assert tao emission is split evenly.
         assert_eq!(SubnetTAO::<Test>::get(netuid1), emission / 3);
         assert_eq!(SubnetTAO::<Test>::get(netuid2), emission / 3 + emission / 3);
@@ -305,7 +305,7 @@ fn test_coinbase_alpha_issuance_base() {
         SubnetTAO::<Test>::insert(netuid2, initial);
         SubnetAlphaIn::<Test>::insert(netuid2, initial);
         // Check initial
-        SubtensorModule::run_coinbase(U96F32::from_num(emission));
+        SubtensorModule::run_coinbase(U96F32::from_num(emission)).unwrap();
         // tao_in = 500_000
         // alpha_in = 500_000/price = 500_000
         assert_eq!(SubnetAlphaIn::<Test>::get(netuid1), initial + emission / 2);
@@ -340,7 +340,7 @@ fn test_coinbase_alpha_issuance_different() {
         SubnetMovingPrice::<Test>::insert(netuid1, I96F32::from_num(1));
         SubnetMovingPrice::<Test>::insert(netuid2, I96F32::from_num(2));
         // Run coinbase
-        SubtensorModule::run_coinbase(U96F32::from_num(emission));
+        SubtensorModule::run_coinbase(U96F32::from_num(emission)).unwrap();
         // tao_in = 333_333
         // alpha_in = 333_333/price = 333_333 + initial
         assert_eq!(SubnetAlphaIn::<Test>::get(netuid1), initial + emission / 3);
@@ -376,7 +376,7 @@ fn test_coinbase_alpha_issuance_with_cap_trigger() {
         SubnetMovingPrice::<Test>::insert(netuid1, I96F32::from_num(1));
         SubnetMovingPrice::<Test>::insert(netuid2, I96F32::from_num(2));
         // Run coinbase
-        SubtensorModule::run_coinbase(U96F32::from_num(emission));
+        SubtensorModule::run_coinbase(U96F32::from_num(emission)).unwrap();
         // tao_in = 333_333
         // alpha_in = 333_333/price > 1_000_000_000 --> 1_000_000_000 + initial_alpha
         assert_eq!(
@@ -420,7 +420,7 @@ fn test_coinbase_alpha_issuance_with_cap_trigger_and_block_emission() {
         SubnetMovingPrice::<Test>::insert(netuid1, I96F32::from_num(1));
         SubnetMovingPrice::<Test>::insert(netuid2, I96F32::from_num(2));
         // Run coinbase
-        SubtensorModule::run_coinbase(U96F32::from_num(emission));
+        SubtensorModule::run_coinbase(U96F32::from_num(emission)).unwrap();
         // tao_in = 333_333
         // alpha_in = 333_333/price > 1_000_000_000 --> 0 + initial_alpha
         assert_eq!(SubnetAlphaIn::<Test>::get(netuid1), initial_alpha);
@@ -441,10 +441,10 @@ fn test_owner_cut_base() {
         add_network(netuid, 1, 0);
         SubtensorModule::set_tempo(netuid, 10000); // Large number (dont drain)
         SubtensorModule::set_subnet_owner_cut(0);
-        SubtensorModule::run_coinbase(U96F32::from_num(0));
+        SubtensorModule::run_coinbase(U96F32::from_num(0)).unwrap();
         assert_eq!(PendingOwnerCut::<Test>::get(netuid), 0); // No cut
         SubtensorModule::set_subnet_owner_cut(u16::MAX);
-        SubtensorModule::run_coinbase(U96F32::from_num(0));
+        SubtensorModule::run_coinbase(U96F32::from_num(0)).unwrap();
         assert_eq!(PendingOwnerCut::<Test>::get(netuid), 1_000_000_000); // Full cut.
     });
 }
@@ -456,14 +456,14 @@ fn test_pending_swapped() {
         let netuid: u16 = 1;
         let emission: u64 = 1_000_000;
         add_network(netuid, 1, 0);
-        SubtensorModule::run_coinbase(U96F32::from_num(0));
+        SubtensorModule::run_coinbase(U96F32::from_num(0)).unwrap();
         assert_eq!(PendingAlphaSwapped::<Test>::get(netuid), 0); // Zero tao weight and no root.
         SubnetTAO::<Test>::insert(0, 1_000_000_000); // Add root weight.
-        SubtensorModule::run_coinbase(U96F32::from_num(0));
+        SubtensorModule::run_coinbase(U96F32::from_num(0)).unwrap();
         assert_eq!(PendingAlphaSwapped::<Test>::get(netuid), 0); // Zero tao weight with 1 root.
         SubtensorModule::set_tempo(netuid, 10000); // Large number (dont drain)
         SubtensorModule::set_tao_weight(u64::MAX); // Set TAO weight to 1.0
-        SubtensorModule::run_coinbase(U96F32::from_num(0));
+        SubtensorModule::run_coinbase(U96F32::from_num(0)).unwrap();
         assert_eq!(PendingAlphaSwapped::<Test>::get(netuid), 125000000); // 1 TAO / ( 1 + 3 ) = 0.25 * 1 / 2 = 125000000
         assert_eq!(
             PendingEmission::<Test>::get(netuid),
@@ -2018,7 +2018,7 @@ fn test_run_coinbase_not_started() {
         assert!(SubtensorModule::should_run_epoch(netuid, current_block));
 
         // Run coinbase with emission.
-        SubtensorModule::run_coinbase(U96F32::saturating_from_num(100_000_000));
+        SubtensorModule::run_coinbase(U96F32::saturating_from_num(100_000_000)).unwrap();
 
         // We expect that the epoch ran.
         assert_eq!(BlocksSinceLastStep::<Test>::get(netuid), 0);
@@ -2100,7 +2100,7 @@ fn test_run_coinbase_not_started_start_after() {
         assert!(SubtensorModule::should_run_epoch(netuid, current_block));
 
         // Run coinbase with emission.
-        SubtensorModule::run_coinbase(U96F32::saturating_from_num(100_000_000));
+        SubtensorModule::run_coinbase(U96F32::saturating_from_num(100_000_000)).unwrap();
         // We expect that the epoch ran.
         assert_eq!(BlocksSinceLastStep::<Test>::get(netuid), 0);
 
@@ -2120,7 +2120,7 @@ fn test_run_coinbase_not_started_start_after() {
         );
 
         // Run coinbase with emission.
-        SubtensorModule::run_coinbase(U96F32::saturating_from_num(100_000_000));
+        SubtensorModule::run_coinbase(U96F32::saturating_from_num(100_000_000)).unwrap();
         // We expect that the epoch ran.
         assert_eq!(BlocksSinceLastStep::<Test>::get(netuid), 0);
 
diff --git a/pallets/subtensor/src/tests/mock.rs b/pallets/subtensor/src/tests/mock.rs
index 177a9dbc6e..34c9453cf5 100644
--- a/pallets/subtensor/src/tests/mock.rs
+++ b/pallets/subtensor/src/tests/mock.rs
@@ -20,7 +20,7 @@ use sp_runtime::{
 };
 use sp_std::cmp::Ordering;
 use substrate_fixed::types::U64F64;
-use subtensor_swap_interface::LiquidityDataProvider;
+use subtensor_swap_interface::{LiquidityDataProvider, SwapHandler};
 
 use crate::*;
 
@@ -417,24 +417,6 @@ impl crate::Config for Test {
     type SwapInterface = Swap;
 }
 
-impl LiquidityDataProvider<AccountId> for SubtensorModule {
-    fn tao_reserve(netuid: u16) -> u64 {
-        SubnetTAO::<Test>::get(netuid)
-    }
-
-    fn alpha_reserve(netuid: u16) -> u64 {
-        SubnetAlphaIn::<Test>::get(netuid)
-    }
-
-    fn tao_balance(account_id: &AccountId) -> u64 {
-        Balances::free_balance(account_id)
-    }
-
-    fn alpha_balance(netuid: u16, coldkey: &AccountId, hotkey: &AccountId) -> u64 {
-        SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(hotkey, coldkey, netuid)
-    }
-}
-
 // Swap-related parameter types
 parameter_types! {
     pub const SwapProtocolId: PalletId = PalletId(*b"ten/swap");
@@ -846,8 +828,14 @@ pub fn increase_stake_on_coldkey_hotkey_account(
     tao_staked: u64,
     netuid: u16,
 ) {
-    let fee = 0;
-    SubtensorModule::stake_into_subnet(hotkey, coldkey, netuid, tao_staked, fee);
+    SubtensorModule::stake_into_subnet(
+        hotkey,
+        coldkey,
+        netuid,
+        tao_staked,
+        <Test as Config>::SwapInterface::max_price(),
+    )
+    .unwrap();
 }
 
 /// Increases the stake on the hotkey account under its owning coldkey.
diff --git a/pallets/subtensor/src/tests/move_stake.rs b/pallets/subtensor/src/tests/move_stake.rs
index 0b7584a4f0..0b073d58a9 100644
--- a/pallets/subtensor/src/tests/move_stake.rs
+++ b/pallets/subtensor/src/tests/move_stake.rs
@@ -4,6 +4,7 @@ use approx::assert_abs_diff_eq;
 use frame_support::{assert_err, assert_noop, assert_ok};
 use sp_core::{Get, U256};
 use substrate_fixed::types::{U64F64, U96F32};
+use subtensor_swap_interface::SwapHandler;
 
 // 1. test_do_move_success
 // Description: Test a successful move of stake between two hotkeys in the same subnet
@@ -23,7 +24,14 @@ fn test_do_move_success() {
         // Set up initial stake
         SubtensorModule::create_account_if_non_existent(&coldkey, &origin_hotkey);
         SubtensorModule::create_account_if_non_existent(&coldkey, &destination_hotkey);
-        SubtensorModule::stake_into_subnet(&origin_hotkey, &coldkey, netuid, stake_amount, fee);
+        SubtensorModule::stake_into_subnet(
+            &origin_hotkey,
+            &coldkey,
+            netuid,
+            stake_amount,
+            <Test as Config>::SwapInterface::max_price(),
+        )
+        .unwrap();
         let alpha = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
             &origin_hotkey,
             &coldkey,
@@ -85,8 +93,9 @@ fn test_do_move_different_subnets() {
             &coldkey,
             origin_netuid,
             stake_amount,
-            fee,
-        );
+            <Test as Config>::SwapInterface::max_price(),
+        )
+        .unwrap();
         let alpha = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
             &origin_hotkey,
             &coldkey,
@@ -151,8 +160,9 @@ fn test_do_move_nonexistent_subnet() {
             &coldkey,
             origin_netuid,
             stake_amount,
-            fee,
-        );
+            <Test as Config>::SwapInterface::max_price(),
+        )
+        .unwrap();
         let alpha = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
             &origin_hotkey,
             &coldkey,
@@ -242,12 +252,17 @@ fn test_do_move_nonexistent_destination_hotkey() {
         let nonexistent_destination_hotkey = U256::from(99); // Assuming this hotkey doesn't exist
         let netuid = 1;
         let stake_amount = 1_000_000;
-        let fee = 0;
 
         // Set up initial stake
         SubtensorModule::create_account_if_non_existent(&coldkey, &origin_hotkey);
-        let alpha =
-            SubtensorModule::stake_into_subnet(&origin_hotkey, &coldkey, netuid, stake_amount, fee);
+        let alpha = SubtensorModule::stake_into_subnet(
+            &origin_hotkey,
+            &coldkey,
+            netuid,
+            stake_amount,
+            <Test as Config>::SwapInterface::max_price(),
+        )
+        .unwrap();
 
         // Attempt to move stake from a non-existent origin hotkey
         add_network(netuid, 1, 0);
@@ -299,7 +314,14 @@ fn test_do_move_all_stake() {
         let fee = DefaultStakingFee::<Test>::get();
 
         // Set up initial stake
-        SubtensorModule::stake_into_subnet(&origin_hotkey, &coldkey, netuid, stake_amount, fee);
+        SubtensorModule::stake_into_subnet(
+            &origin_hotkey,
+            &coldkey,
+            netuid,
+            stake_amount,
+            <Test as Config>::SwapInterface::max_price(),
+        )
+        .unwrap();
         let alpha = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
             &origin_hotkey,
             &coldkey,
@@ -352,7 +374,14 @@ fn test_do_move_half_stake() {
         let fee = DefaultStakingFee::<Test>::get();
 
         // Set up initial stake
-        SubtensorModule::stake_into_subnet(&origin_hotkey, &coldkey, netuid, stake_amount, fee);
+        SubtensorModule::stake_into_subnet(
+            &origin_hotkey,
+            &coldkey,
+            netuid,
+            stake_amount,
+            <Test as Config>::SwapInterface::max_price(),
+        )
+        .unwrap();
         let alpha = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
             &origin_hotkey,
             &coldkey,
@@ -409,7 +438,14 @@ fn test_do_move_partial_stake() {
         let fee = DefaultStakingFee::<Test>::get();
 
         // Set up initial stake
-        SubtensorModule::stake_into_subnet(&origin_hotkey, &coldkey, netuid, total_stake, fee);
+        SubtensorModule::stake_into_subnet(
+            &origin_hotkey,
+            &coldkey,
+            netuid,
+            total_stake,
+            <Test as Config>::SwapInterface::max_price(),
+        )
+        .unwrap();
         let alpha = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
             &origin_hotkey,
             &coldkey,
@@ -467,7 +503,14 @@ fn test_do_move_multiple_times() {
         // Set up initial stake
         SubtensorModule::create_account_if_non_existent(&coldkey, &hotkey1);
         SubtensorModule::create_account_if_non_existent(&coldkey, &hotkey2);
-        SubtensorModule::stake_into_subnet(&hotkey1, &coldkey, netuid, initial_stake, fee);
+        SubtensorModule::stake_into_subnet(
+            &hotkey1,
+            &coldkey,
+            netuid,
+            initial_stake,
+            <Test as Config>::SwapInterface::max_price(),
+        )
+        .unwrap();
 
         // Move stake multiple times
         for _ in 0..3 {
@@ -523,7 +566,14 @@ fn test_do_move_wrong_origin() {
         let fee = 0;
 
         // Set up initial stake
-        SubtensorModule::stake_into_subnet(&origin_hotkey, &coldkey, netuid, stake_amount, fee);
+        SubtensorModule::stake_into_subnet(
+            &origin_hotkey,
+            &coldkey,
+            netuid,
+            stake_amount,
+            <Test as Config>::SwapInterface::max_price(),
+        )
+        .unwrap();
         let alpha = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
             &origin_hotkey,
             &coldkey,
@@ -582,7 +632,14 @@ fn test_do_move_same_hotkey() {
 
         // Set up initial stake
         SubtensorModule::create_account_if_non_existent(&coldkey, &hotkey);
-        SubtensorModule::stake_into_subnet(&hotkey, &coldkey, netuid, stake_amount, fee);
+        SubtensorModule::stake_into_subnet(
+            &hotkey,
+            &coldkey,
+            netuid,
+            stake_amount,
+            <Test as Config>::SwapInterface::max_price(),
+        )
+        .unwrap();
         let alpha =
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid);
 
@@ -623,7 +680,14 @@ fn test_do_move_event_emission() {
         // Set up initial stake
         SubtensorModule::create_account_if_non_existent(&coldkey, &origin_hotkey);
         SubtensorModule::create_account_if_non_existent(&coldkey, &destination_hotkey);
-        SubtensorModule::stake_into_subnet(&origin_hotkey, &coldkey, netuid, stake_amount, 0); // use 0 fee for precision
+        SubtensorModule::stake_into_subnet(
+            &origin_hotkey,
+            &coldkey,
+            netuid,
+            stake_amount,
+            <Test as Config>::SwapInterface::max_price(),
+        )
+        .unwrap();
         let alpha = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
             &origin_hotkey,
             &coldkey,
@@ -678,8 +742,9 @@ fn test_do_move_storage_updates() {
             &coldkey,
             origin_netuid,
             stake_amount,
-            fee,
-        );
+            <Test as Config>::SwapInterface::max_price(),
+        )
+        .unwrap();
 
         // Move stake
         SubtensorModule::create_account_if_non_existent(&coldkey, &origin_hotkey);
@@ -747,7 +812,14 @@ fn test_do_move_max_values() {
         SubnetTAO::<Test>::insert(netuid, u64::MAX / 1000);
         SubnetAlphaIn::<Test>::insert(netuid, u64::MAX / 1000);
 
-        SubtensorModule::stake_into_subnet(&origin_hotkey, &coldkey, netuid, max_stake, fee);
+        SubtensorModule::stake_into_subnet(
+            &origin_hotkey,
+            &coldkey,
+            netuid,
+            max_stake,
+            <Test as Config>::SwapInterface::max_price(),
+        )
+        .unwrap();
         let alpha = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
             &origin_hotkey,
             &coldkey,
@@ -840,7 +912,14 @@ fn test_do_transfer_success() {
         // 3. Set up initial stake: (origin_coldkey, hotkey) on netuid.
         SubtensorModule::create_account_if_non_existent(&origin_coldkey, &hotkey);
         SubtensorModule::create_account_if_non_existent(&destination_coldkey, &hotkey);
-        SubtensorModule::stake_into_subnet(&hotkey, &origin_coldkey, netuid, stake_amount, 0);
+        SubtensorModule::stake_into_subnet(
+            &hotkey,
+            &origin_coldkey,
+            netuid,
+            stake_amount,
+            <Test as Config>::SwapInterface::max_price(),
+        )
+        .unwrap();
         let alpha = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
             &hotkey,
             &origin_coldkey,
@@ -939,7 +1018,14 @@ fn test_do_transfer_insufficient_stake() {
         let stake_amount = DefaultMinStake::<Test>::get() * 10;
 
         SubtensorModule::create_account_if_non_existent(&origin_coldkey, &hotkey);
-        SubtensorModule::stake_into_subnet(&hotkey, &origin_coldkey, netuid, stake_amount, 0);
+        SubtensorModule::stake_into_subnet(
+            &hotkey,
+            &origin_coldkey,
+            netuid,
+            stake_amount,
+            <Test as Config>::SwapInterface::max_price(),
+        )
+        .unwrap();
 
         let alpha = stake_amount * 2;
         assert_noop!(
@@ -972,7 +1058,14 @@ fn test_do_transfer_wrong_origin() {
 
         SubtensorModule::create_account_if_non_existent(&origin_coldkey, &hotkey);
         SubtensorModule::add_balance_to_coldkey_account(&origin_coldkey, stake_amount + fee);
-        SubtensorModule::stake_into_subnet(&hotkey, &origin_coldkey, netuid, stake_amount, fee);
+        SubtensorModule::stake_into_subnet(
+            &hotkey,
+            &origin_coldkey,
+            netuid,
+            stake_amount,
+            <Test as Config>::SwapInterface::max_price(),
+        )
+        .unwrap();
 
         assert_noop!(
             SubtensorModule::do_transfer_stake(
@@ -1001,7 +1094,14 @@ fn test_do_transfer_minimum_stake_check() {
 
         let stake_amount = DefaultMinStake::<Test>::get();
         SubtensorModule::create_account_if_non_existent(&origin_coldkey, &hotkey);
-        SubtensorModule::stake_into_subnet(&hotkey, &origin_coldkey, netuid, stake_amount, 0);
+        SubtensorModule::stake_into_subnet(
+            &hotkey,
+            &origin_coldkey,
+            netuid,
+            stake_amount,
+            <Test as Config>::SwapInterface::max_price(),
+        )
+        .unwrap();
 
         assert_err!(
             SubtensorModule::do_transfer_stake(
@@ -1046,8 +1146,9 @@ fn test_do_transfer_different_subnets() {
             &origin_coldkey,
             origin_netuid,
             stake_amount,
-            0,
-        );
+            <Test as Config>::SwapInterface::max_price(),
+        )
+        .unwrap();
 
         // 6. Transfer entire stake from origin_netuid -> destination_netuid.
         let alpha = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
@@ -1104,7 +1205,14 @@ fn test_do_swap_success() {
         let fee = DefaultStakingFee::<Test>::get();
 
         SubtensorModule::create_account_if_non_existent(&coldkey, &hotkey);
-        SubtensorModule::stake_into_subnet(&hotkey, &coldkey, origin_netuid, stake_amount, 0);
+        SubtensorModule::stake_into_subnet(
+            &hotkey,
+            &coldkey,
+            origin_netuid,
+            stake_amount,
+            <Test as Config>::SwapInterface::max_price(),
+        )
+        .unwrap();
         let alpha_before = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
             &hotkey,
             &coldkey,
@@ -1208,7 +1316,14 @@ fn test_do_swap_insufficient_stake() {
         let attempted_swap = stake_amount * 2;
 
         SubtensorModule::create_account_if_non_existent(&coldkey, &hotkey);
-        SubtensorModule::stake_into_subnet(&hotkey, &coldkey, netuid1, stake_amount, 0);
+        SubtensorModule::stake_into_subnet(
+            &hotkey,
+            &coldkey,
+            netuid1,
+            stake_amount,
+            <Test as Config>::SwapInterface::max_price(),
+        )
+        .unwrap();
 
         assert_noop!(
             SubtensorModule::do_swap_stake(
@@ -1237,7 +1352,14 @@ fn test_do_swap_wrong_origin() {
         let stake_amount = 100_000;
 
         SubtensorModule::create_account_if_non_existent(&real_coldkey, &hotkey);
-        SubtensorModule::stake_into_subnet(&hotkey, &real_coldkey, netuid1, stake_amount, 0);
+        SubtensorModule::stake_into_subnet(
+            &hotkey,
+            &real_coldkey,
+            netuid1,
+            stake_amount,
+            <Test as Config>::SwapInterface::max_price(),
+        )
+        .unwrap();
 
         assert_noop!(
             SubtensorModule::do_swap_stake(
@@ -1265,7 +1387,14 @@ fn test_do_swap_minimum_stake_check() {
         let swap_amount = 1;
 
         SubtensorModule::create_account_if_non_existent(&coldkey, &hotkey);
-        SubtensorModule::stake_into_subnet(&hotkey, &coldkey, netuid, total_stake, 0);
+        SubtensorModule::stake_into_subnet(
+            &hotkey,
+            &coldkey,
+            netuid,
+            total_stake,
+            <Test as Config>::SwapInterface::max_price(),
+        )
+        .unwrap();
 
         assert_err!(
             SubtensorModule::do_swap_stake(
@@ -1293,11 +1422,24 @@ fn test_do_swap_same_subnet() {
         let fee = DefaultStakingFee::<Test>::get();
 
         SubtensorModule::create_account_if_non_existent(&coldkey, &hotkey);
-        SubtensorModule::stake_into_subnet(&hotkey, &coldkey, netuid, stake_amount, 0);
+        SubtensorModule::stake_into_subnet(
+            &hotkey,
+            &coldkey,
+            netuid,
+            stake_amount,
+            <Test as Config>::SwapInterface::max_price(),
+        )
+        .unwrap();
 
         let alpha_before =
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid);
-        let fee_as_alpha = SubtensorModule::swap_tao_for_alpha(netuid, fee);
+        let fee_as_alpha = SubtensorModule::swap_tao_for_alpha(
+            netuid,
+            fee,
+            <Test as Config>::SwapInterface::max_price(),
+        )
+        .unwrap()
+        .amount_paid_out;
 
         assert_ok!(SubtensorModule::do_swap_stake(
             RuntimeOrigin::signed(coldkey),
@@ -1331,7 +1473,14 @@ fn test_do_swap_partial_stake() {
         let fee = DefaultStakingFee::<Test>::get();
 
         SubtensorModule::create_account_if_non_existent(&coldkey, &hotkey);
-        SubtensorModule::stake_into_subnet(&hotkey, &coldkey, origin_netuid, total_stake, 0);
+        SubtensorModule::stake_into_subnet(
+            &hotkey,
+            &coldkey,
+            origin_netuid,
+            total_stake,
+            <Test as Config>::SwapInterface::max_price(),
+        )
+        .unwrap();
 
         let swap_amount = total_stake / 2;
         assert_ok!(SubtensorModule::do_swap_stake(
@@ -1383,7 +1532,14 @@ fn test_do_swap_storage_updates() {
         let fee = DefaultStakingFee::<Test>::get();
 
         SubtensorModule::create_account_if_non_existent(&coldkey, &hotkey);
-        SubtensorModule::stake_into_subnet(&hotkey, &coldkey, origin_netuid, stake_amount, 0);
+        SubtensorModule::stake_into_subnet(
+            &hotkey,
+            &coldkey,
+            origin_netuid,
+            stake_amount,
+            <Test as Config>::SwapInterface::max_price(),
+        )
+        .unwrap();
 
         let alpha = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
             &hotkey,
@@ -1438,7 +1594,14 @@ fn test_do_swap_multiple_times() {
         let fee = DefaultStakingFee::<Test>::get();
 
         SubtensorModule::create_account_if_non_existent(&coldkey, &hotkey);
-        SubtensorModule::stake_into_subnet(&hotkey, &coldkey, netuid1, initial_stake, 0);
+        SubtensorModule::stake_into_subnet(
+            &hotkey,
+            &coldkey,
+            netuid1,
+            initial_stake,
+            <Test as Config>::SwapInterface::max_price(),
+        )
+        .unwrap();
 
         let mut total_alpha1_fee = 0;
         for _ in 0..3 {
@@ -1454,7 +1617,13 @@ fn test_do_swap_multiple_times() {
                     alpha1
                 ));
 
-                let fee_as_alpha = SubtensorModule::swap_tao_for_alpha(netuid1, fee);
+                let fee_as_alpha = SubtensorModule::swap_tao_for_alpha(
+                    netuid1,
+                    fee,
+                    <Test as Config>::SwapInterface::max_price(),
+                )
+                .unwrap()
+                .amount_paid_out;
                 total_alpha1_fee += fee_as_alpha;
             }
             let alpha2 = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
@@ -1469,7 +1638,13 @@ fn test_do_swap_multiple_times() {
                     alpha2
                 ));
 
-                let fee_as_alpha = SubtensorModule::swap_tao_for_alpha(netuid1, fee);
+                let fee_as_alpha = SubtensorModule::swap_tao_for_alpha(
+                    netuid1,
+                    fee,
+                    <Test as Config>::SwapInterface::max_price(),
+                )
+                .unwrap()
+                .amount_paid_out;
                 total_alpha1_fee += fee_as_alpha;
             }
         }
@@ -1503,7 +1678,14 @@ fn test_do_swap_allows_non_owned_hotkey() {
         let stake_amount = DefaultMinStake::<Test>::get() * 10;
 
         SubtensorModule::create_account_if_non_existent(&foreign_coldkey, &hotkey);
-        SubtensorModule::stake_into_subnet(&hotkey, &coldkey, origin_netuid, stake_amount, 0);
+        SubtensorModule::stake_into_subnet(
+            &hotkey,
+            &coldkey,
+            origin_netuid,
+            stake_amount,
+            <Test as Config>::SwapInterface::max_price(),
+        )
+        .unwrap();
         let alpha_before = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
             &hotkey,
             &coldkey,
@@ -1537,8 +1719,14 @@ fn test_swap_stake_limit_validate() {
         let stake_amount = 100_000_000_000;
 
         SubtensorModule::create_account_if_non_existent(&coldkey, &hotkey);
-        let unstake_amount =
-            SubtensorModule::stake_into_subnet(&hotkey, &coldkey, origin_netuid, stake_amount, 0);
+        let unstake_amount = SubtensorModule::stake_into_subnet(
+            &hotkey,
+            &coldkey,
+            origin_netuid,
+            stake_amount,
+            <Test as Config>::SwapInterface::max_price(),
+        )
+        .unwrap();
 
         // Setup limit price so that it doesn't allow much slippage at all
         let limit_price = ((SubtensorModule::get_alpha_price(origin_netuid)
@@ -1591,8 +1779,14 @@ fn test_stake_transfers_disabled_validate() {
         let stake_amount = 100_000_000_000;
 
         SubtensorModule::create_account_if_non_existent(&coldkey, &hotkey);
-        let unstake_amount =
-            SubtensorModule::stake_into_subnet(&hotkey, &coldkey, origin_netuid, stake_amount, 0);
+        let unstake_amount = SubtensorModule::stake_into_subnet(
+            &hotkey,
+            &coldkey,
+            origin_netuid,
+            stake_amount,
+            <Test as Config>::SwapInterface::max_price(),
+        )
+        .unwrap();
 
         // Swap stake limit call
         let call = RuntimeCall::SubtensorModule(SubtensorCall::transfer_stake {
diff --git a/pallets/subtensor/src/tests/staking.rs b/pallets/subtensor/src/tests/staking.rs
index 8fe5964311..f7dfaccaf3 100644
--- a/pallets/subtensor/src/tests/staking.rs
+++ b/pallets/subtensor/src/tests/staking.rs
@@ -1,18 +1,19 @@
 #![allow(clippy::unwrap_used)]
 #![allow(clippy::arithmetic_side_effects)]
 
+use approx::assert_abs_diff_eq;
+use frame_support::dispatch::{DispatchClass, DispatchInfo, GetDispatchInfo, Pays};
+use frame_support::sp_runtime::DispatchError;
 use frame_support::{assert_err, assert_noop, assert_ok, traits::Currency};
 use frame_system::RawOrigin;
 use safe_math::FixedExt;
+use sp_core::{Get, H256, U256};
 use substrate_fixed::traits::FromFixed;
+use substrate_fixed::types::{I96F32, I110F18, U64F64, U96F32};
+use subtensor_swap_interface::{OrderType, SwapHandler};
 
 use super::mock::*;
 use crate::*;
-use approx::assert_abs_diff_eq;
-use frame_support::dispatch::{DispatchClass, DispatchInfo, GetDispatchInfo, Pays};
-use frame_support::sp_runtime::DispatchError;
-use sp_core::{Get, H256, U256};
-use substrate_fixed::types::{I96F32, I110F18, U64F64, U96F32};
 
 /***********************************************************
     staking::add_stake() tests
@@ -401,13 +402,7 @@ fn test_remove_stake_ok_no_emission() {
             amount
         ));
 
-        let fee = SubtensorModule::calculate_staking_fee(
-            Some((&hotkey_account_id, netuid)),
-            &coldkey_account_id,
-            None,
-            &coldkey_account_id,
-            U96F32::saturating_from_num(amount),
-        );
+        let fee = <Test as Config>::SwapInterface::approx_fee_amount(netuid, amount);
 
         // we do not expect the exact amount due to slippage
         assert!(SubtensorModule::get_coldkey_balance(&coldkey_account_id) > amount / 10 * 9 - fee);
@@ -582,13 +577,7 @@ fn test_remove_stake_total_balance_no_change() {
             amount
         ));
 
-        let fee = SubtensorModule::calculate_staking_fee(
-            Some((&hotkey_account_id, netuid)),
-            &coldkey_account_id,
-            None,
-            &coldkey_account_id,
-            U96F32::saturating_from_num(amount),
-        );
+        let fee = <Test as Config>::SwapInterface::approx_fee_amount(netuid, amount);
         assert_abs_diff_eq!(
             SubtensorModule::get_coldkey_balance(&coldkey_account_id),
             amount - fee,
@@ -661,7 +650,14 @@ fn test_remove_stake_insufficient_liquidity() {
         // Simulate stake for hotkey
         SubnetTAO::<Test>::insert(netuid, u64::MAX / 1000);
         SubnetAlphaIn::<Test>::insert(netuid, u64::MAX / 1000);
-        let alpha = SubtensorModule::stake_into_subnet(&hotkey, &coldkey, netuid, amount_staked, 0);
+        let alpha = SubtensorModule::stake_into_subnet(
+            &hotkey,
+            &coldkey,
+            netuid,
+            amount_staked,
+            <Test as Config>::SwapInterface::max_price(),
+        )
+        .unwrap();
 
         // Set the liquidity at lowest possible value so that all staking requests fail
         SubnetTAO::<Test>::insert(
@@ -1513,7 +1509,7 @@ fn test_clear_small_nominations() {
         // Run clear all small nominations when min stake is zero (noop)
         SubtensorModule::set_nominator_min_required_stake(0);
         assert_eq!(SubtensorModule::get_nominator_min_required_stake(), 0);
-        SubtensorModule::clear_small_nominations();
+        SubtensorModule::clear_small_nominations().unwrap();
         assert_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hot1, &cold1, netuid),
             100
@@ -1540,7 +1536,7 @@ fn test_clear_small_nominations() {
         SubtensorModule::set_nominator_min_required_stake(1000);
 
         // Run clear all small nominations (removes delegations under 10)
-        SubtensorModule::clear_small_nominations();
+        SubtensorModule::clear_small_nominations().unwrap();
         assert_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hot1, &cold1, netuid),
             100
@@ -2478,8 +2474,15 @@ fn test_remove_stake_fee_realistic_values() {
 
         // Remove stake to measure fee
         let balance_before = SubtensorModule::get_coldkey_balance(&coldkey);
-        let expected_tao_no_fee =
-            SubtensorModule::sim_swap_alpha_for_tao(netuid, alpha_to_unstake).unwrap();
+        let expected_tao_no_fee = <Test as Config>::SwapInterface::swap(
+            netuid,
+            OrderType::Sell,
+            alpha_to_unstake,
+            <Test as Config>::SwapInterface::max_price(),
+            true,
+        )
+        .unwrap()
+        .amount_paid_out;
 
         // Estimate fees
         let mut expected_fee =
@@ -2800,7 +2803,14 @@ fn test_unstake_low_liquidity_validate() {
         // Simulate stake for hotkey
         SubnetTAO::<Test>::insert(netuid, u64::MAX / 1000);
         SubnetAlphaIn::<Test>::insert(netuid, u64::MAX / 1000);
-        let alpha = SubtensorModule::stake_into_subnet(&hotkey, &coldkey, netuid, amount_staked, 0);
+        let alpha = SubtensorModule::stake_into_subnet(
+            &hotkey,
+            &coldkey,
+            netuid,
+            amount_staked,
+            <Test as Config>::SwapInterface::max_price(),
+        )
+        .unwrap();
 
         // Set the liquidity at lowest possible value so that all staking requests fail
         SubnetTAO::<Test>::insert(
@@ -3975,8 +3985,8 @@ fn test_remove_stake_limit_fill_or_kill() {
 //             &coldkey_account_id,
 //             netuid,
 //             tao_staked,
-//             fee,
-//         );
+// 			   <Test as Config>::SwapInterface::max_price(),
+//         ).unwrap();
 
 //         // Check the stake and shares are correct
 //         assert!(Alpha::<Test>::get((&hotkey_account_id, &coldkey_account_id, netuid)) > 0);
@@ -4043,8 +4053,15 @@ fn test_add_stake_specific_stake_into_subnet_fail() {
         );
 
         // Add stake as new hotkey
-        let expected_alpha =
-            SubtensorModule::sim_swap_tao_for_alpha(netuid, tao_staked).unwrap_or(0);
+        let expected_alpha = <Test as Config>::SwapInterface::swap(
+            netuid,
+            OrderType::Buy,
+            tao_staked,
+            <Test as Config>::SwapInterface::max_price(),
+            true,
+        )
+        .map(|v| v.amount_paid_out)
+        .unwrap_or_default();
         assert_ok!(SubtensorModule::add_stake(
             RuntimeOrigin::signed(coldkey_account_id),
             hotkey_account_id,
diff --git a/pallets/subtensor/src/tests/staking2.rs b/pallets/subtensor/src/tests/staking2.rs
index 9dffa2fef3..1ea686c98b 100644
--- a/pallets/subtensor/src/tests/staking2.rs
+++ b/pallets/subtensor/src/tests/staking2.rs
@@ -30,7 +30,13 @@ fn test_stake_base_case() {
         let initial_total_stake = TotalStake::<Test>::get();
 
         // Perform swap
-        let alpha_received = SubtensorModule::swap_tao_for_alpha(netuid, tao_to_swap);
+        let alpha_received = SubtensorModule::swap_tao_for_alpha(
+            netuid,
+            tao_to_swap,
+            <Test as Config>::SwapInterface::max_price(),
+        )
+        .unwrap()
+        .amount_paid_out;
 
         // Verify correct alpha calculation using constant product formula
         let k: I96F32 =
@@ -670,7 +676,7 @@ fn test_stake_fee_api() {
             stake_amount,
         );
         let dynamic_fee_0 =
-            <SubtensorModule as Config>::SwapInterface::approx_fee_amount(netuid0, stake_amount);
+            <Test as Config>::SwapInterface::approx_fee_amount(netuid0, stake_amount);
         assert_eq!(stake_fee_0, dynamic_fee_0);
 
         // Test stake fee for remove on root
@@ -681,10 +687,8 @@ fn test_stake_fee_api() {
             coldkey1,
             stake_amount,
         );
-        let dynamic_fee_1 = <SubtensorModule as Config>::SwapInterface::approx_fee_amount(
-            root_netuid,
-            stake_amount,
-        );
+        let dynamic_fee_1 =
+            <Test as Config>::SwapInterface::approx_fee_amount(root_netuid, stake_amount);
         assert_eq!(stake_fee_1, dynamic_fee_1);
 
         // Test stake fee for move from root to non-root
@@ -696,7 +700,7 @@ fn test_stake_fee_api() {
             stake_amount,
         );
         let dynamic_fee_2 =
-            <SubtensorModule as Config>::SwapInterface::approx_fee_amount(netuid0, stake_amount);
+            <Test as Config>::SwapInterface::approx_fee_amount(netuid0, stake_amount);
         assert_eq!(stake_fee_2, dynamic_fee_2);
 
         // Test stake fee for move between hotkeys on root
@@ -707,10 +711,8 @@ fn test_stake_fee_api() {
             coldkey1,
             stake_amount,
         );
-        let dynamic_fee_3 = <SubtensorModule as Config>::SwapInterface::approx_fee_amount(
-            root_netuid,
-            stake_amount,
-        );
+        let dynamic_fee_3 =
+            <Test as Config>::SwapInterface::approx_fee_amount(root_netuid, stake_amount);
         assert_eq!(stake_fee_3, dynamic_fee_3);
 
         // Test stake fee for move between coldkeys on root
@@ -721,10 +723,8 @@ fn test_stake_fee_api() {
             coldkey2,
             stake_amount,
         );
-        let dynamic_fee_4 = <SubtensorModule as Config>::SwapInterface::approx_fee_amount(
-            root_netuid,
-            stake_amount,
-        );
+        let dynamic_fee_4 =
+            <Test as Config>::SwapInterface::approx_fee_amount(root_netuid, stake_amount);
         assert_eq!(stake_fee_4, dynamic_fee_4);
 
         // Test stake fee for *swap* from non-root to root
@@ -735,10 +735,8 @@ fn test_stake_fee_api() {
             coldkey1,
             stake_amount,
         );
-        let dynamic_fee_5 = <SubtensorModule as Config>::SwapInterface::approx_fee_amount(
-            root_netuid,
-            stake_amount,
-        );
+        let dynamic_fee_5 =
+            <Test as Config>::SwapInterface::approx_fee_amount(root_netuid, stake_amount);
         assert_eq!(stake_fee_5, dynamic_fee_5);
 
         // Test stake fee for move between hotkeys on non-root
@@ -750,7 +748,7 @@ fn test_stake_fee_api() {
             stake_amount,
         );
         let dynamic_fee_6 =
-            <SubtensorModule as Config>::SwapInterface::approx_fee_amount(netuid0, stake_amount);
+            <Test as Config>::SwapInterface::approx_fee_amount(netuid0, stake_amount);
         assert_eq!(stake_fee_6, dynamic_fee_6);
 
         // Test stake fee for move between coldkeys on non-root
@@ -762,7 +760,7 @@ fn test_stake_fee_api() {
             stake_amount,
         );
         let dynamic_fee_7 =
-            <SubtensorModule as Config>::SwapInterface::approx_fee_amount(netuid0, stake_amount);
+            <Test as Config>::SwapInterface::approx_fee_amount(netuid0, stake_amount);
         assert_eq!(stake_fee_7, dynamic_fee_7);
 
         // Test stake fee for *swap* from non-root to non-root
@@ -774,7 +772,7 @@ fn test_stake_fee_api() {
             stake_amount,
         );
         let dynamic_fee_8 =
-            <SubtensorModule as Config>::SwapInterface::approx_fee_amount(netuid1, stake_amount);
+            <Test as Config>::SwapInterface::approx_fee_amount(netuid1, stake_amount);
         assert_eq!(stake_fee_8, dynamic_fee_8);
     });
 }
@@ -822,36 +820,29 @@ fn test_stake_fee_calculation() {
         // Test stake fee for add_stake
 
         // Default for adding stake
-        let stake_fee =
-            <SubtensorModule as Config>::SwapInterface::approx_fee_amount(netuid0, stake_amount);
+        let stake_fee = <Test as Config>::SwapInterface::approx_fee_amount(netuid0, stake_amount);
         assert_eq!(stake_fee, default_fee);
 
         // Test stake fee for remove on root
-        let stake_fee = <SubtensorModule as Config>::SwapInterface::approx_fee_amount(
-            root_netuid,
-            stake_amount,
-        ); // Default for removing stake from root
+        let stake_fee =
+            <Test as Config>::SwapInterface::approx_fee_amount(root_netuid, stake_amount); // Default for removing stake from root
         assert_eq!(stake_fee, default_fee);
 
         // Test stake fee for move from root to non-root
 
         // Default for moving stake from root to non-root
-        let stake_fee =
-            <SubtensorModule as Config>::SwapInterface::approx_fee_amount(netuid0, stake_amount);
+        let stake_fee = <Test as Config>::SwapInterface::approx_fee_amount(netuid0, stake_amount);
         assert_eq!(stake_fee, default_fee);
 
         // Test stake fee for move between hotkeys on root
-        let stake_fee = <SubtensorModule as Config>::SwapInterface::approx_fee_amount(
-            root_netuid,
-            stake_amount,
-        ); // Default for moving stake between hotkeys on root
+        let stake_fee =
+            <Test as Config>::SwapInterface::approx_fee_amount(root_netuid, stake_amount); // Default for moving stake between hotkeys on root
         assert_eq!(stake_fee, default_fee);
 
         // Test stake fee for *swap* from non-root to non-root
 
         // Charged a dynamic fee
-        let stake_fee =
-            <SubtensorModule as Config>::SwapInterface::approx_fee_amount(netuid1, stake_amount);
+        let stake_fee = <Test as Config>::SwapInterface::approx_fee_amount(netuid1, stake_amount);
         assert_ne!(stake_fee, default_fee);
     });
 }
diff --git a/pallets/subtensor/src/tests/swap_coldkey.rs b/pallets/subtensor/src/tests/swap_coldkey.rs
index beb4df59a5..d157cde4ee 100644
--- a/pallets/subtensor/src/tests/swap_coldkey.rs
+++ b/pallets/subtensor/src/tests/swap_coldkey.rs
@@ -1,20 +1,22 @@
 #![allow(unused, clippy::indexing_slicing, clippy::panic, clippy::unwrap_used)]
-use codec::Encode;
-use frame_support::weights::Weight;
-use frame_support::{assert_err, assert_noop, assert_ok};
-use frame_system::{Config, RawOrigin};
 
-use super::mock::*;
-use crate::*;
-use crate::{Call, ColdkeySwapScheduleDuration, Error};
 use approx::assert_abs_diff_eq;
+use codec::Encode;
 use frame_support::error::BadOrigin;
 use frame_support::traits::OnInitialize;
 use frame_support::traits::schedule::DispatchTime;
 use frame_support::traits::schedule::v3::Named as ScheduleNamed;
+use frame_support::weights::Weight;
+use frame_support::{assert_err, assert_noop, assert_ok};
+use frame_system::{Config, RawOrigin};
 use sp_core::{Get, H256, U256};
 use sp_runtime::DispatchError;
 use substrate_fixed::types::U96F32;
+use subtensor_swap_interface::SwapHandler;
+
+use super::mock::*;
+use crate::*;
+use crate::{Call, ColdkeySwapScheduleDuration, Error};
 
 // // SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_coldkey -- test_swap_total_hotkey_coldkey_stakes_this_interval --exact --nocapture
 // #[test]
@@ -540,12 +542,9 @@ fn test_swap_concurrent_modifications() {
         let additional_stake = 500_000_000_000;
         let initial_stake_alpha =
             U96F32::from(initial_stake).saturating_mul(SubtensorModule::get_alpha_price(netuid));
-        let fee = SubtensorModule::calculate_staking_fee(
-            None,
-            &new_coldkey,
-            Some((&hotkey, netuid)),
-            &new_coldkey,
-            initial_stake_alpha,
+        let fee = <Test as pallet::Config>::SwapInterface::approx_fee_amount(
+            netuid,
+            initial_stake_alpha.to_num::<u64>(),
         );
 
         // Setup initial state
diff --git a/pallets/swap/src/benchmarking.rs b/pallets/swap/src/benchmarking.rs
index 1bf1b8a95d..e1d75304ae 100644
--- a/pallets/swap/src/benchmarking.rs
+++ b/pallets/swap/src/benchmarking.rs
@@ -8,16 +8,16 @@ use frame_system::RawOrigin;
 
 #[benchmarks(where T: Config)]
 mod benchmarks {
-	use super::*; // Use imports from outer scope
+    use super::*; // Use imports from outer scope
 
-	#[benchmark]
-	fn set_fee_rate() {
-		let netuid: u16 = 1;
-		let rate: u16 = 100;  // Some arbitrary fee rate value
+    #[benchmark]
+    fn set_fee_rate() {
+        let netuid: u16 = 1;
+        let rate: u16 = 100; // Some arbitrary fee rate value
 
-		#[extrinsic_call]
-		set_fee_rate(RawOrigin::Root, netuid, rate);
-	}
+        #[extrinsic_call]
+        set_fee_rate(RawOrigin::Root, netuid, rate);
+    }
 
-	impl_benchmark_test_suite!(Pallet, crate::mock::new_test_ext(), crate::mock::Test);
+    impl_benchmark_test_suite!(Pallet, crate::mock::new_test_ext(), crate::mock::Test);
 }
diff --git a/pallets/swap/src/lib.rs b/pallets/swap/src/lib.rs
index 8bfdcbf3b0..c7c30e9d3b 100644
--- a/pallets/swap/src/lib.rs
+++ b/pallets/swap/src/lib.rs
@@ -2,9 +2,9 @@
 
 use codec::{Decode, Encode, MaxEncodedLen};
 use frame_support::pallet_prelude::*;
-use subtensor_swap_interface::OrderType;
 use substrate_fixed::types::U64F64;
 use subtensor_macros::freeze_struct;
+use subtensor_swap_interface::OrderType;
 
 pub mod pallet;
 mod position;
diff --git a/pallets/swap/src/mock.rs b/pallets/swap/src/mock.rs
index f400127dd0..880aea9bfc 100644
--- a/pallets/swap/src/mock.rs
+++ b/pallets/swap/src/mock.rs
@@ -74,14 +74,14 @@ impl LiquidityDataProvider<AccountId> for MockLiquidityProvider {
     fn tao_reserve(netuid: u16) -> u64 {
         match netuid {
             123 => 1_000,
-            _ => 1_000_000_000_000
+            _ => 1_000_000_000_000,
         }
     }
 
     fn alpha_reserve(netuid: u16) -> u64 {
         match netuid {
             123 => 1,
-            _ => 4_000_000_000_000
+            _ => 4_000_000_000_000,
         }
     }
 
@@ -94,7 +94,9 @@ impl LiquidityDataProvider<AccountId> for MockLiquidityProvider {
     }
 
     fn alpha_balance(_: u16, coldkey_account_id: &AccountId, hotkey_account_id: &AccountId) -> u64 {
-        if (*coldkey_account_id == OK_COLDKEY_ACCOUNT_ID) && (*hotkey_account_id == OK_HOTKEY_ACCOUNT_ID) {
+        if (*coldkey_account_id == OK_COLDKEY_ACCOUNT_ID)
+            && (*hotkey_account_id == OK_HOTKEY_ACCOUNT_ID)
+        {
             100_000_000_000_000
         } else {
             1_000_000_000
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 4636df575b..a291cfe1b7 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -358,7 +358,7 @@ impl<T: Config> Pallet<T> {
     ///
     /// The function can be used without writing into the storage by setting `should_rollback` to
     /// `true`.
-    pub fn swap(
+    pub fn do_swap(
         netuid: NetUid,
         order_type: OrderType,
         amount: u64,
@@ -1104,7 +1104,7 @@ impl<T: Config> SwapHandler<T::AccountId> for Pallet<T> {
             .checked_sqrt(SqrtPrice::saturating_from_num(2))
             .ok_or(Error::<T>::PriceLimitExceeded)?;
 
-        Self::swap(
+        Self::do_swap(
             NetUid::from(netuid),
             order_t,
             amount,
@@ -1649,7 +1649,7 @@ mod tests {
 
                     // Swap
                     let sqrt_limit_price = SqrtPrice::from_num((limit_price).sqrt());
-                    let swap_result = Pallet::<Test>::swap(
+                    let swap_result = Pallet::<Test>::do_swap(
                         netuid,
                         order_type,
                         liquidity,
@@ -1891,7 +1891,7 @@ mod tests {
 
                         // Do the swap
                         let sqrt_limit_price = SqrtPrice::from_num((limit_price).sqrt());
-                        let swap_result = Pallet::<Test>::swap(
+                        let swap_result = Pallet::<Test>::do_swap(
                             netuid,
                             order_type,
                             order_liquidity as u64,
@@ -2126,7 +2126,7 @@ mod tests {
 
                 // Do the swap
                 let sqrt_limit_price = SqrtPrice::from_num((limit_price).sqrt());
-                let swap_result = Pallet::<Test>::swap(
+                let swap_result = Pallet::<Test>::do_swap(
                     netuid,
                     order_type,
                     order_liquidity,
@@ -2218,7 +2218,7 @@ mod tests {
 
             // Swap
             let swap_result =
-                Pallet::<Test>::swap(netuid, order_type, liquidity, sqrt_limit_price, true)
+                Pallet::<Test>::do_swap(netuid, order_type, liquidity, sqrt_limit_price, true)
                     .unwrap();
 
             assert!(swap_result.amount_paid_out > 0);
diff --git a/pallets/swap/src/position.rs b/pallets/swap/src/position.rs
index 7558d55c0b..aa4fe85ddd 100644
--- a/pallets/swap/src/position.rs
+++ b/pallets/swap/src/position.rs
@@ -151,5 +151,3 @@ impl From<PositionId> for u128 {
         value.0
     }
 }
-
-
diff --git a/pallets/swap/src/weights.rs b/pallets/swap/src/weights.rs
index d630ff661d..210bf1dc6d 100644
--- a/pallets/swap/src/weights.rs
+++ b/pallets/swap/src/weights.rs
@@ -7,32 +7,32 @@
 #![allow(unused_imports)]
 
 use frame_support::{
-	traits::Get,
-	weights::{Weight, constants::RocksDbWeight},
+    traits::Get,
+    weights::{Weight, constants::RocksDbWeight},
 };
 use sp_std::marker::PhantomData;
 
 /// Weight functions needed for pallet_subtensor_swap.
 pub trait WeightInfo {
-	fn set_fee_rate() -> Weight;
+    fn set_fee_rate() -> Weight;
 }
 
 /// Default weights for pallet_subtensor_swap.
 pub struct DefaultWeight<T>(PhantomData<T>);
 impl<T: frame_system::Config> WeightInfo for DefaultWeight<T> {
-	fn set_fee_rate() -> Weight {
-		// Conservative weight estimate: one read and one write
-		Weight::from_parts(10_000_000, 0)
-			.saturating_add(T::DbWeight::get().reads(1))
-			.saturating_add(T::DbWeight::get().writes(1))
-	}
+    fn set_fee_rate() -> Weight {
+        // Conservative weight estimate: one read and one write
+        Weight::from_parts(10_000_000, 0)
+            .saturating_add(T::DbWeight::get().reads(1))
+            .saturating_add(T::DbWeight::get().writes(1))
+    }
 }
 
 // For backwards compatibility and tests
 impl WeightInfo for () {
-	fn set_fee_rate() -> Weight {
-		Weight::from_parts(10_000_000, 0)
-			.saturating_add(RocksDbWeight::get().reads(1))
-			.saturating_add(RocksDbWeight::get().writes(1))
-	}
+    fn set_fee_rate() -> Weight {
+        Weight::from_parts(10_000_000, 0)
+            .saturating_add(RocksDbWeight::get().reads(1))
+            .saturating_add(RocksDbWeight::get().writes(1))
+    }
 }

From 704df270fc70364414c79e2d5726fa1e3b388f26 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Wed, 16 Apr 2025 18:03:41 +0200
Subject: [PATCH 075/418] Add minimum reserves requirement

---
 pallets/swap/src/mock.rs         | 4 ++++
 pallets/swap/src/pallet/impls.rs | 9 ++++++++-
 pallets/swap/src/pallet/mod.rs   | 9 +++++++++
 3 files changed, 21 insertions(+), 1 deletion(-)

diff --git a/pallets/swap/src/mock.rs b/pallets/swap/src/mock.rs
index 880aea9bfc..dd59a9d232 100644
--- a/pallets/swap/src/mock.rs
+++ b/pallets/swap/src/mock.rs
@@ -1,3 +1,5 @@
+use core::num::NonZeroU64;
+
 use frame_support::construct_runtime;
 use frame_support::{
     PalletId, parameter_types,
@@ -65,6 +67,7 @@ parameter_types! {
     pub const MaxFeeRate: u16 = 10000; // 15.26%
     pub const MaxPositions: u32 = 100;
     pub const MinimumLiquidity: u64 = 1_000;
+    pub const MinimumReserves: NonZeroU64 = NonZeroU64::new(1).unwrap();
 }
 
 // Mock implementor of LiquidityDataProvider trait
@@ -112,6 +115,7 @@ impl crate::pallet::Config for Test {
     type MaxFeeRate = MaxFeeRate;
     type MaxPositions = MaxPositions;
     type MinimumLiquidity = MinimumLiquidity;
+    type MinimumReserve = MinimumReserves;
     type WeightInfo = ();
 }
 
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index a291cfe1b7..d58eaeb457 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -383,6 +383,13 @@ impl<T: Config> Pallet<T> {
         amount: u64,
         sqrt_price_limit: SqrtPrice,
     ) -> Result<SwapResult, Error<T>> {
+        ensure!(
+            T::LiquidityDataProvider::tao_reserve(netuid.into()) >= T::MinimumReserve::get().get()
+                && T::LiquidityDataProvider::alpha_reserve(netuid.into())
+                    >= T::MinimumReserve::get().get(),
+            Error::<T>::ReservesTooLow
+        );
+
         Self::maybe_initialize_v3(netuid)?;
 
         let mut amount_remaining = amount;
@@ -2198,7 +2205,7 @@ mod tests {
         new_test_ext().execute_with(|| {
             let netuid = NetUid::from(123); // 123 is netuid with low edge case liquidity
             let order_type = OrderType::Sell;
-            let liquidity = 1000000000000000000;
+            let liquidity = 1_000_000_000_000_000_000;
             let tick_low = TickIndex::MIN;
             let tick_high = TickIndex::MAX;
 
diff --git a/pallets/swap/src/pallet/mod.rs b/pallets/swap/src/pallet/mod.rs
index 66e7d35091..771132056c 100644
--- a/pallets/swap/src/pallet/mod.rs
+++ b/pallets/swap/src/pallet/mod.rs
@@ -1,3 +1,5 @@
+use core::num::NonZeroU64;
+
 use frame_support::{PalletId, pallet_prelude::*, traits::Get};
 use frame_system::pallet_prelude::*;
 use substrate_fixed::types::U64F64;
@@ -51,6 +53,10 @@ mod pallet {
         #[pallet::constant]
         type MinimumLiquidity: Get<u64>;
 
+        /// Minimum reserve for tao and alpha
+        #[pallet::constant]
+        type MinimumReserve: Get<NonZeroU64>;
+
         /// Weight information for extrinsics in this pallet.
         type WeightInfo: WeightInfo;
     }
@@ -159,6 +165,9 @@ mod pallet {
 
         /// Provided liquidity parameter is invalid (likely too small)
         InvalidLiquidityValue,
+
+		/// Reserves too low for operation.
+		ReservesTooLow,
     }
 
     #[pallet::call]

From 76bfd1885041464c0a25fdeaef0a09cd58c37b28 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Wed, 16 Apr 2025 19:45:02 +0200
Subject: [PATCH 076/418] Fix swap_coldkey tests

---
 pallets/admin-utils/src/tests/mock.rs       |   4 +
 pallets/subtensor/src/tests/mock.rs         |  33 +++-
 pallets/subtensor/src/tests/swap_coldkey.rs | 182 +++++++++++++-------
 runtime/src/lib.rs                          |   4 +
 4 files changed, 154 insertions(+), 69 deletions(-)

diff --git a/pallets/admin-utils/src/tests/mock.rs b/pallets/admin-utils/src/tests/mock.rs
index c5ff6acda7..e9f4655825 100644
--- a/pallets/admin-utils/src/tests/mock.rs
+++ b/pallets/admin-utils/src/tests/mock.rs
@@ -1,5 +1,7 @@
 #![allow(clippy::arithmetic_side_effects, clippy::unwrap_used)]
 
+use core::num::NonZeroU64;
+
 use frame_support::{
     PalletId, assert_ok, derive_impl, parameter_types,
     traits::{Everything, Hooks, PrivilegeCmp},
@@ -267,6 +269,7 @@ parameter_types! {
     pub const SwapMaxFeeRate: u16 = 10000; // 15.26%
     pub const SwapMaxPositions: u32 = 100;
     pub const SwapMinimumLiquidity: u64 = 1_000;
+    pub const SwapMinimumReserve: NonZeroU64 = NonZeroU64::new(1_000_000).unwrap();
 }
 
 impl pallet_subtensor_swap::Config for Test {
@@ -277,6 +280,7 @@ impl pallet_subtensor_swap::Config for Test {
     type MaxFeeRate = SwapMaxFeeRate;
     type MaxPositions = SwapMaxPositions;
     type MinimumLiquidity = SwapMinimumLiquidity;
+    type MinimumReserve = SwapMinimumReserve;
     type WeightInfo = ();
 }
 
diff --git a/pallets/subtensor/src/tests/mock.rs b/pallets/subtensor/src/tests/mock.rs
index 34c9453cf5..dbbe2edbfb 100644
--- a/pallets/subtensor/src/tests/mock.rs
+++ b/pallets/subtensor/src/tests/mock.rs
@@ -1,5 +1,7 @@
 #![allow(clippy::arithmetic_side_effects, clippy::unwrap_used)]
-use crate::utils::rate_limiting::TransactionType;
+
+use core::num::NonZeroU64;
+
 use frame_support::PalletId;
 use frame_support::derive_impl;
 use frame_support::dispatch::DispatchResultWithPostInfo;
@@ -20,8 +22,9 @@ use sp_runtime::{
 };
 use sp_std::cmp::Ordering;
 use substrate_fixed::types::U64F64;
-use subtensor_swap_interface::{LiquidityDataProvider, SwapHandler};
+use subtensor_swap_interface::{LiquidityDataProvider, OrderType, SwapHandler};
 
+use crate::utils::rate_limiting::TransactionType;
 use crate::*;
 
 type Block = frame_system::mocking::MockBlock<Test>;
@@ -423,6 +426,7 @@ parameter_types! {
     pub const SwapMaxFeeRate: u16 = 10000; // 15.26%
     pub const SwapMaxPositions: u32 = 100;
     pub const SwapMinimumLiquidity: u64 = 1_000;
+    pub const SwapMinimumReserve: NonZeroU64 = NonZeroU64::new(1).unwrap();
 }
 
 impl pallet_subtensor_swap::Config for Test {
@@ -433,6 +437,7 @@ impl pallet_subtensor_swap::Config for Test {
     type MaxFeeRate = SwapMaxFeeRate;
     type MaxPositions = SwapMaxPositions;
     type MinimumLiquidity = SwapMinimumLiquidity;
+    type MinimumReserve = SwapMinimumReserve;
     type WeightInfo = ();
 }
 
@@ -852,3 +857,27 @@ pub fn increase_stake_on_hotkey_account(hotkey: &U256, increment: u64, netuid: u
         netuid,
     );
 }
+
+pub(crate) fn setup_reserves(netuid: u16, tao: u64, alpha: u64) {
+    SubnetTAO::<Test>::set(netuid, tao);
+    SubnetAlphaIn::<Test>::set(netuid, alpha);
+}
+
+pub(crate) fn swap_tao_to_alpha(netuid: u16, tao: u64) -> u64 {
+    let result = <Test as pallet::Config>::SwapInterface::swap(
+        netuid,
+        OrderType::Buy,
+        tao,
+        <Test as pallet::Config>::SwapInterface::max_price(),
+        true,
+    );
+
+    assert_ok!(&result);
+
+    let result = result.unwrap().amount_paid_out;
+
+    // we don't want to have silent 0 comparissons in tests
+    assert!(result > 0);
+
+    result
+}
diff --git a/pallets/subtensor/src/tests/swap_coldkey.rs b/pallets/subtensor/src/tests/swap_coldkey.rs
index d157cde4ee..07812547e5 100644
--- a/pallets/subtensor/src/tests/swap_coldkey.rs
+++ b/pallets/subtensor/src/tests/swap_coldkey.rs
@@ -12,8 +12,9 @@ use frame_system::{Config, RawOrigin};
 use sp_core::{Get, H256, U256};
 use sp_runtime::DispatchError;
 use substrate_fixed::types::U96F32;
-use subtensor_swap_interface::SwapHandler;
+use subtensor_swap_interface::{LiquidityDataProvider, OrderType, SwapHandler};
 
+use super::mock;
 use super::mock::*;
 use crate::*;
 use crate::{Call, ColdkeySwapScheduleDuration, Error};
@@ -88,6 +89,9 @@ fn test_swap_total_coldkey_stake() {
         register_ok_neuron(netuid, hotkey, old_coldkey, 1001000);
         register_ok_neuron(netuid, other_hotkey, other_coldkey, 1001000);
 
+        let reserve = stake * 10;
+        mock::setup_reserves(netuid, reserve, reserve);
+
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(old_coldkey),
             hotkey,
@@ -292,6 +296,9 @@ fn test_swap_idempotency() {
         let hotkey = U256::from(3);
         let netuid = 1u16;
         let stake = DefaultMinStake::<Test>::get() * 10;
+        let reserve = stake * 10;
+
+        mock::setup_reserves(netuid, reserve, reserve);
 
         // Add a network
         add_network(netuid, 1, 0);
@@ -361,13 +368,20 @@ fn test_swap_with_max_values() {
         SubtensorModule::add_balance_to_coldkey_account(&old_coldkey, max_stake + 1_000);
         SubtensorModule::add_balance_to_coldkey_account(&old_coldkey2, max_stake + 1_000);
 
+        let reserve = max_stake * 10;
+        mock::setup_reserves(netuid, reserve, reserve);
+        mock::setup_reserves(netuid2, reserve, reserve);
+
         // Stake to hotkey on each subnet.
+        let expected_stake_alpha1 = mock::swap_tao_to_alpha(netuid, max_stake);
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(old_coldkey),
             hotkey,
             netuid,
             max_stake
         ));
+
+        let expected_stake_alpha2 = mock::swap_tao_to_alpha(netuid2, max_stake);
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(old_coldkey2),
             hotkey2,
@@ -393,7 +407,7 @@ fn test_swap_with_max_values() {
         );
         assert_eq!(
             SubtensorModule::get_total_stake_for_coldkey(&new_coldkey),
-            max_stake - fee
+            expected_stake_alpha1
         );
         assert_eq!(
             SubtensorModule::get_total_stake_for_coldkey(&old_coldkey2),
@@ -401,7 +415,7 @@ fn test_swap_with_max_values() {
         );
         assert_eq!(
             SubtensorModule::get_total_stake_for_coldkey(&new_coldkey2),
-            max_stake - fee
+            expected_stake_alpha2
         );
     });
 }
@@ -415,13 +429,18 @@ fn test_swap_with_non_existent_new_coldkey() {
         let hotkey = U256::from(3);
         let stake = DefaultMinStake::<Test>::get() * 10;
         let netuid = 1u16;
-        let fee = DefaultStakingFee::<Test>::get();
 
         add_network(netuid, 1, 0);
         register_ok_neuron(netuid, hotkey, old_coldkey, 1001000);
         // Give old coldkey some balance.
         SubtensorModule::add_balance_to_coldkey_account(&old_coldkey, stake + 1_000);
+
+        let reserve = stake * 10;
+        mock::setup_reserves(netuid, reserve, reserve);
+
         // Stake to hotkey.
+
+        let expected_stake_alpha = mock::swap_tao_to_alpha(netuid, stake);
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(old_coldkey),
             hotkey,
@@ -442,7 +461,7 @@ fn test_swap_with_non_existent_new_coldkey() {
         );
         assert_eq!(
             SubtensorModule::get_total_stake_for_coldkey(&new_coldkey),
-            stake - fee
+            expected_stake_alpha
         );
     });
 }
@@ -540,12 +559,10 @@ fn test_swap_concurrent_modifications() {
         let netuid: u16 = 1;
         let initial_stake = 1_000_000_000_000;
         let additional_stake = 500_000_000_000;
-        let initial_stake_alpha =
-            U96F32::from(initial_stake).saturating_mul(SubtensorModule::get_alpha_price(netuid));
-        let fee = <Test as pallet::Config>::SwapInterface::approx_fee_amount(
-            netuid,
-            initial_stake_alpha.to_num::<u64>(),
-        );
+
+        mock::setup_reserves(netuid, 1_000_000_000_000_000, 1_000_000_000_000_000);
+
+        let initial_stake_alpha = mock::swap_tao_to_alpha(netuid, initial_stake);
 
         // Setup initial state
         add_network(netuid, 1, 1);
@@ -562,25 +579,19 @@ fn test_swap_concurrent_modifications() {
         ));
 
         // Verify initial stake
-        assert_eq!(
-            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
-                &hotkey,
-                &new_coldkey,
-                netuid
-            ),
-            initial_stake - fee
-        );
-
-        // Wait some blocks
-        step_block(10);
-
-        // Get stake before swap
         let stake_before_swap = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
             &hotkey,
             &new_coldkey,
             netuid,
         );
 
+        assert_eq!(stake_before_swap, initial_stake_alpha);
+
+        // Wait some blocks
+        step_block(10);
+
+        let additional_stake_alpha = mock::swap_tao_to_alpha(netuid, additional_stake);
+
         // Simulate concurrent stake addition
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(new_coldkey),
@@ -596,14 +607,13 @@ fn test_swap_concurrent_modifications() {
             &mut weight
         ));
 
-        assert_abs_diff_eq!(
+        assert_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
                 &hotkey,
                 &new_coldkey,
                 netuid
             ),
-            stake_before_swap + additional_stake - fee,
-            epsilon = (stake_before_swap + additional_stake - fee) / 1000
+            stake_before_swap + additional_stake_alpha
         );
         assert!(!Alpha::<Test>::contains_key((hotkey, old_coldkey, netuid)));
     });
@@ -648,6 +658,9 @@ fn test_do_swap_coldkey_success() {
         let swap_cost = SubtensorModule::get_key_swap_cost();
         let free_balance_old = 12345u64 + swap_cost;
 
+        let reserve = (stake_amount1 + stake_amount2) * 10;
+        mock::setup_reserves(netuid, reserve, reserve);
+
         // Setup initial state
         add_network(netuid, 13, 0);
         register_ok_neuron(netuid, hotkey1, old_coldkey, 0);
@@ -821,9 +834,7 @@ fn test_swap_stake_for_coldkey() {
         let stake_amount1 = DefaultMinStake::<Test>::get() * 10;
         let stake_amount2 = DefaultMinStake::<Test>::get() * 20;
         let stake_amount3 = DefaultMinStake::<Test>::get() * 30;
-        let total_stake = stake_amount1 + stake_amount2;
         let mut weight = Weight::zero();
-        let fee = DefaultStakingFee::<Test>::get();
 
         // Setup initial state
         // Add a network
@@ -839,13 +850,20 @@ fn test_swap_stake_for_coldkey() {
             stake_amount1 + stake_amount2 + 1_000_000,
         );
 
+        let reserve = (stake_amount1 + stake_amount2 + stake_amount3) * 10;
+        mock::setup_reserves(netuid, reserve, reserve);
+
         // Stake to hotkeys
+        let expected_stake_alpha1 = mock::swap_tao_to_alpha(netuid, stake_amount1);
+
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(old_coldkey),
             hotkey1,
             netuid,
             stake_amount1
         ));
+
+        let expected_stake_alpha2 = mock::swap_tao_to_alpha(netuid, stake_amount2);
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(old_coldkey),
             hotkey2,
@@ -860,7 +878,7 @@ fn test_swap_stake_for_coldkey() {
                 &old_coldkey,
                 netuid
             ),
-            stake_amount1 - fee
+            expected_stake_alpha1
         );
         assert_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
@@ -868,13 +886,14 @@ fn test_swap_stake_for_coldkey() {
                 &old_coldkey,
                 netuid
             ),
-            stake_amount2 - fee
+            expected_stake_alpha2
         );
 
         // Insert existing for same hotkey1
         // give new coldkey some balance
         SubtensorModule::add_balance_to_coldkey_account(&new_coldkey, stake_amount3 + 1_000_000);
         // Stake to hotkey1
+        let expected_stake_alpha3 = mock::swap_tao_to_alpha(netuid, stake_amount3);
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(new_coldkey),
             hotkey1,
@@ -915,7 +934,7 @@ fn test_swap_stake_for_coldkey() {
                 &new_coldkey,
                 netuid
             ),
-            stake_amount1 + stake_amount3 - fee * 2
+            expected_stake_alpha1 + expected_stake_alpha3
         );
         assert_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
@@ -923,7 +942,7 @@ fn test_swap_stake_for_coldkey() {
                 &new_coldkey,
                 netuid
             ),
-            stake_amount2 - fee
+            expected_stake_alpha2
         );
         assert_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
@@ -977,9 +996,7 @@ fn test_swap_staking_hotkeys_for_coldkey() {
         let hotkey2 = U256::from(5);
         let stake_amount1 = DefaultMinStake::<Test>::get() * 10;
         let stake_amount2 = DefaultMinStake::<Test>::get() * 20;
-        let total_stake = stake_amount1 + stake_amount2;
         let mut weight = Weight::zero();
-        let fee = DefaultStakingFee::<Test>::get();
 
         // Setup initial state
         // Add a network
@@ -989,18 +1006,23 @@ fn test_swap_staking_hotkeys_for_coldkey() {
         SubtensorModule::add_balance_to_coldkey_account(
             &old_coldkey,
             stake_amount1 + stake_amount2 + 1_000_000,
-        );
-        // Register hotkeys
+        ); // Register hotkeys
         register_ok_neuron(netuid, hotkey1, old_coldkey, 0);
         register_ok_neuron(netuid, hotkey2, other_coldkey, 0);
 
+        let reserve = (stake_amount1 + stake_amount2) * 10;
+        mock::setup_reserves(netuid, reserve, reserve);
+
         // Stake to hotkeys
+        let expected_stake_alpha1 = mock::swap_tao_to_alpha(netuid, stake_amount1);
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(old_coldkey),
             hotkey1,
             netuid,
             stake_amount1
         ));
+
+        let expected_stake_alpha2 = mock::swap_tao_to_alpha(netuid, stake_amount2);
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(old_coldkey),
             hotkey2,
@@ -1015,7 +1037,7 @@ fn test_swap_staking_hotkeys_for_coldkey() {
                 &old_coldkey,
                 netuid
             ),
-            stake_amount1 - fee
+            expected_stake_alpha1
         );
         assert_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
@@ -1023,7 +1045,7 @@ fn test_swap_staking_hotkeys_for_coldkey() {
                 &old_coldkey,
                 netuid
             ),
-            stake_amount2 - fee
+            expected_stake_alpha2
         );
 
         // Perform the swap
@@ -1051,13 +1073,15 @@ fn test_swap_delegated_stake_for_coldkey() {
         let stake_amount2 = DefaultMinStake::<Test>::get() * 20;
         let mut weight = Weight::zero();
         let netuid = 1u16;
-        let fee = DefaultStakingFee::<Test>::get();
 
         // Setup initial state
         add_network(netuid, 1, 0);
         register_ok_neuron(netuid, hotkey1, other_coldkey, 0);
         register_ok_neuron(netuid, hotkey2, other_coldkey, 0);
 
+        let reserve = (stake_amount1 + stake_amount2) * 10;
+        mock::setup_reserves(netuid, reserve, reserve);
+
         // Notice hotkey1 and hotkey2 are Owned by other_coldkey
         // old_coldkey and new_coldkey therefore delegates stake to them
         // === Give old_coldkey some balance ===
@@ -1065,6 +1089,9 @@ fn test_swap_delegated_stake_for_coldkey() {
             &old_coldkey,
             stake_amount1 + stake_amount2 + 1_000_000,
         );
+
+        let expected_stake_alpha1 = mock::swap_tao_to_alpha(netuid, stake_amount1);
+
         // === Stake to hotkeys ===
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(old_coldkey),
@@ -1072,6 +1099,8 @@ fn test_swap_delegated_stake_for_coldkey() {
             netuid,
             stake_amount1
         ));
+
+        let expected_stake_alpha2 = mock::swap_tao_to_alpha(netuid, stake_amount2);
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(old_coldkey),
             hotkey2,
@@ -1106,7 +1135,7 @@ fn test_swap_delegated_stake_for_coldkey() {
                 &new_coldkey,
                 netuid
             ),
-            stake_amount1 - fee
+            expected_stake_alpha1
         );
         assert_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
@@ -1114,7 +1143,7 @@ fn test_swap_delegated_stake_for_coldkey() {
                 &new_coldkey,
                 netuid
             ),
-            stake_amount2 - fee
+            expected_stake_alpha2
         );
         assert_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
@@ -1271,6 +1300,11 @@ fn test_coldkey_swap_total() {
         SubtensorModule::add_balance_to_coldkey_account(&nominator2, stake * 2);
         SubtensorModule::add_balance_to_coldkey_account(&nominator3, stake * 2);
 
+        let reserve = stake * 10;
+        mock::setup_reserves(netuid1, reserve, reserve);
+        mock::setup_reserves(netuid2, reserve, reserve);
+        mock::setup_reserves(netuid3, reserve, reserve);
+
         // Setup initial state
         add_network(netuid1, 13, 0);
         add_network(netuid2, 14, 0);
@@ -1612,7 +1646,12 @@ fn test_coldkey_delegations() {
         let netuid = 0u16; // Stake to 0
         let netuid2 = 1u16; // Stake to 1
         let stake = DefaultMinStake::<Test>::get() * 10;
-        let fee = DefaultStakingFee::<Test>::get();
+        let reserve = stake * 10;
+
+        mock::setup_reserves(netuid, reserve, reserve);
+        mock::setup_reserves(netuid2, reserve, reserve);
+
+        let expected_stake = mock::swap_tao_to_alpha(netuid, stake);
 
         add_network(netuid, 13, 0); // root
         add_network(netuid2, 13, 0);
@@ -1648,28 +1687,24 @@ fn test_coldkey_delegations() {
         ));
 
         // Verify stake was moved for the delegate
-        assert_abs_diff_eq!(
+        assert_eq!(
             SubtensorModule::get_total_stake_for_hotkey(&delegate),
-            stake * 2 - fee * 2,
-            epsilon = stake / 1000
+            expected_stake * 2,
         );
         assert_eq!(SubtensorModule::get_total_stake_for_coldkey(&coldkey), 0);
-        assert_abs_diff_eq!(
+        assert_eq!(
             SubtensorModule::get_total_stake_for_coldkey(&new_coldkey),
-            stake * 2 - fee * 2,
-            epsilon = stake / 1000
+            expected_stake * 2,
         );
-        assert_abs_diff_eq!(
+        assert_eq!(
             Alpha::<Test>::get((delegate, new_coldkey, netuid)).to_num::<u64>(),
-            stake - fee,
-            epsilon = stake / 1000
+            expected_stake
         );
         assert_eq!(Alpha::<Test>::get((delegate, coldkey, netuid)), 0);
 
-        assert_abs_diff_eq!(
+        assert_eq!(
             Alpha::<Test>::get((delegate, new_coldkey, netuid2)).to_num::<u64>(),
-            stake - fee,
-            epsilon = stake / 1000
+            expected_stake,
         );
         assert_eq!(Alpha::<Test>::get((delegate, coldkey, netuid2)), 0);
     });
@@ -1751,6 +1786,9 @@ fn test_schedule_swap_coldkey_execution() {
         let hotkey = U256::from(3);
         let netuid = 1u16;
         let stake_amount = DefaultMinStake::<Test>::get() * 10;
+        let reserve = stake_amount * 10;
+
+        mock::setup_reserves(netuid, reserve, reserve);
 
         add_network(netuid, 13, 0);
         register_ok_neuron(netuid, hotkey, old_coldkey, 0);
@@ -1896,6 +1934,7 @@ fn test_coldkey_swap_delegate_identity_updated() {
         add_network(netuid, tempo, 0);
 
         SubtensorModule::add_balance_to_coldkey_account(&old_coldkey, 100_000_000_000);
+        mock::setup_reserves(netuid, 1_000_000_000_000, 1_000_000_000_000);
 
         assert_ok!(SubtensorModule::burned_register(
             <<Test as Config>::RuntimeOrigin>::signed(old_coldkey),
@@ -1948,6 +1987,7 @@ fn test_coldkey_swap_no_identity_no_changes() {
         add_network(netuid, tempo, 0);
 
         SubtensorModule::add_balance_to_coldkey_account(&old_coldkey, 100_000_000_000);
+        mock::setup_reserves(netuid, 1_000_000_000_000, 1_000_000_000_000);
 
         assert_ok!(SubtensorModule::burned_register(
             <<Test as Config>::RuntimeOrigin>::signed(old_coldkey),
@@ -1984,6 +2024,7 @@ fn test_coldkey_swap_no_identity_no_changes_newcoldkey_exists() {
         SubtensorModule::set_burn(netuid, burn_cost);
         add_network(netuid, tempo, 0);
         SubtensorModule::add_balance_to_coldkey_account(&old_coldkey, 100_000_000_000);
+        mock::setup_reserves(netuid, 1_000_000_000_000, 1_000_000_000_000);
 
         assert_ok!(SubtensorModule::burned_register(
             <<Test as Config>::RuntimeOrigin>::signed(old_coldkey),
@@ -2053,7 +2094,11 @@ fn test_coldkey_in_swap_schedule_prevents_funds_usage() {
         let new_coldkey = U256::from(1);
         let hotkey: U256 = U256::from(2); // Add the hotkey field
         assert_ne!(hotkey, coldkey); // Ensure hotkey is NOT the same as coldkey !!!
-        let fee = DefaultStakingFee::<Test>::get();
+
+        let stake = 100_000_000_000;
+        let reserve = stake * 100;
+
+        mock::setup_reserves(netuid, reserve, reserve);
 
         let who = coldkey; // The coldkey signs this transaction
 
@@ -2088,7 +2133,7 @@ fn test_coldkey_in_swap_schedule_prevents_funds_usage() {
             <<Test as Config>::RuntimeOrigin>::signed(who),
             hotkey,
             netuid,
-            100_000_000_000
+            stake
         ));
 
         // Schedule the coldkey for a swap
@@ -2110,7 +2155,7 @@ fn test_coldkey_in_swap_schedule_prevents_funds_usage() {
         let call = RuntimeCall::SubtensorModule(SubtensorCall::add_stake {
             hotkey,
             netuid,
-            amount_staked: 100_000_000_000,
+            amount_staked: stake,
         });
         let result: Result<ValidTransaction, TransactionValidityError> =
             extension.validate(&who, &call.clone(), &info, 10);
@@ -2127,8 +2172,8 @@ fn test_coldkey_in_swap_schedule_prevents_funds_usage() {
         let call = RuntimeCall::SubtensorModule(SubtensorCall::add_stake_limit {
             hotkey,
             netuid,
-            amount_staked: 100_000_000_000,
-            limit_price: 100_000_000_000,
+            amount_staked: stake,
+            limit_price: stake,
             allow_partial: false,
         });
         let result = extension.validate(&who, &call.clone(), &info, 10);
@@ -2146,7 +2191,7 @@ fn test_coldkey_in_swap_schedule_prevents_funds_usage() {
             hotkey,
             origin_netuid: netuid,
             destination_netuid: netuid,
-            alpha_amount: 100_000_000_000,
+            alpha_amount: stake,
         });
         let result = extension.validate(&who, &call.clone(), &info, 10);
         // Should fail
@@ -2163,8 +2208,8 @@ fn test_coldkey_in_swap_schedule_prevents_funds_usage() {
             hotkey,
             origin_netuid: netuid,
             destination_netuid: netuid,
-            alpha_amount: 100_000_000_000,
-            limit_price: 100_000_000_000,
+            alpha_amount: stake,
+            limit_price: stake,
             allow_partial: false,
         });
         let result = extension.validate(&who, &call.clone(), &info, 10);
@@ -2183,7 +2228,7 @@ fn test_coldkey_in_swap_schedule_prevents_funds_usage() {
             destination_hotkey: hotkey,
             origin_netuid: netuid,
             destination_netuid: netuid,
-            alpha_amount: 100_000_000_000,
+            alpha_amount: stake,
         });
         let result = extension.validate(&who, &call.clone(), &info, 10);
         // Should fail
@@ -2201,7 +2246,7 @@ fn test_coldkey_in_swap_schedule_prevents_funds_usage() {
             hotkey,
             origin_netuid: netuid,
             destination_netuid: netuid,
-            alpha_amount: 100_000_000_000,
+            alpha_amount: stake,
         });
         let result = extension.validate(&who, &call.clone(), &info, 10);
         // Should fail
@@ -2308,7 +2353,10 @@ fn test_coldkey_in_swap_schedule_prevents_critical_calls() {
         let new_coldkey = U256::from(1);
         let hotkey: U256 = U256::from(2); // Add the hotkey field
         assert_ne!(hotkey, coldkey); // Ensure hotkey is NOT the same as coldkey !!!
-        let fee = DefaultStakingFee::<Test>::get();
+        let stake = 100_000_000_000;
+        let reserve = stake * 10;
+
+        mock::setup_reserves(netuid, reserve, reserve);
 
         let who = coldkey; // The coldkey signs this transaction
 
@@ -2330,7 +2378,7 @@ fn test_coldkey_in_swap_schedule_prevents_critical_calls() {
             <<Test as Config>::RuntimeOrigin>::signed(who),
             hotkey,
             netuid,
-            100_000_000_000
+            stake
         ));
 
         // Schedule the coldkey for a swap
diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index b43d25d108..4bef958ebe 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -8,6 +8,8 @@
 #[cfg(feature = "std")]
 include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));
 
+use core::num::NonZeroU64;
+
 pub mod check_nonce;
 mod migrations;
 
@@ -1123,6 +1125,7 @@ parameter_types! {
     pub const SwapMaxFeeRate: u16 = 10000; // 15.26%
     pub const SwapMaxPositions: u32 = 100;
     pub const SwapMinimumLiquidity: u64 = 1_000;
+    pub const SwapMinimumReserve: NonZeroU64 = NonZeroU64::new(1_000_000).unwrap();
 }
 
 impl pallet_subtensor_swap::Config for Runtime {
@@ -1133,6 +1136,7 @@ impl pallet_subtensor_swap::Config for Runtime {
     type MaxFeeRate = SwapMaxFeeRate;
     type MaxPositions = SwapMaxPositions;
     type MinimumLiquidity = SwapMinimumLiquidity;
+    type MinimumReserve = SwapMinimumReserve;
     type WeightInfo = ();
 }
 

From ea0cd060adc7abc7bb54ae85dcb18a974fba0d69 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Fri, 18 Apr 2025 19:26:57 +0200
Subject: [PATCH 077/418] Actualize children tests

---
 pallets/subtensor/src/tests/children.rs     | 63 ++++++++++-----------
 pallets/subtensor/src/tests/mock.rs         |  8 +--
 pallets/subtensor/src/tests/swap_coldkey.rs | 26 ++++-----
 3 files changed, 48 insertions(+), 49 deletions(-)

diff --git a/pallets/subtensor/src/tests/children.rs b/pallets/subtensor/src/tests/children.rs
index 9d31c8ab1a..3ed7f77d3d 100644
--- a/pallets/subtensor/src/tests/children.rs
+++ b/pallets/subtensor/src/tests/children.rs
@@ -1,6 +1,7 @@
 #![allow(clippy::indexing_slicing)]
 #![allow(clippy::unwrap_used)]
 #![allow(clippy::arithmetic_side_effects)]
+use super::mock;
 use super::mock::*;
 use approx::assert_abs_diff_eq;
 use frame_support::{assert_err, assert_noop, assert_ok};
@@ -3160,17 +3161,12 @@ fn test_parent_child_chain_epoch() {
         SubtensorModule::add_balance_to_coldkey_account(&coldkey_b, 1_000);
         SubtensorModule::add_balance_to_coldkey_account(&coldkey_c, 1_000);
 
+        mock::setup_reserves(netuid, 1_000_000_000_000, 1_000_000_000_000);
+
         // Swap to alpha
-        let total_tao: I96F32 = I96F32::from_num(300_000 + 100_000 + 50_000);
-        let total_alpha = I96F32::from_num(
-            SubtensorModule::swap_tao_for_alpha(
-                netuid,
-                total_tao.saturating_to_num::<u64>(),
-                <Test as Config>::SwapInterface::max_price(),
-            )
-            .unwrap()
-            .amount_paid_out,
-        );
+        let total_tao = I96F32::from_num(300_000 + 100_000 + 50_000);
+        let (total_alpha, _) = mock::swap_tao_to_alpha(netuid, total_tao.to_num());
+        let total_alpha = I96F32::from_num(total_alpha);
 
         // Set the stakes directly
         // This avoids needing to swap tao to alpha, impacting the initial stake distribution.
@@ -3194,21 +3190,28 @@ fn test_parent_child_chain_epoch() {
         );
 
         // Get old stakes
-        let stake_a: u64 = SubtensorModule::get_total_stake_for_hotkey(&hotkey_a);
-        let stake_b: u64 = SubtensorModule::get_total_stake_for_hotkey(&hotkey_b);
-        let stake_c: u64 = SubtensorModule::get_total_stake_for_hotkey(&hotkey_c);
+        let stake_a = SubtensorModule::get_total_stake_for_hotkey(&hotkey_a);
+        let stake_b = SubtensorModule::get_total_stake_for_hotkey(&hotkey_b);
+        let stake_c = SubtensorModule::get_total_stake_for_hotkey(&hotkey_c);
 
         // Assert initial stake is correct
-        let rel_stake_a = I96F32::from_num(stake_a) / total_tao;
-        let rel_stake_b = I96F32::from_num(stake_b) / total_tao;
-        let rel_stake_c = I96F32::from_num(stake_c) / total_tao;
+        let rel_stake_a = I96F32::from_num(stake_a) / total_alpha;
+        let rel_stake_b = I96F32::from_num(stake_b) / total_alpha;
+        let rel_stake_c = I96F32::from_num(stake_c) / total_alpha;
 
         log::info!("rel_stake_a: {:?}", rel_stake_a); // 0.6666 -> 2/3
         log::info!("rel_stake_b: {:?}", rel_stake_b); // 0.2222 -> 2/9
         log::info!("rel_stake_c: {:?}", rel_stake_c); // 0.1111 -> 1/9
-        assert_eq!(rel_stake_a, I96F32::from_num(300_000) / total_tao);
-        assert_eq!(rel_stake_b, I96F32::from_num(100_000) / total_tao);
-        assert_eq!(rel_stake_c, I96F32::from_num(50_000) / total_tao);
+
+        assert!(rel_stake_a > I96F32::from_num(0));
+        assert!(rel_stake_b > I96F32::from_num(0));
+        assert!(rel_stake_c > I96F32::from_num(0));
+
+        // because of the fee we allow slightly higher range
+        let epsilon = I96F32::from_num(0.00001);
+        assert!((rel_stake_a - (I96F32::from_num(300_000) / total_tao)).abs() <= epsilon);
+        assert!((rel_stake_b - (I96F32::from_num(100_000) / total_tao)).abs() <= epsilon);
+        assert!((rel_stake_c - (I96F32::from_num(50_000) / total_tao)).abs() <= epsilon);
 
         // Set parent-child relationships
         // A -> B (50% of A's stake)
@@ -3218,7 +3221,7 @@ fn test_parent_child_chain_epoch() {
         mock_set_children(&coldkey_b, &hotkey_b, netuid, &[(u64::MAX / 2, hotkey_c)]);
 
         // Set CHK take rate to 1/9
-        let chk_take: I96F32 = I96F32::from_num(1_f64 / 9_f64);
+        let chk_take = I96F32::from_num(1_f64 / 9_f64);
         let chk_take_u16: u16 = (chk_take * I96F32::from_num(u16::MAX)).saturating_to_num::<u16>();
         ChildkeyTake::<Test>::insert(hotkey_b, netuid, chk_take_u16);
         ChildkeyTake::<Test>::insert(hotkey_c, netuid, chk_take_u16);
@@ -3226,9 +3229,9 @@ fn test_parent_child_chain_epoch() {
         // Set the weight of root TAO to be 0%, so only alpha is effective.
         SubtensorModule::set_tao_weight(0);
 
-        let hardcoded_emission: I96F32 = I96F32::from_num(1_000_000); // 1 million (adjust as needed)
+        let hardcoded_emission = I96F32::from_num(1_000_000); // 1 million (adjust as needed)
 
-        let hotkey_emission: Vec<(U256, u64, u64)> =
+        let hotkey_emission =
             SubtensorModule::epoch(netuid, hardcoded_emission.saturating_to_num::<u64>());
         log::info!("hotkey_emission: {:?}", hotkey_emission);
         let total_emission: I96F32 = hotkey_emission
@@ -3237,7 +3240,7 @@ fn test_parent_child_chain_epoch() {
             .sum();
 
         // Verify emissions match expected from CHK arrangements
-        let em_eps: I96F32 = I96F32::from_num(1e-4); // 4 decimal places
+        let em_eps = I96F32::from_num(1e-4); // 4 decimal places
         // A's pending emission:
         assert!(
             ((I96F32::from_num(hotkey_emission[0].2) / total_emission) -
@@ -3529,17 +3532,13 @@ fn test_dynamic_parent_child_relationships() {
         SubtensorModule::add_balance_to_coldkey_account(&coldkey_child1, 50_000 + 1_000);
         SubtensorModule::add_balance_to_coldkey_account(&coldkey_child2, 30_000 + 1_000);
 
+        let reserve = 1_000_000_000_000;
+        mock::setup_reserves(netuid, reserve, reserve);
+
         // Swap to alpha
         let total_tao = I96F32::from_num(500_000 + 50_000 + 30_000);
-        let total_alpha = I96F32::from_num(
-            SubtensorModule::swap_tao_for_alpha(
-                netuid,
-                total_tao.saturating_to_num::<u64>(),
-                <Test as Config>::SwapInterface::max_price(),
-            )
-            .unwrap()
-            .amount_paid_out,
-        );
+        let (total_alpha, _) = mock::swap_tao_to_alpha(netuid, total_tao.to_num());
+        let total_alpha = I96F32::from_num(total_alpha);
         log::info!("total_alpha: {:?}", total_alpha);
 
         // Set the stakes directly
diff --git a/pallets/subtensor/src/tests/mock.rs b/pallets/subtensor/src/tests/mock.rs
index dbbe2edbfb..2015504cae 100644
--- a/pallets/subtensor/src/tests/mock.rs
+++ b/pallets/subtensor/src/tests/mock.rs
@@ -863,7 +863,7 @@ pub(crate) fn setup_reserves(netuid: u16, tao: u64, alpha: u64) {
     SubnetAlphaIn::<Test>::set(netuid, alpha);
 }
 
-pub(crate) fn swap_tao_to_alpha(netuid: u16, tao: u64) -> u64 {
+pub(crate) fn swap_tao_to_alpha(netuid: u16, tao: u64) -> (u64, u64) {
     let result = <Test as pallet::Config>::SwapInterface::swap(
         netuid,
         OrderType::Buy,
@@ -874,10 +874,10 @@ pub(crate) fn swap_tao_to_alpha(netuid: u16, tao: u64) -> u64 {
 
     assert_ok!(&result);
 
-    let result = result.unwrap().amount_paid_out;
+    let result = result.unwrap();
 
     // we don't want to have silent 0 comparissons in tests
-    assert!(result > 0);
+    assert!(result.amount_paid_out > 0);
 
-    result
+    (result.amount_paid_out, result.fee_paid)
 }
diff --git a/pallets/subtensor/src/tests/swap_coldkey.rs b/pallets/subtensor/src/tests/swap_coldkey.rs
index 07812547e5..6c487cfc12 100644
--- a/pallets/subtensor/src/tests/swap_coldkey.rs
+++ b/pallets/subtensor/src/tests/swap_coldkey.rs
@@ -373,7 +373,7 @@ fn test_swap_with_max_values() {
         mock::setup_reserves(netuid2, reserve, reserve);
 
         // Stake to hotkey on each subnet.
-        let expected_stake_alpha1 = mock::swap_tao_to_alpha(netuid, max_stake);
+        let (expected_stake_alpha1, fee) = mock::swap_tao_to_alpha(netuid, max_stake);
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(old_coldkey),
             hotkey,
@@ -381,7 +381,7 @@ fn test_swap_with_max_values() {
             max_stake
         ));
 
-        let expected_stake_alpha2 = mock::swap_tao_to_alpha(netuid2, max_stake);
+        let (expected_stake_alpha2, fee) = mock::swap_tao_to_alpha(netuid2, max_stake);
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(old_coldkey2),
             hotkey2,
@@ -440,7 +440,7 @@ fn test_swap_with_non_existent_new_coldkey() {
 
         // Stake to hotkey.
 
-        let expected_stake_alpha = mock::swap_tao_to_alpha(netuid, stake);
+        let (expected_stake_alpha, fee) = mock::swap_tao_to_alpha(netuid, stake);
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(old_coldkey),
             hotkey,
@@ -562,7 +562,7 @@ fn test_swap_concurrent_modifications() {
 
         mock::setup_reserves(netuid, 1_000_000_000_000_000, 1_000_000_000_000_000);
 
-        let initial_stake_alpha = mock::swap_tao_to_alpha(netuid, initial_stake);
+        let (initial_stake_alpha, fee) = mock::swap_tao_to_alpha(netuid, initial_stake);
 
         // Setup initial state
         add_network(netuid, 1, 1);
@@ -590,7 +590,7 @@ fn test_swap_concurrent_modifications() {
         // Wait some blocks
         step_block(10);
 
-        let additional_stake_alpha = mock::swap_tao_to_alpha(netuid, additional_stake);
+        let (additional_stake_alpha, fee) = mock::swap_tao_to_alpha(netuid, additional_stake);
 
         // Simulate concurrent stake addition
         assert_ok!(SubtensorModule::add_stake(
@@ -854,7 +854,7 @@ fn test_swap_stake_for_coldkey() {
         mock::setup_reserves(netuid, reserve, reserve);
 
         // Stake to hotkeys
-        let expected_stake_alpha1 = mock::swap_tao_to_alpha(netuid, stake_amount1);
+        let (expected_stake_alpha1, fee) = mock::swap_tao_to_alpha(netuid, stake_amount1);
 
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(old_coldkey),
@@ -863,7 +863,7 @@ fn test_swap_stake_for_coldkey() {
             stake_amount1
         ));
 
-        let expected_stake_alpha2 = mock::swap_tao_to_alpha(netuid, stake_amount2);
+        let (expected_stake_alpha2, fee) = mock::swap_tao_to_alpha(netuid, stake_amount2);
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(old_coldkey),
             hotkey2,
@@ -893,7 +893,7 @@ fn test_swap_stake_for_coldkey() {
         // give new coldkey some balance
         SubtensorModule::add_balance_to_coldkey_account(&new_coldkey, stake_amount3 + 1_000_000);
         // Stake to hotkey1
-        let expected_stake_alpha3 = mock::swap_tao_to_alpha(netuid, stake_amount3);
+        let (expected_stake_alpha3, fee) = mock::swap_tao_to_alpha(netuid, stake_amount3);
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(new_coldkey),
             hotkey1,
@@ -1014,7 +1014,7 @@ fn test_swap_staking_hotkeys_for_coldkey() {
         mock::setup_reserves(netuid, reserve, reserve);
 
         // Stake to hotkeys
-        let expected_stake_alpha1 = mock::swap_tao_to_alpha(netuid, stake_amount1);
+        let (expected_stake_alpha1, fee) = mock::swap_tao_to_alpha(netuid, stake_amount1);
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(old_coldkey),
             hotkey1,
@@ -1022,7 +1022,7 @@ fn test_swap_staking_hotkeys_for_coldkey() {
             stake_amount1
         ));
 
-        let expected_stake_alpha2 = mock::swap_tao_to_alpha(netuid, stake_amount2);
+        let (expected_stake_alpha2, fee) = mock::swap_tao_to_alpha(netuid, stake_amount2);
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(old_coldkey),
             hotkey2,
@@ -1090,7 +1090,7 @@ fn test_swap_delegated_stake_for_coldkey() {
             stake_amount1 + stake_amount2 + 1_000_000,
         );
 
-        let expected_stake_alpha1 = mock::swap_tao_to_alpha(netuid, stake_amount1);
+        let (expected_stake_alpha1, fee) = mock::swap_tao_to_alpha(netuid, stake_amount1);
 
         // === Stake to hotkeys ===
         assert_ok!(SubtensorModule::add_stake(
@@ -1100,7 +1100,7 @@ fn test_swap_delegated_stake_for_coldkey() {
             stake_amount1
         ));
 
-        let expected_stake_alpha2 = mock::swap_tao_to_alpha(netuid, stake_amount2);
+        let (expected_stake_alpha2, fee) = mock::swap_tao_to_alpha(netuid, stake_amount2);
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(old_coldkey),
             hotkey2,
@@ -1651,7 +1651,7 @@ fn test_coldkey_delegations() {
         mock::setup_reserves(netuid, reserve, reserve);
         mock::setup_reserves(netuid2, reserve, reserve);
 
-        let expected_stake = mock::swap_tao_to_alpha(netuid, stake);
+        let (expected_stake, fee) = mock::swap_tao_to_alpha(netuid, stake);
 
         add_network(netuid, 13, 0); // root
         add_network(netuid2, 13, 0);

From c6a68e982cd4a36ddf172f39cb46a2405240473d Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Tue, 22 Apr 2025 23:48:43 +0800
Subject: [PATCH 078/418] init solution

---
 pallets/subtensor/src/macros/dispatches.rs |   5 +-
 pallets/subtensor/src/swap/swap_hotkey.rs  | 105 +++++++++++++++++++++
 2 files changed, 108 insertions(+), 2 deletions(-)

diff --git a/pallets/subtensor/src/macros/dispatches.rs b/pallets/subtensor/src/macros/dispatches.rs
index 4ea03c957b..c216bc469d 100644
--- a/pallets/subtensor/src/macros/dispatches.rs
+++ b/pallets/subtensor/src/macros/dispatches.rs
@@ -926,7 +926,7 @@ mod dispatches {
             Self::do_burned_registration(origin, netuid, hotkey)
         }
 
-        /// The extrinsic for user to change its hotkey
+        /// The extrinsic for user to change its hotkey in subnet or all subnets.
         #[pallet::call_index(70)]
         #[pallet::weight((Weight::from_parts(1_940_000_000, 0)
         .saturating_add(T::DbWeight::get().reads(272))
@@ -935,8 +935,9 @@ mod dispatches {
             origin: OriginFor<T>,
             hotkey: T::AccountId,
             new_hotkey: T::AccountId,
+            netuid: Option<u16>,
         ) -> DispatchResultWithPostInfo {
-            Self::do_swap_hotkey(origin, &hotkey, &new_hotkey)
+            Self::do_swap_hotkey(origin, &hotkey, &new_hotkey, netuid)
         }
 
         /// The extrinsic for user to change the coldkey associated with their account.
diff --git a/pallets/subtensor/src/swap/swap_hotkey.rs b/pallets/subtensor/src/swap/swap_hotkey.rs
index 54c7c01d8e..10bb3aa6a7 100644
--- a/pallets/subtensor/src/swap/swap_hotkey.rs
+++ b/pallets/subtensor/src/swap/swap_hotkey.rs
@@ -11,6 +11,7 @@ impl<T: Config> Pallet<T> {
     /// * `origin` - The origin of the transaction, and also the coldkey account.
     /// * `old_hotkey` - The old hotkey to be swapped.
     /// * `new_hotkey` - The new hotkey to replace the old one.
+    /// * `netuid` - The hotkey swap in a subnet or all subnets.
     ///
     /// # Returns
     ///
@@ -27,6 +28,7 @@ impl<T: Config> Pallet<T> {
         origin: T::RuntimeOrigin,
         old_hotkey: &T::AccountId,
         new_hotkey: &T::AccountId,
+        netuid: Option<u16>,
     ) -> DispatchResultWithPostInfo {
         // 1. Ensure the origin is signed and get the coldkey
         let coldkey = ensure_signed(origin)?;
@@ -489,4 +491,107 @@ impl<T: Config> Pallet<T> {
         }
         Ok(())
     }
+
+    /// Swaps the hotkey of a coldkey account.
+    ///
+    /// # Arguments
+    ///
+    /// * `origin` - The origin of the transaction, and also the coldkey account.
+    /// * `old_hotkey` - The old hotkey to be swapped.
+    /// * `new_hotkey` - The new hotkey to replace the old one.
+    ///
+    /// # Returns
+    ///
+    /// * `DispatchResultWithPostInfo` - The result of the dispatch.
+    ///
+    /// # Errors
+    ///
+    /// * `NonAssociatedColdKey` - If the coldkey does not own the old hotkey.
+    /// * `HotKeySetTxRateLimitExceeded` - If the transaction rate limit is exceeded.
+    /// * `NewHotKeyIsSameWithOld` - If the new hotkey is the same as the old hotkey.
+    /// * `HotKeyAlreadyRegisteredInSubNet` - If the new hotkey is already registered in the subnet.
+    /// * `NotEnoughBalanceToPaySwapHotKey` - If there is not enough balance to pay for the swap.
+    pub fn do_swap_hotkey_in_subnet(
+        origin: T::RuntimeOrigin,
+        old_hotkey: &T::AccountId,
+        new_hotkey: &T::AccountId,
+        netuid: Option<u16>,
+    ) -> DispatchResultWithPostInfo {
+        // 1. Ensure the origin is signed and get the coldkey
+        let coldkey = ensure_signed(origin)?;
+
+        // 2. Initialize the weight for this operation
+        let mut weight = T::DbWeight::get().reads(2);
+
+        // 3. Ensure the new hotkey is different from the old one
+        ensure!(old_hotkey != new_hotkey, Error::<T>::NewHotKeyIsSameWithOld);
+
+        let netuid = netuid.unwrap_or(0);
+        ensure!(
+            Self::if_subnet_exist(netuid),
+            Error::<T>::SubNetworkDoesNotExist
+        );
+
+        // 4. Ensure the new hotkey is not already registered on any network
+        ensure!(
+            IsNetworkMember::<T>::get(new_hotkey, netuid),
+            Error::<T>::HotKeyNotRegisteredInSubNet
+        );
+
+        // 5. Update the weight for the checks above
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 0));
+
+        // 6. Ensure the coldkey owns the old hotkey
+        ensure!(
+            Self::coldkey_owns_hotkey(&coldkey, old_hotkey),
+            Error::<T>::NonAssociatedColdKey
+        );
+
+        // 7. Get the current block number
+        let block: u64 = Self::get_current_block_as_u64();
+
+        // 8. Ensure the transaction rate limit is not exceeded
+        ensure!(
+            !Self::exceeds_tx_rate_limit(Self::get_last_tx_block(&coldkey), block),
+            Error::<T>::HotKeySetTxRateLimitExceeded
+        );
+
+        // 9. Update the weight for reading the total networks
+        weight.saturating_accrue(
+            T::DbWeight::get().reads((TotalNetworks::<T>::get().saturating_add(1u16)) as u64),
+        );
+
+        // 10. Get the cost for swapping the key
+        let swap_cost = Self::get_key_swap_cost();
+        log::debug!("Swap cost: {:?}", swap_cost);
+
+        // 11. Ensure the coldkey has enough balance to pay for the swap
+        ensure!(
+            Self::can_remove_balance_from_coldkey_account(&coldkey, swap_cost),
+            Error::<T>::NotEnoughBalanceToPaySwapHotKey
+        );
+
+        // 12. Remove the swap cost from the coldkey's account
+        let actual_burn_amount = Self::remove_balance_from_coldkey_account(&coldkey, swap_cost)?;
+
+        // 13. Burn the tokens
+        Self::burn_tokens(actual_burn_amount);
+
+        // 14. Perform the hotkey swap
+        let _ = Self::perform_hotkey_swap(old_hotkey, new_hotkey, &coldkey, &mut weight);
+
+        // 15. Update the last transaction block for the coldkey
+        Self::set_last_tx_block(&coldkey, block);
+        weight.saturating_accrue(T::DbWeight::get().writes(1));
+
+        // 16. Emit an event for the hotkey swap
+        Self::deposit_event(Event::HotkeySwapped {
+            coldkey,
+            old_hotkey: old_hotkey.clone(),
+            new_hotkey: new_hotkey.clone(),
+        });
+
+        // 17. Return the weight of the operation
+        Ok(Some(weight).into())
+    }
 }

From d01d1c5dd056c4f7c097b10b89287aa12b1ceb70 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Fri, 25 Apr 2025 10:01:33 +0800
Subject: [PATCH 079/418] keep progress

---
 pallets/subtensor/src/macros/config.rs    |   3 +
 pallets/subtensor/src/subnets/uids.rs     |   6 ++
 pallets/subtensor/src/swap/swap_hotkey.rs | 105 ++++++----------------
 3 files changed, 37 insertions(+), 77 deletions(-)

diff --git a/pallets/subtensor/src/macros/config.rs b/pallets/subtensor/src/macros/config.rs
index cf4d97b65b..46ca9dadca 100644
--- a/pallets/subtensor/src/macros/config.rs
+++ b/pallets/subtensor/src/macros/config.rs
@@ -213,5 +213,8 @@ mod config {
         /// Block number after a new subnet accept the start call extrinsic.
         #[pallet::constant]
         type DurationOfStartCall: Get<u64>;
+        /// Cost of swapping a hotkey in a subnet.
+        #[pallet::constant]
+        type KeySwapOneSubnetCost: Get<u64>;
     }
 }
diff --git a/pallets/subtensor/src/subnets/uids.rs b/pallets/subtensor/src/subnets/uids.rs
index c97252677c..008fc03669 100644
--- a/pallets/subtensor/src/subnets/uids.rs
+++ b/pallets/subtensor/src/subnets/uids.rs
@@ -187,4 +187,10 @@ impl<T: Config> Pallet<T> {
         }
         false
     }
+
+    /// Return true if a hotkey is registered on specific network.
+    ///
+    pub fn is_hotkey_registered_on_specific_network(hotkey: &T::AccountId, netuid: u16) -> bool {
+        IsNetworkMember::<T>::contains_key(hotkey, netuid)
+    }
 }
diff --git a/pallets/subtensor/src/swap/swap_hotkey.rs b/pallets/subtensor/src/swap/swap_hotkey.rs
index 10bb3aa6a7..e74475959f 100644
--- a/pallets/subtensor/src/swap/swap_hotkey.rs
+++ b/pallets/subtensor/src/swap/swap_hotkey.rs
@@ -33,27 +33,21 @@ impl<T: Config> Pallet<T> {
         // 1. Ensure the origin is signed and get the coldkey
         let coldkey = ensure_signed(origin)?;
 
+        // 6. Ensure the coldkey owns the old hotkey
+        ensure!(
+            Self::coldkey_owns_hotkey(&coldkey, old_hotkey),
+            Error::<T>::NonAssociatedColdKey
+        );
+
         // 2. Initialize the weight for this operation
         let mut weight = T::DbWeight::get().reads(2);
 
         // 3. Ensure the new hotkey is different from the old one
         ensure!(old_hotkey != new_hotkey, Error::<T>::NewHotKeyIsSameWithOld);
 
-        // 4. Ensure the new hotkey is not already registered on any network
-        ensure!(
-            !Self::is_hotkey_registered_on_any_network(new_hotkey),
-            Error::<T>::HotKeyAlreadyRegisteredInSubNet
-        );
-
         // 5. Update the weight for the checks above
         weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 0));
 
-        // 6. Ensure the coldkey owns the old hotkey
-        ensure!(
-            Self::coldkey_owns_hotkey(&coldkey, old_hotkey),
-            Error::<T>::NonAssociatedColdKey
-        );
-
         // 7. Get the current block number
         let block: u64 = Self::get_current_block_as_u64();
 
@@ -68,6 +62,16 @@ impl<T: Config> Pallet<T> {
             T::DbWeight::get().reads((TotalNetworks::<T>::get().saturating_add(1u16)) as u64),
         );
 
+        if let Some(netuid) = netuid {
+            return Self::swap_hotkey_on_subnet(&coldkey, old_hotkey, new_hotkey, netuid, weight);
+        };
+
+        // 4. Ensure the new hotkey is not already registered on any network
+        ensure!(
+            !Self::is_hotkey_registered_on_any_network(new_hotkey),
+            Error::<T>::HotKeyAlreadyRegisteredInSubNet
+        );
+
         // 10. Get the cost for swapping the key
         let swap_cost = Self::get_key_swap_cost();
         log::debug!("Swap cost: {:?}", swap_cost);
@@ -492,78 +496,26 @@ impl<T: Config> Pallet<T> {
         Ok(())
     }
 
-    /// Swaps the hotkey of a coldkey account.
-    ///
-    /// # Arguments
-    ///
-    /// * `origin` - The origin of the transaction, and also the coldkey account.
-    /// * `old_hotkey` - The old hotkey to be swapped.
-    /// * `new_hotkey` - The new hotkey to replace the old one.
-    ///
-    /// # Returns
-    ///
-    /// * `DispatchResultWithPostInfo` - The result of the dispatch.
-    ///
-    /// # Errors
-    ///
-    /// * `NonAssociatedColdKey` - If the coldkey does not own the old hotkey.
-    /// * `HotKeySetTxRateLimitExceeded` - If the transaction rate limit is exceeded.
-    /// * `NewHotKeyIsSameWithOld` - If the new hotkey is the same as the old hotkey.
-    /// * `HotKeyAlreadyRegisteredInSubNet` - If the new hotkey is already registered in the subnet.
-    /// * `NotEnoughBalanceToPaySwapHotKey` - If there is not enough balance to pay for the swap.
-    pub fn do_swap_hotkey_in_subnet(
-        origin: T::RuntimeOrigin,
+    fn swap_hotkey_on_subnet(
+        coldkey: &T::AccountId,
         old_hotkey: &T::AccountId,
         new_hotkey: &T::AccountId,
-        netuid: Option<u16>,
+        netuid: u16,
+        init_weight: Weight,
     ) -> DispatchResultWithPostInfo {
-        // 1. Ensure the origin is signed and get the coldkey
-        let coldkey = ensure_signed(origin)?;
-
-        // 2. Initialize the weight for this operation
-        let mut weight = T::DbWeight::get().reads(2);
-
-        // 3. Ensure the new hotkey is different from the old one
-        ensure!(old_hotkey != new_hotkey, Error::<T>::NewHotKeyIsSameWithOld);
+        let mut weight = init_weight;
 
-        let netuid = netuid.unwrap_or(0);
-        ensure!(
-            Self::if_subnet_exist(netuid),
-            Error::<T>::SubNetworkDoesNotExist
-        );
+        // Ensure the hotkey not registered on the network before.
 
-        // 4. Ensure the new hotkey is not already registered on any network
         ensure!(
-            IsNetworkMember::<T>::get(new_hotkey, netuid),
-            Error::<T>::HotKeyNotRegisteredInSubNet
+            !Self::is_hotkey_registered_on_specific_network(new_hotkey, netuid),
+            Error::<T>::HotKeyAlreadyRegisteredInSubNet
         );
-
-        // 5. Update the weight for the checks above
         weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 0));
 
-        // 6. Ensure the coldkey owns the old hotkey
-        ensure!(
-            Self::coldkey_owns_hotkey(&coldkey, old_hotkey),
-            Error::<T>::NonAssociatedColdKey
-        );
-
-        // 7. Get the current block number
-        let block: u64 = Self::get_current_block_as_u64();
-
-        // 8. Ensure the transaction rate limit is not exceeded
-        ensure!(
-            !Self::exceeds_tx_rate_limit(Self::get_last_tx_block(&coldkey), block),
-            Error::<T>::HotKeySetTxRateLimitExceeded
-        );
-
-        // 9. Update the weight for reading the total networks
-        weight.saturating_accrue(
-            T::DbWeight::get().reads((TotalNetworks::<T>::get().saturating_add(1u16)) as u64),
-        );
-
         // 10. Get the cost for swapping the key
-        let swap_cost = Self::get_key_swap_cost();
-        log::debug!("Swap cost: {:?}", swap_cost);
+        let swap_cost = T::KeySwapOneSubnetCost::get();
+        log::debug!("Swap cost in subnet {:?}: {:?}", netuid, swap_cost);
 
         // 11. Ensure the coldkey has enough balance to pay for the swap
         ensure!(
@@ -579,19 +531,18 @@ impl<T: Config> Pallet<T> {
 
         // 14. Perform the hotkey swap
         let _ = Self::perform_hotkey_swap(old_hotkey, new_hotkey, &coldkey, &mut weight);
-
+        let block: u64 = Self::get_current_block_as_u64();
         // 15. Update the last transaction block for the coldkey
         Self::set_last_tx_block(&coldkey, block);
         weight.saturating_accrue(T::DbWeight::get().writes(1));
 
         // 16. Emit an event for the hotkey swap
         Self::deposit_event(Event::HotkeySwapped {
-            coldkey,
+            coldkey: coldkey.clone(),
             old_hotkey: old_hotkey.clone(),
             new_hotkey: new_hotkey.clone(),
         });
 
-        // 17. Return the weight of the operation
         Ok(Some(weight).into())
     }
 }

From 3b2fbcebabe9721cdf4849a7a6b5c62562475f1c Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Mon, 28 Apr 2025 21:16:38 +0800
Subject: [PATCH 080/418] most of coding done

---
 pallets/subtensor/src/macros/events.rs    |  12 +
 pallets/subtensor/src/swap/swap_hotkey.rs | 596 ++++++++++++----------
 runtime/src/lib.rs                        |   2 +
 3 files changed, 335 insertions(+), 275 deletions(-)

diff --git a/pallets/subtensor/src/macros/events.rs b/pallets/subtensor/src/macros/events.rs
index ccbfed9eff..f691ff4760 100644
--- a/pallets/subtensor/src/macros/events.rs
+++ b/pallets/subtensor/src/macros/events.rs
@@ -347,5 +347,17 @@ mod events {
         /// - **netuid**: The network identifier.
         /// - **Enabled**: Is Commit-Reveal enabled.
         CommitRevealEnabled(u16, bool),
+
+        /// the hotkey is swapped
+        HotkeySwappedOnSubnet {
+            /// the account ID of coldkey
+            coldkey: T::AccountId,
+            /// the account ID of old hotkey
+            old_hotkey: T::AccountId,
+            /// the account ID of new hotkey
+            new_hotkey: T::AccountId,
+            /// the subnet ID
+            netuid: u16,
+        },
     }
 }
diff --git a/pallets/subtensor/src/swap/swap_hotkey.rs b/pallets/subtensor/src/swap/swap_hotkey.rs
index e74475959f..451dd86b1a 100644
--- a/pallets/subtensor/src/swap/swap_hotkey.rs
+++ b/pallets/subtensor/src/swap/swap_hotkey.rs
@@ -33,7 +33,7 @@ impl<T: Config> Pallet<T> {
         // 1. Ensure the origin is signed and get the coldkey
         let coldkey = ensure_signed(origin)?;
 
-        // 6. Ensure the coldkey owns the old hotkey
+        // 2. Ensure the coldkey owns the old hotkey
         ensure!(
             Self::coldkey_owns_hotkey(&coldkey, old_hotkey),
             Error::<T>::NonAssociatedColdKey
@@ -57,15 +57,48 @@ impl<T: Config> Pallet<T> {
             Error::<T>::HotKeySetTxRateLimitExceeded
         );
 
-        // 9. Update the weight for reading the total networks
-        weight.saturating_accrue(
-            T::DbWeight::get().reads((TotalNetworks::<T>::get().saturating_add(1u16)) as u64),
-        );
-
+        // fork for swap hotkey on a specific subnet case after do the common check
         if let Some(netuid) = netuid {
             return Self::swap_hotkey_on_subnet(&coldkey, old_hotkey, new_hotkey, netuid, weight);
         };
 
+        // 5. Swap LastTxBlock
+        // LastTxBlock( hotkey ) --> u64 -- the last transaction block for the hotkey.
+        let last_tx_block: u64 = LastTxBlock::<T>::get(old_hotkey);
+        LastTxBlock::<T>::remove(old_hotkey);
+        LastTxBlock::<T>::insert(new_hotkey, last_tx_block);
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
+
+        // 6. Swap LastTxBlockDelegateTake
+        // LastTxBlockDelegateTake( hotkey ) --> u64 -- the last transaction block for the hotkey delegate take.
+        let last_tx_block_delegate_take: u64 = LastTxBlockDelegateTake::<T>::get(old_hotkey);
+        LastTxBlockDelegateTake::<T>::remove(old_hotkey);
+        LastTxBlockDelegateTake::<T>::insert(new_hotkey, last_tx_block_delegate_take);
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
+
+        // 7. Swap LastTxBlockChildKeyTake
+        // LastTxBlockChildKeyTake( hotkey ) --> u64 -- the last transaction block for the hotkey child key take.
+        let last_tx_block_child_key_take: u64 = LastTxBlockChildKeyTake::<T>::get(old_hotkey);
+        LastTxBlockChildKeyTake::<T>::remove(old_hotkey);
+        LastTxBlockChildKeyTake::<T>::insert(new_hotkey, last_tx_block_child_key_take);
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
+
+        // 8. Swap Senate members.
+        // Senate( hotkey ) --> ?
+        if T::SenateMembers::is_member(old_hotkey) {
+            T::SenateMembers::swap_member(old_hotkey, new_hotkey).map_err(|e| e.error)?;
+            weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
+        }
+
+        // 9. Swap delegates.
+        // Delegates( hotkey ) -> take value -- the hotkey delegate take value.
+        if Delegates::<T>::contains_key(old_hotkey) {
+            let old_delegate_take = Delegates::<T>::get(old_hotkey);
+            Delegates::<T>::remove(old_hotkey);
+            Delegates::<T>::insert(new_hotkey, old_delegate_take);
+            weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 2));
+        }
+
         // 4. Ensure the new hotkey is not already registered on any network
         ensure!(
             !Self::is_hotkey_registered_on_any_network(new_hotkey),
@@ -89,7 +122,8 @@ impl<T: Config> Pallet<T> {
         Self::burn_tokens(actual_burn_amount);
 
         // 14. Perform the hotkey swap
-        let _ = Self::perform_hotkey_swap(old_hotkey, new_hotkey, &coldkey, &mut weight);
+        let _ =
+            Self::perform_hotkey_swap_on_all_subnets(old_hotkey, new_hotkey, &coldkey, &mut weight);
 
         // 15. Update the last transaction block for the coldkey
         Self::set_last_tx_block(&coldkey, block);
@@ -140,7 +174,7 @@ impl<T: Config> Pallet<T> {
     /// # Note
     /// This function performs extensive storage reads and writes, which can be computationally expensive.
     /// The accumulated weight should be carefully considered in the context of block limits.
-    pub fn perform_hotkey_swap(
+    pub fn perform_hotkey_swap_on_all_subnets(
         old_hotkey: &T::AccountId,
         new_hotkey: &T::AccountId,
         coldkey: &T::AccountId,
@@ -164,33 +198,9 @@ impl<T: Config> Pallet<T> {
         OwnedHotkeys::<T>::insert(coldkey, hotkeys);
         weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
 
-        // 3. Swap total hotkey alpha for all subnets it exists on.
-        // TotalHotkeyAlpha( hotkey, netuid ) -> alpha -- the total alpha that the hotkey has on a specific subnet.
-        TotalHotkeyAlpha::<T>::iter_prefix(old_hotkey)
-            .drain()
-            .for_each(|(netuid, old_alpha)| {
-                let new_total_hotkey_alpha = TotalHotkeyAlpha::<T>::get(new_hotkey, netuid);
-                TotalHotkeyAlpha::<T>::insert(
-                    new_hotkey,
-                    netuid,
-                    old_alpha.saturating_add(new_total_hotkey_alpha),
-                );
-                weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 2));
-            });
-
-        // 4. Swap total hotkey shares on all subnets it exists on.
-        // TotalHotkeyShares( hotkey, netuid ) -> alpha -- the total alpha that the hotkey has on a specific subnet.
-        TotalHotkeyShares::<T>::iter_prefix(old_hotkey)
-            .drain()
-            .for_each(|(netuid, old_shares)| {
-                let new_total_hotkey_shares = TotalHotkeyShares::<T>::get(new_hotkey, netuid);
-                TotalHotkeyShares::<T>::insert(
-                    new_hotkey,
-                    netuid,
-                    old_shares.saturating_add(new_total_hotkey_shares),
-                );
-                weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 2));
-            });
+        for netuid in Self::get_all_subnet_netuids() {
+            Self::perform_hotkey_swap_on_one_subnet(old_hotkey, new_hotkey, weight, netuid);
+        }
 
         // 5. Swap LastTxBlock
         // LastTxBlock( hotkey ) --> u64 -- the last transaction block for the hotkey.
@@ -229,92 +239,201 @@ impl<T: Config> Pallet<T> {
             weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 2));
         }
 
-        // 9. swap PendingHotkeyEmissionOnNetuid
-        // (DEPRECATED.)
-
-        // 10. Swap all subnet specific info.
-        let all_netuids: Vec<u16> = Self::get_all_subnet_netuids();
-        all_netuids.iter().for_each(|netuid| {
-            // 10.1 Remove the previous hotkey and insert the new hotkey from membership.
-            // IsNetworkMember( hotkey, netuid ) -> bool -- is the hotkey a subnet member.
-            let is_network_member: bool = IsNetworkMember::<T>::get(old_hotkey, netuid);
-            IsNetworkMember::<T>::remove(old_hotkey, netuid);
-            IsNetworkMember::<T>::insert(new_hotkey, netuid, is_network_member);
+        // Return successful after swapping all the relevant terms.
+        Ok(())
+    }
+
+    pub fn swap_senate_member(
+        old_hotkey: &T::AccountId,
+        new_hotkey: &T::AccountId,
+        weight: &mut Weight,
+    ) -> DispatchResult {
+        weight.saturating_accrue(T::DbWeight::get().reads(1));
+        if T::SenateMembers::is_member(old_hotkey) {
+            T::SenateMembers::swap_member(old_hotkey, new_hotkey).map_err(|e| e.error)?;
             weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
+        }
+        Ok(())
+    }
 
-            // 10.2 Swap Uids + Keys.
-            // Keys( netuid, hotkey ) -> uid -- the uid the hotkey has in the network if it is a member.
-            // Uids( netuid, hotkey ) -> uid -- the uids that the hotkey has.
-            if is_network_member {
-                // 10.2.1 Swap the UIDS
-                if let Ok(old_uid) = Uids::<T>::try_get(netuid, old_hotkey) {
-                    Uids::<T>::remove(netuid, old_hotkey);
-                    Uids::<T>::insert(netuid, new_hotkey, old_uid);
-                    weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
-
-                    // 10.2.2 Swap the keys.
-                    Keys::<T>::insert(netuid, old_uid, new_hotkey.clone());
-                    weight.saturating_accrue(T::DbWeight::get().reads_writes(0, 1));
-                }
+    fn swap_hotkey_on_subnet(
+        coldkey: &T::AccountId,
+        old_hotkey: &T::AccountId,
+        new_hotkey: &T::AccountId,
+        netuid: u16,
+        init_weight: Weight,
+    ) -> DispatchResultWithPostInfo {
+        let mut weight = init_weight;
+
+        // Ensure the hotkey not registered on the network before.
+
+        ensure!(
+            !Self::is_hotkey_registered_on_specific_network(new_hotkey, netuid),
+            Error::<T>::HotKeyAlreadyRegisteredInSubNet
+        );
+
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 0));
+
+        // 10. Get the cost for swapping the key
+        let swap_cost = T::KeySwapOneSubnetCost::get();
+        log::debug!("Swap cost in subnet {:?}: {:?}", netuid, swap_cost);
+
+        // 11. Ensure the coldkey has enough balance to pay for the swap
+        ensure!(
+            Self::can_remove_balance_from_coldkey_account(&coldkey, swap_cost),
+            Error::<T>::NotEnoughBalanceToPaySwapHotKey
+        );
+
+        // 12. Remove the swap cost from the coldkey's account
+        let actual_burn_amount = Self::remove_balance_from_coldkey_account(&coldkey, swap_cost)?;
+
+        // 13. Burn the tokens
+        Self::burn_tokens(actual_burn_amount);
+
+        // 1. Swap owner.
+        // Owner( hotkey ) -> coldkey -- the coldkey that owns the hotkey.
+        // Owner::<T>::remove(old_hotkey);
+        Owner::<T>::insert(new_hotkey, coldkey.clone());
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
+
+        // 2. Swap OwnedHotkeys.
+        // OwnedHotkeys( coldkey ) -> Vec<hotkey> -- the hotkeys that the coldkey owns.
+        let mut hotkeys = OwnedHotkeys::<T>::get(coldkey);
+        // Add the new key if needed.
+        if !hotkeys.contains(new_hotkey) {
+            hotkeys.push(new_hotkey.clone());
+            OwnedHotkeys::<T>::insert(coldkey, hotkeys);
+            weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
+        }
+        // Remove the old key.
+        // hotkeys.retain(|hk| *hk != *old_hotkey);
+
+        // 14. Perform the hotkey swap
+        Self::perform_hotkey_swap_on_one_subnet(old_hotkey, new_hotkey, &mut weight, netuid);
+
+        let block: u64 = Self::get_current_block_as_u64();
+        // 15. Update the last transaction block for the coldkey
+        Self::set_last_tx_block(&coldkey, block);
+        weight.saturating_accrue(T::DbWeight::get().writes(1));
+
+        // 16. Emit an event for the hotkey swap
+        Self::deposit_event(Event::HotkeySwappedOnSubnet {
+            coldkey: coldkey.clone(),
+            old_hotkey: old_hotkey.clone(),
+            new_hotkey: new_hotkey.clone(),
+            netuid,
+        });
+
+        Ok(Some(weight).into())
+    }
+
+    // do hotkey swap public part for both swap all subnets and just swap one subnet
+    pub fn perform_hotkey_swap_on_one_subnet(
+        old_hotkey: &T::AccountId,
+        new_hotkey: &T::AccountId,
+        weight: &mut Weight,
+        netuid: u16,
+    ) {
+        // 1. Swap total hotkey alpha for all subnets it exists on.
+        // TotalHotkeyAlpha( hotkey, netuid ) -> alpha -- the total alpha that the hotkey has on a specific subnet.
+
+        let alpha = TotalHotkeyAlpha::<T>::take(old_hotkey, netuid);
+        // TotalHotkeyAlpha::<T>::remove(old_hotkey, netuid);
+        TotalHotkeyAlpha::<T>::mutate(new_hotkey, netuid, |value| {
+            *value = value.saturating_add(alpha)
+        });
+
+        // 2. Swap total hotkey shares on all subnets it exists on.
+        // TotalHotkeyShares( hotkey, netuid ) -> alpha -- the total alpha that the hotkey has on a specific subnet.
+
+        let share = TotalHotkeyShares::<T>::take(old_hotkey, netuid);
+        // TotalHotkeyAlpha::<T>::remove(old_hotkey, netuid);
+        TotalHotkeyShares::<T>::mutate(new_hotkey, netuid, |value| {
+            *value = value.saturating_add(share)
+        });
+
+        // 3. Swap all subnet specific info.
+
+        // 10.1 Remove the previous hotkey and insert the new hotkey from membership.
+        // IsNetworkMember( hotkey, netuid ) -> bool -- is the hotkey a subnet member.
+        let is_network_member: bool = IsNetworkMember::<T>::get(old_hotkey, netuid);
+        IsNetworkMember::<T>::remove(old_hotkey, netuid);
+        IsNetworkMember::<T>::insert(new_hotkey, netuid, is_network_member);
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
+
+        // 10.2 Swap Uids + Keys.
+        // Keys( netuid, hotkey ) -> uid -- the uid the hotkey has in the network if it is a member.
+        // Uids( netuid, hotkey ) -> uid -- the uids that the hotkey has.
+        if is_network_member {
+            // 10.2.1 Swap the UIDS
+            if let Ok(old_uid) = Uids::<T>::try_get(netuid, old_hotkey) {
+                Uids::<T>::remove(netuid, old_hotkey);
+                Uids::<T>::insert(netuid, new_hotkey, old_uid);
+                weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
+
+                // 10.2.2 Swap the keys.
+                Keys::<T>::insert(netuid, old_uid, new_hotkey.clone());
+                weight.saturating_accrue(T::DbWeight::get().reads_writes(0, 1));
             }
+        }
 
-            // 10.3 Swap Prometheus.
-            // Prometheus( netuid, hotkey ) -> prometheus -- the prometheus data that a hotkey has in the network.
-            if is_network_member {
-                if let Ok(old_prometheus_info) = Prometheus::<T>::try_get(netuid, old_hotkey) {
-                    Prometheus::<T>::remove(netuid, old_hotkey);
-                    Prometheus::<T>::insert(netuid, new_hotkey, old_prometheus_info);
-                    weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
-                }
+        // 10.3 Swap Prometheus.
+        // Prometheus( netuid, hotkey ) -> prometheus -- the prometheus data that a hotkey has in the network.
+        if is_network_member {
+            if let Ok(old_prometheus_info) = Prometheus::<T>::try_get(netuid, old_hotkey) {
+                Prometheus::<T>::remove(netuid, old_hotkey);
+                Prometheus::<T>::insert(netuid, new_hotkey, old_prometheus_info);
+                weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
             }
+        }
 
-            // 10.4. Swap axons.
-            // Axons( netuid, hotkey ) -> axon -- the axon that the hotkey has.
-            if is_network_member {
-                if let Ok(old_axon_info) = Axons::<T>::try_get(netuid, old_hotkey) {
-                    Axons::<T>::remove(netuid, old_hotkey);
-                    Axons::<T>::insert(netuid, new_hotkey, old_axon_info);
-                    weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
-                }
+        // 10.4. Swap axons.
+        // Axons( netuid, hotkey ) -> axon -- the axon that the hotkey has.
+        if is_network_member {
+            if let Ok(old_axon_info) = Axons::<T>::try_get(netuid, old_hotkey) {
+                Axons::<T>::remove(netuid, old_hotkey);
+                Axons::<T>::insert(netuid, new_hotkey, old_axon_info);
+                weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
             }
+        }
 
-            // 10.5 Swap WeightCommits
-            // WeightCommits( hotkey ) --> Vec<u64> -- the weight commits for the hotkey.
-            if is_network_member {
-                if let Ok(old_weight_commits) = WeightCommits::<T>::try_get(netuid, old_hotkey) {
-                    WeightCommits::<T>::remove(netuid, old_hotkey);
-                    WeightCommits::<T>::insert(netuid, new_hotkey, old_weight_commits);
-                    weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
-                }
+        // 10.5 Swap WeightCommits
+        // WeightCommits( hotkey ) --> Vec<u64> -- the weight commits for the hotkey.
+        if is_network_member {
+            if let Ok(old_weight_commits) = WeightCommits::<T>::try_get(netuid, old_hotkey) {
+                WeightCommits::<T>::remove(netuid, old_hotkey);
+                WeightCommits::<T>::insert(netuid, new_hotkey, old_weight_commits);
+                weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
             }
+        }
 
-            // 10.6. Swap the subnet loaded emission.
-            // LoadedEmission( netuid ) --> Vec<(hotkey, u64)> -- the loaded emission for the subnet.
-            if is_network_member {
-                if let Some(mut old_loaded_emission) = LoadedEmission::<T>::get(netuid) {
-                    for emission in old_loaded_emission.iter_mut() {
-                        if emission.0 == *old_hotkey {
-                            emission.0 = new_hotkey.clone();
-                        }
+        // 10.6. Swap the subnet loaded emission.
+        // LoadedEmission( netuid ) --> Vec<(hotkey, u64)> -- the loaded emission for the subnet.
+        if is_network_member {
+            if let Some(mut old_loaded_emission) = LoadedEmission::<T>::get(netuid) {
+                for emission in old_loaded_emission.iter_mut() {
+                    if emission.0 == *old_hotkey {
+                        emission.0 = new_hotkey.clone();
                     }
-                    LoadedEmission::<T>::remove(netuid);
-                    LoadedEmission::<T>::insert(netuid, old_loaded_emission);
-                    weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
                 }
+                LoadedEmission::<T>::remove(netuid);
+                LoadedEmission::<T>::insert(netuid, old_loaded_emission);
+                weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
             }
+        }
 
-            // 10.7. Swap neuron TLS certificates.
-            // NeuronCertificates( netuid, hotkey ) -> Vec<u8> -- the neuron certificate for the hotkey.
-            if is_network_member {
-                if let Ok(old_neuron_certificates) =
-                    NeuronCertificates::<T>::try_get(netuid, old_hotkey)
-                {
-                    NeuronCertificates::<T>::remove(netuid, old_hotkey);
-                    NeuronCertificates::<T>::insert(netuid, new_hotkey, old_neuron_certificates);
-                    weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
-                }
+        // 10.7. Swap neuron TLS certificates.
+        // NeuronCertificates( netuid, hotkey ) -> Vec<u8> -- the neuron certificate for the hotkey.
+        if is_network_member {
+            if let Ok(old_neuron_certificates) =
+                NeuronCertificates::<T>::try_get(netuid, old_hotkey)
+            {
+                NeuronCertificates::<T>::remove(netuid, old_hotkey);
+                NeuronCertificates::<T>::insert(netuid, new_hotkey, old_neuron_certificates);
+                weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
             }
-        });
+        }
+        // });
 
         // 11. Swap Alpha
         // Alpha( hotkey, coldkey, netuid ) -> alpha
@@ -348,201 +467,128 @@ impl<T: Config> Pallet<T> {
 
         // 12. Swap ChildKeys.
         // ChildKeys( parent, netuid ) --> Vec<(proportion,child)> -- the child keys of the parent.
-        for netuid in Self::get_all_subnet_netuids() {
-            // Get the children of the old hotkey for this subnet
-            let my_children: Vec<(u64, T::AccountId)> = ChildKeys::<T>::get(old_hotkey, netuid);
-            // Remove the old hotkey's child entries
-            ChildKeys::<T>::remove(old_hotkey, netuid);
-            // Insert the same child entries for the new hotkey
-            ChildKeys::<T>::insert(new_hotkey, netuid, my_children.clone());
-            weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
-            for (_, child_key_i) in my_children {
-                // For each child, update their parent list
-                let mut child_parents: Vec<(u64, T::AccountId)> =
-                    ParentKeys::<T>::get(child_key_i.clone(), netuid);
-                for parent in child_parents.iter_mut() {
-                    // If the parent is the old hotkey, replace it with the new hotkey
-                    if parent.1 == *old_hotkey {
-                        parent.1 = new_hotkey.clone();
-                    }
+        // for netuid in Self::get_all_subnet_netuids() {
+        // Get the children of the old hotkey for this subnet
+        let my_children: Vec<(u64, T::AccountId)> = ChildKeys::<T>::get(old_hotkey, netuid);
+        // Remove the old hotkey's child entries
+        ChildKeys::<T>::remove(old_hotkey, netuid);
+        // Insert the same child entries for the new hotkey
+        ChildKeys::<T>::insert(new_hotkey, netuid, my_children.clone());
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
+        for (_, child_key_i) in my_children {
+            // For each child, update their parent list
+            let mut child_parents: Vec<(u64, T::AccountId)> =
+                ParentKeys::<T>::get(child_key_i.clone(), netuid);
+            for parent in child_parents.iter_mut() {
+                // If the parent is the old hotkey, replace it with the new hotkey
+                if parent.1 == *old_hotkey {
+                    parent.1 = new_hotkey.clone();
                 }
-                // Update the child's parent list
-                ParentKeys::<T>::insert(child_key_i, netuid, child_parents);
-                weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
             }
+            // Update the child's parent list
+            ParentKeys::<T>::insert(child_key_i, netuid, child_parents);
+            weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
         }
+        // }
 
         // 13. Swap ParentKeys.
         // ParentKeys( child, netuid ) --> Vec<(proportion,parent)> -- the parent keys of the child.
-        for netuid in Self::get_all_subnet_netuids() {
-            // Get the parents of the old hotkey for this subnet
-            let parents: Vec<(u64, T::AccountId)> = ParentKeys::<T>::get(old_hotkey, netuid);
-            // Remove the old hotkey's parent entries
-            ParentKeys::<T>::remove(old_hotkey, netuid);
-            // Insert the same parent entries for the new hotkey
-            ParentKeys::<T>::insert(new_hotkey, netuid, parents.clone());
-            weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
-            for (_, parent_key_i) in parents {
-                // For each parent, update their children list
-                let mut parent_children: Vec<(u64, T::AccountId)> =
-                    ChildKeys::<T>::get(parent_key_i.clone(), netuid);
-                for child in parent_children.iter_mut() {
-                    // If the child is the old hotkey, replace it with the new hotkey
-                    if child.1 == *old_hotkey {
-                        child.1 = new_hotkey.clone();
-                    }
+        // for netuid in Self::get_all_subnet_netuids() {
+        // Get the parents of the old hotkey for this subnet
+        let parents: Vec<(u64, T::AccountId)> = ParentKeys::<T>::get(old_hotkey, netuid);
+        // Remove the old hotkey's parent entries
+        ParentKeys::<T>::remove(old_hotkey, netuid);
+        // Insert the same parent entries for the new hotkey
+        ParentKeys::<T>::insert(new_hotkey, netuid, parents.clone());
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
+        for (_, parent_key_i) in parents {
+            // For each parent, update their children list
+            let mut parent_children: Vec<(u64, T::AccountId)> =
+                ChildKeys::<T>::get(parent_key_i.clone(), netuid);
+            for child in parent_children.iter_mut() {
+                // If the child is the old hotkey, replace it with the new hotkey
+                if child.1 == *old_hotkey {
+                    child.1 = new_hotkey.clone();
                 }
-                // Update the parent's children list
-                ChildKeys::<T>::insert(parent_key_i, netuid, parent_children);
-                weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
             }
+            // Update the parent's children list
+            ChildKeys::<T>::insert(parent_key_i, netuid, parent_children);
+            weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
         }
 
         // 14. Swap PendingChildKeys.
         // PendingChildKeys( netuid, parent ) --> Vec<(proportion,child), cool_down_block>
-        for netuid in Self::get_all_subnet_netuids() {
+        // for netuid in Self::get_all_subnet_netuids() {
+        weight.saturating_accrue(T::DbWeight::get().reads(1));
+        if PendingChildKeys::<T>::contains_key(netuid, old_hotkey) {
+            let (children, cool_down_block) = PendingChildKeys::<T>::get(netuid, old_hotkey);
+            PendingChildKeys::<T>::remove(netuid, old_hotkey);
+            PendingChildKeys::<T>::insert(netuid, new_hotkey, (children, cool_down_block));
+            weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
+        }
+
+        // Also check for others with our hotkey as a child
+        for (hotkey, (children, cool_down_block)) in PendingChildKeys::<T>::iter_prefix(netuid) {
             weight.saturating_accrue(T::DbWeight::get().reads(1));
-            if PendingChildKeys::<T>::contains_key(netuid, old_hotkey) {
-                let (children, cool_down_block) = PendingChildKeys::<T>::get(netuid, old_hotkey);
-                PendingChildKeys::<T>::remove(netuid, old_hotkey);
-                PendingChildKeys::<T>::insert(netuid, new_hotkey, (children, cool_down_block));
-                weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
-            }
 
-            // Also check for others with our hotkey as a child
-            for (hotkey, (children, cool_down_block)) in PendingChildKeys::<T>::iter_prefix(netuid)
+            if let Some(potential_idx) =
+                children.iter().position(|(_, child)| *child == *old_hotkey)
             {
-                weight.saturating_accrue(T::DbWeight::get().reads(1));
-
-                if let Some(potential_idx) =
-                    children.iter().position(|(_, child)| *child == *old_hotkey)
-                {
-                    let mut new_children = children.clone();
-                    let entry_to_remove = new_children.remove(potential_idx);
-                    new_children.push((entry_to_remove.0, new_hotkey.clone())); // Keep the proportion.
-
-                    PendingChildKeys::<T>::remove(netuid, hotkey.clone());
-                    PendingChildKeys::<T>::insert(netuid, hotkey, (new_children, cool_down_block));
-                    weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
-                }
+                let mut new_children = children.clone();
+                let entry_to_remove = new_children.remove(potential_idx);
+                new_children.push((entry_to_remove.0, new_hotkey.clone())); // Keep the proportion.
+
+                PendingChildKeys::<T>::remove(netuid, hotkey.clone());
+                PendingChildKeys::<T>::insert(netuid, hotkey, (new_children, cool_down_block));
+                weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
             }
         }
 
         // 15. Swap SubnetOwnerHotkey
         // SubnetOwnerHotkey( netuid ) --> hotkey -- the hotkey that is the owner of the subnet.
-        for netuid in Self::get_all_subnet_netuids() {
-            if let Ok(old_subnet_owner_hotkey) = SubnetOwnerHotkey::<T>::try_get(netuid) {
-                weight.saturating_accrue(T::DbWeight::get().reads(1));
-                if old_subnet_owner_hotkey == *old_hotkey {
-                    SubnetOwnerHotkey::<T>::insert(netuid, new_hotkey);
-                    weight.saturating_accrue(T::DbWeight::get().writes(1));
-                }
+        // for netuid in Self::get_all_subnet_netuids() {
+        if let Ok(old_subnet_owner_hotkey) = SubnetOwnerHotkey::<T>::try_get(netuid) {
+            weight.saturating_accrue(T::DbWeight::get().reads(1));
+            if old_subnet_owner_hotkey == *old_hotkey {
+                SubnetOwnerHotkey::<T>::insert(netuid, new_hotkey);
+                weight.saturating_accrue(T::DbWeight::get().writes(1));
             }
         }
 
         // 16. Swap dividend records
-        TotalHotkeyAlphaLastEpoch::<T>::iter_prefix(old_hotkey)
-            .drain()
-            .for_each(|(netuid, old_alpha)| {
-                // 16.1 Swap TotalHotkeyAlphaLastEpoch
-                let new_total_hotkey_alpha =
-                    TotalHotkeyAlphaLastEpoch::<T>::get(new_hotkey, netuid);
-                TotalHotkeyAlphaLastEpoch::<T>::insert(
-                    new_hotkey,
-                    netuid,
-                    old_alpha.saturating_add(new_total_hotkey_alpha),
-                );
-                weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 2));
-
-                // 16.2 Swap AlphaDividendsPerSubnet
-                let old_hotkey_alpha_dividends =
-                    AlphaDividendsPerSubnet::<T>::get(netuid, old_hotkey);
-                let new_hotkey_alpha_dividends =
-                    AlphaDividendsPerSubnet::<T>::get(netuid, new_hotkey);
-                AlphaDividendsPerSubnet::<T>::remove(netuid, old_hotkey);
-                AlphaDividendsPerSubnet::<T>::insert(
-                    netuid,
-                    new_hotkey,
-                    old_hotkey_alpha_dividends.saturating_add(new_hotkey_alpha_dividends),
-                );
-                weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 2));
-
-                // 16.3 Swap TaoDividendsPerSubnet
-                let old_hotkey_tao_dividends = TaoDividendsPerSubnet::<T>::get(netuid, old_hotkey);
-                let new_hotkey_tao_dividends = TaoDividendsPerSubnet::<T>::get(netuid, new_hotkey);
-                TaoDividendsPerSubnet::<T>::remove(netuid, old_hotkey);
-                TaoDividendsPerSubnet::<T>::insert(
-                    netuid,
-                    new_hotkey,
-                    old_hotkey_tao_dividends.saturating_add(new_hotkey_tao_dividends),
-                );
-                weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 2));
-            });
-
-        // Return successful after swapping all the relevant terms.
-        Ok(())
-    }
-
-    pub fn swap_senate_member(
-        old_hotkey: &T::AccountId,
-        new_hotkey: &T::AccountId,
-        weight: &mut Weight,
-    ) -> DispatchResult {
-        weight.saturating_accrue(T::DbWeight::get().reads(1));
-        if T::SenateMembers::is_member(old_hotkey) {
-            T::SenateMembers::swap_member(old_hotkey, new_hotkey).map_err(|e| e.error)?;
-            weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
-        }
-        Ok(())
-    }
-
-    fn swap_hotkey_on_subnet(
-        coldkey: &T::AccountId,
-        old_hotkey: &T::AccountId,
-        new_hotkey: &T::AccountId,
-        netuid: u16,
-        init_weight: Weight,
-    ) -> DispatchResultWithPostInfo {
-        let mut weight = init_weight;
-
-        // Ensure the hotkey not registered on the network before.
-
-        ensure!(
-            !Self::is_hotkey_registered_on_specific_network(new_hotkey, netuid),
-            Error::<T>::HotKeyAlreadyRegisteredInSubNet
+        // 16.1 Swap TotalHotkeyAlphaLastEpoch
+        let old_alpha = TotalHotkeyAlphaLastEpoch::<T>::take(old_hotkey, netuid);
+        let new_total_hotkey_alpha = TotalHotkeyAlphaLastEpoch::<T>::get(new_hotkey, netuid);
+        TotalHotkeyAlphaLastEpoch::<T>::insert(
+            new_hotkey,
+            netuid,
+            old_alpha.saturating_add(new_total_hotkey_alpha),
         );
-        weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 0));
-
-        // 10. Get the cost for swapping the key
-        let swap_cost = T::KeySwapOneSubnetCost::get();
-        log::debug!("Swap cost in subnet {:?}: {:?}", netuid, swap_cost);
-
-        // 11. Ensure the coldkey has enough balance to pay for the swap
-        ensure!(
-            Self::can_remove_balance_from_coldkey_account(&coldkey, swap_cost),
-            Error::<T>::NotEnoughBalanceToPaySwapHotKey
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 2));
+
+        // 16.2 Swap AlphaDividendsPerSubnet
+        let old_hotkey_alpha_dividends = AlphaDividendsPerSubnet::<T>::get(netuid, old_hotkey);
+        let new_hotkey_alpha_dividends = AlphaDividendsPerSubnet::<T>::get(netuid, new_hotkey);
+        AlphaDividendsPerSubnet::<T>::remove(netuid, old_hotkey);
+        AlphaDividendsPerSubnet::<T>::insert(
+            netuid,
+            new_hotkey,
+            old_hotkey_alpha_dividends.saturating_add(new_hotkey_alpha_dividends),
         );
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 2));
+
+        // 16.3 Swap TaoDividendsPerSubnet
+        let old_hotkey_tao_dividends = TaoDividendsPerSubnet::<T>::get(netuid, old_hotkey);
+        let new_hotkey_tao_dividends = TaoDividendsPerSubnet::<T>::get(netuid, new_hotkey);
+        TaoDividendsPerSubnet::<T>::remove(netuid, old_hotkey);
+        TaoDividendsPerSubnet::<T>::insert(
+            netuid,
+            new_hotkey,
+            old_hotkey_tao_dividends.saturating_add(new_hotkey_tao_dividends),
+        );
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 2));
 
-        // 12. Remove the swap cost from the coldkey's account
-        let actual_burn_amount = Self::remove_balance_from_coldkey_account(&coldkey, swap_cost)?;
-
-        // 13. Burn the tokens
-        Self::burn_tokens(actual_burn_amount);
-
-        // 14. Perform the hotkey swap
-        let _ = Self::perform_hotkey_swap(old_hotkey, new_hotkey, &coldkey, &mut weight);
-        let block: u64 = Self::get_current_block_as_u64();
-        // 15. Update the last transaction block for the coldkey
-        Self::set_last_tx_block(&coldkey, block);
-        weight.saturating_accrue(T::DbWeight::get().writes(1));
-
-        // 16. Emit an event for the hotkey swap
-        Self::deposit_event(Event::HotkeySwapped {
-            coldkey: coldkey.clone(),
-            old_hotkey: old_hotkey.clone(),
-            new_hotkey: new_hotkey.clone(),
-        });
-
-        Ok(Some(weight).into())
+        // Return successful after swapping all the relevant terms.
+        // Ok(())
     }
 }
diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index 55c2d957f8..30b3866615 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -1073,6 +1073,7 @@ parameter_types! {
     } else {
         7 * 24 * 60 * 60 / 12 // 7 days
     };
+    pub const SubtensorInitialKeySwapOnSubnetCost: u64 = 1_000_000; // 0.001 TAO
 }
 
 impl pallet_subtensor::Config for Runtime {
@@ -1138,6 +1139,7 @@ impl pallet_subtensor::Config for Runtime {
     type InitialDissolveNetworkScheduleDuration = InitialDissolveNetworkScheduleDuration;
     type InitialEmaPriceHalvingPeriod = InitialEmaPriceHalvingPeriod;
     type DurationOfStartCall = DurationOfStartCall;
+    type KeySwapOneSubnetCost = SubtensorInitialKeySwapOnSubnetCost;
 }
 
 use sp_runtime::BoundedVec;

From 5240483ba9b7bfabb89cad16c3fe94b4dcdfff92 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Mon, 28 Apr 2025 21:45:35 +0800
Subject: [PATCH 081/418] commit Cargo.lock

---
 pallets/subtensor/src/swap/swap_hotkey.rs | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

diff --git a/pallets/subtensor/src/swap/swap_hotkey.rs b/pallets/subtensor/src/swap/swap_hotkey.rs
index 451dd86b1a..e1d9892ea2 100644
--- a/pallets/subtensor/src/swap/swap_hotkey.rs
+++ b/pallets/subtensor/src/swap/swap_hotkey.rs
@@ -39,44 +39,46 @@ impl<T: Config> Pallet<T> {
             Error::<T>::NonAssociatedColdKey
         );
 
-        // 2. Initialize the weight for this operation
+        // 3. Initialize the weight for this operation
         let mut weight = T::DbWeight::get().reads(2);
 
-        // 3. Ensure the new hotkey is different from the old one
+        // 4. Ensure the new hotkey is different from the old one
         ensure!(old_hotkey != new_hotkey, Error::<T>::NewHotKeyIsSameWithOld);
 
         // 5. Update the weight for the checks above
         weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 0));
 
-        // 7. Get the current block number
+        // 6. Get the current block number
         let block: u64 = Self::get_current_block_as_u64();
 
-        // 8. Ensure the transaction rate limit is not exceeded
+        // 7. Ensure the transaction rate limit is not exceeded
         ensure!(
             !Self::exceeds_tx_rate_limit(Self::get_last_tx_block(&coldkey), block),
             Error::<T>::HotKeySetTxRateLimitExceeded
         );
 
-        // fork for swap hotkey on a specific subnet case after do the common check
+        // 8. fork for swap hotkey on a specific subnet case after do the common check
         if let Some(netuid) = netuid {
             return Self::swap_hotkey_on_subnet(&coldkey, old_hotkey, new_hotkey, netuid, weight);
         };
 
-        // 5. Swap LastTxBlock
+        // following update just for swap hotkey in all subnets case
+
+        // 9. Swap LastTxBlock
         // LastTxBlock( hotkey ) --> u64 -- the last transaction block for the hotkey.
         let last_tx_block: u64 = LastTxBlock::<T>::get(old_hotkey);
         LastTxBlock::<T>::remove(old_hotkey);
         LastTxBlock::<T>::insert(new_hotkey, last_tx_block);
         weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
 
-        // 6. Swap LastTxBlockDelegateTake
+        // 10. Swap LastTxBlockDelegateTake
         // LastTxBlockDelegateTake( hotkey ) --> u64 -- the last transaction block for the hotkey delegate take.
         let last_tx_block_delegate_take: u64 = LastTxBlockDelegateTake::<T>::get(old_hotkey);
         LastTxBlockDelegateTake::<T>::remove(old_hotkey);
         LastTxBlockDelegateTake::<T>::insert(new_hotkey, last_tx_block_delegate_take);
         weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
 
-        // 7. Swap LastTxBlockChildKeyTake
+        // 11. Swap LastTxBlockChildKeyTake
         // LastTxBlockChildKeyTake( hotkey ) --> u64 -- the last transaction block for the hotkey child key take.
         let last_tx_block_child_key_take: u64 = LastTxBlockChildKeyTake::<T>::get(old_hotkey);
         LastTxBlockChildKeyTake::<T>::remove(old_hotkey);

From 3a991831125dff18aad8a8c0906e568d73977dc8 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Mon, 28 Apr 2025 22:12:55 +0800
Subject: [PATCH 082/418] commit Cargo.lock

---
 pallets/subtensor/src/benchmarks.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pallets/subtensor/src/benchmarks.rs b/pallets/subtensor/src/benchmarks.rs
index b5ff1197e0..bbea816fff 100644
--- a/pallets/subtensor/src/benchmarks.rs
+++ b/pallets/subtensor/src/benchmarks.rs
@@ -1270,7 +1270,7 @@ benchmark_swap_hotkey {
   Owner::<T>::insert(&old, &coldkey);
   let cost = Subtensor::<T>::get_key_swap_cost();
   Subtensor::<T>::add_balance_to_coldkey_account(&coldkey, cost);
-}: swap_hotkey(RawOrigin::Signed(coldkey.clone()), old.clone(), new.clone())
+}: swap_hotkey(RawOrigin::Signed(coldkey.clone()), old.clone(), new.clone(), None)
 
 benchmark_try_associate_hotkey {
   let coldkey: T::AccountId = whitelisted_caller::<AccountIdOf<T>>();

From 8438f1267ad4f266372d7f557e1f33080815d99e Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Mon, 28 Apr 2025 22:20:32 +0800
Subject: [PATCH 083/418] fix compilation

---
 pallets/subtensor/src/swap/swap_hotkey.rs  |   6 +-
 pallets/subtensor/src/tests/swap_hotkey.rs | 126 +++++++++++++++------
 2 files changed, 96 insertions(+), 36 deletions(-)

diff --git a/pallets/subtensor/src/swap/swap_hotkey.rs b/pallets/subtensor/src/swap/swap_hotkey.rs
index e1d9892ea2..a9fc3c23bb 100644
--- a/pallets/subtensor/src/swap/swap_hotkey.rs
+++ b/pallets/subtensor/src/swap/swap_hotkey.rs
@@ -282,12 +282,12 @@ impl<T: Config> Pallet<T> {
 
         // 11. Ensure the coldkey has enough balance to pay for the swap
         ensure!(
-            Self::can_remove_balance_from_coldkey_account(&coldkey, swap_cost),
+            Self::can_remove_balance_from_coldkey_account(coldkey, swap_cost),
             Error::<T>::NotEnoughBalanceToPaySwapHotKey
         );
 
         // 12. Remove the swap cost from the coldkey's account
-        let actual_burn_amount = Self::remove_balance_from_coldkey_account(&coldkey, swap_cost)?;
+        let actual_burn_amount = Self::remove_balance_from_coldkey_account(coldkey, swap_cost)?;
 
         // 13. Burn the tokens
         Self::burn_tokens(actual_burn_amount);
@@ -315,7 +315,7 @@ impl<T: Config> Pallet<T> {
 
         let block: u64 = Self::get_current_block_as_u64();
         // 15. Update the last transaction block for the coldkey
-        Self::set_last_tx_block(&coldkey, block);
+        Self::set_last_tx_block(coldkey, block);
         weight.saturating_accrue(T::DbWeight::get().writes(1));
 
         // 16. Emit an event for the hotkey swap
diff --git a/pallets/subtensor/src/tests/swap_hotkey.rs b/pallets/subtensor/src/tests/swap_hotkey.rs
index a82972c2f7..41464f35ed 100644
--- a/pallets/subtensor/src/tests/swap_hotkey.rs
+++ b/pallets/subtensor/src/tests/swap_hotkey.rs
@@ -22,7 +22,7 @@ fn test_swap_owner() {
         let mut weight = Weight::zero();
 
         Owner::<Test>::insert(old_hotkey, coldkey);
-        assert_ok!(SubtensorModule::perform_hotkey_swap(
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
             &old_hotkey,
             &new_hotkey,
             &coldkey,
@@ -44,7 +44,7 @@ fn test_swap_owned_hotkeys() {
         let mut weight = Weight::zero();
 
         OwnedHotkeys::<Test>::insert(coldkey, vec![old_hotkey]);
-        assert_ok!(SubtensorModule::perform_hotkey_swap(
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
             &old_hotkey,
             &new_hotkey,
             &coldkey,
@@ -95,7 +95,7 @@ fn test_swap_total_hotkey_stake() {
         );
 
         // Swap hotkey
-        assert_ok!(SubtensorModule::perform_hotkey_swap(
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
             &old_hotkey,
             &new_hotkey,
             &coldkey,
@@ -127,7 +127,7 @@ fn test_swap_senate_members() {
 
         // Assuming there's a way to add a member to the senate
         // SenateMembers::add_member(&old_hotkey);
-        assert_ok!(SubtensorModule::perform_hotkey_swap(
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
             &old_hotkey,
             &new_hotkey,
             &coldkey,
@@ -150,7 +150,7 @@ fn test_swap_delegates() {
         let mut weight = Weight::zero();
 
         Delegates::<Test>::insert(old_hotkey, 100);
-        assert_ok!(SubtensorModule::perform_hotkey_swap(
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
             &old_hotkey,
             &new_hotkey,
             &coldkey,
@@ -174,7 +174,7 @@ fn test_swap_subnet_membership() {
 
         add_network(netuid, 1, 1);
         IsNetworkMember::<Test>::insert(old_hotkey, netuid, true);
-        assert_ok!(SubtensorModule::perform_hotkey_swap(
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
             &old_hotkey,
             &new_hotkey,
             &coldkey,
@@ -202,7 +202,7 @@ fn test_swap_uids_and_keys() {
         Uids::<Test>::insert(netuid, old_hotkey, uid);
         Keys::<Test>::insert(netuid, uid, old_hotkey);
 
-        assert_ok!(SubtensorModule::perform_hotkey_swap(
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
             &old_hotkey,
             &new_hotkey,
             &coldkey,
@@ -230,7 +230,7 @@ fn test_swap_prometheus() {
         IsNetworkMember::<Test>::insert(old_hotkey, netuid, true);
         Prometheus::<Test>::insert(netuid, old_hotkey, prometheus_info.clone());
 
-        assert_ok!(SubtensorModule::perform_hotkey_swap(
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
             &old_hotkey,
             &new_hotkey,
             &coldkey,
@@ -260,7 +260,7 @@ fn test_swap_axons() {
         IsNetworkMember::<Test>::insert(old_hotkey, netuid, true);
         Axons::<Test>::insert(netuid, old_hotkey, axon_info.clone());
 
-        assert_ok!(SubtensorModule::perform_hotkey_swap(
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
             &old_hotkey,
             &new_hotkey,
             &coldkey,
@@ -287,7 +287,7 @@ fn test_swap_certificates() {
         IsNetworkMember::<Test>::insert(old_hotkey, netuid, true);
         NeuronCertificates::<Test>::insert(netuid, old_hotkey, certificate.clone());
 
-        assert_ok!(SubtensorModule::perform_hotkey_swap(
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
             &old_hotkey,
             &new_hotkey,
             &coldkey,
@@ -320,7 +320,7 @@ fn test_swap_weight_commits() {
         IsNetworkMember::<Test>::insert(old_hotkey, netuid, true);
         WeightCommits::<Test>::insert(netuid, old_hotkey, weight_commits.clone());
 
-        assert_ok!(SubtensorModule::perform_hotkey_swap(
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
             &old_hotkey,
             &new_hotkey,
             &coldkey,
@@ -354,7 +354,7 @@ fn test_swap_loaded_emission() {
             vec![(old_hotkey, server_emission, validator_emission)],
         );
 
-        assert_ok!(SubtensorModule::perform_hotkey_swap(
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
             &old_hotkey,
             &new_hotkey,
             &coldkey,
@@ -382,7 +382,7 @@ fn test_swap_staking_hotkeys() {
         StakingHotkeys::<Test>::insert(coldkey, vec![old_hotkey]);
         Alpha::<Test>::insert((old_hotkey, coldkey, netuid), U64F64::from_num(100));
 
-        assert_ok!(SubtensorModule::perform_hotkey_swap(
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
             &old_hotkey,
             &new_hotkey,
             &coldkey,
@@ -437,7 +437,7 @@ fn test_swap_hotkey_with_multiple_coldkeys() {
         let stake1_before = SubtensorModule::get_total_stake_for_coldkey(&coldkey1);
         let stake2_before = SubtensorModule::get_total_stake_for_coldkey(&coldkey2);
 
-        assert_ok!(SubtensorModule::perform_hotkey_swap(
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
             &old_hotkey,
             &new_hotkey,
             &coldkey1,
@@ -473,7 +473,7 @@ fn test_swap_hotkey_with_multiple_subnets() {
         IsNetworkMember::<Test>::insert(old_hotkey, netuid1, true);
         IsNetworkMember::<Test>::insert(old_hotkey, netuid2, true);
 
-        assert_ok!(SubtensorModule::perform_hotkey_swap(
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
             &old_hotkey,
             &new_hotkey,
             &coldkey,
@@ -529,7 +529,7 @@ fn test_swap_staking_hotkeys_multiple_coldkeys() {
             stake
         ));
 
-        assert_ok!(SubtensorModule::perform_hotkey_swap(
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
             &old_hotkey,
             &new_hotkey,
             &coldkey1,
@@ -564,7 +564,7 @@ fn test_swap_hotkey_with_no_stake() {
         // Set up initial state with no stake
         Owner::<Test>::insert(old_hotkey, coldkey);
 
-        assert_ok!(SubtensorModule::perform_hotkey_swap(
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
             &old_hotkey,
             &new_hotkey,
             &coldkey,
@@ -635,7 +635,7 @@ fn test_swap_hotkey_with_multiple_coldkeys_and_subnets() {
         let total_hk_stake = SubtensorModule::get_total_stake_for_hotkey(&old_hotkey);
         assert!(total_hk_stake > 0);
 
-        assert_ok!(SubtensorModule::perform_hotkey_swap(
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
             &old_hotkey,
             &new_hotkey,
             &coldkey1,
@@ -807,7 +807,12 @@ fn test_swap_owner_success() {
         Owner::<Test>::insert(old_hotkey, coldkey);
 
         // Perform the swap
-        SubtensorModule::perform_hotkey_swap(&old_hotkey, &new_hotkey, &coldkey, &mut weight);
+        SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight,
+        );
 
         // Verify the swap
         assert_eq!(Owner::<Test>::get(new_hotkey), coldkey);
@@ -828,7 +833,12 @@ fn test_swap_owner_old_hotkey_not_exist() {
         assert!(!Owner::<Test>::contains_key(old_hotkey));
 
         // Perform the swap
-        SubtensorModule::perform_hotkey_swap(&old_hotkey, &new_hotkey, &coldkey, &mut weight);
+        SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight,
+        );
 
         // Verify the swap
         assert_eq!(Owner::<Test>::get(new_hotkey), coldkey);
@@ -851,7 +861,12 @@ fn test_swap_owner_new_hotkey_already_exists() {
         Owner::<Test>::insert(new_hotkey, another_coldkey);
 
         // Perform the swap
-        SubtensorModule::perform_hotkey_swap(&old_hotkey, &new_hotkey, &coldkey, &mut weight);
+        SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight,
+        );
 
         // Verify the swap
         assert_eq!(Owner::<Test>::get(new_hotkey), coldkey);
@@ -873,7 +888,12 @@ fn test_swap_delegates_success() {
         Delegates::<Test>::insert(old_hotkey, delegate_take);
 
         // Perform the swap
-        SubtensorModule::perform_hotkey_swap(&old_hotkey, &new_hotkey, &coldkey, &mut weight);
+        SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight,
+        );
 
         // Verify the swap
         assert_eq!(Delegates::<Test>::get(new_hotkey), delegate_take);
@@ -904,7 +924,12 @@ fn test_swap_stake_success() {
         TaoDividendsPerSubnet::<Test>::insert(netuid, old_hotkey, amount);
 
         // Perform the swap
-        SubtensorModule::perform_hotkey_swap(&old_hotkey, &new_hotkey, &coldkey, &mut weight);
+        SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight,
+        );
 
         // Verify the swap
         assert_eq!(TotalHotkeyAlpha::<Test>::get(old_hotkey, netuid), 0);
@@ -964,7 +989,12 @@ fn test_swap_stake_old_hotkey_not_exist() {
         assert!(Alpha::<Test>::contains_key((old_hotkey, coldkey, netuid)));
 
         // Perform the swap
-        SubtensorModule::perform_hotkey_swap(&old_hotkey, &new_hotkey, &coldkey, &mut weight);
+        SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight,
+        );
 
         // Verify that new_hotkey has the stake and old_hotkey does not
         assert!(Alpha::<Test>::contains_key((new_hotkey, coldkey, netuid)));
@@ -986,7 +1016,7 @@ fn test_swap_stake_old_hotkey_not_exist() {
 //         TotalHotkeyColdkeyStakesThisInterval::<Test>::insert(old_hotkey, coldkey, stake);
 
 //         // Perform the swap
-//         SubtensorModule::perform_hotkey_swap(&old_hotkey, &new_hotkey, &coldkey, &mut weight);
+//         SubtensorModule::perform_hotkey_swap_on_all_subnets(&old_hotkey, &new_hotkey, &coldkey, &mut weight);
 
 //         // Verify the swap
 //         assert_eq!(
@@ -1087,7 +1117,12 @@ fn test_swap_child_keys() {
         ChildKeys::<Test>::insert(old_hotkey, netuid, children.clone());
 
         // Perform the swap
-        SubtensorModule::perform_hotkey_swap(&old_hotkey, &new_hotkey, &coldkey, &mut weight);
+        SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight,
+        );
 
         // Verify the swap
         assert_eq!(ChildKeys::<Test>::get(new_hotkey, netuid), children);
@@ -1115,7 +1150,12 @@ fn test_swap_parent_keys() {
         ChildKeys::<Test>::insert(U256::from(5), netuid, vec![(200u64, old_hotkey)]);
 
         // Perform the swap
-        SubtensorModule::perform_hotkey_swap(&old_hotkey, &new_hotkey, &coldkey, &mut weight);
+        SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight,
+        );
 
         // Verify ParentKeys swap
         assert_eq!(ParentKeys::<Test>::get(new_hotkey, netuid), parents);
@@ -1154,7 +1194,12 @@ fn test_swap_multiple_subnets() {
         ChildKeys::<Test>::insert(old_hotkey, netuid2, children2.clone());
 
         // Perform the swap
-        SubtensorModule::perform_hotkey_swap(&old_hotkey, &new_hotkey, &coldkey, &mut weight);
+        SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight,
+        );
 
         // Verify the swap for both subnets
         assert_eq!(ChildKeys::<Test>::get(new_hotkey, netuid1), children1);
@@ -1199,7 +1244,12 @@ fn test_swap_complex_parent_child_structure() {
         );
 
         // Perform the swap
-        SubtensorModule::perform_hotkey_swap(&old_hotkey, &new_hotkey, &coldkey, &mut weight);
+        SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight,
+        );
 
         // Verify ParentKeys swap
         assert_eq!(
@@ -1259,7 +1309,7 @@ fn test_swap_parent_hotkey_childkey_maps() {
 
         // Swap
         let mut weight = Weight::zero();
-        assert_ok!(SubtensorModule::perform_hotkey_swap(
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
             &parent_old,
             &parent_new,
             &coldkey,
@@ -1314,7 +1364,7 @@ fn test_swap_child_hotkey_childkey_maps() {
 
         // Swap
         let mut weight = Weight::zero();
-        assert_ok!(SubtensorModule::perform_hotkey_swap(
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
             &child_old,
             &child_new,
             &coldkey,
@@ -1352,7 +1402,12 @@ fn test_swap_hotkey_is_sn_owner_hotkey() {
         assert_eq!(SubnetOwnerHotkey::<Test>::get(netuid), old_hotkey);
 
         // Perform the swap
-        SubtensorModule::perform_hotkey_swap(&old_hotkey, &new_hotkey, &coldkey, &mut weight);
+        SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight,
+        );
 
         // Check for SubnetOwnerHotkey
         assert_eq!(SubnetOwnerHotkey::<Test>::get(netuid), new_hotkey);
@@ -1380,7 +1435,12 @@ fn test_swap_hotkey_swap_rate_limits() {
         LastTxBlockChildKeyTake::<Test>::insert(old_hotkey, child_key_take_block);
 
         // Perform the swap
-        SubtensorModule::perform_hotkey_swap(&old_hotkey, &new_hotkey, &coldkey, &mut weight);
+        SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight,
+        );
 
         // Check for new hotkey
         assert_eq!(LastTxBlock::<Test>::get(new_hotkey), last_tx_block);

From e3025577f776254340a32a8bdaa09bf86f1441ce Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Mon, 28 Apr 2025 22:57:29 +0800
Subject: [PATCH 084/418] commit Cargo.lock

---
 pallets/subtensor/src/tests/mock.rs        |  3 +++
 pallets/subtensor/src/tests/swap_hotkey.rs | 27 ++++++++++++++--------
 2 files changed, 21 insertions(+), 9 deletions(-)

diff --git a/pallets/subtensor/src/tests/mock.rs b/pallets/subtensor/src/tests/mock.rs
index a8ab96be8c..d934d33725 100644
--- a/pallets/subtensor/src/tests/mock.rs
+++ b/pallets/subtensor/src/tests/mock.rs
@@ -186,6 +186,8 @@ parameter_types! {
     pub const InitialTaoWeight: u64 = 0; // 100% global weight.
     pub const InitialEmaPriceHalvingPeriod: u64 = 201_600_u64; // 4 weeks
     pub const DurationOfStartCall: u64 =  7 * 24 * 60 * 60 / 12; // Default as 7 days
+    pub const InitialKeySwapOnSubnetCost: u64 = 10_000_000;
+
 }
 
 // Configure collective pallet for council
@@ -410,6 +412,7 @@ impl crate::Config for Test {
     type InitialTaoWeight = InitialTaoWeight;
     type InitialEmaPriceHalvingPeriod = InitialEmaPriceHalvingPeriod;
     type DurationOfStartCall = DurationOfStartCall;
+    type KeySwapOneSubnetCost = InitialKeySwapOnSubnetCost;
 }
 
 pub struct OriginPrivilegeCmp;
diff --git a/pallets/subtensor/src/tests/swap_hotkey.rs b/pallets/subtensor/src/tests/swap_hotkey.rs
index 41464f35ed..be5e8b6b17 100644
--- a/pallets/subtensor/src/tests/swap_hotkey.rs
+++ b/pallets/subtensor/src/tests/swap_hotkey.rs
@@ -742,7 +742,8 @@ fn test_swap_hotkey_tx_rate_limit_exceeded() {
         assert_ok!(SubtensorModule::do_swap_hotkey(
             <<Test as Config>::RuntimeOrigin>::signed(coldkey),
             &old_hotkey,
-            &new_hotkey_1
+            &new_hotkey_1,
+            None
         ));
 
         // Attempt to perform another swap immediately, which should fail due to rate limit
@@ -750,7 +751,8 @@ fn test_swap_hotkey_tx_rate_limit_exceeded() {
             SubtensorModule::do_swap_hotkey(
                 <<Test as Config>::RuntimeOrigin>::signed(coldkey),
                 &new_hotkey_1,
-                &new_hotkey_2
+                &new_hotkey_2,
+                None
             ),
             Error::<Test>::HotKeySetTxRateLimitExceeded
         );
@@ -760,7 +762,8 @@ fn test_swap_hotkey_tx_rate_limit_exceeded() {
         assert_ok!(SubtensorModule::do_swap_hotkey(
             <<Test as Config>::RuntimeOrigin>::signed(coldkey),
             &new_hotkey_1,
-            &new_hotkey_2
+            &new_hotkey_2,
+            None
         ));
     });
 }
@@ -787,7 +790,8 @@ fn test_do_swap_hotkey_err_not_owner() {
             SubtensorModule::do_swap_hotkey(
                 <<Test as Config>::RuntimeOrigin>::signed(not_owner_coldkey),
                 &old_hotkey,
-                &new_hotkey
+                &new_hotkey,
+                None
             ),
             Error::<Test>::NonAssociatedColdKey
         );
@@ -1049,7 +1053,8 @@ fn test_swap_hotkey_error_cases() {
             SubtensorModule::do_swap_hotkey(
                 RuntimeOrigin::signed(coldkey),
                 &old_hotkey,
-                &new_hotkey
+                &new_hotkey,
+                None
             ),
             Error::<Test>::NotEnoughBalanceToPaySwapHotKey
         );
@@ -1062,7 +1067,8 @@ fn test_swap_hotkey_error_cases() {
             SubtensorModule::do_swap_hotkey(
                 RuntimeOrigin::signed(coldkey),
                 &old_hotkey,
-                &old_hotkey
+                &old_hotkey,
+                None
             ),
             Error::<Test>::NewHotKeyIsSameWithOld
         );
@@ -1073,7 +1079,8 @@ fn test_swap_hotkey_error_cases() {
             SubtensorModule::do_swap_hotkey(
                 RuntimeOrigin::signed(coldkey),
                 &old_hotkey,
-                &new_hotkey
+                &new_hotkey,
+                None
             ),
             Error::<Test>::HotKeyAlreadyRegisteredInSubNet
         );
@@ -1084,7 +1091,8 @@ fn test_swap_hotkey_error_cases() {
             SubtensorModule::do_swap_hotkey(
                 RuntimeOrigin::signed(wrong_coldkey),
                 &old_hotkey,
-                &new_hotkey
+                &new_hotkey,
+                None
             ),
             Error::<Test>::NonAssociatedColdKey
         );
@@ -1093,7 +1101,8 @@ fn test_swap_hotkey_error_cases() {
         assert_ok!(SubtensorModule::do_swap_hotkey(
             RuntimeOrigin::signed(coldkey),
             &old_hotkey,
-            &new_hotkey
+            &new_hotkey,
+            None
         ));
 
         // Check balance after swap

From 8b0be6dcb15b8d0df8d569edcaa5e3be4043ced6 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Mon, 28 Apr 2025 22:59:53 +0800
Subject: [PATCH 085/418] commit Cargo.lock

---
 pallets/admin-utils/src/tests/mock.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/pallets/admin-utils/src/tests/mock.rs b/pallets/admin-utils/src/tests/mock.rs
index 99c11b7165..fc80f77c35 100644
--- a/pallets/admin-utils/src/tests/mock.rs
+++ b/pallets/admin-utils/src/tests/mock.rs
@@ -136,6 +136,7 @@ parameter_types! {
     pub const InitialTaoWeight: u64 = u64::MAX/10; // 10% global weight.
     pub const InitialEmaPriceHalvingPeriod: u64 = 201_600_u64; // 4 weeks
     pub const DurationOfStartCall: u64 = 7 * 24 * 60 * 60 / 12; // 7 days
+    pub const InitialKeySwapOnSubnetCost: u64 = 10_000_000;
 }
 
 impl pallet_subtensor::Config for Test {
@@ -201,6 +202,7 @@ impl pallet_subtensor::Config for Test {
     type InitialTaoWeight = InitialTaoWeight;
     type InitialEmaPriceHalvingPeriod = InitialEmaPriceHalvingPeriod;
     type DurationOfStartCall = DurationOfStartCall;
+    type KeySwapOneSubnetCost = InitialKeySwapOnSubnetCost;
 }
 
 #[derive_impl(frame_system::config_preludes::TestDefaultConfig)]

From 898796f656dc20fb59701b5879e1b0580399bf42 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Tue, 22 Apr 2025 14:12:27 +0200
Subject: [PATCH 086/418] Fix integration issues and update tests

---
 pallets/subtensor/src/lib.rs                 |   6 -
 pallets/subtensor/src/staking/helpers.rs     |  13 +-
 pallets/subtensor/src/staking/stake_utils.rs |  52 ++-
 pallets/subtensor/src/tests/children.rs      |  86 +++--
 pallets/subtensor/src/tests/coinbase.rs      |   3 +
 pallets/subtensor/src/tests/epoch.rs         | 353 ++++++++++---------
 pallets/subtensor/src/tests/mock.rs          |  22 +-
 pallets/subtensor/src/tests/move_stake.rs    |  73 ++--
 pallets/subtensor/src/tests/senate.rs        |  14 +-
 pallets/subtensor/src/tests/staking.rs       | 349 +++++++++---------
 pallets/subtensor/src/tests/staking2.rs      |  32 +-
 pallets/subtensor/src/tests/subnet.rs        |  12 +-
 pallets/subtensor/src/tests/swap_coldkey.rs  |   2 +-
 pallets/subtensor/src/tests/swap_hotkey.rs   |  30 +-
 pallets/subtensor/src/tests/weights.rs       |  13 +-
 15 files changed, 544 insertions(+), 516 deletions(-)

diff --git a/pallets/subtensor/src/lib.rs b/pallets/subtensor/src/lib.rs
index 5fdb82a92c..fc18d19a66 100644
--- a/pallets/subtensor/src/lib.rs
+++ b/pallets/subtensor/src/lib.rs
@@ -752,12 +752,6 @@ pub mod pallet {
         500_000
     }
 
-    #[pallet::type_value]
-    /// Default staking fee.
-    pub fn DefaultStakingFee<T: Config>() -> u64 {
-        50_000
-    }
-
     #[pallet::type_value]
     /// Default unicode vector for tau symbol.
     pub fn DefaultUnicodeVecU8<T: Config>() -> Vec<u8> {
diff --git a/pallets/subtensor/src/staking/helpers.rs b/pallets/subtensor/src/staking/helpers.rs
index 2d103fa17f..89ac345699 100644
--- a/pallets/subtensor/src/staking/helpers.rs
+++ b/pallets/subtensor/src/staking/helpers.rs
@@ -42,16 +42,15 @@ impl<T: Config> Pallet<T> {
         TotalStake::<T>::put(Self::get_total_stake().saturating_sub(decrement));
     }
 
-    // Returns the total amount of stake under a hotkey (delegative or otherwise)
-    //
+    /// Returns the total amount of stake (in TAO) under a hotkey (delegative or otherwise)
     pub fn get_total_stake_for_hotkey(hotkey: &T::AccountId) -> u64 {
         Self::get_all_subnet_netuids()
-            .iter()
+            .into_iter()
             .map(|netuid| {
-                let alpha: U96F32 = U96F32::saturating_from_num(
-                    Self::get_stake_for_hotkey_on_subnet(hotkey, *netuid),
-                );
-                let tao_price: U96F32 = Self::get_alpha_price(*netuid);
+                let alpha = U96F32::saturating_from_num(Self::get_stake_for_hotkey_on_subnet(
+                    hotkey, netuid,
+                ));
+                let tao_price = Self::get_alpha_price(netuid);
                 alpha.saturating_mul(tao_price).saturating_to_num::<u64>()
             })
             .sum()
diff --git a/pallets/subtensor/src/staking/stake_utils.rs b/pallets/subtensor/src/staking/stake_utils.rs
index a151ebc83f..7b89c61cc9 100644
--- a/pallets/subtensor/src/staking/stake_utils.rs
+++ b/pallets/subtensor/src/staking/stake_utils.rs
@@ -3,7 +3,7 @@ use safe_math::*;
 use share_pool::{SharePool, SharePoolDataOperations};
 use sp_std::ops::Neg;
 use substrate_fixed::types::{I64F64, I96F32, U64F64, U96F32};
-use subtensor_swap_interface::{OrderType, SwapHandler, SwapResult};
+use subtensor_swap_interface::{LiquidityDataProvider, OrderType, SwapHandler, SwapResult};
 
 impl<T: Config> Pallet<T> {
     /// Retrieves the total alpha issuance for a given subnet.
@@ -642,9 +642,7 @@ impl<T: Config> Pallet<T> {
         SubnetTAO::<T>::set(netuid, swap_result.new_tao_reserve);
 
         // Increase Total Tao reserves.
-        TotalStake::<T>::mutate(|total| {
-            *total = total.saturating_add(tao);
-        });
+        TotalStake::<T>::mutate(|total| *total = total.saturating_add(tao));
 
         // Increase total subnet TAO volume.
         SubnetVolume::<T>::mutate(netuid, |total| {
@@ -678,13 +676,11 @@ impl<T: Config> Pallet<T> {
         SubnetTAO::<T>::set(netuid, swap_result.new_tao_reserve);
 
         // Reduce total TAO reserves.
-        TotalStake::<T>::mutate(|total| {
-            *total = total.saturating_sub(swap_result.amount_paid_out);
-        });
+        TotalStake::<T>::mutate(|total| *total = total.saturating_sub(swap_result.amount_paid_out));
 
         // Increase total subnet TAO volume.
         SubnetVolume::<T>::mutate(netuid, |total| {
-            *total = total.saturating_add(swap_result.amount_paid_out.into());
+            *total = total.saturating_add(swap_result.amount_paid_out.into())
         });
 
         // Return the tao received.
@@ -828,7 +824,11 @@ impl<T: Config> Pallet<T> {
         ensure!(Self::if_subnet_exist(netuid), Error::<T>::SubnetNotExists);
 
         // Get the minimum balance (and amount) that satisfies the transaction
-        let min_amount = DefaultMinStake::<T>::get().saturating_add(DefaultStakingFee::<T>::get());
+        let min_amount = {
+            let default_stake = DefaultMinStake::<T>::get();
+            let fee = T::SwapInterface::approx_fee_amount(netuid, default_stake);
+            default_stake.saturating_add(fee)
+        };
 
         // Ensure that the stake_to_be_added is at least the min_amount
         ensure!(stake_to_be_added >= min_amount, Error::<T>::AmountTooLow);
@@ -851,6 +851,25 @@ impl<T: Config> Pallet<T> {
             Error::<T>::HotKeyAccountNotExists
         );
 
+        let expected_alpha = T::SwapInterface::swap(
+            netuid,
+            OrderType::Buy,
+            stake_to_be_added,
+            T::SwapInterface::max_price(),
+            true,
+        )
+        .map_err(|_| Error::<T>::InsufficientLiquidity)?;
+
+		ensure!(expected_alpha.amount_paid_out > 0, Error::<T>::InsufficientLiquidity);
+
+        // Ensure hotkey pool is precise enough
+        let try_stake_result = Self::try_increase_stake_for_hotkey_and_coldkey_on_subnet(
+            hotkey,
+            netuid,
+            expected_alpha.amount_paid_out,
+        );
+        ensure!(try_stake_result, Error::<T>::InsufficientLiquidity);
+
         Ok(())
     }
 
@@ -867,6 +886,21 @@ impl<T: Config> Pallet<T> {
         // Ensure that the subnet exists.
         ensure!(Self::if_subnet_exist(netuid), Error::<T>::SubnetNotExists);
 
+        // Ensure that the stake amount to be removed is above the minimum in tao equivalent.
+        match T::SwapInterface::swap(
+            netuid,
+            OrderType::Sell,
+            alpha_unstaked,
+            T::SwapInterface::max_price(),
+            true,
+        ) {
+            Ok(res) => ensure!(
+                res.amount_paid_out > DefaultMinStake::<T>::get(),
+                Error::<T>::AmountTooLow
+            ),
+            Err(_) => return Err(Error::<T>::InsufficientLiquidity),
+        }
+
         // Ensure that if partial execution is not allowed, the amount will not cause
         // slippage over desired
         if !allow_partial {
diff --git a/pallets/subtensor/src/tests/children.rs b/pallets/subtensor/src/tests/children.rs
index 3ed7f77d3d..44eceb474d 100644
--- a/pallets/subtensor/src/tests/children.rs
+++ b/pallets/subtensor/src/tests/children.rs
@@ -2211,6 +2211,10 @@ fn test_do_remove_stake_clears_pending_childkeys() {
         add_network(child_netuid, 13, 0);
         register_ok_neuron(child_netuid, hotkey, coldkey, 0);
 
+        let reserve = 1_000_000_000_000_000;
+        mock::setup_reserves(netuid, reserve, reserve);
+        mock::setup_reserves(child_netuid, reserve, reserve);
+
         // Set non-default value for childkey stake threshold
         StakeThreshold::<Test>::set(1_000_000_000_000);
 
@@ -2815,6 +2819,7 @@ fn test_childkey_take_drain() {
 
             // Add network, register hotkeys, and setup network parameters
             add_network(netuid, subnet_tempo, 0);
+            mock::setup_reserves(netuid, stake * 10, stake * 10);
             register_ok_neuron(netuid, child_hotkey, child_coldkey, 0);
             register_ok_neuron(netuid, parent_hotkey, parent_coldkey, 1);
             register_ok_neuron(netuid, miner_hotkey, miner_coldkey, 1);
@@ -3278,6 +3283,7 @@ fn test_dividend_distribution_with_children() {
     new_test_ext(1).execute_with(|| {
         let netuid: u16 = 1;
         add_network(netuid, 1, 0);
+        mock::setup_reserves(netuid, 1_000_000_000_000_000, 1_000_000_000_000_000);
         // Set owner cut to 0
         SubtensorModule::set_subnet_owner_cut(0_u16);
 
@@ -3300,16 +3306,9 @@ fn test_dividend_distribution_with_children() {
         SubtensorModule::add_balance_to_coldkey_account(&coldkey_c, 1_000);
 
         // Swap to alpha
-        let total_tao: I96F32 = I96F32::from_num(300_000 + 100_000 + 50_000);
-        let total_alpha = I96F32::from_num(
-            SubtensorModule::swap_tao_for_alpha(
-                netuid,
-                total_tao.saturating_to_num::<u64>(),
-                <Test as Config>::SwapInterface::max_price(),
-            )
-            .unwrap()
-            .amount_paid_out,
-        );
+        let total_tao = I96F32::from_num(300_000 + 100_000 + 50_000);
+        let (total_alpha, _) = mock::swap_tao_to_alpha(netuid, total_tao.to_num());
+        let total_alpha = I96F32::from_num(total_alpha);
 
         // Set the stakes directly
         // This avoids needing to swap tao to alpha, impacting the initial stake distribution.
@@ -3333,21 +3332,22 @@ fn test_dividend_distribution_with_children() {
         );
 
         // Get old stakes
-        let stake_a: u64 = SubtensorModule::get_total_stake_for_hotkey(&hotkey_a);
-        let stake_b: u64 = SubtensorModule::get_total_stake_for_hotkey(&hotkey_b);
-        let stake_c: u64 = SubtensorModule::get_total_stake_for_hotkey(&hotkey_c);
+        let stake_a = SubtensorModule::get_total_stake_for_hotkey(&hotkey_a);
+        let stake_b = SubtensorModule::get_total_stake_for_hotkey(&hotkey_b);
+        let stake_c = SubtensorModule::get_total_stake_for_hotkey(&hotkey_c);
 
         // Assert initial stake is correct
-        let rel_stake_a = I96F32::from_num(stake_a) / total_tao;
-        let rel_stake_b = I96F32::from_num(stake_b) / total_tao;
-        let rel_stake_c = I96F32::from_num(stake_c) / total_tao;
+        let rel_stake_a = I96F32::from_num(stake_a) / total_alpha;
+        let rel_stake_b = I96F32::from_num(stake_b) / total_alpha;
+        let rel_stake_c = I96F32::from_num(stake_c) / total_alpha;
 
         log::info!("rel_stake_a: {:?}", rel_stake_a); // 0.6666 -> 2/3
         log::info!("rel_stake_b: {:?}", rel_stake_b); // 0.2222 -> 2/9
         log::info!("rel_stake_c: {:?}", rel_stake_c); // 0.1111 -> 1/9
-        assert_eq!(rel_stake_a, I96F32::from_num(300_000) / total_tao);
-        assert_eq!(rel_stake_b, I96F32::from_num(100_000) / total_tao);
-        assert_eq!(rel_stake_c, I96F32::from_num(50_000) / total_tao);
+        let epsilon = I96F32::from_num(0.00001);
+        assert!((rel_stake_a - I96F32::from_num(300_000) / total_tao).abs() <= epsilon);
+        assert!((rel_stake_b - I96F32::from_num(100_000) / total_tao).abs() <= epsilon);
+        assert!((rel_stake_c - I96F32::from_num(50_000) / total_tao).abs() <= epsilon);
 
         // Set parent-child relationships
         // A -> B (50% of A's stake)
@@ -3510,12 +3510,12 @@ fn test_dynamic_parent_child_relationships() {
         add_network(netuid, 1, 0);
 
         // Define hotkeys and coldkeys
-        let parent: U256 = U256::from(1);
-        let child1: U256 = U256::from(2);
-        let child2: U256 = U256::from(3);
-        let coldkey_parent: U256 = U256::from(100);
-        let coldkey_child1: U256 = U256::from(101);
-        let coldkey_child2: U256 = U256::from(102);
+        let parent = U256::from(1);
+        let child1 = U256::from(2);
+        let child2 = U256::from(3);
+        let coldkey_parent = U256::from(100);
+        let coldkey_child1 = U256::from(101);
+        let coldkey_child2 = U256::from(102);
 
         // Register neurons with varying stakes
         register_ok_neuron(netuid, parent, coldkey_parent, 0);
@@ -3573,16 +3573,17 @@ fn test_dynamic_parent_child_relationships() {
         let total_stake_0: u64 = stake_parent_0 + stake_child1_0 + stake_child2_0;
 
         // Assert initial stake is correct
-        let rel_stake_parent_0 = I96F32::from_num(stake_parent_0) / total_tao;
-        let rel_stake_child1_0 = I96F32::from_num(stake_child1_0) / total_tao;
-        let rel_stake_child2_0 = I96F32::from_num(stake_child2_0) / total_tao;
+        let rel_stake_parent_0 = I96F32::from_num(stake_parent_0) / total_alpha;
+        let rel_stake_child1_0 = I96F32::from_num(stake_child1_0) / total_alpha;
+        let rel_stake_child2_0 = I96F32::from_num(stake_child2_0) / total_alpha;
 
         log::info!("rel_stake_parent_0: {:?}", rel_stake_parent_0);
         log::info!("rel_stake_child1_0: {:?}", rel_stake_child1_0);
         log::info!("rel_stake_child2_0: {:?}", rel_stake_child2_0);
-        assert_eq!(rel_stake_parent_0, I96F32::from_num(500_000) / total_tao);
-        assert_eq!(rel_stake_child1_0, I96F32::from_num(50_000) / total_tao);
-        assert_eq!(rel_stake_child2_0, I96F32::from_num(30_000) / total_tao);
+        let epsilon = I96F32::from_num(0.00001);
+        assert!((rel_stake_parent_0 - I96F32::from_num(500_000) / total_tao).abs() <= epsilon);
+        assert!((rel_stake_child1_0 - I96F32::from_num(50_000) / total_tao).abs() <= epsilon);
+        assert!((rel_stake_child2_0 - I96F32::from_num(30_000) / total_tao).abs() <= epsilon);
 
         mock_set_children(&coldkey_parent, &parent, netuid, &[(u64::MAX / 2, child1)]);
 
@@ -3811,6 +3812,7 @@ fn test_dividend_distribution_with_children_same_coldkey_owner() {
         add_network(netuid, 1, 0);
         // Set SN owner cut to 0
         SubtensorModule::set_subnet_owner_cut(0_u16);
+        mock::setup_reserves(netuid, 1_000_000_000_000, 1_000_000_000_000);
 
         // Define hotkeys and coldkeys
         let hotkey_a: U256 = U256::from(1);
@@ -3826,16 +3828,9 @@ fn test_dividend_distribution_with_children_same_coldkey_owner() {
         SubtensorModule::add_balance_to_coldkey_account(&coldkey_a, 1_000);
 
         // Swap to alpha
-        let total_tao: I96F32 = I96F32::from_num(300_000 + 100_000);
-        let total_alpha: I96F32 = I96F32::from_num(
-            SubtensorModule::swap_tao_for_alpha(
-                netuid,
-                total_tao.saturating_to_num::<u64>(),
-                <Test as Config>::SwapInterface::max_price(),
-            )
-            .unwrap()
-            .amount_paid_out,
-        );
+        let total_tao = 300_000 + 100_000;
+        let total_alpha = I96F32::from_num(mock::swap_tao_to_alpha(netuid, total_tao).0);
+        let total_tao = I96F32::from_num(total_tao);
 
         // Set the stakes directly
         // This avoids needing to swap tao to alpha, impacting the initial stake distribution.
@@ -3857,13 +3852,14 @@ fn test_dividend_distribution_with_children_same_coldkey_owner() {
         let stake_b: u64 = SubtensorModule::get_total_stake_for_hotkey(&hotkey_b);
 
         // Assert initial stake is correct
-        let rel_stake_a = I96F32::from_num(stake_a) / total_tao;
-        let rel_stake_b = I96F32::from_num(stake_b) / total_tao;
+        let rel_stake_a = I96F32::from_num(stake_a) / total_alpha;
+        let rel_stake_b = I96F32::from_num(stake_b) / total_alpha;
 
         log::info!("rel_stake_a: {:?}", rel_stake_a); // 0.75 -> 3/4
         log::info!("rel_stake_b: {:?}", rel_stake_b); // 0.25 -> 1/4
-        assert_eq!(rel_stake_a, I96F32::from_num(300_000) / total_tao);
-        assert_eq!(rel_stake_b, I96F32::from_num(100_000) / total_tao);
+        let epsilon = I96F32::from_num(0.0001);
+        assert!((rel_stake_a - I96F32::from_num(300_000) / total_tao).abs() <= epsilon);
+        assert!((rel_stake_b - I96F32::from_num(100_000) / total_tao).abs() <= epsilon);
 
         // Set parent-child relationships
         // A -> B (50% of A's stake)
diff --git a/pallets/subtensor/src/tests/coinbase.rs b/pallets/subtensor/src/tests/coinbase.rs
index c8bd50f47f..030fcf655d 100644
--- a/pallets/subtensor/src/tests/coinbase.rs
+++ b/pallets/subtensor/src/tests/coinbase.rs
@@ -1,6 +1,7 @@
 #![allow(unused, clippy::indexing_slicing, clippy::panic, clippy::unwrap_used)]
 use super::mock::*;
 
+use crate::tests::mock;
 use crate::*;
 use alloc::collections::BTreeMap;
 use approx::assert_abs_diff_eq;
@@ -439,6 +440,7 @@ fn test_owner_cut_base() {
     new_test_ext(1).execute_with(|| {
         let netuid: u16 = 1;
         add_network(netuid, 1, 0);
+        mock::setup_reserves(netuid, 1_000_000_000_000, 1_000_000_000_000);
         SubtensorModule::set_tempo(netuid, 10000); // Large number (dont drain)
         SubtensorModule::set_subnet_owner_cut(0);
         SubtensorModule::run_coinbase(U96F32::from_num(0)).unwrap();
@@ -456,6 +458,7 @@ fn test_pending_swapped() {
         let netuid: u16 = 1;
         let emission: u64 = 1_000_000;
         add_network(netuid, 1, 0);
+        mock::setup_reserves(netuid, 1_000_000_000_000, 1_000_000_000_000);
         SubtensorModule::run_coinbase(U96F32::from_num(0)).unwrap();
         assert_eq!(PendingAlphaSwapped::<Test>::get(netuid), 0); // Zero tao weight and no root.
         SubnetTAO::<Test>::insert(0, 1_000_000_000); // Add root weight.
diff --git a/pallets/subtensor/src/tests/epoch.rs b/pallets/subtensor/src/tests/epoch.rs
index aaaf93e086..7df41a1301 100644
--- a/pallets/subtensor/src/tests/epoch.rs
+++ b/pallets/subtensor/src/tests/epoch.rs
@@ -1507,39 +1507,40 @@ fn test_bonds_with_liquid_alpha() {
 #[test]
 fn test_set_alpha_disabled() {
     new_test_ext(1).execute_with(|| {
-        let hotkey = U256::from(1);
-        let coldkey = U256::from(1 + 456);
-        let netuid = add_dynamic_network(&hotkey, &coldkey);
-        let signer = RuntimeOrigin::signed(coldkey);
-
-        // Enable Liquid Alpha and setup
-        SubtensorModule::set_liquid_alpha_enabled(netuid, true);
-        migrations::migrate_create_root_network::migrate_create_root_network::<Test>();
-        SubtensorModule::add_balance_to_coldkey_account(&coldkey, 1_000_000_000_000_000);
-        assert_ok!(SubtensorModule::root_register(signer.clone(), hotkey,));
-        assert_ok!(SubtensorModule::add_stake(
-            signer.clone(),
-            hotkey,
-            netuid,
-            DefaultMinStake::<Test>::get() + DefaultStakingFee::<Test>::get()
-        ));
-        // Only owner can set alpha values
-        assert_ok!(SubtensorModule::register_network(signer.clone(), hotkey));
-
-        // Explicitly set to false
-        SubtensorModule::set_liquid_alpha_enabled(netuid, false);
-        assert_err!(
-            SubtensorModule::do_set_alpha_values(signer.clone(), netuid, 12_u16, u16::MAX),
-            Error::<Test>::LiquidAlphaDisabled
-        );
-
-        SubtensorModule::set_liquid_alpha_enabled(netuid, true);
-        assert_ok!(SubtensorModule::do_set_alpha_values(
-            signer.clone(),
-            netuid,
-            12_u16,
-            u16::MAX
-        ));
+		todo!();
+        // let hotkey = U256::from(1);
+        // let coldkey = U256::from(1 + 456);
+        // let netuid = add_dynamic_network(&hotkey, &coldkey);
+        // let signer = RuntimeOrigin::signed(coldkey);
+
+        // // Enable Liquid Alpha and setup
+        // SubtensorModule::set_liquid_alpha_enabled(netuid, true);
+        // migrations::migrate_create_root_network::migrate_create_root_network::<Test>();
+        // SubtensorModule::add_balance_to_coldkey_account(&coldkey, 1_000_000_000_000_000);
+        // assert_ok!(SubtensorModule::root_register(signer.clone(), hotkey,));
+        // assert_ok!(SubtensorModule::add_stake(
+        //     signer.clone(),
+        //     hotkey,
+        //     netuid,
+        //     DefaultMinStake::<Test>::get() + DefaultStakingFee::<Test>::get()
+        // ));
+        // // Only owner can set alpha values
+        // assert_ok!(SubtensorModule::register_network(signer.clone(), hotkey));
+
+        // // Explicitly set to false
+        // SubtensorModule::set_liquid_alpha_enabled(netuid, false);
+        // assert_err!(
+        //     SubtensorModule::do_set_alpha_values(signer.clone(), netuid, 12_u16, u16::MAX),
+        //     Error::<Test>::LiquidAlphaDisabled
+        // );
+
+        // SubtensorModule::set_liquid_alpha_enabled(netuid, true);
+        // assert_ok!(SubtensorModule::do_set_alpha_values(
+        //     signer.clone(),
+        //     netuid,
+        //     12_u16,
+        //     u16::MAX
+        // ));
     });
 }
 
@@ -2768,148 +2769,150 @@ fn test_compute_ema_bonds_with_liquid_alpha_sparse_empty() {
 #[test]
 fn test_get_set_alpha() {
     new_test_ext(1).execute_with(|| {
-        let netuid = 1;
-        let alpha_low: u16 = 12_u16;
-        let alpha_high: u16 = u16::MAX - 10;
-
-        let hotkey: U256 = U256::from(1);
-        let coldkey: U256 = U256::from(1 + 456);
-        let signer = RuntimeOrigin::signed(coldkey);
-
-        // Enable Liquid Alpha and setup
-        SubtensorModule::set_liquid_alpha_enabled(netuid, true);
-        migrations::migrate_create_root_network::migrate_create_root_network::<Test>();
-        SubtensorModule::add_balance_to_coldkey_account(&coldkey, 1_000_000_000_000_000);
-        assert_ok!(SubtensorModule::root_register(signer.clone(), hotkey,));
-
-        // Should fail as signer does not own the subnet
-        assert_err!(
-            SubtensorModule::do_set_alpha_values(signer.clone(), netuid, alpha_low, alpha_high),
-            DispatchError::BadOrigin
-        );
-
-        assert_ok!(SubtensorModule::register_network(signer.clone(), hotkey));
-        assert_ok!(SubtensorModule::add_stake(
-            signer.clone(),
-            hotkey,
-            netuid,
-            DefaultMinStake::<Test>::get() + DefaultStakingFee::<Test>::get()
-        ));
-
-        assert_ok!(SubtensorModule::do_set_alpha_values(
-            signer.clone(),
-            netuid,
-            alpha_low,
-            alpha_high
-        ));
-        let (grabbed_alpha_low, grabbed_alpha_high): (u16, u16) =
-            SubtensorModule::get_alpha_values(netuid);
-
-        log::info!(
-            "alpha_low: {:?} alpha_high: {:?}",
-            grabbed_alpha_low,
-            grabbed_alpha_high
-        );
-        assert_eq!(grabbed_alpha_low, alpha_low);
-        assert_eq!(grabbed_alpha_high, alpha_high);
-
-        // Convert the u16 values to decimal values
-        fn unnormalize_u16_to_float(normalized_value: u16) -> f32 {
-            const MAX_U16: u16 = 65535;
-            normalized_value as f32 / MAX_U16 as f32
-        }
-
-        let alpha_low_decimal = unnormalize_u16_to_float(alpha_low);
-        let alpha_high_decimal = unnormalize_u16_to_float(alpha_high);
-
-        let (alpha_low_32, alpha_high_32) = SubtensorModule::get_alpha_values_32(netuid);
-
-        let tolerance: f32 = 1e-6; // 0.000001
-
-        // Check if the values are equal to the sixth decimal
-        assert!(
-            (alpha_low_32.to_num::<f32>() - alpha_low_decimal).abs() < tolerance,
-            "alpha_low mismatch: {} != {}",
-            alpha_low_32.to_num::<f32>(),
-            alpha_low_decimal
-        );
-        assert!(
-            (alpha_high_32.to_num::<f32>() - alpha_high_decimal).abs() < tolerance,
-            "alpha_high mismatch: {} != {}",
-            alpha_high_32.to_num::<f32>(),
-            alpha_high_decimal
-        );
-
-        // 1. Liquid alpha disabled
-        SubtensorModule::set_liquid_alpha_enabled(netuid, false);
-        assert_err!(
-            SubtensorModule::do_set_alpha_values(signer.clone(), netuid, alpha_low, alpha_high),
-            Error::<Test>::LiquidAlphaDisabled
-        );
-        // Correct scenario after error
-        SubtensorModule::set_liquid_alpha_enabled(netuid, true); // Re-enable for further tests
-        assert_ok!(SubtensorModule::do_set_alpha_values(
-            signer.clone(),
-            netuid,
-            alpha_low,
-            alpha_high
-        ));
-
-        // 2. Alpha high too low
-        let alpha_high_too_low = (u16::MAX as u32 * 4 / 5) as u16 - 1; // One less than the minimum acceptable value
-        assert_err!(
-            SubtensorModule::do_set_alpha_values(
-                signer.clone(),
-                netuid,
-                alpha_low,
-                alpha_high_too_low
-            ),
-            Error::<Test>::AlphaHighTooLow
-        );
-        // Correct scenario after error
-        assert_ok!(SubtensorModule::do_set_alpha_values(
-            signer.clone(),
-            netuid,
-            alpha_low,
-            alpha_high
-        ));
-
-        // 3. Alpha low too low or too high
-        let alpha_low_too_low = 0_u16;
-        assert_err!(
-            SubtensorModule::do_set_alpha_values(
-                signer.clone(),
-                netuid,
-                alpha_low_too_low,
-                alpha_high
-            ),
-            Error::<Test>::AlphaLowOutOfRange
-        );
-        // Correct scenario after error
-        assert_ok!(SubtensorModule::do_set_alpha_values(
-            signer.clone(),
-            netuid,
-            alpha_low,
-            alpha_high
-        ));
-
-        let alpha_low_too_high = (u16::MAX as u32 * 4 / 5) as u16 + 1; // One more than the maximum acceptable value
-        assert_err!(
-            SubtensorModule::do_set_alpha_values(
-                signer.clone(),
-                netuid,
-                alpha_low_too_high,
-                alpha_high
-            ),
-            Error::<Test>::AlphaLowOutOfRange
-        );
-        // Correct scenario after error
-        assert_ok!(SubtensorModule::do_set_alpha_values(
-            signer.clone(),
-            netuid,
-            alpha_low,
-            alpha_high
-        ));
+		todo!();
+
+        // let netuid = 1;
+        // let alpha_low: u16 = 12_u16;
+        // let alpha_high: u16 = u16::MAX - 10;
+
+        // let hotkey: U256 = U256::from(1);
+        // let coldkey: U256 = U256::from(1 + 456);
+        // let signer = RuntimeOrigin::signed(coldkey);
+
+        // // Enable Liquid Alpha and setup
+        // SubtensorModule::set_liquid_alpha_enabled(netuid, true);
+        // migrations::migrate_create_root_network::migrate_create_root_network::<Test>();
+        // SubtensorModule::add_balance_to_coldkey_account(&coldkey, 1_000_000_000_000_000);
+        // assert_ok!(SubtensorModule::root_register(signer.clone(), hotkey,));
+
+        // // Should fail as signer does not own the subnet
+        // assert_err!(
+        //     SubtensorModule::do_set_alpha_values(signer.clone(), netuid, alpha_low, alpha_high),
+        //     DispatchError::BadOrigin
+        // );
+
+        // assert_ok!(SubtensorModule::register_network(signer.clone(), hotkey));
+        // assert_ok!(SubtensorModule::add_stake(
+        //     signer.clone(),
+        //     hotkey,
+        //     netuid,
+        //     DefaultMinStake::<Test>::get() + DefaultStakingFee::<Test>::get()
+        // ));
+
+        // assert_ok!(SubtensorModule::do_set_alpha_values(
+        //     signer.clone(),
+        //     netuid,
+        //     alpha_low,
+        //     alpha_high
+        // ));
+        // let (grabbed_alpha_low, grabbed_alpha_high): (u16, u16) =
+        //     SubtensorModule::get_alpha_values(netuid);
+
+        // log::info!(
+        //     "alpha_low: {:?} alpha_high: {:?}",
+        //     grabbed_alpha_low,
+        //     grabbed_alpha_high
+        // );
+        // assert_eq!(grabbed_alpha_low, alpha_low);
+        // assert_eq!(grabbed_alpha_high, alpha_high);
+
+        // // Convert the u16 values to decimal values
+        // fn unnormalize_u16_to_float(normalized_value: u16) -> f32 {
+        //     const MAX_U16: u16 = 65535;
+        //     normalized_value as f32 / MAX_U16 as f32
+        // }
+
+        // let alpha_low_decimal = unnormalize_u16_to_float(alpha_low);
+        // let alpha_high_decimal = unnormalize_u16_to_float(alpha_high);
+
+        // let (alpha_low_32, alpha_high_32) = SubtensorModule::get_alpha_values_32(netuid);
+
+        // let tolerance: f32 = 1e-6; // 0.000001
+
+        // // Check if the values are equal to the sixth decimal
+        // assert!(
+        //     (alpha_low_32.to_num::<f32>() - alpha_low_decimal).abs() < tolerance,
+        //     "alpha_low mismatch: {} != {}",
+        //     alpha_low_32.to_num::<f32>(),
+        //     alpha_low_decimal
+        // );
+        // assert!(
+        //     (alpha_high_32.to_num::<f32>() - alpha_high_decimal).abs() < tolerance,
+        //     "alpha_high mismatch: {} != {}",
+        //     alpha_high_32.to_num::<f32>(),
+        //     alpha_high_decimal
+        // );
+
+        // // 1. Liquid alpha disabled
+        // SubtensorModule::set_liquid_alpha_enabled(netuid, false);
+        // assert_err!(
+        //     SubtensorModule::do_set_alpha_values(signer.clone(), netuid, alpha_low, alpha_high),
+        //     Error::<Test>::LiquidAlphaDisabled
+        // );
+        // // Correct scenario after error
+        // SubtensorModule::set_liquid_alpha_enabled(netuid, true); // Re-enable for further tests
+        // assert_ok!(SubtensorModule::do_set_alpha_values(
+        //     signer.clone(),
+        //     netuid,
+        //     alpha_low,
+        //     alpha_high
+        // ));
+
+        // // 2. Alpha high too low
+        // let alpha_high_too_low = (u16::MAX as u32 * 4 / 5) as u16 - 1; // One less than the minimum acceptable value
+        // assert_err!(
+        //     SubtensorModule::do_set_alpha_values(
+        //         signer.clone(),
+        //         netuid,
+        //         alpha_low,
+        //         alpha_high_too_low
+        //     ),
+        //     Error::<Test>::AlphaHighTooLow
+        // );
+        // // Correct scenario after error
+        // assert_ok!(SubtensorModule::do_set_alpha_values(
+        //     signer.clone(),
+        //     netuid,
+        //     alpha_low,
+        //     alpha_high
+        // ));
+
+        // // 3. Alpha low too low or too high
+        // let alpha_low_too_low = 0_u16;
+        // assert_err!(
+        //     SubtensorModule::do_set_alpha_values(
+        //         signer.clone(),
+        //         netuid,
+        //         alpha_low_too_low,
+        //         alpha_high
+        //     ),
+        //     Error::<Test>::AlphaLowOutOfRange
+        // );
+        // // Correct scenario after error
+        // assert_ok!(SubtensorModule::do_set_alpha_values(
+        //     signer.clone(),
+        //     netuid,
+        //     alpha_low,
+        //     alpha_high
+        // ));
+
+        // let alpha_low_too_high = (u16::MAX as u32 * 4 / 5) as u16 + 1; // One more than the maximum acceptable value
+        // assert_err!(
+        //     SubtensorModule::do_set_alpha_values(
+        //         signer.clone(),
+        //         netuid,
+        //         alpha_low_too_high,
+        //         alpha_high
+        //     ),
+        //     Error::<Test>::AlphaLowOutOfRange
+        // );
+        // // Correct scenario after error
+        // assert_ok!(SubtensorModule::do_set_alpha_values(
+        //     signer.clone(),
+        //     netuid,
+        //     alpha_low,
+        //     alpha_high
+        // ));
     });
 }
 
diff --git a/pallets/subtensor/src/tests/mock.rs b/pallets/subtensor/src/tests/mock.rs
index 2015504cae..a0ad52dc50 100644
--- a/pallets/subtensor/src/tests/mock.rs
+++ b/pallets/subtensor/src/tests/mock.rs
@@ -426,7 +426,7 @@ parameter_types! {
     pub const SwapMaxFeeRate: u16 = 10000; // 15.26%
     pub const SwapMaxPositions: u32 = 100;
     pub const SwapMinimumLiquidity: u64 = 1_000;
-    pub const SwapMinimumReserve: NonZeroU64 = NonZeroU64::new(1).unwrap();
+    pub const SwapMinimumReserve: NonZeroU64 = NonZeroU64::new(100).unwrap();
 }
 
 impl pallet_subtensor_swap::Config for Test {
@@ -881,3 +881,23 @@ pub(crate) fn swap_tao_to_alpha(netuid: u16, tao: u64) -> (u64, u64) {
 
     (result.amount_paid_out, result.fee_paid)
 }
+
+pub(crate) fn swap_alpha_to_tao(netuid: u16, alpha: u64) -> (u64, u64) {
+    let result = <Test as pallet::Config>::SwapInterface::swap(
+        netuid,
+        OrderType::Sell,
+        alpha,
+        <Test as pallet::Config>::SwapInterface::max_price(),
+        true,
+    );
+
+    assert_ok!(&result);
+
+    let result = result.unwrap();
+
+    // we don't want to have silent 0 comparissons in tests
+    assert!(result.amount_paid_out > 0);
+
+    (result.amount_paid_out, result.fee_paid)
+}
+
diff --git a/pallets/subtensor/src/tests/move_stake.rs b/pallets/subtensor/src/tests/move_stake.rs
index 0b073d58a9..8c41198de3 100644
--- a/pallets/subtensor/src/tests/move_stake.rs
+++ b/pallets/subtensor/src/tests/move_stake.rs
@@ -1,11 +1,13 @@
-use super::mock::*;
-use crate::*;
 use approx::assert_abs_diff_eq;
 use frame_support::{assert_err, assert_noop, assert_ok};
 use sp_core::{Get, U256};
 use substrate_fixed::types::{U64F64, U96F32};
 use subtensor_swap_interface::SwapHandler;
 
+use super::mock;
+use super::mock::*;
+use crate::*;
+
 // 1. test_do_move_success
 // Description: Test a successful move of stake between two hotkeys in the same subnet
 // SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test move -- test_do_move_success --exact --nocapture
@@ -19,7 +21,7 @@ fn test_do_move_success() {
         let origin_hotkey = U256::from(2);
         let destination_hotkey = U256::from(3);
         let stake_amount = DefaultMinStake::<Test>::get() * 10;
-        let fee = DefaultStakingFee::<Test>::get();
+        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         // Set up initial stake
         SubtensorModule::create_account_if_non_existent(&coldkey, &origin_hotkey);
@@ -83,7 +85,10 @@ fn test_do_move_different_subnets() {
         let origin_hotkey = U256::from(2);
         let destination_hotkey = U256::from(3);
         let stake_amount = DefaultMinStake::<Test>::get() * 10;
-        let fee = DefaultStakingFee::<Test>::get();
+        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
+
+        mock::setup_reserves(origin_netuid, stake_amount * 100, stake_amount * 100);
+        mock::setup_reserves(destination_netuid, stake_amount * 100, stake_amount * 100);
 
         // Set up initial stake and subnets
         SubtensorModule::create_account_if_non_existent(&coldkey, &origin_hotkey);
@@ -121,19 +126,15 @@ fn test_do_move_different_subnets() {
             ),
             0
         );
-        let alpha_fee: U96F32 =
-            U96F32::from_num(fee) / SubtensorModule::get_alpha_price(destination_netuid);
-        let expected_value = U96F32::from_num(alpha)
-            * SubtensorModule::get_alpha_price(origin_netuid)
-            / SubtensorModule::get_alpha_price(destination_netuid);
+        let fee = <Test as Config>::SwapInterface::approx_fee_amount(destination_netuid, alpha);
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
                 &destination_hotkey,
                 &coldkey,
                 destination_netuid
             ),
-            (expected_value - alpha_fee).to_num::<u64>(),
-            epsilon = (expected_value / 1000).to_num::<u64>()
+            alpha - (2 * fee),
+            epsilon = alpha / 1000
         );
     });
 }
@@ -311,7 +312,8 @@ fn test_do_move_all_stake() {
         let origin_hotkey = U256::from(2);
         let destination_hotkey = U256::from(3);
         let stake_amount = DefaultMinStake::<Test>::get() * 10;
-        let fee = DefaultStakingFee::<Test>::get();
+
+        mock::setup_reserves(netuid, stake_amount * 10, stake_amount * 10);
 
         // Set up initial stake
         SubtensorModule::stake_into_subnet(
@@ -349,14 +351,15 @@ fn test_do_move_all_stake() {
             ),
             0
         );
+        let fee = <Test as Config>::SwapInterface::approx_fee_amount(netuid, alpha);
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
                 &destination_hotkey,
                 &coldkey,
                 netuid
             ),
-            stake_amount - 2 * fee,
-            epsilon = stake_amount / 1000
+            alpha - (2 * fee),
+            epsilon = alpha / 1000
         );
     });
 }
@@ -371,7 +374,7 @@ fn test_do_move_half_stake() {
         let origin_hotkey = U256::from(2);
         let destination_hotkey = U256::from(3);
         let stake_amount = DefaultMinStake::<Test>::get() * 10;
-        let fee = DefaultStakingFee::<Test>::get();
+        mock::setup_reserves(netuid, stake_amount * 100, stake_amount * 100);
 
         // Set up initial stake
         SubtensorModule::stake_into_subnet(
@@ -410,6 +413,7 @@ fn test_do_move_half_stake() {
             alpha / 2,
             epsilon = alpha / 1000
         );
+        let fee = <Test as Config>::SwapInterface::approx_fee_amount(netuid, alpha);
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
                 &destination_hotkey,
@@ -435,7 +439,7 @@ fn test_do_move_partial_stake() {
         let origin_hotkey = U256::from(2);
         let destination_hotkey = U256::from(3);
         let total_stake = DefaultMinStake::<Test>::get() * 10;
-        let fee = DefaultStakingFee::<Test>::get();
+        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         // Set up initial stake
         SubtensorModule::stake_into_subnet(
@@ -498,7 +502,7 @@ fn test_do_move_multiple_times() {
         let hotkey1 = U256::from(2);
         let hotkey2 = U256::from(3);
         let initial_stake = DefaultMinStake::<Test>::get() * 10;
-        let fee = DefaultStakingFee::<Test>::get();
+        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         // Set up initial stake
         SubtensorModule::create_account_if_non_existent(&coldkey, &hotkey1);
@@ -628,7 +632,7 @@ fn test_do_move_same_hotkey() {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
         let stake_amount = DefaultMinStake::<Test>::get() * 10;
-        let fee = DefaultStakingFee::<Test>::get();
+        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         // Set up initial stake
         SubtensorModule::create_account_if_non_existent(&coldkey, &hotkey);
@@ -675,7 +679,6 @@ fn test_do_move_event_emission() {
         let origin_hotkey = U256::from(2);
         let destination_hotkey = U256::from(3);
         let stake_amount = DefaultMinStake::<Test>::get() * 10;
-        let fee = DefaultStakingFee::<Test>::get();
 
         // Set up initial stake
         SubtensorModule::create_account_if_non_existent(&coldkey, &origin_hotkey);
@@ -705,6 +708,8 @@ fn test_do_move_event_emission() {
             alpha,
         ));
 
+        let fee = <Test as Config>::SwapInterface::approx_fee_amount(netuid, stake_amount);
+
         // Check for the correct event emission
         System::assert_last_event(
             Event::StakeMoved(
@@ -713,7 +718,7 @@ fn test_do_move_event_emission() {
                 netuid,
                 destination_hotkey,
                 netuid,
-                stake_amount - fee - 1, // Should be TAO equivalent
+                stake_amount - fee * 2, // Should be TAO equivalent
             )
             .into(),
         );
@@ -734,7 +739,7 @@ fn test_do_move_storage_updates() {
         let origin_hotkey = U256::from(2);
         let destination_hotkey = U256::from(3);
         let stake_amount = DefaultMinStake::<Test>::get() * 10;
-        let fee = DefaultStakingFee::<Test>::get();
+        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         // Set up initial stake
         SubtensorModule::stake_into_subnet(
@@ -845,14 +850,16 @@ fn test_do_move_max_values() {
             ),
             0
         );
+		let fee = <Test as Config>::SwapInterface::approx_fee_amount(netuid, alpha);
+		let alpha_after_fee = alpha - fee;
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
                 &destination_hotkey,
                 &coldkey,
                 netuid
             ),
-            alpha,
-            epsilon = alpha / 1_000_000
+            alpha_after_fee,
+            epsilon = alpha_after_fee / 1_000_000
         );
     });
 }
@@ -864,7 +871,7 @@ fn test_moving_too_little_unstakes() {
         let hotkey_account_id = U256::from(533453);
         let coldkey_account_id = U256::from(55453);
         let amount = DefaultMinStake::<Test>::get();
-        let fee = DefaultStakingFee::<Test>::get();
+        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         //add network
         let netuid: u16 = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
@@ -901,7 +908,7 @@ fn test_do_transfer_success() {
         let subnet_owner_coldkey = U256::from(1001);
         let subnet_owner_hotkey = U256::from(1002);
         let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
-        let fee = DefaultStakingFee::<Test>::get();
+        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         // 2. Define the origin coldkey, destination coldkey, and hotkey to be used.
         let origin_coldkey = U256::from(1);
@@ -1054,7 +1061,7 @@ fn test_do_transfer_wrong_origin() {
         let destination_coldkey = U256::from(2);
         let hotkey = U256::from(3);
         let stake_amount = DefaultMinStake::<Test>::get() * 10;
-        let fee = DefaultStakingFee::<Test>::get();
+        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         SubtensorModule::create_account_if_non_existent(&origin_coldkey, &hotkey);
         SubtensorModule::add_balance_to_coldkey_account(&origin_coldkey, stake_amount + fee);
@@ -1131,7 +1138,7 @@ fn test_do_transfer_different_subnets() {
         let destination_coldkey = U256::from(2);
         let hotkey = U256::from(3);
         let stake_amount = DefaultMinStake::<Test>::get() * 10;
-        let fee = DefaultStakingFee::<Test>::get();
+        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         // 3. Create accounts if needed.
         SubtensorModule::create_account_if_non_existent(&origin_coldkey, &hotkey);
@@ -1202,7 +1209,7 @@ fn test_do_swap_success() {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
         let stake_amount = DefaultMinStake::<Test>::get() * 10;
-        let fee = DefaultStakingFee::<Test>::get();
+        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         SubtensorModule::create_account_if_non_existent(&coldkey, &hotkey);
         SubtensorModule::stake_into_subnet(
@@ -1419,7 +1426,7 @@ fn test_do_swap_same_subnet() {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
         let stake_amount = DefaultMinStake::<Test>::get() * 10;
-        let fee = DefaultStakingFee::<Test>::get();
+        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         SubtensorModule::create_account_if_non_existent(&coldkey, &hotkey);
         SubtensorModule::stake_into_subnet(
@@ -1470,7 +1477,7 @@ fn test_do_swap_partial_stake() {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
         let total_stake = DefaultMinStake::<Test>::get() * 10;
-        let fee = DefaultStakingFee::<Test>::get();
+        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         SubtensorModule::create_account_if_non_existent(&coldkey, &hotkey);
         SubtensorModule::stake_into_subnet(
@@ -1529,7 +1536,7 @@ fn test_do_swap_storage_updates() {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
         let stake_amount = DefaultMinStake::<Test>::get() * 10;
-        let fee = DefaultStakingFee::<Test>::get();
+        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         SubtensorModule::create_account_if_non_existent(&coldkey, &hotkey);
         SubtensorModule::stake_into_subnet(
@@ -1591,7 +1598,7 @@ fn test_do_swap_multiple_times() {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
         let initial_stake = DefaultMinStake::<Test>::get() * 10;
-        let fee = DefaultStakingFee::<Test>::get();
+        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         SubtensorModule::create_account_if_non_existent(&coldkey, &hotkey);
         SubtensorModule::stake_into_subnet(
@@ -1930,7 +1937,7 @@ fn test_move_stake_specific_stake_into_subnet_fail() {
             ),
             0
         );
-        let fee = DefaultStakingFee::<Test>::get();
+        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
         let alpha_fee: U96F32 = U96F32::from_num(fee) / SubtensorModule::get_alpha_price(netuid);
         let expected_value = U96F32::from_num(alpha_to_move)
             * SubtensorModule::get_alpha_price(origin_netuid)
diff --git a/pallets/subtensor/src/tests/senate.rs b/pallets/subtensor/src/tests/senate.rs
index 5592b303be..ad60c6f9a0 100644
--- a/pallets/subtensor/src/tests/senate.rs
+++ b/pallets/subtensor/src/tests/senate.rs
@@ -67,7 +67,7 @@ fn test_senate_join_works() {
         let burn_cost = 1000;
         let coldkey_account_id = U256::from(667); // Neighbour of the beast, har har
         let stake = DefaultMinStake::<Test>::get() * 100;
-        let fee = DefaultStakingFee::<Test>::get();
+        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         //add network
         SubtensorModule::set_burn(netuid, burn_cost);
@@ -141,7 +141,7 @@ fn test_senate_vote_works() {
         let hotkey_account_id = U256::from(6);
         let burn_cost = 1000;
         let coldkey_account_id = U256::from(667); // Neighbour of the beast, har har
-        let fee = DefaultStakingFee::<Test>::get();
+        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         //add network
         SubtensorModule::set_burn(netuid, burn_cost);
@@ -315,7 +315,7 @@ fn test_senate_leave_works() {
         let burn_cost = 1000;
         let coldkey_account_id = U256::from(667); // Neighbour of the beast, har har
         let stake = DefaultMinStake::<Test>::get() * 10;
-        let fee = DefaultStakingFee::<Test>::get();
+        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         //add network
         SubtensorModule::set_burn(netuid, burn_cost);
@@ -390,7 +390,7 @@ fn test_senate_leave_vote_removal() {
         let coldkey_account_id = U256::from(667); // Neighbour of the beast, har har
         let coldkey_origin = <<Test as Config>::RuntimeOrigin>::signed(coldkey_account_id);
         let stake = DefaultMinStake::<Test>::get() * 10;
-        let fee = DefaultStakingFee::<Test>::get();
+        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         //add network
         SubtensorModule::set_burn(netuid, burn_cost);
@@ -532,7 +532,7 @@ fn test_senate_not_leave_when_stake_removed() {
         let hotkey_account_id = U256::from(6);
         let burn_cost = 1000;
         let coldkey_account_id = U256::from(667); // Neighbour of the beast, har har
-        let fee = DefaultStakingFee::<Test>::get();
+        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         //add network
         SubtensorModule::set_burn(netuid, burn_cost);
@@ -691,11 +691,11 @@ fn test_adjust_senate_events() {
         let burn_cost = 1000;
         let coldkey_account_id = U256::from(667);
         let root_netuid = SubtensorModule::get_root_netuid();
-        let fee = DefaultStakingFee::<Test>::get();
+        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         let max_senate_size: u16 = SenateMaxMembers::get() as u16;
         let stake_threshold: u64 =
-            DefaultMinStake::<Test>::get() + DefaultStakingFee::<Test>::get(); // Give this much to every senator
+            DefaultMinStake::<Test>::get() + 0; // FIXME: DefaultStakingFee is deprecated // Give this much to every senator
 
         // We will be registering MaxMembers hotkeys and two more to try a replace
         let balance_to_add = DefaultMinStake::<Test>::get() * 10
diff --git a/pallets/subtensor/src/tests/staking.rs b/pallets/subtensor/src/tests/staking.rs
index f7dfaccaf3..2de34310dc 100644
--- a/pallets/subtensor/src/tests/staking.rs
+++ b/pallets/subtensor/src/tests/staking.rs
@@ -12,6 +12,7 @@ use substrate_fixed::traits::FromFixed;
 use substrate_fixed::types::{I96F32, I110F18, U64F64, U96F32};
 use subtensor_swap_interface::{OrderType, SwapHandler};
 
+use super::mock;
 use super::mock::*;
 use crate::*;
 
@@ -43,13 +44,16 @@ fn test_add_stake_dispatch_info_ok() {
 #[test]
 fn test_add_stake_ok_no_emission() {
     new_test_ext(1).execute_with(|| {
+        // this test indicates the problem with get_alpha_price
+        // todo!("this test will fail because of get_alpha_price implementation");
         let hotkey_account_id = U256::from(533453);
         let coldkey_account_id = U256::from(55453);
         let amount = DefaultMinStake::<Test>::get() * 10;
-        let fee = DefaultStakingFee::<Test>::get();
 
         //add network
-        let netuid: u16 = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
+        let netuid = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
+
+        mock::setup_reserves(netuid, amount * 10, amount * 100);
 
         // Give it some $$$ in his coldkey balance
         SubtensorModule::add_balance_to_coldkey_account(&coldkey_account_id, amount);
@@ -67,6 +71,7 @@ fn test_add_stake_ok_no_emission() {
         );
 
         // Transfer to hotkey account, and check if the result is ok
+        let (alpha_staked, fee) = mock::swap_tao_to_alpha(netuid, amount);
         assert_ok!(SubtensorModule::add_stake(
             RuntimeOrigin::signed(coldkey_account_id),
             hotkey_account_id,
@@ -74,11 +79,17 @@ fn test_add_stake_ok_no_emission() {
             amount
         ));
 
+        let (tao_expected, _) = mock::swap_alpha_to_tao(netuid, alpha_staked);
+
+        assert_eq!(
+            SubtensorModule::get_total_stake_for_hotkey(&hotkey_account_id),
+            tao_expected
+        );
+
         // Check if stake has increased
-        assert_abs_diff_eq!(
+        assert_eq!(
             SubtensorModule::get_total_stake_for_hotkey(&hotkey_account_id),
-            amount - fee,
-            epsilon = amount / 1000,
+            amount - fee
         );
 
         // Check if balance has decreased
@@ -169,7 +180,7 @@ fn test_add_stake_not_registered_key_pair() {
         let hotkey_account_id = U256::from(54544);
         let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
         let amount = DefaultMinStake::<Test>::get() * 10;
-        let fee = DefaultStakingFee::<Test>::get();
+        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
         SubtensorModule::add_balance_to_coldkey_account(&coldkey_account_id, amount + fee);
         assert_err!(
             SubtensorModule::add_stake(
@@ -587,9 +598,10 @@ fn test_remove_stake_total_balance_no_change() {
             SubtensorModule::get_total_stake_for_hotkey(&hotkey_account_id),
             0
         );
-        assert_eq!(
+        assert_abs_diff_eq!(
             SubtensorModule::get_total_stake(),
-            SubtensorModule::get_network_min_lock() + fee
+            SubtensorModule::get_network_min_lock() + fee,
+            epsilon = 3
         );
 
         // Check total balance is equal to the added stake. Even after remove stake (no fee, includes reserved/locked balance)
@@ -605,7 +617,7 @@ fn test_add_stake_insufficient_liquidity() {
         let subnet_owner_hotkey = U256::from(1002);
         let hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let amount_staked = DefaultMinStake::<Test>::get() * 10 + DefaultStakingFee::<Test>::get();
+        let amount_staked = DefaultMinStake::<Test>::get() * 10;
 
         let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
         SubtensorModule::create_account_if_non_existent(&coldkey, &hotkey);
@@ -641,15 +653,16 @@ fn test_remove_stake_insufficient_liquidity() {
         let subnet_owner_hotkey = U256::from(1002);
         let hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let amount_staked = DefaultMinStake::<Test>::get() * 10 + DefaultStakingFee::<Test>::get();
+        let amount_staked = DefaultMinStake::<Test>::get() * 10;
 
         let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
         SubtensorModule::create_account_if_non_existent(&coldkey, &hotkey);
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, amount_staked);
 
         // Simulate stake for hotkey
-        SubnetTAO::<Test>::insert(netuid, u64::MAX / 1000);
-        SubnetAlphaIn::<Test>::insert(netuid, u64::MAX / 1000);
+        let reserve = u64::MAX / 1000;
+        mock::setup_reserves(netuid, reserve, reserve);
+
         let alpha = SubtensorModule::stake_into_subnet(
             &hotkey,
             &coldkey,
@@ -688,13 +701,14 @@ fn test_remove_stake_total_issuance_no_change() {
         let hotkey_account_id = U256::from(581337);
         let coldkey_account_id = U256::from(81337);
         let amount = DefaultMinStake::<Test>::get() * 10;
-        let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
-        let fee = DefaultStakingFee::<Test>::get();
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
         register_ok_neuron(netuid, hotkey_account_id, coldkey_account_id, 192213123);
 
         // Give it some $$$ in his coldkey balance
         SubtensorModule::add_balance_to_coldkey_account(&coldkey_account_id, amount);
 
+        mock::setup_reserves(netuid, amount * 100, amount * 100);
+
         // Some basic assertions
         assert_eq!(
             SubtensorModule::get_total_stake(),
@@ -713,6 +727,7 @@ fn test_remove_stake_total_issuance_no_change() {
         let inital_total_issuance = Balances::total_issuance();
 
         // Stake to hotkey account, and check if the result is ok
+        let (_, fee) = mock::swap_tao_to_alpha(netuid, amount);
         assert_ok!(SubtensorModule::add_stake(
             RuntimeOrigin::signed(coldkey_account_id),
             hotkey_account_id,
@@ -728,6 +743,9 @@ fn test_remove_stake_total_issuance_no_change() {
             &coldkey_account_id,
             netuid,
         );
+
+        let total_fee = mock::swap_alpha_to_tao(netuid, stake).1 + fee;
+
         assert_ok!(SubtensorModule::remove_stake(
             RuntimeOrigin::signed(coldkey_account_id),
             hotkey_account_id,
@@ -739,8 +757,8 @@ fn test_remove_stake_total_issuance_no_change() {
 
         assert_abs_diff_eq!(
             SubtensorModule::get_coldkey_balance(&coldkey_account_id),
-            amount - fee * 2,
-            epsilon = amount / 1000,
+            amount - total_fee,
+            epsilon = 1
         );
         assert_eq!(
             SubtensorModule::get_total_stake_for_hotkey(&hotkey_account_id),
@@ -748,11 +766,12 @@ fn test_remove_stake_total_issuance_no_change() {
         );
         assert_abs_diff_eq!(
             SubtensorModule::get_total_stake(),
-            fee * 2 + SubtensorModule::get_network_min_lock(),
+            total_fee + SubtensorModule::get_network_min_lock(),
             epsilon = fee / 1000
         );
 
-        // Check if total issuance is equal to the added stake, even after remove stake (no fee, includes reserved/locked balance)
+        // Check if total issuance is equal to the added stake, even after remove stake (no fee,
+        // includes reserved/locked balance)
         assert_abs_diff_eq!(
             inital_total_issuance,
             total_issuance_after_stake + amount,
@@ -763,7 +782,7 @@ fn test_remove_stake_total_issuance_no_change() {
         // so the total issuance should be lower by that amount
         assert_abs_diff_eq!(
             inital_total_issuance,
-            total_issuance_after_unstake + 2 * fee,
+            total_issuance_after_unstake + total_fee,
             epsilon = inital_total_issuance / 10000,
         );
     });
@@ -773,99 +792,68 @@ fn test_remove_stake_total_issuance_no_change() {
 #[test]
 fn test_remove_prev_epoch_stake() {
     new_test_ext(1).execute_with(|| {
-        let def_fee = DefaultStakingFee::<Test>::get();
-
         // Test case: (amount_to_stake, AlphaDividendsPerSubnet, TotalHotkeyAlphaLastEpoch, expected_fee)
         [
             // No previous epoch stake and low hotkey stake
-            (
-                DefaultMinStake::<Test>::get() * 10,
-                0_u64,
-                1000_u64,
-                def_fee * 2,
-            ),
+            (DefaultMinStake::<Test>::get() * 10, 0_u64, 1000_u64),
             // Same, but larger amount to stake - we get 0.005% for unstake
-            (
-                1_000_000_000,
-                0_u64,
-                1000_u64,
-                (1_000_000_000_f64 * 0.00005) as u64 + def_fee,
-            ),
-            (
-                100_000_000_000,
-                0_u64,
-                1000_u64,
-                (100_000_000_000_f64 * 0.00005) as u64 + def_fee,
-            ),
+            (1_000_000_000, 0_u64, 1000_u64),
+            (100_000_000_000, 0_u64, 1000_u64),
             // Lower previous epoch stake than current stake
             // Staking/unstaking 100 TAO, divs / total = 0.1 => fee is 1 TAO
-            (
-                100_000_000_000,
-                1_000_000_000_u64,
-                10_000_000_000_u64,
-                (100_000_000_000_f64 * 0.1) as u64 + def_fee,
-            ),
+            (100_000_000_000, 1_000_000_000_u64, 10_000_000_000_u64),
             // Staking/unstaking 100 TAO, divs / total = 0.001 => fee is 0.01 TAO
-            (
-                100_000_000_000,
-                10_000_000_u64,
-                10_000_000_000_u64,
-                (100_000_000_000_f64 * 0.001) as u64 + def_fee,
-            ),
+            (100_000_000_000, 10_000_000_u64, 10_000_000_000_u64),
             // Higher previous epoch stake than current stake
-            (
-                1_000_000_000,
-                100_000_000_000_u64,
-                100_000_000_000_000_u64,
-                (1_000_000_000_f64 * 0.001) as u64 + def_fee,
-            ),
+            (1_000_000_000, 100_000_000_000_u64, 100_000_000_000_000_u64),
         ]
-        .iter()
-        .for_each(
-            |(amount_to_stake, alpha_divs, hotkey_alpha, expected_fee)| {
-                let subnet_owner_coldkey = U256::from(1);
-                let subnet_owner_hotkey = U256::from(2);
-                let hotkey_account_id = U256::from(581337);
-                let coldkey_account_id = U256::from(81337);
-                let amount = *amount_to_stake;
-                let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
-                register_ok_neuron(netuid, hotkey_account_id, coldkey_account_id, 192213123);
-
-                // Give it some $$$ in his coldkey balance
-                SubtensorModule::add_balance_to_coldkey_account(&coldkey_account_id, amount);
-                AlphaDividendsPerSubnet::<Test>::insert(netuid, hotkey_account_id, *alpha_divs);
-                TotalHotkeyAlphaLastEpoch::<Test>::insert(hotkey_account_id, netuid, *hotkey_alpha);
-                let balance_before = SubtensorModule::get_coldkey_balance(&coldkey_account_id);
-
-                // Stake to hotkey account, and check if the result is ok
-                assert_ok!(SubtensorModule::add_stake(
-                    RuntimeOrigin::signed(coldkey_account_id),
-                    hotkey_account_id,
-                    netuid,
-                    amount
-                ));
-
-                // Remove all stake
-                let stake = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
-                    &hotkey_account_id,
-                    &coldkey_account_id,
-                    netuid,
-                );
+        .into_iter()
+        .for_each(|(amount_to_stake, alpha_divs, hotkey_alpha)| {
+            let subnet_owner_coldkey = U256::from(1);
+            let subnet_owner_hotkey = U256::from(2);
+            let hotkey_account_id = U256::from(581337);
+            let coldkey_account_id = U256::from(81337);
+            let amount = amount_to_stake;
+            let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+            register_ok_neuron(netuid, hotkey_account_id, coldkey_account_id, 192213123);
+
+            // Give it some $$$ in his coldkey balance
+            SubtensorModule::add_balance_to_coldkey_account(&coldkey_account_id, amount);
+            AlphaDividendsPerSubnet::<Test>::insert(netuid, hotkey_account_id, alpha_divs);
+            TotalHotkeyAlphaLastEpoch::<Test>::insert(hotkey_account_id, netuid, hotkey_alpha);
+            let balance_before = SubtensorModule::get_coldkey_balance(&coldkey_account_id);
+            mock::setup_reserves(netuid, amount_to_stake * 10, amount_to_stake * 10);
+
+            // Stake to hotkey account, and check if the result is ok
+            let (_, fee) = mock::swap_tao_to_alpha(netuid, amount);
+            assert_ok!(SubtensorModule::add_stake(
+                RuntimeOrigin::signed(coldkey_account_id),
+                hotkey_account_id,
+                netuid,
+                amount
+            ));
+
+            // Remove all stake
+            let stake = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+                &hotkey_account_id,
+                &coldkey_account_id,
+                netuid,
+            );
 
-                assert_ok!(SubtensorModule::remove_stake(
-                    RuntimeOrigin::signed(coldkey_account_id),
-                    hotkey_account_id,
-                    netuid,
-                    stake
-                ));
+            let fee = mock::swap_alpha_to_tao(netuid, stake).1 + fee;
+            assert_ok!(SubtensorModule::remove_stake(
+                RuntimeOrigin::signed(coldkey_account_id),
+                hotkey_account_id,
+                netuid,
+                stake
+            ));
 
-                // Measure actual fee
-                let balance_after = SubtensorModule::get_coldkey_balance(&coldkey_account_id);
-                let actual_fee = balance_before - balance_after;
+            // Measure actual fee
+            let balance_after = SubtensorModule::get_coldkey_balance(&coldkey_account_id);
+            let actual_fee = balance_before - balance_after;
 
-                assert_abs_diff_eq!(actual_fee, *expected_fee, epsilon = *expected_fee / 100,);
-            },
-        );
+            assert_abs_diff_eq!(actual_fee, fee, epsilon = fee / 100);
+        });
     });
 }
 
@@ -1965,7 +1953,6 @@ fn test_get_total_delegated_stake_after_unstaking() {
         let unstake_amount = DefaultMinStake::<Test>::get() * 5;
         let existential_deposit = ExistentialDeposit::get();
         let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
-        let fee = DefaultStakingFee::<Test>::get();
 
         register_ok_neuron(netuid, delegate_hotkey, delegate_coldkey, 0);
 
@@ -1973,6 +1960,7 @@ fn test_get_total_delegated_stake_after_unstaking() {
         SubtensorModule::add_balance_to_coldkey_account(&delegator, initial_stake);
 
         // Delegate stake
+        let (_, fee) = mock::swap_tao_to_alpha(netuid, initial_stake);
         assert_ok!(SubtensorModule::add_stake(
             RuntimeOrigin::signed(delegator),
             delegate_hotkey,
@@ -2053,12 +2041,14 @@ fn test_get_total_delegated_stake_single_delegator() {
         let stake_amount = DefaultMinStake::<Test>::get() * 10 - 1;
         let existential_deposit = ExistentialDeposit::get();
         let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
-        let fee = DefaultStakingFee::<Test>::get();
 
         register_ok_neuron(netuid, delegate_hotkey, delegate_coldkey, 0);
 
         // Add stake from delegator
         SubtensorModule::add_balance_to_coldkey_account(&delegator, stake_amount);
+
+        let (_, fee) = mock::swap_tao_to_alpha(netuid, stake_amount);
+
         assert_ok!(SubtensorModule::add_stake(
             RuntimeOrigin::signed(delegator),
             delegate_hotkey,
@@ -2111,7 +2101,6 @@ fn test_get_alpha_share_stake_multiple_delegators() {
         let existential_deposit = 2;
         let stake1 = DefaultMinStake::<Test>::get() * 10;
         let stake2 = DefaultMinStake::<Test>::get() * 10 - 1;
-        let fee = DefaultStakingFee::<Test>::get();
 
         let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
         register_ok_neuron(netuid, hotkey1, coldkey1, 0);
@@ -2148,7 +2137,8 @@ fn test_get_alpha_share_stake_multiple_delegators() {
         );
 
         // Calculate expected total delegated stake
-        let expected_total_stake = stake1 + stake2 - existential_deposit * 2 - fee * 2;
+        let fee = <Test as Config>::SwapInterface::approx_fee_amount(netuid, stake1 + stake2);
+        let expected_total_stake = stake1 + stake2 - existential_deposit * 2 - fee;
         let actual_total_stake = SubtensorModule::get_alpha_share_pool(hotkey1, netuid)
             .get_value(&coldkey1)
             + SubtensorModule::get_alpha_share_pool(hotkey2, netuid).get_value(&coldkey2);
@@ -2170,7 +2160,7 @@ fn test_get_total_delegated_stake_exclude_owner_stake() {
         let delegator = U256::from(3);
         let owner_stake = DefaultMinStake::<Test>::get() * 10;
         let delegator_stake = DefaultMinStake::<Test>::get() * 10 - 1;
-        let fee = DefaultStakingFee::<Test>::get();
+        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         let netuid = add_dynamic_network(&delegate_hotkey, &delegate_coldkey);
 
@@ -2339,6 +2329,7 @@ fn test_staking_too_little_fails() {
 }
 
 // cargo test --package pallet-subtensor --lib -- tests::staking::test_add_stake_fee_goes_to_subnet_tao --exact --show-output --nocapture
+#[ignore = "fee now goes to liquidity provider"]
 #[test]
 fn test_add_stake_fee_goes_to_subnet_tao() {
     new_test_ext(1).execute_with(|| {
@@ -2348,7 +2339,7 @@ fn test_add_stake_fee_goes_to_subnet_tao() {
         let coldkey = U256::from(3);
         let existential_deposit = ExistentialDeposit::get();
         let tao_to_stake = DefaultMinStake::<Test>::get() * 10;
-        let fee = DefaultStakingFee::<Test>::get();
+        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
         SubtensorModule::create_account_if_non_existent(&coldkey, &hotkey);
@@ -2386,6 +2377,7 @@ fn test_add_stake_fee_goes_to_subnet_tao() {
 }
 
 // cargo test --package pallet-subtensor --lib -- tests::staking::test_remove_stake_fee_goes_to_subnet_tao --exact --show-output --nocapture
+#[ignore = "fees no go to liquidity providers"]
 #[test]
 fn test_remove_stake_fee_goes_to_subnet_tao() {
     new_test_ext(1).execute_with(|| {
@@ -2394,7 +2386,6 @@ fn test_remove_stake_fee_goes_to_subnet_tao() {
         let hotkey = U256::from(2);
         let coldkey = U256::from(3);
         let tao_to_stake = DefaultMinStake::<Test>::get() * 10;
-        let fee = DefaultStakingFee::<Test>::get();
 
         let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
         SubtensorModule::create_account_if_non_existent(&coldkey, &hotkey);
@@ -2422,22 +2413,19 @@ fn test_remove_stake_fee_goes_to_subnet_tao() {
 
         // Subnet TAO should have increased by 2x fee as a result of staking + unstaking
         assert_abs_diff_eq!(
-            subnet_tao_before + 2 * fee,
+            subnet_tao_before,
             subnet_tao_after,
             epsilon = alpha_to_unstake / 1000
         );
 
         // User balance should decrease by 2x fee as a result of staking + unstaking
         let balance_after = SubtensorModule::get_coldkey_balance(&coldkey);
-        assert_abs_diff_eq!(
-            balance_after + 2 * fee,
-            tao_to_stake,
-            epsilon = tao_to_stake / 1000
-        );
+        assert_abs_diff_eq!(balance_after, tao_to_stake, epsilon = tao_to_stake / 1000);
     });
 }
 
 // cargo test --package pallet-subtensor --lib -- tests::staking::test_remove_stake_fee_realistic_values --exact --show-output --nocapture
+#[ignore = "fees are now calculated on the SwapInterface side"]
 #[test]
 fn test_remove_stake_fee_realistic_values() {
     new_test_ext(1).execute_with(|| {
@@ -2459,8 +2447,7 @@ fn test_remove_stake_fee_realistic_values() {
         //   This makes fee be equal ~0.0028 Alpha ~= 84000 rao
         let tao_reserve: U96F32 = U96F32::from_num(3_896_056_559_708_u64);
         let alpha_in: U96F32 = U96F32::from_num(128_011_331_299_964_u64);
-        SubnetTAO::<Test>::insert(netuid, tao_reserve.to_num::<u64>());
-        SubnetAlphaIn::<Test>::insert(netuid, alpha_in.to_num::<u64>());
+        mock::setup_reserves(netuid, tao_reserve.to_num(), alpha_in.to_num());
         AlphaDividendsPerSubnet::<Test>::insert(netuid, hotkey, alpha_divs);
         TotalHotkeyAlphaLastEpoch::<Test>::insert(hotkey, netuid, alpha_to_unstake);
 
@@ -2474,22 +2461,7 @@ fn test_remove_stake_fee_realistic_values() {
 
         // Remove stake to measure fee
         let balance_before = SubtensorModule::get_coldkey_balance(&coldkey);
-        let expected_tao_no_fee = <Test as Config>::SwapInterface::swap(
-            netuid,
-            OrderType::Sell,
-            alpha_to_unstake,
-            <Test as Config>::SwapInterface::max_price(),
-            true,
-        )
-        .unwrap()
-        .amount_paid_out;
-
-        // Estimate fees
-        let mut expected_fee =
-            expected_tao_no_fee as f64 * alpha_divs as f64 / alpha_to_unstake as f64;
-        if expected_fee < expected_tao_no_fee as f64 * 0.00005 {
-            expected_fee = expected_tao_no_fee as f64 * 0.00005;
-        }
+        let (expected_tao, expected_fee) = mock::swap_alpha_to_tao(netuid, alpha_to_unstake);
 
         assert_ok!(SubtensorModule::remove_stake(
             RuntimeOrigin::signed(coldkey),
@@ -2500,14 +2472,12 @@ fn test_remove_stake_fee_realistic_values() {
 
         // Calculate expected fee
         let balance_after = SubtensorModule::get_coldkey_balance(&coldkey);
-        let actual_fee = expected_tao_no_fee as f64 - (balance_after - balance_before) as f64;
+        // FIXME since fee is calculated by SwapInterface and the values here are after fees, the
+        // actual_fee is 0. but it's left here to discuss in review
+        let actual_fee = expected_tao - (balance_after - balance_before);
         log::info!("Actual fee: {:?}", actual_fee);
 
-        assert_abs_diff_eq!(
-            actual_fee as u64,
-            expected_fee as u64,
-            epsilon = expected_fee as u64 / 1000
-        );
+        assert_abs_diff_eq!(actual_fee, expected_fee, epsilon = expected_fee / 1000);
     });
 }
 
@@ -2518,9 +2488,15 @@ fn test_stake_below_min_validate() {
         let subnet_owner_hotkey = U256::from(1002);
         let hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let amount_staked = DefaultMinStake::<Test>::get() + DefaultStakingFee::<Test>::get() - 1;
-
         let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+        let amount_staked = {
+            let defaulte_stake = DefaultMinStake::<Test>::get();
+            let fee = <Test as Config>::SwapInterface::approx_fee_amount(netuid, defaulte_stake);
+            let min_valid_stake = defaulte_stake + fee;
+
+            min_valid_stake - 1
+        };
+
         SubtensorModule::create_account_if_non_existent(&coldkey, &hotkey);
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, amount_staked);
 
@@ -2547,7 +2523,12 @@ fn test_stake_below_min_validate() {
         );
 
         // Increase the stake to be equal to the minimum, but leave the balance low
-        let amount_staked = DefaultMinStake::<Test>::get() + DefaultStakingFee::<Test>::get();
+        let amount_staked = {
+            let defaulte_stake = DefaultMinStake::<Test>::get();
+            let fee = <Test as Config>::SwapInterface::approx_fee_amount(netuid, defaulte_stake);
+
+            defaulte_stake + fee
+        };
         let call_2 = RuntimeCall::SubtensorModule(SubtensorCall::add_stake {
             hotkey,
             netuid,
@@ -2700,17 +2681,16 @@ fn test_stake_overflow() {
         let hotkey_account_id = U256::from(54544);
         let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
         let amount = 21_000_000_000_000_000; // Max TAO supply
-        let fee = DefaultStakingFee::<Test>::get();
         register_ok_neuron(netuid, hotkey_account_id, coldkey_account_id, 192213123);
 
         // Give it some $$$ in his coldkey balance
         SubtensorModule::add_balance_to_coldkey_account(&coldkey_account_id, amount);
 
         // Setup liquidity with 21M TAO values
-        SubnetTAO::<Test>::insert(netuid, amount);
-        SubnetAlphaIn::<Test>::insert(netuid, amount);
+        mock::setup_reserves(netuid, amount, amount);
 
         // Stake and check if the result is ok
+        let (expected_alpha, _) = mock::swap_tao_to_alpha(netuid, amount);
         assert_ok!(SubtensorModule::add_stake(
             RuntimeOrigin::signed(coldkey_account_id),
             hotkey_account_id,
@@ -2718,18 +2698,17 @@ fn test_stake_overflow() {
             amount
         ));
 
-        // Check if stake has increased properly (staking 1:1 to SubnetTAO results in SubnetTAO/2 alpha)
-        assert_abs_diff_eq!(
+        // Check if stake has increased properly
+        assert_eq!(
             SubtensorModule::get_stake_for_hotkey_on_subnet(&hotkey_account_id, netuid),
-            (amount - fee) / 2,
-            epsilon = amount / 1_000_000,
+            expected_alpha
         );
 
         // Check if total stake has increased accordingly.
         assert_abs_diff_eq!(
             SubtensorModule::get_total_stake(),
             amount + SubtensorModule::get_network_min_lock(),
-            epsilon = 10
+            epsilon = 1
         );
     });
 }
@@ -2744,21 +2723,16 @@ fn test_stake_low_liquidity_validate() {
         let subnet_owner_hotkey = U256::from(1002);
         let hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let amount_staked = DefaultMinStake::<Test>::get() * 10 + DefaultStakingFee::<Test>::get();
+        let amount_staked = DefaultMinStake::<Test>::get() * 10;
 
         let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
         SubtensorModule::create_account_if_non_existent(&coldkey, &hotkey);
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, amount_staked);
 
         // Set the liquidity at lowest possible value so that all staking requests fail
-        SubnetTAO::<Test>::insert(
-            netuid,
-            DefaultMinimumPoolLiquidity::<Test>::get().to_num::<u64>(),
-        );
-        SubnetAlphaIn::<Test>::insert(
-            netuid,
-            DefaultMinimumPoolLiquidity::<Test>::get().to_num::<u64>(),
-        );
+
+        let reserve = mock::SwapMinimumReserve::get().into();
+        mock::setup_reserves(netuid, reserve, reserve);
 
         // Add stake call
         let call = RuntimeCall::SubtensorModule(SubtensorCall::add_stake {
@@ -2767,8 +2741,7 @@ fn test_stake_low_liquidity_validate() {
             amount_staked,
         });
 
-        let info: DispatchInfo =
-            DispatchInfoOf::<<Test as frame_system::Config>::RuntimeCall>::default();
+        let info = DispatchInfoOf::<<Test as frame_system::Config>::RuntimeCall>::default();
 
         let extension = SubtensorSignedExtension::<Test>::new();
         // Submit to the signed extension validate function
@@ -2794,15 +2767,16 @@ fn test_unstake_low_liquidity_validate() {
         let subnet_owner_hotkey = U256::from(1002);
         let hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let amount_staked = DefaultMinStake::<Test>::get() * 10 + DefaultStakingFee::<Test>::get();
+        let amount_staked = DefaultMinStake::<Test>::get() * 10 + 0; // FIXME: DefaultStakingFee is deprecated
 
         let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
         SubtensorModule::create_account_if_non_existent(&coldkey, &hotkey);
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, amount_staked);
 
         // Simulate stake for hotkey
-        SubnetTAO::<Test>::insert(netuid, u64::MAX / 1000);
-        SubnetAlphaIn::<Test>::insert(netuid, u64::MAX / 1000);
+        let reserve = u64::MAX / 1000;
+        mock::setup_reserves(netuid, reserve, reserve);
+
         let alpha = SubtensorModule::stake_into_subnet(
             &hotkey,
             &coldkey,
@@ -2813,14 +2787,8 @@ fn test_unstake_low_liquidity_validate() {
         .unwrap();
 
         // Set the liquidity at lowest possible value so that all staking requests fail
-        SubnetTAO::<Test>::insert(
-            netuid,
-            DefaultMinimumPoolLiquidity::<Test>::get().to_num::<u64>(),
-        );
-        SubnetAlphaIn::<Test>::insert(
-            netuid,
-            DefaultMinimumPoolLiquidity::<Test>::get().to_num::<u64>(),
-        );
+        let reserve = DefaultMinimumPoolLiquidity::<Test>::get().to_num::<u64>();
+        mock::setup_reserves(netuid, reserve, reserve);
 
         // Remove stake call
         let call = RuntimeCall::SubtensorModule(SubtensorCall::remove_stake {
@@ -2829,8 +2797,7 @@ fn test_unstake_low_liquidity_validate() {
             amount_unstaked: alpha,
         });
 
-        let info: DispatchInfo =
-            DispatchInfoOf::<<Test as frame_system::Config>::RuntimeCall>::default();
+        let info = DispatchInfoOf::<<Test as frame_system::Config>::RuntimeCall>::default();
 
         let extension = SubtensorSignedExtension::<Test>::new();
         // Submit to the signed extension validate function
@@ -3650,17 +3617,15 @@ fn test_add_stake_limit_ok() {
         let hotkey_account_id = U256::from(533453);
         let coldkey_account_id = U256::from(55453);
         let amount = 900_000_000_000; // over the maximum
-        let fee = DefaultStakingFee::<Test>::get();
 
         // add network
         let netuid: u16 = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
 
         // Forse-set alpha in and tao reserve to make price equal 1.5
-        let tao_reserve: U96F32 = U96F32::from_num(150_000_000_000_u64);
-        let alpha_in: U96F32 = U96F32::from_num(100_000_000_000_u64);
-        SubnetTAO::<Test>::insert(netuid, tao_reserve.to_num::<u64>());
-        SubnetAlphaIn::<Test>::insert(netuid, alpha_in.to_num::<u64>());
-        let current_price: U96F32 = U96F32::from_num(SubtensorModule::get_alpha_price(netuid));
+        let tao_reserve = U96F32::from_num(150_000_000_000_u64);
+        let alpha_in = U96F32::from_num(100_000_000_000_u64);
+        mock::setup_reserves(netuid, tao_reserve.to_num(), alpha_in.to_num());
+        let current_price = U96F32::from_num(SubtensorModule::get_alpha_price(netuid));
         assert_eq!(current_price, U96F32::from_num(1.5));
 
         // Give it some $$$ in his coldkey balance
@@ -3689,7 +3654,7 @@ fn test_add_stake_limit_ok() {
                 &coldkey_account_id,
                 netuid
             ),
-            expected_executed_stake - fee,
+            expected_executed_stake,
             epsilon = expected_executed_stake / 1000,
         );
 
@@ -3706,7 +3671,7 @@ fn test_add_stake_limit_ok() {
         assert_abs_diff_eq!(
             exp_price.to_num::<f64>(),
             current_price.to_num::<f64>(),
-            epsilon = 0.0001,
+            epsilon = 0.2, // because of the new swap, epsilon should be quite big
         );
     });
 }
@@ -3770,7 +3735,7 @@ fn test_remove_stake_limit_ok() {
         let coldkey_account_id = U256::from(55453);
         let stake_amount = 300_000_000_000;
         let unstake_amount = 150_000_000_000;
-        let fee = DefaultStakingFee::<Test>::get();
+        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         // add network
         let netuid: u16 = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
@@ -3951,7 +3916,7 @@ fn test_remove_stake_limit_fill_or_kill() {
 //         let alpha_in = 15_358_708_513_716;
 
 //         let tao_staked = 200_000_000;
-//         let fee = DefaultStakingFee::<Test>::get();
+//         let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
 //         //add network
 //         let netuid: u16 = add_dynamic_network(&sn_owner_coldkey, &sn_owner_coldkey);
@@ -4093,7 +4058,7 @@ fn test_remove_99_9991_per_cent_stake_removes_all() {
         let coldkey_account_id = U256::from(81337);
         let amount = 10_000_000_000;
         let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
-        let mut fee = DefaultStakingFee::<Test>::get();
+        let mut fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
         register_ok_neuron(netuid, hotkey_account_id, coldkey_account_id, 192213123);
 
         // Give it some $$$ in his coldkey balance
@@ -4151,13 +4116,13 @@ fn test_remove_99_9989_per_cent_stake_leaves_a_little() {
         let coldkey_account_id = U256::from(81337);
         let amount = 10_000_000_000;
         let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
-        let fee = DefaultStakingFee::<Test>::get();
         register_ok_neuron(netuid, hotkey_account_id, coldkey_account_id, 192213123);
 
         // Give it some $$$ in his coldkey balance
         SubtensorModule::add_balance_to_coldkey_account(&coldkey_account_id, amount);
 
         // Stake to hotkey account, and check if the result is ok
+        let (_, fee) = mock::swap_tao_to_alpha(netuid, amount);
         assert_ok!(SubtensorModule::add_stake(
             RuntimeOrigin::signed(coldkey_account_id),
             hotkey_account_id,
@@ -4171,6 +4136,7 @@ fn test_remove_99_9989_per_cent_stake_leaves_a_little() {
             &coldkey_account_id,
             netuid,
         );
+        let fee = mock::swap_alpha_to_tao(netuid, (alpha as f64 * 0.99) as u64).1 + fee;
         assert_ok!(SubtensorModule::remove_stake(
             RuntimeOrigin::signed(coldkey_account_id),
             hotkey_account_id,
@@ -4179,9 +4145,10 @@ fn test_remove_99_9989_per_cent_stake_leaves_a_little() {
         ));
 
         // Check that all alpha was unstaked and 99% TAO balance was returned (less fees)
+        // let fee = <Test as Config>::SwapInterface::approx_fee_amount(netuid, (amount as f64 * 0.99) as u64);
         assert_abs_diff_eq!(
             SubtensorModule::get_coldkey_balance(&coldkey_account_id),
-            (amount as f64 * 0.99) as u64 - fee * 2,
+            (amount as f64 * 0.99) as u64 - fee,
             epsilon = amount / 1000,
         );
         assert_abs_diff_eq!(
@@ -4366,6 +4333,7 @@ fn test_unstake_all_alpha_works() {
 
         let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
         register_ok_neuron(netuid, hotkey, coldkey, 192213123);
+
         // Give the neuron some stake to remove
         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
             &hotkey,
@@ -4375,17 +4343,16 @@ fn test_unstake_all_alpha_works() {
         );
 
         // Setup the Alpha pool so that removing all the Alpha will keep liq above min
-        let remaining_tao: I96F32 =
+        let remaining_tao =
             DefaultMinimumPoolLiquidity::<Test>::get().saturating_add(I96F32::from(10_000_000));
-        let alpha_reserves: I110F18 = I110F18::from(stake_amount + 10_000_000);
+        let alpha_reserves = I110F18::from(stake_amount + 10_000_000);
         let alpha = stake_amount;
 
-        let k: I110F18 = I110F18::from_fixed(remaining_tao)
+        let k = I110F18::from_fixed(remaining_tao)
             .saturating_mul(alpha_reserves.saturating_add(I110F18::from(alpha)));
-        let tao_reserves: I110F18 = k.safe_div(alpha_reserves);
+        let tao_reserves = k.safe_div(alpha_reserves);
 
-        SubnetTAO::<Test>::insert(netuid, tao_reserves.to_num::<u64>());
-        SubnetAlphaIn::<Test>::insert(netuid, alpha_reserves.to_num::<u64>());
+        mock::setup_reserves(netuid, tao_reserves.to_num(), alpha_reserves.to_num());
 
         // Unstake all alpha to root
         assert_ok!(SubtensorModule::unstake_all_alpha(
diff --git a/pallets/subtensor/src/tests/staking2.rs b/pallets/subtensor/src/tests/staking2.rs
index 1ea686c98b..d77eb1e944 100644
--- a/pallets/subtensor/src/tests/staking2.rs
+++ b/pallets/subtensor/src/tests/staking2.rs
@@ -1,5 +1,3 @@
-use super::mock::*;
-use crate::*;
 use frame_support::{
     assert_ok,
     dispatch::{GetDispatchInfo, Pays},
@@ -9,6 +7,10 @@ use sp_core::U256;
 use substrate_fixed::types::{I96F32, U96F32};
 use subtensor_swap_interface::SwapHandler;
 
+use super::mock;
+use super::mock::*;
+use crate::*;
+
 // SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --workspace --test staking2 -- test_swap_tao_for_alpha_dynamic_mechanism --exact --nocapture
 #[test]
 fn test_stake_base_case() {
@@ -22,14 +24,14 @@ fn test_stake_base_case() {
         // Initialize subnet with some existing TAO and Alpha
         let initial_subnet_tao = 10_000_000_000; // 10 TAO
         let initial_subnet_alpha = 5_000_000_000; // 5 Alpha
-        SubnetTAO::<Test>::insert(netuid, initial_subnet_tao);
-        SubnetAlphaIn::<Test>::insert(netuid, initial_subnet_alpha);
+        mock::setup_reserves(netuid, initial_subnet_tao, initial_subnet_alpha);
         SubnetAlphaOut::<Test>::insert(netuid, initial_subnet_alpha);
 
         // Record initial total stake
         let initial_total_stake = TotalStake::<Test>::get();
 
         // Perform swap
+        let (alpha_expected, fee) = mock::swap_tao_to_alpha(netuid, tao_to_swap);
         let alpha_received = SubtensorModule::swap_tao_for_alpha(
             netuid,
             tao_to_swap,
@@ -39,21 +41,15 @@ fn test_stake_base_case() {
         .amount_paid_out;
 
         // Verify correct alpha calculation using constant product formula
-        let k: I96F32 =
-            I96F32::from_num(initial_subnet_alpha) * I96F32::from_num(initial_subnet_tao);
-        let expected_alpha: I96F32 = I96F32::from_num(initial_subnet_alpha)
-            - (k / (I96F32::from_num(initial_subnet_tao + tao_to_swap)));
-        let expected_alpha_u64 = expected_alpha.to_num::<u64>();
-
         assert_eq!(
-            alpha_received, expected_alpha_u64,
+            alpha_received, alpha_expected,
             "Alpha received calculation is incorrect"
         );
 
         // Check subnet updates
         assert_eq!(
             SubnetTAO::<Test>::get(netuid),
-            initial_subnet_tao + tao_to_swap,
+            initial_subnet_tao + tao_to_swap - fee,
             "Subnet TAO not updated correctly"
         );
         assert_eq!(
@@ -777,13 +773,11 @@ fn test_stake_fee_api() {
     });
 }
 
+#[ignore = "fees are now calculated by SwapInterface"]
 #[test]
 fn test_stake_fee_calculation() {
     new_test_ext(1).execute_with(|| {
         let hotkey1 = U256::from(1);
-        let coldkey1 = U256::from(2);
-        let hotkey2 = U256::from(3);
-        let coldkey2 = U256::from(4);
 
         let netuid0 = 1;
         let netuid1 = 2;
@@ -798,16 +792,14 @@ fn test_stake_fee_calculation() {
         let reciprocal_price = 2; // 1 / price
         let stake_amount = 100_000_000_000_u64;
 
-        let default_fee = DefaultStakingFee::<Test>::get();
+        let default_fee = 0; // FIXME: DefaultStakingFee is deprecated
 
         // Setup alpha out
         SubnetAlphaOut::<Test>::insert(netuid0, 100_000_000_000);
         SubnetAlphaOut::<Test>::insert(netuid1, 100_000_000_000);
         // Set pools using price
-        SubnetAlphaIn::<Test>::insert(netuid0, tao_in * reciprocal_price);
-        SubnetTAO::<Test>::insert(netuid0, tao_in);
-        SubnetAlphaIn::<Test>::insert(netuid1, tao_in * reciprocal_price);
-        SubnetTAO::<Test>::insert(netuid1, tao_in);
+        mock::setup_reserves(netuid0, tao_in, tao_in * reciprocal_price);
+        mock::setup_reserves(netuid1, tao_in, tao_in * reciprocal_price);
 
         // Setup alpha divs for hotkey1
         AlphaDividendsPerSubnet::<Test>::insert(netuid0, hotkey1, alpha_divs);
diff --git a/pallets/subtensor/src/tests/subnet.rs b/pallets/subtensor/src/tests/subnet.rs
index 4ceeaab897..a6829ba586 100644
--- a/pallets/subtensor/src/tests/subnet.rs
+++ b/pallets/subtensor/src/tests/subnet.rs
@@ -1,9 +1,11 @@
-use super::mock::*;
-use crate::*;
 use frame_support::{assert_noop, assert_ok};
 use frame_system::Config;
 use sp_core::U256;
 
+use super::mock;
+use super::mock::*;
+use crate::*;
+
 /***************************
   pub fn do_start_call() tests
 *****************************/
@@ -20,6 +22,7 @@ fn test_do_start_call_ok() {
         SubtensorModule::set_burn(netuid, burn_cost);
         add_network_without_emission_block(netuid, tempo, 0);
         assert_eq!(FirstEmissionBlockNumber::<Test>::get(netuid), None);
+        mock::setup_reserves(netuid, 1_000_000_000, 1_000_000_000);
 
         // Give it some $$$ in his coldkey balance
         SubtensorModule::add_balance_to_coldkey_account(&coldkey_account_id, 10000);
@@ -75,6 +78,7 @@ fn test_do_start_call_fail_not_owner() {
         //add network
         SubtensorModule::set_burn(netuid, burn_cost);
         add_network_without_emission_block(netuid, tempo, 0);
+        mock::setup_reserves(netuid, 1_000_000_000, 1_000_000_000);
         // Give it some $$$ in his coldkey balance
         SubtensorModule::add_balance_to_coldkey_account(&coldkey_account_id, 10000);
 
@@ -110,6 +114,7 @@ fn test_do_start_call_fail_with_cannot_start_call_now() {
         //add network
         SubtensorModule::set_burn(netuid, burn_cost);
         add_network_without_emission_block(netuid, tempo, 0);
+        mock::setup_reserves(netuid, 1_000_000_000, 1_000_000_000);
         // Give it some $$$ in his coldkey balance
         SubtensorModule::add_balance_to_coldkey_account(&coldkey_account_id, 10000);
 
@@ -145,6 +150,8 @@ fn test_do_start_call_fail_for_set_again() {
         add_network_without_emission_block(netuid, tempo, 0);
         assert_eq!(FirstEmissionBlockNumber::<Test>::get(netuid), None);
 
+        mock::setup_reserves(netuid, 1_000_000_000, 1_000_000_000);
+
         // Give it some $$$ in his coldkey balance
         SubtensorModule::add_balance_to_coldkey_account(&coldkey_account_id, 10000);
 
@@ -187,6 +194,7 @@ fn test_do_start_call_ok_with_same_block_number_after_coinbase() {
         SubtensorModule::set_burn(netuid, burn_cost);
         add_network_without_emission_block(netuid, tempo, 0);
         assert_eq!(FirstEmissionBlockNumber::<Test>::get(netuid), None);
+        mock::setup_reserves(netuid, 1_000_000_000, 1_000_000_000);
 
         // Give it some $$$ in his coldkey balance
         SubtensorModule::add_balance_to_coldkey_account(&coldkey_account_id, 10000);
diff --git a/pallets/subtensor/src/tests/swap_coldkey.rs b/pallets/subtensor/src/tests/swap_coldkey.rs
index 6c487cfc12..02196cf63e 100644
--- a/pallets/subtensor/src/tests/swap_coldkey.rs
+++ b/pallets/subtensor/src/tests/swap_coldkey.rs
@@ -353,7 +353,7 @@ fn test_swap_with_max_values() {
         let netuid2 = 2u16;
         let stake = 10_000;
         let max_stake = 21_000_000_000_000_000; // 21 Million TAO; max possible balance.
-        let fee = DefaultStakingFee::<Test>::get();
+        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         // Add a network
         add_network(netuid, 1, 0);
diff --git a/pallets/subtensor/src/tests/swap_hotkey.rs b/pallets/subtensor/src/tests/swap_hotkey.rs
index a82972c2f7..059e489a04 100644
--- a/pallets/subtensor/src/tests/swap_hotkey.rs
+++ b/pallets/subtensor/src/tests/swap_hotkey.rs
@@ -5,12 +5,14 @@ use codec::Encode;
 use frame_support::weights::Weight;
 use frame_support::{assert_err, assert_noop, assert_ok};
 use frame_system::{Config, RawOrigin};
-
-use super::mock::*;
-use crate::*;
 use sp_core::{Get, H256, U256};
 use sp_runtime::SaturatedConversion;
 use substrate_fixed::types::U64F64;
+use subtensor_swap_interface::SwapHandler;
+
+use super::mock;
+use super::mock::*;
+use crate::*;
 
 // SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey -- test_swap_owner --exact --nocapture
 #[test]
@@ -66,15 +68,18 @@ fn test_swap_total_hotkey_stake() {
         let coldkey = U256::from(3);
         let amount = DefaultMinStake::<Test>::get() * 10;
         let mut weight = Weight::zero();
-        let fee = DefaultStakingFee::<Test>::get();
 
         //add network
-        let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
+        let netuid = add_dynamic_network(&old_hotkey, &coldkey);
+
+        mock::setup_reserves(netuid, amount * 100, amount * 100);
 
         // Give it some $$$ in his coldkey balance
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, amount);
 
         // Add stake
+        let (expected_alpha, _) = mock::swap_tao_to_alpha(netuid, amount);
+		assert!(expected_alpha > 0);
         assert_ok!(SubtensorModule::add_stake(
             RuntimeOrigin::signed(coldkey),
             old_hotkey,
@@ -83,11 +88,7 @@ fn test_swap_total_hotkey_stake() {
         ));
 
         // Check if stake has increased
-        assert_abs_diff_eq!(
-            SubtensorModule::get_total_stake_for_hotkey(&old_hotkey),
-            amount - fee,
-            epsilon = amount / 1000,
-        );
+        assert_eq!(TotalHotkeyAlpha::<Test>::get(old_hotkey, netuid), expected_alpha);
         assert_abs_diff_eq!(
             SubtensorModule::get_total_stake_for_hotkey(&new_hotkey),
             0,
@@ -108,11 +109,7 @@ fn test_swap_total_hotkey_stake() {
             0,
             epsilon = 1,
         );
-        assert_abs_diff_eq!(
-            SubtensorModule::get_total_stake_for_hotkey(&new_hotkey),
-            amount - fee,
-            epsilon = amount / 1000,
-        );
+        assert_eq!(TotalHotkeyAlpha::<Test>::get(new_hotkey, netuid), expected_alpha);
     });
 }
 
@@ -600,6 +597,9 @@ fn test_swap_hotkey_with_multiple_coldkeys_and_subnets() {
         register_ok_neuron(netuid1, old_hotkey, coldkey1, 1234);
         register_ok_neuron(netuid2, old_hotkey, coldkey1, 1234);
 
+        mock::setup_reserves(netuid1, stake * 100, stake * 100);
+        mock::setup_reserves(netuid2, stake * 100, stake * 100);
+
         // Add balance to both coldkeys
         SubtensorModule::add_balance_to_coldkey_account(&coldkey1, stake + 1_000);
         SubtensorModule::add_balance_to_coldkey_account(&coldkey2, stake + 1_000);
diff --git a/pallets/subtensor/src/tests/weights.rs b/pallets/subtensor/src/tests/weights.rs
index 14b80a0310..4da941cdc9 100644
--- a/pallets/subtensor/src/tests/weights.rs
+++ b/pallets/subtensor/src/tests/weights.rs
@@ -1,6 +1,7 @@
 #![allow(clippy::indexing_slicing)]
 
 use super::mock::*;
+use super::mock;
 use crate::coinbase::run_coinbase::WeightsTlockPayload;
 use crate::*;
 use ark_serialize::CanonicalDeserialize;
@@ -69,7 +70,7 @@ fn test_set_rootweights_validate() {
         let coldkey = U256::from(0);
         let hotkey: U256 = U256::from(1); // Add the hotkey field
         assert_ne!(hotkey, coldkey); // Ensure hotkey is NOT the same as coldkey !!!
-        let fee = DefaultStakingFee::<Test>::get();
+        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         let who = coldkey; // The coldkey signs this transaction
 
@@ -186,7 +187,7 @@ fn test_commit_weights_validate() {
         let coldkey = U256::from(0);
         let hotkey: U256 = U256::from(1); // Add the hotkey field
         assert_ne!(hotkey, coldkey); // Ensure hotkey is NOT the same as coldkey !!!
-        let fee = DefaultStakingFee::<Test>::get();
+        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         let who = hotkey; // The hotkey signs this transaction
 
@@ -207,6 +208,9 @@ fn test_commit_weights_validate() {
         SubtensorModule::add_balance_to_coldkey_account(&hotkey, u64::MAX);
 
         let min_stake = 500_000_000_000;
+
+		mock::setup_reserves(netuid, min_stake * 100, min_stake * 10);
+
         // Set the minimum stake
         SubtensorModule::set_stake_threshold(min_stake);
 
@@ -296,7 +300,7 @@ fn test_set_weights_validate() {
         let coldkey = U256::from(0);
         let hotkey: U256 = U256::from(1);
         assert_ne!(hotkey, coldkey);
-        let fee = DefaultStakingFee::<Test>::get();
+        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         let who = hotkey; // The hotkey signs this transaction
 
@@ -309,6 +313,7 @@ fn test_set_weights_validate() {
 
         // Create netuid
         add_network(netuid, 1, 0);
+		mock::setup_reserves(netuid, 1_000_000_000_000, 1_000_000_000_000);
         // Register the hotkey
         SubtensorModule::append_neuron(netuid, &hotkey, 0);
         crate::Owner::<Test>::insert(hotkey, coldkey);
@@ -371,7 +376,7 @@ fn test_reveal_weights_validate() {
         let coldkey = U256::from(0);
         let hotkey: U256 = U256::from(1); // Add the hotkey field
         assert_ne!(hotkey, coldkey); // Ensure hotkey is NOT the same as coldkey !!!
-        let fee = DefaultStakingFee::<Test>::get();
+        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         let who = hotkey; // The hotkey signs this transaction
 

From f79aef9e703094fb58c7b24f80207ba05a201f11 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Thu, 1 May 2025 17:38:50 +0800
Subject: [PATCH 087/418] fix test case

---
 pallets/subtensor/src/swap/swap_hotkey.rs  | 103 ++++++++++++---------
 pallets/subtensor/src/tests/swap_hotkey.rs |  11 ++-
 2 files changed, 67 insertions(+), 47 deletions(-)

diff --git a/pallets/subtensor/src/swap/swap_hotkey.rs b/pallets/subtensor/src/swap/swap_hotkey.rs
index a9fc3c23bb..b16996d5b5 100644
--- a/pallets/subtensor/src/swap/swap_hotkey.rs
+++ b/pallets/subtensor/src/swap/swap_hotkey.rs
@@ -1,7 +1,6 @@
 use super::*;
 use frame_support::weights::Weight;
 use sp_core::Get;
-use substrate_fixed::types::U64F64;
 
 impl<T: Config> Pallet<T> {
     /// Swaps the hotkey of a coldkey account.
@@ -64,6 +63,25 @@ impl<T: Config> Pallet<T> {
 
         // following update just for swap hotkey in all subnets case
 
+        // 4. Ensure the new hotkey is not already registered on any network
+        ensure!(
+            !Self::is_hotkey_registered_on_any_network(new_hotkey),
+            Error::<T>::HotKeyAlreadyRegisteredInSubNet
+        );
+
+        // 10. Get the cost for swapping the key
+        let swap_cost = Self::get_key_swap_cost();
+        log::debug!("Swap cost: {:?}", swap_cost);
+
+        // 11. Ensure the coldkey has enough balance to pay for the swap
+        ensure!(
+            Self::can_remove_balance_from_coldkey_account(&coldkey, swap_cost),
+            Error::<T>::NotEnoughBalanceToPaySwapHotKey
+        );
+
+        // 12. Remove the swap cost from the coldkey's account
+        let actual_burn_amount = Self::remove_balance_from_coldkey_account(&coldkey, swap_cost)?;
+
         // 9. Swap LastTxBlock
         // LastTxBlock( hotkey ) --> u64 -- the last transaction block for the hotkey.
         let last_tx_block: u64 = LastTxBlock::<T>::get(old_hotkey);
@@ -101,25 +119,6 @@ impl<T: Config> Pallet<T> {
             weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 2));
         }
 
-        // 4. Ensure the new hotkey is not already registered on any network
-        ensure!(
-            !Self::is_hotkey_registered_on_any_network(new_hotkey),
-            Error::<T>::HotKeyAlreadyRegisteredInSubNet
-        );
-
-        // 10. Get the cost for swapping the key
-        let swap_cost = Self::get_key_swap_cost();
-        log::debug!("Swap cost: {:?}", swap_cost);
-
-        // 11. Ensure the coldkey has enough balance to pay for the swap
-        ensure!(
-            Self::can_remove_balance_from_coldkey_account(&coldkey, swap_cost),
-            Error::<T>::NotEnoughBalanceToPaySwapHotKey
-        );
-
-        // 12. Remove the swap cost from the coldkey's account
-        let actual_burn_amount = Self::remove_balance_from_coldkey_account(&coldkey, swap_cost)?;
-
         // 13. Burn the tokens
         Self::burn_tokens(actual_burn_amount);
 
@@ -195,13 +194,17 @@ impl<T: Config> Pallet<T> {
         if !hotkeys.contains(new_hotkey) {
             hotkeys.push(new_hotkey.clone());
         }
+
         // Remove the old key.
         hotkeys.retain(|hk| *hk != *old_hotkey);
         OwnedHotkeys::<T>::insert(coldkey, hotkeys);
+
         weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
 
         for netuid in Self::get_all_subnet_netuids() {
-            Self::perform_hotkey_swap_on_one_subnet(old_hotkey, new_hotkey, weight, netuid);
+            Self::perform_hotkey_swap_on_one_subnet(
+                coldkey, old_hotkey, new_hotkey, weight, netuid,
+            );
         }
 
         // 5. Swap LastTxBlock
@@ -241,6 +244,17 @@ impl<T: Config> Pallet<T> {
             weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 2));
         }
 
+        // Swap StakingHotkeys.
+        // StakingHotkeys( coldkey ) --> Vec<hotkey> -- the hotkeys that the coldkey stakes.
+        let mut staking_hotkeys = StakingHotkeys::<T>::get(&coldkey);
+        weight.saturating_accrue(T::DbWeight::get().reads(1));
+        if staking_hotkeys.contains(old_hotkey) {
+            staking_hotkeys.retain(|hk| *hk != *old_hotkey && *hk != *new_hotkey);
+            staking_hotkeys.push(new_hotkey.clone());
+            StakingHotkeys::<T>::insert(&coldkey, staking_hotkeys);
+            weight.saturating_accrue(T::DbWeight::get().writes(1));
+        }
+
         // Return successful after swapping all the relevant terms.
         Ok(())
     }
@@ -311,7 +325,13 @@ impl<T: Config> Pallet<T> {
         // hotkeys.retain(|hk| *hk != *old_hotkey);
 
         // 14. Perform the hotkey swap
-        Self::perform_hotkey_swap_on_one_subnet(old_hotkey, new_hotkey, &mut weight, netuid);
+        Self::perform_hotkey_swap_on_one_subnet(
+            coldkey,
+            old_hotkey,
+            new_hotkey,
+            &mut weight,
+            netuid,
+        );
 
         let block: u64 = Self::get_current_block_as_u64();
         // 15. Update the last transaction block for the coldkey
@@ -331,6 +351,7 @@ impl<T: Config> Pallet<T> {
 
     // do hotkey swap public part for both swap all subnets and just swap one subnet
     pub fn perform_hotkey_swap_on_one_subnet(
+        coldkey: &T::AccountId,
         old_hotkey: &T::AccountId,
         new_hotkey: &T::AccountId,
         weight: &mut Weight,
@@ -341,6 +362,7 @@ impl<T: Config> Pallet<T> {
 
         let alpha = TotalHotkeyAlpha::<T>::take(old_hotkey, netuid);
         // TotalHotkeyAlpha::<T>::remove(old_hotkey, netuid);
+
         TotalHotkeyAlpha::<T>::mutate(new_hotkey, netuid, |value| {
             *value = value.saturating_add(alpha)
         });
@@ -435,37 +457,28 @@ impl<T: Config> Pallet<T> {
                 weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
             }
         }
+
         // });
 
         // 11. Swap Alpha
         // Alpha( hotkey, coldkey, netuid ) -> alpha
-        let old_alpha_values: Vec<((T::AccountId, u16), U64F64)> =
-            Alpha::<T>::iter_prefix((old_hotkey,)).collect();
+        // let old_alpha_values: Vec<((T::AccountId, u16), U64F64)> =
+        //     Alpha::<T>::iter_prefix((old_hotkey,)).collect();
         // Clear the entire old prefix here.
-        let _ = Alpha::<T>::clear_prefix((old_hotkey,), old_alpha_values.len() as u32, None);
-        weight.saturating_accrue(T::DbWeight::get().reads(old_alpha_values.len() as u64));
-        weight.saturating_accrue(T::DbWeight::get().writes(old_alpha_values.len() as u64));
+        // let _ = Alpha::<T>::clear_prefix((old_hotkey,), old_alpha_values.len() as u32, None);
+
+        let alpha_value = Alpha::<T>::take((old_hotkey, &coldkey, netuid));
+
+        weight.saturating_accrue(T::DbWeight::get().reads(1_u64));
+        weight.saturating_accrue(T::DbWeight::get().writes(1_u64));
 
         // Insert the new alpha values.
-        for ((coldkey, netuid), alpha) in old_alpha_values {
-            let new_alpha = Alpha::<T>::get((new_hotkey, &coldkey, netuid));
-            Alpha::<T>::insert(
-                (new_hotkey, &coldkey, netuid),
-                new_alpha.saturating_add(alpha),
-            );
-            weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
+        // for ((coldkey, netuid), alpha) in old_alpha_values {
+        //     let new_alpha = Alpha::<T>::get((new_hotkey, &coldkey, netuid));
+        Alpha::<T>::insert((new_hotkey, &coldkey, netuid), alpha_value);
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
 
-            // Swap StakingHotkeys.
-            // StakingHotkeys( coldkey ) --> Vec<hotkey> -- the hotkeys that the coldkey stakes.
-            let mut staking_hotkeys = StakingHotkeys::<T>::get(&coldkey);
-            weight.saturating_accrue(T::DbWeight::get().reads(1));
-            if staking_hotkeys.contains(old_hotkey) {
-                staking_hotkeys.retain(|hk| *hk != *old_hotkey && *hk != *new_hotkey);
-                staking_hotkeys.push(new_hotkey.clone());
-                StakingHotkeys::<T>::insert(&coldkey, staking_hotkeys);
-                weight.saturating_accrue(T::DbWeight::get().writes(1));
-            }
-        }
+        // }
 
         // 12. Swap ChildKeys.
         // ChildKeys( parent, netuid ) --> Vec<(proportion,child)> -- the child keys of the parent.
diff --git a/pallets/subtensor/src/tests/swap_hotkey.rs b/pallets/subtensor/src/tests/swap_hotkey.rs
index be5e8b6b17..27c60cc6b1 100644
--- a/pallets/subtensor/src/tests/swap_hotkey.rs
+++ b/pallets/subtensor/src/tests/swap_hotkey.rs
@@ -376,8 +376,12 @@ fn test_swap_staking_hotkeys() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
+
+        let subnet_owner_coldkey = U256::from(1001);
+        let subnet_owner_hotkey = U256::from(1002);
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+
         let mut weight = Weight::zero();
-        let netuid = 1;
 
         StakingHotkeys::<Test>::insert(coldkey, vec![old_hotkey]);
         Alpha::<Test>::insert((old_hotkey, coldkey, netuid), U64F64::from_num(100));
@@ -982,9 +986,12 @@ fn test_swap_stake_old_hotkey_not_exist() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
+        let subnet_owner_coldkey = U256::from(1001);
+        let subnet_owner_hotkey = U256::from(1002);
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+
         let alpha_share = U64F64::from_num(1234);
         let mut weight = Weight::zero();
-        let netuid = 1;
 
         // Initialize Stake for old_hotkey
         Alpha::<Test>::insert((old_hotkey, coldkey, netuid), alpha_share);

From b29e18db1aaaa7580331123b9b8a8e69eaceaaa5 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Thu, 1 May 2025 17:40:58 +0800
Subject: [PATCH 088/418] cargo clippy

---
 pallets/subtensor/src/swap/swap_hotkey.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pallets/subtensor/src/swap/swap_hotkey.rs b/pallets/subtensor/src/swap/swap_hotkey.rs
index b16996d5b5..6ac43656ba 100644
--- a/pallets/subtensor/src/swap/swap_hotkey.rs
+++ b/pallets/subtensor/src/swap/swap_hotkey.rs
@@ -246,12 +246,12 @@ impl<T: Config> Pallet<T> {
 
         // Swap StakingHotkeys.
         // StakingHotkeys( coldkey ) --> Vec<hotkey> -- the hotkeys that the coldkey stakes.
-        let mut staking_hotkeys = StakingHotkeys::<T>::get(&coldkey);
+        let mut staking_hotkeys = StakingHotkeys::<T>::get(coldkey);
         weight.saturating_accrue(T::DbWeight::get().reads(1));
         if staking_hotkeys.contains(old_hotkey) {
             staking_hotkeys.retain(|hk| *hk != *old_hotkey && *hk != *new_hotkey);
             staking_hotkeys.push(new_hotkey.clone());
-            StakingHotkeys::<T>::insert(&coldkey, staking_hotkeys);
+            StakingHotkeys::<T>::insert(coldkey, staking_hotkeys);
             weight.saturating_accrue(T::DbWeight::get().writes(1));
         }
 

From d93720929f9ffea0d8c439f6ac21c1ca6a08c0be Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Thu, 1 May 2025 19:44:01 +0800
Subject: [PATCH 089/418] fix test cases

---
 pallets/subtensor/src/staking/helpers.rs  |  6 ++-
 pallets/subtensor/src/swap/swap_hotkey.rs | 52 ++++++++++++++---------
 2 files changed, 35 insertions(+), 23 deletions(-)

diff --git a/pallets/subtensor/src/staking/helpers.rs b/pallets/subtensor/src/staking/helpers.rs
index 9ee04f36a8..24accfc9ca 100644
--- a/pallets/subtensor/src/staking/helpers.rs
+++ b/pallets/subtensor/src/staking/helpers.rs
@@ -60,7 +60,7 @@ impl<T: Config> Pallet<T> {
     //
     pub fn get_total_stake_for_coldkey(coldkey: &T::AccountId) -> u64 {
         let hotkeys = StakingHotkeys::<T>::get(coldkey);
-        hotkeys
+        let result = hotkeys
             .iter()
             .map(|hotkey| {
                 let mut total_stake: u64 = 0;
@@ -76,7 +76,9 @@ impl<T: Config> Pallet<T> {
                 }
                 total_stake
             })
-            .sum::<u64>()
+            .sum::<u64>();
+        log::error!("= ======= Total stake for coldkey {}: {}", coldkey, result);
+        result
     }
 
     // Creates a cold - hot pairing account if the hotkey is not already an active account.
diff --git a/pallets/subtensor/src/swap/swap_hotkey.rs b/pallets/subtensor/src/swap/swap_hotkey.rs
index 6ac43656ba..de5766300f 100644
--- a/pallets/subtensor/src/swap/swap_hotkey.rs
+++ b/pallets/subtensor/src/swap/swap_hotkey.rs
@@ -1,7 +1,7 @@
 use super::*;
 use frame_support::weights::Weight;
 use sp_core::Get;
-
+use substrate_fixed::types::U64F64;
 impl<T: Config> Pallet<T> {
     /// Swaps the hotkey of a coldkey account.
     ///
@@ -255,6 +255,36 @@ impl<T: Config> Pallet<T> {
             weight.saturating_accrue(T::DbWeight::get().writes(1));
         }
 
+        // 11. Swap Alpha
+        // Alpha( hotkey, coldkey, netuid ) -> alpha
+        let old_alpha_values: Vec<((T::AccountId, u16), U64F64)> =
+            Alpha::<T>::iter_prefix((old_hotkey,)).collect();
+        // Clear the entire old prefix here.
+        let _ = Alpha::<T>::clear_prefix((old_hotkey,), old_alpha_values.len() as u32, None);
+        weight.saturating_accrue(T::DbWeight::get().reads(old_alpha_values.len() as u64));
+        weight.saturating_accrue(T::DbWeight::get().writes(old_alpha_values.len() as u64));
+
+        // Insert the new alpha values.
+        for ((coldkey, netuid), alpha) in old_alpha_values {
+            let new_alpha = Alpha::<T>::get((new_hotkey, &coldkey, netuid));
+            Alpha::<T>::insert(
+                (new_hotkey, &coldkey, netuid),
+                new_alpha.saturating_add(alpha),
+            );
+            weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
+
+            // Swap StakingHotkeys.
+            // StakingHotkeys( coldkey ) --> Vec<hotkey> -- the hotkeys that the coldkey stakes.
+            let mut staking_hotkeys = StakingHotkeys::<T>::get(&coldkey);
+            weight.saturating_accrue(T::DbWeight::get().reads(1));
+            if staking_hotkeys.contains(old_hotkey) {
+                staking_hotkeys.retain(|hk| *hk != *old_hotkey && *hk != *new_hotkey);
+                staking_hotkeys.push(new_hotkey.clone());
+                StakingHotkeys::<T>::insert(&coldkey, staking_hotkeys);
+                weight.saturating_accrue(T::DbWeight::get().writes(1));
+            }
+        }
+
         // Return successful after swapping all the relevant terms.
         Ok(())
     }
@@ -458,26 +488,6 @@ impl<T: Config> Pallet<T> {
             }
         }
 
-        // });
-
-        // 11. Swap Alpha
-        // Alpha( hotkey, coldkey, netuid ) -> alpha
-        // let old_alpha_values: Vec<((T::AccountId, u16), U64F64)> =
-        //     Alpha::<T>::iter_prefix((old_hotkey,)).collect();
-        // Clear the entire old prefix here.
-        // let _ = Alpha::<T>::clear_prefix((old_hotkey,), old_alpha_values.len() as u32, None);
-
-        let alpha_value = Alpha::<T>::take((old_hotkey, &coldkey, netuid));
-
-        weight.saturating_accrue(T::DbWeight::get().reads(1_u64));
-        weight.saturating_accrue(T::DbWeight::get().writes(1_u64));
-
-        // Insert the new alpha values.
-        // for ((coldkey, netuid), alpha) in old_alpha_values {
-        //     let new_alpha = Alpha::<T>::get((new_hotkey, &coldkey, netuid));
-        Alpha::<T>::insert((new_hotkey, &coldkey, netuid), alpha_value);
-        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
-
         // }
 
         // 12. Swap ChildKeys.

From c1903a2b025c968b660203e10f7fd5acf977ac42 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Thu, 1 May 2025 20:03:41 +0800
Subject: [PATCH 090/418] fix compile error

---
 pallets/subtensor/src/staking/helpers.rs | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/pallets/subtensor/src/staking/helpers.rs b/pallets/subtensor/src/staking/helpers.rs
index 24accfc9ca..9ee04f36a8 100644
--- a/pallets/subtensor/src/staking/helpers.rs
+++ b/pallets/subtensor/src/staking/helpers.rs
@@ -60,7 +60,7 @@ impl<T: Config> Pallet<T> {
     //
     pub fn get_total_stake_for_coldkey(coldkey: &T::AccountId) -> u64 {
         let hotkeys = StakingHotkeys::<T>::get(coldkey);
-        let result = hotkeys
+        hotkeys
             .iter()
             .map(|hotkey| {
                 let mut total_stake: u64 = 0;
@@ -76,9 +76,7 @@ impl<T: Config> Pallet<T> {
                 }
                 total_stake
             })
-            .sum::<u64>();
-        log::error!("= ======= Total stake for coldkey {}: {}", coldkey, result);
-        result
+            .sum::<u64>()
     }
 
     // Creates a cold - hot pairing account if the hotkey is not already an active account.

From ee036f99e3333b722b8b0ca35f315b1d74643ea2 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Thu, 1 May 2025 20:04:34 +0800
Subject: [PATCH 091/418] cargo clippy

---
 pallets/subtensor/src/swap/swap_hotkey.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/pallets/subtensor/src/swap/swap_hotkey.rs b/pallets/subtensor/src/swap/swap_hotkey.rs
index de5766300f..aa31b7f508 100644
--- a/pallets/subtensor/src/swap/swap_hotkey.rs
+++ b/pallets/subtensor/src/swap/swap_hotkey.rs
@@ -381,7 +381,6 @@ impl<T: Config> Pallet<T> {
 
     // do hotkey swap public part for both swap all subnets and just swap one subnet
     pub fn perform_hotkey_swap_on_one_subnet(
-        coldkey: &T::AccountId,
         old_hotkey: &T::AccountId,
         new_hotkey: &T::AccountId,
         weight: &mut Weight,

From 9baf4a0f5c6ca13fd39c36895010a2f9465ae5f5 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Thu, 1 May 2025 20:06:30 +0800
Subject: [PATCH 092/418] commit Cargo.lock

---
 pallets/subtensor/src/swap/swap_hotkey.rs | 12 ++----------
 1 file changed, 2 insertions(+), 10 deletions(-)

diff --git a/pallets/subtensor/src/swap/swap_hotkey.rs b/pallets/subtensor/src/swap/swap_hotkey.rs
index aa31b7f508..5e51e86503 100644
--- a/pallets/subtensor/src/swap/swap_hotkey.rs
+++ b/pallets/subtensor/src/swap/swap_hotkey.rs
@@ -202,9 +202,7 @@ impl<T: Config> Pallet<T> {
         weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
 
         for netuid in Self::get_all_subnet_netuids() {
-            Self::perform_hotkey_swap_on_one_subnet(
-                coldkey, old_hotkey, new_hotkey, weight, netuid,
-            );
+            Self::perform_hotkey_swap_on_one_subnet(old_hotkey, new_hotkey, weight, netuid);
         }
 
         // 5. Swap LastTxBlock
@@ -355,13 +353,7 @@ impl<T: Config> Pallet<T> {
         // hotkeys.retain(|hk| *hk != *old_hotkey);
 
         // 14. Perform the hotkey swap
-        Self::perform_hotkey_swap_on_one_subnet(
-            coldkey,
-            old_hotkey,
-            new_hotkey,
-            &mut weight,
-            netuid,
-        );
+        Self::perform_hotkey_swap_on_one_subnet(old_hotkey, new_hotkey, &mut weight, netuid);
 
         let block: u64 = Self::get_current_block_as_u64();
         // 15. Update the last transaction block for the coldkey

From e7de51e10af93defaa02ceed2934db94a875bb1b Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Thu, 1 May 2025 17:53:17 +0200
Subject: [PATCH 093/418] Replace get_alpha_price with swap V3 equivalent

---
 Cargo.lock                                    |  1 +
 .../subtensor/src/coinbase/block_emission.rs  |  3 +-
 .../subtensor/src/coinbase/run_coinbase.rs    |  2 +-
 pallets/subtensor/src/staking/add_stake.rs    |  2 +-
 pallets/subtensor/src/staking/helpers.rs      | 45 ++++++-----
 pallets/subtensor/src/staking/move_stake.rs   |  4 +-
 pallets/subtensor/src/staking/stake_utils.rs  | 37 ++-------
 pallets/subtensor/src/tests/move_stake.rs     | 36 ++++-----
 pallets/subtensor/src/tests/senate.rs         | 34 +++++---
 pallets/subtensor/src/tests/staking.rs        | 81 ++++++++++---------
 pallets/subtensor/src/tests/swap_coldkey.rs   | 32 +++++---
 pallets/subtensor/src/tests/weights.rs        | 12 +--
 pallets/swap-interface/Cargo.toml             |  8 +-
 pallets/swap-interface/src/lib.rs             |  2 +
 pallets/swap/src/pallet/impls.rs              |  8 +-
 15 files changed, 167 insertions(+), 140 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 78de54f3a4..8a1ce271d4 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -11624,6 +11624,7 @@ dependencies = [
  "frame-support",
  "parity-scale-codec",
  "scale-info",
+ "substrate-fixed",
 ]
 
 [[package]]
diff --git a/pallets/subtensor/src/coinbase/block_emission.rs b/pallets/subtensor/src/coinbase/block_emission.rs
index cd9d778b8a..d5bba2192f 100644
--- a/pallets/subtensor/src/coinbase/block_emission.rs
+++ b/pallets/subtensor/src/coinbase/block_emission.rs
@@ -5,6 +5,7 @@ use substrate_fixed::{
     transcendental::log2,
     types::{I96F32, U96F32},
 };
+use subtensor_swap_interface::SwapHandler;
 
 impl<T: Config> Pallet<T> {
     /// Calculates the dynamic TAO emission for a given subnet.
@@ -38,7 +39,7 @@ impl<T: Config> Pallet<T> {
         let float_alpha_block_emission: U96F32 = U96F32::saturating_from_num(alpha_block_emission);
 
         // Get alpha price for subnet.
-        let alpha_price: U96F32 = Self::get_alpha_price(netuid);
+        let alpha_price = T::SwapInterface::current_alpha_price(netuid);
         log::debug!("{:?} - alpha_price: {:?}", netuid, alpha_price);
 
         // Get initial alpha_in
diff --git a/pallets/subtensor/src/coinbase/run_coinbase.rs b/pallets/subtensor/src/coinbase/run_coinbase.rs
index c0f890784c..e7126f65f6 100644
--- a/pallets/subtensor/src/coinbase/run_coinbase.rs
+++ b/pallets/subtensor/src/coinbase/run_coinbase.rs
@@ -70,7 +70,7 @@ impl<T: Config> Pallet<T> {
         // Only calculate for subnets that we are emitting to.
         for netuid_i in subnets_to_emit_to.iter() {
             // Get subnet price.
-            let price_i: U96F32 = Self::get_alpha_price(*netuid_i);
+            let price_i = T::SwapInterface::current_alpha_price(*netuid_i);
             log::debug!("price_i: {:?}", price_i);
             // Get subnet TAO.
             let moving_price_i: U96F32 = Self::get_moving_alpha_price(*netuid_i);
diff --git a/pallets/subtensor/src/staking/add_stake.rs b/pallets/subtensor/src/staking/add_stake.rs
index 55bafb2771..4852efc2c5 100644
--- a/pallets/subtensor/src/staking/add_stake.rs
+++ b/pallets/subtensor/src/staking/add_stake.rs
@@ -202,7 +202,7 @@ impl<T: Config> Pallet<T> {
         let tao = 1_000_000_000_u128;
         let limit_price_u128 = limit_price as u128;
         if (limit_price_u128
-            < Self::get_alpha_price(netuid)
+            < T::SwapInterface::current_alpha_price(netuid)
                 .saturating_to_num::<u128>()
                 .saturating_mul(tao))
             || (limit_price == 0u64)
diff --git a/pallets/subtensor/src/staking/helpers.rs b/pallets/subtensor/src/staking/helpers.rs
index 89ac345699..3987058c36 100644
--- a/pallets/subtensor/src/staking/helpers.rs
+++ b/pallets/subtensor/src/staking/helpers.rs
@@ -1,7 +1,7 @@
 use super::*;
 use safe_math::*;
 use substrate_fixed::types::U96F32;
-use subtensor_swap_interface::SwapHandler;
+use subtensor_swap_interface::{OrderType, SwapHandler};
 
 use frame_support::traits::{
     Imbalance,
@@ -47,11 +47,16 @@ impl<T: Config> Pallet<T> {
         Self::get_all_subnet_netuids()
             .into_iter()
             .map(|netuid| {
-                let alpha = U96F32::saturating_from_num(Self::get_stake_for_hotkey_on_subnet(
-                    hotkey, netuid,
-                ));
-                let tao_price = Self::get_alpha_price(netuid);
-                alpha.saturating_mul(tao_price).saturating_to_num::<u64>()
+                let alpha = Self::get_stake_for_hotkey_on_subnet(hotkey, netuid);
+                T::SwapInterface::swap(
+                    netuid,
+                    OrderType::Sell,
+                    alpha,
+                    T::SwapInterface::max_price(),
+                    true,
+                )
+                .map(|r| r.amount_paid_out.saturating_add(r.fee_paid))
+                .unwrap_or_default()
             })
             .sum()
     }
@@ -63,18 +68,22 @@ impl<T: Config> Pallet<T> {
         hotkeys
             .iter()
             .map(|hotkey| {
-                let mut total_stake: u64 = 0;
-                for (netuid, _) in Alpha::<T>::iter_prefix((hotkey, coldkey)) {
-                    let alpha_stake =
-                        Self::get_stake_for_hotkey_and_coldkey_on_subnet(hotkey, coldkey, netuid);
-                    let tao_price: U96F32 = Self::get_alpha_price(netuid);
-                    total_stake = total_stake.saturating_add(
-                        U96F32::saturating_from_num(alpha_stake)
-                            .saturating_mul(tao_price)
-                            .saturating_to_num::<u64>(),
-                    );
-                }
-                total_stake
+                Alpha::<T>::iter_prefix((hotkey, coldkey))
+                    .map(|(netuid, _)| {
+                        let alpha_stake = Self::get_stake_for_hotkey_and_coldkey_on_subnet(
+                            hotkey, coldkey, netuid,
+                        );
+                        T::SwapInterface::swap(
+                            netuid,
+                            OrderType::Sell,
+                            alpha_stake,
+                            T::SwapInterface::max_price(),
+                            true,
+                        )
+                        .map(|r| r.amount_paid_out.saturating_add(r.fee_paid))
+                        .unwrap_or_default()
+                    })
+                    .sum::<u64>()
             })
             .sum::<u64>()
     }
diff --git a/pallets/subtensor/src/staking/move_stake.rs b/pallets/subtensor/src/staking/move_stake.rs
index db3cd33e97..64fb3130d0 100644
--- a/pallets/subtensor/src/staking/move_stake.rs
+++ b/pallets/subtensor/src/staking/move_stake.rs
@@ -462,8 +462,8 @@ impl<T: Config> Pallet<T> {
         let limit_price_float: U64F64 = U64F64::saturating_from_num(limit_price)
             .checked_div(U64F64::saturating_from_num(1_000_000_000))
             .unwrap_or(U64F64::saturating_from_num(0));
-        let current_price = Self::get_alpha_price(origin_netuid)
-            .safe_div(Self::get_alpha_price(destination_netuid));
+        let current_price = T::SwapInterface::current_alpha_price(origin_netuid)
+            .safe_div(T::SwapInterface::current_alpha_price(destination_netuid));
         if limit_price_float > current_price {
             return 0;
         }
diff --git a/pallets/subtensor/src/staking/stake_utils.rs b/pallets/subtensor/src/staking/stake_utils.rs
index 7b89c61cc9..35c8fb1bad 100644
--- a/pallets/subtensor/src/staking/stake_utils.rs
+++ b/pallets/subtensor/src/staking/stake_utils.rs
@@ -20,32 +20,6 @@ impl<T: Config> Pallet<T> {
         SubnetAlphaIn::<T>::get(netuid).saturating_add(SubnetAlphaOut::<T>::get(netuid))
     }
 
-    /// Calculates the price of alpha for a given subnet.
-    ///
-    /// This function determines the price of alpha by dividing the total TAO
-    /// reserves by the total alpha reserves (`SubnetAlphaIn`) for the specified subnet.
-    /// If the alpha reserves are zero, the function returns zero to avoid division by zero.
-    ///
-    /// # Arguments
-    /// * `netuid` - The unique identifier of the subnet.
-    ///
-    /// # Returns
-    /// * `I96F32` - The price of alpha for the specified subnet.
-    pub fn get_alpha_price(netuid: u16) -> U96F32 {
-        if netuid == Self::get_root_netuid() {
-            return U96F32::saturating_from_num(1.0); // Root.
-        }
-        if SubnetMechanism::<T>::get(netuid) == 0 {
-            return U96F32::saturating_from_num(1.0); // Stable
-        }
-        if SubnetAlphaIn::<T>::get(netuid) == 0 {
-            U96F32::saturating_from_num(0)
-        } else {
-            U96F32::saturating_from_num(SubnetTAO::<T>::get(netuid))
-                .checked_div(U96F32::saturating_from_num(SubnetAlphaIn::<T>::get(netuid)))
-                .unwrap_or(U96F32::saturating_from_num(0))
-        }
-    }
     pub fn get_moving_alpha_price(netuid: u16) -> U96F32 {
         let one = U96F32::saturating_from_num(1.0);
         if netuid == Self::get_root_netuid() {
@@ -58,6 +32,7 @@ impl<T: Config> Pallet<T> {
             U96F32::saturating_from_num(SubnetMovingPrice::<T>::get(netuid))
         }
     }
+
     pub fn update_moving_price(netuid: u16) {
         let blocks_since_start_call = U96F32::saturating_from_num({
             // We expect FirstEmissionBlockNumber to be set earlier, and we take the block when
@@ -81,8 +56,9 @@ impl<T: Config> Pallet<T> {
         // Because alpha = b / (b + h), where b and h > 0, alpha < 1, so 1 - alpha > 0.
         // We can use unsigned type here: U96F32
         let one_minus_alpha: U96F32 = U96F32::saturating_from_num(1.0).saturating_sub(alpha);
-        let current_price: U96F32 = alpha
-            .saturating_mul(Self::get_alpha_price(netuid).min(U96F32::saturating_from_num(1.0)));
+        let current_price: U96F32 = alpha.saturating_mul(
+            T::SwapInterface::current_alpha_price(netuid).min(U96F32::saturating_from_num(1.0)),
+        );
         let current_moving: U96F32 =
             one_minus_alpha.saturating_mul(Self::get_moving_alpha_price(netuid));
         // Convert batch to signed I96F32 to avoid migration of SubnetMovingPrice for now``
@@ -860,7 +836,10 @@ impl<T: Config> Pallet<T> {
         )
         .map_err(|_| Error::<T>::InsufficientLiquidity)?;
 
-		ensure!(expected_alpha.amount_paid_out > 0, Error::<T>::InsufficientLiquidity);
+        ensure!(
+            expected_alpha.amount_paid_out > 0,
+            Error::<T>::InsufficientLiquidity
+        );
 
         // Ensure hotkey pool is precise enough
         let try_stake_result = Self::try_increase_stake_for_hotkey_and_coldkey_on_subnet(
diff --git a/pallets/subtensor/src/tests/move_stake.rs b/pallets/subtensor/src/tests/move_stake.rs
index 8c41198de3..646c965bc1 100644
--- a/pallets/subtensor/src/tests/move_stake.rs
+++ b/pallets/subtensor/src/tests/move_stake.rs
@@ -779,9 +779,9 @@ fn test_do_move_storage_updates() {
             0
         );
         let alpha_fee =
-            U96F32::from_num(fee) / SubtensorModule::get_alpha_price(destination_netuid);
-        let alpha2 = U96F32::from_num(alpha) * SubtensorModule::get_alpha_price(origin_netuid)
-            / SubtensorModule::get_alpha_price(destination_netuid);
+            U96F32::from_num(fee) / <Test as pallet::Config>::SwapInterface::current_alpha_price(destination_netuid);
+        let alpha2 = U96F32::from_num(alpha) * <Test as pallet::Config>::SwapInterface::current_alpha_price(origin_netuid)
+            / <Test as pallet::Config>::SwapInterface::current_alpha_price(destination_netuid);
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
                 &destination_hotkey,
@@ -1189,7 +1189,7 @@ fn test_do_transfer_different_subnets() {
             destination_netuid,
         );
         let expected_value = U96F32::from_num(stake_amount - fee)
-            / SubtensorModule::get_alpha_price(destination_netuid);
+            / <Test as pallet::Config>::SwapInterface::current_alpha_price(destination_netuid);
         assert_abs_diff_eq!(
             dest_stake,
             expected_value.to_num::<u64>(),
@@ -1249,10 +1249,10 @@ fn test_do_swap_success() {
             destination_netuid,
         );
         let alpha_fee =
-            U96F32::from_num(fee) / SubtensorModule::get_alpha_price(destination_netuid);
+            U96F32::from_num(fee) / <Test as pallet::Config>::SwapInterface::current_alpha_price(destination_netuid);
         let expected_value = U96F32::from_num(alpha_before)
-            * SubtensorModule::get_alpha_price(origin_netuid)
-            / SubtensorModule::get_alpha_price(destination_netuid);
+            * <Test as pallet::Config>::SwapInterface::current_alpha_price(origin_netuid)
+            / <Test as pallet::Config>::SwapInterface::current_alpha_price(destination_netuid);
         assert_abs_diff_eq!(
             alpha_after,
             (expected_value - alpha_fee).to_num::<u64>(),
@@ -1509,10 +1509,10 @@ fn test_do_swap_partial_stake() {
         );
 
         let alpha_fee =
-            U96F32::from_num(fee) / SubtensorModule::get_alpha_price(destination_netuid);
+            U96F32::from_num(fee) / <Test as pallet::Config>::SwapInterface::current_alpha_price(destination_netuid);
         let expected_value = U96F32::from_num(swap_amount)
-            * SubtensorModule::get_alpha_price(origin_netuid)
-            / SubtensorModule::get_alpha_price(destination_netuid);
+            * <Test as pallet::Config>::SwapInterface::current_alpha_price(origin_netuid)
+            / <Test as pallet::Config>::SwapInterface::current_alpha_price(destination_netuid);
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
                 &hotkey,
@@ -1571,10 +1571,10 @@ fn test_do_swap_storage_updates() {
         );
 
         let alpha_fee =
-            U96F32::from_num(fee) / SubtensorModule::get_alpha_price(destination_netuid);
+            U96F32::from_num(fee) / <Test as pallet::Config>::SwapInterface::current_alpha_price(destination_netuid);
         let expected_value = U96F32::from_num(alpha)
-            * SubtensorModule::get_alpha_price(origin_netuid)
-            / SubtensorModule::get_alpha_price(destination_netuid);
+            * <Test as pallet::Config>::SwapInterface::current_alpha_price(origin_netuid)
+            / <Test as pallet::Config>::SwapInterface::current_alpha_price(destination_netuid);
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
                 &hotkey,
@@ -1736,8 +1736,8 @@ fn test_swap_stake_limit_validate() {
         .unwrap();
 
         // Setup limit price so that it doesn't allow much slippage at all
-        let limit_price = ((SubtensorModule::get_alpha_price(origin_netuid)
-            / SubtensorModule::get_alpha_price(destination_netuid))
+        let limit_price = ((<Test as pallet::Config>::SwapInterface::current_alpha_price(origin_netuid)
+            / <Test as pallet::Config>::SwapInterface::current_alpha_price(destination_netuid))
             * U96F32::from_num(1_000_000_000))
         .to_num::<u64>()
             - 1_u64;
@@ -1938,10 +1938,10 @@ fn test_move_stake_specific_stake_into_subnet_fail() {
             0
         );
         let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
-        let alpha_fee: U96F32 = U96F32::from_num(fee) / SubtensorModule::get_alpha_price(netuid);
+        let alpha_fee: U96F32 = U96F32::from_num(fee) / <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid);
         let expected_value = U96F32::from_num(alpha_to_move)
-            * SubtensorModule::get_alpha_price(origin_netuid)
-            / SubtensorModule::get_alpha_price(netuid);
+            * <Test as pallet::Config>::SwapInterface::current_alpha_price(origin_netuid)
+            / <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid);
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
                 &hotkey_account_id,
diff --git a/pallets/subtensor/src/tests/senate.rs b/pallets/subtensor/src/tests/senate.rs
index ad60c6f9a0..c5aa93f10b 100644
--- a/pallets/subtensor/src/tests/senate.rs
+++ b/pallets/subtensor/src/tests/senate.rs
@@ -1,24 +1,25 @@
 #![allow(clippy::unwrap_used)]
 
-use super::mock::*;
-use crate::*;
 use approx::assert_abs_diff_eq;
 use codec::Encode;
 use frame_support::{assert_noop, assert_ok};
+use frame_system::Config;
+use frame_system::pallet_prelude::*;
 use frame_system::{EventRecord, Phase};
+use pallet_collective::Event as CollectiveEvent;
 use sp_core::{Get, H256, U256, bounded_vec};
 use sp_runtime::{
     BuildStorage,
     traits::{BlakeTwo256, Hash},
 };
+use subtensor_swap_interface::SwapHandler;
 
+use super::mock;
+use super::mock::*;
+use crate::Delegates;
 use crate::Error;
 use crate::migrations;
-use frame_system::Config;
-use frame_system::pallet_prelude::*;
-use pallet_collective::Event as CollectiveEvent;
-
-use crate::Delegates;
+use crate::*;
 
 pub fn new_test_ext() -> sp_io::TestExternalities {
     sp_tracing::try_init_simple();
@@ -691,11 +692,13 @@ fn test_adjust_senate_events() {
         let burn_cost = 1000;
         let coldkey_account_id = U256::from(667);
         let root_netuid = SubtensorModule::get_root_netuid();
-        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
-
         let max_senate_size: u16 = SenateMaxMembers::get() as u16;
-        let stake_threshold: u64 =
-            DefaultMinStake::<Test>::get() + 0; // FIXME: DefaultStakingFee is deprecated // Give this much to every senator
+        let stake_threshold = {
+            let default_stake = DefaultMinStake::<Test>::get();
+            let fee =
+                <Test as pallet::Config>::SwapInterface::approx_fee_amount(netuid, default_stake);
+            default_stake + fee
+        };
 
         // We will be registering MaxMembers hotkeys and two more to try a replace
         let balance_to_add = DefaultMinStake::<Test>::get() * 10
@@ -716,6 +719,9 @@ fn test_adjust_senate_events() {
         SubtensorModule::set_max_registrations_per_block(root_netuid, max_senate_size + 1);
         SubtensorModule::set_target_registrations_per_interval(root_netuid, max_senate_size + 1);
 
+        let reserve = 1_000_000_000_000;
+        mock::setup_reserves(netuid, reserve, reserve);
+
         // Subscribe and check extrinsic output
         assert_ok!(SubtensorModule::burned_register(
             <<Test as Config>::RuntimeOrigin>::signed(coldkey_account_id),
@@ -802,6 +808,12 @@ fn test_adjust_senate_events() {
         assert!(!Senate::is_member(&replacement_hotkey_account_id));
         // Add/delegate enough stake to join the senate
         let stake = DefaultMinStake::<Test>::get() * 10;
+
+        let reserve = stake * 1000;
+        mock::setup_reserves(root_netuid, reserve, reserve);
+
+		let (_, fee) = mock::swap_tao_to_alpha(root_netuid, stake);
+
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(coldkey_account_id),
             replacement_hotkey_account_id,
diff --git a/pallets/subtensor/src/tests/staking.rs b/pallets/subtensor/src/tests/staking.rs
index 2de34310dc..c69942b1d0 100644
--- a/pallets/subtensor/src/tests/staking.rs
+++ b/pallets/subtensor/src/tests/staking.rs
@@ -394,16 +394,16 @@ fn test_remove_stake_ok_no_emission() {
             netuid,
             amount,
         );
-        assert_eq!(
+        assert_abs_diff_eq!(
             SubtensorModule::get_total_stake_for_hotkey(&hotkey_account_id),
-            amount
+            amount,
+            epsilon = amount / 1000
         );
 
         // Add subnet TAO for the equivalent amount added at price
-        let amount_tao =
-            U96F32::saturating_from_num(amount) * SubtensorModule::get_alpha_price(netuid);
-        SubnetTAO::<Test>::mutate(netuid, |v| *v += amount_tao.saturating_to_num::<u64>());
-        TotalStake::<Test>::mutate(|v| *v += amount_tao.saturating_to_num::<u64>());
+        let (amount_tao, fee) = mock::swap_alpha_to_tao(netuid, amount);
+        SubnetTAO::<Test>::mutate(netuid, |v| *v += amount_tao + fee);
+        TotalStake::<Test>::mutate(|v| *v += amount_tao + fee);
 
         // Do the magic
         assert_ok!(SubtensorModule::remove_stake(
@@ -413,17 +413,17 @@ fn test_remove_stake_ok_no_emission() {
             amount
         ));
 
-        let fee = <Test as Config>::SwapInterface::approx_fee_amount(netuid, amount);
-
         // we do not expect the exact amount due to slippage
         assert!(SubtensorModule::get_coldkey_balance(&coldkey_account_id) > amount / 10 * 9 - fee);
-        assert_eq!(
+        assert_abs_diff_eq!(
             SubtensorModule::get_total_stake_for_hotkey(&hotkey_account_id),
-            0
+            0,
+			epsilon = 20000
         );
-        assert_eq!(
+        assert_abs_diff_eq!(
             SubtensorModule::get_total_stake(),
-            SubtensorModule::get_network_min_lock() + fee
+            SubtensorModule::get_network_min_lock() + fee,
+			epsilon = 1000
         );
     });
 }
@@ -575,8 +575,8 @@ fn test_remove_stake_total_balance_no_change() {
         );
 
         // Add subnet TAO for the equivalent amount added at price
-        let amount_tao =
-            U96F32::saturating_from_num(amount) * SubtensorModule::get_alpha_price(netuid);
+        let amount_tao = U96F32::saturating_from_num(amount)
+            * <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid);
         SubnetTAO::<Test>::mutate(netuid, |v| *v += amount_tao.saturating_to_num::<u64>());
         TotalStake::<Test>::mutate(|v| *v += amount_tao.saturating_to_num::<u64>());
 
@@ -624,14 +624,8 @@ fn test_add_stake_insufficient_liquidity() {
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, amount_staked);
 
         // Set the liquidity at lowest possible value so that all staking requests fail
-        SubnetTAO::<Test>::insert(
-            netuid,
-            DefaultMinimumPoolLiquidity::<Test>::get().to_num::<u64>(),
-        );
-        SubnetAlphaIn::<Test>::insert(
-            netuid,
-            DefaultMinimumPoolLiquidity::<Test>::get().to_num::<u64>(),
-        );
+        let reserve = DefaultMinimumPoolLiquidity::<Test>::get().to_num::<u64>();
+        mock::setup_reserves(netuid, reserve, reserve);
 
         // Check the error
         assert_noop!(
@@ -2576,7 +2570,7 @@ fn test_add_stake_limit_validate() {
         let alpha_in: U96F32 = U96F32::from_num(100_000_000_000_u64);
         SubnetTAO::<Test>::insert(netuid, tao_reserve.to_num::<u64>());
         SubnetAlphaIn::<Test>::insert(netuid, alpha_in.to_num::<u64>());
-        let current_price: U96F32 = U96F32::from_num(SubtensorModule::get_alpha_price(netuid));
+        let current_price = <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid);
         assert_eq!(current_price, U96F32::from_num(1.5));
 
         // Give it some $$$ in his coldkey balance
@@ -2640,7 +2634,7 @@ fn test_remove_stake_limit_validate() {
         let alpha_in: U96F32 = U96F32::from_num(100_000_000_000_u64);
         SubnetTAO::<Test>::insert(netuid, tao_reserve.to_num::<u64>());
         SubnetAlphaIn::<Test>::insert(netuid, alpha_in.to_num::<u64>());
-        let current_price: U96F32 = U96F32::from_num(SubtensorModule::get_alpha_price(netuid));
+        let current_price = <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid);
         assert_eq!(current_price, U96F32::from_num(1.5));
 
         // Setup limit price so that it doesn't drop by more than 10% from current price
@@ -2981,7 +2975,10 @@ fn test_max_amount_add_dynamic() {
 
             if alpha_in != 0 {
                 let expected_price = I96F32::from_num(tao_in) / I96F32::from_num(alpha_in);
-                assert_eq!(SubtensorModule::get_alpha_price(netuid), expected_price);
+                assert_eq!(
+                    <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid),
+                    expected_price
+                );
             }
 
             assert_eq!(
@@ -3150,7 +3147,10 @@ fn test_max_amount_remove_dynamic() {
 
             if alpha_in != 0 {
                 let expected_price = I96F32::from_num(tao_in) / I96F32::from_num(alpha_in);
-                assert_eq!(SubtensorModule::get_alpha_price(netuid), expected_price);
+                assert_eq!(
+                    <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid),
+                    expected_price
+                );
             }
 
             assert_eq!(
@@ -3254,8 +3254,8 @@ fn test_max_amount_move_stable_dynamic() {
         let alpha_in: U96F32 = U96F32::from_num(100_000_000_000_u64);
         SubnetTAO::<Test>::insert(dynamic_netuid, tao_reserve.to_num::<u64>());
         SubnetAlphaIn::<Test>::insert(dynamic_netuid, alpha_in.to_num::<u64>());
-        let current_price: U96F32 =
-            U96F32::from_num(SubtensorModule::get_alpha_price(dynamic_netuid));
+        let current_price =
+            <Test as pallet::Config>::SwapInterface::current_alpha_price(dynamic_netuid);
         assert_eq!(current_price, U96F32::from_num(0.5));
 
         // The tests below just mimic the add_stake_limit tests for reverted price
@@ -3325,8 +3325,8 @@ fn test_max_amount_move_dynamic_stable() {
         let alpha_in: U96F32 = U96F32::from_num(100_000_000_000_u64);
         SubnetTAO::<Test>::insert(dynamic_netuid, tao_reserve.to_num::<u64>());
         SubnetAlphaIn::<Test>::insert(dynamic_netuid, alpha_in.to_num::<u64>());
-        let current_price: U96F32 =
-            U96F32::from_num(SubtensorModule::get_alpha_price(dynamic_netuid));
+        let current_price =
+            <Test as pallet::Config>::SwapInterface::current_alpha_price(dynamic_netuid);
         assert_eq!(current_price, U96F32::from_num(1.5));
 
         // The tests below just mimic the remove_stake_limit tests
@@ -3590,8 +3590,11 @@ fn test_max_amount_move_dynamic_dynamic() {
                     if dest_price != 0 {
                         let expected_price = origin_price / dest_price;
                         assert_eq!(
-                            SubtensorModule::get_alpha_price(origin_netuid)
-                                / SubtensorModule::get_alpha_price(destination_netuid),
+                            <Test as pallet::Config>::SwapInterface::current_alpha_price(
+                                origin_netuid
+                            ) / <Test as pallet::Config>::SwapInterface::current_alpha_price(
+                                destination_netuid
+                            ),
                             expected_price
                         );
                     }
@@ -3625,7 +3628,7 @@ fn test_add_stake_limit_ok() {
         let tao_reserve = U96F32::from_num(150_000_000_000_u64);
         let alpha_in = U96F32::from_num(100_000_000_000_u64);
         mock::setup_reserves(netuid, tao_reserve.to_num(), alpha_in.to_num());
-        let current_price = U96F32::from_num(SubtensorModule::get_alpha_price(netuid));
+        let current_price = <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid);
         assert_eq!(current_price, U96F32::from_num(1.5));
 
         // Give it some $$$ in his coldkey balance
@@ -3667,7 +3670,7 @@ fn test_add_stake_limit_ok() {
 
         // Check that price has updated to ~24 = (150+450) / (100 - 75)
         let exp_price = U96F32::from_num(24.0);
-        let current_price: U96F32 = U96F32::from_num(SubtensorModule::get_alpha_price(netuid));
+        let current_price = <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid);
         assert_abs_diff_eq!(
             exp_price.to_num::<f64>(),
             current_price.to_num::<f64>(),
@@ -3691,7 +3694,7 @@ fn test_add_stake_limit_fill_or_kill() {
         let alpha_in: U96F32 = U96F32::from_num(100_000_000_000_u64);
         SubnetTAO::<Test>::insert(netuid, tao_reserve.to_num::<u64>());
         SubnetAlphaIn::<Test>::insert(netuid, alpha_in.to_num::<u64>());
-        let current_price: U96F32 = U96F32::from_num(SubtensorModule::get_alpha_price(netuid));
+        let current_price = <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid);
         assert_eq!(current_price, U96F32::from_num(1.5));
 
         // Give it some $$$ in his coldkey balance
@@ -3758,7 +3761,7 @@ fn test_remove_stake_limit_ok() {
         let alpha_in: U96F32 = U96F32::from_num(100_000_000_000_u64);
         SubnetTAO::<Test>::insert(netuid, tao_reserve.to_num::<u64>());
         SubnetAlphaIn::<Test>::insert(netuid, alpha_in.to_num::<u64>());
-        let current_price: U96F32 = U96F32::from_num(SubtensorModule::get_alpha_price(netuid));
+        let current_price = <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid);
         assert_eq!(current_price, U96F32::from_num(1.5));
 
         // Setup limit price so resulting average price doesn't drop by more than 10% from current price
@@ -3814,7 +3817,7 @@ fn test_remove_stake_limit_fill_or_kill() {
         let alpha_in: U96F32 = U96F32::from_num(100_000_000_000_u64);
         SubnetTAO::<Test>::insert(netuid, tao_reserve.to_num::<u64>());
         SubnetAlphaIn::<Test>::insert(netuid, alpha_in.to_num::<u64>());
-        let current_price: U96F32 = U96F32::from_num(SubtensorModule::get_alpha_price(netuid));
+        let current_price = <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid);
         assert_eq!(current_price, U96F32::from_num(1.5));
 
         // Setup limit price so that it doesn't drop by more than 10% from current price
@@ -4198,8 +4201,8 @@ fn test_move_stake_limit_partial() {
         SubnetAlphaIn::<Test>::insert(origin_netuid, alpha_in.to_num::<u64>());
         SubnetTAO::<Test>::insert(destination_netuid, (tao_reserve * 100_000).to_num::<u64>());
         SubnetAlphaIn::<Test>::insert(destination_netuid, (alpha_in * 100_000).to_num::<u64>());
-        let current_price: U96F32 =
-            U96F32::from_num(SubtensorModule::get_alpha_price(origin_netuid));
+        let current_price =
+            <Test as pallet::Config>::SwapInterface::current_alpha_price(origin_netuid);
         assert_eq!(current_price, U96F32::from_num(1.5));
 
         // The relative price between origin and destination subnets is 1.
diff --git a/pallets/subtensor/src/tests/swap_coldkey.rs b/pallets/subtensor/src/tests/swap_coldkey.rs
index 02196cf63e..76c921469f 100644
--- a/pallets/subtensor/src/tests/swap_coldkey.rs
+++ b/pallets/subtensor/src/tests/swap_coldkey.rs
@@ -560,9 +560,8 @@ fn test_swap_concurrent_modifications() {
         let initial_stake = 1_000_000_000_000;
         let additional_stake = 500_000_000_000;
 
-        mock::setup_reserves(netuid, 1_000_000_000_000_000, 1_000_000_000_000_000);
-
-        let (initial_stake_alpha, fee) = mock::swap_tao_to_alpha(netuid, initial_stake);
+        let reserve = (initial_stake + additional_stake) * 1000;
+        mock::setup_reserves(netuid, reserve, reserve);
 
         // Setup initial state
         add_network(netuid, 1, 1);
@@ -571,6 +570,8 @@ fn test_swap_concurrent_modifications() {
             initial_stake + additional_stake + 1_000_000,
         );
         register_ok_neuron(netuid, hotkey, new_coldkey, 1001000);
+
+        let (initial_stake_alpha, fee) = mock::swap_tao_to_alpha(netuid, initial_stake);
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(new_coldkey),
             hotkey,
@@ -915,9 +916,10 @@ fn test_swap_stake_for_coldkey() {
         SubtensorModule::perform_swap_coldkey(&old_coldkey, &new_coldkey, &mut weight);
 
         // Verify stake is additive, not replaced
-        assert_eq!(
+        assert_abs_diff_eq!(
             SubtensorModule::get_total_stake_for_coldkey(&new_coldkey),
-            initial_total_stake_for_old_coldkey + initial_total_stake_for_new_coldkey
+            initial_total_stake_for_old_coldkey + initial_total_stake_for_new_coldkey,
+            epsilon = 2
         );
 
         // Verify ownership transfer
@@ -1646,13 +1648,11 @@ fn test_coldkey_delegations() {
         let netuid = 0u16; // Stake to 0
         let netuid2 = 1u16; // Stake to 1
         let stake = DefaultMinStake::<Test>::get() * 10;
-        let reserve = stake * 10;
+        let reserve = stake * 1000;
 
         mock::setup_reserves(netuid, reserve, reserve);
         mock::setup_reserves(netuid2, reserve, reserve);
 
-        let (expected_stake, fee) = mock::swap_tao_to_alpha(netuid, stake);
-
         add_network(netuid, 13, 0); // root
         add_network(netuid2, 13, 0);
 
@@ -1663,6 +1663,11 @@ fn test_coldkey_delegations() {
         register_ok_neuron(netuid2, delegate, owner, 0);
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, stake * 10);
 
+        // since the reserves are equal and we stake the same amount to both networks, we can reuse
+        // this values for different networks. but you should take it into account in case of tests
+        // changes
+        let (expected_stake, fee) = mock::swap_tao_to_alpha(netuid, stake);
+
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(coldkey),
             delegate,
@@ -1687,14 +1692,17 @@ fn test_coldkey_delegations() {
         ));
 
         // Verify stake was moved for the delegate
-        assert_eq!(
+        let approx_total_stake = stake * 2 - fee * 2;
+        assert_abs_diff_eq!(
             SubtensorModule::get_total_stake_for_hotkey(&delegate),
-            expected_stake * 2,
+            approx_total_stake,
+            epsilon = approx_total_stake / 100
         );
         assert_eq!(SubtensorModule::get_total_stake_for_coldkey(&coldkey), 0);
-        assert_eq!(
+        assert_abs_diff_eq!(
             SubtensorModule::get_total_stake_for_coldkey(&new_coldkey),
-            expected_stake * 2,
+            approx_total_stake,
+            epsilon = approx_total_stake / 100
         );
         assert_eq!(
             Alpha::<Test>::get((delegate, new_coldkey, netuid)).to_num::<u64>(),
diff --git a/pallets/subtensor/src/tests/weights.rs b/pallets/subtensor/src/tests/weights.rs
index 4da941cdc9..0d5066b181 100644
--- a/pallets/subtensor/src/tests/weights.rs
+++ b/pallets/subtensor/src/tests/weights.rs
@@ -1,7 +1,7 @@
 #![allow(clippy::indexing_slicing)]
 
-use super::mock::*;
 use super::mock;
+use super::mock::*;
 use crate::coinbase::run_coinbase::WeightsTlockPayload;
 use crate::*;
 use ark_serialize::CanonicalDeserialize;
@@ -187,7 +187,6 @@ fn test_commit_weights_validate() {
         let coldkey = U256::from(0);
         let hotkey: U256 = U256::from(1); // Add the hotkey field
         assert_ne!(hotkey, coldkey); // Ensure hotkey is NOT the same as coldkey !!!
-        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         let who = hotkey; // The hotkey signs this transaction
 
@@ -208,16 +207,17 @@ fn test_commit_weights_validate() {
         SubtensorModule::add_balance_to_coldkey_account(&hotkey, u64::MAX);
 
         let min_stake = 500_000_000_000;
+        let reserve = min_stake * 1000;
+        mock::setup_reserves(netuid, reserve, reserve);
 
-		mock::setup_reserves(netuid, min_stake * 100, min_stake * 10);
+        let (_, fee) = mock::swap_tao_to_alpha(netuid, min_stake);
 
         // Set the minimum stake
         SubtensorModule::set_stake_threshold(min_stake);
 
         // Verify stake is less than minimum
         assert!(SubtensorModule::get_total_stake_for_hotkey(&hotkey) < min_stake);
-        let info: crate::DispatchInfo =
-            crate::DispatchInfoOf::<<Test as frame_system::Config>::RuntimeCall>::default();
+        let info = crate::DispatchInfoOf::<<Test as frame_system::Config>::RuntimeCall>::default();
 
         let extension = crate::SubtensorSignedExtension::<Test>::new();
         // Submit to the signed extension validate function
@@ -313,7 +313,7 @@ fn test_set_weights_validate() {
 
         // Create netuid
         add_network(netuid, 1, 0);
-		mock::setup_reserves(netuid, 1_000_000_000_000, 1_000_000_000_000);
+        mock::setup_reserves(netuid, 1_000_000_000_000, 1_000_000_000_000);
         // Register the hotkey
         SubtensorModule::append_neuron(netuid, &hotkey, 0);
         crate::Owner::<Test>::insert(hotkey, coldkey);
diff --git a/pallets/swap-interface/Cargo.toml b/pallets/swap-interface/Cargo.toml
index 6b52737588..cdde4a78b2 100644
--- a/pallets/swap-interface/Cargo.toml
+++ b/pallets/swap-interface/Cargo.toml
@@ -7,10 +7,16 @@ edition.workspace = true
 codec = { workspace = true }
 frame-support = { workspace = true }
 scale-info = { workspace = true }
+substrate-fixed = { workspace = true }
 
 [lints]
 workspace = true
 
 [features]
 default = ["std"]
-std = ["codec/std", "frame-support/std", "scale-info/std"]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"scale-info/std",
+	"substrate-fixed/std",
+]
diff --git a/pallets/swap-interface/src/lib.rs b/pallets/swap-interface/src/lib.rs
index d77edd57b5..533e9ab52c 100644
--- a/pallets/swap-interface/src/lib.rs
+++ b/pallets/swap-interface/src/lib.rs
@@ -1,6 +1,7 @@
 #![cfg_attr(not(feature = "std"), no_std)]
 
 use frame_support::pallet_prelude::*;
+use substrate_fixed::types::U96F32;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum OrderType {
@@ -30,6 +31,7 @@ pub trait SwapHandler<AccountId> {
         position_id: u128,
     ) -> Result<RemoveLiquidityResult, DispatchError>;
     fn approx_fee_amount(netuid: u16, amount: u64) -> u64;
+    fn current_alpha_price(netuid: u16) -> U96F32;
     fn max_price() -> u64;
     fn min_price() -> u64;
 }
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index d58eaeb457..2e0fdf60d0 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -5,7 +5,7 @@ use frame_support::{ensure, pallet_prelude::DispatchError, traits::Get};
 use safe_math::*;
 use sp_arithmetic::helpers_128bit;
 use sp_runtime::traits::AccountIdConversion;
-use substrate_fixed::types::U64F64;
+use substrate_fixed::types::{U64F64, U96F32};
 use subtensor_swap_interface::{
     LiquidityDataProvider, RemoveLiquidityResult, SwapHandler, SwapResult,
 };
@@ -1157,6 +1157,11 @@ impl<T: Config> SwapHandler<T::AccountId> for Pallet<T> {
         Self::calculate_fee_amount(netuid.into(), amount)
     }
 
+    fn current_alpha_price(netuid: u16) -> U96F32 {
+        let sqrt_price = AlphaSqrtPrice::<T>::get(NetUid::from(netuid));
+        U96F32::saturating_from_num(sqrt_price.saturating_mul(sqrt_price))
+    }
+
     fn min_price() -> u64 {
         TickIndex::min_sqrt_price()
             .saturating_mul(TickIndex::min_sqrt_price())
@@ -1166,6 +1171,7 @@ impl<T: Config> SwapHandler<T::AccountId> for Pallet<T> {
     fn max_price() -> u64 {
         TickIndex::max_sqrt_price()
             .saturating_mul(TickIndex::max_sqrt_price())
+            .saturating_round()
             .saturating_to_num()
     }
 }

From 3ab6fc10ccc7b7c5f6fd334cce1adf10a5369b7f Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Fri, 2 May 2025 17:13:57 +0800
Subject: [PATCH 094/418] add new test file

---
 pallets/subtensor/src/tests/mod.rs            |    1 +
 .../src/tests/swap_hotkey_with_subnet.rs      | 1509 +++++++++++++++++
 2 files changed, 1510 insertions(+)
 create mode 100644 pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs

diff --git a/pallets/subtensor/src/tests/mod.rs b/pallets/subtensor/src/tests/mod.rs
index ce891e5615..857666f822 100644
--- a/pallets/subtensor/src/tests/mod.rs
+++ b/pallets/subtensor/src/tests/mod.rs
@@ -21,5 +21,6 @@ mod staking2;
 mod subnet;
 mod swap_coldkey;
 mod swap_hotkey;
+mod swap_hotkey_with_subnet;
 mod uids;
 mod weights;
diff --git a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
new file mode 100644
index 0000000000..96d902e0da
--- /dev/null
+++ b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
@@ -0,0 +1,1509 @@
+#![allow(unused, clippy::indexing_slicing, clippy::panic, clippy::unwrap_used)]
+
+use approx::assert_abs_diff_eq;
+use codec::Encode;
+use frame_support::weights::Weight;
+use frame_support::{assert_err, assert_noop, assert_ok};
+use frame_system::{Config, RawOrigin};
+
+use super::mock::*;
+use crate::*;
+use sp_core::{Get, H256, U256};
+use sp_runtime::SaturatedConversion;
+use substrate_fixed::types::U64F64;
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_owner --exact --nocapture
+#[test]
+fn test_swap_owner() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let mut weight = Weight::zero();
+
+        let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+        Owner::<Test>::insert(old_hotkey, coldkey);
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
+            &old_hotkey,
+            &new_hotkey,
+            Some(netuid)
+        ));
+
+        assert_eq!(Owner::<Test>::get(old_hotkey), coldkey);
+        assert_eq!(Owner::<Test>::get(new_hotkey), coldkey);
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_owned_hotkeys --exact --nocapture
+#[test]
+fn test_swap_owned_hotkeys() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let mut weight = Weight::zero();
+
+        let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+
+        OwnedHotkeys::<Test>::insert(coldkey, vec![old_hotkey]);
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
+            &old_hotkey,
+            &new_hotkey,
+            Some(netuid)
+        ));
+
+        let hotkeys = OwnedHotkeys::<Test>::get(coldkey);
+        assert!(hotkeys.contains(&old_hotkey));
+        assert!(hotkeys.contains(&new_hotkey));
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_total_hotkey_stake --exact --nocapture
+#[test]
+fn test_swap_total_hotkey_stake() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let amount = DefaultMinStake::<Test>::get() * 10;
+        let mut weight = Weight::zero();
+        let fee = DefaultStakingFee::<Test>::get();
+
+        //add network
+        let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
+
+        // Give it some $$$ in his coldkey balance
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+
+        // Add stake
+        assert_ok!(SubtensorModule::add_stake(
+            RuntimeOrigin::signed(coldkey),
+            old_hotkey,
+            netuid,
+            amount
+        ));
+
+        // Check if stake has increased
+        assert_abs_diff_eq!(
+            SubtensorModule::get_total_stake_for_hotkey(&old_hotkey),
+            amount - fee,
+            epsilon = amount / 1000,
+        );
+        assert_abs_diff_eq!(
+            SubtensorModule::get_total_stake_for_hotkey(&new_hotkey),
+            0,
+            epsilon = 1,
+        );
+
+        // Swap hotkey
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
+            &old_hotkey,
+            &new_hotkey,
+            Some(netuid)
+        ));
+
+        // Verify that total hotkey stake swapped
+        assert_abs_diff_eq!(
+            SubtensorModule::get_total_stake_for_hotkey(&old_hotkey),
+            0,
+            epsilon = 1,
+        );
+        assert_abs_diff_eq!(
+            SubtensorModule::get_total_stake_for_hotkey(&new_hotkey),
+            amount - fee,
+            epsilon = amount / 1000,
+        );
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_senate_members --exact --nocapture
+#[test]
+fn test_swap_senate_members() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let mut weight = Weight::zero();
+
+        let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+
+        assert_ok!(SenateMembers::add_member(
+            RuntimeOrigin::root(),
+            old_hotkey.clone()
+        ));
+
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
+            &old_hotkey,
+            &new_hotkey,
+            Some(netuid)
+        ));
+
+        let members = SenateMembers::members();
+        assert!(members.contains(&old_hotkey));
+        assert!(!members.contains(&new_hotkey));
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_delegates --exact --nocapture
+#[test]
+fn test_swap_delegates() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let mut weight = Weight::zero();
+
+        Delegates::<Test>::insert(old_hotkey, 100);
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight
+        ));
+
+        assert!(!Delegates::<Test>::contains_key(old_hotkey));
+        assert_eq!(Delegates::<Test>::get(new_hotkey), 100);
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_subnet_membership --exact --nocapture
+#[test]
+fn test_swap_subnet_membership() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let netuid = 0u16;
+        let mut weight = Weight::zero();
+
+        add_network(netuid, 1, 1);
+        IsNetworkMember::<Test>::insert(old_hotkey, netuid, true);
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight
+        ));
+
+        assert!(!IsNetworkMember::<Test>::contains_key(old_hotkey, netuid));
+        assert!(IsNetworkMember::<Test>::get(new_hotkey, netuid));
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_uids_and_keys --exact --nocapture
+#[test]
+fn test_swap_uids_and_keys() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let netuid = 0u16;
+        let uid = 5u16;
+        let mut weight = Weight::zero();
+
+        add_network(netuid, 1, 1);
+        IsNetworkMember::<Test>::insert(old_hotkey, netuid, true);
+        Uids::<Test>::insert(netuid, old_hotkey, uid);
+        Keys::<Test>::insert(netuid, uid, old_hotkey);
+
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight
+        ));
+
+        assert_eq!(Uids::<Test>::get(netuid, old_hotkey), None);
+        assert_eq!(Uids::<Test>::get(netuid, new_hotkey), Some(uid));
+        assert_eq!(Keys::<Test>::get(netuid, uid), new_hotkey);
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_prometheus --exact --nocapture
+#[test]
+fn test_swap_prometheus() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let netuid = 0u16;
+        let prometheus_info = PrometheusInfo::default();
+        let mut weight = Weight::zero();
+
+        add_network(netuid, 1, 1);
+        IsNetworkMember::<Test>::insert(old_hotkey, netuid, true);
+        Prometheus::<Test>::insert(netuid, old_hotkey, prometheus_info.clone());
+
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight
+        ));
+
+        assert!(!Prometheus::<Test>::contains_key(netuid, old_hotkey));
+        assert_eq!(
+            Prometheus::<Test>::get(netuid, new_hotkey),
+            Some(prometheus_info)
+        );
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_axons --exact --nocapture
+#[test]
+fn test_swap_axons() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let netuid = 0u16;
+        let axon_info = AxonInfo::default();
+        let mut weight = Weight::zero();
+
+        add_network(netuid, 1, 1);
+        IsNetworkMember::<Test>::insert(old_hotkey, netuid, true);
+        Axons::<Test>::insert(netuid, old_hotkey, axon_info.clone());
+
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight
+        ));
+
+        assert!(!Axons::<Test>::contains_key(netuid, old_hotkey));
+        assert_eq!(Axons::<Test>::get(netuid, new_hotkey), Some(axon_info));
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_certificates --exact --nocapture
+#[test]
+fn test_swap_certificates() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let netuid = 0u16;
+        let certificate = NeuronCertificate::try_from(vec![1, 2, 3]).unwrap();
+        let mut weight = Weight::zero();
+
+        add_network(netuid, 1, 1);
+        IsNetworkMember::<Test>::insert(old_hotkey, netuid, true);
+        NeuronCertificates::<Test>::insert(netuid, old_hotkey, certificate.clone());
+
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight
+        ));
+
+        assert!(!NeuronCertificates::<Test>::contains_key(
+            netuid, old_hotkey
+        ));
+        assert_eq!(
+            NeuronCertificates::<Test>::get(netuid, new_hotkey),
+            Some(certificate)
+        );
+    });
+}
+use sp_std::collections::vec_deque::VecDeque;
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_weight_commits --exact --nocapture
+#[test]
+fn test_swap_weight_commits() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let netuid = 0u16;
+        let mut weight_commits: VecDeque<(H256, u64, u64, u64)> = VecDeque::new();
+        weight_commits.push_back((H256::from_low_u64_be(100), 200, 1, 1));
+        let mut weight = Weight::zero();
+
+        add_network(netuid, 1, 1);
+        IsNetworkMember::<Test>::insert(old_hotkey, netuid, true);
+        WeightCommits::<Test>::insert(netuid, old_hotkey, weight_commits.clone());
+
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight
+        ));
+
+        assert!(!WeightCommits::<Test>::contains_key(netuid, old_hotkey));
+        assert_eq!(
+            WeightCommits::<Test>::get(netuid, new_hotkey),
+            Some(weight_commits)
+        );
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_loaded_emission --exact --nocapture
+#[test]
+fn test_swap_loaded_emission() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let netuid = 0u16;
+        let server_emission = 1000u64;
+        let validator_emission = 1000u64;
+        let mut weight = Weight::zero();
+
+        add_network(netuid, 1, 1);
+        IsNetworkMember::<Test>::insert(old_hotkey, netuid, true);
+        LoadedEmission::<Test>::insert(
+            netuid,
+            vec![(old_hotkey, server_emission, validator_emission)],
+        );
+
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight
+        ));
+
+        let new_loaded_emission = LoadedEmission::<Test>::get(netuid);
+        assert_eq!(
+            new_loaded_emission,
+            Some(vec![(new_hotkey, server_emission, validator_emission)])
+        );
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_staking_hotkeys --exact --nocapture
+#[test]
+fn test_swap_staking_hotkeys() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+
+        let subnet_owner_coldkey = U256::from(1001);
+        let subnet_owner_hotkey = U256::from(1002);
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+
+        let mut weight = Weight::zero();
+
+        StakingHotkeys::<Test>::insert(coldkey, vec![old_hotkey]);
+        Alpha::<Test>::insert((old_hotkey, coldkey, netuid), U64F64::from_num(100));
+
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight
+        ));
+
+        let staking_hotkeys = StakingHotkeys::<Test>::get(coldkey);
+        assert!(!staking_hotkeys.contains(&old_hotkey));
+        assert!(staking_hotkeys.contains(&new_hotkey));
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor --lib -- tests::swap_hotkey::test_swap_hotkey_with_multiple_coldkeys --exact --show-output --nocapture
+#[test]
+fn test_swap_hotkey_with_multiple_coldkeys() {
+    new_test_ext(1).execute_with(|| {
+        let subnet_owner_coldkey = U256::from(1001);
+        let subnet_owner_hotkey = U256::from(1002);
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey1 = U256::from(3);
+        let coldkey2 = U256::from(4);
+        let mut weight = Weight::zero();
+        let stake = 1_000_000_000;
+
+        StakingHotkeys::<Test>::insert(coldkey1, vec![old_hotkey]);
+        StakingHotkeys::<Test>::insert(coldkey2, vec![old_hotkey]);
+        SubtensorModule::create_account_if_non_existent(&coldkey1, &old_hotkey);
+        SubtensorModule::add_balance_to_coldkey_account(
+            &coldkey1,
+            stake + ExistentialDeposit::get(),
+        );
+        SubtensorModule::add_balance_to_coldkey_account(
+            &coldkey2,
+            stake + ExistentialDeposit::get(),
+        );
+
+        assert_ok!(SubtensorModule::add_stake(
+            RuntimeOrigin::signed(coldkey1),
+            old_hotkey,
+            netuid,
+            stake
+        ));
+        assert_ok!(SubtensorModule::add_stake(
+            RuntimeOrigin::signed(coldkey2),
+            old_hotkey,
+            netuid,
+            stake / 2
+        ));
+        let stake1_before = SubtensorModule::get_total_stake_for_coldkey(&coldkey1);
+        let stake2_before = SubtensorModule::get_total_stake_for_coldkey(&coldkey2);
+
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey1,
+            &mut weight
+        ));
+
+        assert_eq!(
+            SubtensorModule::get_total_stake_for_coldkey(&coldkey1),
+            stake1_before
+        );
+        assert_eq!(
+            SubtensorModule::get_total_stake_for_coldkey(&coldkey2),
+            stake2_before
+        );
+        assert!(StakingHotkeys::<Test>::get(coldkey1).contains(&new_hotkey));
+        assert!(StakingHotkeys::<Test>::get(coldkey2).contains(&new_hotkey));
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_hotkey_with_multiple_subnets --exact --nocapture
+#[test]
+fn test_swap_hotkey_with_multiple_subnets() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let netuid1 = 0;
+        let netuid2 = 1;
+        let mut weight = Weight::zero();
+
+        add_network(netuid1, 1, 1);
+        add_network(netuid2, 1, 1);
+        IsNetworkMember::<Test>::insert(old_hotkey, netuid1, true);
+        IsNetworkMember::<Test>::insert(old_hotkey, netuid2, true);
+
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight
+        ));
+
+        assert!(IsNetworkMember::<Test>::get(new_hotkey, netuid1));
+        assert!(IsNetworkMember::<Test>::get(new_hotkey, netuid2));
+        assert!(!IsNetworkMember::<Test>::get(old_hotkey, netuid1));
+        assert!(!IsNetworkMember::<Test>::get(old_hotkey, netuid2));
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_staking_hotkeys_multiple_coldkeys --exact --nocapture
+#[test]
+fn test_swap_staking_hotkeys_multiple_coldkeys() {
+    new_test_ext(1).execute_with(|| {
+        let subnet_owner_coldkey = U256::from(1001);
+        let subnet_owner_hotkey = U256::from(1002);
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey1 = U256::from(3);
+        let coldkey2 = U256::from(4);
+        let staker5 = U256::from(5);
+        let mut weight = Weight::zero();
+        let stake = 1_000_000_000;
+
+        // Set up initial state
+        StakingHotkeys::<Test>::insert(coldkey1, vec![old_hotkey]);
+        StakingHotkeys::<Test>::insert(coldkey2, vec![old_hotkey, staker5]);
+
+        SubtensorModule::create_account_if_non_existent(&coldkey1, &old_hotkey);
+        SubtensorModule::add_balance_to_coldkey_account(
+            &coldkey1,
+            stake + ExistentialDeposit::get(),
+        );
+        SubtensorModule::add_balance_to_coldkey_account(
+            &coldkey2,
+            stake + ExistentialDeposit::get(),
+        );
+        assert_ok!(SubtensorModule::add_stake(
+            RuntimeOrigin::signed(coldkey1),
+            old_hotkey,
+            netuid,
+            stake
+        ));
+        assert_ok!(SubtensorModule::add_stake(
+            RuntimeOrigin::signed(coldkey2),
+            old_hotkey,
+            netuid,
+            stake
+        ));
+
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey1,
+            &mut weight
+        ));
+
+        // Check if new_hotkey replaced old_hotkey in StakingHotkeys
+        assert!(StakingHotkeys::<Test>::get(coldkey1).contains(&new_hotkey));
+        assert!(!StakingHotkeys::<Test>::get(coldkey1).contains(&old_hotkey));
+
+        // Check if new_hotkey replaced old_hotkey for coldkey2 as well
+        assert!(StakingHotkeys::<Test>::get(coldkey2).contains(&new_hotkey));
+        assert!(!StakingHotkeys::<Test>::get(coldkey2).contains(&old_hotkey));
+        assert!(StakingHotkeys::<Test>::get(coldkey2).contains(&staker5));
+        // Other hotkeys should remain
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_hotkey_with_no_stake --exact --nocapture
+#[test]
+fn test_swap_hotkey_with_no_stake() {
+    new_test_ext(1).execute_with(|| {
+        let subnet_owner_coldkey = U256::from(1001);
+        let subnet_owner_hotkey = U256::from(1002);
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let mut weight = Weight::zero();
+
+        // Set up initial state with no stake
+        Owner::<Test>::insert(old_hotkey, coldkey);
+
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight
+        ));
+
+        // Check if ownership transferred
+        assert!(!Owner::<Test>::contains_key(old_hotkey));
+        assert_eq!(Owner::<Test>::get(new_hotkey), coldkey);
+
+        // Ensure no unexpected changes in Stake
+        assert!(!Alpha::<Test>::contains_key((old_hotkey, coldkey, netuid)));
+        assert!(!Alpha::<Test>::contains_key((new_hotkey, coldkey, netuid)));
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor --lib -- tests::swap_hotkey::test_swap_hotkey_with_multiple_coldkeys_and_subnets --exact --show-output
+#[test]
+fn test_swap_hotkey_with_multiple_coldkeys_and_subnets() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey1 = U256::from(3);
+        let coldkey2 = U256::from(4);
+        let netuid1 = 1;
+        let netuid2 = 2;
+        let stake = DefaultMinStake::<Test>::get() * 10;
+        let mut weight = Weight::zero();
+
+        // Set up initial state
+        add_network(netuid1, 1, 1);
+        add_network(netuid2, 1, 1);
+        register_ok_neuron(netuid1, old_hotkey, coldkey1, 1234);
+        register_ok_neuron(netuid2, old_hotkey, coldkey1, 1234);
+
+        // Add balance to both coldkeys
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey1, stake + 1_000);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey2, stake + 1_000);
+
+        // Stake with coldkey1
+        assert_ok!(SubtensorModule::add_stake(
+            <<Test as Config>::RuntimeOrigin>::signed(coldkey1),
+            old_hotkey,
+            netuid1,
+            stake
+        ));
+
+        // Stake with coldkey2 also
+        assert_ok!(SubtensorModule::add_stake(
+            <<Test as Config>::RuntimeOrigin>::signed(coldkey2),
+            old_hotkey,
+            netuid2,
+            stake
+        ));
+
+        let ck1_stake = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+            &old_hotkey,
+            &coldkey1,
+            netuid1,
+        );
+        let ck2_stake = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+            &old_hotkey,
+            &coldkey2,
+            netuid2,
+        );
+        assert!(ck1_stake > 0);
+        assert!(ck2_stake > 0);
+        let total_hk_stake = SubtensorModule::get_total_stake_for_hotkey(&old_hotkey);
+        assert!(total_hk_stake > 0);
+
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey1,
+            &mut weight
+        ));
+
+        // Check ownership transfer
+        assert_eq!(
+            SubtensorModule::get_owning_coldkey_for_hotkey(&new_hotkey),
+            coldkey1
+        );
+        assert!(!SubtensorModule::get_owned_hotkeys(&coldkey2).contains(&new_hotkey));
+
+        // Check stake transfer
+        assert_eq!(
+            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+                &new_hotkey,
+                &coldkey1,
+                netuid1
+            ),
+            ck1_stake
+        );
+        assert_eq!(
+            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+                &new_hotkey,
+                &coldkey2,
+                netuid2
+            ),
+            ck2_stake
+        );
+        assert_eq!(
+            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+                &old_hotkey,
+                &coldkey1,
+                netuid1
+            ),
+            0
+        );
+        assert_eq!(
+            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+                &old_hotkey,
+                &coldkey2,
+                netuid2
+            ),
+            0
+        );
+
+        // Check subnet membership transfer
+        assert!(SubtensorModule::is_hotkey_registered_on_network(
+            netuid1,
+            &new_hotkey
+        ));
+        assert!(SubtensorModule::is_hotkey_registered_on_network(
+            netuid2,
+            &new_hotkey
+        ));
+        assert!(!SubtensorModule::is_hotkey_registered_on_network(
+            netuid1,
+            &old_hotkey
+        ));
+        assert!(!SubtensorModule::is_hotkey_registered_on_network(
+            netuid2,
+            &old_hotkey
+        ));
+
+        // Check total stake transfer
+        assert_eq!(
+            SubtensorModule::get_total_stake_for_hotkey(&new_hotkey),
+            total_hk_stake
+        );
+        assert_eq!(SubtensorModule::get_total_stake_for_hotkey(&old_hotkey), 0);
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_hotkey_tx_rate_limit_exceeded --exact --nocapture
+#[test]
+fn test_swap_hotkey_tx_rate_limit_exceeded() {
+    new_test_ext(1).execute_with(|| {
+        let netuid: u16 = 1;
+        let tempo: u16 = 13;
+        let old_hotkey = U256::from(1);
+        let new_hotkey_1 = U256::from(2);
+        let new_hotkey_2 = U256::from(4);
+        let coldkey = U256::from(3);
+        let swap_cost = 1_000_000_000u64 * 2;
+
+        let tx_rate_limit = 1;
+
+        // Get the current transaction rate limit
+        let current_tx_rate_limit = SubtensorModule::get_tx_rate_limit();
+        log::info!("current_tx_rate_limit: {:?}", current_tx_rate_limit);
+
+        // Set the transaction rate limit
+        SubtensorModule::set_tx_rate_limit(tx_rate_limit);
+        // assert the rate limit is set to 1000 blocks
+        assert_eq!(SubtensorModule::get_tx_rate_limit(), tx_rate_limit);
+
+        // Setup initial state
+        add_network(netuid, tempo, 0);
+        register_ok_neuron(netuid, old_hotkey, coldkey, 0);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, swap_cost);
+
+        // Perform the first swap
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            <<Test as Config>::RuntimeOrigin>::signed(coldkey),
+            &old_hotkey,
+            &new_hotkey_1,
+            None
+        ));
+
+        // Attempt to perform another swap immediately, which should fail due to rate limit
+        assert_err!(
+            SubtensorModule::do_swap_hotkey(
+                <<Test as Config>::RuntimeOrigin>::signed(coldkey),
+                &new_hotkey_1,
+                &new_hotkey_2,
+                None
+            ),
+            Error::<Test>::HotKeySetTxRateLimitExceeded
+        );
+
+        // move in time past the rate limit
+        step_block(1001);
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            <<Test as Config>::RuntimeOrigin>::signed(coldkey),
+            &new_hotkey_1,
+            &new_hotkey_2,
+            None
+        ));
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_do_swap_hotkey_err_not_owner --exact --nocapture
+#[test]
+fn test_do_swap_hotkey_err_not_owner() {
+    new_test_ext(1).execute_with(|| {
+        let netuid: u16 = 1;
+        let tempo: u16 = 13;
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let not_owner_coldkey = U256::from(4);
+        let swap_cost = 1_000_000_000u64;
+
+        // Setup initial state
+        add_network(netuid, tempo, 0);
+        register_ok_neuron(netuid, old_hotkey, coldkey, 0);
+        SubtensorModule::add_balance_to_coldkey_account(&not_owner_coldkey, swap_cost);
+
+        // Attempt the swap with a non-owner coldkey
+        assert_err!(
+            SubtensorModule::do_swap_hotkey(
+                <<Test as Config>::RuntimeOrigin>::signed(not_owner_coldkey),
+                &old_hotkey,
+                &new_hotkey,
+                None
+            ),
+            Error::<Test>::NonAssociatedColdKey
+        );
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_owner_success --exact --nocapture
+#[test]
+fn test_swap_owner_success() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let mut weight = Weight::zero();
+
+        // Initialize Owner for old_hotkey
+        Owner::<Test>::insert(old_hotkey, coldkey);
+
+        // Perform the swap
+        SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight,
+        );
+
+        // Verify the swap
+        assert_eq!(Owner::<Test>::get(new_hotkey), coldkey);
+        assert!(!Owner::<Test>::contains_key(old_hotkey));
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_owner_old_hotkey_not_exist --exact --nocapture
+#[test]
+fn test_swap_owner_old_hotkey_not_exist() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let mut weight = Weight::zero();
+
+        // Ensure old_hotkey does not exist
+        assert!(!Owner::<Test>::contains_key(old_hotkey));
+
+        // Perform the swap
+        SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight,
+        );
+
+        // Verify the swap
+        assert_eq!(Owner::<Test>::get(new_hotkey), coldkey);
+        assert!(!Owner::<Test>::contains_key(old_hotkey));
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_owner_new_hotkey_already_exists --exact --nocapture
+#[test]
+fn test_swap_owner_new_hotkey_already_exists() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let another_coldkey = U256::from(4);
+        let mut weight = Weight::zero();
+
+        // Initialize Owner for old_hotkey and new_hotkey
+        Owner::<Test>::insert(old_hotkey, coldkey);
+        Owner::<Test>::insert(new_hotkey, another_coldkey);
+
+        // Perform the swap
+        SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight,
+        );
+
+        // Verify the swap
+        assert_eq!(Owner::<Test>::get(new_hotkey), coldkey);
+        assert!(!Owner::<Test>::contains_key(old_hotkey));
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor --lib -- tests::swap_hotkey::test_swap_delegates_success --exact --show-output
+#[test]
+fn test_swap_delegates_success() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let delegate_take = 10u16;
+        let mut weight = Weight::zero();
+
+        // Initialize Delegates for old_hotkey
+        Delegates::<Test>::insert(old_hotkey, delegate_take);
+
+        // Perform the swap
+        SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight,
+        );
+
+        // Verify the swap
+        assert_eq!(Delegates::<Test>::get(new_hotkey), delegate_take);
+        assert!(!Delegates::<Test>::contains_key(old_hotkey));
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_stake_success --exact --nocapture
+#[test]
+fn test_swap_stake_success() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let subnet_owner_coldkey = U256::from(1001);
+        let subnet_owner_hotkey = U256::from(1002);
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+        let amount = 10_000;
+        let shares = U64F64::from_num(123456);
+        let mut weight = Weight::zero();
+
+        // Initialize staking variables for old_hotkey
+        TotalHotkeyAlpha::<Test>::insert(old_hotkey, netuid, amount);
+        TotalHotkeyAlphaLastEpoch::<Test>::insert(old_hotkey, netuid, amount * 2);
+        TotalHotkeyShares::<Test>::insert(old_hotkey, netuid, U64F64::from_num(shares));
+        Alpha::<Test>::insert((old_hotkey, coldkey, netuid), U64F64::from_num(amount));
+        AlphaDividendsPerSubnet::<Test>::insert(netuid, old_hotkey, amount);
+        TaoDividendsPerSubnet::<Test>::insert(netuid, old_hotkey, amount);
+
+        // Perform the swap
+        SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight,
+        );
+
+        // Verify the swap
+        assert_eq!(TotalHotkeyAlpha::<Test>::get(old_hotkey, netuid), 0);
+        assert_eq!(TotalHotkeyAlpha::<Test>::get(new_hotkey, netuid), amount);
+        assert_eq!(
+            TotalHotkeyAlphaLastEpoch::<Test>::get(old_hotkey, netuid),
+            0
+        );
+        assert_eq!(
+            TotalHotkeyAlphaLastEpoch::<Test>::get(new_hotkey, netuid),
+            amount * 2
+        );
+        assert_eq!(
+            TotalHotkeyShares::<Test>::get(old_hotkey, netuid),
+            U64F64::from_num(0)
+        );
+        assert_eq!(
+            TotalHotkeyShares::<Test>::get(new_hotkey, netuid),
+            U64F64::from_num(shares)
+        );
+        assert_eq!(
+            Alpha::<Test>::get((old_hotkey, coldkey, netuid)),
+            U64F64::from_num(0)
+        );
+        assert_eq!(
+            Alpha::<Test>::get((new_hotkey, coldkey, netuid)),
+            U64F64::from_num(amount)
+        );
+        assert_eq!(AlphaDividendsPerSubnet::<Test>::get(netuid, old_hotkey), 0);
+        assert_eq!(
+            AlphaDividendsPerSubnet::<Test>::get(netuid, new_hotkey),
+            amount
+        );
+        assert_eq!(TaoDividendsPerSubnet::<Test>::get(netuid, old_hotkey), 0);
+        assert_eq!(
+            TaoDividendsPerSubnet::<Test>::get(netuid, new_hotkey),
+            amount
+        );
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_stake_old_hotkey_not_exist --exact --nocapture
+#[test]
+fn test_swap_stake_old_hotkey_not_exist() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let subnet_owner_coldkey = U256::from(1001);
+        let subnet_owner_hotkey = U256::from(1002);
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+
+        let alpha_share = U64F64::from_num(1234);
+        let mut weight = Weight::zero();
+
+        // Initialize Stake for old_hotkey
+        Alpha::<Test>::insert((old_hotkey, coldkey, netuid), alpha_share);
+
+        // Ensure old_hotkey has a stake
+        assert!(Alpha::<Test>::contains_key((old_hotkey, coldkey, netuid)));
+
+        // Perform the swap
+        SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight,
+        );
+
+        // Verify that new_hotkey has the stake and old_hotkey does not
+        assert!(Alpha::<Test>::contains_key((new_hotkey, coldkey, netuid)));
+        assert!(!Alpha::<Test>::contains_key((old_hotkey, coldkey, netuid)));
+    });
+}
+
+// // SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_total_hotkey_coldkey_stakes_this_interval_success --exact --nocapture
+// #[test]
+// fn test_swap_total_hotkey_coldkey_stakes_this_interval_success() {
+//     new_test_ext(1).execute_with(|| {
+//         let old_hotkey = U256::from(1);
+//         let new_hotkey = U256::from(2);
+//         let coldkey = U256::from(3);
+//         let stake = (1000u64, 42u64); // Example tuple value
+//         let mut weight = Weight::zero();
+
+//         // Initialize TotalHotkeyColdkeyStakesThisInterval for old_hotkey
+//         TotalHotkeyColdkeyStakesThisInterval::<Test>::insert(old_hotkey, coldkey, stake);
+
+//         // Perform the swap
+//         SubtensorModule::perform_hotkey_swap_on_all_subnets(&old_hotkey, &new_hotkey, &coldkey, &mut weight);
+
+//         // Verify the swap
+//         assert_eq!(
+//             TotalHotkeyColdkeyStakesThisInterval::<Test>::get(new_hotkey, coldkey),
+//             stake
+//         );
+//         assert!(!TotalHotkeyColdkeyStakesThisInterval::<Test>::contains_key(
+//             old_hotkey, coldkey
+//         ));
+//     });
+// }
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_hotkey_error_cases --exact --nocapture
+#[test]
+fn test_swap_hotkey_error_cases() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let wrong_coldkey = U256::from(4);
+
+        // Set up initial state
+        Owner::<Test>::insert(old_hotkey, coldkey);
+        TotalNetworks::<Test>::put(1);
+        LastTxBlock::<Test>::insert(coldkey, 0);
+
+        // Test not enough balance
+        let swap_cost = SubtensorModule::get_key_swap_cost();
+        assert_noop!(
+            SubtensorModule::do_swap_hotkey(
+                RuntimeOrigin::signed(coldkey),
+                &old_hotkey,
+                &new_hotkey,
+                None
+            ),
+            Error::<Test>::NotEnoughBalanceToPaySwapHotKey
+        );
+
+        let initial_balance = SubtensorModule::get_key_swap_cost() + 1000;
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, initial_balance);
+
+        // Test new hotkey same as old
+        assert_noop!(
+            SubtensorModule::do_swap_hotkey(
+                RuntimeOrigin::signed(coldkey),
+                &old_hotkey,
+                &old_hotkey,
+                None
+            ),
+            Error::<Test>::NewHotKeyIsSameWithOld
+        );
+
+        // Test new hotkey already registered
+        IsNetworkMember::<Test>::insert(new_hotkey, 0, true);
+        assert_noop!(
+            SubtensorModule::do_swap_hotkey(
+                RuntimeOrigin::signed(coldkey),
+                &old_hotkey,
+                &new_hotkey,
+                None
+            ),
+            Error::<Test>::HotKeyAlreadyRegisteredInSubNet
+        );
+        IsNetworkMember::<Test>::remove(new_hotkey, 0);
+
+        // Test non-associated coldkey
+        assert_noop!(
+            SubtensorModule::do_swap_hotkey(
+                RuntimeOrigin::signed(wrong_coldkey),
+                &old_hotkey,
+                &new_hotkey,
+                None
+            ),
+            Error::<Test>::NonAssociatedColdKey
+        );
+
+        // Run the successful swap
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
+            &old_hotkey,
+            &new_hotkey,
+            None
+        ));
+
+        // Check balance after swap
+        assert_eq!(Balances::free_balance(coldkey), initial_balance - swap_cost);
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_child_keys --exact --nocapture
+#[test]
+fn test_swap_child_keys() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let netuid = 0u16;
+        let children = vec![(100u64, U256::from(4)), (200u64, U256::from(5))];
+        let mut weight = Weight::zero();
+
+        // Initialize ChildKeys for old_hotkey
+        add_network(netuid, 1, 0);
+        ChildKeys::<Test>::insert(old_hotkey, netuid, children.clone());
+
+        // Perform the swap
+        SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight,
+        );
+
+        // Verify the swap
+        assert_eq!(ChildKeys::<Test>::get(new_hotkey, netuid), children);
+        assert!(ChildKeys::<Test>::get(old_hotkey, netuid).is_empty());
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_parent_keys --exact --nocapture
+#[test]
+fn test_swap_parent_keys() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let netuid = 0u16;
+        let parents = vec![(100u64, U256::from(4)), (200u64, U256::from(5))];
+        let mut weight = Weight::zero();
+
+        // Initialize ParentKeys for old_hotkey
+        add_network(netuid, 1, 0);
+        ParentKeys::<Test>::insert(old_hotkey, netuid, parents.clone());
+
+        // Initialize ChildKeys for parent
+        ChildKeys::<Test>::insert(U256::from(4), netuid, vec![(100u64, old_hotkey)]);
+        ChildKeys::<Test>::insert(U256::from(5), netuid, vec![(200u64, old_hotkey)]);
+
+        // Perform the swap
+        SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight,
+        );
+
+        // Verify ParentKeys swap
+        assert_eq!(ParentKeys::<Test>::get(new_hotkey, netuid), parents);
+        assert!(ParentKeys::<Test>::get(old_hotkey, netuid).is_empty());
+
+        // Verify ChildKeys update for parents
+        assert_eq!(
+            ChildKeys::<Test>::get(U256::from(4), netuid),
+            vec![(100u64, new_hotkey)]
+        );
+        assert_eq!(
+            ChildKeys::<Test>::get(U256::from(5), netuid),
+            vec![(200u64, new_hotkey)]
+        );
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_multiple_subnets --exact --nocapture
+#[test]
+fn test_swap_multiple_subnets() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let netuid1 = 0u16;
+        let netuid2 = 1u16;
+        let children1 = vec![(100u64, U256::from(4)), (200u64, U256::from(5))];
+        let children2 = vec![(300u64, U256::from(6))];
+        let mut weight = Weight::zero();
+
+        add_network(netuid1, 1, 0);
+        add_network(netuid2, 1, 0);
+
+        // Initialize ChildKeys for old_hotkey in multiple subnets
+        ChildKeys::<Test>::insert(old_hotkey, netuid1, children1.clone());
+        ChildKeys::<Test>::insert(old_hotkey, netuid2, children2.clone());
+
+        // Perform the swap
+        SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight,
+        );
+
+        // Verify the swap for both subnets
+        assert_eq!(ChildKeys::<Test>::get(new_hotkey, netuid1), children1);
+        assert_eq!(ChildKeys::<Test>::get(new_hotkey, netuid2), children2);
+        assert!(ChildKeys::<Test>::get(old_hotkey, netuid1).is_empty());
+        assert!(ChildKeys::<Test>::get(old_hotkey, netuid2).is_empty());
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_complex_parent_child_structure --exact --nocapture
+#[test]
+fn test_swap_complex_parent_child_structure() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let netuid = 0u16;
+        let parent1 = U256::from(4);
+        let parent2 = U256::from(5);
+        let child1 = U256::from(6);
+        let child2 = U256::from(7);
+        let mut weight = Weight::zero();
+
+        add_network(netuid, 1, 0);
+
+        // Set up complex parent-child structure
+        ParentKeys::<Test>::insert(
+            old_hotkey,
+            netuid,
+            vec![(100u64, parent1), (200u64, parent2)],
+        );
+        ChildKeys::<Test>::insert(old_hotkey, netuid, vec![(300u64, child1), (400u64, child2)]);
+        ChildKeys::<Test>::insert(
+            parent1,
+            netuid,
+            vec![(100u64, old_hotkey), (500u64, U256::from(8))],
+        );
+        ChildKeys::<Test>::insert(
+            parent2,
+            netuid,
+            vec![(200u64, old_hotkey), (600u64, U256::from(9))],
+        );
+
+        // Perform the swap
+        SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight,
+        );
+
+        // Verify ParentKeys swap
+        assert_eq!(
+            ParentKeys::<Test>::get(new_hotkey, netuid),
+            vec![(100u64, parent1), (200u64, parent2)]
+        );
+        assert!(ParentKeys::<Test>::get(old_hotkey, netuid).is_empty());
+
+        // Verify ChildKeys swap
+        assert_eq!(
+            ChildKeys::<Test>::get(new_hotkey, netuid),
+            vec![(300u64, child1), (400u64, child2)]
+        );
+        assert!(ChildKeys::<Test>::get(old_hotkey, netuid).is_empty());
+
+        // Verify parent's ChildKeys update
+        assert_eq!(
+            ChildKeys::<Test>::get(parent1, netuid),
+            vec![(100u64, new_hotkey), (500u64, U256::from(8))]
+        );
+        assert_eq!(
+            ChildKeys::<Test>::get(parent2, netuid),
+            vec![(200u64, new_hotkey), (600u64, U256::from(9))]
+        );
+    });
+}
+
+#[test]
+fn test_swap_parent_hotkey_childkey_maps() {
+    new_test_ext(1).execute_with(|| {
+        let netuid: u16 = 1;
+        let parent_old = U256::from(1);
+        let coldkey = U256::from(2);
+        let child = U256::from(3);
+        let child_other = U256::from(4);
+        let parent_new = U256::from(4);
+        add_network(netuid, 1, 0);
+        SubtensorModule::create_account_if_non_existent(&coldkey, &parent_old);
+
+        // Set child and verify state maps
+        mock_set_children(&coldkey, &parent_old, netuid, &[(u64::MAX, child)]);
+        // Wait rate limit
+        step_rate_limit(&TransactionType::SetChildren, netuid);
+        // Schedule some pending child keys.
+        mock_schedule_children(&coldkey, &parent_old, netuid, &[(u64::MAX, child_other)]);
+
+        assert_eq!(
+            ParentKeys::<Test>::get(child, netuid),
+            vec![(u64::MAX, parent_old)]
+        );
+        assert_eq!(
+            ChildKeys::<Test>::get(parent_old, netuid),
+            vec![(u64::MAX, child)]
+        );
+        let existing_pending_child_keys = PendingChildKeys::<Test>::get(netuid, parent_old);
+        assert_eq!(existing_pending_child_keys.0, vec![(u64::MAX, child_other)]);
+
+        // Swap
+        let mut weight = Weight::zero();
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &parent_old,
+            &parent_new,
+            &coldkey,
+            &mut weight
+        ));
+
+        // Verify parent and child keys updates
+        assert_eq!(
+            ParentKeys::<Test>::get(child, netuid),
+            vec![(u64::MAX, parent_new)]
+        );
+        assert_eq!(
+            ChildKeys::<Test>::get(parent_new, netuid),
+            vec![(u64::MAX, child)]
+        );
+        assert_eq!(
+            PendingChildKeys::<Test>::get(netuid, parent_new),
+            existing_pending_child_keys // Entry under new hotkey.
+        );
+    })
+}
+
+#[test]
+fn test_swap_child_hotkey_childkey_maps() {
+    new_test_ext(1).execute_with(|| {
+        let netuid: u16 = 1;
+        let parent = U256::from(1);
+        let coldkey = U256::from(2);
+        let child_old = U256::from(3);
+        let child_new = U256::from(4);
+        add_network(netuid, 1, 0);
+        SubtensorModule::create_account_if_non_existent(&coldkey, &child_old);
+        SubtensorModule::create_account_if_non_existent(&coldkey, &parent);
+
+        // Set child and verify state maps
+        mock_set_children(&coldkey, &parent, netuid, &[(u64::MAX, child_old)]);
+        // Wait rate limit
+        step_rate_limit(&TransactionType::SetChildren, netuid);
+        // Schedule some pending child keys.
+        mock_schedule_children(&coldkey, &parent, netuid, &[(u64::MAX, child_old)]);
+
+        assert_eq!(
+            ParentKeys::<Test>::get(child_old, netuid),
+            vec![(u64::MAX, parent)]
+        );
+        assert_eq!(
+            ChildKeys::<Test>::get(parent, netuid),
+            vec![(u64::MAX, child_old)]
+        );
+        let existing_pending_child_keys = PendingChildKeys::<Test>::get(netuid, parent);
+        assert_eq!(existing_pending_child_keys.0, vec![(u64::MAX, child_old)]);
+
+        // Swap
+        let mut weight = Weight::zero();
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &child_old,
+            &child_new,
+            &coldkey,
+            &mut weight
+        ));
+
+        // Verify parent and child keys updates
+        assert_eq!(
+            ParentKeys::<Test>::get(child_new, netuid),
+            vec![(u64::MAX, parent)]
+        );
+        assert_eq!(
+            ChildKeys::<Test>::get(parent, netuid),
+            vec![(u64::MAX, child_new)]
+        );
+        assert_eq!(
+            PendingChildKeys::<Test>::get(netuid, parent),
+            (vec![(u64::MAX, child_new)], existing_pending_child_keys.1) // Same cooldown block.
+        );
+    })
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_hotkey_is_sn_owner_hotkey --exact --nocapture
+#[test]
+fn test_swap_hotkey_is_sn_owner_hotkey() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let mut weight = Weight::zero();
+
+        // Create dynamic network
+        let netuid = add_dynamic_network(&old_hotkey, &coldkey);
+        // Check for SubnetOwnerHotkey
+        assert_eq!(SubnetOwnerHotkey::<Test>::get(netuid), old_hotkey);
+
+        // Perform the swap
+        SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight,
+        );
+
+        // Check for SubnetOwnerHotkey
+        assert_eq!(SubnetOwnerHotkey::<Test>::get(netuid), new_hotkey);
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_hotkey_swap_rate_limits --exact --nocapture
+#[test]
+fn test_swap_hotkey_swap_rate_limits() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let mut weight = Weight::zero();
+
+        let last_tx_block = 123;
+        let delegate_take_block = 4567;
+        let child_key_take_block = 8910;
+
+        // Set the last tx block for the old hotkey
+        LastTxBlock::<Test>::insert(old_hotkey, last_tx_block);
+        // Set the last delegate take block for the old hotkey
+        LastTxBlockDelegateTake::<Test>::insert(old_hotkey, delegate_take_block);
+        // Set last childkey take block for the old hotkey
+        LastTxBlockChildKeyTake::<Test>::insert(old_hotkey, child_key_take_block);
+
+        // Perform the swap
+        SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight,
+        );
+
+        // Check for new hotkey
+        assert_eq!(LastTxBlock::<Test>::get(new_hotkey), last_tx_block);
+        assert_eq!(
+            LastTxBlockDelegateTake::<Test>::get(new_hotkey),
+            delegate_take_block
+        );
+        assert_eq!(
+            LastTxBlockChildKeyTake::<Test>::get(new_hotkey),
+            child_key_take_block
+        );
+    });
+}
+
+#[test]
+fn test_swap_hotkey_on_specific_subnet_successful() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+
+        let subnet_owner_coldkey = U256::from(1001);
+        let subnet_owner_hotkey = U256::from(1002);
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+
+        let mut weight = Weight::zero();
+
+        Owner::<Test>::insert(old_hotkey, coldkey);
+        SubtensorModule::perform_hotkey_swap_on_one_subnet(
+            &old_hotkey,
+            &new_hotkey,
+            &mut weight,
+            netuid,
+        );
+
+        assert!(!Owner::<Test>::contains_key(old_hotkey));
+        assert!(!Owner::<Test>::contains_key(new_hotkey));
+        // assert_eq!(Owner::<Test>::get(new_hotkey), coldkey);
+    });
+}

From e10c37cd018bdd50b948a762d9513d997ab9e1e8 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Fri, 2 May 2025 17:21:08 +0800
Subject: [PATCH 095/418] fix an old test

---
 pallets/subtensor/src/tests/swap_hotkey.rs | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/pallets/subtensor/src/tests/swap_hotkey.rs b/pallets/subtensor/src/tests/swap_hotkey.rs
index 27c60cc6b1..1587976bbf 100644
--- a/pallets/subtensor/src/tests/swap_hotkey.rs
+++ b/pallets/subtensor/src/tests/swap_hotkey.rs
@@ -125,8 +125,14 @@ fn test_swap_senate_members() {
         let coldkey = U256::from(3);
         let mut weight = Weight::zero();
 
-        // Assuming there's a way to add a member to the senate
-        // SenateMembers::add_member(&old_hotkey);
+        assert_ok!(SenateMembers::add_member(
+            RuntimeOrigin::root(),
+            old_hotkey.clone()
+        ));
+        let members = SenateMembers::members();
+        assert!(members.contains(&old_hotkey));
+        assert!(!members.contains(&new_hotkey));
+
         assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
             &old_hotkey,
             &new_hotkey,
@@ -135,8 +141,9 @@ fn test_swap_senate_members() {
         ));
 
         // Assert that the old_hotkey is no longer a member and new_hotkey is now a member
-        // assert!(!SenateMembers::is_member(&old_hotkey));
-        // assert!(SenateMembers::is_member(&new_hotkey));
+        let members = SenateMembers::members();
+        assert!(!members.contains(&old_hotkey));
+        assert!(members.contains(&new_hotkey));
     });
 }
 

From 41dd31382fd6d808eda223749f57a4c669da2e3f Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Fri, 2 May 2025 19:45:57 +0800
Subject: [PATCH 096/418] fix more test case

---
 pallets/subtensor/src/staking/helpers.rs      |  10 +-
 pallets/subtensor/src/swap/swap_hotkey.rs     | 100 ++++++---
 .../src/tests/swap_hotkey_with_subnet.rs      | 200 ++++++++++--------
 3 files changed, 190 insertions(+), 120 deletions(-)

diff --git a/pallets/subtensor/src/staking/helpers.rs b/pallets/subtensor/src/staking/helpers.rs
index 9ee04f36a8..fc0088c771 100644
--- a/pallets/subtensor/src/staking/helpers.rs
+++ b/pallets/subtensor/src/staking/helpers.rs
@@ -60,7 +60,7 @@ impl<T: Config> Pallet<T> {
     //
     pub fn get_total_stake_for_coldkey(coldkey: &T::AccountId) -> u64 {
         let hotkeys = StakingHotkeys::<T>::get(coldkey);
-        hotkeys
+        let result = hotkeys
             .iter()
             .map(|hotkey| {
                 let mut total_stake: u64 = 0;
@@ -76,7 +76,13 @@ impl<T: Config> Pallet<T> {
                 }
                 total_stake
             })
-            .sum::<u64>()
+            .sum::<u64>();
+        log::error!(
+            "======== get_total_stake_for_coldkey: coldkey: {:?}, total_stake: {:?}",
+            coldkey,
+            result
+        );
+        result
     }
 
     // Creates a cold - hot pairing account if the hotkey is not already an active account.
diff --git a/pallets/subtensor/src/swap/swap_hotkey.rs b/pallets/subtensor/src/swap/swap_hotkey.rs
index 5e51e86503..3266ce031f 100644
--- a/pallets/subtensor/src/swap/swap_hotkey.rs
+++ b/pallets/subtensor/src/swap/swap_hotkey.rs
@@ -253,35 +253,37 @@ impl<T: Config> Pallet<T> {
             weight.saturating_accrue(T::DbWeight::get().writes(1));
         }
 
-        // 11. Swap Alpha
-        // Alpha( hotkey, coldkey, netuid ) -> alpha
-        let old_alpha_values: Vec<((T::AccountId, u16), U64F64)> =
-            Alpha::<T>::iter_prefix((old_hotkey,)).collect();
-        // Clear the entire old prefix here.
-        let _ = Alpha::<T>::clear_prefix((old_hotkey,), old_alpha_values.len() as u32, None);
-        weight.saturating_accrue(T::DbWeight::get().reads(old_alpha_values.len() as u64));
-        weight.saturating_accrue(T::DbWeight::get().writes(old_alpha_values.len() as u64));
-
-        // Insert the new alpha values.
-        for ((coldkey, netuid), alpha) in old_alpha_values {
-            let new_alpha = Alpha::<T>::get((new_hotkey, &coldkey, netuid));
-            Alpha::<T>::insert(
-                (new_hotkey, &coldkey, netuid),
-                new_alpha.saturating_add(alpha),
-            );
-            weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
-
-            // Swap StakingHotkeys.
-            // StakingHotkeys( coldkey ) --> Vec<hotkey> -- the hotkeys that the coldkey stakes.
-            let mut staking_hotkeys = StakingHotkeys::<T>::get(&coldkey);
-            weight.saturating_accrue(T::DbWeight::get().reads(1));
-            if staking_hotkeys.contains(old_hotkey) {
-                staking_hotkeys.retain(|hk| *hk != *old_hotkey && *hk != *new_hotkey);
-                staking_hotkeys.push(new_hotkey.clone());
-                StakingHotkeys::<T>::insert(&coldkey, staking_hotkeys);
-                weight.saturating_accrue(T::DbWeight::get().writes(1));
-            }
-        }
+        // // 11. Swap Alpha
+        // // Alpha( hotkey, coldkey, netuid ) -> alpha
+        // let old_alpha_values: Vec<((T::AccountId, u16), U64F64)> =
+        //     Alpha::<T>::iter_prefix((old_hotkey,)).collect();
+        // // Clear the entire old prefix here.
+        // let _ = Alpha::<T>::clear_prefix((old_hotkey,), old_alpha_values.len() as u32, None);
+        // weight.saturating_accrue(T::DbWeight::get().reads(old_alpha_values.len() as u64));
+        // weight.saturating_accrue(T::DbWeight::get().writes(old_alpha_values.len() as u64));
+
+        // // Insert the new alpha values.
+        // for ((coldkey, netuid), alpha) in old_alpha_values {
+        //     let new_alpha = Alpha::<T>::get((new_hotkey, &coldkey, netuid));
+        //     Alpha::<T>::insert(
+        //         (new_hotkey, &coldkey, netuid),
+        //         new_alpha.saturating_add(alpha),
+        //     );
+        //     weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
+
+        //     // Swap StakingHotkeys.
+        //     // StakingHotkeys( coldkey ) --> Vec<hotkey> -- the hotkeys that the coldkey stakes.
+        //     let mut staking_hotkeys = StakingHotkeys::<T>::get(&coldkey);
+        //     weight.saturating_accrue(T::DbWeight::get().reads(1));
+        //     if staking_hotkeys.contains(old_hotkey) {
+        //         staking_hotkeys.retain(|hk| *hk != *old_hotkey && *hk != *new_hotkey);
+        //         if !staking_hotkeys.contains(new_hotkey) {
+        //             staking_hotkeys.push(new_hotkey.clone());
+        //         }
+        //         StakingHotkeys::<T>::insert(&coldkey, staking_hotkeys);
+        //         weight.saturating_accrue(T::DbWeight::get().writes(1));
+        //     }
+        // }
 
         // Return successful after swapping all the relevant terms.
         Ok(())
@@ -360,6 +362,14 @@ impl<T: Config> Pallet<T> {
         Self::set_last_tx_block(coldkey, block);
         weight.saturating_accrue(T::DbWeight::get().writes(1));
 
+        let mut staking_hotkeys = StakingHotkeys::<T>::get(coldkey);
+        weight.saturating_accrue(T::DbWeight::get().reads(1));
+        if staking_hotkeys.contains(old_hotkey) && !staking_hotkeys.contains(new_hotkey) {
+            staking_hotkeys.push(new_hotkey.clone());
+            StakingHotkeys::<T>::insert(coldkey, staking_hotkeys);
+            weight.saturating_accrue(T::DbWeight::get().writes(1));
+        }
+
         // 16. Emit an event for the hotkey swap
         Self::deposit_event(Event::HotkeySwappedOnSubnet {
             coldkey: coldkey.clone(),
@@ -604,6 +614,38 @@ impl<T: Config> Pallet<T> {
         );
         weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 2));
 
+        // 11. Swap Alpha
+        // Alpha( hotkey, coldkey, netuid ) -> alpha
+        let old_alpha_values: Vec<((T::AccountId, u16), U64F64)> =
+            Alpha::<T>::iter_prefix((old_hotkey,)).collect();
+        // Clear the entire old prefix here.
+        // let _ = Alpha::<T>::clear_prefix((old_hotkey,), old_alpha_values.len() as u32, None);
+        weight.saturating_accrue(T::DbWeight::get().reads(old_alpha_values.len() as u64));
+        weight.saturating_accrue(T::DbWeight::get().writes(old_alpha_values.len() as u64));
+
+        // Insert the new alpha values.
+        for ((coldkey, netuid_alpha), alpha) in old_alpha_values {
+            if netuid == netuid_alpha {
+                let new_alpha = Alpha::<T>::take((new_hotkey, &coldkey, netuid));
+                Alpha::<T>::insert(
+                    (new_hotkey, &coldkey, netuid),
+                    new_alpha.saturating_add(alpha),
+                );
+                weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
+
+                // Swap StakingHotkeys.
+                // StakingHotkeys( coldkey ) --> Vec<hotkey> -- the hotkeys that the coldkey stakes.
+                let mut staking_hotkeys = StakingHotkeys::<T>::get(&coldkey);
+                weight.saturating_accrue(T::DbWeight::get().reads(1));
+                if staking_hotkeys.contains(old_hotkey) && !staking_hotkeys.contains(new_hotkey) {
+                    staking_hotkeys.push(new_hotkey.clone());
+
+                    StakingHotkeys::<T>::insert(&coldkey, staking_hotkeys);
+                    weight.saturating_accrue(T::DbWeight::get().writes(1));
+                }
+            }
+        }
+
         // Return successful after swapping all the relevant terms.
         // Ok(())
     }
diff --git a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
index 96d902e0da..2afe09426e 100644
--- a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
+++ b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
@@ -1,5 +1,7 @@
 #![allow(unused, clippy::indexing_slicing, clippy::panic, clippy::unwrap_used)]
 
+use core::u64;
+
 use approx::assert_abs_diff_eq;
 use codec::Encode;
 use frame_support::weights::Weight;
@@ -159,16 +161,19 @@ fn test_swap_delegates() {
         let coldkey = U256::from(3);
         let mut weight = Weight::zero();
 
+        let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+
         Delegates::<Test>::insert(old_hotkey, 100);
-        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
             &old_hotkey,
             &new_hotkey,
-            &coldkey,
-            &mut weight
+            Some(netuid)
         ));
 
-        assert!(!Delegates::<Test>::contains_key(old_hotkey));
-        assert_eq!(Delegates::<Test>::get(new_hotkey), 100);
+        assert!(Delegates::<Test>::contains_key(old_hotkey));
+        assert!(!Delegates::<Test>::contains_key(new_hotkey));
     });
 }
 
@@ -179,16 +184,17 @@ fn test_swap_subnet_membership() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let netuid = 0u16;
         let mut weight = Weight::zero();
 
-        add_network(netuid, 1, 1);
+        let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+
         IsNetworkMember::<Test>::insert(old_hotkey, netuid, true);
-        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
             &old_hotkey,
             &new_hotkey,
-            &coldkey,
-            &mut weight
+            Some(netuid)
         ));
 
         assert!(!IsNetworkMember::<Test>::contains_key(old_hotkey, netuid));
@@ -200,23 +206,24 @@ fn test_swap_subnet_membership() {
 #[test]
 fn test_swap_uids_and_keys() {
     new_test_ext(1).execute_with(|| {
+        let uid = 5u16;
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let netuid = 0u16;
-        let uid = 5u16;
         let mut weight = Weight::zero();
 
-        add_network(netuid, 1, 1);
+        let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+
         IsNetworkMember::<Test>::insert(old_hotkey, netuid, true);
         Uids::<Test>::insert(netuid, old_hotkey, uid);
         Keys::<Test>::insert(netuid, uid, old_hotkey);
 
-        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
             &old_hotkey,
             &new_hotkey,
-            &coldkey,
-            &mut weight
+            Some(netuid)
         ));
 
         assert_eq!(Uids::<Test>::get(netuid, old_hotkey), None);
@@ -229,22 +236,24 @@ fn test_swap_uids_and_keys() {
 #[test]
 fn test_swap_prometheus() {
     new_test_ext(1).execute_with(|| {
+        let uid = 5u16;
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let netuid = 0u16;
-        let prometheus_info = PrometheusInfo::default();
         let mut weight = Weight::zero();
+        let prometheus_info = PrometheusInfo::default();
+
+        let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
 
-        add_network(netuid, 1, 1);
         IsNetworkMember::<Test>::insert(old_hotkey, netuid, true);
         Prometheus::<Test>::insert(netuid, old_hotkey, prometheus_info.clone());
 
-        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
             &old_hotkey,
             &new_hotkey,
-            &coldkey,
-            &mut weight
+            Some(netuid)
         ));
 
         assert!(!Prometheus::<Test>::contains_key(netuid, old_hotkey));
@@ -259,22 +268,24 @@ fn test_swap_prometheus() {
 #[test]
 fn test_swap_axons() {
     new_test_ext(1).execute_with(|| {
+        let uid = 5u16;
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let netuid = 0u16;
-        let axon_info = AxonInfo::default();
         let mut weight = Weight::zero();
+        let axon_info = AxonInfo::default();
+
+        let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
 
-        add_network(netuid, 1, 1);
         IsNetworkMember::<Test>::insert(old_hotkey, netuid, true);
         Axons::<Test>::insert(netuid, old_hotkey, axon_info.clone());
 
-        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
             &old_hotkey,
             &new_hotkey,
-            &coldkey,
-            &mut weight
+            Some(netuid)
         ));
 
         assert!(!Axons::<Test>::contains_key(netuid, old_hotkey));
@@ -286,22 +297,24 @@ fn test_swap_axons() {
 #[test]
 fn test_swap_certificates() {
     new_test_ext(1).execute_with(|| {
+        let uid = 5u16;
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let netuid = 0u16;
-        let certificate = NeuronCertificate::try_from(vec![1, 2, 3]).unwrap();
         let mut weight = Weight::zero();
+        let certificate = NeuronCertificate::try_from(vec![1, 2, 3]).unwrap();
+
+        let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
 
-        add_network(netuid, 1, 1);
         IsNetworkMember::<Test>::insert(old_hotkey, netuid, true);
         NeuronCertificates::<Test>::insert(netuid, old_hotkey, certificate.clone());
 
-        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
             &old_hotkey,
             &new_hotkey,
-            &coldkey,
-            &mut weight
+            Some(netuid)
         ));
 
         assert!(!NeuronCertificates::<Test>::contains_key(
@@ -318,23 +331,25 @@ use sp_std::collections::vec_deque::VecDeque;
 #[test]
 fn test_swap_weight_commits() {
     new_test_ext(1).execute_with(|| {
+        let uid = 5u16;
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let netuid = 0u16;
+        let mut weight = Weight::zero();
         let mut weight_commits: VecDeque<(H256, u64, u64, u64)> = VecDeque::new();
         weight_commits.push_back((H256::from_low_u64_be(100), 200, 1, 1));
-        let mut weight = Weight::zero();
 
-        add_network(netuid, 1, 1);
+        let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+
         IsNetworkMember::<Test>::insert(old_hotkey, netuid, true);
         WeightCommits::<Test>::insert(netuid, old_hotkey, weight_commits.clone());
 
-        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
             &old_hotkey,
             &new_hotkey,
-            &coldkey,
-            &mut weight
+            Some(netuid)
         ));
 
         assert!(!WeightCommits::<Test>::contains_key(netuid, old_hotkey));
@@ -349,26 +364,28 @@ fn test_swap_weight_commits() {
 #[test]
 fn test_swap_loaded_emission() {
     new_test_ext(1).execute_with(|| {
+        let uid = 5u16;
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let netuid = 0u16;
+        let mut weight = Weight::zero();
         let server_emission = 1000u64;
         let validator_emission = 1000u64;
-        let mut weight = Weight::zero();
 
-        add_network(netuid, 1, 1);
+        let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+
         IsNetworkMember::<Test>::insert(old_hotkey, netuid, true);
         LoadedEmission::<Test>::insert(
             netuid,
             vec![(old_hotkey, server_emission, validator_emission)],
         );
 
-        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
             &old_hotkey,
             &new_hotkey,
-            &coldkey,
-            &mut weight
+            Some(netuid)
         ));
 
         let new_loaded_emission = LoadedEmission::<Test>::get(netuid);
@@ -386,25 +403,23 @@ fn test_swap_staking_hotkeys() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-
-        let subnet_owner_coldkey = U256::from(1001);
-        let subnet_owner_hotkey = U256::from(1002);
-        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+        let netuid = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
 
         let mut weight = Weight::zero();
 
         StakingHotkeys::<Test>::insert(coldkey, vec![old_hotkey]);
         Alpha::<Test>::insert((old_hotkey, coldkey, netuid), U64F64::from_num(100));
 
-        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
             &old_hotkey,
             &new_hotkey,
-            &coldkey,
-            &mut weight
+            Some(netuid)
         ));
 
         let staking_hotkeys = StakingHotkeys::<Test>::get(coldkey);
-        assert!(!staking_hotkeys.contains(&old_hotkey));
+        assert!(staking_hotkeys.contains(&old_hotkey));
         assert!(staking_hotkeys.contains(&new_hotkey));
     });
 }
@@ -427,14 +442,8 @@ fn test_swap_hotkey_with_multiple_coldkeys() {
         StakingHotkeys::<Test>::insert(coldkey1, vec![old_hotkey]);
         StakingHotkeys::<Test>::insert(coldkey2, vec![old_hotkey]);
         SubtensorModule::create_account_if_non_existent(&coldkey1, &old_hotkey);
-        SubtensorModule::add_balance_to_coldkey_account(
-            &coldkey1,
-            stake + ExistentialDeposit::get(),
-        );
-        SubtensorModule::add_balance_to_coldkey_account(
-            &coldkey2,
-            stake + ExistentialDeposit::get(),
-        );
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey1, u64::MAX);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey2, u64::MAX);
 
         assert_ok!(SubtensorModule::add_stake(
             RuntimeOrigin::signed(coldkey1),
@@ -451,13 +460,22 @@ fn test_swap_hotkey_with_multiple_coldkeys() {
         let stake1_before = SubtensorModule::get_total_stake_for_coldkey(&coldkey1);
         let stake2_before = SubtensorModule::get_total_stake_for_coldkey(&coldkey2);
 
-        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey1),
             &old_hotkey,
             &new_hotkey,
-            &coldkey1,
-            &mut weight
+            Some(netuid)
         ));
 
+        assert_eq!(
+            SubtensorModule::get_total_stake_for_coldkey(&coldkey1),
+            SubtensorModule::get_total_stake_for_coldkey(&coldkey1),
+        );
+        assert_eq!(
+            SubtensorModule::get_total_stake_for_coldkey(&coldkey2),
+            SubtensorModule::get_total_stake_for_coldkey(&coldkey2),
+        );
+
         assert_eq!(
             SubtensorModule::get_total_stake_for_coldkey(&coldkey1),
             stake1_before
@@ -466,6 +484,7 @@ fn test_swap_hotkey_with_multiple_coldkeys() {
             SubtensorModule::get_total_stake_for_coldkey(&coldkey2),
             stake2_before
         );
+
         assert!(StakingHotkeys::<Test>::get(coldkey1).contains(&new_hotkey));
         assert!(StakingHotkeys::<Test>::get(coldkey2).contains(&new_hotkey));
     });
@@ -478,20 +497,27 @@ fn test_swap_hotkey_with_multiple_subnets() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let netuid1 = 0;
-        let netuid2 = 1;
         let mut weight = Weight::zero();
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+
+        let netuid1 = add_dynamic_network(&old_hotkey, &coldkey);
+        let netuid2 = add_dynamic_network(&old_hotkey, &coldkey);
 
-        add_network(netuid1, 1, 1);
-        add_network(netuid2, 1, 1);
         IsNetworkMember::<Test>::insert(old_hotkey, netuid1, true);
         IsNetworkMember::<Test>::insert(old_hotkey, netuid2, true);
 
-        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
             &old_hotkey,
             &new_hotkey,
-            &coldkey,
-            &mut weight
+            Some(netuid1)
+        ));
+
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
+            &old_hotkey,
+            &new_hotkey,
+            Some(netuid2)
         ));
 
         assert!(IsNetworkMember::<Test>::get(new_hotkey, netuid1));
@@ -516,20 +542,15 @@ fn test_swap_staking_hotkeys_multiple_coldkeys() {
         let staker5 = U256::from(5);
         let mut weight = Weight::zero();
         let stake = 1_000_000_000;
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey1, u64::MAX);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey2, u64::MAX);
 
         // Set up initial state
         StakingHotkeys::<Test>::insert(coldkey1, vec![old_hotkey]);
         StakingHotkeys::<Test>::insert(coldkey2, vec![old_hotkey, staker5]);
 
         SubtensorModule::create_account_if_non_existent(&coldkey1, &old_hotkey);
-        SubtensorModule::add_balance_to_coldkey_account(
-            &coldkey1,
-            stake + ExistentialDeposit::get(),
-        );
-        SubtensorModule::add_balance_to_coldkey_account(
-            &coldkey2,
-            stake + ExistentialDeposit::get(),
-        );
+
         assert_ok!(SubtensorModule::add_stake(
             RuntimeOrigin::signed(coldkey1),
             old_hotkey,
@@ -543,20 +564,20 @@ fn test_swap_staking_hotkeys_multiple_coldkeys() {
             stake
         ));
 
-        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey1),
             &old_hotkey,
             &new_hotkey,
-            &coldkey1,
-            &mut weight
+            Some(netuid)
         ));
 
         // Check if new_hotkey replaced old_hotkey in StakingHotkeys
         assert!(StakingHotkeys::<Test>::get(coldkey1).contains(&new_hotkey));
-        assert!(!StakingHotkeys::<Test>::get(coldkey1).contains(&old_hotkey));
+        assert!(StakingHotkeys::<Test>::get(coldkey1).contains(&old_hotkey));
 
         // Check if new_hotkey replaced old_hotkey for coldkey2 as well
         assert!(StakingHotkeys::<Test>::get(coldkey2).contains(&new_hotkey));
-        assert!(!StakingHotkeys::<Test>::get(coldkey2).contains(&old_hotkey));
+        assert!(StakingHotkeys::<Test>::get(coldkey2).contains(&old_hotkey));
         assert!(StakingHotkeys::<Test>::get(coldkey2).contains(&staker5));
         // Other hotkeys should remain
     });
@@ -574,19 +595,20 @@ fn test_swap_hotkey_with_no_stake() {
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
         let mut weight = Weight::zero();
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
 
         // Set up initial state with no stake
         Owner::<Test>::insert(old_hotkey, coldkey);
 
-        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
             &old_hotkey,
             &new_hotkey,
-            &coldkey,
-            &mut weight
+            Some(netuid)
         ));
 
         // Check if ownership transferred
-        assert!(!Owner::<Test>::contains_key(old_hotkey));
+        assert!(Owner::<Test>::contains_key(old_hotkey));
         assert_eq!(Owner::<Test>::get(new_hotkey), coldkey);
 
         // Ensure no unexpected changes in Stake

From 8b335e8d732f9d93b2ee0dbac18d73173a96ac4a Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Fri, 2 May 2025 20:08:25 +0800
Subject: [PATCH 097/418] commit Cargo.lock

---
 pallets/subtensor/src/benchmarks.rs | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/pallets/subtensor/src/benchmarks.rs b/pallets/subtensor/src/benchmarks.rs
index 9201a73fc5..787a761675 100644
--- a/pallets/subtensor/src/benchmarks.rs
+++ b/pallets/subtensor/src/benchmarks.rs
@@ -1433,7 +1433,12 @@ mod pallet_benchmarks {
         Subtensor::<T>::add_balance_to_coldkey_account(&coldkey, cost);
 
         #[extrinsic_call]
-        _(RawOrigin::Signed(coldkey.clone()), old.clone(), new.clone());
+        _(
+            RawOrigin::Signed(coldkey.clone()),
+            old.clone(),
+            new.clone(),
+            None,
+        );
     }
 
     #[benchmark]

From 70f768fcb9134fcc22002833b2b0c896847abbbc Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Fri, 2 May 2025 20:09:19 +0800
Subject: [PATCH 098/418] cargo clippy

---
 pallets/subtensor/src/tests/swap_hotkey.rs             | 2 +-
 pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/pallets/subtensor/src/tests/swap_hotkey.rs b/pallets/subtensor/src/tests/swap_hotkey.rs
index 1587976bbf..fac64431fb 100644
--- a/pallets/subtensor/src/tests/swap_hotkey.rs
+++ b/pallets/subtensor/src/tests/swap_hotkey.rs
@@ -127,7 +127,7 @@ fn test_swap_senate_members() {
 
         assert_ok!(SenateMembers::add_member(
             RuntimeOrigin::root(),
-            old_hotkey.clone()
+            old_hotkey
         ));
         let members = SenateMembers::members();
         assert!(members.contains(&old_hotkey));
diff --git a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
index 2afe09426e..34e04d3766 100644
--- a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
+++ b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
@@ -136,7 +136,7 @@ fn test_swap_senate_members() {
 
         assert_ok!(SenateMembers::add_member(
             RuntimeOrigin::root(),
-            old_hotkey.clone()
+            old_hotkey
         ));
 
         assert_ok!(SubtensorModule::do_swap_hotkey(

From 51360f8a6dcfa75c9bcd1942228d70cffa07c63d Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Fri, 2 May 2025 20:09:51 +0800
Subject: [PATCH 099/418] cargo fmt

---
 pallets/subtensor/src/tests/swap_hotkey.rs             | 5 +----
 pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs | 5 +----
 2 files changed, 2 insertions(+), 8 deletions(-)

diff --git a/pallets/subtensor/src/tests/swap_hotkey.rs b/pallets/subtensor/src/tests/swap_hotkey.rs
index fac64431fb..9b2b9d2197 100644
--- a/pallets/subtensor/src/tests/swap_hotkey.rs
+++ b/pallets/subtensor/src/tests/swap_hotkey.rs
@@ -125,10 +125,7 @@ fn test_swap_senate_members() {
         let coldkey = U256::from(3);
         let mut weight = Weight::zero();
 
-        assert_ok!(SenateMembers::add_member(
-            RuntimeOrigin::root(),
-            old_hotkey
-        ));
+        assert_ok!(SenateMembers::add_member(RuntimeOrigin::root(), old_hotkey));
         let members = SenateMembers::members();
         assert!(members.contains(&old_hotkey));
         assert!(!members.contains(&new_hotkey));
diff --git a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
index 34e04d3766..e5a0037537 100644
--- a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
+++ b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
@@ -134,10 +134,7 @@ fn test_swap_senate_members() {
         let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
 
-        assert_ok!(SenateMembers::add_member(
-            RuntimeOrigin::root(),
-            old_hotkey
-        ));
+        assert_ok!(SenateMembers::add_member(RuntimeOrigin::root(), old_hotkey));
 
         assert_ok!(SubtensorModule::do_swap_hotkey(
             RuntimeOrigin::signed(coldkey),

From fa7c9df4930dfdf252d439361534ceccf190bbc4 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Fri, 2 May 2025 20:44:00 +0800
Subject: [PATCH 100/418] commit Cargo.lock

---
 pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
index e5a0037537..490950c174 100644
--- a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
+++ b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
@@ -1,7 +1,5 @@
 #![allow(unused, clippy::indexing_slicing, clippy::panic, clippy::unwrap_used)]
 
-use core::u64;
-
 use approx::assert_abs_diff_eq;
 use codec::Encode;
 use frame_support::weights::Weight;

From a37245b31e2014040461969aea400b063e214301 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Sat, 3 May 2025 11:53:06 +0800
Subject: [PATCH 101/418] fix test case

---
 .../src/tests/swap_hotkey_with_subnet.rs      | 132 +++++++-----------
 1 file changed, 49 insertions(+), 83 deletions(-)

diff --git a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
index 490950c174..6330f59c40 100644
--- a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
+++ b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
@@ -632,8 +632,8 @@ fn test_swap_hotkey_with_multiple_coldkeys_and_subnets() {
         register_ok_neuron(netuid2, old_hotkey, coldkey1, 1234);
 
         // Add balance to both coldkeys
-        SubtensorModule::add_balance_to_coldkey_account(&coldkey1, stake + 1_000);
-        SubtensorModule::add_balance_to_coldkey_account(&coldkey2, stake + 1_000);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey1, u64::MAX);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey2, u64::MAX);
 
         // Stake with coldkey1
         assert_ok!(SubtensorModule::add_stake(
@@ -666,11 +666,18 @@ fn test_swap_hotkey_with_multiple_coldkeys_and_subnets() {
         let total_hk_stake = SubtensorModule::get_total_stake_for_hotkey(&old_hotkey);
         assert!(total_hk_stake > 0);
 
-        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey1),
             &old_hotkey,
             &new_hotkey,
-            &coldkey1,
-            &mut weight
+            Some(netuid1)
+        ));
+
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey1),
+            &old_hotkey,
+            &new_hotkey,
+            Some(netuid2)
         ));
 
         // Check ownership transfer
@@ -771,19 +778,19 @@ fn test_swap_hotkey_tx_rate_limit_exceeded() {
 
         // Perform the first swap
         assert_ok!(SubtensorModule::do_swap_hotkey(
-            <<Test as Config>::RuntimeOrigin>::signed(coldkey),
+            RuntimeOrigin::signed(coldkey),
             &old_hotkey,
             &new_hotkey_1,
-            None
-        ));
+            Some(netuid)
+        ),);
 
         // Attempt to perform another swap immediately, which should fail due to rate limit
         assert_err!(
             SubtensorModule::do_swap_hotkey(
-                <<Test as Config>::RuntimeOrigin>::signed(coldkey),
+                RuntimeOrigin::signed(coldkey),
+                &old_hotkey,
                 &new_hotkey_1,
-                &new_hotkey_2,
-                None
+                Some(netuid)
             ),
             Error::<Test>::HotKeySetTxRateLimitExceeded
         );
@@ -819,42 +826,16 @@ fn test_do_swap_hotkey_err_not_owner() {
         // Attempt the swap with a non-owner coldkey
         assert_err!(
             SubtensorModule::do_swap_hotkey(
-                <<Test as Config>::RuntimeOrigin>::signed(not_owner_coldkey),
+                RuntimeOrigin::signed(not_owner_coldkey),
                 &old_hotkey,
                 &new_hotkey,
-                None
+                Some(netuid)
             ),
             Error::<Test>::NonAssociatedColdKey
         );
     });
 }
 
-// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_owner_success --exact --nocapture
-#[test]
-fn test_swap_owner_success() {
-    new_test_ext(1).execute_with(|| {
-        let old_hotkey = U256::from(1);
-        let new_hotkey = U256::from(2);
-        let coldkey = U256::from(3);
-        let mut weight = Weight::zero();
-
-        // Initialize Owner for old_hotkey
-        Owner::<Test>::insert(old_hotkey, coldkey);
-
-        // Perform the swap
-        SubtensorModule::perform_hotkey_swap_on_all_subnets(
-            &old_hotkey,
-            &new_hotkey,
-            &coldkey,
-            &mut weight,
-        );
-
-        // Verify the swap
-        assert_eq!(Owner::<Test>::get(new_hotkey), coldkey);
-        assert!(!Owner::<Test>::contains_key(old_hotkey));
-    });
-}
-
 // SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_owner_old_hotkey_not_exist --exact --nocapture
 #[test]
 fn test_swap_owner_old_hotkey_not_exist() {
@@ -864,15 +845,21 @@ fn test_swap_owner_old_hotkey_not_exist() {
         let coldkey = U256::from(3);
         let mut weight = Weight::zero();
 
+        let netuid = add_dynamic_network(&new_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+
         // Ensure old_hotkey does not exist
         assert!(!Owner::<Test>::contains_key(old_hotkey));
 
         // Perform the swap
-        SubtensorModule::perform_hotkey_swap_on_all_subnets(
-            &old_hotkey,
-            &new_hotkey,
-            &coldkey,
-            &mut weight,
+        assert_err!(
+            SubtensorModule::do_swap_hotkey(
+                RuntimeOrigin::signed(coldkey),
+                &old_hotkey,
+                &new_hotkey,
+                Some(netuid)
+            ),
+            Error::<Test>::NonAssociatedColdKey
         );
 
         // Verify the swap
@@ -890,49 +877,27 @@ fn test_swap_owner_new_hotkey_already_exists() {
         let coldkey = U256::from(3);
         let another_coldkey = U256::from(4);
         let mut weight = Weight::zero();
+        let netuid = add_dynamic_network(&new_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
 
         // Initialize Owner for old_hotkey and new_hotkey
         Owner::<Test>::insert(old_hotkey, coldkey);
         Owner::<Test>::insert(new_hotkey, another_coldkey);
 
         // Perform the swap
-        SubtensorModule::perform_hotkey_swap_on_all_subnets(
-            &old_hotkey,
-            &new_hotkey,
-            &coldkey,
-            &mut weight,
-        );
-
-        // Verify the swap
-        assert_eq!(Owner::<Test>::get(new_hotkey), coldkey);
-        assert!(!Owner::<Test>::contains_key(old_hotkey));
-    });
-}
-
-// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor --lib -- tests::swap_hotkey::test_swap_delegates_success --exact --show-output
-#[test]
-fn test_swap_delegates_success() {
-    new_test_ext(1).execute_with(|| {
-        let old_hotkey = U256::from(1);
-        let new_hotkey = U256::from(2);
-        let coldkey = U256::from(3);
-        let delegate_take = 10u16;
-        let mut weight = Weight::zero();
-
-        // Initialize Delegates for old_hotkey
-        Delegates::<Test>::insert(old_hotkey, delegate_take);
-
-        // Perform the swap
-        SubtensorModule::perform_hotkey_swap_on_all_subnets(
-            &old_hotkey,
-            &new_hotkey,
-            &coldkey,
-            &mut weight,
+        assert_err!(
+            SubtensorModule::do_swap_hotkey(
+                RuntimeOrigin::signed(coldkey),
+                &old_hotkey,
+                &new_hotkey,
+                Some(netuid)
+            ),
+            Error::<Test>::HotKeyAlreadyRegisteredInSubNet
         );
 
         // Verify the swap
-        assert_eq!(Delegates::<Test>::get(new_hotkey), delegate_take);
-        assert!(!Delegates::<Test>::contains_key(old_hotkey));
+        assert_eq!(Owner::<Test>::get(old_hotkey), coldkey);
+        assert!(Owner::<Test>::contains_key(old_hotkey));
     });
 }
 
@@ -945,7 +910,8 @@ fn test_swap_stake_success() {
         let coldkey = U256::from(3);
         let subnet_owner_coldkey = U256::from(1001);
         let subnet_owner_hotkey = U256::from(1002);
-        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+        let netuid = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
         let amount = 10_000;
         let shares = U64F64::from_num(123456);
         let mut weight = Weight::zero();
@@ -959,12 +925,12 @@ fn test_swap_stake_success() {
         TaoDividendsPerSubnet::<Test>::insert(netuid, old_hotkey, amount);
 
         // Perform the swap
-        SubtensorModule::perform_hotkey_swap_on_all_subnets(
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
             &old_hotkey,
             &new_hotkey,
-            &coldkey,
-            &mut weight,
-        );
+            Some(netuid)
+        ),);
 
         // Verify the swap
         assert_eq!(TotalHotkeyAlpha::<Test>::get(old_hotkey, netuid), 0);

From 18e4bc447d0dd585ae39cc6f4f35c022c9dcd206 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Sat, 3 May 2025 13:05:27 +0800
Subject: [PATCH 102/418] all test case done

---
 pallets/subtensor/src/swap/swap_hotkey.rs     |  51 ++--
 pallets/subtensor/src/tests/swap_hotkey.rs    |  53 -----
 .../src/tests/swap_hotkey_with_subnet.rs      | 219 ++++++------------
 3 files changed, 101 insertions(+), 222 deletions(-)

diff --git a/pallets/subtensor/src/swap/swap_hotkey.rs b/pallets/subtensor/src/swap/swap_hotkey.rs
index 3266ce031f..116a521d60 100644
--- a/pallets/subtensor/src/swap/swap_hotkey.rs
+++ b/pallets/subtensor/src/swap/swap_hotkey.rs
@@ -56,10 +56,31 @@ impl<T: Config> Pallet<T> {
             Error::<T>::HotKeySetTxRateLimitExceeded
         );
 
+        // 9. Swap LastTxBlock
+        // LastTxBlock( hotkey ) --> u64 -- the last transaction block for the hotkey.
+        let last_tx_block: u64 = LastTxBlock::<T>::get(old_hotkey);
+        LastTxBlock::<T>::insert(new_hotkey, last_tx_block);
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
+
+        // 10. Swap LastTxBlockDelegateTake
+        // LastTxBlockDelegateTake( hotkey ) --> u64 -- the last transaction block for the hotkey delegate take.
+        let last_tx_block_delegate_take: u64 = LastTxBlockDelegateTake::<T>::get(old_hotkey);
+        LastTxBlockDelegateTake::<T>::insert(new_hotkey, last_tx_block_delegate_take);
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
+
+        // 11. Swap LastTxBlockChildKeyTake
+        // LastTxBlockChildKeyTake( hotkey ) --> u64 -- the last transaction block for the hotkey child key take.
+        let last_tx_block_child_key_take: u64 = LastTxBlockChildKeyTake::<T>::get(old_hotkey);
+        LastTxBlockChildKeyTake::<T>::insert(new_hotkey, last_tx_block_child_key_take);
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
+
         // 8. fork for swap hotkey on a specific subnet case after do the common check
         if let Some(netuid) = netuid {
             return Self::swap_hotkey_on_subnet(&coldkey, old_hotkey, new_hotkey, netuid, weight);
         };
+        LastTxBlock::<T>::remove(old_hotkey);
+        LastTxBlockDelegateTake::<T>::remove(old_hotkey);
+        LastTxBlockChildKeyTake::<T>::remove(old_hotkey);
 
         // following update just for swap hotkey in all subnets case
 
@@ -82,27 +103,6 @@ impl<T: Config> Pallet<T> {
         // 12. Remove the swap cost from the coldkey's account
         let actual_burn_amount = Self::remove_balance_from_coldkey_account(&coldkey, swap_cost)?;
 
-        // 9. Swap LastTxBlock
-        // LastTxBlock( hotkey ) --> u64 -- the last transaction block for the hotkey.
-        let last_tx_block: u64 = LastTxBlock::<T>::get(old_hotkey);
-        LastTxBlock::<T>::remove(old_hotkey);
-        LastTxBlock::<T>::insert(new_hotkey, last_tx_block);
-        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
-
-        // 10. Swap LastTxBlockDelegateTake
-        // LastTxBlockDelegateTake( hotkey ) --> u64 -- the last transaction block for the hotkey delegate take.
-        let last_tx_block_delegate_take: u64 = LastTxBlockDelegateTake::<T>::get(old_hotkey);
-        LastTxBlockDelegateTake::<T>::remove(old_hotkey);
-        LastTxBlockDelegateTake::<T>::insert(new_hotkey, last_tx_block_delegate_take);
-        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
-
-        // 11. Swap LastTxBlockChildKeyTake
-        // LastTxBlockChildKeyTake( hotkey ) --> u64 -- the last transaction block for the hotkey child key take.
-        let last_tx_block_child_key_take: u64 = LastTxBlockChildKeyTake::<T>::get(old_hotkey);
-        LastTxBlockChildKeyTake::<T>::remove(old_hotkey);
-        LastTxBlockChildKeyTake::<T>::insert(new_hotkey, last_tx_block_child_key_take);
-        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
-
         // 8. Swap Senate members.
         // Senate( hotkey ) --> ?
         if T::SenateMembers::is_member(old_hotkey) {
@@ -625,11 +625,17 @@ impl<T: Config> Pallet<T> {
 
         // Insert the new alpha values.
         for ((coldkey, netuid_alpha), alpha) in old_alpha_values {
+            log::error!("Alpha: {:?}", alpha);
+            log::error!("Coldkey: {:?}", coldkey);
+            log::error!("Netuid: {:?}", netuid_alpha);
             if netuid == netuid_alpha {
+                // let new_alpha = Alpha::<T>::take((old_hotkey, &coldkey, netuid));
                 let new_alpha = Alpha::<T>::take((new_hotkey, &coldkey, netuid));
+                Alpha::<T>::remove((old_hotkey, &coldkey, netuid));
+                log::error!("New Alpha: {:?}", new_alpha);
                 Alpha::<T>::insert(
                     (new_hotkey, &coldkey, netuid),
-                    new_alpha.saturating_add(alpha),
+                    alpha.saturating_add(new_alpha),
                 );
                 weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
 
@@ -638,6 +644,7 @@ impl<T: Config> Pallet<T> {
                 let mut staking_hotkeys = StakingHotkeys::<T>::get(&coldkey);
                 weight.saturating_accrue(T::DbWeight::get().reads(1));
                 if staking_hotkeys.contains(old_hotkey) && !staking_hotkeys.contains(new_hotkey) {
+                    log::error!("Staking hotkeys: {:?}", staking_hotkeys);
                     staking_hotkeys.push(new_hotkey.clone());
 
                     StakingHotkeys::<T>::insert(&coldkey, staking_hotkeys);
diff --git a/pallets/subtensor/src/tests/swap_hotkey.rs b/pallets/subtensor/src/tests/swap_hotkey.rs
index 9b2b9d2197..f6b1db9ec6 100644
--- a/pallets/subtensor/src/tests/swap_hotkey.rs
+++ b/pallets/subtensor/src/tests/swap_hotkey.rs
@@ -806,32 +806,6 @@ fn test_do_swap_hotkey_err_not_owner() {
     });
 }
 
-// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey -- test_swap_owner_success --exact --nocapture
-#[test]
-fn test_swap_owner_success() {
-    new_test_ext(1).execute_with(|| {
-        let old_hotkey = U256::from(1);
-        let new_hotkey = U256::from(2);
-        let coldkey = U256::from(3);
-        let mut weight = Weight::zero();
-
-        // Initialize Owner for old_hotkey
-        Owner::<Test>::insert(old_hotkey, coldkey);
-
-        // Perform the swap
-        SubtensorModule::perform_hotkey_swap_on_all_subnets(
-            &old_hotkey,
-            &new_hotkey,
-            &coldkey,
-            &mut weight,
-        );
-
-        // Verify the swap
-        assert_eq!(Owner::<Test>::get(new_hotkey), coldkey);
-        assert!(!Owner::<Test>::contains_key(old_hotkey));
-    });
-}
-
 // SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey -- test_swap_owner_old_hotkey_not_exist --exact --nocapture
 #[test]
 fn test_swap_owner_old_hotkey_not_exist() {
@@ -886,33 +860,6 @@ fn test_swap_owner_new_hotkey_already_exists() {
     });
 }
 
-// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor --lib -- tests::swap_hotkey::test_swap_delegates_success --exact --show-output
-#[test]
-fn test_swap_delegates_success() {
-    new_test_ext(1).execute_with(|| {
-        let old_hotkey = U256::from(1);
-        let new_hotkey = U256::from(2);
-        let coldkey = U256::from(3);
-        let delegate_take = 10u16;
-        let mut weight = Weight::zero();
-
-        // Initialize Delegates for old_hotkey
-        Delegates::<Test>::insert(old_hotkey, delegate_take);
-
-        // Perform the swap
-        SubtensorModule::perform_hotkey_swap_on_all_subnets(
-            &old_hotkey,
-            &new_hotkey,
-            &coldkey,
-            &mut weight,
-        );
-
-        // Verify the swap
-        assert_eq!(Delegates::<Test>::get(new_hotkey), delegate_take);
-        assert!(!Delegates::<Test>::contains_key(old_hotkey));
-    });
-}
-
 // SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey -- test_swap_stake_success --exact --nocapture
 #[test]
 fn test_swap_stake_success() {
diff --git a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
index 6330f59c40..74cda8a144 100644
--- a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
+++ b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
@@ -972,67 +972,6 @@ fn test_swap_stake_success() {
     });
 }
 
-// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_stake_old_hotkey_not_exist --exact --nocapture
-#[test]
-fn test_swap_stake_old_hotkey_not_exist() {
-    new_test_ext(1).execute_with(|| {
-        let old_hotkey = U256::from(1);
-        let new_hotkey = U256::from(2);
-        let coldkey = U256::from(3);
-        let subnet_owner_coldkey = U256::from(1001);
-        let subnet_owner_hotkey = U256::from(1002);
-        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
-
-        let alpha_share = U64F64::from_num(1234);
-        let mut weight = Weight::zero();
-
-        // Initialize Stake for old_hotkey
-        Alpha::<Test>::insert((old_hotkey, coldkey, netuid), alpha_share);
-
-        // Ensure old_hotkey has a stake
-        assert!(Alpha::<Test>::contains_key((old_hotkey, coldkey, netuid)));
-
-        // Perform the swap
-        SubtensorModule::perform_hotkey_swap_on_all_subnets(
-            &old_hotkey,
-            &new_hotkey,
-            &coldkey,
-            &mut weight,
-        );
-
-        // Verify that new_hotkey has the stake and old_hotkey does not
-        assert!(Alpha::<Test>::contains_key((new_hotkey, coldkey, netuid)));
-        assert!(!Alpha::<Test>::contains_key((old_hotkey, coldkey, netuid)));
-    });
-}
-
-// // SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_total_hotkey_coldkey_stakes_this_interval_success --exact --nocapture
-// #[test]
-// fn test_swap_total_hotkey_coldkey_stakes_this_interval_success() {
-//     new_test_ext(1).execute_with(|| {
-//         let old_hotkey = U256::from(1);
-//         let new_hotkey = U256::from(2);
-//         let coldkey = U256::from(3);
-//         let stake = (1000u64, 42u64); // Example tuple value
-//         let mut weight = Weight::zero();
-
-//         // Initialize TotalHotkeyColdkeyStakesThisInterval for old_hotkey
-//         TotalHotkeyColdkeyStakesThisInterval::<Test>::insert(old_hotkey, coldkey, stake);
-
-//         // Perform the swap
-//         SubtensorModule::perform_hotkey_swap_on_all_subnets(&old_hotkey, &new_hotkey, &coldkey, &mut weight);
-
-//         // Verify the swap
-//         assert_eq!(
-//             TotalHotkeyColdkeyStakesThisInterval::<Test>::get(new_hotkey, coldkey),
-//             stake
-//         );
-//         assert!(!TotalHotkeyColdkeyStakesThisInterval::<Test>::contains_key(
-//             old_hotkey, coldkey
-//         ));
-//     });
-// }
-
 // SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_hotkey_error_cases --exact --nocapture
 #[test]
 fn test_swap_hotkey_error_cases() {
@@ -1041,6 +980,7 @@ fn test_swap_hotkey_error_cases() {
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
         let wrong_coldkey = U256::from(4);
+        let netuid = add_dynamic_network(&old_hotkey, &coldkey);
 
         // Set up initial state
         Owner::<Test>::insert(old_hotkey, coldkey);
@@ -1054,7 +994,7 @@ fn test_swap_hotkey_error_cases() {
                 RuntimeOrigin::signed(coldkey),
                 &old_hotkey,
                 &new_hotkey,
-                None
+                Some(netuid)
             ),
             Error::<Test>::NotEnoughBalanceToPaySwapHotKey
         );
@@ -1068,23 +1008,23 @@ fn test_swap_hotkey_error_cases() {
                 RuntimeOrigin::signed(coldkey),
                 &old_hotkey,
                 &old_hotkey,
-                None
+                Some(netuid)
             ),
             Error::<Test>::NewHotKeyIsSameWithOld
         );
 
         // Test new hotkey already registered
-        IsNetworkMember::<Test>::insert(new_hotkey, 0, true);
+        IsNetworkMember::<Test>::insert(new_hotkey, netuid, true);
         assert_noop!(
             SubtensorModule::do_swap_hotkey(
                 RuntimeOrigin::signed(coldkey),
                 &old_hotkey,
                 &new_hotkey,
-                None
+                Some(netuid)
             ),
             Error::<Test>::HotKeyAlreadyRegisteredInSubNet
         );
-        IsNetworkMember::<Test>::remove(new_hotkey, 0);
+        IsNetworkMember::<Test>::remove(new_hotkey, netuid);
 
         // Test non-associated coldkey
         assert_noop!(
@@ -1092,7 +1032,7 @@ fn test_swap_hotkey_error_cases() {
                 RuntimeOrigin::signed(wrong_coldkey),
                 &old_hotkey,
                 &new_hotkey,
-                None
+                Some(netuid)
             ),
             Error::<Test>::NonAssociatedColdKey
         );
@@ -1102,11 +1042,8 @@ fn test_swap_hotkey_error_cases() {
             RuntimeOrigin::signed(coldkey),
             &old_hotkey,
             &new_hotkey,
-            None
-        ));
-
-        // Check balance after swap
-        assert_eq!(Balances::free_balance(coldkey), initial_balance - swap_cost);
+            Some(netuid)
+        ),);
     });
 }
 
@@ -1117,21 +1054,22 @@ fn test_swap_child_keys() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let netuid = 0u16;
+        let netuid = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+
         let children = vec![(100u64, U256::from(4)), (200u64, U256::from(5))];
         let mut weight = Weight::zero();
 
         // Initialize ChildKeys for old_hotkey
-        add_network(netuid, 1, 0);
         ChildKeys::<Test>::insert(old_hotkey, netuid, children.clone());
 
         // Perform the swap
-        SubtensorModule::perform_hotkey_swap_on_all_subnets(
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
             &old_hotkey,
             &new_hotkey,
-            &coldkey,
-            &mut weight,
-        );
+            Some(netuid)
+        ),);
 
         // Verify the swap
         assert_eq!(ChildKeys::<Test>::get(new_hotkey, netuid), children);
@@ -1146,12 +1084,12 @@ fn test_swap_parent_keys() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let netuid = 0u16;
+        let netuid = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
         let parents = vec![(100u64, U256::from(4)), (200u64, U256::from(5))];
         let mut weight = Weight::zero();
 
         // Initialize ParentKeys for old_hotkey
-        add_network(netuid, 1, 0);
         ParentKeys::<Test>::insert(old_hotkey, netuid, parents.clone());
 
         // Initialize ChildKeys for parent
@@ -1159,12 +1097,12 @@ fn test_swap_parent_keys() {
         ChildKeys::<Test>::insert(U256::from(5), netuid, vec![(200u64, old_hotkey)]);
 
         // Perform the swap
-        SubtensorModule::perform_hotkey_swap_on_all_subnets(
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
             &old_hotkey,
             &new_hotkey,
-            &coldkey,
-            &mut weight,
-        );
+            Some(netuid)
+        ),);
 
         // Verify ParentKeys swap
         assert_eq!(ParentKeys::<Test>::get(new_hotkey, netuid), parents);
@@ -1189,26 +1127,33 @@ fn test_swap_multiple_subnets() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let netuid1 = 0u16;
-        let netuid2 = 1u16;
+        let netuid1 = add_dynamic_network(&old_hotkey, &coldkey);
+        let netuid2 = add_dynamic_network(&old_hotkey, &coldkey);
+
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+
         let children1 = vec![(100u64, U256::from(4)), (200u64, U256::from(5))];
         let children2 = vec![(300u64, U256::from(6))];
         let mut weight = Weight::zero();
 
-        add_network(netuid1, 1, 0);
-        add_network(netuid2, 1, 0);
-
         // Initialize ChildKeys for old_hotkey in multiple subnets
         ChildKeys::<Test>::insert(old_hotkey, netuid1, children1.clone());
         ChildKeys::<Test>::insert(old_hotkey, netuid2, children2.clone());
 
         // Perform the swap
-        SubtensorModule::perform_hotkey_swap_on_all_subnets(
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
             &old_hotkey,
             &new_hotkey,
-            &coldkey,
-            &mut weight,
-        );
+            Some(netuid1)
+        ),);
+
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
+            &old_hotkey,
+            &new_hotkey,
+            Some(netuid2)
+        ),);
 
         // Verify the swap for both subnets
         assert_eq!(ChildKeys::<Test>::get(new_hotkey, netuid1), children1);
@@ -1225,15 +1170,14 @@ fn test_swap_complex_parent_child_structure() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let netuid = 0u16;
+        let netuid = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
         let parent1 = U256::from(4);
         let parent2 = U256::from(5);
         let child1 = U256::from(6);
         let child2 = U256::from(7);
         let mut weight = Weight::zero();
 
-        add_network(netuid, 1, 0);
-
         // Set up complex parent-child structure
         ParentKeys::<Test>::insert(
             old_hotkey,
@@ -1253,12 +1197,12 @@ fn test_swap_complex_parent_child_structure() {
         );
 
         // Perform the swap
-        SubtensorModule::perform_hotkey_swap_on_all_subnets(
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
             &old_hotkey,
             &new_hotkey,
-            &coldkey,
-            &mut weight,
-        );
+            Some(netuid)
+        ),);
 
         // Verify ParentKeys swap
         assert_eq!(
@@ -1289,13 +1233,15 @@ fn test_swap_complex_parent_child_structure() {
 #[test]
 fn test_swap_parent_hotkey_childkey_maps() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
         let parent_old = U256::from(1);
         let coldkey = U256::from(2);
         let child = U256::from(3);
         let child_other = U256::from(4);
         let parent_new = U256::from(4);
-        add_network(netuid, 1, 0);
+
+        let netuid = add_dynamic_network(&parent_old, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+
         SubtensorModule::create_account_if_non_existent(&coldkey, &parent_old);
 
         // Set child and verify state maps
@@ -1318,12 +1264,12 @@ fn test_swap_parent_hotkey_childkey_maps() {
 
         // Swap
         let mut weight = Weight::zero();
-        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
             &parent_old,
             &parent_new,
-            &coldkey,
-            &mut weight
-        ));
+            Some(netuid)
+        ),);
 
         // Verify parent and child keys updates
         assert_eq!(
@@ -1344,12 +1290,13 @@ fn test_swap_parent_hotkey_childkey_maps() {
 #[test]
 fn test_swap_child_hotkey_childkey_maps() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
         let parent = U256::from(1);
         let coldkey = U256::from(2);
         let child_old = U256::from(3);
         let child_new = U256::from(4);
-        add_network(netuid, 1, 0);
+        let netuid = add_dynamic_network(&child_old, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+
         SubtensorModule::create_account_if_non_existent(&coldkey, &child_old);
         SubtensorModule::create_account_if_non_existent(&coldkey, &parent);
 
@@ -1373,12 +1320,12 @@ fn test_swap_child_hotkey_childkey_maps() {
 
         // Swap
         let mut weight = Weight::zero();
-        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
             &child_old,
             &child_new,
-            &coldkey,
-            &mut weight
-        ));
+            Some(netuid)
+        ),);
 
         // Verify parent and child keys updates
         assert_eq!(
@@ -1407,16 +1354,18 @@ fn test_swap_hotkey_is_sn_owner_hotkey() {
 
         // Create dynamic network
         let netuid = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+
         // Check for SubnetOwnerHotkey
         assert_eq!(SubnetOwnerHotkey::<Test>::get(netuid), old_hotkey);
 
         // Perform the swap
-        SubtensorModule::perform_hotkey_swap_on_all_subnets(
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
             &old_hotkey,
             &new_hotkey,
-            &coldkey,
-            &mut weight,
-        );
+            Some(netuid)
+        ),);
 
         // Check for SubnetOwnerHotkey
         assert_eq!(SubnetOwnerHotkey::<Test>::get(netuid), new_hotkey);
@@ -1436,6 +1385,9 @@ fn test_swap_hotkey_swap_rate_limits() {
         let delegate_take_block = 4567;
         let child_key_take_block = 8910;
 
+        let netuid = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+
         // Set the last tx block for the old hotkey
         LastTxBlock::<Test>::insert(old_hotkey, last_tx_block);
         // Set the last delegate take block for the old hotkey
@@ -1444,12 +1396,12 @@ fn test_swap_hotkey_swap_rate_limits() {
         LastTxBlockChildKeyTake::<Test>::insert(old_hotkey, child_key_take_block);
 
         // Perform the swap
-        SubtensorModule::perform_hotkey_swap_on_all_subnets(
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
             &old_hotkey,
             &new_hotkey,
-            &coldkey,
-            &mut weight,
-        );
+            Some(netuid)
+        ),);
 
         // Check for new hotkey
         assert_eq!(LastTxBlock::<Test>::get(new_hotkey), last_tx_block);
@@ -1463,30 +1415,3 @@ fn test_swap_hotkey_swap_rate_limits() {
         );
     });
 }
-
-#[test]
-fn test_swap_hotkey_on_specific_subnet_successful() {
-    new_test_ext(1).execute_with(|| {
-        let old_hotkey = U256::from(1);
-        let new_hotkey = U256::from(2);
-        let coldkey = U256::from(3);
-
-        let subnet_owner_coldkey = U256::from(1001);
-        let subnet_owner_hotkey = U256::from(1002);
-        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
-
-        let mut weight = Weight::zero();
-
-        Owner::<Test>::insert(old_hotkey, coldkey);
-        SubtensorModule::perform_hotkey_swap_on_one_subnet(
-            &old_hotkey,
-            &new_hotkey,
-            &mut weight,
-            netuid,
-        );
-
-        assert!(!Owner::<Test>::contains_key(old_hotkey));
-        assert!(!Owner::<Test>::contains_key(new_hotkey));
-        // assert_eq!(Owner::<Test>::get(new_hotkey), coldkey);
-    });
-}

From 6e37a4c980036fbe781d581b4c216a98c79c5520 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Sat, 3 May 2025 13:06:14 +0800
Subject: [PATCH 103/418] clean up code

---
 pallets/subtensor/src/swap/swap_hotkey.rs | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/pallets/subtensor/src/swap/swap_hotkey.rs b/pallets/subtensor/src/swap/swap_hotkey.rs
index 116a521d60..04e42e8b16 100644
--- a/pallets/subtensor/src/swap/swap_hotkey.rs
+++ b/pallets/subtensor/src/swap/swap_hotkey.rs
@@ -625,14 +625,10 @@ impl<T: Config> Pallet<T> {
 
         // Insert the new alpha values.
         for ((coldkey, netuid_alpha), alpha) in old_alpha_values {
-            log::error!("Alpha: {:?}", alpha);
-            log::error!("Coldkey: {:?}", coldkey);
-            log::error!("Netuid: {:?}", netuid_alpha);
             if netuid == netuid_alpha {
                 // let new_alpha = Alpha::<T>::take((old_hotkey, &coldkey, netuid));
                 let new_alpha = Alpha::<T>::take((new_hotkey, &coldkey, netuid));
                 Alpha::<T>::remove((old_hotkey, &coldkey, netuid));
-                log::error!("New Alpha: {:?}", new_alpha);
                 Alpha::<T>::insert(
                     (new_hotkey, &coldkey, netuid),
                     alpha.saturating_add(new_alpha),
@@ -644,9 +640,7 @@ impl<T: Config> Pallet<T> {
                 let mut staking_hotkeys = StakingHotkeys::<T>::get(&coldkey);
                 weight.saturating_accrue(T::DbWeight::get().reads(1));
                 if staking_hotkeys.contains(old_hotkey) && !staking_hotkeys.contains(new_hotkey) {
-                    log::error!("Staking hotkeys: {:?}", staking_hotkeys);
                     staking_hotkeys.push(new_hotkey.clone());
-
                     StakingHotkeys::<T>::insert(&coldkey, staking_hotkeys);
                     weight.saturating_accrue(T::DbWeight::get().writes(1));
                 }

From 5fe01d8847a10a2218db950b4710cec17da03dea Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Sat, 3 May 2025 15:46:40 +0800
Subject: [PATCH 104/418] fix failed test cases

---
 pallets/subtensor/src/swap/swap_hotkey.rs     | 89 ++++++++++---------
 pallets/subtensor/src/tests/swap_hotkey.rs    |  4 +-
 .../src/tests/swap_hotkey_with_subnet.rs      |  2 +-
 3 files changed, 52 insertions(+), 43 deletions(-)

diff --git a/pallets/subtensor/src/swap/swap_hotkey.rs b/pallets/subtensor/src/swap/swap_hotkey.rs
index 04e42e8b16..f5208f2cd4 100644
--- a/pallets/subtensor/src/swap/swap_hotkey.rs
+++ b/pallets/subtensor/src/swap/swap_hotkey.rs
@@ -78,9 +78,6 @@ impl<T: Config> Pallet<T> {
         if let Some(netuid) = netuid {
             return Self::swap_hotkey_on_subnet(&coldkey, old_hotkey, new_hotkey, netuid, weight);
         };
-        LastTxBlock::<T>::remove(old_hotkey);
-        LastTxBlockDelegateTake::<T>::remove(old_hotkey);
-        LastTxBlockChildKeyTake::<T>::remove(old_hotkey);
 
         // following update just for swap hotkey in all subnets case
 
@@ -103,6 +100,10 @@ impl<T: Config> Pallet<T> {
         // 12. Remove the swap cost from the coldkey's account
         let actual_burn_amount = Self::remove_balance_from_coldkey_account(&coldkey, swap_cost)?;
 
+        LastTxBlock::<T>::remove(old_hotkey);
+        LastTxBlockDelegateTake::<T>::remove(old_hotkey);
+        LastTxBlockChildKeyTake::<T>::remove(old_hotkey);
+
         // 8. Swap Senate members.
         // Senate( hotkey ) --> ?
         if T::SenateMembers::is_member(old_hotkey) {
@@ -181,6 +182,8 @@ impl<T: Config> Pallet<T> {
         coldkey: &T::AccountId,
         weight: &mut Weight,
     ) -> DispatchResult {
+        let old_alpha_values: Vec<((T::AccountId, u16), U64F64)> =
+            Alpha::<T>::iter_prefix((old_hotkey,)).collect();
         // 1. Swap owner.
         // Owner( hotkey ) -> coldkey -- the coldkey that owns the hotkey.
         Owner::<T>::remove(old_hotkey);
@@ -244,46 +247,45 @@ impl<T: Config> Pallet<T> {
 
         // Swap StakingHotkeys.
         // StakingHotkeys( coldkey ) --> Vec<hotkey> -- the hotkeys that the coldkey stakes.
-        let mut staking_hotkeys = StakingHotkeys::<T>::get(coldkey);
-        weight.saturating_accrue(T::DbWeight::get().reads(1));
-        if staking_hotkeys.contains(old_hotkey) {
-            staking_hotkeys.retain(|hk| *hk != *old_hotkey && *hk != *new_hotkey);
-            staking_hotkeys.push(new_hotkey.clone());
-            StakingHotkeys::<T>::insert(coldkey, staking_hotkeys);
-            weight.saturating_accrue(T::DbWeight::get().writes(1));
-        }
+        // let mut staking_hotkeys = StakingHotkeys::<T>::get(coldkey);
+        // weight.saturating_accrue(T::DbWeight::get().reads(1));
+        // if staking_hotkeys.contains(old_hotkey) {
+        //     staking_hotkeys.retain(|hk| *hk != *old_hotkey && *hk != *new_hotkey);
+        //     staking_hotkeys.push(new_hotkey.clone());
+        //     StakingHotkeys::<T>::insert(coldkey, staking_hotkeys);
+        //     weight.saturating_accrue(T::DbWeight::get().writes(1));
+        // }
 
         // // 11. Swap Alpha
         // // Alpha( hotkey, coldkey, netuid ) -> alpha
-        // let old_alpha_values: Vec<((T::AccountId, u16), U64F64)> =
-        //     Alpha::<T>::iter_prefix((old_hotkey,)).collect();
+
         // // Clear the entire old prefix here.
         // let _ = Alpha::<T>::clear_prefix((old_hotkey,), old_alpha_values.len() as u32, None);
         // weight.saturating_accrue(T::DbWeight::get().reads(old_alpha_values.len() as u64));
         // weight.saturating_accrue(T::DbWeight::get().writes(old_alpha_values.len() as u64));
 
         // // Insert the new alpha values.
-        // for ((coldkey, netuid), alpha) in old_alpha_values {
-        //     let new_alpha = Alpha::<T>::get((new_hotkey, &coldkey, netuid));
-        //     Alpha::<T>::insert(
-        //         (new_hotkey, &coldkey, netuid),
-        //         new_alpha.saturating_add(alpha),
-        //     );
-        //     weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
-
-        //     // Swap StakingHotkeys.
-        //     // StakingHotkeys( coldkey ) --> Vec<hotkey> -- the hotkeys that the coldkey stakes.
-        //     let mut staking_hotkeys = StakingHotkeys::<T>::get(&coldkey);
-        //     weight.saturating_accrue(T::DbWeight::get().reads(1));
-        //     if staking_hotkeys.contains(old_hotkey) {
-        //         staking_hotkeys.retain(|hk| *hk != *old_hotkey && *hk != *new_hotkey);
-        //         if !staking_hotkeys.contains(new_hotkey) {
-        //             staking_hotkeys.push(new_hotkey.clone());
-        //         }
-        //         StakingHotkeys::<T>::insert(&coldkey, staking_hotkeys);
-        //         weight.saturating_accrue(T::DbWeight::get().writes(1));
-        //     }
-        // }
+        for ((coldkey, _netuid), _alpha) in old_alpha_values {
+            // let new_alpha = Alpha::<T>::get((new_hotkey, &coldkey, netuid));
+            // Alpha::<T>::insert(
+            //     (new_hotkey, &coldkey, netuid),
+            //     new_alpha.saturating_add(alpha),
+            // );
+            // weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
+
+            // Swap StakingHotkeys.
+            // StakingHotkeys( coldkey ) --> Vec<hotkey> -- the hotkeys that the coldkey stakes.
+            let mut staking_hotkeys = StakingHotkeys::<T>::get(&coldkey);
+            weight.saturating_accrue(T::DbWeight::get().reads(1));
+            if staking_hotkeys.contains(old_hotkey) {
+                staking_hotkeys.retain(|hk| *hk != *old_hotkey && *hk != *new_hotkey);
+                if !staking_hotkeys.contains(new_hotkey) {
+                    staking_hotkeys.push(new_hotkey.clone());
+                }
+                StakingHotkeys::<T>::insert(&coldkey, staking_hotkeys);
+                weight.saturating_accrue(T::DbWeight::get().writes(1));
+            }
+        }
 
         // Return successful after swapping all the relevant terms.
         Ok(())
@@ -362,13 +364,13 @@ impl<T: Config> Pallet<T> {
         Self::set_last_tx_block(coldkey, block);
         weight.saturating_accrue(T::DbWeight::get().writes(1));
 
-        let mut staking_hotkeys = StakingHotkeys::<T>::get(coldkey);
-        weight.saturating_accrue(T::DbWeight::get().reads(1));
-        if staking_hotkeys.contains(old_hotkey) && !staking_hotkeys.contains(new_hotkey) {
-            staking_hotkeys.push(new_hotkey.clone());
-            StakingHotkeys::<T>::insert(coldkey, staking_hotkeys);
-            weight.saturating_accrue(T::DbWeight::get().writes(1));
-        }
+        // let mut staking_hotkeys = StakingHotkeys::<T>::get(coldkey);
+        // weight.saturating_accrue(T::DbWeight::get().reads(1));
+        // if staking_hotkeys.contains(old_hotkey) && !staking_hotkeys.contains(new_hotkey) {
+        //     staking_hotkeys.push(new_hotkey.clone());
+        //     StakingHotkeys::<T>::insert(coldkey, staking_hotkeys);
+        //     weight.saturating_accrue(T::DbWeight::get().writes(1));
+        // }
 
         // 16. Emit an event for the hotkey swap
         Self::deposit_event(Event::HotkeySwappedOnSubnet {
@@ -625,7 +627,12 @@ impl<T: Config> Pallet<T> {
 
         // Insert the new alpha values.
         for ((coldkey, netuid_alpha), alpha) in old_alpha_values {
+            log::error!("======== Alpha: {:?}", alpha);
+            log::error!("Coldkey: {:?}", coldkey);
+            log::error!("Netuid: {:?}", netuid_alpha);
             if netuid == netuid_alpha {
+                log::error!("Netuid: {:?}", netuid);
+                log::error!("netuid_alpha: {:?}", netuid_alpha);
                 // let new_alpha = Alpha::<T>::take((old_hotkey, &coldkey, netuid));
                 let new_alpha = Alpha::<T>::take((new_hotkey, &coldkey, netuid));
                 Alpha::<T>::remove((old_hotkey, &coldkey, netuid));
diff --git a/pallets/subtensor/src/tests/swap_hotkey.rs b/pallets/subtensor/src/tests/swap_hotkey.rs
index f6b1db9ec6..9220eef94b 100644
--- a/pallets/subtensor/src/tests/swap_hotkey.rs
+++ b/pallets/subtensor/src/tests/swap_hotkey.rs
@@ -514,6 +514,8 @@ fn test_swap_staking_hotkeys_multiple_coldkeys() {
         // Set up initial state
         StakingHotkeys::<Test>::insert(coldkey1, vec![old_hotkey]);
         StakingHotkeys::<Test>::insert(coldkey2, vec![old_hotkey, staker5]);
+        Alpha::<Test>::insert((old_hotkey, coldkey1, netuid), U64F64::from_num(100));
+        Alpha::<Test>::insert((old_hotkey, coldkey2, netuid), U64F64::from_num(100));
 
         SubtensorModule::create_account_if_non_existent(&coldkey1, &old_hotkey);
         SubtensorModule::add_balance_to_coldkey_account(
@@ -1007,7 +1009,7 @@ fn test_swap_hotkey_error_cases() {
 
         // Test not enough balance
         let swap_cost = SubtensorModule::get_key_swap_cost();
-        assert_noop!(
+        assert_err!(
             SubtensorModule::do_swap_hotkey(
                 RuntimeOrigin::signed(coldkey),
                 &old_hotkey,
diff --git a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
index 74cda8a144..62785fe409 100644
--- a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
+++ b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
@@ -989,7 +989,7 @@ fn test_swap_hotkey_error_cases() {
 
         // Test not enough balance
         let swap_cost = SubtensorModule::get_key_swap_cost();
-        assert_noop!(
+        assert_err!(
             SubtensorModule::do_swap_hotkey(
                 RuntimeOrigin::signed(coldkey),
                 &old_hotkey,

From 197b68b21afb86360c8adecb94ff6e443ab8e23b Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Sun, 4 May 2025 12:11:29 +0800
Subject: [PATCH 105/418] fix test cases

---
 pallets/subtensor/src/swap/swap_hotkey.rs  | 143 ++++++++-------------
 pallets/subtensor/src/tests/swap_hotkey.rs |  10 +-
 2 files changed, 63 insertions(+), 90 deletions(-)

diff --git a/pallets/subtensor/src/swap/swap_hotkey.rs b/pallets/subtensor/src/swap/swap_hotkey.rs
index f5208f2cd4..c2e75e7d2e 100644
--- a/pallets/subtensor/src/swap/swap_hotkey.rs
+++ b/pallets/subtensor/src/swap/swap_hotkey.rs
@@ -44,101 +44,99 @@ impl<T: Config> Pallet<T> {
         // 4. Ensure the new hotkey is different from the old one
         ensure!(old_hotkey != new_hotkey, Error::<T>::NewHotKeyIsSameWithOld);
 
-        // 5. Update the weight for the checks above
-        weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 0));
-
-        // 6. Get the current block number
+        // 5. Get the current block number
         let block: u64 = Self::get_current_block_as_u64();
 
-        // 7. Ensure the transaction rate limit is not exceeded
+        // 6. Ensure the transaction rate limit is not exceeded
         ensure!(
             !Self::exceeds_tx_rate_limit(Self::get_last_tx_block(&coldkey), block),
             Error::<T>::HotKeySetTxRateLimitExceeded
         );
 
-        // 9. Swap LastTxBlock
+        weight.saturating_accrue(T::DbWeight::get().reads(2));
+
+        // 7. Swap LastTxBlock
         // LastTxBlock( hotkey ) --> u64 -- the last transaction block for the hotkey.
         let last_tx_block: u64 = LastTxBlock::<T>::get(old_hotkey);
         LastTxBlock::<T>::insert(new_hotkey, last_tx_block);
         weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
 
-        // 10. Swap LastTxBlockDelegateTake
+        // 8. Swap LastTxBlockDelegateTake
         // LastTxBlockDelegateTake( hotkey ) --> u64 -- the last transaction block for the hotkey delegate take.
         let last_tx_block_delegate_take: u64 = LastTxBlockDelegateTake::<T>::get(old_hotkey);
         LastTxBlockDelegateTake::<T>::insert(new_hotkey, last_tx_block_delegate_take);
         weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
 
-        // 11. Swap LastTxBlockChildKeyTake
+        // 9. Swap LastTxBlockChildKeyTake
         // LastTxBlockChildKeyTake( hotkey ) --> u64 -- the last transaction block for the hotkey child key take.
         let last_tx_block_child_key_take: u64 = LastTxBlockChildKeyTake::<T>::get(old_hotkey);
         LastTxBlockChildKeyTake::<T>::insert(new_hotkey, last_tx_block_child_key_take);
         weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
 
-        // 8. fork for swap hotkey on a specific subnet case after do the common check
+        // 10. fork for swap hotkey on a specific subnet case after do the common check
         if let Some(netuid) = netuid {
             return Self::swap_hotkey_on_subnet(&coldkey, old_hotkey, new_hotkey, netuid, weight);
         };
 
-        // following update just for swap hotkey in all subnets case
-
-        // 4. Ensure the new hotkey is not already registered on any network
+        // Start to do everything for swap hotkey on all subnets case
+        // 11. Ensure the new hotkey is not already registered on any network
         ensure!(
             !Self::is_hotkey_registered_on_any_network(new_hotkey),
             Error::<T>::HotKeyAlreadyRegisteredInSubNet
         );
 
-        // 10. Get the cost for swapping the key
+        // 12. Get the cost for swapping the key
         let swap_cost = Self::get_key_swap_cost();
         log::debug!("Swap cost: {:?}", swap_cost);
 
-        // 11. Ensure the coldkey has enough balance to pay for the swap
+        // 13. Ensure the coldkey has enough balance to pay for the swap
         ensure!(
             Self::can_remove_balance_from_coldkey_account(&coldkey, swap_cost),
             Error::<T>::NotEnoughBalanceToPaySwapHotKey
         );
 
-        // 12. Remove the swap cost from the coldkey's account
+        // 14. Remove the swap cost from the coldkey's account
         let actual_burn_amount = Self::remove_balance_from_coldkey_account(&coldkey, swap_cost)?;
 
-        LastTxBlock::<T>::remove(old_hotkey);
-        LastTxBlockDelegateTake::<T>::remove(old_hotkey);
-        LastTxBlockChildKeyTake::<T>::remove(old_hotkey);
+        // 15. Remove block related info for the old hotkey in swap all subnets case
+        // LastTxBlock::<T>::remove(old_hotkey);
+        // LastTxBlockDelegateTake::<T>::remove(old_hotkey);
+        // LastTxBlockChildKeyTake::<T>::remove(old_hotkey);
 
-        // 8. Swap Senate members.
+        // 16. Swap Senate members.
         // Senate( hotkey ) --> ?
-        if T::SenateMembers::is_member(old_hotkey) {
-            T::SenateMembers::swap_member(old_hotkey, new_hotkey).map_err(|e| e.error)?;
-            weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
-        }
+        // if T::SenateMembers::is_member(old_hotkey) {
+        //     T::SenateMembers::swap_member(old_hotkey, new_hotkey).map_err(|e| e.error)?;
+        //     weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
+        // }
 
-        // 9. Swap delegates.
-        // Delegates( hotkey ) -> take value -- the hotkey delegate take value.
-        if Delegates::<T>::contains_key(old_hotkey) {
-            let old_delegate_take = Delegates::<T>::get(old_hotkey);
-            Delegates::<T>::remove(old_hotkey);
-            Delegates::<T>::insert(new_hotkey, old_delegate_take);
-            weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 2));
-        }
+        // // 17. Swap delegates.
+        // // Delegates( hotkey ) -> take value -- the hotkey delegate take value.
+        // if Delegates::<T>::contains_key(old_hotkey) {
+        //     let old_delegate_take = Delegates::<T>::get(old_hotkey);
+        //     Delegates::<T>::remove(old_hotkey);
+        //     Delegates::<T>::insert(new_hotkey, old_delegate_take);
+        //     weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 2));
+        // }
 
-        // 13. Burn the tokens
+        // 18. Burn the tokens
         Self::burn_tokens(actual_burn_amount);
 
-        // 14. Perform the hotkey swap
-        let _ =
-            Self::perform_hotkey_swap_on_all_subnets(old_hotkey, new_hotkey, &coldkey, &mut weight);
+        // 19. Perform the hotkey swap
+        Self::perform_hotkey_swap_on_all_subnets(old_hotkey, new_hotkey, &coldkey, &mut weight)?;
 
-        // 15. Update the last transaction block for the coldkey
+        // 20. Update the last transaction block for the coldkey
         Self::set_last_tx_block(&coldkey, block);
         weight.saturating_accrue(T::DbWeight::get().writes(1));
 
-        // 16. Emit an event for the hotkey swap
+        // 21. Emit an event for the hotkey swap
         Self::deposit_event(Event::HotkeySwapped {
             coldkey,
             old_hotkey: old_hotkey.clone(),
             new_hotkey: new_hotkey.clone(),
         });
 
-        // 17. Return the weight of the operation
+        // 22. Return the weight of the operation
         Ok(Some(weight).into())
     }
 
@@ -182,15 +180,17 @@ impl<T: Config> Pallet<T> {
         coldkey: &T::AccountId,
         weight: &mut Weight,
     ) -> DispatchResult {
+        // 1. keep the old hotkey alpha values for the case where hotkey staked by multiple coldkeys.
         let old_alpha_values: Vec<((T::AccountId, u16), U64F64)> =
             Alpha::<T>::iter_prefix((old_hotkey,)).collect();
-        // 1. Swap owner.
+
+        // 2. Swap owner.
         // Owner( hotkey ) -> coldkey -- the coldkey that owns the hotkey.
         Owner::<T>::remove(old_hotkey);
         Owner::<T>::insert(new_hotkey, coldkey.clone());
         weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
 
-        // 2. Swap OwnedHotkeys.
+        // 3. Swap OwnedHotkeys.
         // OwnedHotkeys( coldkey ) -> Vec<hotkey> -- the hotkeys that the coldkey owns.
         let mut hotkeys = OwnedHotkeys::<T>::get(coldkey);
         // Add the new key if needed.
@@ -198,45 +198,46 @@ impl<T: Config> Pallet<T> {
             hotkeys.push(new_hotkey.clone());
         }
 
-        // Remove the old key.
+        // 4. Remove the old key.
         hotkeys.retain(|hk| *hk != *old_hotkey);
         OwnedHotkeys::<T>::insert(coldkey, hotkeys);
 
         weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
 
+        // 5. execute the hotkey swap on all subnets
         for netuid in Self::get_all_subnet_netuids() {
             Self::perform_hotkey_swap_on_one_subnet(old_hotkey, new_hotkey, weight, netuid);
         }
 
-        // 5. Swap LastTxBlock
+        // 6. Swap LastTxBlock
         // LastTxBlock( hotkey ) --> u64 -- the last transaction block for the hotkey.
-        let last_tx_block: u64 = LastTxBlock::<T>::get(old_hotkey);
+        // let last_tx_block: u64 = LastTxBlock::<T>::get(old_hotkey);
         LastTxBlock::<T>::remove(old_hotkey);
-        LastTxBlock::<T>::insert(new_hotkey, last_tx_block);
+        // LastTxBlock::<T>::insert(new_hotkey, last_tx_block);
         weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
 
-        // 6. Swap LastTxBlockDelegateTake
+        // 7. Swap LastTxBlockDelegateTake
         // LastTxBlockDelegateTake( hotkey ) --> u64 -- the last transaction block for the hotkey delegate take.
-        let last_tx_block_delegate_take: u64 = LastTxBlockDelegateTake::<T>::get(old_hotkey);
+        // let last_tx_block_delegate_take: u64 = LastTxBlockDelegateTake::<T>::get(old_hotkey);
         LastTxBlockDelegateTake::<T>::remove(old_hotkey);
-        LastTxBlockDelegateTake::<T>::insert(new_hotkey, last_tx_block_delegate_take);
+        // LastTxBlockDelegateTake::<T>::insert(new_hotkey, last_tx_block_delegate_take);
         weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
 
-        // 7. Swap LastTxBlockChildKeyTake
+        // 8. Swap LastTxBlockChildKeyTake
         // LastTxBlockChildKeyTake( hotkey ) --> u64 -- the last transaction block for the hotkey child key take.
-        let last_tx_block_child_key_take: u64 = LastTxBlockChildKeyTake::<T>::get(old_hotkey);
+        // let last_tx_block_child_key_take: u64 = LastTxBlockChildKeyTake::<T>::get(old_hotkey);
         LastTxBlockChildKeyTake::<T>::remove(old_hotkey);
-        LastTxBlockChildKeyTake::<T>::insert(new_hotkey, last_tx_block_child_key_take);
+        // LastTxBlockChildKeyTake::<T>::insert(new_hotkey, last_tx_block_child_key_take);
         weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
 
-        // 8. Swap Senate members.
+        // 9. Swap Senate members.
         // Senate( hotkey ) --> ?
         if T::SenateMembers::is_member(old_hotkey) {
             T::SenateMembers::swap_member(old_hotkey, new_hotkey).map_err(|e| e.error)?;
             weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
         }
 
-        // 9. Swap delegates.
+        // 10. Swap delegates.
         // Delegates( hotkey ) -> take value -- the hotkey delegate take value.
         if Delegates::<T>::contains_key(old_hotkey) {
             let old_delegate_take = Delegates::<T>::get(old_hotkey);
@@ -245,34 +246,9 @@ impl<T: Config> Pallet<T> {
             weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 2));
         }
 
-        // Swap StakingHotkeys.
-        // StakingHotkeys( coldkey ) --> Vec<hotkey> -- the hotkeys that the coldkey stakes.
-        // let mut staking_hotkeys = StakingHotkeys::<T>::get(coldkey);
-        // weight.saturating_accrue(T::DbWeight::get().reads(1));
-        // if staking_hotkeys.contains(old_hotkey) {
-        //     staking_hotkeys.retain(|hk| *hk != *old_hotkey && *hk != *new_hotkey);
-        //     staking_hotkeys.push(new_hotkey.clone());
-        //     StakingHotkeys::<T>::insert(coldkey, staking_hotkeys);
-        //     weight.saturating_accrue(T::DbWeight::get().writes(1));
-        // }
-
-        // // 11. Swap Alpha
-        // // Alpha( hotkey, coldkey, netuid ) -> alpha
-
-        // // Clear the entire old prefix here.
-        // let _ = Alpha::<T>::clear_prefix((old_hotkey,), old_alpha_values.len() as u32, None);
-        // weight.saturating_accrue(T::DbWeight::get().reads(old_alpha_values.len() as u64));
-        // weight.saturating_accrue(T::DbWeight::get().writes(old_alpha_values.len() as u64));
-
-        // // Insert the new alpha values.
+        // 11. Alpha already update in perform_hotkey_swap_on_one_subnet
+        // Update the StakingHotkeys for the case where hotkey staked by multiple coldkeys.
         for ((coldkey, _netuid), _alpha) in old_alpha_values {
-            // let new_alpha = Alpha::<T>::get((new_hotkey, &coldkey, netuid));
-            // Alpha::<T>::insert(
-            //     (new_hotkey, &coldkey, netuid),
-            //     new_alpha.saturating_add(alpha),
-            // );
-            // weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
-
             // Swap StakingHotkeys.
             // StakingHotkeys( coldkey ) --> Vec<hotkey> -- the hotkeys that the coldkey stakes.
             let mut staking_hotkeys = StakingHotkeys::<T>::get(&coldkey);
@@ -311,18 +287,16 @@ impl<T: Config> Pallet<T> {
         netuid: u16,
         init_weight: Weight,
     ) -> DispatchResultWithPostInfo {
-        let mut weight = init_weight;
-
         // Ensure the hotkey not registered on the network before.
-
         ensure!(
             !Self::is_hotkey_registered_on_specific_network(new_hotkey, netuid),
             Error::<T>::HotKeyAlreadyRegisteredInSubNet
         );
+        let mut weight: Weight = init_weight;
 
         weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 0));
 
-        // 10. Get the cost for swapping the key
+        // 10. Get the cost for swapping the key on the subnet
         let swap_cost = T::KeySwapOneSubnetCost::get();
         log::debug!("Swap cost in subnet {:?}: {:?}", netuid, swap_cost);
 
@@ -653,8 +627,5 @@ impl<T: Config> Pallet<T> {
                 }
             }
         }
-
-        // Return successful after swapping all the relevant terms.
-        // Ok(())
     }
 }
diff --git a/pallets/subtensor/src/tests/swap_hotkey.rs b/pallets/subtensor/src/tests/swap_hotkey.rs
index 9220eef94b..ffd212b093 100644
--- a/pallets/subtensor/src/tests/swap_hotkey.rs
+++ b/pallets/subtensor/src/tests/swap_hotkey.rs
@@ -1391,6 +1391,8 @@ fn test_swap_hotkey_swap_rate_limits() {
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
         let mut weight = Weight::zero();
+        let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
 
         let last_tx_block = 123;
         let delegate_take_block = 4567;
@@ -1404,12 +1406,12 @@ fn test_swap_hotkey_swap_rate_limits() {
         LastTxBlockChildKeyTake::<Test>::insert(old_hotkey, child_key_take_block);
 
         // Perform the swap
-        SubtensorModule::perform_hotkey_swap_on_all_subnets(
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
             &old_hotkey,
             &new_hotkey,
-            &coldkey,
-            &mut weight,
-        );
+            None
+        ));
 
         // Check for new hotkey
         assert_eq!(LastTxBlock::<Test>::get(new_hotkey), last_tx_block);

From 75f56ec852bda54369ae7b255055f2fac3aedf64 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Sun, 4 May 2025 18:55:25 +0800
Subject: [PATCH 106/418] update weights

---
 pallets/subtensor/src/swap/swap_hotkey.rs | 79 +++++------------------
 1 file changed, 16 insertions(+), 63 deletions(-)

diff --git a/pallets/subtensor/src/swap/swap_hotkey.rs b/pallets/subtensor/src/swap/swap_hotkey.rs
index c2e75e7d2e..bf5e6f0b2d 100644
--- a/pallets/subtensor/src/swap/swap_hotkey.rs
+++ b/pallets/subtensor/src/swap/swap_hotkey.rs
@@ -59,19 +59,19 @@ impl<T: Config> Pallet<T> {
         // LastTxBlock( hotkey ) --> u64 -- the last transaction block for the hotkey.
         let last_tx_block: u64 = LastTxBlock::<T>::get(old_hotkey);
         LastTxBlock::<T>::insert(new_hotkey, last_tx_block);
-        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
 
         // 8. Swap LastTxBlockDelegateTake
         // LastTxBlockDelegateTake( hotkey ) --> u64 -- the last transaction block for the hotkey delegate take.
         let last_tx_block_delegate_take: u64 = LastTxBlockDelegateTake::<T>::get(old_hotkey);
         LastTxBlockDelegateTake::<T>::insert(new_hotkey, last_tx_block_delegate_take);
-        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
 
         // 9. Swap LastTxBlockChildKeyTake
         // LastTxBlockChildKeyTake( hotkey ) --> u64 -- the last transaction block for the hotkey child key take.
         let last_tx_block_child_key_take: u64 = LastTxBlockChildKeyTake::<T>::get(old_hotkey);
         LastTxBlockChildKeyTake::<T>::insert(new_hotkey, last_tx_block_child_key_take);
-        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
 
         // 10. fork for swap hotkey on a specific subnet case after do the common check
         if let Some(netuid) = netuid {
@@ -95,32 +95,14 @@ impl<T: Config> Pallet<T> {
             Error::<T>::NotEnoughBalanceToPaySwapHotKey
         );
 
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(3, 0));
+
         // 14. Remove the swap cost from the coldkey's account
         let actual_burn_amount = Self::remove_balance_from_coldkey_account(&coldkey, swap_cost)?;
 
-        // 15. Remove block related info for the old hotkey in swap all subnets case
-        // LastTxBlock::<T>::remove(old_hotkey);
-        // LastTxBlockDelegateTake::<T>::remove(old_hotkey);
-        // LastTxBlockChildKeyTake::<T>::remove(old_hotkey);
-
-        // 16. Swap Senate members.
-        // Senate( hotkey ) --> ?
-        // if T::SenateMembers::is_member(old_hotkey) {
-        //     T::SenateMembers::swap_member(old_hotkey, new_hotkey).map_err(|e| e.error)?;
-        //     weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
-        // }
-
-        // // 17. Swap delegates.
-        // // Delegates( hotkey ) -> take value -- the hotkey delegate take value.
-        // if Delegates::<T>::contains_key(old_hotkey) {
-        //     let old_delegate_take = Delegates::<T>::get(old_hotkey);
-        //     Delegates::<T>::remove(old_hotkey);
-        //     Delegates::<T>::insert(new_hotkey, old_delegate_take);
-        //     weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 2));
-        // }
-
         // 18. Burn the tokens
         Self::burn_tokens(actual_burn_amount);
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(0, 2));
 
         // 19. Perform the hotkey swap
         Self::perform_hotkey_swap_on_all_subnets(old_hotkey, new_hotkey, &coldkey, &mut weight)?;
@@ -183,6 +165,7 @@ impl<T: Config> Pallet<T> {
         // 1. keep the old hotkey alpha values for the case where hotkey staked by multiple coldkeys.
         let old_alpha_values: Vec<((T::AccountId, u16), U64F64)> =
             Alpha::<T>::iter_prefix((old_hotkey,)).collect();
+        weight.saturating_accrue(T::DbWeight::get().reads(old_alpha_values.len() as u64));
 
         // 2. Swap owner.
         // Owner( hotkey ) -> coldkey -- the coldkey that owns the hotkey.
@@ -211,23 +194,17 @@ impl<T: Config> Pallet<T> {
 
         // 6. Swap LastTxBlock
         // LastTxBlock( hotkey ) --> u64 -- the last transaction block for the hotkey.
-        // let last_tx_block: u64 = LastTxBlock::<T>::get(old_hotkey);
         LastTxBlock::<T>::remove(old_hotkey);
-        // LastTxBlock::<T>::insert(new_hotkey, last_tx_block);
         weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
 
         // 7. Swap LastTxBlockDelegateTake
         // LastTxBlockDelegateTake( hotkey ) --> u64 -- the last transaction block for the hotkey delegate take.
-        // let last_tx_block_delegate_take: u64 = LastTxBlockDelegateTake::<T>::get(old_hotkey);
         LastTxBlockDelegateTake::<T>::remove(old_hotkey);
-        // LastTxBlockDelegateTake::<T>::insert(new_hotkey, last_tx_block_delegate_take);
         weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
 
         // 8. Swap LastTxBlockChildKeyTake
         // LastTxBlockChildKeyTake( hotkey ) --> u64 -- the last transaction block for the hotkey child key take.
-        // let last_tx_block_child_key_take: u64 = LastTxBlockChildKeyTake::<T>::get(old_hotkey);
         LastTxBlockChildKeyTake::<T>::remove(old_hotkey);
-        // LastTxBlockChildKeyTake::<T>::insert(new_hotkey, last_tx_block_child_key_take);
         weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
 
         // 9. Swap Senate members.
@@ -294,11 +271,12 @@ impl<T: Config> Pallet<T> {
         );
         let mut weight: Weight = init_weight;
 
-        weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 0));
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 0));
 
         // 10. Get the cost for swapping the key on the subnet
         let swap_cost = T::KeySwapOneSubnetCost::get();
         log::debug!("Swap cost in subnet {:?}: {:?}", netuid, swap_cost);
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 0));
 
         // 11. Ensure the coldkey has enough balance to pay for the swap
         ensure!(
@@ -308,9 +286,11 @@ impl<T: Config> Pallet<T> {
 
         // 12. Remove the swap cost from the coldkey's account
         let actual_burn_amount = Self::remove_balance_from_coldkey_account(coldkey, swap_cost)?;
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 0));
 
         // 13. Burn the tokens
         Self::burn_tokens(actual_burn_amount);
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
 
         // 1. Swap owner.
         // Owner( hotkey ) -> coldkey -- the coldkey that owns the hotkey.
@@ -327,8 +307,6 @@ impl<T: Config> Pallet<T> {
             OwnedHotkeys::<T>::insert(coldkey, hotkeys);
             weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
         }
-        // Remove the old key.
-        // hotkeys.retain(|hk| *hk != *old_hotkey);
 
         // 14. Perform the hotkey swap
         Self::perform_hotkey_swap_on_one_subnet(old_hotkey, new_hotkey, &mut weight, netuid);
@@ -338,14 +316,6 @@ impl<T: Config> Pallet<T> {
         Self::set_last_tx_block(coldkey, block);
         weight.saturating_accrue(T::DbWeight::get().writes(1));
 
-        // let mut staking_hotkeys = StakingHotkeys::<T>::get(coldkey);
-        // weight.saturating_accrue(T::DbWeight::get().reads(1));
-        // if staking_hotkeys.contains(old_hotkey) && !staking_hotkeys.contains(new_hotkey) {
-        //     staking_hotkeys.push(new_hotkey.clone());
-        //     StakingHotkeys::<T>::insert(coldkey, staking_hotkeys);
-        //     weight.saturating_accrue(T::DbWeight::get().writes(1));
-        // }
-
         // 16. Emit an event for the hotkey swap
         Self::deposit_event(Event::HotkeySwappedOnSubnet {
             coldkey: coldkey.clone(),
@@ -366,22 +336,21 @@ impl<T: Config> Pallet<T> {
     ) {
         // 1. Swap total hotkey alpha for all subnets it exists on.
         // TotalHotkeyAlpha( hotkey, netuid ) -> alpha -- the total alpha that the hotkey has on a specific subnet.
-
         let alpha = TotalHotkeyAlpha::<T>::take(old_hotkey, netuid);
-        // TotalHotkeyAlpha::<T>::remove(old_hotkey, netuid);
 
         TotalHotkeyAlpha::<T>::mutate(new_hotkey, netuid, |value| {
             *value = value.saturating_add(alpha)
         });
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
 
         // 2. Swap total hotkey shares on all subnets it exists on.
         // TotalHotkeyShares( hotkey, netuid ) -> alpha -- the total alpha that the hotkey has on a specific subnet.
-
         let share = TotalHotkeyShares::<T>::take(old_hotkey, netuid);
         // TotalHotkeyAlpha::<T>::remove(old_hotkey, netuid);
         TotalHotkeyShares::<T>::mutate(new_hotkey, netuid, |value| {
             *value = value.saturating_add(share)
         });
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
 
         // 3. Swap all subnet specific info.
 
@@ -464,19 +433,15 @@ impl<T: Config> Pallet<T> {
                 weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
             }
         }
-
-        // }
-
         // 12. Swap ChildKeys.
         // ChildKeys( parent, netuid ) --> Vec<(proportion,child)> -- the child keys of the parent.
-        // for netuid in Self::get_all_subnet_netuids() {
-        // Get the children of the old hotkey for this subnet
         let my_children: Vec<(u64, T::AccountId)> = ChildKeys::<T>::get(old_hotkey, netuid);
         // Remove the old hotkey's child entries
         ChildKeys::<T>::remove(old_hotkey, netuid);
         // Insert the same child entries for the new hotkey
         ChildKeys::<T>::insert(new_hotkey, netuid, my_children.clone());
         weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
+
         for (_, child_key_i) in my_children {
             // For each child, update their parent list
             let mut child_parents: Vec<(u64, T::AccountId)> =
@@ -495,14 +460,13 @@ impl<T: Config> Pallet<T> {
 
         // 13. Swap ParentKeys.
         // ParentKeys( child, netuid ) --> Vec<(proportion,parent)> -- the parent keys of the child.
-        // for netuid in Self::get_all_subnet_netuids() {
-        // Get the parents of the old hotkey for this subnet
         let parents: Vec<(u64, T::AccountId)> = ParentKeys::<T>::get(old_hotkey, netuid);
         // Remove the old hotkey's parent entries
         ParentKeys::<T>::remove(old_hotkey, netuid);
         // Insert the same parent entries for the new hotkey
         ParentKeys::<T>::insert(new_hotkey, netuid, parents.clone());
         weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
+
         for (_, parent_key_i) in parents {
             // For each parent, update their children list
             let mut parent_children: Vec<(u64, T::AccountId)> =
@@ -520,8 +484,6 @@ impl<T: Config> Pallet<T> {
 
         // 14. Swap PendingChildKeys.
         // PendingChildKeys( netuid, parent ) --> Vec<(proportion,child), cool_down_block>
-        // for netuid in Self::get_all_subnet_netuids() {
-        weight.saturating_accrue(T::DbWeight::get().reads(1));
         if PendingChildKeys::<T>::contains_key(netuid, old_hotkey) {
             let (children, cool_down_block) = PendingChildKeys::<T>::get(netuid, old_hotkey);
             PendingChildKeys::<T>::remove(netuid, old_hotkey);
@@ -548,7 +510,6 @@ impl<T: Config> Pallet<T> {
 
         // 15. Swap SubnetOwnerHotkey
         // SubnetOwnerHotkey( netuid ) --> hotkey -- the hotkey that is the owner of the subnet.
-        // for netuid in Self::get_all_subnet_netuids() {
         if let Ok(old_subnet_owner_hotkey) = SubnetOwnerHotkey::<T>::try_get(netuid) {
             weight.saturating_accrue(T::DbWeight::get().reads(1));
             if old_subnet_owner_hotkey == *old_hotkey {
@@ -594,27 +555,19 @@ impl<T: Config> Pallet<T> {
         // Alpha( hotkey, coldkey, netuid ) -> alpha
         let old_alpha_values: Vec<((T::AccountId, u16), U64F64)> =
             Alpha::<T>::iter_prefix((old_hotkey,)).collect();
-        // Clear the entire old prefix here.
-        // let _ = Alpha::<T>::clear_prefix((old_hotkey,), old_alpha_values.len() as u32, None);
         weight.saturating_accrue(T::DbWeight::get().reads(old_alpha_values.len() as u64));
         weight.saturating_accrue(T::DbWeight::get().writes(old_alpha_values.len() as u64));
 
         // Insert the new alpha values.
         for ((coldkey, netuid_alpha), alpha) in old_alpha_values {
-            log::error!("======== Alpha: {:?}", alpha);
-            log::error!("Coldkey: {:?}", coldkey);
-            log::error!("Netuid: {:?}", netuid_alpha);
             if netuid == netuid_alpha {
-                log::error!("Netuid: {:?}", netuid);
-                log::error!("netuid_alpha: {:?}", netuid_alpha);
-                // let new_alpha = Alpha::<T>::take((old_hotkey, &coldkey, netuid));
                 let new_alpha = Alpha::<T>::take((new_hotkey, &coldkey, netuid));
                 Alpha::<T>::remove((old_hotkey, &coldkey, netuid));
                 Alpha::<T>::insert(
                     (new_hotkey, &coldkey, netuid),
                     alpha.saturating_add(new_alpha),
                 );
-                weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
+                weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
 
                 // Swap StakingHotkeys.
                 // StakingHotkeys( coldkey ) --> Vec<hotkey> -- the hotkeys that the coldkey stakes.

From c0bd9ecfb685c3c1e0465978d17e6058abdcad3f Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Sun, 4 May 2025 19:15:07 +0800
Subject: [PATCH 107/418] commit Cargo.lock

---
 pallets/subtensor/src/staking/helpers.rs      | 10 +----
 .../src/tests/swap_hotkey_with_subnet.rs      | 43 ++++++-------------
 2 files changed, 15 insertions(+), 38 deletions(-)

diff --git a/pallets/subtensor/src/staking/helpers.rs b/pallets/subtensor/src/staking/helpers.rs
index fc0088c771..9ee04f36a8 100644
--- a/pallets/subtensor/src/staking/helpers.rs
+++ b/pallets/subtensor/src/staking/helpers.rs
@@ -60,7 +60,7 @@ impl<T: Config> Pallet<T> {
     //
     pub fn get_total_stake_for_coldkey(coldkey: &T::AccountId) -> u64 {
         let hotkeys = StakingHotkeys::<T>::get(coldkey);
-        let result = hotkeys
+        hotkeys
             .iter()
             .map(|hotkey| {
                 let mut total_stake: u64 = 0;
@@ -76,13 +76,7 @@ impl<T: Config> Pallet<T> {
                 }
                 total_stake
             })
-            .sum::<u64>();
-        log::error!(
-            "======== get_total_stake_for_coldkey: coldkey: {:?}, total_stake: {:?}",
-            coldkey,
-            result
-        );
-        result
+            .sum::<u64>()
     }
 
     // Creates a cold - hot pairing account if the hotkey is not already an active account.
diff --git a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
index 62785fe409..df8366a49b 100644
--- a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
+++ b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
@@ -18,7 +18,6 @@ fn test_swap_owner() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let mut weight = Weight::zero();
 
         let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
@@ -42,7 +41,6 @@ fn test_swap_owned_hotkeys() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let mut weight = Weight::zero();
 
         let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
@@ -69,7 +67,7 @@ fn test_swap_total_hotkey_stake() {
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
         let amount = DefaultMinStake::<Test>::get() * 10;
-        let mut weight = Weight::zero();
+
         let fee = DefaultStakingFee::<Test>::get();
 
         //add network
@@ -127,7 +125,6 @@ fn test_swap_senate_members() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let mut weight = Weight::zero();
 
         let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
@@ -154,7 +151,6 @@ fn test_swap_delegates() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let mut weight = Weight::zero();
 
         let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
@@ -179,7 +175,6 @@ fn test_swap_subnet_membership() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let mut weight = Weight::zero();
 
         let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
@@ -205,7 +200,6 @@ fn test_swap_uids_and_keys() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let mut weight = Weight::zero();
 
         let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
@@ -235,7 +229,7 @@ fn test_swap_prometheus() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let mut weight = Weight::zero();
+
         let prometheus_info = PrometheusInfo::default();
 
         let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
@@ -267,7 +261,7 @@ fn test_swap_axons() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let mut weight = Weight::zero();
+
         let axon_info = AxonInfo::default();
 
         let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
@@ -296,7 +290,7 @@ fn test_swap_certificates() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let mut weight = Weight::zero();
+
         let certificate = NeuronCertificate::try_from(vec![1, 2, 3]).unwrap();
 
         let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
@@ -330,7 +324,7 @@ fn test_swap_weight_commits() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let mut weight = Weight::zero();
+
         let mut weight_commits: VecDeque<(H256, u64, u64, u64)> = VecDeque::new();
         weight_commits.push_back((H256::from_low_u64_be(100), 200, 1, 1));
 
@@ -363,7 +357,7 @@ fn test_swap_loaded_emission() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let mut weight = Weight::zero();
+
         let server_emission = 1000u64;
         let validator_emission = 1000u64;
 
@@ -401,8 +395,6 @@ fn test_swap_staking_hotkeys() {
         let netuid = add_dynamic_network(&old_hotkey, &coldkey);
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
 
-        let mut weight = Weight::zero();
-
         StakingHotkeys::<Test>::insert(coldkey, vec![old_hotkey]);
         Alpha::<Test>::insert((old_hotkey, coldkey, netuid), U64F64::from_num(100));
 
@@ -431,7 +423,7 @@ fn test_swap_hotkey_with_multiple_coldkeys() {
         let new_hotkey = U256::from(2);
         let coldkey1 = U256::from(3);
         let coldkey2 = U256::from(4);
-        let mut weight = Weight::zero();
+
         let stake = 1_000_000_000;
 
         StakingHotkeys::<Test>::insert(coldkey1, vec![old_hotkey]);
@@ -492,7 +484,7 @@ fn test_swap_hotkey_with_multiple_subnets() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let mut weight = Weight::zero();
+
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
 
         let netuid1 = add_dynamic_network(&old_hotkey, &coldkey);
@@ -535,7 +527,7 @@ fn test_swap_staking_hotkeys_multiple_coldkeys() {
         let coldkey1 = U256::from(3);
         let coldkey2 = U256::from(4);
         let staker5 = U256::from(5);
-        let mut weight = Weight::zero();
+
         let stake = 1_000_000_000;
         SubtensorModule::add_balance_to_coldkey_account(&coldkey1, u64::MAX);
         SubtensorModule::add_balance_to_coldkey_account(&coldkey2, u64::MAX);
@@ -589,7 +581,7 @@ fn test_swap_hotkey_with_no_stake() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let mut weight = Weight::zero();
+
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
 
         // Set up initial state with no stake
@@ -623,7 +615,6 @@ fn test_swap_hotkey_with_multiple_coldkeys_and_subnets() {
         let netuid1 = 1;
         let netuid2 = 2;
         let stake = DefaultMinStake::<Test>::get() * 10;
-        let mut weight = Weight::zero();
 
         // Set up initial state
         add_network(netuid1, 1, 1);
@@ -843,7 +834,6 @@ fn test_swap_owner_old_hotkey_not_exist() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let mut weight = Weight::zero();
 
         let netuid = add_dynamic_network(&new_hotkey, &coldkey);
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
@@ -876,7 +866,7 @@ fn test_swap_owner_new_hotkey_already_exists() {
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
         let another_coldkey = U256::from(4);
-        let mut weight = Weight::zero();
+
         let netuid = add_dynamic_network(&new_hotkey, &coldkey);
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
 
@@ -914,7 +904,6 @@ fn test_swap_stake_success() {
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
         let amount = 10_000;
         let shares = U64F64::from_num(123456);
-        let mut weight = Weight::zero();
 
         // Initialize staking variables for old_hotkey
         TotalHotkeyAlpha::<Test>::insert(old_hotkey, netuid, amount);
@@ -1058,7 +1047,6 @@ fn test_swap_child_keys() {
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
 
         let children = vec![(100u64, U256::from(4)), (200u64, U256::from(5))];
-        let mut weight = Weight::zero();
 
         // Initialize ChildKeys for old_hotkey
         ChildKeys::<Test>::insert(old_hotkey, netuid, children.clone());
@@ -1087,7 +1075,6 @@ fn test_swap_parent_keys() {
         let netuid = add_dynamic_network(&old_hotkey, &coldkey);
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
         let parents = vec![(100u64, U256::from(4)), (200u64, U256::from(5))];
-        let mut weight = Weight::zero();
 
         // Initialize ParentKeys for old_hotkey
         ParentKeys::<Test>::insert(old_hotkey, netuid, parents.clone());
@@ -1134,7 +1121,6 @@ fn test_swap_multiple_subnets() {
 
         let children1 = vec![(100u64, U256::from(4)), (200u64, U256::from(5))];
         let children2 = vec![(300u64, U256::from(6))];
-        let mut weight = Weight::zero();
 
         // Initialize ChildKeys for old_hotkey in multiple subnets
         ChildKeys::<Test>::insert(old_hotkey, netuid1, children1.clone());
@@ -1176,7 +1162,6 @@ fn test_swap_complex_parent_child_structure() {
         let parent2 = U256::from(5);
         let child1 = U256::from(6);
         let child2 = U256::from(7);
-        let mut weight = Weight::zero();
 
         // Set up complex parent-child structure
         ParentKeys::<Test>::insert(
@@ -1263,7 +1248,7 @@ fn test_swap_parent_hotkey_childkey_maps() {
         assert_eq!(existing_pending_child_keys.0, vec![(u64::MAX, child_other)]);
 
         // Swap
-        let mut weight = Weight::zero();
+
         assert_ok!(SubtensorModule::do_swap_hotkey(
             RuntimeOrigin::signed(coldkey),
             &parent_old,
@@ -1319,7 +1304,7 @@ fn test_swap_child_hotkey_childkey_maps() {
         assert_eq!(existing_pending_child_keys.0, vec![(u64::MAX, child_old)]);
 
         // Swap
-        let mut weight = Weight::zero();
+
         assert_ok!(SubtensorModule::do_swap_hotkey(
             RuntimeOrigin::signed(coldkey),
             &child_old,
@@ -1350,7 +1335,6 @@ fn test_swap_hotkey_is_sn_owner_hotkey() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let mut weight = Weight::zero();
 
         // Create dynamic network
         let netuid = add_dynamic_network(&old_hotkey, &coldkey);
@@ -1379,7 +1363,6 @@ fn test_swap_hotkey_swap_rate_limits() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let mut weight = Weight::zero();
 
         let last_tx_block = 123;
         let delegate_take_block = 4567;

From 4da3b4ee1c04ce88cbaf7d7fc974c00da6620b32 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Sun, 4 May 2025 19:15:45 +0800
Subject: [PATCH 108/418] cargo clippy

---
 pallets/subtensor/src/tests/swap_hotkey.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/pallets/subtensor/src/tests/swap_hotkey.rs b/pallets/subtensor/src/tests/swap_hotkey.rs
index ffd212b093..0d6b24d7c0 100644
--- a/pallets/subtensor/src/tests/swap_hotkey.rs
+++ b/pallets/subtensor/src/tests/swap_hotkey.rs
@@ -1390,7 +1390,6 @@ fn test_swap_hotkey_swap_rate_limits() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let mut weight = Weight::zero();
         let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
 

From 24d9c5515c96a16fbb0b86ddb1b49892e5b9a208 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Mon, 5 May 2025 09:22:43 +0800
Subject: [PATCH 109/418] add swap records

---
 pallets/subtensor/src/lib.rs              | 13 +++++++++++++
 pallets/subtensor/src/macros/config.rs    |  3 +++
 pallets/subtensor/src/macros/errors.rs    |  2 ++
 pallets/subtensor/src/macros/hooks.rs     | 23 +++++++++++++++++++++++
 pallets/subtensor/src/swap/swap_hotkey.rs | 17 ++++++++++++++---
 pallets/subtensor/src/tests/mock.rs       |  2 ++
 runtime/src/lib.rs                        |  2 ++
 7 files changed, 59 insertions(+), 3 deletions(-)

diff --git a/pallets/subtensor/src/lib.rs b/pallets/subtensor/src/lib.rs
index 2e0b479c0f..f5cd1c316c 100644
--- a/pallets/subtensor/src/lib.rs
+++ b/pallets/subtensor/src/lib.rs
@@ -908,6 +908,19 @@ pub mod pallet {
         OptionQuery,
     >;
 
+    #[pallet::storage]
+    /// --- DMap ( netuid, coldkey ) --> blocknumber | last hotkey swap on network.
+    pub type LastHotkeySwapOnNetuid<T: Config> = StorageDoubleMap<
+        _,
+        Identity,
+        u16,
+        Blake2_128Concat,
+        T::AccountId,
+        u64,
+        ValueQuery,
+        DefaultZeroU64<T>,
+    >;
+
     #[pallet::storage]
     /// Ensures unique IDs for StakeJobs storage map
     pub type NextStakeJobId<T> = StorageValue<_, u64, ValueQuery, DefaultZeroU64<T>>;
diff --git a/pallets/subtensor/src/macros/config.rs b/pallets/subtensor/src/macros/config.rs
index 46ca9dadca..9373444df8 100644
--- a/pallets/subtensor/src/macros/config.rs
+++ b/pallets/subtensor/src/macros/config.rs
@@ -216,5 +216,8 @@ mod config {
         /// Cost of swapping a hotkey in a subnet.
         #[pallet::constant]
         type KeySwapOneSubnetCost: Get<u64>;
+        /// Block number for a coldkey swap the hotkey in specific subnet.
+        #[pallet::constant]
+        type HotkeySwapOnSubnetInterval: Get<u64>;
     }
 }
diff --git a/pallets/subtensor/src/macros/errors.rs b/pallets/subtensor/src/macros/errors.rs
index 089c741c33..b4a2ca699c 100644
--- a/pallets/subtensor/src/macros/errors.rs
+++ b/pallets/subtensor/src/macros/errors.rs
@@ -209,5 +209,7 @@ mod errors {
         InvalidRecoveredPublicKey,
         /// SubToken disabled now
         SubtokenDisabled,
+        /// Too frequent hotkey swap on subnet
+        HotKeySwapOnSubnetIntervalNotPassed,
     }
 }
diff --git a/pallets/subtensor/src/macros/hooks.rs b/pallets/subtensor/src/macros/hooks.rs
index 4d26994f05..a80b94f6b2 100644
--- a/pallets/subtensor/src/macros/hooks.rs
+++ b/pallets/subtensor/src/macros/hooks.rs
@@ -41,6 +41,7 @@ mod hooks {
         // 		- The number of the block we are finalizing.
         fn on_finalize(block_number: BlockNumberFor<T>) {
             Self::do_on_finalize(block_number);
+            Self::clean_up_hotkey_swap_records(block_number);
         }
 
         fn on_runtime_upgrade() -> frame_support::weights::Weight {
@@ -122,4 +123,26 @@ mod hooks {
             Ok(())
         }
     }
+
+    impl<T: Config> Pallet<T> {
+        fn clean_up_hotkey_swap_records(block_number: BlockNumberFor<T>) {
+            let hotkey_swap_on_subnet_interval = T::HotkeySwapOnSubnetInterval::get();
+            let block_number: u64 = TryInto::try_into(block_number)
+                .ok()
+                .expect("blockchain will not exceed 2^64 blocks; QED.");
+            let netuids = Self::get_all_subnet_netuids();
+
+            let slot = block_number % hotkey_swap_on_subnet_interval;
+
+            if slot < (u16::MAX as u64) && netuids.contains(&(slot as u16)) {
+                for (coldkey, swap_block_number) in
+                    LastHotkeySwapOnNetuid::<T>::iter_prefix(slot as u16)
+                {
+                    if swap_block_number + hotkey_swap_on_subnet_interval < block_number {
+                        LastHotkeySwapOnNetuid::<T>::remove(slot as u16, coldkey);
+                    }
+                }
+            }
+        }
+    }
 }
diff --git a/pallets/subtensor/src/swap/swap_hotkey.rs b/pallets/subtensor/src/swap/swap_hotkey.rs
index bf5e6f0b2d..ff3580923f 100644
--- a/pallets/subtensor/src/swap/swap_hotkey.rs
+++ b/pallets/subtensor/src/swap/swap_hotkey.rs
@@ -264,12 +264,23 @@ impl<T: Config> Pallet<T> {
         netuid: u16,
         init_weight: Weight,
     ) -> DispatchResultWithPostInfo {
+        // 1. Ensure coldkey not swap hotkey too frequently
+        let mut weight: Weight = init_weight;
+        let block: u64 = Self::get_current_block_as_u64();
+        let hotkey_swap_interval = T::HotkeySwapOnSubnetInterval::get();
+        let last_hotkey_swap_block = LastHotkeySwapOnNetuid::<T>::get(netuid, coldkey);
+
+        ensure!(
+            last_hotkey_swap_block + hotkey_swap_interval < block,
+            Error::<T>::HotKeySwapOnSubnetIntervalNotPassed
+        );
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(3, 0));
+
         // Ensure the hotkey not registered on the network before.
         ensure!(
             !Self::is_hotkey_registered_on_specific_network(new_hotkey, netuid),
             Error::<T>::HotKeyAlreadyRegisteredInSubNet
         );
-        let mut weight: Weight = init_weight;
 
         weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 0));
 
@@ -311,10 +322,10 @@ impl<T: Config> Pallet<T> {
         // 14. Perform the hotkey swap
         Self::perform_hotkey_swap_on_one_subnet(old_hotkey, new_hotkey, &mut weight, netuid);
 
-        let block: u64 = Self::get_current_block_as_u64();
         // 15. Update the last transaction block for the coldkey
         Self::set_last_tx_block(coldkey, block);
-        weight.saturating_accrue(T::DbWeight::get().writes(1));
+        LastHotkeySwapOnNetuid::<T>::insert(netuid, coldkey, block);
+        weight.saturating_accrue(T::DbWeight::get().writes(2));
 
         // 16. Emit an event for the hotkey swap
         Self::deposit_event(Event::HotkeySwappedOnSubnet {
diff --git a/pallets/subtensor/src/tests/mock.rs b/pallets/subtensor/src/tests/mock.rs
index d934d33725..bb43015b87 100644
--- a/pallets/subtensor/src/tests/mock.rs
+++ b/pallets/subtensor/src/tests/mock.rs
@@ -187,6 +187,7 @@ parameter_types! {
     pub const InitialEmaPriceHalvingPeriod: u64 = 201_600_u64; // 4 weeks
     pub const DurationOfStartCall: u64 =  7 * 24 * 60 * 60 / 12; // Default as 7 days
     pub const InitialKeySwapOnSubnetCost: u64 = 10_000_000;
+    pub const HotkeySwapOnSubnetInterval: u64 = 1; // 1 block
 
 }
 
@@ -413,6 +414,7 @@ impl crate::Config for Test {
     type InitialEmaPriceHalvingPeriod = InitialEmaPriceHalvingPeriod;
     type DurationOfStartCall = DurationOfStartCall;
     type KeySwapOneSubnetCost = InitialKeySwapOnSubnetCost;
+    type HotkeySwapOnSubnetInterval = HotkeySwapOnSubnetInterval;
 }
 
 pub struct OriginPrivilegeCmp;
diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index ffb4d0722c..4b33eebf5c 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -1083,6 +1083,7 @@ parameter_types! {
         7 * 24 * 60 * 60 / 12 // 7 days
     };
     pub const SubtensorInitialKeySwapOnSubnetCost: u64 = 1_000_000; // 0.001 TAO
+    pub const HotkeySwapOnSubnetInterval : BlockNumber = 5 * 24 * 60 * 60 / 12; // 5 days
 }
 
 impl pallet_subtensor::Config for Runtime {
@@ -1149,6 +1150,7 @@ impl pallet_subtensor::Config for Runtime {
     type InitialEmaPriceHalvingPeriod = InitialEmaPriceHalvingPeriod;
     type DurationOfStartCall = DurationOfStartCall;
     type KeySwapOneSubnetCost = SubtensorInitialKeySwapOnSubnetCost;
+    type HotkeySwapOnSubnetInterval = HotkeySwapOnSubnetInterval;
 }
 
 use sp_runtime::BoundedVec;

From bbf8337c5165b73907ee1dfb618fc15fe01f5112 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Mon, 5 May 2025 09:24:42 +0800
Subject: [PATCH 110/418] add hook for clean up records

---
 pallets/subtensor/src/macros/hooks.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/pallets/subtensor/src/macros/hooks.rs b/pallets/subtensor/src/macros/hooks.rs
index a80b94f6b2..c552cf1db1 100644
--- a/pallets/subtensor/src/macros/hooks.rs
+++ b/pallets/subtensor/src/macros/hooks.rs
@@ -125,6 +125,8 @@ mod hooks {
     }
 
     impl<T: Config> Pallet<T> {
+        // This function is to clean up the old hotkey swap records
+        // It just clean up for one subnet at a time, according to the block number
         fn clean_up_hotkey_swap_records(block_number: BlockNumberFor<T>) {
             let hotkey_swap_on_subnet_interval = T::HotkeySwapOnSubnetInterval::get();
             let block_number: u64 = TryInto::try_into(block_number)

From 3cbe465742c1a594f0f1da6ac47f05b3b78dd2dc Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Mon, 5 May 2025 09:28:54 +0800
Subject: [PATCH 111/418] commit Cargo.lock

---
 pallets/admin-utils/src/tests/mock.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/pallets/admin-utils/src/tests/mock.rs b/pallets/admin-utils/src/tests/mock.rs
index fc80f77c35..f37b8e2537 100644
--- a/pallets/admin-utils/src/tests/mock.rs
+++ b/pallets/admin-utils/src/tests/mock.rs
@@ -137,6 +137,7 @@ parameter_types! {
     pub const InitialEmaPriceHalvingPeriod: u64 = 201_600_u64; // 4 weeks
     pub const DurationOfStartCall: u64 = 7 * 24 * 60 * 60 / 12; // 7 days
     pub const InitialKeySwapOnSubnetCost: u64 = 10_000_000;
+    pub const HotkeySwapOnSubnetInterval: u64 = 10_000_7 * 24 * 60 * 60 / 12; // 7 days
 }
 
 impl pallet_subtensor::Config for Test {
@@ -203,6 +204,7 @@ impl pallet_subtensor::Config for Test {
     type InitialEmaPriceHalvingPeriod = InitialEmaPriceHalvingPeriod;
     type DurationOfStartCall = DurationOfStartCall;
     type KeySwapOneSubnetCost = InitialKeySwapOnSubnetCost;
+    type HotkeySwapOnSubnetInterval = HotkeySwapOnSubnetInterval;
 }
 
 #[derive_impl(frame_system::config_preludes::TestDefaultConfig)]

From 1055f851ca0a3e1fbbf21b57e3977bc1641487f8 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Mon, 5 May 2025 09:29:44 +0800
Subject: [PATCH 112/418] fix mock, missed parameter

---
 pallets/admin-utils/src/tests/mock.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pallets/admin-utils/src/tests/mock.rs b/pallets/admin-utils/src/tests/mock.rs
index f37b8e2537..dcc583fe2f 100644
--- a/pallets/admin-utils/src/tests/mock.rs
+++ b/pallets/admin-utils/src/tests/mock.rs
@@ -137,7 +137,7 @@ parameter_types! {
     pub const InitialEmaPriceHalvingPeriod: u64 = 201_600_u64; // 4 weeks
     pub const DurationOfStartCall: u64 = 7 * 24 * 60 * 60 / 12; // 7 days
     pub const InitialKeySwapOnSubnetCost: u64 = 10_000_000;
-    pub const HotkeySwapOnSubnetInterval: u64 = 10_000_7 * 24 * 60 * 60 / 12; // 7 days
+    pub const HotkeySwapOnSubnetInterval: u64 = 7 * 24 * 60 * 60 / 12; // 7 days
 }
 
 impl pallet_subtensor::Config for Test {

From f63424ebf2acc604c71cdcd0fecd71c7642042c5 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Mon, 5 May 2025 09:42:29 +0800
Subject: [PATCH 113/418] fix clippy

---
 pallets/subtensor/src/macros/hooks.rs | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/pallets/subtensor/src/macros/hooks.rs b/pallets/subtensor/src/macros/hooks.rs
index c552cf1db1..e7d4b76353 100644
--- a/pallets/subtensor/src/macros/hooks.rs
+++ b/pallets/subtensor/src/macros/hooks.rs
@@ -134,14 +134,14 @@ mod hooks {
                 .expect("blockchain will not exceed 2^64 blocks; QED.");
             let netuids = Self::get_all_subnet_netuids();
 
-            let slot = block_number % hotkey_swap_on_subnet_interval;
-
-            if slot < (u16::MAX as u64) && netuids.contains(&(slot as u16)) {
-                for (coldkey, swap_block_number) in
-                    LastHotkeySwapOnNetuid::<T>::iter_prefix(slot as u16)
-                {
-                    if swap_block_number + hotkey_swap_on_subnet_interval < block_number {
-                        LastHotkeySwapOnNetuid::<T>::remove(slot as u16, coldkey);
+            if let Some(slot) = block_number.checked_rem(hotkey_swap_on_subnet_interval) {
+                if slot < (u16::MAX as u64) && netuids.contains(&(slot as u16)) {
+                    for (coldkey, swap_block_number) in
+                        LastHotkeySwapOnNetuid::<T>::iter_prefix(slot as u16)
+                    {
+                        if swap_block_number + hotkey_swap_on_subnet_interval < block_number {
+                            LastHotkeySwapOnNetuid::<T>::remove(slot as u16, coldkey);
+                        }
                     }
                 }
             }

From 566b24b05b63ab67a804d97bd12118ff1d26f00f Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Mon, 5 May 2025 10:13:07 +0800
Subject: [PATCH 114/418] fix clippy

---
 pallets/subtensor/src/macros/hooks.rs     | 4 +++-
 pallets/subtensor/src/swap/swap_hotkey.rs | 2 +-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/pallets/subtensor/src/macros/hooks.rs b/pallets/subtensor/src/macros/hooks.rs
index e7d4b76353..f95819d064 100644
--- a/pallets/subtensor/src/macros/hooks.rs
+++ b/pallets/subtensor/src/macros/hooks.rs
@@ -139,7 +139,9 @@ mod hooks {
                     for (coldkey, swap_block_number) in
                         LastHotkeySwapOnNetuid::<T>::iter_prefix(slot as u16)
                     {
-                        if swap_block_number + hotkey_swap_on_subnet_interval < block_number {
+                        if swap_block_number.saturating_add(hotkey_swap_on_subnet_interval)
+                            < block_number
+                        {
                             LastHotkeySwapOnNetuid::<T>::remove(slot as u16, coldkey);
                         }
                     }
diff --git a/pallets/subtensor/src/swap/swap_hotkey.rs b/pallets/subtensor/src/swap/swap_hotkey.rs
index ff3580923f..67d9c417d5 100644
--- a/pallets/subtensor/src/swap/swap_hotkey.rs
+++ b/pallets/subtensor/src/swap/swap_hotkey.rs
@@ -271,7 +271,7 @@ impl<T: Config> Pallet<T> {
         let last_hotkey_swap_block = LastHotkeySwapOnNetuid::<T>::get(netuid, coldkey);
 
         ensure!(
-            last_hotkey_swap_block + hotkey_swap_interval < block,
+            last_hotkey_swap_block.saturating_add(hotkey_swap_interval) < block,
             Error::<T>::HotKeySwapOnSubnetIntervalNotPassed
         );
         weight.saturating_accrue(T::DbWeight::get().reads_writes(3, 0));

From 0b0856bc7cf1ea29ea767b3e3d5521cdafa478aa Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Mon, 5 May 2025 10:41:21 +0800
Subject: [PATCH 115/418] fix test case

---
 .../src/tests/swap_hotkey_with_subnet.rs      | 37 +++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
index df8366a49b..efe4790f0a 100644
--- a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
+++ b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
@@ -22,6 +22,7 @@ fn test_swap_owner() {
         let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
         Owner::<Test>::insert(old_hotkey, coldkey);
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
         assert_ok!(SubtensorModule::do_swap_hotkey(
             RuntimeOrigin::signed(coldkey),
             &old_hotkey,
@@ -46,6 +47,7 @@ fn test_swap_owned_hotkeys() {
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
 
         OwnedHotkeys::<Test>::insert(coldkey, vec![old_hotkey]);
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
         assert_ok!(SubtensorModule::do_swap_hotkey(
             RuntimeOrigin::signed(coldkey),
             &old_hotkey,
@@ -97,6 +99,7 @@ fn test_swap_total_hotkey_stake() {
         );
 
         // Swap hotkey
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
         assert_ok!(SubtensorModule::do_swap_hotkey(
             RuntimeOrigin::signed(coldkey),
             &old_hotkey,
@@ -131,6 +134,7 @@ fn test_swap_senate_members() {
 
         assert_ok!(SenateMembers::add_member(RuntimeOrigin::root(), old_hotkey));
 
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
         assert_ok!(SubtensorModule::do_swap_hotkey(
             RuntimeOrigin::signed(coldkey),
             &old_hotkey,
@@ -156,6 +160,7 @@ fn test_swap_delegates() {
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
 
         Delegates::<Test>::insert(old_hotkey, 100);
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
         assert_ok!(SubtensorModule::do_swap_hotkey(
             RuntimeOrigin::signed(coldkey),
             &old_hotkey,
@@ -180,6 +185,7 @@ fn test_swap_subnet_membership() {
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
 
         IsNetworkMember::<Test>::insert(old_hotkey, netuid, true);
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
         assert_ok!(SubtensorModule::do_swap_hotkey(
             RuntimeOrigin::signed(coldkey),
             &old_hotkey,
@@ -208,6 +214,7 @@ fn test_swap_uids_and_keys() {
         Uids::<Test>::insert(netuid, old_hotkey, uid);
         Keys::<Test>::insert(netuid, uid, old_hotkey);
 
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
         assert_ok!(SubtensorModule::do_swap_hotkey(
             RuntimeOrigin::signed(coldkey),
             &old_hotkey,
@@ -238,6 +245,7 @@ fn test_swap_prometheus() {
         IsNetworkMember::<Test>::insert(old_hotkey, netuid, true);
         Prometheus::<Test>::insert(netuid, old_hotkey, prometheus_info.clone());
 
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
         assert_ok!(SubtensorModule::do_swap_hotkey(
             RuntimeOrigin::signed(coldkey),
             &old_hotkey,
@@ -270,6 +278,7 @@ fn test_swap_axons() {
         IsNetworkMember::<Test>::insert(old_hotkey, netuid, true);
         Axons::<Test>::insert(netuid, old_hotkey, axon_info.clone());
 
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
         assert_ok!(SubtensorModule::do_swap_hotkey(
             RuntimeOrigin::signed(coldkey),
             &old_hotkey,
@@ -299,6 +308,7 @@ fn test_swap_certificates() {
         IsNetworkMember::<Test>::insert(old_hotkey, netuid, true);
         NeuronCertificates::<Test>::insert(netuid, old_hotkey, certificate.clone());
 
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
         assert_ok!(SubtensorModule::do_swap_hotkey(
             RuntimeOrigin::signed(coldkey),
             &old_hotkey,
@@ -334,6 +344,7 @@ fn test_swap_weight_commits() {
         IsNetworkMember::<Test>::insert(old_hotkey, netuid, true);
         WeightCommits::<Test>::insert(netuid, old_hotkey, weight_commits.clone());
 
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
         assert_ok!(SubtensorModule::do_swap_hotkey(
             RuntimeOrigin::signed(coldkey),
             &old_hotkey,
@@ -370,6 +381,7 @@ fn test_swap_loaded_emission() {
             vec![(old_hotkey, server_emission, validator_emission)],
         );
 
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
         assert_ok!(SubtensorModule::do_swap_hotkey(
             RuntimeOrigin::signed(coldkey),
             &old_hotkey,
@@ -398,6 +410,7 @@ fn test_swap_staking_hotkeys() {
         StakingHotkeys::<Test>::insert(coldkey, vec![old_hotkey]);
         Alpha::<Test>::insert((old_hotkey, coldkey, netuid), U64F64::from_num(100));
 
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
         assert_ok!(SubtensorModule::do_swap_hotkey(
             RuntimeOrigin::signed(coldkey),
             &old_hotkey,
@@ -447,6 +460,7 @@ fn test_swap_hotkey_with_multiple_coldkeys() {
         let stake1_before = SubtensorModule::get_total_stake_for_coldkey(&coldkey1);
         let stake2_before = SubtensorModule::get_total_stake_for_coldkey(&coldkey2);
 
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
         assert_ok!(SubtensorModule::do_swap_hotkey(
             RuntimeOrigin::signed(coldkey1),
             &old_hotkey,
@@ -493,6 +507,7 @@ fn test_swap_hotkey_with_multiple_subnets() {
         IsNetworkMember::<Test>::insert(old_hotkey, netuid1, true);
         IsNetworkMember::<Test>::insert(old_hotkey, netuid2, true);
 
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
         assert_ok!(SubtensorModule::do_swap_hotkey(
             RuntimeOrigin::signed(coldkey),
             &old_hotkey,
@@ -500,6 +515,7 @@ fn test_swap_hotkey_with_multiple_subnets() {
             Some(netuid1)
         ));
 
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
         assert_ok!(SubtensorModule::do_swap_hotkey(
             RuntimeOrigin::signed(coldkey),
             &old_hotkey,
@@ -551,6 +567,7 @@ fn test_swap_staking_hotkeys_multiple_coldkeys() {
             stake
         ));
 
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
         assert_ok!(SubtensorModule::do_swap_hotkey(
             RuntimeOrigin::signed(coldkey1),
             &old_hotkey,
@@ -587,6 +604,7 @@ fn test_swap_hotkey_with_no_stake() {
         // Set up initial state with no stake
         Owner::<Test>::insert(old_hotkey, coldkey);
 
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
         assert_ok!(SubtensorModule::do_swap_hotkey(
             RuntimeOrigin::signed(coldkey),
             &old_hotkey,
@@ -656,6 +674,7 @@ fn test_swap_hotkey_with_multiple_coldkeys_and_subnets() {
         assert!(ck2_stake > 0);
         let total_hk_stake = SubtensorModule::get_total_stake_for_hotkey(&old_hotkey);
         assert!(total_hk_stake > 0);
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
 
         assert_ok!(SubtensorModule::do_swap_hotkey(
             RuntimeOrigin::signed(coldkey1),
@@ -664,6 +683,7 @@ fn test_swap_hotkey_with_multiple_coldkeys_and_subnets() {
             Some(netuid1)
         ));
 
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
         assert_ok!(SubtensorModule::do_swap_hotkey(
             RuntimeOrigin::signed(coldkey1),
             &old_hotkey,
@@ -768,6 +788,7 @@ fn test_swap_hotkey_tx_rate_limit_exceeded() {
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, swap_cost);
 
         // Perform the first swap
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
         assert_ok!(SubtensorModule::do_swap_hotkey(
             RuntimeOrigin::signed(coldkey),
             &old_hotkey,
@@ -788,6 +809,7 @@ fn test_swap_hotkey_tx_rate_limit_exceeded() {
 
         // move in time past the rate limit
         step_block(1001);
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
         assert_ok!(SubtensorModule::do_swap_hotkey(
             <<Test as Config>::RuntimeOrigin>::signed(coldkey),
             &new_hotkey_1,
@@ -875,6 +897,7 @@ fn test_swap_owner_new_hotkey_already_exists() {
         Owner::<Test>::insert(new_hotkey, another_coldkey);
 
         // Perform the swap
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
         assert_err!(
             SubtensorModule::do_swap_hotkey(
                 RuntimeOrigin::signed(coldkey),
@@ -914,6 +937,7 @@ fn test_swap_stake_success() {
         TaoDividendsPerSubnet::<Test>::insert(netuid, old_hotkey, amount);
 
         // Perform the swap
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
         assert_ok!(SubtensorModule::do_swap_hotkey(
             RuntimeOrigin::signed(coldkey),
             &old_hotkey,
@@ -978,6 +1002,7 @@ fn test_swap_hotkey_error_cases() {
 
         // Test not enough balance
         let swap_cost = SubtensorModule::get_key_swap_cost();
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
         assert_err!(
             SubtensorModule::do_swap_hotkey(
                 RuntimeOrigin::signed(coldkey),
@@ -992,6 +1017,7 @@ fn test_swap_hotkey_error_cases() {
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, initial_balance);
 
         // Test new hotkey same as old
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
         assert_noop!(
             SubtensorModule::do_swap_hotkey(
                 RuntimeOrigin::signed(coldkey),
@@ -1004,6 +1030,7 @@ fn test_swap_hotkey_error_cases() {
 
         // Test new hotkey already registered
         IsNetworkMember::<Test>::insert(new_hotkey, netuid, true);
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
         assert_noop!(
             SubtensorModule::do_swap_hotkey(
                 RuntimeOrigin::signed(coldkey),
@@ -1027,6 +1054,7 @@ fn test_swap_hotkey_error_cases() {
         );
 
         // Run the successful swap
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
         assert_ok!(SubtensorModule::do_swap_hotkey(
             RuntimeOrigin::signed(coldkey),
             &old_hotkey,
@@ -1052,6 +1080,7 @@ fn test_swap_child_keys() {
         ChildKeys::<Test>::insert(old_hotkey, netuid, children.clone());
 
         // Perform the swap
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
         assert_ok!(SubtensorModule::do_swap_hotkey(
             RuntimeOrigin::signed(coldkey),
             &old_hotkey,
@@ -1084,6 +1113,7 @@ fn test_swap_parent_keys() {
         ChildKeys::<Test>::insert(U256::from(5), netuid, vec![(200u64, old_hotkey)]);
 
         // Perform the swap
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
         assert_ok!(SubtensorModule::do_swap_hotkey(
             RuntimeOrigin::signed(coldkey),
             &old_hotkey,
@@ -1127,6 +1157,7 @@ fn test_swap_multiple_subnets() {
         ChildKeys::<Test>::insert(old_hotkey, netuid2, children2.clone());
 
         // Perform the swap
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
         assert_ok!(SubtensorModule::do_swap_hotkey(
             RuntimeOrigin::signed(coldkey),
             &old_hotkey,
@@ -1134,6 +1165,7 @@ fn test_swap_multiple_subnets() {
             Some(netuid1)
         ),);
 
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
         assert_ok!(SubtensorModule::do_swap_hotkey(
             RuntimeOrigin::signed(coldkey),
             &old_hotkey,
@@ -1182,6 +1214,7 @@ fn test_swap_complex_parent_child_structure() {
         );
 
         // Perform the swap
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
         assert_ok!(SubtensorModule::do_swap_hotkey(
             RuntimeOrigin::signed(coldkey),
             &old_hotkey,
@@ -1249,6 +1282,7 @@ fn test_swap_parent_hotkey_childkey_maps() {
 
         // Swap
 
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
         assert_ok!(SubtensorModule::do_swap_hotkey(
             RuntimeOrigin::signed(coldkey),
             &parent_old,
@@ -1305,6 +1339,7 @@ fn test_swap_child_hotkey_childkey_maps() {
 
         // Swap
 
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
         assert_ok!(SubtensorModule::do_swap_hotkey(
             RuntimeOrigin::signed(coldkey),
             &child_old,
@@ -1344,6 +1379,7 @@ fn test_swap_hotkey_is_sn_owner_hotkey() {
         assert_eq!(SubnetOwnerHotkey::<Test>::get(netuid), old_hotkey);
 
         // Perform the swap
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
         assert_ok!(SubtensorModule::do_swap_hotkey(
             RuntimeOrigin::signed(coldkey),
             &old_hotkey,
@@ -1379,6 +1415,7 @@ fn test_swap_hotkey_swap_rate_limits() {
         LastTxBlockChildKeyTake::<Test>::insert(old_hotkey, child_key_take_block);
 
         // Perform the swap
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
         assert_ok!(SubtensorModule::do_swap_hotkey(
             RuntimeOrigin::signed(coldkey),
             &old_hotkey,

From 054222d38f55d7eeaeaef67f31a08b56097008e6 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Mon, 5 May 2025 11:26:00 +0800
Subject: [PATCH 116/418] test case for records

---
 pallets/subtensor/src/tests/mock.rs           |  2 +-
 .../src/tests/swap_hotkey_with_subnet.rs      | 79 +++++++++++++++++++
 2 files changed, 80 insertions(+), 1 deletion(-)

diff --git a/pallets/subtensor/src/tests/mock.rs b/pallets/subtensor/src/tests/mock.rs
index bb43015b87..1757bc3605 100644
--- a/pallets/subtensor/src/tests/mock.rs
+++ b/pallets/subtensor/src/tests/mock.rs
@@ -187,7 +187,7 @@ parameter_types! {
     pub const InitialEmaPriceHalvingPeriod: u64 = 201_600_u64; // 4 weeks
     pub const DurationOfStartCall: u64 =  7 * 24 * 60 * 60 / 12; // Default as 7 days
     pub const InitialKeySwapOnSubnetCost: u64 = 10_000_000;
-    pub const HotkeySwapOnSubnetInterval: u64 = 1; // 1 block
+    pub const HotkeySwapOnSubnetInterval: u64 = 15; // 15 block, should be bigger than subnet number, then trigger clean up for all subnets
 
 }
 
diff --git a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
index efe4790f0a..583a8cf448 100644
--- a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
+++ b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
@@ -1435,3 +1435,82 @@ fn test_swap_hotkey_swap_rate_limits() {
         );
     });
 }
+
+#[test]
+fn test_swap_owner_failed_interval_not_passed() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+
+        let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+        Owner::<Test>::insert(old_hotkey, coldkey);
+        assert_err!(
+            SubtensorModule::do_swap_hotkey(
+                RuntimeOrigin::signed(coldkey),
+                &old_hotkey,
+                &new_hotkey,
+                Some(netuid)
+            ),
+            Error::<Test>::HotKeySwapOnSubnetIntervalNotPassed,
+        );
+    });
+}
+
+#[test]
+fn test_swap_owner_check_swap_block_set() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+
+        let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+        Owner::<Test>::insert(old_hotkey, coldkey);
+        let new_block_number = System::block_number() + HotkeySwapOnSubnetInterval::get();
+        System::set_block_number(new_block_number);
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
+            &old_hotkey,
+            &new_hotkey,
+            Some(netuid)
+        ));
+
+        assert_eq!(
+            LastHotkeySwapOnNetuid::<Test>::get(netuid, coldkey),
+            new_block_number
+        );
+    });
+}
+
+#[test]
+fn test_swap_owner_check_swap_record_clean_up() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+
+        let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+        Owner::<Test>::insert(old_hotkey, coldkey);
+        let new_block_number = System::block_number() + HotkeySwapOnSubnetInterval::get();
+        System::set_block_number(new_block_number);
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
+            &old_hotkey,
+            &new_hotkey,
+            Some(netuid)
+        ));
+
+        assert_eq!(
+            LastHotkeySwapOnNetuid::<Test>::get(netuid, coldkey),
+            new_block_number
+        );
+
+        step_block((HotkeySwapOnSubnetInterval::get() as u16 + netuid) * 2);
+        assert!(!LastHotkeySwapOnNetuid::<Test>::contains_key(
+            netuid, coldkey
+        ));
+    });
+}

From d0f0ce287777c609a4814676b569e3eff86671f4 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Mon, 5 May 2025 17:02:25 +0200
Subject: [PATCH 117/418] Fix senate tests

---
 pallets/subtensor/src/tests/senate.rs | 93 +++++++++++++++++++--------
 1 file changed, 66 insertions(+), 27 deletions(-)

diff --git a/pallets/subtensor/src/tests/senate.rs b/pallets/subtensor/src/tests/senate.rs
index c5aa93f10b..bd1bebf9b3 100644
--- a/pallets/subtensor/src/tests/senate.rs
+++ b/pallets/subtensor/src/tests/senate.rs
@@ -68,7 +68,6 @@ fn test_senate_join_works() {
         let burn_cost = 1000;
         let coldkey_account_id = U256::from(667); // Neighbour of the beast, har har
         let stake = DefaultMinStake::<Test>::get() * 100;
-        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         //add network
         SubtensorModule::set_burn(netuid, burn_cost);
@@ -76,6 +75,9 @@ fn test_senate_join_works() {
         // Give it some $$$ in his coldkey balance
         SubtensorModule::add_balance_to_coldkey_account(&coldkey_account_id, 10000);
 
+        let reserve = stake * 1000;
+        mock::setup_reserves(netuid, reserve, reserve);
+
         // Subscribe and check extrinsic output
         assert_ok!(SubtensorModule::burned_register(
             <<Test as Config>::RuntimeOrigin>::signed(coldkey_account_id),
@@ -101,6 +103,7 @@ fn test_senate_join_works() {
         let staker_coldkey = U256::from(7);
         SubtensorModule::add_balance_to_coldkey_account(&staker_coldkey, stake);
 
+        let (_, fee) = mock::swap_tao_to_alpha(netuid, stake);
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(staker_coldkey),
             hotkey_account_id,
@@ -108,19 +111,21 @@ fn test_senate_join_works() {
             stake
         ));
 
+        let approx_expected = stake - fee;
+
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
                 &hotkey_account_id,
                 &staker_coldkey,
                 netuid
             ),
-            stake - fee,
-            epsilon = 10
+            approx_expected,
+            epsilon = approx_expected / 1000
         );
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_on_subnet(&hotkey_account_id, netuid),
-            stake - fee,
-            epsilon = 10
+            approx_expected,
+            epsilon = approx_expected / 1000
         );
 
         assert_ok!(SubtensorModule::root_register(
@@ -142,7 +147,6 @@ fn test_senate_vote_works() {
         let hotkey_account_id = U256::from(6);
         let burn_cost = 1000;
         let coldkey_account_id = U256::from(667); // Neighbour of the beast, har har
-        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         //add network
         SubtensorModule::set_burn(netuid, burn_cost);
@@ -150,6 +154,9 @@ fn test_senate_vote_works() {
         // Give it some $$$ in his coldkey balance
         SubtensorModule::add_balance_to_coldkey_account(&coldkey_account_id, 10000);
 
+        let reserve = 1_000_000_000_000;
+        mock::setup_reserves(netuid, reserve, reserve);
+
         // Subscribe and check extrinsic output
         assert_ok!(SubtensorModule::burned_register(
             <<Test as Config>::RuntimeOrigin>::signed(coldkey_account_id),
@@ -176,25 +183,28 @@ fn test_senate_vote_works() {
         let stake = DefaultMinStake::<Test>::get() * 10;
         SubtensorModule::add_balance_to_coldkey_account(&staker_coldkey, stake);
 
+        let (_, fee) = mock::swap_tao_to_alpha(netuid, stake);
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(staker_coldkey),
             hotkey_account_id,
             netuid,
             stake
         ));
+
+		let approx_expected = stake - fee;
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
                 &hotkey_account_id,
                 &staker_coldkey,
                 netuid
             ),
-            stake - fee,
-            epsilon = stake / 1000
+			approx_expected,
+            epsilon = approx_expected / 1000
         );
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_on_subnet(&hotkey_account_id, netuid),
-            stake - fee,
-            epsilon = stake / 1000
+			approx_expected,
+            epsilon = approx_expected / 1000
         );
 
         assert_ok!(SubtensorModule::root_register(
@@ -262,6 +272,9 @@ fn test_senate_vote_not_member() {
         // Give it some $$$ in his coldkey balance
         SubtensorModule::add_balance_to_coldkey_account(&coldkey_account_id, 10000);
 
+        let reserve = 1_000_000_000_000;
+        mock::setup_reserves(netuid, reserve, reserve);
+
         // Subscribe and check extrinsic output
         assert_ok!(SubtensorModule::burned_register(
             <<Test as Config>::RuntimeOrigin>::signed(coldkey_account_id),
@@ -316,7 +329,6 @@ fn test_senate_leave_works() {
         let burn_cost = 1000;
         let coldkey_account_id = U256::from(667); // Neighbour of the beast, har har
         let stake = DefaultMinStake::<Test>::get() * 10;
-        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         //add network
         SubtensorModule::set_burn(netuid, burn_cost);
@@ -324,6 +336,9 @@ fn test_senate_leave_works() {
         // Give it some $$$ in his coldkey balance
         SubtensorModule::add_balance_to_coldkey_account(&coldkey_account_id, 10000);
 
+        let reserve = stake * 1000;
+        mock::setup_reserves(netuid, reserve, reserve);
+
         // Subscribe and check extrinsic output
         assert_ok!(SubtensorModule::burned_register(
             <<Test as Config>::RuntimeOrigin>::signed(coldkey_account_id),
@@ -349,25 +364,28 @@ fn test_senate_leave_works() {
         let staker_coldkey = U256::from(7);
         SubtensorModule::add_balance_to_coldkey_account(&staker_coldkey, stake);
 
+        let (_, fee) = mock::swap_tao_to_alpha(netuid, stake);
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(staker_coldkey),
             hotkey_account_id,
             netuid,
             stake
         ));
+
+        let approx_expected = stake - fee;
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
                 &hotkey_account_id,
                 &staker_coldkey,
                 netuid
             ),
-            stake - fee,
-            epsilon = stake / 1000
+            approx_expected,
+            epsilon = approx_expected / 1000
         );
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_on_subnet(&hotkey_account_id, netuid),
-            stake - fee,
-            epsilon = stake / 1000
+            approx_expected,
+            epsilon = approx_expected / 1000
         );
 
         assert_ok!(SubtensorModule::root_register(
@@ -391,7 +409,6 @@ fn test_senate_leave_vote_removal() {
         let coldkey_account_id = U256::from(667); // Neighbour of the beast, har har
         let coldkey_origin = <<Test as Config>::RuntimeOrigin>::signed(coldkey_account_id);
         let stake = DefaultMinStake::<Test>::get() * 10;
-        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         //add network
         SubtensorModule::set_burn(netuid, burn_cost);
@@ -399,6 +416,9 @@ fn test_senate_leave_vote_removal() {
         // Give it some $$$ in his coldkey balance
         SubtensorModule::add_balance_to_coldkey_account(&coldkey_account_id, stake);
 
+        let reserve = stake * 1000;
+        mock::setup_reserves(netuid, reserve, reserve);
+
         // Subscribe and check extrinsic output
         assert_ok!(SubtensorModule::burned_register(
             coldkey_origin.clone(),
@@ -424,25 +444,29 @@ fn test_senate_leave_vote_removal() {
         let staker_coldkey = U256::from(7);
         SubtensorModule::add_balance_to_coldkey_account(&staker_coldkey, stake);
 
+        let (_, fee) = mock::swap_tao_to_alpha(netuid, stake);
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(staker_coldkey),
             hotkey_account_id,
             netuid,
             stake
         ));
+
+        let approx_expected = stake - fee;
+
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
                 &hotkey_account_id,
                 &staker_coldkey,
                 netuid
             ),
-            stake - fee,
-            epsilon = 10
+            approx_expected,
+            epsilon = approx_expected / 1000
         );
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_on_subnet(&hotkey_account_id, netuid),
-            stake - fee,
-            epsilon = 10
+            approx_expected,
+            epsilon = approx_expected / 1000
         );
 
         assert_ok!(SubtensorModule::root_register(
@@ -480,9 +504,14 @@ fn test_senate_leave_vote_removal() {
         SubtensorModule::set_target_registrations_per_interval(other_netuid, 1000);
         SubtensorModule::set_max_registrations_per_block(root_netuid, 1000);
         SubtensorModule::set_target_registrations_per_interval(root_netuid, 1000);
+
+        let reserve = 1_000_000_000_000;
+        mock::setup_reserves(other_netuid, reserve, reserve);
+        mock::setup_reserves(root_netuid, reserve, reserve);
+
         for i in 0..200 {
-            let hot: U256 = U256::from(i + 100);
-            let cold: U256 = U256::from(i + 100);
+            let hot = U256::from(i + 100);
+            let cold = U256::from(i + 100);
             // Add balance
             SubtensorModule::add_balance_to_coldkey_account(&cold, 100_000_000 + (i as u64)); // lots ot stake
             // Register
@@ -541,6 +570,9 @@ fn test_senate_not_leave_when_stake_removed() {
         // Give it some $$$ in his coldkey balance
         SubtensorModule::add_balance_to_coldkey_account(&coldkey_account_id, 10000);
 
+        let reserve = 1_000_000_000_000;
+        mock::setup_reserves(netuid, reserve, reserve);
+
         // Subscribe and check extrinsic output
         assert_ok!(SubtensorModule::burned_register(
             <<Test as Config>::RuntimeOrigin>::signed(coldkey_account_id),
@@ -567,25 +599,29 @@ fn test_senate_not_leave_when_stake_removed() {
         let stake_amount: u64 = DefaultMinStake::<Test>::get() * 10;
         SubtensorModule::add_balance_to_coldkey_account(&staker_coldkey, stake_amount);
 
+        let (_, fee) = mock::swap_tao_to_alpha(netuid, stake_amount);
+
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(staker_coldkey),
             hotkey_account_id,
             netuid,
             stake_amount
         ));
+
+        let approx_expected = stake_amount - fee;
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
                 &hotkey_account_id,
                 &staker_coldkey,
                 netuid
             ),
-            stake_amount - fee,
-            epsilon = stake_amount / 1000
+            approx_expected,
+            epsilon = approx_expected / 1000
         );
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_on_subnet(&hotkey_account_id, netuid),
-            stake_amount - fee,
-            epsilon = stake_amount / 1000
+            approx_expected,
+            epsilon = approx_expected / 1000
         );
 
         assert_ok!(SubtensorModule::root_register(
@@ -624,6 +660,9 @@ fn test_senate_join_current_delegate() {
         // Give some coldkey balance
         SubtensorModule::add_balance_to_coldkey_account(&coldkey_account_id, 10000);
 
+        let reserve = 1_000_000_000_000;
+        mock::setup_reserves(netuid, reserve, reserve);
+
         // Subscribe and check extrinsic output
         assert_ok!(SubtensorModule::burned_register(
             <<Test as Config>::RuntimeOrigin>::signed(coldkey_account_id),
@@ -812,7 +851,7 @@ fn test_adjust_senate_events() {
         let reserve = stake * 1000;
         mock::setup_reserves(root_netuid, reserve, reserve);
 
-		let (_, fee) = mock::swap_tao_to_alpha(root_netuid, stake);
+        let (_, fee) = mock::swap_tao_to_alpha(root_netuid, stake);
 
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(coldkey_account_id),

From 15455de21d27ff4550b0c00b73271118face4660 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Mon, 5 May 2025 18:26:43 +0200
Subject: [PATCH 118/418] Fix tests relying on DefaultMinimumPoolLiquidity

---
 pallets/subtensor/src/lib.rs           |  6 ---
 pallets/subtensor/src/tests/staking.rs | 62 ++++++++++++--------------
 2 files changed, 29 insertions(+), 39 deletions(-)

diff --git a/pallets/subtensor/src/lib.rs b/pallets/subtensor/src/lib.rs
index fc18d19a66..c7a28502aa 100644
--- a/pallets/subtensor/src/lib.rs
+++ b/pallets/subtensor/src/lib.rs
@@ -782,12 +782,6 @@ pub mod pallet {
         U64F64::saturating_from_num(0)
     }
 
-    #[pallet::type_value]
-    /// Default value for minimum liquidity in pool
-    pub fn DefaultMinimumPoolLiquidity<T: Config>() -> I96F32 {
-        I96F32::saturating_from_num(10_000_000)
-    }
-
     #[pallet::type_value]
     /// Default value for minimum activity cutoff
     pub fn DefaultMinActivityCutoff<T: Config>() -> u16 {
diff --git a/pallets/subtensor/src/tests/staking.rs b/pallets/subtensor/src/tests/staking.rs
index c69942b1d0..f01b3a00c5 100644
--- a/pallets/subtensor/src/tests/staking.rs
+++ b/pallets/subtensor/src/tests/staking.rs
@@ -418,12 +418,12 @@ fn test_remove_stake_ok_no_emission() {
         assert_abs_diff_eq!(
             SubtensorModule::get_total_stake_for_hotkey(&hotkey_account_id),
             0,
-			epsilon = 20000
+            epsilon = 20000
         );
         assert_abs_diff_eq!(
             SubtensorModule::get_total_stake(),
             SubtensorModule::get_network_min_lock() + fee,
-			epsilon = 1000
+            epsilon = 1000
         );
     });
 }
@@ -624,7 +624,7 @@ fn test_add_stake_insufficient_liquidity() {
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, amount_staked);
 
         // Set the liquidity at lowest possible value so that all staking requests fail
-        let reserve = DefaultMinimumPoolLiquidity::<Test>::get().to_num::<u64>();
+        let reserve = u64::from(mock::SwapMinimumReserve::get()) - 1;
         mock::setup_reserves(netuid, reserve, reserve);
 
         // Check the error
@@ -667,14 +667,8 @@ fn test_remove_stake_insufficient_liquidity() {
         .unwrap();
 
         // Set the liquidity at lowest possible value so that all staking requests fail
-        SubnetTAO::<Test>::insert(
-            netuid,
-            DefaultMinimumPoolLiquidity::<Test>::get().to_num::<u64>(),
-        );
-        SubnetAlphaIn::<Test>::insert(
-            netuid,
-            DefaultMinimumPoolLiquidity::<Test>::get().to_num::<u64>(),
-        );
+        let reserve = u64::from(mock::SwapMinimumReserve::get()) - 1;
+        mock::setup_reserves(netuid, reserve, reserve);
 
         // Check the error
         assert_noop!(
@@ -2725,7 +2719,7 @@ fn test_stake_low_liquidity_validate() {
 
         // Set the liquidity at lowest possible value so that all staking requests fail
 
-        let reserve = mock::SwapMinimumReserve::get().into();
+        let reserve = u64::from(mock::SwapMinimumReserve::get()) - 1;
         mock::setup_reserves(netuid, reserve, reserve);
 
         // Add stake call
@@ -2781,7 +2775,7 @@ fn test_unstake_low_liquidity_validate() {
         .unwrap();
 
         // Set the liquidity at lowest possible value so that all staking requests fail
-        let reserve = DefaultMinimumPoolLiquidity::<Test>::get().to_num::<u64>();
+        let reserve = u64::from(mock::SwapMinimumReserve::get()) - 1;
         mock::setup_reserves(netuid, reserve, reserve);
 
         // Remove stake call
@@ -3695,6 +3689,8 @@ fn test_add_stake_limit_fill_or_kill() {
         SubnetTAO::<Test>::insert(netuid, tao_reserve.to_num::<u64>());
         SubnetAlphaIn::<Test>::insert(netuid, alpha_in.to_num::<u64>());
         let current_price = <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid);
+		// FIXME it's failing because in the swap pallet, the alpha price is set only after an
+		// initial swap
         assert_eq!(current_price, U96F32::from_num(1.5));
 
         // Give it some $$$ in his coldkey balance
@@ -4251,17 +4247,16 @@ fn test_unstake_all_hits_liquidity_min() {
         );
 
         // Setup the Alpha pool so that removing all the Alpha will bring liqudity below the minimum
-        let remaining_tao: I96F32 =
-            DefaultMinimumPoolLiquidity::<Test>::get().saturating_sub(I96F32::from(1));
-        let alpha_reserves: I110F18 = I110F18::from(stake_amount + 10_000_000);
+        let remaining_tao = I96F32::from_num(u64::from(mock::SwapMinimumReserve::get()) - 1)
+            .saturating_sub(I96F32::from(1));
+        let alpha_reserves = I110F18::from(stake_amount + 10_000_000);
         let alpha = stake_amount;
 
-        let k: I110F18 = I110F18::from_fixed(remaining_tao)
+        let k = I110F18::from_fixed(remaining_tao)
             .saturating_mul(alpha_reserves.saturating_add(I110F18::from(alpha)));
-        let tao_reserves: I110F18 = k.safe_div(alpha_reserves);
+        let tao_reserves = k.safe_div(alpha_reserves);
 
-        SubnetTAO::<Test>::insert(netuid, tao_reserves.to_num::<u64>());
-        SubnetAlphaIn::<Test>::insert(netuid, alpha_reserves.to_num::<u64>());
+        mock::setup_reserves(netuid, tao_reserves.to_num(), alpha_reserves.to_num());
 
         // Try to unstake, but we reduce liquidity too far
 
@@ -4298,17 +4293,16 @@ fn test_unstake_all_alpha_hits_liquidity_min() {
         );
 
         // Setup the Alpha pool so that removing all the Alpha will bring liqudity below the minimum
-        let remaining_tao: I96F32 =
-            DefaultMinimumPoolLiquidity::<Test>::get().saturating_sub(I96F32::from(1));
-        let alpha_reserves: I110F18 = I110F18::from(stake_amount + 10_000_000);
+        let remaining_tao = I96F32::from_num(u64::from(mock::SwapMinimumReserve::get()) - 1)
+            .saturating_sub(I96F32::from(1));
+        let alpha_reserves = I110F18::from(stake_amount + 10_000_000);
         let alpha = stake_amount;
 
-        let k: I110F18 = I110F18::from_fixed(remaining_tao)
+        let k = I110F18::from_fixed(remaining_tao)
             .saturating_mul(alpha_reserves.saturating_add(I110F18::from(alpha)));
-        let tao_reserves: I110F18 = k.safe_div(alpha_reserves);
+        let tao_reserves = k.safe_div(alpha_reserves);
 
-        SubnetTAO::<Test>::insert(netuid, tao_reserves.to_num::<u64>());
-        SubnetAlphaIn::<Test>::insert(netuid, alpha_reserves.to_num::<u64>());
+        mock::setup_reserves(netuid, tao_reserves.to_num(), alpha_reserves.to_num());
 
         // Try to unstake, but we reduce liquidity too far
 
@@ -4346,8 +4340,8 @@ fn test_unstake_all_alpha_works() {
         );
 
         // Setup the Alpha pool so that removing all the Alpha will keep liq above min
-        let remaining_tao =
-            DefaultMinimumPoolLiquidity::<Test>::get().saturating_add(I96F32::from(10_000_000));
+        let remaining_tao = I96F32::from_num(u64::from(mock::SwapMinimumReserve::get()) - 1)
+            .saturating_add(I96F32::from(10_000_000));
         let alpha_reserves = I110F18::from(stake_amount + 10_000_000);
         let alpha = stake_amount;
 
@@ -4393,15 +4387,17 @@ fn test_unstake_all_works() {
         );
 
         // Setup the Alpha pool so that removing all the Alpha will keep liq above min
-        let remaining_tao: I96F32 =
-            DefaultMinimumPoolLiquidity::<Test>::get().saturating_add(I96F32::from(10_000_000));
-        let alpha_reserves: I110F18 = I110F18::from(stake_amount + 10_000_000);
+        let remaining_tao = I96F32::from_num(u64::from(mock::SwapMinimumReserve::get()) - 1)
+            .saturating_add(I96F32::from(10_000_000));
+        let alpha_reserves = I110F18::from(stake_amount + 10_000_000);
         let alpha = stake_amount;
 
-        let k: I110F18 = I110F18::from_fixed(remaining_tao)
+        let k = I110F18::from_fixed(remaining_tao)
             .saturating_mul(alpha_reserves.saturating_add(I110F18::from(alpha)));
         let tao_reserves: I110F18 = k.safe_div(alpha_reserves);
 
+        mock::setup_reserves(netuid, tao_reserves.to_num(), alpha_reserves.to_num());
+
         SubnetTAO::<Test>::insert(netuid, tao_reserves.to_num::<u64>());
         SubnetAlphaIn::<Test>::insert(netuid, alpha_reserves.to_num::<u64>());
 

From 22d7fe2a956b09512e2656ff3f60bc99066a23a5 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Mon, 5 May 2025 16:23:45 -0400
Subject: [PATCH 119/418] Address review comments

---
 pallets/swap-interface/src/lib.rs |  4 +-
 pallets/swap/src/pallet/impls.rs  | 68 +++++++++++++++++++------------
 pallets/swap/src/pallet/mod.rs    |  4 ++
 pallets/swap/src/position.rs      | 12 +++---
 pallets/swap/src/tick.rs          | 12 ++++--
 5 files changed, 63 insertions(+), 37 deletions(-)

diff --git a/pallets/swap-interface/src/lib.rs b/pallets/swap-interface/src/lib.rs
index 533e9ab52c..e26a85ba63 100644
--- a/pallets/swap-interface/src/lib.rs
+++ b/pallets/swap-interface/src/lib.rs
@@ -29,7 +29,7 @@ pub trait SwapHandler<AccountId> {
         netuid: u16,
         coldkey_account_id: &AccountId,
         position_id: u128,
-    ) -> Result<RemoveLiquidityResult, DispatchError>;
+    ) -> Result<UpdateLiquidityResult, DispatchError>;
     fn approx_fee_amount(netuid: u16, amount: u64) -> u64;
     fn current_alpha_price(netuid: u16) -> U96F32;
     fn max_price() -> u64;
@@ -47,7 +47,7 @@ pub struct SwapResult {
 }
 
 #[derive(Debug, PartialEq)]
-pub struct RemoveLiquidityResult {
+pub struct UpdateLiquidityResult {
     pub tao: u64,
     pub alpha: u64,
     pub fee_tao: u64,
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 2e0fdf60d0..858ab7b3bd 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -7,7 +7,7 @@ use sp_arithmetic::helpers_128bit;
 use sp_runtime::traits::AccountIdConversion;
 use substrate_fixed::types::{U64F64, U96F32};
 use subtensor_swap_interface::{
-    LiquidityDataProvider, RemoveLiquidityResult, SwapHandler, SwapResult,
+    LiquidityDataProvider, UpdateLiquidityResult, SwapHandler, SwapResult,
 };
 
 use super::pallet::*;
@@ -214,17 +214,17 @@ impl<T: Config> SwapStep<T> {
 
     /// Process a single step of a swap
     fn process_swap(&self) -> Result<SwapStepResult, Error<T>> {
-        // amount_swapped = delta_in / (1 - self.fee_size)
+        // total_cost = delta_in / (1 - self.fee_size)
         let fee_rate = U64F64::saturating_from_num(FeeRate::<T>::get(self.netuid));
         let u16_max = U64F64::saturating_from_num(u16::MAX);
         let delta_fixed = U64F64::saturating_from_num(self.delta_in);
-        let amount_swapped =
+        let total_cost =
             delta_fixed.saturating_mul(u16_max.safe_div(u16_max.saturating_sub(fee_rate)));
 
         // Hold the fees
         let fee = Pallet::<T>::calculate_fee_amount(
             self.netuid,
-            amount_swapped.saturating_to_num::<u64>(),
+            total_cost.saturating_to_num::<u64>(),
         );
         Pallet::<T>::add_fees(self.netuid, self.order_type, fee);
         let delta_out = Pallet::<T>::convert_deltas(self.netuid, self.order_type, self.delta_in);
@@ -275,11 +275,15 @@ impl<T: Config> SwapStep<T> {
             SwapStepAction::StopIn => {}
         }
 
-        // Update current price, which effectively updates current tick too
+        // Update current price
         AlphaSqrtPrice::<T>::set(self.netuid, self.final_price);
 
+        // Update current tick
+        let new_current_tick = TickIndex::from_sqrt_price_bounded(self.final_price);
+        CurrentTick::<T>::set(self.netuid, new_current_tick);
+
         Ok(SwapStepResult {
-            amount_to_take: amount_swapped.saturating_to_num::<u64>(),
+            amount_to_take: total_cost.saturating_to_num::<u64>(),
             delta_in: self.delta_in,
             delta_out,
         })
@@ -325,11 +329,16 @@ impl<T: Config> Pallet<T> {
 
         let epsilon = U64F64::saturating_from_num(0.000001);
 
+        let current_sqrt_price = price.checked_sqrt(epsilon).unwrap_or(U64F64::from_num(0));
         AlphaSqrtPrice::<T>::set(
             netuid,
-            price.checked_sqrt(epsilon).unwrap_or(U64F64::from_num(0)),
+            current_sqrt_price,
         );
 
+        // Set current tick
+        let current_tick = TickIndex::from_sqrt_price_bounded(current_sqrt_price);
+        CurrentTick::<T>::set(netuid, current_tick);        
+
         // Set initial (protocol owned) liquidity and positions
         // Protocol liquidity makes one position from TickIndex::MIN to TickIndex::MAX
         // We are using the sp_arithmetic sqrt here, which works for u128
@@ -449,8 +458,8 @@ impl<T: Config> Pallet<T> {
         };
 
         let global_fee = match order_type {
-            OrderType::Sell => FeeGlobalTao::<T>::get(netuid),
-            OrderType::Buy => FeeGlobalAlpha::<T>::get(netuid),
+            OrderType::Sell => FeeGlobalAlpha::<T>::get(netuid),
+            OrderType::Buy => FeeGlobalTao::<T>::get(netuid),
         };
         let fee_paid = global_fee
             .saturating_mul(SqrtPrice::saturating_from_num(liquidity_before))
@@ -539,15 +548,15 @@ impl<T: Config> Pallet<T> {
 
         match order_type {
             OrderType::Sell => {
-                FeeGlobalTao::<T>::set(
+                FeeGlobalAlpha::<T>::set(
                     netuid,
-                    fee_global_tao.saturating_add(fee_fixed.safe_div(liquidity_curr)),
+                    fee_global_alpha.saturating_add(fee_fixed.safe_div(liquidity_curr)),
                 );
             }
             OrderType::Buy => {
-                FeeGlobalAlpha::<T>::set(
+                FeeGlobalTao::<T>::set(
                     netuid,
-                    fee_global_alpha.saturating_add(fee_fixed.safe_div(liquidity_curr)),
+                    fee_global_tao.saturating_add(fee_fixed.safe_div(liquidity_curr)),
                 );
             }
         }
@@ -828,7 +837,7 @@ impl<T: Config> Pallet<T> {
         netuid: NetUid,
         coldkey_account_id: &T::AccountId,
         position_id: PositionId,
-    ) -> Result<RemoveLiquidityResult, Error<T>> {
+    ) -> Result<UpdateLiquidityResult, Error<T>> {
         let Some(mut position) = Positions::<T>::get((netuid, coldkey_account_id, position_id))
         else {
             return Err(Error::<T>::LiquidityNotFound);
@@ -866,11 +875,7 @@ impl<T: Config> Pallet<T> {
             //     self.state_ops.set_alpha_reserve(new_alpha_reserve);
         }
 
-        // TODO: Clear with R&D
-        // Update current price (why?)
-        // AlphaSqrtPrice::<T>::set(netuid, sqrt_price);
-
-        Ok(RemoveLiquidityResult {
+        Ok(UpdateLiquidityResult {
             tao,
             alpha,
             fee_tao,
@@ -884,7 +889,7 @@ impl<T: Config> Pallet<T> {
         hotkey_account_id: &T::AccountId,
         position_id: PositionId,
         liquidity_delta: i64,
-    ) -> Result<RemoveLiquidityResult, Error<T>> {
+    ) -> Result<UpdateLiquidityResult, Error<T>> {
         // Find the position
         let Some(mut position) = Positions::<T>::get((netuid, coldkey_account_id, position_id))
         else {
@@ -979,7 +984,7 @@ impl<T: Config> Pallet<T> {
 
         // TODO: Withdraw balances and update pool reserves
 
-        Ok(RemoveLiquidityResult {
+        Ok(UpdateLiquidityResult {
             tao: tao.saturating_to_num::<u64>(),
             alpha: alpha.saturating_to_num::<u64>(),
             fee_tao,
@@ -1148,7 +1153,7 @@ impl<T: Config> SwapHandler<T::AccountId> for Pallet<T> {
         netuid: u16,
         coldkey_account_id: &T::AccountId,
         position_id: u128,
-    ) -> Result<RemoveLiquidityResult, DispatchError> {
+    ) -> Result<UpdateLiquidityResult, DispatchError> {
         Self::remove_liquidity(netuid.into(), coldkey_account_id, position_id.into())
             .map_err(Into::into)
     }
@@ -1256,6 +1261,7 @@ mod tests {
 
             assert!(SwapV3Initialized::<Test>::get(netuid));
 
+            // Verify current price is set
             let sqrt_price = AlphaSqrtPrice::<Test>::get(netuid);
             let expected_sqrt_price = U64F64::from_num(tao)
                 .safe_div(U64F64::from_num(alpha))
@@ -1263,6 +1269,11 @@ mod tests {
                 .unwrap();
             assert_eq!(sqrt_price, expected_sqrt_price);
 
+            // Verify that current tick is set
+            let current_tick = CurrentTick::<Test>::get(netuid);            
+            let expected_current_tick = TickIndex::from_sqrt_price_bounded(expected_sqrt_price);
+            assert_eq!(current_tick, expected_current_tick);
+
             // Calculate expected liquidity
             let expected_liquidity =
                 helpers_128bit::sqrt((tao as u128).saturating_mul(alpha as u128)) as u64;
@@ -1719,8 +1730,8 @@ mod tests {
 
                     // Global fees should be updated
                     let actual_global_fee = ((match order_type {
-                        OrderType::Buy => FeeGlobalAlpha::<Test>::get(netuid),
-                        OrderType::Sell => FeeGlobalTao::<Test>::get(netuid),
+                        OrderType::Buy => FeeGlobalTao::<Test>::get(netuid),
+                        OrderType::Sell => FeeGlobalAlpha::<Test>::get(netuid),
                     })
                     .to_num::<f64>()
                         * (liquidity_before as f64))
@@ -1760,6 +1771,11 @@ mod tests {
                         OrderType::Buy => assert!(current_price_after > current_price),
                         OrderType::Sell => assert!(current_price_after < current_price),
                     }
+
+                    // Assert that current tick is updated
+                    let current_tick = CurrentTick::<Test>::get(netuid);            
+                    let expected_current_tick = TickIndex::from_sqrt_price_bounded(sqrt_current_price_after);
+                    assert_eq!(current_tick, expected_current_tick);                    
                 },
             );
         });
@@ -1985,8 +2001,8 @@ mod tests {
 
                         // Global fees should be updated
                         let actual_global_fee = ((match order_type {
-                            OrderType::Buy => FeeGlobalAlpha::<Test>::get(netuid),
-                            OrderType::Sell => FeeGlobalTao::<Test>::get(netuid),
+                            OrderType::Buy => FeeGlobalTao::<Test>::get(netuid),
+                            OrderType::Sell => FeeGlobalAlpha::<Test>::get(netuid),
                         })
                         .to_num::<f64>()
                             * (liquidity_before as f64))
diff --git a/pallets/swap/src/pallet/mod.rs b/pallets/swap/src/pallet/mod.rs
index 771132056c..e9b66fa2ca 100644
--- a/pallets/swap/src/pallet/mod.rs
+++ b/pallets/swap/src/pallet/mod.rs
@@ -91,6 +91,10 @@ mod pallet {
     #[pallet::storage]
     pub type AlphaSqrtPrice<T> = StorageMap<_, Twox64Concat, NetUid, U64F64, ValueQuery>;
 
+    /// Storage for the current price tick.
+    #[pallet::storage]
+    pub type CurrentTick<T> = StorageMap<_, Twox64Concat, NetUid, TickIndex, ValueQuery>;
+
     /// Storage for the current liquidity amount for each subnet.
     #[pallet::storage]
     pub type CurrentLiquidity<T> = StorageMap<_, Twox64Concat, NetUid, u64, ValueQuery>;
diff --git a/pallets/swap/src/position.rs b/pallets/swap/src/position.rs
index aa4fe85ddd..5ef685c26b 100644
--- a/pallets/swap/src/position.rs
+++ b/pallets/swap/src/position.rs
@@ -94,14 +94,14 @@ impl Position {
     /// Collect fees for a position
     /// Updates the position
     pub fn collect_fees<T: Config>(&mut self) -> (u64, u64) {
-        let mut fee_tao = self.fees_in_range::<T>(true);
-        let mut fee_alpha = self.fees_in_range::<T>(false);
+        let fee_tao_agg = self.fees_in_range::<T>(true);
+        let fee_alpha_agg = self.fees_in_range::<T>(false);
 
-        fee_tao = fee_tao.saturating_sub(self.fees_tao);
-        fee_alpha = fee_alpha.saturating_sub(self.fees_alpha);
+        let mut fee_tao = fee_tao_agg.saturating_sub(self.fees_tao);
+        let mut fee_alpha = fee_alpha_agg.saturating_sub(self.fees_alpha);
 
-        self.fees_tao = fee_tao;
-        self.fees_alpha = fee_alpha;
+        self.fees_tao = fee_tao_agg;
+        self.fees_alpha = fee_alpha_agg;
 
         fee_tao = self.liquidity.saturating_mul(fee_tao);
         fee_alpha = self.liquidity.saturating_mul(fee_alpha);
diff --git a/pallets/swap/src/tick.rs b/pallets/swap/src/tick.rs
index a13a8051eb..8253647abc 100644
--- a/pallets/swap/src/tick.rs
+++ b/pallets/swap/src/tick.rs
@@ -15,7 +15,7 @@ use substrate_fixed::types::U64F64;
 use subtensor_macros::freeze_struct;
 
 use crate::pallet::{
-    AlphaSqrtPrice, Config, FeeGlobalAlpha, FeeGlobalTao, TickIndexBitmapWords, Ticks,
+    AlphaSqrtPrice, Config, CurrentTick, FeeGlobalAlpha, FeeGlobalTao, TickIndexBitmapWords, Ticks,
 };
 use crate::{NetUid, SqrtPrice};
 
@@ -248,8 +248,14 @@ impl TickIndex {
 
     /// Get the current tick index for a subnet, ensuring it's within valid bounds
     pub fn current_bounded<T: Config>(netuid: NetUid) -> Self {
-        let current_price = AlphaSqrtPrice::<T>::get(netuid);
-        Self::from_sqrt_price_bounded(current_price)
+        let current_tick = CurrentTick::<T>::get(netuid);
+        if current_tick > Self::MAX {
+            Self::MAX
+        } else if current_tick < Self::MIN {
+            Self::MIN
+        } else {
+            current_tick
+        }
     }
 
     /// Converts a sqrt price to a tick index, ensuring it's within valid bounds

From 57f109764d9b5d8f4459cc9333c1fdd31c5e9c0b Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Tue, 6 May 2025 08:12:34 +0800
Subject: [PATCH 120/418] update execution index

---
 pallets/subtensor/src/swap/swap_hotkey.rs | 56 +++++++++++------------
 1 file changed, 28 insertions(+), 28 deletions(-)

diff --git a/pallets/subtensor/src/swap/swap_hotkey.rs b/pallets/subtensor/src/swap/swap_hotkey.rs
index 67d9c417d5..f9b5cb9ebc 100644
--- a/pallets/subtensor/src/swap/swap_hotkey.rs
+++ b/pallets/subtensor/src/swap/swap_hotkey.rs
@@ -276,7 +276,7 @@ impl<T: Config> Pallet<T> {
         );
         weight.saturating_accrue(T::DbWeight::get().reads_writes(3, 0));
 
-        // Ensure the hotkey not registered on the network before.
+        // 2. Ensure the hotkey not registered on the network before.
         ensure!(
             !Self::is_hotkey_registered_on_specific_network(new_hotkey, netuid),
             Error::<T>::HotKeyAlreadyRegisteredInSubNet
@@ -284,32 +284,32 @@ impl<T: Config> Pallet<T> {
 
         weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 0));
 
-        // 10. Get the cost for swapping the key on the subnet
+        // 3. Get the cost for swapping the key on the subnet
         let swap_cost = T::KeySwapOneSubnetCost::get();
         log::debug!("Swap cost in subnet {:?}: {:?}", netuid, swap_cost);
         weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 0));
 
-        // 11. Ensure the coldkey has enough balance to pay for the swap
+        // 4. Ensure the coldkey has enough balance to pay for the swap
         ensure!(
             Self::can_remove_balance_from_coldkey_account(coldkey, swap_cost),
             Error::<T>::NotEnoughBalanceToPaySwapHotKey
         );
 
-        // 12. Remove the swap cost from the coldkey's account
+        // 5. Remove the swap cost from the coldkey's account
         let actual_burn_amount = Self::remove_balance_from_coldkey_account(coldkey, swap_cost)?;
         weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 0));
 
-        // 13. Burn the tokens
+        // 6. Burn the tokens
         Self::burn_tokens(actual_burn_amount);
         weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
 
-        // 1. Swap owner.
+        // 7. Swap owner.
         // Owner( hotkey ) -> coldkey -- the coldkey that owns the hotkey.
         // Owner::<T>::remove(old_hotkey);
         Owner::<T>::insert(new_hotkey, coldkey.clone());
         weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
 
-        // 2. Swap OwnedHotkeys.
+        // 8. Swap OwnedHotkeys.
         // OwnedHotkeys( coldkey ) -> Vec<hotkey> -- the hotkeys that the coldkey owns.
         let mut hotkeys = OwnedHotkeys::<T>::get(coldkey);
         // Add the new key if needed.
@@ -319,15 +319,15 @@ impl<T: Config> Pallet<T> {
             weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
         }
 
-        // 14. Perform the hotkey swap
+        // 9. Perform the hotkey swap
         Self::perform_hotkey_swap_on_one_subnet(old_hotkey, new_hotkey, &mut weight, netuid);
 
-        // 15. Update the last transaction block for the coldkey
+        // 10. Update the last transaction block for the coldkey
         Self::set_last_tx_block(coldkey, block);
         LastHotkeySwapOnNetuid::<T>::insert(netuid, coldkey, block);
         weight.saturating_accrue(T::DbWeight::get().writes(2));
 
-        // 16. Emit an event for the hotkey swap
+        // 11. Emit an event for the hotkey swap
         Self::deposit_event(Event::HotkeySwappedOnSubnet {
             coldkey: coldkey.clone(),
             old_hotkey: old_hotkey.clone(),
@@ -365,30 +365,30 @@ impl<T: Config> Pallet<T> {
 
         // 3. Swap all subnet specific info.
 
-        // 10.1 Remove the previous hotkey and insert the new hotkey from membership.
+        // 3.1 Remove the previous hotkey and insert the new hotkey from membership.
         // IsNetworkMember( hotkey, netuid ) -> bool -- is the hotkey a subnet member.
         let is_network_member: bool = IsNetworkMember::<T>::get(old_hotkey, netuid);
         IsNetworkMember::<T>::remove(old_hotkey, netuid);
         IsNetworkMember::<T>::insert(new_hotkey, netuid, is_network_member);
         weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
 
-        // 10.2 Swap Uids + Keys.
+        // 3.2 Swap Uids + Keys.
         // Keys( netuid, hotkey ) -> uid -- the uid the hotkey has in the network if it is a member.
         // Uids( netuid, hotkey ) -> uid -- the uids that the hotkey has.
         if is_network_member {
-            // 10.2.1 Swap the UIDS
+            // 3.2.1 Swap the UIDS
             if let Ok(old_uid) = Uids::<T>::try_get(netuid, old_hotkey) {
                 Uids::<T>::remove(netuid, old_hotkey);
                 Uids::<T>::insert(netuid, new_hotkey, old_uid);
                 weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
 
-                // 10.2.2 Swap the keys.
+                // 3.2.2 Swap the keys.
                 Keys::<T>::insert(netuid, old_uid, new_hotkey.clone());
                 weight.saturating_accrue(T::DbWeight::get().reads_writes(0, 1));
             }
         }
 
-        // 10.3 Swap Prometheus.
+        // 3.3 Swap Prometheus.
         // Prometheus( netuid, hotkey ) -> prometheus -- the prometheus data that a hotkey has in the network.
         if is_network_member {
             if let Ok(old_prometheus_info) = Prometheus::<T>::try_get(netuid, old_hotkey) {
@@ -398,7 +398,7 @@ impl<T: Config> Pallet<T> {
             }
         }
 
-        // 10.4. Swap axons.
+        // 3.4. Swap axons.
         // Axons( netuid, hotkey ) -> axon -- the axon that the hotkey has.
         if is_network_member {
             if let Ok(old_axon_info) = Axons::<T>::try_get(netuid, old_hotkey) {
@@ -408,7 +408,7 @@ impl<T: Config> Pallet<T> {
             }
         }
 
-        // 10.5 Swap WeightCommits
+        // 3.5 Swap WeightCommits
         // WeightCommits( hotkey ) --> Vec<u64> -- the weight commits for the hotkey.
         if is_network_member {
             if let Ok(old_weight_commits) = WeightCommits::<T>::try_get(netuid, old_hotkey) {
@@ -418,7 +418,7 @@ impl<T: Config> Pallet<T> {
             }
         }
 
-        // 10.6. Swap the subnet loaded emission.
+        // 3.6. Swap the subnet loaded emission.
         // LoadedEmission( netuid ) --> Vec<(hotkey, u64)> -- the loaded emission for the subnet.
         if is_network_member {
             if let Some(mut old_loaded_emission) = LoadedEmission::<T>::get(netuid) {
@@ -433,7 +433,7 @@ impl<T: Config> Pallet<T> {
             }
         }
 
-        // 10.7. Swap neuron TLS certificates.
+        // 3.7. Swap neuron TLS certificates.
         // NeuronCertificates( netuid, hotkey ) -> Vec<u8> -- the neuron certificate for the hotkey.
         if is_network_member {
             if let Ok(old_neuron_certificates) =
@@ -444,7 +444,7 @@ impl<T: Config> Pallet<T> {
                 weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
             }
         }
-        // 12. Swap ChildKeys.
+        // 4. Swap ChildKeys.
         // ChildKeys( parent, netuid ) --> Vec<(proportion,child)> -- the child keys of the parent.
         let my_children: Vec<(u64, T::AccountId)> = ChildKeys::<T>::get(old_hotkey, netuid);
         // Remove the old hotkey's child entries
@@ -469,7 +469,7 @@ impl<T: Config> Pallet<T> {
         }
         // }
 
-        // 13. Swap ParentKeys.
+        // 5. Swap ParentKeys.
         // ParentKeys( child, netuid ) --> Vec<(proportion,parent)> -- the parent keys of the child.
         let parents: Vec<(u64, T::AccountId)> = ParentKeys::<T>::get(old_hotkey, netuid);
         // Remove the old hotkey's parent entries
@@ -493,7 +493,7 @@ impl<T: Config> Pallet<T> {
             weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
         }
 
-        // 14. Swap PendingChildKeys.
+        // 6. Swap PendingChildKeys.
         // PendingChildKeys( netuid, parent ) --> Vec<(proportion,child), cool_down_block>
         if PendingChildKeys::<T>::contains_key(netuid, old_hotkey) {
             let (children, cool_down_block) = PendingChildKeys::<T>::get(netuid, old_hotkey);
@@ -519,7 +519,7 @@ impl<T: Config> Pallet<T> {
             }
         }
 
-        // 15. Swap SubnetOwnerHotkey
+        // 7. Swap SubnetOwnerHotkey
         // SubnetOwnerHotkey( netuid ) --> hotkey -- the hotkey that is the owner of the subnet.
         if let Ok(old_subnet_owner_hotkey) = SubnetOwnerHotkey::<T>::try_get(netuid) {
             weight.saturating_accrue(T::DbWeight::get().reads(1));
@@ -529,8 +529,8 @@ impl<T: Config> Pallet<T> {
             }
         }
 
-        // 16. Swap dividend records
-        // 16.1 Swap TotalHotkeyAlphaLastEpoch
+        // 8. Swap dividend records
+        // 8.1 Swap TotalHotkeyAlphaLastEpoch
         let old_alpha = TotalHotkeyAlphaLastEpoch::<T>::take(old_hotkey, netuid);
         let new_total_hotkey_alpha = TotalHotkeyAlphaLastEpoch::<T>::get(new_hotkey, netuid);
         TotalHotkeyAlphaLastEpoch::<T>::insert(
@@ -540,7 +540,7 @@ impl<T: Config> Pallet<T> {
         );
         weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 2));
 
-        // 16.2 Swap AlphaDividendsPerSubnet
+        // 8.2 Swap AlphaDividendsPerSubnet
         let old_hotkey_alpha_dividends = AlphaDividendsPerSubnet::<T>::get(netuid, old_hotkey);
         let new_hotkey_alpha_dividends = AlphaDividendsPerSubnet::<T>::get(netuid, new_hotkey);
         AlphaDividendsPerSubnet::<T>::remove(netuid, old_hotkey);
@@ -551,7 +551,7 @@ impl<T: Config> Pallet<T> {
         );
         weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 2));
 
-        // 16.3 Swap TaoDividendsPerSubnet
+        // 8.3 Swap TaoDividendsPerSubnet
         let old_hotkey_tao_dividends = TaoDividendsPerSubnet::<T>::get(netuid, old_hotkey);
         let new_hotkey_tao_dividends = TaoDividendsPerSubnet::<T>::get(netuid, new_hotkey);
         TaoDividendsPerSubnet::<T>::remove(netuid, old_hotkey);
@@ -562,7 +562,7 @@ impl<T: Config> Pallet<T> {
         );
         weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 2));
 
-        // 11. Swap Alpha
+        // 9. Swap Alpha
         // Alpha( hotkey, coldkey, netuid ) -> alpha
         let old_alpha_values: Vec<((T::AccountId, u16), U64F64)> =
             Alpha::<T>::iter_prefix((old_hotkey,)).collect();

From 0185213a004fb795ac9a09c5c0c082faf57e656c Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Tue, 6 May 2025 15:13:33 +0200
Subject: [PATCH 121/418] Fix paid fee calculation

---
 pallets/swap/src/pallet/impls.rs | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 2e0fdf60d0..b4b847361f 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -448,14 +448,7 @@ impl<T: Config> Pallet<T> {
             ),
         };
 
-        let global_fee = match order_type {
-            OrderType::Sell => FeeGlobalTao::<T>::get(netuid),
-            OrderType::Buy => FeeGlobalAlpha::<T>::get(netuid),
-        };
-        let fee_paid = global_fee
-            .saturating_mul(SqrtPrice::saturating_from_num(liquidity_before))
-            .saturating_round()
-            .saturating_to_num::<u64>();
+        let fee_paid = amount.saturating_sub(in_acc);
 
         Ok(SwapResult {
             amount_paid_out,

From f5012329ef391ea0859af04b5cd7fbe438bc479f Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Tue, 6 May 2025 17:13:17 +0200
Subject: [PATCH 122/418] Fix alpha price before first swap and children tests

---
 pallets/subtensor/src/tests/children.rs | 21 ++++++++++++++++-----
 pallets/swap/src/pallet/impls.rs        | 10 +++++++++-
 2 files changed, 25 insertions(+), 6 deletions(-)

diff --git a/pallets/subtensor/src/tests/children.rs b/pallets/subtensor/src/tests/children.rs
index 44eceb474d..813a0c2064 100644
--- a/pallets/subtensor/src/tests/children.rs
+++ b/pallets/subtensor/src/tests/children.rs
@@ -2218,11 +2218,12 @@ fn test_do_remove_stake_clears_pending_childkeys() {
         // Set non-default value for childkey stake threshold
         StakeThreshold::<Test>::set(1_000_000_000_000);
 
+        let (_, fee) = mock::swap_tao_to_alpha(netuid, StakeThreshold::<Test>::get());
         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
             &hotkey,
             &coldkey,
             netuid,
-            StakeThreshold::<Test>::get(),
+            StakeThreshold::<Test>::get() + fee,
         );
 
         // Attempt to set child
@@ -2415,13 +2416,19 @@ fn test_revoke_child_no_min_stake_check() {
         add_network(netuid, 13, 0);
         register_ok_neuron(netuid, parent, coldkey, 0);
 
+		let reserve = 1_000_000_000_000_000;
+		mock::setup_reserves(netuid, reserve, reserve);
+		mock::setup_reserves(root, reserve, reserve);
+
         // Set minimum stake for setting children
         StakeThreshold::<Test>::put(1_000_000_000_000);
+
+		let (_, fee) = mock::swap_tao_to_alpha(root, StakeThreshold::<Test>::get());
         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
             &parent,
             &coldkey,
             root,
-            StakeThreshold::<Test>::get(),
+            StakeThreshold::<Test>::get() + fee,
         );
 
         // Schedule parent-child relationship
@@ -2441,7 +2448,7 @@ fn test_revoke_child_no_min_stake_check() {
             &parent,
             &coldkey,
             root,
-            StakeThreshold::<Test>::get(),
+            StakeThreshold::<Test>::get() + fee,
         );
 
         // Ensure the childkeys are applied
@@ -2487,13 +2494,17 @@ fn test_do_set_child_registration_disabled() {
         add_network(netuid, 13, 0);
         register_ok_neuron(netuid, parent, coldkey, 0);
 
+		let reserve = 1_000_000_000_000_000;
+		mock::setup_reserves(netuid, reserve, reserve);
+
         // Set minimum stake for setting children
         StakeThreshold::<Test>::put(1_000_000_000_000);
+		let (_, fee) = mock::swap_tao_to_alpha(netuid, StakeThreshold::<Test>::get());
         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
             &parent,
             &coldkey,
             netuid,
-            StakeThreshold::<Test>::get(),
+            StakeThreshold::<Test>::get() + fee,
         );
 
         // Disable subnet registrations
@@ -2512,7 +2523,7 @@ fn test_do_set_child_registration_disabled() {
             &parent,
             &coldkey,
             netuid,
-            StakeThreshold::<Test>::get(),
+            StakeThreshold::<Test>::get() + fee,
         );
 
         // Ensure the childkeys are applied
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index b4b847361f..1253aea326 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -1152,7 +1152,15 @@ impl<T: Config> SwapHandler<T::AccountId> for Pallet<T> {
 
     fn current_alpha_price(netuid: u16) -> U96F32 {
         let sqrt_price = AlphaSqrtPrice::<T>::get(NetUid::from(netuid));
-        U96F32::saturating_from_num(sqrt_price.saturating_mul(sqrt_price))
+        let tao_reserve = T::LiquidityDataProvider::tao_reserve(netuid);
+        let alpha_reserve = T::LiquidityDataProvider::alpha_reserve(netuid);
+
+        if sqrt_price == 0 && tao_reserve > 0 && alpha_reserve > 0 {
+            U96F32::saturating_from_num(tao_reserve)
+                .saturating_div(U96F32::saturating_from_num(alpha_reserve))
+        } else {
+            U96F32::saturating_from_num(sqrt_price.saturating_mul(sqrt_price))
+        }
     }
 
     fn min_price() -> u64 {

From 3d50f9b87a6f7349a05205b679e1e96a06b2cd4b Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Tue, 6 May 2025 11:45:21 -0400
Subject: [PATCH 123/418] Fix egde-target-limit logic

---
 pallets/swap/src/pallet/impls.rs | 138 +++++++++++++++++++++++++------
 1 file changed, 111 insertions(+), 27 deletions(-)

diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 858ab7b3bd..827a1807d7 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -81,18 +81,24 @@ impl<T: Config> SwapStep<T> {
             OrderType::Buy => sqrt_price_edge.into(),
             OrderType::Sell => one.safe_div(sqrt_price_edge.into()),
         };
-        let mut lim_quantity = match order_type {
-            OrderType::Buy => one
-                .safe_div(TickIndex::min_sqrt_price())
-                .min(one.safe_div(sqrt_price_limit.into())),
-            OrderType::Sell => TickIndex::max_sqrt_price().min(sqrt_price_limit.into()),
+        let lim_quantity = match order_type {
+            OrderType::Sell => {
+                let mut lq = one
+                    .safe_div(TickIndex::min_sqrt_price())
+                    .min(one.safe_div(sqrt_price_limit.into()));
+                if lq < one.safe_div(current_price) {
+                    lq = one.safe_div(TickIndex::min_sqrt_price());
+                }
+                lq
+            },
+            OrderType::Buy => {
+                let mut lq = TickIndex::max_sqrt_price().min(sqrt_price_limit.into());
+                if lq < current_price {
+                    lq = TickIndex::max_sqrt_price();
+                }
+                lq
+            },
         };
-        if lim_quantity < one.safe_div(current_price) {
-            lim_quantity = match order_type {
-                OrderType::Buy => one.safe_div(TickIndex::min_sqrt_price()),
-                OrderType::Sell => TickIndex::max_sqrt_price(),
-            };
-        }
 
         Self {
             netuid,
@@ -1530,24 +1536,24 @@ mod tests {
             //   - liquidity is expressed in RAO units
             // Test case is (price_low, price_high, liquidity, tao, alpha)
             [
-                // // Repeat the protocol liquidity at maximum range: Expect all the same values
-                // (
-                //     min_price,
-                //     max_price,
-                //     2_000_000_000_u64,
-                //     1_000_000_000_u64,
-                //     4_000_000_000_u64,
-                // ),
-                // // Repeat the protocol liquidity at current to max range: Expect the same alpha
-                // (0.25, max_price, 2_000_000_000_u64, 0, 4_000_000_000),
+                // Repeat the protocol liquidity at maximum range: Expect all the same values
+                (
+                    min_price,
+                    max_price,
+                    2_000_000_000_u64,
+                    1_000_000_000_u64,
+                    4_000_000_000_u64,
+                ),
+                // Repeat the protocol liquidity at current to max range: Expect the same alpha
+                (0.25, max_price, 2_000_000_000_u64, 0, 4_000_000_000),
                 // Repeat the protocol liquidity at min to current range: Expect all the same tao
                 (min_price, 0.24999, 2_000_000_000_u64, 1_000_000_000, 0),
-                // // Half to double price - just some sane wothdraw amounts
-                // (0.125, 0.5, 2_000_000_000_u64, 293_000_000, 1_171_000_000),
-                // // Both below price - tao is non-zero, alpha is zero
-                // (0.12, 0.13, 2_000_000_000_u64, 28_270_000, 0),
-                // // Both above price - tao is zero, alpha is non-zero
-                // (0.3, 0.4, 2_000_000_000_u64, 0, 489_200_000),
+                // Half to double price - just some sane wothdraw amounts
+                (0.125, 0.5, 2_000_000_000_u64, 293_000_000, 1_171_000_000),
+                // Both below price - tao is non-zero, alpha is zero
+                (0.12, 0.13, 2_000_000_000_u64, 28_270_000, 0),
+                // Both above price - tao is zero, alpha is non-zero
+                (0.3, 0.4, 2_000_000_000_u64, 0, 489_200_000),
             ]
             .into_iter()
             .enumerate()
@@ -1637,6 +1643,84 @@ mod tests {
         });
     }
 
+    // #[test]
+    // fn test_modify_position_basic() {
+    //     new_test_ext().execute_with(|| {
+    //         let min_price = tick_to_price(TickIndex::MIN);
+    //         let max_price = tick_to_price(TickIndex::MAX);
+    //         let max_tick = price_to_tick(max_price);
+    //         assert_eq!(max_tick, TickIndex::MAX);
+
+    //         // As a user add liquidity with all possible corner cases
+    //         //   - Initial price is 0.25
+    //         //   - liquidity is expressed in RAO units
+    //         // Test case is (price_low, price_high, liquidity, tao, alpha)
+    //         [
+    //             // // Repeat the protocol liquidity at maximum range: Expect all the same values
+    //             // (
+    //             //     min_price,
+    //             //     max_price,
+    //             //     2_000_000_000_u64,
+    //             //     1_000_000_000_u64,
+    //             //     4_000_000_000_u64,
+    //             // ),
+    //             // // Repeat the protocol liquidity at current to max range: Expect the same alpha
+    //             // (0.25, max_price, 2_000_000_000_u64, 0, 4_000_000_000),
+    //             // Repeat the protocol liquidity at min to current range: Expect all the same tao
+    //             (min_price, 0.24999, 2_000_000_000_u64, 1_000_000_000, 0),
+    //             // // Half to double price - just some sane wothdraw amounts
+    //             // (0.125, 0.5, 2_000_000_000_u64, 293_000_000, 1_171_000_000),
+    //             // // Both below price - tao is non-zero, alpha is zero
+    //             // (0.12, 0.13, 2_000_000_000_u64, 28_270_000, 0),
+    //             // // Both above price - tao is zero, alpha is non-zero
+    //             // (0.3, 0.4, 2_000_000_000_u64, 0, 489_200_000),
+    //         ]
+    //         .into_iter()
+    //         .enumerate()
+    //         .map(|(n, v)| (NetUid::from(n as u16), v.0, v.1, v.2, v.3, v.4))
+    //         .for_each(|(netuid, price_low, price_high, liquidity, tao, alpha)| {
+    //             // Calculate ticks (assuming tick math is tested separately)
+    //             let tick_low = price_to_tick(price_low);
+    //             let tick_high = price_to_tick(price_high);
+
+    //             assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
+    //             let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
+
+    //             // Add liquidity
+    //             let (position_id, _, _) = Pallet::<Test>::add_liquidity(
+    //                 netuid,
+    //                 &OK_COLDKEY_ACCOUNT_ID,
+    //                 &OK_HOTKEY_ACCOUNT_ID,
+    //                 tick_low,
+    //                 tick_high,
+    //                 liquidity,
+    //             )
+    //             .unwrap();
+
+    //             // Remove liquidity
+    //             let remove_result =
+    //                 Pallet::<Test>::remove_liquidity(netuid, &OK_COLDKEY_ACCOUNT_ID, position_id)
+    //                     .unwrap();
+    //             assert_abs_diff_eq!(remove_result.tao, tao, epsilon = tao / 1000);
+    //             assert_abs_diff_eq!(remove_result.alpha, alpha, epsilon = alpha / 1000);
+    //             assert_eq!(remove_result.fee_tao, 0);
+    //             assert_eq!(remove_result.fee_alpha, 0);
+
+    //             // Liquidity position is removed
+    //             assert_eq!(
+    //                 Pallet::<Test>::count_positions(netuid, &OK_COLDKEY_ACCOUNT_ID),
+    //                 0
+    //             );
+    //             assert!(
+    //                 Positions::<Test>::get((netuid, OK_COLDKEY_ACCOUNT_ID, position_id)).is_none()
+    //             );
+
+    //             // Current liquidity is updated (back where it was)
+    //             assert_eq!(CurrentLiquidity::<Test>::get(netuid), liquidity_before);
+    //         });
+    //     });
+    // }
+
     // cargo test --package pallet-subtensor-swap --lib -- pallet::impls::tests::test_swap_basic --exact --show-output
     #[test]
     fn test_swap_basic() {

From 11a0455599bc099b65718501ae60afdbdb8e7611 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Tue, 6 May 2025 16:37:15 -0400
Subject: [PATCH 124/418] Add test for modify position, fix fees

---
 pallets/swap/src/pallet/impls.rs | 194 ++++++++++++++++++-------------
 pallets/swap/src/position.rs     |  20 ++--
 2 files changed, 125 insertions(+), 89 deletions(-)

diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index ccc8a68114..c68f5ecb58 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -801,8 +801,8 @@ impl<T: Config> Pallet<T> {
             tick_low,
             tick_high,
             liquidity,
-            fees_tao: 0,
-            fees_alpha: 0,
+            fees_tao: U64F64::saturating_from_num(0),
+            fees_alpha: U64F64::saturating_from_num(0),
         };
 
         let current_price = AlphaSqrtPrice::<T>::get(netuid);
@@ -1636,83 +1636,119 @@ mod tests {
         });
     }
 
-    // #[test]
-    // fn test_modify_position_basic() {
-    //     new_test_ext().execute_with(|| {
-    //         let min_price = tick_to_price(TickIndex::MIN);
-    //         let max_price = tick_to_price(TickIndex::MAX);
-    //         let max_tick = price_to_tick(max_price);
-    //         assert_eq!(max_tick, TickIndex::MAX);
-
-    //         // As a user add liquidity with all possible corner cases
-    //         //   - Initial price is 0.25
-    //         //   - liquidity is expressed in RAO units
-    //         // Test case is (price_low, price_high, liquidity, tao, alpha)
-    //         [
-    //             // // Repeat the protocol liquidity at maximum range: Expect all the same values
-    //             // (
-    //             //     min_price,
-    //             //     max_price,
-    //             //     2_000_000_000_u64,
-    //             //     1_000_000_000_u64,
-    //             //     4_000_000_000_u64,
-    //             // ),
-    //             // // Repeat the protocol liquidity at current to max range: Expect the same alpha
-    //             // (0.25, max_price, 2_000_000_000_u64, 0, 4_000_000_000),
-    //             // Repeat the protocol liquidity at min to current range: Expect all the same tao
-    //             (min_price, 0.24999, 2_000_000_000_u64, 1_000_000_000, 0),
-    //             // // Half to double price - just some sane wothdraw amounts
-    //             // (0.125, 0.5, 2_000_000_000_u64, 293_000_000, 1_171_000_000),
-    //             // // Both below price - tao is non-zero, alpha is zero
-    //             // (0.12, 0.13, 2_000_000_000_u64, 28_270_000, 0),
-    //             // // Both above price - tao is zero, alpha is non-zero
-    //             // (0.3, 0.4, 2_000_000_000_u64, 0, 489_200_000),
-    //         ]
-    //         .into_iter()
-    //         .enumerate()
-    //         .map(|(n, v)| (NetUid::from(n as u16), v.0, v.1, v.2, v.3, v.4))
-    //         .for_each(|(netuid, price_low, price_high, liquidity, tao, alpha)| {
-    //             // Calculate ticks (assuming tick math is tested separately)
-    //             let tick_low = price_to_tick(price_low);
-    //             let tick_high = price_to_tick(price_high);
-
-    //             assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
-    //             let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
-
-    //             // Add liquidity
-    //             let (position_id, _, _) = Pallet::<Test>::add_liquidity(
-    //                 netuid,
-    //                 &OK_COLDKEY_ACCOUNT_ID,
-    //                 &OK_HOTKEY_ACCOUNT_ID,
-    //                 tick_low,
-    //                 tick_high,
-    //                 liquidity,
-    //             )
-    //             .unwrap();
-
-    //             // Remove liquidity
-    //             let remove_result =
-    //                 Pallet::<Test>::remove_liquidity(netuid, &OK_COLDKEY_ACCOUNT_ID, position_id)
-    //                     .unwrap();
-    //             assert_abs_diff_eq!(remove_result.tao, tao, epsilon = tao / 1000);
-    //             assert_abs_diff_eq!(remove_result.alpha, alpha, epsilon = alpha / 1000);
-    //             assert_eq!(remove_result.fee_tao, 0);
-    //             assert_eq!(remove_result.fee_alpha, 0);
-
-    //             // Liquidity position is removed
-    //             assert_eq!(
-    //                 Pallet::<Test>::count_positions(netuid, &OK_COLDKEY_ACCOUNT_ID),
-    //                 0
-    //             );
-    //             assert!(
-    //                 Positions::<Test>::get((netuid, OK_COLDKEY_ACCOUNT_ID, position_id)).is_none()
-    //             );
-
-    //             // Current liquidity is updated (back where it was)
-    //             assert_eq!(CurrentLiquidity::<Test>::get(netuid), liquidity_before);
-    //         });
-    //     });
-    // }
+    #[test]
+    fn test_modify_position_basic() {
+        new_test_ext().execute_with(|| {
+            let min_price = tick_to_price(TickIndex::MIN);
+            let max_price = tick_to_price(TickIndex::MAX);
+            let max_tick = price_to_tick(max_price);
+            let limit_price = 1000.0_f64;
+            assert_eq!(max_tick, TickIndex::MAX);
+
+            // As a user add liquidity with all possible corner cases
+            //   - Initial price is 0.25
+            //   - liquidity is expressed in RAO units
+            // Test case is (price_low, price_high, liquidity, tao, alpha)
+            [
+                // // Repeat the protocol liquidity at maximum range: Expect all the same values
+                // (
+                //     min_price,
+                //     max_price,
+                //     2_000_000_000_u64,
+                //     1_000_000_000_u64,
+                //     4_000_000_000_u64,
+                // ),
+                // // Repeat the protocol liquidity at current to max range: Expect the same alpha
+                (0.25, max_price, 2_000_000_000_u64, 1_000_000_000, 4_000_000_000),
+                // Repeat the protocol liquidity at min to current range: Expect all the same tao
+                // (min_price, 0.24999, 2_000_000_000_u64, 1_000_000_000, 0),
+                // // Half to double price - just some sane wothdraw amounts
+                // (0.125, 0.5, 2_000_000_000_u64, 293_000_000, 1_171_000_000),
+                // // Both below price - tao is non-zero, alpha is zero
+                // (0.12, 0.13, 2_000_000_000_u64, 28_270_000, 0),
+                // // Both above price - tao is zero, alpha is non-zero
+                // (0.3, 0.4, 2_000_000_000_u64, 0, 489_200_000),
+            ]
+            .into_iter()
+            .enumerate()
+            .map(|(n, v)| (NetUid::from(n as u16), v.0, v.1, v.2, v.3, v.4))
+            .for_each(|(netuid, price_low, price_high, liquidity, tao, alpha)| {
+                // Calculate ticks (assuming tick math is tested separately)
+                let tick_low = price_to_tick(price_low);
+                let tick_high = price_to_tick(price_high);
+
+                assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
+
+                // Add liquidity
+                let (position_id, _, _) = Pallet::<Test>::add_liquidity(
+                    netuid,
+                    &OK_COLDKEY_ACCOUNT_ID,
+                    &OK_HOTKEY_ACCOUNT_ID,
+                    tick_low,
+                    tick_high,
+                    liquidity,
+                )
+                .unwrap();
+
+                // Swap to create fees on the position
+                let sqrt_limit_price = SqrtPrice::from_num((limit_price).sqrt());
+                Pallet::<Test>::do_swap(
+                    netuid,
+                    OrderType::Buy,
+                    liquidity / 10,
+                    sqrt_limit_price,
+                    false,
+                )
+                .unwrap();
+
+                // Modify liquidity (also causes claiming of fees)
+                let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
+                let modify_result =
+                    Pallet::<Test>::modify_position(
+                        netuid,
+                        &OK_COLDKEY_ACCOUNT_ID,
+                        &OK_HOTKEY_ACCOUNT_ID,
+                        position_id,
+                        -1_i64 * ((liquidity / 10) as i64),
+                    )
+                    .unwrap();
+                assert_abs_diff_eq!(modify_result.alpha, alpha / 10, epsilon = alpha / 1000);
+                assert!(modify_result.fee_tao > 0);
+                assert_eq!(modify_result.fee_alpha, 0);
+
+                // Liquidity position is reduced
+                assert_eq!(
+                    Pallet::<Test>::count_positions(netuid, &OK_COLDKEY_ACCOUNT_ID),
+                    1
+                );
+
+                // Current liquidity is reduced with modify_position
+                assert!(CurrentLiquidity::<Test>::get(netuid) < liquidity_before);
+
+                // Position liquidity is reduced
+                let position =
+                    Positions::<Test>::get(&(netuid, OK_COLDKEY_ACCOUNT_ID, position_id))
+                        .unwrap();
+                assert_eq!(position.liquidity, liquidity * 9 / 10);
+                assert_eq!(position.tick_low, tick_low);
+                assert_eq!(position.tick_high, tick_high);
+
+                // Modify liquidity again (ensure fees aren't double-collected)
+                let modify_result =
+                    Pallet::<Test>::modify_position(
+                        netuid,
+                        &OK_COLDKEY_ACCOUNT_ID,
+                        &OK_HOTKEY_ACCOUNT_ID,
+                        position_id,
+                        -1_i64 * ((liquidity / 10) as i64),
+                    )
+                    .unwrap();
+                assert_abs_diff_eq!(modify_result.alpha, alpha / 10, epsilon = alpha / 1000);
+                assert_eq!(modify_result.fee_tao, 0);
+                assert_eq!(modify_result.fee_alpha, 0);
+            });
+        });
+    }
 
     // cargo test --package pallet-subtensor-swap --lib -- pallet::impls::tests::test_swap_basic --exact --show-output
     #[test]
diff --git a/pallets/swap/src/position.rs b/pallets/swap/src/position.rs
index 5ef685c26b..37b4cd2853 100644
--- a/pallets/swap/src/position.rs
+++ b/pallets/swap/src/position.rs
@@ -18,7 +18,7 @@ use crate::{NetUid, SqrtPrice};
 /// liquidity - position liquidity
 /// fees_tao - fees accrued by the position in quote currency (TAO)
 /// fees_alpha - fees accrued by the position in base currency (Alpha)
-#[freeze_struct("fef7b4de3c0df37d")]
+#[freeze_struct("1a4924d76eb084f1")]
 #[derive(Clone, Encode, Decode, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen, Default)]
 pub struct Position {
     pub id: PositionId,
@@ -26,8 +26,8 @@ pub struct Position {
     pub tick_low: TickIndex,
     pub tick_high: TickIndex,
     pub liquidity: u64,
-    pub fees_tao: u64,
-    pub fees_alpha: u64,
+    pub fees_tao: U64F64,
+    pub fees_alpha: U64F64,
 }
 
 impl Position {
@@ -97,22 +97,23 @@ impl Position {
         let fee_tao_agg = self.fees_in_range::<T>(true);
         let fee_alpha_agg = self.fees_in_range::<T>(false);
 
-        let mut fee_tao = fee_tao_agg.saturating_sub(self.fees_tao);
-        let mut fee_alpha = fee_alpha_agg.saturating_sub(self.fees_alpha);
+        let mut fee_tao = fee_tao_agg.saturating_sub(U64F64::saturating_from_num(self.fees_tao));
+        let mut fee_alpha = fee_alpha_agg.saturating_sub(U64F64::saturating_from_num(self.fees_alpha));
 
         self.fees_tao = fee_tao_agg;
         self.fees_alpha = fee_alpha_agg;
 
-        fee_tao = self.liquidity.saturating_mul(fee_tao);
-        fee_alpha = self.liquidity.saturating_mul(fee_alpha);
+        let liquidity_frac = U64F64::saturating_from_num(self.liquidity);
+        fee_tao = liquidity_frac.saturating_mul(fee_tao);
+        fee_alpha = liquidity_frac.saturating_mul(fee_alpha);
 
-        (fee_tao, fee_alpha)
+        (fee_tao.saturating_to_num::<u64>(), fee_alpha.saturating_to_num::<u64>())
     }
 
     /// Get fees in a position's range
     ///
     /// If quote flag is true, Tao is returned, otherwise alpha.
-    fn fees_in_range<T: Config>(&self, quote: bool) -> u64 {
+    fn fees_in_range<T: Config>(&self, quote: bool) -> U64F64 {
         if quote {
             FeeGlobalTao::<T>::get(self.netuid)
         } else {
@@ -120,7 +121,6 @@ impl Position {
         }
         .saturating_sub(self.tick_low.fees_below::<T>(self.netuid, quote))
         .saturating_sub(self.tick_high.fees_above::<T>(self.netuid, quote))
-        .saturating_to_num::<u64>()
     }
 }
 

From 95c7b4b1da61f8aa5956a9764183f65196a30c79 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Wed, 7 May 2025 17:25:28 +0200
Subject: [PATCH 125/418] Fix most of move stake tests

---
 pallets/subtensor/src/staking/stake_utils.rs |  25 +-
 pallets/subtensor/src/tests/move_stake.rs    | 245 ++++++++-----------
 pallets/subtensor/src/tests/staking.rs       |  11 +-
 3 files changed, 133 insertions(+), 148 deletions(-)

diff --git a/pallets/subtensor/src/staking/stake_utils.rs b/pallets/subtensor/src/staking/stake_utils.rs
index 35c8fb1bad..2599cbb74c 100644
--- a/pallets/subtensor/src/staking/stake_utils.rs
+++ b/pallets/subtensor/src/staking/stake_utils.rs
@@ -802,7 +802,15 @@ impl<T: Config> Pallet<T> {
         // Get the minimum balance (and amount) that satisfies the transaction
         let min_amount = {
             let default_stake = DefaultMinStake::<T>::get();
-            let fee = T::SwapInterface::approx_fee_amount(netuid, default_stake);
+            let fee = T::SwapInterface::swap(
+                netuid,
+                OrderType::Buy,
+                default_stake,
+                T::SwapInterface::max_price(),
+                true,
+            )
+            .map(|res| res.fee_paid)
+            .unwrap_or(T::SwapInterface::approx_fee_amount(netuid, default_stake));
             default_stake.saturating_add(fee)
         };
 
@@ -951,6 +959,21 @@ impl<T: Config> Pallet<T> {
             Error::<T>::NotEnoughStakeToWithdraw
         );
 
+        // Ensure that the stake amount to be removed is above the minimum in tao equivalent.
+        let tao_equivalent = T::SwapInterface::swap(
+            origin_netuid,
+            OrderType::Sell,
+            alpha_amount,
+            T::SwapInterface::max_price(),
+            true,
+        )
+        .map(|res| res.amount_paid_out)
+        .map_err(|_| Error::<T>::InsufficientLiquidity)?;
+        ensure!(
+            tao_equivalent > DefaultMinStake::<T>::get(),
+            Error::<T>::AmountTooLow
+        );
+
         // Ensure that if partial execution is not allowed, the amount will not cause
         // slippage over desired
         if let Some(allow_partial) = maybe_allow_partial {
diff --git a/pallets/subtensor/src/tests/move_stake.rs b/pallets/subtensor/src/tests/move_stake.rs
index 646c965bc1..0b3bf447b2 100644
--- a/pallets/subtensor/src/tests/move_stake.rs
+++ b/pallets/subtensor/src/tests/move_stake.rs
@@ -21,7 +21,6 @@ fn test_do_move_success() {
         let origin_hotkey = U256::from(2);
         let destination_hotkey = U256::from(3);
         let stake_amount = DefaultMinStake::<Test>::get() * 10;
-        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         // Set up initial stake
         SubtensorModule::create_account_if_non_existent(&coldkey, &origin_hotkey);
@@ -41,6 +40,8 @@ fn test_do_move_success() {
         );
 
         // Perform the move
+        let (tao_equivalent, _) = mock::swap_alpha_to_tao(netuid, alpha);
+        let (expected_alpha, _) = mock::swap_tao_to_alpha(netuid, tao_equivalent);
         assert_ok!(SubtensorModule::do_move_stake(
             RuntimeOrigin::signed(coldkey),
             origin_hotkey,
@@ -65,8 +66,8 @@ fn test_do_move_success() {
                 &coldkey,
                 netuid
             ),
-            stake_amount - 2 * fee,
-            epsilon = stake_amount / 1000
+            expected_alpha,
+            epsilon = 1000
         );
     });
 }
@@ -153,7 +154,9 @@ fn test_do_move_nonexistent_subnet() {
         let destination_hotkey = U256::from(3);
         let nonexistent_netuid = 99; // Assuming this subnet doesn't exist
         let stake_amount = 1_000_000;
-        let fee = 0;
+
+        let reserve = stake_amount * 1000;
+        mock::setup_reserves(origin_netuid, reserve, reserve);
 
         // Set up initial stake
         SubtensorModule::stake_into_subnet(
@@ -184,14 +187,13 @@ fn test_do_move_nonexistent_subnet() {
         );
 
         // Check that the stake remains unchanged
-        assert_abs_diff_eq!(
+        assert_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
                 &origin_hotkey,
                 &coldkey,
                 origin_netuid
             ),
-            stake_amount,
-            epsilon = 100
+            alpha,
         );
     });
 }
@@ -254,6 +256,9 @@ fn test_do_move_nonexistent_destination_hotkey() {
         let netuid = 1;
         let stake_amount = 1_000_000;
 
+        let reserve = stake_amount * 1000;
+        mock::setup_reserves(netuid, reserve, reserve);
+
         // Set up initial stake
         SubtensorModule::create_account_if_non_existent(&coldkey, &origin_hotkey);
         let alpha = SubtensorModule::stake_into_subnet(
@@ -286,8 +291,9 @@ fn test_do_move_nonexistent_destination_hotkey() {
                 &coldkey,
                 netuid
             ),
-            stake_amount
+            alpha
         );
+
         assert_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
                 &nonexistent_destination_hotkey,
@@ -439,7 +445,6 @@ fn test_do_move_partial_stake() {
         let origin_hotkey = U256::from(2);
         let destination_hotkey = U256::from(3);
         let total_stake = DefaultMinStake::<Test>::get() * 10;
-        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         // Set up initial stake
         SubtensorModule::stake_into_subnet(
@@ -457,6 +462,8 @@ fn test_do_move_partial_stake() {
         );
 
         // Move partial stake
+        let (tao_equivalent, _) = mock::swap_alpha_to_tao(netuid, alpha);
+        let (expected_alpha, _) = mock::swap_tao_to_alpha(netuid, tao_equivalent);
         SubtensorModule::create_account_if_non_existent(&coldkey, &origin_hotkey);
         SubtensorModule::create_account_if_non_existent(&coldkey, &destination_hotkey);
         assert_ok!(SubtensorModule::do_move_stake(
@@ -483,8 +490,8 @@ fn test_do_move_partial_stake() {
                 &coldkey,
                 netuid
             ),
-            total_stake - 2 * fee,
-            epsilon = total_stake / 1000
+            expected_alpha,
+            epsilon = 1000
         );
     });
 }
@@ -502,7 +509,6 @@ fn test_do_move_multiple_times() {
         let hotkey1 = U256::from(2);
         let hotkey2 = U256::from(3);
         let initial_stake = DefaultMinStake::<Test>::get() * 10;
-        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         // Set up initial stake
         SubtensorModule::create_account_if_non_existent(&coldkey, &hotkey1);
@@ -517,6 +523,7 @@ fn test_do_move_multiple_times() {
         .unwrap();
 
         // Move stake multiple times
+        let mut expected_alpha: u64 = 0;
         for _ in 0..3 {
             let alpha1 = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
                 &hotkey1, &coldkey, netuid,
@@ -532,6 +539,9 @@ fn test_do_move_multiple_times() {
             let alpha2 = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
                 &hotkey2, &coldkey, netuid,
             );
+            let (tao_equivalent, _) = mock::swap_alpha_to_tao(netuid, alpha2);
+            // we need expected_alpha before the last move, so we call it within the loop
+            expected_alpha = mock::swap_tao_to_alpha(netuid, tao_equivalent).0;
             assert_ok!(SubtensorModule::do_move_stake(
                 RuntimeOrigin::signed(coldkey),
                 hotkey2,
@@ -545,8 +555,8 @@ fn test_do_move_multiple_times() {
         // Check final stake distribution
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey1, &coldkey, netuid),
-            initial_stake - 7 * fee,
-            epsilon = initial_stake / 1000
+            expected_alpha,
+            epsilon = 1000,
         );
         assert_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey2, &coldkey, netuid),
@@ -567,7 +577,9 @@ fn test_do_move_wrong_origin() {
         let destination_hotkey = U256::from(3);
         let netuid = 1;
         let stake_amount = DefaultMinStake::<Test>::get() * 10;
-        let fee = 0;
+
+        let reserve = stake_amount * 1000;
+        mock::setup_reserves(netuid, reserve, reserve);
 
         // Set up initial stake
         SubtensorModule::stake_into_subnet(
@@ -607,7 +619,7 @@ fn test_do_move_wrong_origin() {
                 &coldkey,
                 netuid
             ),
-            stake_amount
+            alpha
         );
         assert_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
@@ -632,7 +644,6 @@ fn test_do_move_same_hotkey() {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
         let stake_amount = DefaultMinStake::<Test>::get() * 10;
-        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         // Set up initial stake
         SubtensorModule::create_account_if_non_existent(&coldkey, &hotkey);
@@ -648,6 +659,9 @@ fn test_do_move_same_hotkey() {
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid);
 
         // Attempt to move stake to the same hotkey
+        let (tao_equivalent, _) = mock::swap_alpha_to_tao(netuid, alpha);
+        let (expected_alpha, _) = mock::swap_tao_to_alpha(netuid, tao_equivalent);
+
         assert_ok!(SubtensorModule::do_move_stake(
             RuntimeOrigin::signed(coldkey),
             hotkey,
@@ -660,8 +674,8 @@ fn test_do_move_same_hotkey() {
         // Check that stake remains unchanged
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid),
-            alpha - fee,
-            epsilon = alpha / 1000
+            expected_alpha,
+            epsilon = 1000
         );
     });
 }
@@ -699,6 +713,7 @@ fn test_do_move_event_emission() {
 
         // Move stake and capture events
         System::reset_events();
+        let (tao_equivalent, _) = mock::swap_alpha_to_tao(netuid, alpha);
         assert_ok!(SubtensorModule::do_move_stake(
             RuntimeOrigin::signed(coldkey),
             origin_hotkey,
@@ -708,8 +723,6 @@ fn test_do_move_event_emission() {
             alpha,
         ));
 
-        let fee = <Test as Config>::SwapInterface::approx_fee_amount(netuid, stake_amount);
-
         // Check for the correct event emission
         System::assert_last_event(
             Event::StakeMoved(
@@ -718,7 +731,7 @@ fn test_do_move_event_emission() {
                 netuid,
                 destination_hotkey,
                 netuid,
-                stake_amount - fee * 2, // Should be TAO equivalent
+                tao_equivalent, // Should be TAO equivalent
             )
             .into(),
         );
@@ -739,7 +752,6 @@ fn test_do_move_storage_updates() {
         let origin_hotkey = U256::from(2);
         let destination_hotkey = U256::from(3);
         let stake_amount = DefaultMinStake::<Test>::get() * 10;
-        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         // Set up initial stake
         SubtensorModule::stake_into_subnet(
@@ -760,6 +772,8 @@ fn test_do_move_storage_updates() {
             origin_netuid,
         );
 
+        let (tao_equivalent, _) = mock::swap_alpha_to_tao(origin_netuid, alpha);
+        let (alpha2, _) = mock::swap_tao_to_alpha(destination_netuid, tao_equivalent);
         assert_ok!(SubtensorModule::do_move_stake(
             RuntimeOrigin::signed(coldkey),
             origin_hotkey,
@@ -778,18 +792,15 @@ fn test_do_move_storage_updates() {
             ),
             0
         );
-        let alpha_fee =
-            U96F32::from_num(fee) / <Test as pallet::Config>::SwapInterface::current_alpha_price(destination_netuid);
-        let alpha2 = U96F32::from_num(alpha) * <Test as pallet::Config>::SwapInterface::current_alpha_price(origin_netuid)
-            / <Test as pallet::Config>::SwapInterface::current_alpha_price(destination_netuid);
+
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
                 &destination_hotkey,
                 &coldkey,
                 destination_netuid
             ),
-            (alpha2 - alpha_fee).to_num::<u64>(),
-            epsilon = alpha / 1000
+            alpha2,
+            epsilon = 2
         );
     });
 }
@@ -807,15 +818,14 @@ fn test_do_move_max_values() {
         let destination_hotkey = U256::from(3);
         let max_stake = u64::MAX;
         let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
-        let fee = 0;
 
         // Set up initial stake with maximum value
         SubtensorModule::create_account_if_non_existent(&coldkey, &origin_hotkey);
         SubtensorModule::create_account_if_non_existent(&coldkey, &destination_hotkey);
 
         // Add lots of liquidity to bypass low liquidity check
-        SubnetTAO::<Test>::insert(netuid, u64::MAX / 1000);
-        SubnetAlphaIn::<Test>::insert(netuid, u64::MAX / 1000);
+        let reserve = u64::MAX / 1000;
+        mock::setup_reserves(netuid, reserve, reserve);
 
         SubtensorModule::stake_into_subnet(
             &origin_hotkey,
@@ -832,6 +842,7 @@ fn test_do_move_max_values() {
         );
 
         // Move maximum stake
+        let (_, fee) = mock::swap_alpha_to_tao(netuid, alpha);
         assert_ok!(SubtensorModule::do_move_stake(
             RuntimeOrigin::signed(coldkey),
             origin_hotkey,
@@ -850,8 +861,7 @@ fn test_do_move_max_values() {
             ),
             0
         );
-		let fee = <Test as Config>::SwapInterface::approx_fee_amount(netuid, alpha);
-		let alpha_after_fee = alpha - fee;
+        let alpha_after_fee = alpha - fee;
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
                 &destination_hotkey,
@@ -871,13 +881,15 @@ fn test_moving_too_little_unstakes() {
         let hotkey_account_id = U256::from(533453);
         let coldkey_account_id = U256::from(55453);
         let amount = DefaultMinStake::<Test>::get();
-        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         //add network
-        let netuid: u16 = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
-        let netuid2: u16 = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
+        let netuid = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
+        let netuid2 = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
 
         // Give it some $$$ in his coldkey balance
+
+        let (_, fee) = mock::swap_tao_to_alpha(netuid, amount);
+
         SubtensorModule::add_balance_to_coldkey_account(&coldkey_account_id, amount + fee);
 
         assert_ok!(SubtensorModule::add_stake(
@@ -908,7 +920,6 @@ fn test_do_transfer_success() {
         let subnet_owner_coldkey = U256::from(1001);
         let subnet_owner_hotkey = U256::from(1002);
         let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
-        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         // 2. Define the origin coldkey, destination coldkey, and hotkey to be used.
         let origin_coldkey = U256::from(1);
@@ -934,6 +945,8 @@ fn test_do_transfer_success() {
         );
 
         // 4. Transfer the entire stake to the destination coldkey on the same subnet (netuid, netuid).
+        let (tao_equivalent, _) = mock::swap_alpha_to_tao(netuid, alpha);
+        let (expected_alpha, _) = mock::swap_tao_to_alpha(netuid, tao_equivalent);
         assert_ok!(SubtensorModule::do_transfer_stake(
             RuntimeOrigin::signed(origin_coldkey),
             destination_coldkey,
@@ -958,8 +971,8 @@ fn test_do_transfer_success() {
                 &destination_coldkey,
                 netuid
             ),
-            stake_amount - fee,
-            epsilon = stake_amount / 1000
+            expected_alpha,
+            epsilon = 1000
         );
     });
 }
@@ -1138,7 +1151,6 @@ fn test_do_transfer_different_subnets() {
         let destination_coldkey = U256::from(2);
         let hotkey = U256::from(3);
         let stake_amount = DefaultMinStake::<Test>::get() * 10;
-        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         // 3. Create accounts if needed.
         SubtensorModule::create_account_if_non_existent(&origin_coldkey, &hotkey);
@@ -1163,6 +1175,10 @@ fn test_do_transfer_different_subnets() {
             &origin_coldkey,
             origin_netuid,
         );
+
+        let (tao_equivalent, _) = mock::swap_alpha_to_tao(origin_netuid, alpha);
+        let (expected_alpha, _) = mock::swap_tao_to_alpha(destination_netuid, tao_equivalent);
+
         assert_ok!(SubtensorModule::do_transfer_stake(
             RuntimeOrigin::signed(origin_coldkey),
             destination_coldkey,
@@ -1183,17 +1199,14 @@ fn test_do_transfer_different_subnets() {
         );
 
         // 8. Verify stake ended up in destination subnet for destination coldkey.
-        let dest_stake = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
-            &hotkey,
-            &destination_coldkey,
-            destination_netuid,
-        );
-        let expected_value = U96F32::from_num(stake_amount - fee)
-            / <Test as pallet::Config>::SwapInterface::current_alpha_price(destination_netuid);
         assert_abs_diff_eq!(
-            dest_stake,
-            expected_value.to_num::<u64>(),
-            epsilon = (expected_value / 1000).to_num::<u64>()
+            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+                &hotkey,
+                &destination_coldkey,
+                destination_netuid,
+            ),
+            expected_alpha,
+            epsilon = 1000
         );
     });
 }
@@ -1209,7 +1222,6 @@ fn test_do_swap_success() {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
         let stake_amount = DefaultMinStake::<Test>::get() * 10;
-        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         SubtensorModule::create_account_if_non_existent(&coldkey, &hotkey);
         SubtensorModule::stake_into_subnet(
@@ -1226,6 +1238,8 @@ fn test_do_swap_success() {
             origin_netuid,
         );
 
+        let (tao_equivalent, _) = mock::swap_alpha_to_tao(origin_netuid, alpha_before);
+        let (expected_alpha, _) = mock::swap_tao_to_alpha(destination_netuid, tao_equivalent);
         assert_ok!(SubtensorModule::do_swap_stake(
             RuntimeOrigin::signed(coldkey),
             hotkey,
@@ -1248,16 +1262,8 @@ fn test_do_swap_success() {
             &coldkey,
             destination_netuid,
         );
-        let alpha_fee =
-            U96F32::from_num(fee) / <Test as pallet::Config>::SwapInterface::current_alpha_price(destination_netuid);
-        let expected_value = U96F32::from_num(alpha_before)
-            * <Test as pallet::Config>::SwapInterface::current_alpha_price(origin_netuid)
-            / <Test as pallet::Config>::SwapInterface::current_alpha_price(destination_netuid);
-        assert_abs_diff_eq!(
-            alpha_after,
-            (expected_value - alpha_fee).to_num::<u64>(),
-            epsilon = (expected_value / 1000).to_num::<u64>()
-        );
+
+        assert_abs_diff_eq!(alpha_after, expected_alpha, epsilon = 1000);
     });
 }
 
@@ -1426,7 +1432,6 @@ fn test_do_swap_same_subnet() {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
         let stake_amount = DefaultMinStake::<Test>::get() * 10;
-        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         SubtensorModule::create_account_if_non_existent(&coldkey, &hotkey);
         SubtensorModule::stake_into_subnet(
@@ -1440,14 +1445,9 @@ fn test_do_swap_same_subnet() {
 
         let alpha_before =
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid);
-        let fee_as_alpha = SubtensorModule::swap_tao_for_alpha(
-            netuid,
-            fee,
-            <Test as Config>::SwapInterface::max_price(),
-        )
-        .unwrap()
-        .amount_paid_out;
 
+        let (tao_equivalent, _) = mock::swap_alpha_to_tao(netuid, alpha_before);
+        let (expected_alpha, _) = mock::swap_tao_to_alpha(netuid, tao_equivalent);
         assert_ok!(SubtensorModule::do_swap_stake(
             RuntimeOrigin::signed(coldkey),
             hotkey,
@@ -1458,11 +1458,7 @@ fn test_do_swap_same_subnet() {
 
         let alpha_after =
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid);
-        assert_abs_diff_eq!(
-            alpha_after,
-            alpha_before - fee_as_alpha,
-            epsilon = alpha_after / 10000
-        );
+        assert_abs_diff_eq!(alpha_after, expected_alpha, epsilon = 1000);
     });
 }
 
@@ -1477,7 +1473,6 @@ fn test_do_swap_partial_stake() {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
         let total_stake = DefaultMinStake::<Test>::get() * 10;
-        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         SubtensorModule::create_account_if_non_existent(&coldkey, &hotkey);
         SubtensorModule::stake_into_subnet(
@@ -1490,6 +1485,8 @@ fn test_do_swap_partial_stake() {
         .unwrap();
 
         let swap_amount = total_stake / 2;
+        let (tao_equivalent, _) = mock::swap_alpha_to_tao(origin_netuid, swap_amount);
+        let (expected_alpha, _) = mock::swap_tao_to_alpha(destination_netuid, tao_equivalent);
         assert_ok!(SubtensorModule::do_swap_stake(
             RuntimeOrigin::signed(coldkey),
             hotkey,
@@ -1504,23 +1501,8 @@ fn test_do_swap_partial_stake() {
                 &coldkey,
                 origin_netuid
             ),
-            total_stake - swap_amount,
-            epsilon = total_stake / 1000
-        );
-
-        let alpha_fee =
-            U96F32::from_num(fee) / <Test as pallet::Config>::SwapInterface::current_alpha_price(destination_netuid);
-        let expected_value = U96F32::from_num(swap_amount)
-            * <Test as pallet::Config>::SwapInterface::current_alpha_price(origin_netuid)
-            / <Test as pallet::Config>::SwapInterface::current_alpha_price(destination_netuid);
-        assert_abs_diff_eq!(
-            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
-                &hotkey,
-                &coldkey,
-                destination_netuid
-            ),
-            (expected_value - alpha_fee).to_num::<u64>(),
-            epsilon = (expected_value / 1000).to_num::<u64>()
+            expected_alpha,
+            epsilon = 1000
         );
     });
 }
@@ -1536,7 +1518,6 @@ fn test_do_swap_storage_updates() {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
         let stake_amount = DefaultMinStake::<Test>::get() * 10;
-        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         SubtensorModule::create_account_if_non_existent(&coldkey, &hotkey);
         SubtensorModule::stake_into_subnet(
@@ -1553,6 +1534,8 @@ fn test_do_swap_storage_updates() {
             &coldkey,
             origin_netuid,
         );
+        let (tao_equivalent, _) = mock::swap_alpha_to_tao(origin_netuid, alpha);
+        let (expected_alpha, _) = mock::swap_tao_to_alpha(destination_netuid, tao_equivalent);
         assert_ok!(SubtensorModule::do_swap_stake(
             RuntimeOrigin::signed(coldkey),
             hotkey,
@@ -1570,19 +1553,14 @@ fn test_do_swap_storage_updates() {
             0
         );
 
-        let alpha_fee =
-            U96F32::from_num(fee) / <Test as pallet::Config>::SwapInterface::current_alpha_price(destination_netuid);
-        let expected_value = U96F32::from_num(alpha)
-            * <Test as pallet::Config>::SwapInterface::current_alpha_price(origin_netuid)
-            / <Test as pallet::Config>::SwapInterface::current_alpha_price(destination_netuid);
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
                 &hotkey,
                 &coldkey,
                 destination_netuid
             ),
-            (expected_value - alpha_fee).to_num::<u64>(),
-            epsilon = (expected_value / 1000).to_num::<u64>()
+            expected_alpha,
+            epsilon = 1000
         );
     });
 }
@@ -1598,7 +1576,6 @@ fn test_do_swap_multiple_times() {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
         let initial_stake = DefaultMinStake::<Test>::get() * 10;
-        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         SubtensorModule::create_account_if_non_existent(&coldkey, &hotkey);
         SubtensorModule::stake_into_subnet(
@@ -1610,7 +1587,7 @@ fn test_do_swap_multiple_times() {
         )
         .unwrap();
 
-        let mut total_alpha1_fee = 0;
+        let mut expected_alpha: u64 = 0;
         for _ in 0..3 {
             let alpha1 = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
                 &hotkey, &coldkey, netuid1,
@@ -1623,20 +1600,14 @@ fn test_do_swap_multiple_times() {
                     netuid2,
                     alpha1
                 ));
-
-                let fee_as_alpha = SubtensorModule::swap_tao_for_alpha(
-                    netuid1,
-                    fee,
-                    <Test as Config>::SwapInterface::max_price(),
-                )
-                .unwrap()
-                .amount_paid_out;
-                total_alpha1_fee += fee_as_alpha;
             }
             let alpha2 = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
                 &hotkey, &coldkey, netuid2,
             );
             if alpha2 > 0 {
+                let (tao_equivalent, _) = mock::swap_alpha_to_tao(netuid2, alpha2);
+                // we do this in the loop, because we need the value before the swap
+                expected_alpha = mock::swap_tao_to_alpha(netuid1, tao_equivalent).0;
                 assert_ok!(SubtensorModule::do_swap_stake(
                     RuntimeOrigin::signed(coldkey),
                     hotkey,
@@ -1644,29 +1615,18 @@ fn test_do_swap_multiple_times() {
                     netuid1,
                     alpha2
                 ));
-
-                let fee_as_alpha = SubtensorModule::swap_tao_for_alpha(
-                    netuid1,
-                    fee,
-                    <Test as Config>::SwapInterface::max_price(),
-                )
-                .unwrap()
-                .amount_paid_out;
-                total_alpha1_fee += fee_as_alpha;
             }
         }
 
-        let final_stake_netuid1: u64 =
-            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid1);
-        let final_stake_netuid2 =
-            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid2);
-        let expected_stake = initial_stake - total_alpha1_fee;
         assert_abs_diff_eq!(
-            final_stake_netuid1,
-            expected_stake,
-            epsilon = initial_stake / 10000
+            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid1),
+            expected_alpha,
+            epsilon = 1000
+        );
+        assert_eq!(
+            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid2),
+            0
         );
-        assert_eq!(final_stake_netuid2, 0);
     });
 }
 
@@ -1736,11 +1696,14 @@ fn test_swap_stake_limit_validate() {
         .unwrap();
 
         // Setup limit price so that it doesn't allow much slippage at all
-        let limit_price = ((<Test as pallet::Config>::SwapInterface::current_alpha_price(origin_netuid)
-            / <Test as pallet::Config>::SwapInterface::current_alpha_price(destination_netuid))
-            * U96F32::from_num(1_000_000_000))
-        .to_num::<u64>()
-            - 1_u64;
+        let limit_price =
+            ((<Test as pallet::Config>::SwapInterface::current_alpha_price(origin_netuid)
+                / <Test as pallet::Config>::SwapInterface::current_alpha_price(
+                    destination_netuid,
+                ))
+                * U96F32::from_num(1_000_000_000))
+            .to_num::<u64>()
+                - 1_u64;
 
         // Swap stake limit call
         let call = RuntimeCall::SubtensorModule(SubtensorCall::swap_stake_limit {
@@ -1919,6 +1882,8 @@ fn test_move_stake_specific_stake_into_subnet_fail() {
         );
 
         // Move stake to destination subnet
+        let (tao_equivalent, _) = mock::swap_alpha_to_tao(origin_netuid, alpha_to_move);
+        let (expected_value, _) = mock::swap_tao_to_alpha(netuid, tao_equivalent);
         assert_ok!(SubtensorModule::move_stake(
             RuntimeOrigin::signed(coldkey_account_id),
             hotkey_account_id,
@@ -1937,19 +1902,15 @@ fn test_move_stake_specific_stake_into_subnet_fail() {
             ),
             0
         );
-        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
-        let alpha_fee: U96F32 = U96F32::from_num(fee) / <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid);
-        let expected_value = U96F32::from_num(alpha_to_move)
-            * <Test as pallet::Config>::SwapInterface::current_alpha_price(origin_netuid)
-            / <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid);
+
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
                 &hotkey_account_id,
                 &coldkey_account_id,
                 netuid
             ),
-            (expected_value - alpha_fee).to_num::<u64>(),
-            epsilon = (expected_value / 1000).to_num::<u64>()
+            expected_value,
+            epsilon = 1000
         );
     });
 }
diff --git a/pallets/subtensor/src/tests/staking.rs b/pallets/subtensor/src/tests/staking.rs
index f01b3a00c5..822e708e5d 100644
--- a/pallets/subtensor/src/tests/staking.rs
+++ b/pallets/subtensor/src/tests/staking.rs
@@ -985,7 +985,7 @@ fn test_remove_stake_from_hotkey_account() {
         let hotkey_id = U256::from(5445);
         let coldkey_id = U256::from(5443433);
         let amount = 10_000;
-        let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
         register_ok_neuron(netuid, hotkey_id, coldkey_id, 192213123);
 
         // Add some stake that can be removed
@@ -997,9 +997,10 @@ fn test_remove_stake_from_hotkey_account() {
         );
 
         // Prelimiary checks
-        assert_eq!(
+        assert_abs_diff_eq!(
             SubtensorModule::get_total_stake_for_hotkey(&hotkey_id),
-            amount
+            amount,
+            epsilon = 10
         );
 
         // Remove stake
@@ -3689,8 +3690,8 @@ fn test_add_stake_limit_fill_or_kill() {
         SubnetTAO::<Test>::insert(netuid, tao_reserve.to_num::<u64>());
         SubnetAlphaIn::<Test>::insert(netuid, alpha_in.to_num::<u64>());
         let current_price = <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid);
-		// FIXME it's failing because in the swap pallet, the alpha price is set only after an
-		// initial swap
+        // FIXME it's failing because in the swap pallet, the alpha price is set only after an
+        // initial swap
         assert_eq!(current_price, U96F32::from_num(1.5));
 
         // Give it some $$$ in his coldkey balance

From 34936a9b8b7fc19af1f7396d4fb3794bd5525029 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Wed, 7 May 2025 17:30:38 -0400
Subject: [PATCH 126/418] Add modify_position extrinsic, fix active ticks
 management

---
 pallets/subtensor/src/macros/dispatches.rs   | 89 ++++++++++++++++++++
 pallets/subtensor/src/staking/stake_utils.rs |  2 +-
 pallets/swap-interface/src/lib.rs            |  7 ++
 pallets/swap/src/pallet/impls.rs             | 69 +++++++++------
 pallets/swap/src/pallet/mod.rs               |  2 +-
 pallets/swap/src/position.rs                 |  4 +-
 pallets/swap/src/tick.rs                     |  6 +-
 7 files changed, 144 insertions(+), 35 deletions(-)

diff --git a/pallets/subtensor/src/macros/dispatches.rs b/pallets/subtensor/src/macros/dispatches.rs
index 732335f2b7..4a70af6ca3 100644
--- a/pallets/subtensor/src/macros/dispatches.rs
+++ b/pallets/subtensor/src/macros/dispatches.rs
@@ -2149,5 +2149,94 @@ mod dispatches {
 
             Ok(())
         }
+
+        /// Modify a liquidity position.
+        ///
+        /// Parameters:
+        /// - origin: The origin of the transaction
+        /// - netuid: Subnet ID
+        /// - position_id: ID of the position to remove
+        /// - liquidity_delta: Liquidity to add (if positive) or remove (if negative)
+        ///
+        /// Emits `Event::LiquidityRemoved` on success
+        #[pallet::call_index(105)]
+        #[pallet::weight((
+		Weight::from_parts(50_000_000, 0)
+			.saturating_add(T::DbWeight::get().reads(4))
+			.saturating_add(T::DbWeight::get().writes(4)),
+            DispatchClass::Operational,
+            Pays::Yes
+        ))]
+        pub fn modify_position(
+            origin: OriginFor<T>,
+            hotkey: T::AccountId,
+            netuid: u16,
+            position_id: u128,
+            liquidity_delta: i64,
+        ) -> DispatchResult {
+            let coldkey = ensure_signed(origin)?;
+
+            // Ensure that the subnet exists.
+            ensure!(
+                Self::if_subnet_exist(netuid),
+                Error::<T>::SubNetworkDoesNotExist
+            );
+
+            // Ensure the hotkey account exists
+            ensure!(
+                Self::hotkey_account_exists(&hotkey),
+                Error::<T>::HotKeyAccountNotExists
+            );
+
+            // Add or remove liquidity
+            let result = T::SwapInterface::modify_position(netuid, &coldkey, &hotkey, position_id, liquidity_delta)?;
+
+            if liquidity_delta > 0 {
+                // Remove TAO and Alpha balances or fail transaction if they can't be removed exactly
+                let tao_provided = Self::remove_balance_from_coldkey_account(&coldkey, result.tao)?;
+                ensure!(tao_provided == result.tao, Error::<T>::InsufficientBalance);
+
+                let alpha_provided = Self::decrease_stake_for_hotkey_and_coldkey_on_subnet(
+                    &hotkey, &coldkey, netuid, result.alpha,
+                );
+                ensure!(alpha_provided == result.alpha, Error::<T>::InsufficientBalance);
+
+                // Emit an event
+                Self::deposit_event(Event::LiquidityAdded {
+                    coldkey,
+                    hotkey,
+                    netuid,
+                    position_id,
+                    liquidity: liquidity_delta as u64,
+                    tao: result.tao,
+                    alpha: result.alpha,
+                });
+            } else {
+                // Credit the returned tao and alpha to the account
+                Self::add_balance_to_coldkey_account(
+                    &coldkey,
+                    result.tao.saturating_add(result.fee_tao),
+                );
+                Self::increase_stake_for_hotkey_and_coldkey_on_subnet(
+                    &hotkey,
+                    &coldkey,
+                    netuid,
+                    result.alpha.saturating_add(result.fee_alpha),
+                );
+
+                // Emit an event
+                Self::deposit_event(Event::LiquidityRemoved {
+                    coldkey,
+                    netuid: netuid.into(),
+                    position_id,
+                    tao: result.tao,
+                    alpha: result.alpha,
+                    fee_tao: result.fee_tao,
+                    fee_alpha: result.fee_alpha,
+                });
+            }
+
+            Ok(())
+        }
     }
 }
diff --git a/pallets/subtensor/src/staking/stake_utils.rs b/pallets/subtensor/src/staking/stake_utils.rs
index 35c8fb1bad..94f46e2475 100644
--- a/pallets/subtensor/src/staking/stake_utils.rs
+++ b/pallets/subtensor/src/staking/stake_utils.rs
@@ -3,7 +3,7 @@ use safe_math::*;
 use share_pool::{SharePool, SharePoolDataOperations};
 use sp_std::ops::Neg;
 use substrate_fixed::types::{I64F64, I96F32, U64F64, U96F32};
-use subtensor_swap_interface::{LiquidityDataProvider, OrderType, SwapHandler, SwapResult};
+use subtensor_swap_interface::{OrderType, SwapHandler, SwapResult};
 
 impl<T: Config> Pallet<T> {
     /// Retrieves the total alpha issuance for a given subnet.
diff --git a/pallets/swap-interface/src/lib.rs b/pallets/swap-interface/src/lib.rs
index e26a85ba63..4ea291cea3 100644
--- a/pallets/swap-interface/src/lib.rs
+++ b/pallets/swap-interface/src/lib.rs
@@ -30,6 +30,13 @@ pub trait SwapHandler<AccountId> {
         coldkey_account_id: &AccountId,
         position_id: u128,
     ) -> Result<UpdateLiquidityResult, DispatchError>;
+    fn modify_position(
+        netuid: u16,
+        coldkey_account_id: &AccountId,
+        hotkey_account_id: &AccountId,
+        position_id: u128,
+        liquidity_delta: i64,
+    ) -> Result<UpdateLiquidityResult, DispatchError>;
     fn approx_fee_amount(netuid: u16, amount: u64) -> u64;
     fn current_alpha_price(netuid: u16) -> U96F32;
     fn max_price() -> u64;
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index c68f5ecb58..06202261eb 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -62,6 +62,8 @@ impl<T: Config> SwapStep<T> {
         let possible_delta_in = amount_remaining
             .saturating_sub(Pallet::<T>::calculate_fee_amount(netuid, amount_remaining));
 
+        println!("possible_delta_in = {:?}", possible_delta_in);
+
         // Target price and quantities
         let sqrt_price_target = Pallet::<T>::sqrt_price_target(
             order_type,
@@ -227,6 +229,9 @@ impl<T: Config> SwapStep<T> {
         let total_cost =
             delta_fixed.saturating_mul(u16_max.safe_div(u16_max.saturating_sub(fee_rate)));
 
+        println!("process_swap delta_fixed = {:?}", delta_fixed);
+        println!("process_swap total_cost = {:?}", total_cost);
+
         // Hold the fees
         let fee = Pallet::<T>::calculate_fee_amount(
             self.netuid,
@@ -412,16 +417,19 @@ impl<T: Config> Pallet<T> {
         let mut refund: u64 = 0;
         let mut iteration_counter: u16 = 0;
         let mut in_acc: u64 = 0;
-        let liquidity_before = CurrentLiquidity::<T>::get(netuid);
 
         // Swap one tick at a time until we reach one of the stop conditions
         while amount_remaining > 0 {
             // Create and execute a swap step
+            println!("amount_remaining = {:?}", amount_remaining);
+
             let mut swap_step =
                 SwapStep::<T>::new(netuid, order_type, amount_remaining, sqrt_price_limit);
 
             let swap_result = swap_step.execute()?;
 
+            println!("swap_result = {:?}", swap_result);
+
             in_acc = in_acc.saturating_add(swap_result.delta_in);
             amount_remaining = amount_remaining.saturating_sub(swap_result.amount_to_take);
             amount_paid_out = amount_paid_out.saturating_add(swap_result.delta_out);
@@ -431,6 +439,11 @@ impl<T: Config> Pallet<T> {
                 amount_remaining = 0;
             }
 
+            // The swap step didn't exchange anything
+            if swap_result.amount_to_take == 0 {
+                amount_remaining = 0;
+            }
+
             iteration_counter = iteration_counter.saturating_add(1);
 
             ensure!(
@@ -882,7 +895,7 @@ impl<T: Config> Pallet<T> {
         })
     }
 
-    fn modify_position(
+    pub fn modify_position(
         netuid: NetUid,
         coldkey_account_id: &T::AccountId,
         hotkey_account_id: &T::AccountId,
@@ -1019,6 +1032,9 @@ impl<T: Config> Pallet<T> {
                 });
             }
         });
+
+        // Update active ticks
+        ActiveTickIndexManager::insert::<T>(netuid, tick_index);
     }
 
     /// Remove liquidity at tick index.
@@ -1043,6 +1059,9 @@ impl<T: Config> Pallet<T> {
                 // If no liquidity is left at the tick, remove it
                 if tick.liquidity_gross == 0 {
                     *maybe_tick = None;
+
+                    // Update active ticks: Final liquidity is zero, remove this tick from active.
+                    ActiveTickIndexManager::remove::<T>(netuid, tick_index);
                 }
             }
         });
@@ -1157,6 +1176,17 @@ impl<T: Config> SwapHandler<T::AccountId> for Pallet<T> {
             .map_err(Into::into)
     }
 
+    fn modify_position(
+        netuid: u16,
+        coldkey_account_id: &T::AccountId,
+        hotkey_account_id: &T::AccountId,
+        position_id: u128,
+        liquidity_delta: i64,
+    ) -> Result<UpdateLiquidityResult, DispatchError> {
+        Self::modify_position(netuid.into(), coldkey_account_id, hotkey_account_id, position_id.into(), liquidity_delta)
+            .map_err(Into::into)
+    }
+
     fn approx_fee_amount(netuid: u16, amount: u64) -> u64 {
         Self::calculate_fee_amount(netuid.into(), amount)
     }
@@ -1198,7 +1228,7 @@ pub enum SwapStepAction {
 #[cfg(test)]
 mod tests {
     use approx::assert_abs_diff_eq;
-    use frame_support::{assert_err, assert_noop, assert_ok};
+    use frame_support::{assert_err, assert_ok};
     use sp_arithmetic::helpers_128bit;
 
     use super::*;
@@ -1639,7 +1669,6 @@ mod tests {
     #[test]
     fn test_modify_position_basic() {
         new_test_ext().execute_with(|| {
-            let min_price = tick_to_price(TickIndex::MIN);
             let max_price = tick_to_price(TickIndex::MAX);
             let max_tick = price_to_tick(max_price);
             let limit_price = 1000.0_f64;
@@ -1659,11 +1688,9 @@ mod tests {
                 //     4_000_000_000_u64,
                 // ),
                 // // Repeat the protocol liquidity at current to max range: Expect the same alpha
-                (0.25, max_price, 2_000_000_000_u64, 1_000_000_000, 4_000_000_000),
-                // Repeat the protocol liquidity at min to current range: Expect all the same tao
-                // (min_price, 0.24999, 2_000_000_000_u64, 1_000_000_000, 0),
-                // // Half to double price - just some sane wothdraw amounts
-                // (0.125, 0.5, 2_000_000_000_u64, 293_000_000, 1_171_000_000),
+                (0.25, max_price, 2_000_000_000_u64, 4_000_000_000),
+                // Half to double price - just some sane wothdraw amounts
+                // (0.125, 0.5, 2_000_000_000_u64, 1_171_000_000),
                 // // Both below price - tao is non-zero, alpha is zero
                 // (0.12, 0.13, 2_000_000_000_u64, 28_270_000, 0),
                 // // Both above price - tao is zero, alpha is non-zero
@@ -1671,8 +1698,8 @@ mod tests {
             ]
             .into_iter()
             .enumerate()
-            .map(|(n, v)| (NetUid::from(n as u16), v.0, v.1, v.2, v.3, v.4))
-            .for_each(|(netuid, price_low, price_high, liquidity, tao, alpha)| {
+            .map(|(n, v)| (NetUid::from(n as u16), v.0, v.1, v.2, v.3))
+            .for_each(|(netuid, price_low, price_high, liquidity, alpha)| {
                 // Calculate ticks (assuming tick math is tested separately)
                 let tick_low = price_to_tick(price_low);
                 let tick_high = price_to_tick(price_high);
@@ -1740,10 +1767,11 @@ mod tests {
                         &OK_COLDKEY_ACCOUNT_ID,
                         &OK_HOTKEY_ACCOUNT_ID,
                         position_id,
-                        -1_i64 * ((liquidity / 10) as i64),
+                        -1_i64 * ((liquidity / 100) as i64),
                     )
                     .unwrap();
-                assert_abs_diff_eq!(modify_result.alpha, alpha / 10, epsilon = alpha / 1000);
+
+                assert_abs_diff_eq!(modify_result.alpha, alpha / 100, epsilon = alpha / 1000);
                 assert_eq!(modify_result.fee_tao, 0);
                 assert_eq!(modify_result.fee_alpha, 0);
             });
@@ -2007,10 +2035,6 @@ mod tests {
                         // Calculate the expected output amount for the cornercase of one step
                         let order_liquidity = order_liquidity_fraction * position_liquidity as f64;
 
-                        let input_amount = match order_type {
-                            OrderType::Buy => order_liquidity * sqrt_current_price.to_num::<f64>(),
-                            OrderType::Sell => order_liquidity / sqrt_current_price.to_num::<f64>(),
-                        };
                         let output_amount = match order_type {
                             OrderType::Buy => {
                                 let denom = sqrt_current_price.to_num::<f64>()
@@ -2157,7 +2181,6 @@ mod tests {
             let min_price = tick_to_price(TickIndex::MIN);
             let max_price = tick_to_price(TickIndex::MAX);
             let max_tick = price_to_tick(max_price);
-            let current_price = 0.25;
             let netuid = NetUid(1);
             assert_eq!(max_tick, TickIndex::MAX);
 
@@ -2342,22 +2365,12 @@ mod tests {
             let order_type = OrderType::Sell;
             let liquidity = 1_000_000_000_000_000_000;
             let tick_low = TickIndex::MIN;
-            let tick_high = TickIndex::MAX;
 
             let sqrt_limit_price: SqrtPrice = tick_low.try_to_sqrt_price().unwrap();
 
             // Setup swap
             assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
 
-            // Get tick infos before the swap
-            let tick_low_info_before = Ticks::<Test>::get(netuid, tick_low).unwrap_or_default();
-            let tick_high_info_before = Ticks::<Test>::get(netuid, tick_high).unwrap_or_default();
-            let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
-
-            // Get current price
-            let sqrt_current_price = AlphaSqrtPrice::<Test>::get(netuid);
-            let current_price = (sqrt_current_price * sqrt_current_price).to_num::<f64>();
-
             // Swap
             let swap_result =
                 Pallet::<Test>::do_swap(netuid, order_type, liquidity, sqrt_limit_price, true)
diff --git a/pallets/swap/src/pallet/mod.rs b/pallets/swap/src/pallet/mod.rs
index e9b66fa2ca..46ad895e9d 100644
--- a/pallets/swap/src/pallet/mod.rs
+++ b/pallets/swap/src/pallet/mod.rs
@@ -6,7 +6,7 @@ use substrate_fixed::types::U64F64;
 use subtensor_swap_interface::LiquidityDataProvider;
 
 use crate::{
-    NetUid, SqrtPrice,
+    NetUid,
     position::{Position, PositionId},
     tick::{LayerLevel, Tick, TickIndex},
     weights::WeightInfo,
diff --git a/pallets/swap/src/position.rs b/pallets/swap/src/position.rs
index 37b4cd2853..4039e9f191 100644
--- a/pallets/swap/src/position.rs
+++ b/pallets/swap/src/position.rs
@@ -97,8 +97,8 @@ impl Position {
         let fee_tao_agg = self.fees_in_range::<T>(true);
         let fee_alpha_agg = self.fees_in_range::<T>(false);
 
-        let mut fee_tao = fee_tao_agg.saturating_sub(U64F64::saturating_from_num(self.fees_tao));
-        let mut fee_alpha = fee_alpha_agg.saturating_sub(U64F64::saturating_from_num(self.fees_alpha));
+        let mut fee_tao = fee_tao_agg.saturating_sub(self.fees_tao);
+        let mut fee_alpha = fee_alpha_agg.saturating_sub(self.fees_alpha);
 
         self.fees_tao = fee_tao_agg;
         self.fees_alpha = fee_alpha_agg;
diff --git a/pallets/swap/src/tick.rs b/pallets/swap/src/tick.rs
index 8253647abc..7c4d9b22cb 100644
--- a/pallets/swap/src/tick.rs
+++ b/pallets/swap/src/tick.rs
@@ -15,7 +15,7 @@ use substrate_fixed::types::U64F64;
 use subtensor_macros::freeze_struct;
 
 use crate::pallet::{
-    AlphaSqrtPrice, Config, CurrentTick, FeeGlobalAlpha, FeeGlobalTao, TickIndexBitmapWords, Ticks,
+    Config, CurrentTick, FeeGlobalAlpha, FeeGlobalTao, TickIndexBitmapWords, Ticks,
 };
 use crate::{NetUid, SqrtPrice};
 
@@ -692,9 +692,9 @@ pub enum LayerLevel {
     Bottom = 2,
 }
 
-#[freeze_struct("183175773f3f92e0")]
+#[freeze_struct("4015a04919eb5e2e")]
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Encode, Decode, TypeInfo, MaxEncodedLen)]
-struct BitmapLayer {
+pub(crate) struct BitmapLayer {
     word: u32,
     bit: u32,
 }

From 113d10fda8cdda2c60e54348f287ed7cac08eec2 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Thu, 8 May 2025 10:42:07 +0800
Subject: [PATCH 127/418] init solution

---
 pallets/subtensor/rpc/src/lib.rs            |  2 +
 pallets/subtensor/runtime-api/src/lib.rs    |  2 +-
 pallets/subtensor/src/rpc_info/metagraph.rs | 61 ++++++++++++++++++++-
 3 files changed, 62 insertions(+), 3 deletions(-)

diff --git a/pallets/subtensor/rpc/src/lib.rs b/pallets/subtensor/rpc/src/lib.rs
index b3b60206dd..56bd92daab 100644
--- a/pallets/subtensor/rpc/src/lib.rs
+++ b/pallets/subtensor/rpc/src/lib.rs
@@ -69,6 +69,7 @@ pub trait SubtensorCustomApi<BlockHash> {
         &self,
         netuid: u16,
         metagraph_index: Vec<u16>,
+        validator_only: bool,
         at: Option<BlockHash>,
     ) -> RpcResult<Vec<u8>>;
 }
@@ -402,6 +403,7 @@ where
         &self,
         netuid: u16,
         metagraph_index: Vec<u16>,
+        validator_only: bool,
         at: Option<<Block as BlockT>::Hash>,
     ) -> RpcResult<Vec<u8>> {
         let api = self.client.runtime_api();
diff --git a/pallets/subtensor/runtime-api/src/lib.rs b/pallets/subtensor/runtime-api/src/lib.rs
index 1a2f34aa9e..45402f8be9 100644
--- a/pallets/subtensor/runtime-api/src/lib.rs
+++ b/pallets/subtensor/runtime-api/src/lib.rs
@@ -40,7 +40,7 @@ sp_api::decl_runtime_apis! {
         fn get_metagraph(netuid: u16) -> Option<Metagraph<AccountId32>>;
         fn get_dynamic_info(netuid: u16) -> Option<DynamicInfo<AccountId32>>;
         fn get_subnet_state(netuid: u16) -> Option<SubnetState<AccountId32>>;
-        fn get_selective_metagraph(netuid: u16, metagraph_indexes: Vec<u16>) -> Option<SelectiveMetagraph<AccountId32>>;
+        fn get_selective_metagraph(netuid: u16, metagraph_indexes: Vec<u16>, validator_only: bool) -> Option<SelectiveMetagraph<AccountId32>>;
     }
 
     pub trait StakeInfoRuntimeApi {
diff --git a/pallets/subtensor/src/rpc_info/metagraph.rs b/pallets/subtensor/src/rpc_info/metagraph.rs
index 04325fef4d..ee1a732627 100644
--- a/pallets/subtensor/src/rpc_info/metagraph.rs
+++ b/pallets/subtensor/src/rpc_info/metagraph.rs
@@ -2,6 +2,7 @@ use super::*;
 extern crate alloc;
 use crate::epoch::math::*;
 use codec::Compact;
+use frame_support::IterableStorageDoubleMap;
 use frame_support::pallet_prelude::{Decode, Encode};
 use substrate_fixed::types::I64F64;
 use substrate_fixed::types::I96F32;
@@ -107,7 +108,7 @@ pub struct Metagraph<AccountId: TypeInfo + Encode + Decode> {
     alpha_dividends_per_hotkey: Vec<(AccountId, Compact<u64>)>, // List of dividend payout in alpha via subnet.
 }
 
-#[freeze_struct("182c7375fee9db7b")]
+#[freeze_struct("2eca518cf84390fa")]
 #[derive(Decode, Encode, PartialEq, Eq, Clone, Debug, TypeInfo)]
 pub struct SelectiveMetagraph<AccountId: TypeInfo + Encode + Decode + Clone> {
     // Subnet index
@@ -205,6 +206,9 @@ pub struct SelectiveMetagraph<AccountId: TypeInfo + Encode + Decode + Clone> {
     // Dividend break down.
     tao_dividends_per_hotkey: Option<Vec<(AccountId, Compact<u64>)>>, // List of dividend payouts in tao via root.
     alpha_dividends_per_hotkey: Option<Vec<(AccountId, Compact<u64>)>>, // List of dividend payout in alpha via subnet.
+
+    // validators
+    validators: Option<Vec<Compact<u16>>>, // List of validators
 }
 
 impl<AccountId> SelectiveMetagraph<AccountId>
@@ -362,6 +366,8 @@ where
                 self.alpha_dividends_per_hotkey = other.alpha_dividends_per_hotkey.clone()
             }
 
+            Some(SelectiveMetagraphIndex::Validators) => self.validators = other.validators.clone(),
+
             None => {}
         };
     }
@@ -445,6 +451,7 @@ where
             total_stake: None,
             tao_dividends_per_hotkey: None,
             alpha_dividends_per_hotkey: None,
+            validators: None,
         }
     }
 }
@@ -522,6 +529,7 @@ pub enum SelectiveMetagraphIndex {
     TotalStake,
     TaoDividendsPerHotkey,
     AlphaDividendsPerHotkey,
+    Validators,
 }
 
 impl SelectiveMetagraphIndex {
@@ -599,6 +607,7 @@ impl SelectiveMetagraphIndex {
             69 => Some(SelectiveMetagraphIndex::TotalStake),
             70 => Some(SelectiveMetagraphIndex::TaoDividendsPerHotkey),
             71 => Some(SelectiveMetagraphIndex::AlphaDividendsPerHotkey),
+            72 => Some(SelectiveMetagraphIndex::Validators),
             _ => None,
         }
     }
@@ -791,10 +800,14 @@ impl<T: Config> Pallet<T> {
     pub fn get_selective_metagraph(
         netuid: u16,
         metagraph_indexes: Vec<u16>,
+        validator_only: bool,
     ) -> Option<SelectiveMetagraph<T::AccountId>> {
         if !Self::if_subnet_exist(netuid) {
             None
         } else {
+            if validator_only {
+                return Some(Self::get_valiators(netuid));
+            }
             let mut result = SelectiveMetagraph::default();
             for index in metagraph_indexes.iter() {
                 let value = Self::get_single_selective_metagraph(netuid, *index);
@@ -1356,13 +1369,56 @@ impl<T: Config> Pallet<T> {
                     ..Default::default()
                 }
             }
-            None => SelectiveMetagraph {
+            _ => SelectiveMetagraph {
                 // Subnet index
                 netuid: netuid.into(),
                 ..Default::default()
             },
         }
     }
+
+    fn get_valiators(netuid: u16) -> SelectiveMetagraph<T::AccountId> {
+        let stake_threshold = Self::get_stake_threshold();
+        let hotkeys: Vec<(u16, T::AccountId)> =
+            <Keys<T> as IterableStorageDoubleMap<u16, u16, T::AccountId>>::iter_prefix(netuid)
+                .collect();
+        let validator_permits: Vec<bool> = Self::get_validator_permit(netuid);
+
+        // filter according to validator_permits
+        let hotkeys: Vec<&(u16, T::AccountId)> = hotkeys
+            .iter()
+            .filter(|(uid, _)| *validator_permits.get(*uid as usize).unwrap_or(&false))
+            .collect::<Vec<_>>();
+
+        // map hotkeys to validators with stake
+        let mut validators: Vec<(u16, I64F64)> = hotkeys
+            .iter()
+            .map(|(uid, hotkey)| {
+                let stake = Self::get_stake_weights_for_hotkey_on_subnet(hotkey, netuid);
+                // let stake = stake.0[*uid as usize];
+                (*uid, stake.0)
+            })
+            .collect();
+
+        // sort validators by stake
+        validators.sort_by(|a, b| a.1.cmp(&b.1));
+
+        let validators: Vec<Compact<u16>> = validators
+            .iter()
+            .filter(|(_uid, stake)| {
+                // let stake = stake.0[*uid as usize];
+                *stake > stake_threshold
+            })
+            .map(|(uid, _)| Compact::from(*uid))
+            .collect::<Vec<_>>();
+
+        SelectiveMetagraph {
+            // Subnet index
+            netuid: netuid.into(),
+            validators: Some(validators),
+            ..Default::default()
+        }
+    }
 }
 
 #[test]
@@ -1441,6 +1497,7 @@ fn test_selective_metagraph() {
         total_stake: None,
         tao_dividends_per_hotkey: None,
         alpha_dividends_per_hotkey: None,
+        validators: None,
     };
 
     // test init value

From 11159b6b3765bba7d19f29e067ba4fe9f15dd6ec Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Thu, 8 May 2025 11:18:24 +0800
Subject: [PATCH 128/418] fix wrong interface parameter

---
 pallets/subtensor/rpc/src/lib.rs | 2 +-
 runtime/src/lib.rs               | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/pallets/subtensor/rpc/src/lib.rs b/pallets/subtensor/rpc/src/lib.rs
index 56bd92daab..e9b7da2d04 100644
--- a/pallets/subtensor/rpc/src/lib.rs
+++ b/pallets/subtensor/rpc/src/lib.rs
@@ -409,7 +409,7 @@ where
         let api = self.client.runtime_api();
         let at = at.unwrap_or_else(|| self.client.info().best_hash);
 
-        match api.get_selective_metagraph(at, netuid, metagraph_index) {
+        match api.get_selective_metagraph(at, netuid, metagraph_index, validator_only) {
             Ok(result) => Ok(result.encode()),
             Err(e) => Err(Error::RuntimeError(format!(
                 "Unable to get selective metagraph: {:?}",
diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index a70315d324..a4cf5ddad6 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -2197,8 +2197,8 @@ impl_runtime_apis! {
             SubtensorModule::get_all_dynamic_info()
         }
 
-        fn get_selective_metagraph(netuid: u16, metagraph_indexes: Vec<u16>) -> Option<SelectiveMetagraph<AccountId32>> {
-            SubtensorModule::get_selective_metagraph(netuid, metagraph_indexes)
+        fn get_selective_metagraph(netuid: u16, metagraph_indexes: Vec<u16>, validator_only: bool) -> Option<SelectiveMetagraph<AccountId32>> {
+            SubtensorModule::get_selective_metagraph(netuid, metagraph_indexes, validator_only)
         }
 
     }

From d5d0964ffffe98c53c0ea3dabe2b17857f0f06e6 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Thu, 8 May 2025 15:20:38 +0800
Subject: [PATCH 129/418] remove commented code

---
 pallets/subtensor/src/rpc_info/metagraph.rs | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/pallets/subtensor/src/rpc_info/metagraph.rs b/pallets/subtensor/src/rpc_info/metagraph.rs
index ee1a732627..52c2790d1a 100644
--- a/pallets/subtensor/src/rpc_info/metagraph.rs
+++ b/pallets/subtensor/src/rpc_info/metagraph.rs
@@ -1395,7 +1395,6 @@ impl<T: Config> Pallet<T> {
             .iter()
             .map(|(uid, hotkey)| {
                 let stake = Self::get_stake_weights_for_hotkey_on_subnet(hotkey, netuid);
-                // let stake = stake.0[*uid as usize];
                 (*uid, stake.0)
             })
             .collect();
@@ -1405,10 +1404,7 @@ impl<T: Config> Pallet<T> {
 
         let validators: Vec<Compact<u16>> = validators
             .iter()
-            .filter(|(_uid, stake)| {
-                // let stake = stake.0[*uid as usize];
-                *stake > stake_threshold
-            })
+            .filter(|(_uid, stake)| *stake > stake_threshold)
             .map(|(uid, _)| Compact::from(*uid))
             .collect::<Vec<_>>();
 

From c6ee5d61c0176cc4267ed0a92b3547858fa86d4a Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Thu, 8 May 2025 16:26:32 +0800
Subject: [PATCH 130/418] fix comments in PR

---
 pallets/admin-utils/src/tests/mock.rs     |  2 +-
 pallets/subtensor/src/macros/config.rs    |  2 +-
 pallets/subtensor/src/macros/hooks.rs     | 23 +++++++++++++++++------
 pallets/subtensor/src/swap/swap_hotkey.rs |  2 +-
 pallets/subtensor/src/tests/mock.rs       |  2 +-
 runtime/src/lib.rs                        |  2 +-
 6 files changed, 22 insertions(+), 11 deletions(-)

diff --git a/pallets/admin-utils/src/tests/mock.rs b/pallets/admin-utils/src/tests/mock.rs
index 3e5afc3df4..916065081e 100644
--- a/pallets/admin-utils/src/tests/mock.rs
+++ b/pallets/admin-utils/src/tests/mock.rs
@@ -205,7 +205,7 @@ impl pallet_subtensor::Config for Test {
     type InitialTaoWeight = InitialTaoWeight;
     type InitialEmaPriceHalvingPeriod = InitialEmaPriceHalvingPeriod;
     type DurationOfStartCall = DurationOfStartCall;
-    type KeySwapOneSubnetCost = InitialKeySwapOnSubnetCost;
+    type KeySwapOnSubnetCost = InitialKeySwapOnSubnetCost;
     type HotkeySwapOnSubnetInterval = HotkeySwapOnSubnetInterval;
 }
 
diff --git a/pallets/subtensor/src/macros/config.rs b/pallets/subtensor/src/macros/config.rs
index a32862e988..32e10dde55 100644
--- a/pallets/subtensor/src/macros/config.rs
+++ b/pallets/subtensor/src/macros/config.rs
@@ -218,7 +218,7 @@ mod config {
         type DurationOfStartCall: Get<u64>;
         /// Cost of swapping a hotkey in a subnet.
         #[pallet::constant]
-        type KeySwapOneSubnetCost: Get<u64>;
+        type KeySwapOnSubnetCost: Get<u64>;
         /// Block number for a coldkey swap the hotkey in specific subnet.
         #[pallet::constant]
         type HotkeySwapOnSubnetInterval: Get<u64>;
diff --git a/pallets/subtensor/src/macros/hooks.rs b/pallets/subtensor/src/macros/hooks.rs
index 48898b97b6..e7e1323a7d 100644
--- a/pallets/subtensor/src/macros/hooks.rs
+++ b/pallets/subtensor/src/macros/hooks.rs
@@ -14,7 +14,9 @@ mod hooks {
         // # Args:
         // 	* 'n': (BlockNumberFor<T>):
         // 		- The number of the block we are initializing.
-        fn on_initialize(_block_number: BlockNumberFor<T>) -> Weight {
+        fn on_initialize(block_number: BlockNumberFor<T>) -> Weight {
+            let hotkey_swap_clean_up_weight = Self::clean_up_hotkey_swap_records(block_number);
+
             let block_step_result = Self::block_step();
             match block_step_result {
                 Ok(_) => {
@@ -23,6 +25,7 @@ mod hooks {
                     Weight::from_parts(110_634_229_000_u64, 0)
                         .saturating_add(T::DbWeight::get().reads(8304_u64))
                         .saturating_add(T::DbWeight::get().writes(110_u64))
+                        .saturating_add(hotkey_swap_clean_up_weight)
                 }
                 Err(e) => {
                     // --- If the block step was unsuccessful, return the weight anyway.
@@ -30,6 +33,7 @@ mod hooks {
                     Weight::from_parts(110_634_229_000_u64, 0)
                         .saturating_add(T::DbWeight::get().reads(8304_u64))
                         .saturating_add(T::DbWeight::get().writes(110_u64))
+                        .saturating_add(hotkey_swap_clean_up_weight)
                 }
             }
         }
@@ -41,7 +45,6 @@ mod hooks {
         // 		- The number of the block we are finalizing.
         fn on_finalize(block_number: BlockNumberFor<T>) {
             Self::do_on_finalize(block_number);
-            Self::clean_up_hotkey_swap_records(block_number);
         }
 
         fn on_runtime_upgrade() -> frame_support::weights::Weight {
@@ -132,26 +135,34 @@ mod hooks {
     impl<T: Config> Pallet<T> {
         // This function is to clean up the old hotkey swap records
         // It just clean up for one subnet at a time, according to the block number
-        fn clean_up_hotkey_swap_records(block_number: BlockNumberFor<T>) {
+        fn clean_up_hotkey_swap_records(block_number: BlockNumberFor<T>) -> Weight {
+            let mut weight = Weight::from_parts(0, 0);
             let hotkey_swap_on_subnet_interval = T::HotkeySwapOnSubnetInterval::get();
             let block_number: u64 = TryInto::try_into(block_number)
                 .ok()
                 .expect("blockchain will not exceed 2^64 blocks; QED.");
             let netuids = Self::get_all_subnet_netuids();
 
+            weight.saturating_accrue(T::DbWeight::get().reads(2_u64 + netuids.len() as u64));
+
             if let Some(slot) = block_number.checked_rem(hotkey_swap_on_subnet_interval) {
-                if slot < (u16::MAX as u64) && netuids.contains(&(slot as u16)) {
+                for netuid in netuids.iter().filter(|netuid| {
+                    (**netuid as u64).checked_rem(hotkey_swap_on_subnet_interval) == Some(slot)
+                }) {
                     for (coldkey, swap_block_number) in
-                        LastHotkeySwapOnNetuid::<T>::iter_prefix(slot as u16)
+                        LastHotkeySwapOnNetuid::<T>::iter_prefix(netuid)
                     {
                         if swap_block_number.saturating_add(hotkey_swap_on_subnet_interval)
                             < block_number
                         {
-                            LastHotkeySwapOnNetuid::<T>::remove(slot as u16, coldkey);
+                            LastHotkeySwapOnNetuid::<T>::remove(netuid, coldkey);
+                            weight.saturating_accrue(T::DbWeight::get().writes(1_u64));
                         }
+                        weight.saturating_accrue(T::DbWeight::get().reads(1_u64));
                     }
                 }
             }
+            weight
         }
     }
 }
diff --git a/pallets/subtensor/src/swap/swap_hotkey.rs b/pallets/subtensor/src/swap/swap_hotkey.rs
index f9b5cb9ebc..733535c2ad 100644
--- a/pallets/subtensor/src/swap/swap_hotkey.rs
+++ b/pallets/subtensor/src/swap/swap_hotkey.rs
@@ -285,7 +285,7 @@ impl<T: Config> Pallet<T> {
         weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 0));
 
         // 3. Get the cost for swapping the key on the subnet
-        let swap_cost = T::KeySwapOneSubnetCost::get();
+        let swap_cost = T::KeySwapOnSubnetCost::get();
         log::debug!("Swap cost in subnet {:?}: {:?}", netuid, swap_cost);
         weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 0));
 
diff --git a/pallets/subtensor/src/tests/mock.rs b/pallets/subtensor/src/tests/mock.rs
index 8fe386aa1a..4bd22f85c1 100644
--- a/pallets/subtensor/src/tests/mock.rs
+++ b/pallets/subtensor/src/tests/mock.rs
@@ -415,7 +415,7 @@ impl crate::Config for Test {
     type InitialTaoWeight = InitialTaoWeight;
     type InitialEmaPriceHalvingPeriod = InitialEmaPriceHalvingPeriod;
     type DurationOfStartCall = DurationOfStartCall;
-    type KeySwapOneSubnetCost = InitialKeySwapOnSubnetCost;
+    type KeySwapOnSubnetCost = InitialKeySwapOnSubnetCost;
     type HotkeySwapOnSubnetInterval = HotkeySwapOnSubnetInterval;
 }
 
diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index 987deb9cab..20a9e73ea9 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -1148,7 +1148,7 @@ impl pallet_subtensor::Config for Runtime {
     type InitialDissolveNetworkScheduleDuration = InitialDissolveNetworkScheduleDuration;
     type InitialEmaPriceHalvingPeriod = InitialEmaPriceHalvingPeriod;
     type DurationOfStartCall = DurationOfStartCall;
-    type KeySwapOneSubnetCost = SubtensorInitialKeySwapOnSubnetCost;
+    type KeySwapOnSubnetCost = SubtensorInitialKeySwapOnSubnetCost;
     type HotkeySwapOnSubnetInterval = HotkeySwapOnSubnetInterval;
 }
 

From 70b1ec07e447c1a68cd1f22df8efc01076d5509b Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Thu, 8 May 2025 16:41:13 +0800
Subject: [PATCH 131/418] fix clippy

---
 pallets/subtensor/src/macros/hooks.rs | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/pallets/subtensor/src/macros/hooks.rs b/pallets/subtensor/src/macros/hooks.rs
index e7e1323a7d..c09bf43d40 100644
--- a/pallets/subtensor/src/macros/hooks.rs
+++ b/pallets/subtensor/src/macros/hooks.rs
@@ -141,17 +141,21 @@ mod hooks {
             let block_number: u64 = TryInto::try_into(block_number)
                 .ok()
                 .expect("blockchain will not exceed 2^64 blocks; QED.");
-            let netuids = Self::get_all_subnet_netuids();
+            weight.saturating_accrue(T::DbWeight::get().reads(2_u64));
 
-            weight.saturating_accrue(T::DbWeight::get().reads(2_u64 + netuids.len() as u64));
+            let netuids = Self::get_all_subnet_netuids();
+            weight.saturating_accrue(T::DbWeight::get().reads(netuids.len() as u64));
 
             if let Some(slot) = block_number.checked_rem(hotkey_swap_on_subnet_interval) {
+                // only handle the subnet with the same residue as current block number by HotkeySwapOnSubnetInterval
                 for netuid in netuids.iter().filter(|netuid| {
                     (**netuid as u64).checked_rem(hotkey_swap_on_subnet_interval) == Some(slot)
                 }) {
+                    // Iterate over all the coldkeys in the subnet
                     for (coldkey, swap_block_number) in
                         LastHotkeySwapOnNetuid::<T>::iter_prefix(netuid)
                     {
+                        // Clean up out of date swap records
                         if swap_block_number.saturating_add(hotkey_swap_on_subnet_interval)
                             < block_number
                         {

From c0edd409ffafa8345d3faa77aae4fedd95b30c3f Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Thu, 8 May 2025 16:51:46 +0200
Subject: [PATCH 132/418] Fix most of staking tests

---
 pallets/subtensor/src/staking/helpers.rs | 14 ++++-
 pallets/subtensor/src/tests/coinbase.rs  |  3 +
 pallets/subtensor/src/tests/staking.rs   | 78 +++++++++++++-----------
 3 files changed, 56 insertions(+), 39 deletions(-)

diff --git a/pallets/subtensor/src/staking/helpers.rs b/pallets/subtensor/src/staking/helpers.rs
index 3987058c36..e875228a06 100644
--- a/pallets/subtensor/src/staking/helpers.rs
+++ b/pallets/subtensor/src/staking/helpers.rs
@@ -55,7 +55,12 @@ impl<T: Config> Pallet<T> {
                     T::SwapInterface::max_price(),
                     true,
                 )
-                .map(|r| r.amount_paid_out.saturating_add(r.fee_paid))
+                .map(|r| {
+                    let fee: u64 = U96F32::saturating_from_num(r.fee_paid)
+                        .saturating_mul(T::SwapInterface::current_alpha_price(netuid))
+                        .saturating_to_num();
+                    r.amount_paid_out.saturating_add(fee)
+                })
                 .unwrap_or_default()
             })
             .sum()
@@ -80,7 +85,12 @@ impl<T: Config> Pallet<T> {
                             T::SwapInterface::max_price(),
                             true,
                         )
-                        .map(|r| r.amount_paid_out.saturating_add(r.fee_paid))
+                        .map(|r| {
+                            let fee: u64 = U96F32::saturating_from_num(r.fee_paid)
+                                .saturating_mul(T::SwapInterface::current_alpha_price(netuid))
+                                .saturating_to_num();
+                            r.amount_paid_out.saturating_add(fee)
+                        })
                         .unwrap_or_default()
                     })
                     .sum::<u64>()
diff --git a/pallets/subtensor/src/tests/coinbase.rs b/pallets/subtensor/src/tests/coinbase.rs
index 030fcf655d..f8c405edbd 100644
--- a/pallets/subtensor/src/tests/coinbase.rs
+++ b/pallets/subtensor/src/tests/coinbase.rs
@@ -1980,6 +1980,9 @@ fn test_run_coinbase_not_started() {
         // Set weight-set limit to 0.
         SubtensorModule::set_weights_set_rate_limit(netuid, 0);
 
+		let reserve = init_stake * 1000;
+		mock::setup_reserves(netuid, reserve, reserve);
+
         register_ok_neuron(netuid, hotkey, coldkey, 0);
         register_ok_neuron(netuid, miner_hk, miner_ck, 0);
         register_ok_neuron(netuid, sn_owner_hk, sn_owner_ck, 0);
diff --git a/pallets/subtensor/src/tests/staking.rs b/pallets/subtensor/src/tests/staking.rs
index 822e708e5d..e77be3384e 100644
--- a/pallets/subtensor/src/tests/staking.rs
+++ b/pallets/subtensor/src/tests/staking.rs
@@ -44,8 +44,6 @@ fn test_add_stake_dispatch_info_ok() {
 #[test]
 fn test_add_stake_ok_no_emission() {
     new_test_ext(1).execute_with(|| {
-        // this test indicates the problem with get_alpha_price
-        // todo!("this test will fail because of get_alpha_price implementation");
         let hotkey_account_id = U256::from(533453);
         let coldkey_account_id = U256::from(55453);
         let amount = DefaultMinStake::<Test>::get() * 10;
@@ -80,16 +78,19 @@ fn test_add_stake_ok_no_emission() {
         ));
 
         let (tao_expected, _) = mock::swap_alpha_to_tao(netuid, alpha_staked);
+        let approx_fee = <Test as pallet::Config>::SwapInterface::approx_fee_amount(netuid, amount);
 
-        assert_eq!(
+        assert_abs_diff_eq!(
             SubtensorModule::get_total_stake_for_hotkey(&hotkey_account_id),
-            tao_expected
+            tao_expected + approx_fee, // swap returns value after fee, so we need to compensate it
+            epsilon = 10000,
         );
 
         // Check if stake has increased
-        assert_eq!(
+        assert_abs_diff_eq!(
             SubtensorModule::get_total_stake_for_hotkey(&hotkey_account_id),
-            amount - fee
+            amount - fee,
+            epsilon = 10000
         );
 
         // Check if balance has decreased
@@ -132,9 +133,10 @@ fn test_dividends_with_run_to_block() {
         );
 
         // Check if the initial stake has arrived
-        assert_eq!(
+        assert_abs_diff_eq!(
             SubtensorModule::get_total_stake_for_hotkey(&neuron_src_hotkey_id),
-            initial_stake
+            initial_stake,
+            epsilon = 2
         );
 
         // Check if all three neurons are registered
@@ -144,9 +146,10 @@ fn test_dividends_with_run_to_block() {
         run_to_block(2);
 
         // Check if the stake is equal to the inital stake + transfer
-        assert_eq!(
+        assert_abs_diff_eq!(
             SubtensorModule::get_total_stake_for_hotkey(&neuron_src_hotkey_id),
-            initial_stake
+            initial_stake,
+            epsilon = 2
         );
 
         // Check if the stake is equal to the inital stake + transfer
@@ -967,9 +970,10 @@ fn test_add_stake_to_hotkey_account_ok() {
         );
 
         // The stake that is now in the account, should equal the amount
-        assert_eq!(
+        assert_abs_diff_eq!(
             SubtensorModule::get_total_stake_for_hotkey(&hotkey_id),
-            amount
+            amount,
+            epsilon = 2
         );
     });
 }
@@ -1220,9 +1224,10 @@ fn test_has_enough_stake_yes() {
             intial_amount,
         );
 
-        assert_eq!(
+        assert_abs_diff_eq!(
             SubtensorModule::get_total_stake_for_hotkey(&hotkey_id),
-            intial_amount
+            intial_amount,
+            epsilon = 2
         );
         assert_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
@@ -1255,9 +1260,10 @@ fn test_has_enough_stake_no() {
             intial_amount,
         );
 
-        assert_eq!(
+        assert_abs_diff_eq!(
             SubtensorModule::get_total_stake_for_hotkey(&hotkey_id),
-            intial_amount
+            intial_amount,
+            epsilon = 2
         );
         assert_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
@@ -2149,7 +2155,6 @@ fn test_get_total_delegated_stake_exclude_owner_stake() {
         let delegator = U256::from(3);
         let owner_stake = DefaultMinStake::<Test>::get() * 10;
         let delegator_stake = DefaultMinStake::<Test>::get() * 10 - 1;
-        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         let netuid = add_dynamic_network(&delegate_hotkey, &delegate_coldkey);
 
@@ -2164,6 +2169,7 @@ fn test_get_total_delegated_stake_exclude_owner_stake() {
 
         // Add delegator stake
         SubtensorModule::add_balance_to_coldkey_account(&delegator, delegator_stake);
+        let (_, fee) = mock::swap_tao_to_alpha(netuid, delegator_stake);
         assert_ok!(SubtensorModule::add_stake(
             RuntimeOrigin::signed(delegator),
             delegate_hotkey,
@@ -2190,7 +2196,7 @@ fn test_get_total_delegated_stake_exclude_owner_stake() {
         assert_abs_diff_eq!(
             actual_delegated_stake,
             expected_delegated_stake,
-            epsilon = expected_delegated_stake / 1000
+            epsilon = 1000
         );
     });
 }
@@ -4058,7 +4064,6 @@ fn test_remove_99_9991_per_cent_stake_removes_all() {
         let coldkey_account_id = U256::from(81337);
         let amount = 10_000_000_000;
         let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
-        let mut fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
         register_ok_neuron(netuid, hotkey_account_id, coldkey_account_id, 192213123);
 
         // Give it some $$$ in his coldkey balance
@@ -4079,6 +4084,8 @@ fn test_remove_99_9991_per_cent_stake_removes_all() {
             netuid,
         );
         let remove_amount = (U64F64::from_num(alpha) * U64F64::from_num(0.999991)).to_num::<u64>();
+        // we expected the entire stake to be returned
+        let (expected_balance, _) = mock::swap_alpha_to_tao(netuid, alpha);
         assert_ok!(SubtensorModule::remove_stake(
             RuntimeOrigin::signed(coldkey_account_id),
             hotkey_account_id,
@@ -4087,11 +4094,10 @@ fn test_remove_99_9991_per_cent_stake_removes_all() {
         ));
 
         // Check that all alpha was unstaked and all TAO balance was returned (less fees)
-        fee = fee + fee.max((remove_amount as f64 * 0.00005) as u64);
         assert_abs_diff_eq!(
             SubtensorModule::get_coldkey_balance(&coldkey_account_id),
-            amount - fee,
-            epsilon = 100000,
+            expected_balance,
+            epsilon = 10,
         );
         assert_eq!(
             SubtensorModule::get_total_stake_for_hotkey(&hotkey_account_id),
@@ -4307,15 +4313,14 @@ fn test_unstake_all_alpha_hits_liquidity_min() {
 
         // Try to unstake, but we reduce liquidity too far
 
-        assert_ok!(SubtensorModule::unstake_all_alpha(
-            RuntimeOrigin::signed(coldkey),
-            hotkey,
-        ));
+        assert!(
+            SubtensorModule::unstake_all_alpha(RuntimeOrigin::signed(coldkey), hotkey,).is_err()
+        );
 
         // Expect nothing to be unstaked
         let new_alpha =
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid);
-        assert_abs_diff_eq!(new_alpha, stake_amount, epsilon = 0,);
+        assert_eq!(new_alpha, stake_amount);
     });
 }
 
@@ -4341,16 +4346,15 @@ fn test_unstake_all_alpha_works() {
         );
 
         // Setup the Alpha pool so that removing all the Alpha will keep liq above min
-        let remaining_tao = I96F32::from_num(u64::from(mock::SwapMinimumReserve::get()) - 1)
-            .saturating_add(I96F32::from(10_000_000));
-        let alpha_reserves = I110F18::from(stake_amount + 10_000_000);
-        let alpha = stake_amount;
+        let alpha_reserves = stake_amount + u64::from(mock::SwapMinimumReserve::get());
+        let (tao_reserves, fee) = mock::swap_alpha_to_tao(netuid, alpha_reserves);
+        let fee: u64 = <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid)
+            .saturating_mul(U96F32::from_num(fee))
+            .to_num();
+        let tao_reserves = tao_reserves + fee;
 
-        let k = I110F18::from_fixed(remaining_tao)
-            .saturating_mul(alpha_reserves.saturating_add(I110F18::from(alpha)));
-        let tao_reserves = k.safe_div(alpha_reserves);
-
-        mock::setup_reserves(netuid, tao_reserves.to_num(), alpha_reserves.to_num());
+        mock::setup_reserves(netuid, tao_reserves, alpha_reserves);
+        mock::setup_reserves(0, tao_reserves, alpha_reserves);
 
         // Unstake all alpha to root
         assert_ok!(SubtensorModule::unstake_all_alpha(
@@ -4360,7 +4364,7 @@ fn test_unstake_all_alpha_works() {
 
         let new_alpha =
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid);
-        assert_abs_diff_eq!(new_alpha, 0, epsilon = 1_000,);
+        assert_abs_diff_eq!(new_alpha, 0, epsilon = 1_000);
         let new_root =
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, 0);
         assert!(new_root > 100_000);

From 79bf78fc71fefb02aa4b8e1085c60fc7d51d0e93 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Thu, 8 May 2025 17:38:41 +0200
Subject: [PATCH 133/418] Fix recycle alpha tests

---
 pallets/subtensor/src/tests/epoch.rs         | 375 ++++++++++---------
 pallets/subtensor/src/tests/recycle_alpha.rs |  15 +-
 2 files changed, 201 insertions(+), 189 deletions(-)

diff --git a/pallets/subtensor/src/tests/epoch.rs b/pallets/subtensor/src/tests/epoch.rs
index 7df41a1301..03cedd19de 100644
--- a/pallets/subtensor/src/tests/epoch.rs
+++ b/pallets/subtensor/src/tests/epoch.rs
@@ -4,19 +4,19 @@
     clippy::unwrap_used
 )]
 
-use super::mock::*;
-use crate::epoch::math::safe_exp;
-use crate::*;
+use std::time::Instant;
 
 use approx::assert_abs_diff_eq;
 use frame_support::{assert_err, assert_ok};
-
-// use frame_system::Config;
 use rand::{Rng, SeedableRng, distributions::Uniform, rngs::StdRng, seq::SliceRandom, thread_rng};
 use sp_core::{Get, U256};
-// use sp_runtime::DispatchError;
-use std::time::Instant;
 use substrate_fixed::types::I32F32;
+use subtensor_swap_interface::SwapHandler;
+
+use super::mock;
+use super::mock::*;
+use crate::epoch::math::safe_exp;
+use crate::*;
 
 // Normalizes (sum to 1 except 0) the input vector directly in-place.
 #[allow(dead_code)]
@@ -1507,40 +1507,43 @@ fn test_bonds_with_liquid_alpha() {
 #[test]
 fn test_set_alpha_disabled() {
     new_test_ext(1).execute_with(|| {
-		todo!();
-        // let hotkey = U256::from(1);
-        // let coldkey = U256::from(1 + 456);
-        // let netuid = add_dynamic_network(&hotkey, &coldkey);
-        // let signer = RuntimeOrigin::signed(coldkey);
-
-        // // Enable Liquid Alpha and setup
-        // SubtensorModule::set_liquid_alpha_enabled(netuid, true);
-        // migrations::migrate_create_root_network::migrate_create_root_network::<Test>();
-        // SubtensorModule::add_balance_to_coldkey_account(&coldkey, 1_000_000_000_000_000);
-        // assert_ok!(SubtensorModule::root_register(signer.clone(), hotkey,));
-        // assert_ok!(SubtensorModule::add_stake(
-        //     signer.clone(),
-        //     hotkey,
-        //     netuid,
-        //     DefaultMinStake::<Test>::get() + DefaultStakingFee::<Test>::get()
-        // ));
-        // // Only owner can set alpha values
-        // assert_ok!(SubtensorModule::register_network(signer.clone(), hotkey));
-
-        // // Explicitly set to false
-        // SubtensorModule::set_liquid_alpha_enabled(netuid, false);
-        // assert_err!(
-        //     SubtensorModule::do_set_alpha_values(signer.clone(), netuid, 12_u16, u16::MAX),
-        //     Error::<Test>::LiquidAlphaDisabled
-        // );
-
-        // SubtensorModule::set_liquid_alpha_enabled(netuid, true);
-        // assert_ok!(SubtensorModule::do_set_alpha_values(
-        //     signer.clone(),
-        //     netuid,
-        //     12_u16,
-        //     u16::MAX
-        // ));
+        let hotkey = U256::from(1);
+        let coldkey = U256::from(1 + 456);
+        let netuid = add_dynamic_network(&hotkey, &coldkey);
+        let signer = RuntimeOrigin::signed(coldkey);
+
+        // Enable Liquid Alpha and setup
+        SubtensorModule::set_liquid_alpha_enabled(netuid, true);
+        migrations::migrate_create_root_network::migrate_create_root_network::<Test>();
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, 1_000_000_000_000_000);
+        assert_ok!(SubtensorModule::root_register(signer.clone(), hotkey,));
+        let fee = <Test as pallet::Config>::SwapInterface::approx_fee_amount(
+            netuid,
+            DefaultMinStake::<Test>::get(),
+        );
+        assert_ok!(SubtensorModule::add_stake(
+            signer.clone(),
+            hotkey,
+            netuid,
+            DefaultMinStake::<Test>::get() + fee
+        ));
+        // Only owner can set alpha values
+        assert_ok!(SubtensorModule::register_network(signer.clone(), hotkey));
+
+        // Explicitly set to false
+        SubtensorModule::set_liquid_alpha_enabled(netuid, false);
+        assert_err!(
+            SubtensorModule::do_set_alpha_values(signer.clone(), netuid, 12_u16, u16::MAX),
+            Error::<Test>::LiquidAlphaDisabled
+        );
+
+        SubtensorModule::set_liquid_alpha_enabled(netuid, true);
+        assert_ok!(SubtensorModule::do_set_alpha_values(
+            signer.clone(),
+            netuid,
+            12_u16,
+            u16::MAX
+        ));
     });
 }
 
@@ -2769,150 +2772,152 @@ fn test_compute_ema_bonds_with_liquid_alpha_sparse_empty() {
 #[test]
 fn test_get_set_alpha() {
     new_test_ext(1).execute_with(|| {
-		todo!();
-
-        // let netuid = 1;
-        // let alpha_low: u16 = 12_u16;
-        // let alpha_high: u16 = u16::MAX - 10;
-
-        // let hotkey: U256 = U256::from(1);
-        // let coldkey: U256 = U256::from(1 + 456);
-        // let signer = RuntimeOrigin::signed(coldkey);
-
-        // // Enable Liquid Alpha and setup
-        // SubtensorModule::set_liquid_alpha_enabled(netuid, true);
-        // migrations::migrate_create_root_network::migrate_create_root_network::<Test>();
-        // SubtensorModule::add_balance_to_coldkey_account(&coldkey, 1_000_000_000_000_000);
-        // assert_ok!(SubtensorModule::root_register(signer.clone(), hotkey,));
-
-        // // Should fail as signer does not own the subnet
-        // assert_err!(
-        //     SubtensorModule::do_set_alpha_values(signer.clone(), netuid, alpha_low, alpha_high),
-        //     DispatchError::BadOrigin
-        // );
-
-        // assert_ok!(SubtensorModule::register_network(signer.clone(), hotkey));
-        // assert_ok!(SubtensorModule::add_stake(
-        //     signer.clone(),
-        //     hotkey,
-        //     netuid,
-        //     DefaultMinStake::<Test>::get() + DefaultStakingFee::<Test>::get()
-        // ));
-
-        // assert_ok!(SubtensorModule::do_set_alpha_values(
-        //     signer.clone(),
-        //     netuid,
-        //     alpha_low,
-        //     alpha_high
-        // ));
-        // let (grabbed_alpha_low, grabbed_alpha_high): (u16, u16) =
-        //     SubtensorModule::get_alpha_values(netuid);
-
-        // log::info!(
-        //     "alpha_low: {:?} alpha_high: {:?}",
-        //     grabbed_alpha_low,
-        //     grabbed_alpha_high
-        // );
-        // assert_eq!(grabbed_alpha_low, alpha_low);
-        // assert_eq!(grabbed_alpha_high, alpha_high);
-
-        // // Convert the u16 values to decimal values
-        // fn unnormalize_u16_to_float(normalized_value: u16) -> f32 {
-        //     const MAX_U16: u16 = 65535;
-        //     normalized_value as f32 / MAX_U16 as f32
-        // }
-
-        // let alpha_low_decimal = unnormalize_u16_to_float(alpha_low);
-        // let alpha_high_decimal = unnormalize_u16_to_float(alpha_high);
-
-        // let (alpha_low_32, alpha_high_32) = SubtensorModule::get_alpha_values_32(netuid);
-
-        // let tolerance: f32 = 1e-6; // 0.000001
-
-        // // Check if the values are equal to the sixth decimal
-        // assert!(
-        //     (alpha_low_32.to_num::<f32>() - alpha_low_decimal).abs() < tolerance,
-        //     "alpha_low mismatch: {} != {}",
-        //     alpha_low_32.to_num::<f32>(),
-        //     alpha_low_decimal
-        // );
-        // assert!(
-        //     (alpha_high_32.to_num::<f32>() - alpha_high_decimal).abs() < tolerance,
-        //     "alpha_high mismatch: {} != {}",
-        //     alpha_high_32.to_num::<f32>(),
-        //     alpha_high_decimal
-        // );
-
-        // // 1. Liquid alpha disabled
-        // SubtensorModule::set_liquid_alpha_enabled(netuid, false);
-        // assert_err!(
-        //     SubtensorModule::do_set_alpha_values(signer.clone(), netuid, alpha_low, alpha_high),
-        //     Error::<Test>::LiquidAlphaDisabled
-        // );
-        // // Correct scenario after error
-        // SubtensorModule::set_liquid_alpha_enabled(netuid, true); // Re-enable for further tests
-        // assert_ok!(SubtensorModule::do_set_alpha_values(
-        //     signer.clone(),
-        //     netuid,
-        //     alpha_low,
-        //     alpha_high
-        // ));
-
-        // // 2. Alpha high too low
-        // let alpha_high_too_low = (u16::MAX as u32 * 4 / 5) as u16 - 1; // One less than the minimum acceptable value
-        // assert_err!(
-        //     SubtensorModule::do_set_alpha_values(
-        //         signer.clone(),
-        //         netuid,
-        //         alpha_low,
-        //         alpha_high_too_low
-        //     ),
-        //     Error::<Test>::AlphaHighTooLow
-        // );
-        // // Correct scenario after error
-        // assert_ok!(SubtensorModule::do_set_alpha_values(
-        //     signer.clone(),
-        //     netuid,
-        //     alpha_low,
-        //     alpha_high
-        // ));
-
-        // // 3. Alpha low too low or too high
-        // let alpha_low_too_low = 0_u16;
-        // assert_err!(
-        //     SubtensorModule::do_set_alpha_values(
-        //         signer.clone(),
-        //         netuid,
-        //         alpha_low_too_low,
-        //         alpha_high
-        //     ),
-        //     Error::<Test>::AlphaLowOutOfRange
-        // );
-        // // Correct scenario after error
-        // assert_ok!(SubtensorModule::do_set_alpha_values(
-        //     signer.clone(),
-        //     netuid,
-        //     alpha_low,
-        //     alpha_high
-        // ));
-
-        // let alpha_low_too_high = (u16::MAX as u32 * 4 / 5) as u16 + 1; // One more than the maximum acceptable value
-        // assert_err!(
-        //     SubtensorModule::do_set_alpha_values(
-        //         signer.clone(),
-        //         netuid,
-        //         alpha_low_too_high,
-        //         alpha_high
-        //     ),
-        //     Error::<Test>::AlphaLowOutOfRange
-        // );
-        // // Correct scenario after error
-        // assert_ok!(SubtensorModule::do_set_alpha_values(
-        //     signer.clone(),
-        //     netuid,
-        //     alpha_low,
-        //     alpha_high
-        // ));
+        let netuid = 1;
+        let alpha_low: u16 = 12_u16;
+        let alpha_high: u16 = u16::MAX - 10;
+
+        let hotkey: U256 = U256::from(1);
+        let coldkey: U256 = U256::from(1 + 456);
+        let signer = RuntimeOrigin::signed(coldkey);
+
+        // Enable Liquid Alpha and setup
+        SubtensorModule::set_liquid_alpha_enabled(netuid, true);
+        migrations::migrate_create_root_network::migrate_create_root_network::<Test>();
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, 1_000_000_000_000_000);
+        assert_ok!(SubtensorModule::root_register(signer.clone(), hotkey,));
+
+        // Should fail as signer does not own the subnet
+        assert_err!(
+            SubtensorModule::do_set_alpha_values(signer.clone(), netuid, alpha_low, alpha_high),
+            DispatchError::BadOrigin
+        );
+
+        assert_ok!(SubtensorModule::register_network(signer.clone(), hotkey));
+        let fee = <Test as pallet::Config>::SwapInterface::approx_fee_amount(
+            netuid,
+            DefaultMinStake::<Test>::get(),
+        );
+        assert_ok!(SubtensorModule::add_stake(
+            signer.clone(),
+            hotkey,
+            netuid,
+            DefaultMinStake::<Test>::get() + fee
+        ));
+
+        assert_ok!(SubtensorModule::do_set_alpha_values(
+            signer.clone(),
+            netuid,
+            alpha_low,
+            alpha_high
+        ));
+        let (grabbed_alpha_low, grabbed_alpha_high): (u16, u16) =
+            SubtensorModule::get_alpha_values(netuid);
+
+        log::info!(
+            "alpha_low: {:?} alpha_high: {:?}",
+            grabbed_alpha_low,
+            grabbed_alpha_high
+        );
+        assert_eq!(grabbed_alpha_low, alpha_low);
+        assert_eq!(grabbed_alpha_high, alpha_high);
+
+        // Convert the u16 values to decimal values
+        fn unnormalize_u16_to_float(normalized_value: u16) -> f32 {
+            const MAX_U16: u16 = 65535;
+            normalized_value as f32 / MAX_U16 as f32
+        }
+
+        let alpha_low_decimal = unnormalize_u16_to_float(alpha_low);
+        let alpha_high_decimal = unnormalize_u16_to_float(alpha_high);
+
+        let (alpha_low_32, alpha_high_32) = SubtensorModule::get_alpha_values_32(netuid);
+
+        let tolerance: f32 = 1e-6; // 0.000001
+
+        // Check if the values are equal to the sixth decimal
+        assert!(
+            (alpha_low_32.to_num::<f32>() - alpha_low_decimal).abs() < tolerance,
+            "alpha_low mismatch: {} != {}",
+            alpha_low_32.to_num::<f32>(),
+            alpha_low_decimal
+        );
+        assert!(
+            (alpha_high_32.to_num::<f32>() - alpha_high_decimal).abs() < tolerance,
+            "alpha_high mismatch: {} != {}",
+            alpha_high_32.to_num::<f32>(),
+            alpha_high_decimal
+        );
+
+        // 1. Liquid alpha disabled
+        SubtensorModule::set_liquid_alpha_enabled(netuid, false);
+        assert_err!(
+            SubtensorModule::do_set_alpha_values(signer.clone(), netuid, alpha_low, alpha_high),
+            Error::<Test>::LiquidAlphaDisabled
+        );
+        // Correct scenario after error
+        SubtensorModule::set_liquid_alpha_enabled(netuid, true); // Re-enable for further tests
+        assert_ok!(SubtensorModule::do_set_alpha_values(
+            signer.clone(),
+            netuid,
+            alpha_low,
+            alpha_high
+        ));
+
+        // 2. Alpha high too low
+        let alpha_high_too_low = (u16::MAX as u32 * 4 / 5) as u16 - 1; // One less than the minimum acceptable value
+        assert_err!(
+            SubtensorModule::do_set_alpha_values(
+                signer.clone(),
+                netuid,
+                alpha_low,
+                alpha_high_too_low
+            ),
+            Error::<Test>::AlphaHighTooLow
+        );
+        // Correct scenario after error
+        assert_ok!(SubtensorModule::do_set_alpha_values(
+            signer.clone(),
+            netuid,
+            alpha_low,
+            alpha_high
+        ));
+
+        // 3. Alpha low too low or too high
+        let alpha_low_too_low = 0_u16;
+        assert_err!(
+            SubtensorModule::do_set_alpha_values(
+                signer.clone(),
+                netuid,
+                alpha_low_too_low,
+                alpha_high
+            ),
+            Error::<Test>::AlphaLowOutOfRange
+        );
+        // Correct scenario after error
+        assert_ok!(SubtensorModule::do_set_alpha_values(
+            signer.clone(),
+            netuid,
+            alpha_low,
+            alpha_high
+        ));
+
+        let alpha_low_too_high = (u16::MAX as u32 * 4 / 5) as u16 + 1; // One more than the maximum acceptable value
+        assert_err!(
+            SubtensorModule::do_set_alpha_values(
+                signer.clone(),
+                netuid,
+                alpha_low_too_high,
+                alpha_high
+            ),
+            Error::<Test>::AlphaLowOutOfRange
+        );
+        // Correct scenario after error
+        assert_ok!(SubtensorModule::do_set_alpha_values(
+            signer.clone(),
+            netuid,
+            alpha_low,
+            alpha_high
+        ));
     });
 }
 
diff --git a/pallets/subtensor/src/tests/recycle_alpha.rs b/pallets/subtensor/src/tests/recycle_alpha.rs
index b142e5d3c9..51ab9782ec 100644
--- a/pallets/subtensor/src/tests/recycle_alpha.rs
+++ b/pallets/subtensor/src/tests/recycle_alpha.rs
@@ -1,7 +1,10 @@
 use approx::assert_abs_diff_eq;
 use frame_support::{assert_noop, assert_ok, traits::Currency};
+use serde::de::Expected;
 use sp_core::U256;
+use sp_core::bytes::ExpectedLen;
 
+use super::mock;
 use super::mock::*;
 use crate::*;
 
@@ -82,6 +85,7 @@ fn test_recycle_two_stakers() {
 
         // add stake to coldkey-hotkey pair so we can recycle it
         let stake = 200_000;
+        let (expected_alpha, _) = mock::swap_tao_to_alpha(netuid, stake);
         increase_stake_on_coldkey_hotkey_account(&coldkey, &hotkey, stake, netuid);
 
         // add some stake to other coldkey on same hotkey.
@@ -115,7 +119,7 @@ fn test_recycle_two_stakers() {
                 &other_coldkey,
                 netuid
             ),
-            stake,
+            expected_alpha,
             epsilon = 2
         );
 
@@ -151,6 +155,7 @@ fn test_recycle_staker_is_nominator() {
 
         // add stake to coldkey-hotkey pair so we can recycle it
         let stake = 200_000;
+        let (expected_alpha, _) = mock::swap_tao_to_alpha(netuid, stake);
         increase_stake_on_coldkey_hotkey_account(&coldkey, &hotkey, stake, netuid);
 
         // add some stake to other coldkey on same hotkey.
@@ -189,7 +194,7 @@ fn test_recycle_staker_is_nominator() {
         // Make sure the other coldkey has no change
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid),
-            stake,
+            expected_alpha,
             epsilon = 2
         );
 
@@ -279,6 +284,7 @@ fn test_burn_staker_is_nominator() {
 
         // add stake to coldkey-hotkey pair so we can recycle it
         let stake = 200_000;
+        let (expected_alpha, _) = mock::swap_tao_to_alpha(netuid, stake);
         increase_stake_on_coldkey_hotkey_account(&coldkey, &hotkey, stake, netuid);
 
         // add some stake to other coldkey on same hotkey.
@@ -312,7 +318,7 @@ fn test_burn_staker_is_nominator() {
         // Make sure the other coldkey has no change
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid),
-            stake,
+            expected_alpha,
             epsilon = 2
         );
 
@@ -348,6 +354,7 @@ fn test_burn_two_stakers() {
 
         // add stake to coldkey-hotkey pair so we can recycle it
         let stake = 200_000;
+        let (expected_alpha, _) = mock::swap_tao_to_alpha(netuid, stake);
         increase_stake_on_coldkey_hotkey_account(&coldkey, &hotkey, stake, netuid);
 
         // add some stake to other coldkey on same hotkey.
@@ -381,7 +388,7 @@ fn test_burn_two_stakers() {
                 &other_coldkey,
                 netuid
             ),
-            stake,
+            expected_alpha,
             epsilon = 2
         );
 

From 8509dc623618b8a2be2939eb70a82fc34278358d Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Thu, 8 May 2025 18:10:04 +0200
Subject: [PATCH 134/418] Fix burned registration tests

---
 pallets/subtensor/src/tests/registration.rs | 30 ++++++++++++++++++---
 1 file changed, 26 insertions(+), 4 deletions(-)

diff --git a/pallets/subtensor/src/tests/registration.rs b/pallets/subtensor/src/tests/registration.rs
index 1ae16d95c0..0d71ea98af 100644
--- a/pallets/subtensor/src/tests/registration.rs
+++ b/pallets/subtensor/src/tests/registration.rs
@@ -1,16 +1,18 @@
 #![allow(clippy::unwrap_used)]
 
 use approx::assert_abs_diff_eq;
-use frame_support::traits::Currency;
-
-use super::mock::*;
-use crate::{AxonInfoOf, CustomTransactionError, Error, SubtensorSignedExtension};
 use frame_support::dispatch::{DispatchClass, DispatchInfo, GetDispatchInfo, Pays};
 use frame_support::sp_runtime::{DispatchError, transaction_validity::InvalidTransaction};
+use frame_support::traits::Currency;
 use frame_support::{assert_err, assert_noop, assert_ok};
 use frame_system::Config;
 use sp_core::U256;
 use sp_runtime::traits::{DispatchInfoOf, SignedExtension};
+use subtensor_swap_interface::SwapHandler;
+
+use super::mock;
+use super::mock::*;
+use crate::{AxonInfoOf, CustomTransactionError, Error, SubtensorSignedExtension};
 
 /********************************************
     subscribing::subscribe() tests
@@ -300,6 +302,9 @@ fn test_burned_registration_under_limit() {
         // Set the burn cost
         SubtensorModule::set_burn(netuid, burn_cost);
 
+        let reserve = 1_000_000_000_000;
+        mock::setup_reserves(netuid, reserve, reserve);
+
         add_network(netuid, 13, 0); // Add the network
         // Give it some TAO to the coldkey balance; more than the burn cost
         SubtensorModule::add_balance_to_coldkey_account(&coldkey_account_id, burn_cost + 10_000);
@@ -383,6 +388,9 @@ fn test_burned_registration_rate_allows_burn_adjustment() {
         // Set the burn cost
         SubtensorModule::set_burn(netuid, burn_cost);
 
+        let reserve = 1_000_000_000_000;
+        mock::setup_reserves(netuid, reserve, reserve);
+
         add_network(netuid, 13, 0); // Add the network
         // Give it some TAO to the coldkey balance; more than the burn cost
         SubtensorModule::add_balance_to_coldkey_account(&coldkey_account_id, burn_cost + 10_000);
@@ -429,6 +437,10 @@ fn test_burned_registration_ok() {
         //add network
         SubtensorModule::set_burn(netuid, burn_cost);
         add_network(netuid, tempo, 0);
+
+        let reserve = 1_000_000_000_000;
+        mock::setup_reserves(netuid, reserve, reserve);
+
         // Give it some $$$ in his coldkey balance
         SubtensorModule::add_balance_to_coldkey_account(&coldkey_account_id, 10000);
         // Subscribe and check extrinsic output
@@ -548,6 +560,9 @@ fn test_burn_adjustment() {
             target_registrations_per_interval,
         );
 
+        let reserve = 1_000_000_000_000;
+        mock::setup_reserves(netuid, reserve, reserve);
+
         // Register key 1.
         let hotkey_account_id_1 = U256::from(1);
         let coldkey_account_id_1 = U256::from(1);
@@ -601,6 +616,9 @@ fn test_burn_registration_pruning_scenarios() {
         SubtensorModule::set_target_registrations_per_interval(netuid, max_allowed_uids);
         SubtensorModule::set_immunity_period(netuid, immunity_period);
 
+        let reserve = 1_000_000_000_000;
+        mock::setup_reserves(netuid, reserve, reserve);
+
         add_network(netuid, tempo, 0);
 
         let mint_balance = burn_cost * u64::from(max_allowed_uids) + 1_000_000_000;
@@ -1503,6 +1521,10 @@ fn test_burn_registration_increase_recycled_rao() {
         let _ =
             Balances::deposit_creating(&coldkey_account_id, Balance::from(1_000_000_000_000_u64));
 
+        let reserve = 1_000_000_000_000;
+        mock::setup_reserves(netuid, reserve, reserve);
+        mock::setup_reserves(netuid2, reserve, reserve);
+
         add_network(netuid, 13, 0);
         assert_eq!(SubtensorModule::get_subnetwork_n(netuid), 0);
 

From 84cd46252ab4b22ca7e6d3071f85b4a2fb282c3e Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Thu, 8 May 2025 19:24:11 +0200
Subject: [PATCH 135/418] Fix more tests

---
 pallets/subtensor/src/tests/move_stake.rs   |  1 -
 pallets/subtensor/src/tests/senate.rs       |  1 -
 pallets/subtensor/src/tests/swap_coldkey.rs | 35 ++++++++++++---------
 pallets/subtensor/src/tests/weights.rs      | 15 ++++-----
 4 files changed, 28 insertions(+), 24 deletions(-)

diff --git a/pallets/subtensor/src/tests/move_stake.rs b/pallets/subtensor/src/tests/move_stake.rs
index 0b3bf447b2..4f6ccb6d7f 100644
--- a/pallets/subtensor/src/tests/move_stake.rs
+++ b/pallets/subtensor/src/tests/move_stake.rs
@@ -86,7 +86,6 @@ fn test_do_move_different_subnets() {
         let origin_hotkey = U256::from(2);
         let destination_hotkey = U256::from(3);
         let stake_amount = DefaultMinStake::<Test>::get() * 10;
-        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         mock::setup_reserves(origin_netuid, stake_amount * 100, stake_amount * 100);
         mock::setup_reserves(destination_netuid, stake_amount * 100, stake_amount * 100);
diff --git a/pallets/subtensor/src/tests/senate.rs b/pallets/subtensor/src/tests/senate.rs
index bd1bebf9b3..1efefc6130 100644
--- a/pallets/subtensor/src/tests/senate.rs
+++ b/pallets/subtensor/src/tests/senate.rs
@@ -562,7 +562,6 @@ fn test_senate_not_leave_when_stake_removed() {
         let hotkey_account_id = U256::from(6);
         let burn_cost = 1000;
         let coldkey_account_id = U256::from(667); // Neighbour of the beast, har har
-        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         //add network
         SubtensorModule::set_burn(netuid, burn_cost);
diff --git a/pallets/subtensor/src/tests/swap_coldkey.rs b/pallets/subtensor/src/tests/swap_coldkey.rs
index 76c921469f..3727b9d2af 100644
--- a/pallets/subtensor/src/tests/swap_coldkey.rs
+++ b/pallets/subtensor/src/tests/swap_coldkey.rs
@@ -353,7 +353,6 @@ fn test_swap_with_max_values() {
         let netuid2 = 2u16;
         let stake = 10_000;
         let max_stake = 21_000_000_000_000_000; // 21 Million TAO; max possible balance.
-        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         // Add a network
         add_network(netuid, 1, 0);
@@ -373,7 +372,7 @@ fn test_swap_with_max_values() {
         mock::setup_reserves(netuid2, reserve, reserve);
 
         // Stake to hotkey on each subnet.
-        let (expected_stake_alpha1, fee) = mock::swap_tao_to_alpha(netuid, max_stake);
+        let (_, fee) = mock::swap_tao_to_alpha(netuid2, max_stake);
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(old_coldkey),
             hotkey,
@@ -381,7 +380,7 @@ fn test_swap_with_max_values() {
             max_stake
         ));
 
-        let (expected_stake_alpha2, fee) = mock::swap_tao_to_alpha(netuid2, max_stake);
+        let (_, fee) = mock::swap_tao_to_alpha(netuid2, max_stake);
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(old_coldkey2),
             hotkey2,
@@ -401,21 +400,25 @@ fn test_swap_with_max_values() {
             &mut weight
         ));
 
+        let expected_stake = max_stake - fee;
+
         assert_eq!(
             SubtensorModule::get_total_stake_for_coldkey(&old_coldkey),
             0
         );
-        assert_eq!(
+        assert_abs_diff_eq!(
             SubtensorModule::get_total_stake_for_coldkey(&new_coldkey),
-            expected_stake_alpha1
+            expected_stake,
+            epsilon = expected_stake / 1000
         );
         assert_eq!(
             SubtensorModule::get_total_stake_for_coldkey(&old_coldkey2),
             0
         );
-        assert_eq!(
+        assert_abs_diff_eq!(
             SubtensorModule::get_total_stake_for_coldkey(&new_coldkey2),
-            expected_stake_alpha2
+            expected_stake,
+            epsilon = expected_stake / 1000
         );
     });
 }
@@ -440,7 +443,7 @@ fn test_swap_with_non_existent_new_coldkey() {
 
         // Stake to hotkey.
 
-        let (expected_stake_alpha, fee) = mock::swap_tao_to_alpha(netuid, stake);
+        let (_, fee) = mock::swap_tao_to_alpha(netuid, stake);
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(old_coldkey),
             hotkey,
@@ -459,9 +462,11 @@ fn test_swap_with_non_existent_new_coldkey() {
             SubtensorModule::get_total_stake_for_coldkey(&old_coldkey),
             0
         );
-        assert_eq!(
+        let expected_stake = stake - fee;
+        assert_abs_diff_eq!(
             SubtensorModule::get_total_stake_for_coldkey(&new_coldkey),
-            expected_stake_alpha
+            expected_stake,
+            epsilon = expected_stake / 1000
         );
     });
 }
@@ -571,7 +576,7 @@ fn test_swap_concurrent_modifications() {
         );
         register_ok_neuron(netuid, hotkey, new_coldkey, 1001000);
 
-        let (initial_stake_alpha, fee) = mock::swap_tao_to_alpha(netuid, initial_stake);
+        let (initial_stake_alpha, _) = mock::swap_tao_to_alpha(netuid, initial_stake);
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(new_coldkey),
             hotkey,
@@ -591,7 +596,7 @@ fn test_swap_concurrent_modifications() {
         // Wait some blocks
         step_block(10);
 
-        let (additional_stake_alpha, fee) = mock::swap_tao_to_alpha(netuid, additional_stake);
+        let (additional_stake_alpha, _) = mock::swap_tao_to_alpha(netuid, additional_stake);
 
         // Simulate concurrent stake addition
         assert_ok!(SubtensorModule::add_stake(
@@ -855,7 +860,7 @@ fn test_swap_stake_for_coldkey() {
         mock::setup_reserves(netuid, reserve, reserve);
 
         // Stake to hotkeys
-        let (expected_stake_alpha1, fee) = mock::swap_tao_to_alpha(netuid, stake_amount1);
+        let (expected_stake_alpha1, _) = mock::swap_tao_to_alpha(netuid, stake_amount1);
 
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(old_coldkey),
@@ -864,7 +869,7 @@ fn test_swap_stake_for_coldkey() {
             stake_amount1
         ));
 
-        let (expected_stake_alpha2, fee) = mock::swap_tao_to_alpha(netuid, stake_amount2);
+        let (expected_stake_alpha2, _) = mock::swap_tao_to_alpha(netuid, stake_amount2);
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(old_coldkey),
             hotkey2,
@@ -894,7 +899,7 @@ fn test_swap_stake_for_coldkey() {
         // give new coldkey some balance
         SubtensorModule::add_balance_to_coldkey_account(&new_coldkey, stake_amount3 + 1_000_000);
         // Stake to hotkey1
-        let (expected_stake_alpha3, fee) = mock::swap_tao_to_alpha(netuid, stake_amount3);
+        let (expected_stake_alpha3, _) = mock::swap_tao_to_alpha(netuid, stake_amount3);
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(new_coldkey),
             hotkey1,
diff --git a/pallets/subtensor/src/tests/weights.rs b/pallets/subtensor/src/tests/weights.rs
index 0d5066b181..bb40c6645d 100644
--- a/pallets/subtensor/src/tests/weights.rs
+++ b/pallets/subtensor/src/tests/weights.rs
@@ -1,17 +1,15 @@
 #![allow(clippy::indexing_slicing)]
 
-use super::mock;
-use super::mock::*;
-use crate::coinbase::run_coinbase::WeightsTlockPayload;
-use crate::*;
 use ark_serialize::CanonicalDeserialize;
 use frame_support::{
     assert_err, assert_ok,
     dispatch::{DispatchClass, DispatchResult, GetDispatchInfo, Pays},
 };
+use pallet_drand::types::Pulse;
 use rand_chacha::{ChaCha20Rng, rand_core::SeedableRng};
 use scale_info::prelude::collections::HashMap;
 use sha2::Digest;
+use sp_core::Encode;
 use sp_core::{Get, H256, U256};
 use sp_runtime::{
     BoundedVec, DispatchError,
@@ -19,6 +17,7 @@ use sp_runtime::{
 };
 use sp_std::collections::vec_deque::VecDeque;
 use substrate_fixed::types::I32F32;
+use subtensor_swap_interface::SwapHandler;
 use tle::{
     curves::drand::TinyBLS381,
     ibe::fullident::Identity,
@@ -27,8 +26,10 @@ use tle::{
 };
 use w3f_bls::EngineBLS;
 
-use pallet_drand::types::Pulse;
-use sp_core::Encode;
+use super::mock;
+use super::mock::*;
+use crate::coinbase::run_coinbase::WeightsTlockPayload;
+use crate::*;
 
 /***************************
   pub fn set_weights() tests
@@ -300,7 +301,6 @@ fn test_set_weights_validate() {
         let coldkey = U256::from(0);
         let hotkey: U256 = U256::from(1);
         assert_ne!(hotkey, coldkey);
-        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         let who = hotkey; // The hotkey signs this transaction
 
@@ -341,6 +341,7 @@ fn test_set_weights_validate() {
         );
 
         // Increase the stake to be equal to the minimum
+        let fee = <Test as pallet::Config>::SwapInterface::approx_fee_amount(netuid, min_stake);
         assert_ok!(SubtensorModule::do_add_stake(
             RuntimeOrigin::signed(hotkey),
             hotkey,

From 97324f184854cfd60c5290e8ad681c7e2ce29538 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Thu, 8 May 2025 14:12:03 -0400
Subject: [PATCH 136/418] Add test for tick math

---
 pallets/subtensor/src/tests/epoch.rs      |  4 +--
 pallets/subtensor/src/tests/mock.rs       |  3 +--
 pallets/subtensor/src/tests/move_stake.rs |  4 ---
 pallets/subtensor/src/tests/senate.rs     |  1 -
 pallets/subtensor/src/tests/staking2.rs   |  1 -
 pallets/swap/src/pallet/impls.rs          | 30 ++++++++++++++++-------
 6 files changed, 24 insertions(+), 19 deletions(-)

diff --git a/pallets/subtensor/src/tests/epoch.rs b/pallets/subtensor/src/tests/epoch.rs
index 7df41a1301..800a61054b 100644
--- a/pallets/subtensor/src/tests/epoch.rs
+++ b/pallets/subtensor/src/tests/epoch.rs
@@ -9,11 +9,11 @@ use crate::epoch::math::safe_exp;
 use crate::*;
 
 use approx::assert_abs_diff_eq;
-use frame_support::{assert_err, assert_ok};
+use frame_support::assert_ok;
 
 // use frame_system::Config;
 use rand::{Rng, SeedableRng, distributions::Uniform, rngs::StdRng, seq::SliceRandom, thread_rng};
-use sp_core::{Get, U256};
+use sp_core::U256;
 // use sp_runtime::DispatchError;
 use std::time::Instant;
 use substrate_fixed::types::I32F32;
diff --git a/pallets/subtensor/src/tests/mock.rs b/pallets/subtensor/src/tests/mock.rs
index a0ad52dc50..9bce02b12b 100644
--- a/pallets/subtensor/src/tests/mock.rs
+++ b/pallets/subtensor/src/tests/mock.rs
@@ -21,8 +21,7 @@ use sp_runtime::{
     traits::{BlakeTwo256, IdentityLookup},
 };
 use sp_std::cmp::Ordering;
-use substrate_fixed::types::U64F64;
-use subtensor_swap_interface::{LiquidityDataProvider, OrderType, SwapHandler};
+use subtensor_swap_interface::{OrderType, SwapHandler};
 
 use crate::utils::rate_limiting::TransactionType;
 use crate::*;
diff --git a/pallets/subtensor/src/tests/move_stake.rs b/pallets/subtensor/src/tests/move_stake.rs
index 646c965bc1..5ea57c04fd 100644
--- a/pallets/subtensor/src/tests/move_stake.rs
+++ b/pallets/subtensor/src/tests/move_stake.rs
@@ -85,7 +85,6 @@ fn test_do_move_different_subnets() {
         let origin_hotkey = U256::from(2);
         let destination_hotkey = U256::from(3);
         let stake_amount = DefaultMinStake::<Test>::get() * 10;
-        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         mock::setup_reserves(origin_netuid, stake_amount * 100, stake_amount * 100);
         mock::setup_reserves(destination_netuid, stake_amount * 100, stake_amount * 100);
@@ -153,7 +152,6 @@ fn test_do_move_nonexistent_subnet() {
         let destination_hotkey = U256::from(3);
         let nonexistent_netuid = 99; // Assuming this subnet doesn't exist
         let stake_amount = 1_000_000;
-        let fee = 0;
 
         // Set up initial stake
         SubtensorModule::stake_into_subnet(
@@ -567,7 +565,6 @@ fn test_do_move_wrong_origin() {
         let destination_hotkey = U256::from(3);
         let netuid = 1;
         let stake_amount = DefaultMinStake::<Test>::get() * 10;
-        let fee = 0;
 
         // Set up initial stake
         SubtensorModule::stake_into_subnet(
@@ -807,7 +804,6 @@ fn test_do_move_max_values() {
         let destination_hotkey = U256::from(3);
         let max_stake = u64::MAX;
         let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
-        let fee = 0;
 
         // Set up initial stake with maximum value
         SubtensorModule::create_account_if_non_existent(&coldkey, &origin_hotkey);
diff --git a/pallets/subtensor/src/tests/senate.rs b/pallets/subtensor/src/tests/senate.rs
index bd1bebf9b3..1efefc6130 100644
--- a/pallets/subtensor/src/tests/senate.rs
+++ b/pallets/subtensor/src/tests/senate.rs
@@ -562,7 +562,6 @@ fn test_senate_not_leave_when_stake_removed() {
         let hotkey_account_id = U256::from(6);
         let burn_cost = 1000;
         let coldkey_account_id = U256::from(667); // Neighbour of the beast, har har
-        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         //add network
         SubtensorModule::set_burn(netuid, burn_cost);
diff --git a/pallets/subtensor/src/tests/staking2.rs b/pallets/subtensor/src/tests/staking2.rs
index d77eb1e944..aaf57b2e7b 100644
--- a/pallets/subtensor/src/tests/staking2.rs
+++ b/pallets/subtensor/src/tests/staking2.rs
@@ -4,7 +4,6 @@ use frame_support::{
     weights::Weight,
 };
 use sp_core::U256;
-use substrate_fixed::types::{I96F32, U96F32};
 use subtensor_swap_interface::SwapHandler;
 
 use super::mock;
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 06202261eb..5732e46a70 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -62,8 +62,6 @@ impl<T: Config> SwapStep<T> {
         let possible_delta_in = amount_remaining
             .saturating_sub(Pallet::<T>::calculate_fee_amount(netuid, amount_remaining));
 
-        println!("possible_delta_in = {:?}", possible_delta_in);
-
         // Target price and quantities
         let sqrt_price_target = Pallet::<T>::sqrt_price_target(
             order_type,
@@ -229,9 +227,6 @@ impl<T: Config> SwapStep<T> {
         let total_cost =
             delta_fixed.saturating_mul(u16_max.safe_div(u16_max.saturating_sub(fee_rate)));
 
-        println!("process_swap delta_fixed = {:?}", delta_fixed);
-        println!("process_swap total_cost = {:?}", total_cost);
-
         // Hold the fees
         let fee = Pallet::<T>::calculate_fee_amount(
             self.netuid,
@@ -421,15 +416,11 @@ impl<T: Config> Pallet<T> {
         // Swap one tick at a time until we reach one of the stop conditions
         while amount_remaining > 0 {
             // Create and execute a swap step
-            println!("amount_remaining = {:?}", amount_remaining);
-
             let mut swap_step =
                 SwapStep::<T>::new(netuid, order_type, amount_remaining, sqrt_price_limit);
 
             let swap_result = swap_step.execute()?;
 
-            println!("swap_result = {:?}", swap_result);
-
             in_acc = in_acc.saturating_add(swap_result.delta_in);
             amount_remaining = amount_remaining.saturating_sub(swap_result.amount_to_take);
             amount_paid_out = amount_paid_out.saturating_add(swap_result.delta_out);
@@ -2379,4 +2370,25 @@ mod tests {
             assert!(swap_result.amount_paid_out > 0);
         });
     }
+
+    // cargo test --package pallet-subtensor-swap --lib -- pallet::impls::tests::test_price_tick_price_roundtrip --exact --show-output
+    #[test]
+    fn test_price_tick_price_roundtrip() {
+        new_test_ext().execute_with(|| {
+            let netuid = NetUid::from(1);
+
+            // Setup swap
+            assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
+
+            let current_price = SqrtPrice::from_num(0.50000051219212275465);
+            let tick = TickIndex::try_from_sqrt_price(current_price).unwrap();
+            let round_trip_price = TickIndex::try_to_sqrt_price(&tick).unwrap();
+            assert!(round_trip_price <= current_price);
+
+            let roundtrip_tick = TickIndex::try_from_sqrt_price(round_trip_price).unwrap();
+            assert!(tick == roundtrip_tick);
+        });
+    }
+
+
 }

From ddbcabd803e26651e13b7b10afc5c4ad2d248eaa Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Fri, 9 May 2025 20:20:34 +0200
Subject: [PATCH 137/418] Fix tick index math rounding

---
 pallets/subtensor/src/macros/dispatches.rs |  18 +++-
 pallets/subtensor/src/tests/children.rs    |  14 +--
 pallets/subtensor/src/tests/coinbase.rs    |   4 +-
 pallets/subtensor/src/tests/mock.rs        |   1 -
 pallets/subtensor/src/tests/senate.rs      |   6 +-
 pallets/subtensor/src/tests/swap_hotkey.rs |  12 ++-
 pallets/swap/src/pallet/impls.rs           |  78 ++++++++--------
 pallets/swap/src/pallet/mod.rs             |   4 +-
 pallets/swap/src/position.rs               |   5 +-
 pallets/swap/src/tick.rs                   | 102 +++++++++++++++------
 10 files changed, 155 insertions(+), 89 deletions(-)

diff --git a/pallets/subtensor/src/macros/dispatches.rs b/pallets/subtensor/src/macros/dispatches.rs
index 4a70af6ca3..fcc086eb58 100644
--- a/pallets/subtensor/src/macros/dispatches.rs
+++ b/pallets/subtensor/src/macros/dispatches.rs
@@ -2189,7 +2189,13 @@ mod dispatches {
             );
 
             // Add or remove liquidity
-            let result = T::SwapInterface::modify_position(netuid, &coldkey, &hotkey, position_id, liquidity_delta)?;
+            let result = T::SwapInterface::modify_position(
+                netuid,
+                &coldkey,
+                &hotkey,
+                position_id,
+                liquidity_delta,
+            )?;
 
             if liquidity_delta > 0 {
                 // Remove TAO and Alpha balances or fail transaction if they can't be removed exactly
@@ -2197,9 +2203,15 @@ mod dispatches {
                 ensure!(tao_provided == result.tao, Error::<T>::InsufficientBalance);
 
                 let alpha_provided = Self::decrease_stake_for_hotkey_and_coldkey_on_subnet(
-                    &hotkey, &coldkey, netuid, result.alpha,
+                    &hotkey,
+                    &coldkey,
+                    netuid,
+                    result.alpha,
+                );
+                ensure!(
+                    alpha_provided == result.alpha,
+                    Error::<T>::InsufficientBalance
                 );
-                ensure!(alpha_provided == result.alpha, Error::<T>::InsufficientBalance);
 
                 // Emit an event
                 Self::deposit_event(Event::LiquidityAdded {
diff --git a/pallets/subtensor/src/tests/children.rs b/pallets/subtensor/src/tests/children.rs
index 813a0c2064..d29fd91184 100644
--- a/pallets/subtensor/src/tests/children.rs
+++ b/pallets/subtensor/src/tests/children.rs
@@ -2416,14 +2416,14 @@ fn test_revoke_child_no_min_stake_check() {
         add_network(netuid, 13, 0);
         register_ok_neuron(netuid, parent, coldkey, 0);
 
-		let reserve = 1_000_000_000_000_000;
-		mock::setup_reserves(netuid, reserve, reserve);
-		mock::setup_reserves(root, reserve, reserve);
+        let reserve = 1_000_000_000_000_000;
+        mock::setup_reserves(netuid, reserve, reserve);
+        mock::setup_reserves(root, reserve, reserve);
 
         // Set minimum stake for setting children
         StakeThreshold::<Test>::put(1_000_000_000_000);
 
-		let (_, fee) = mock::swap_tao_to_alpha(root, StakeThreshold::<Test>::get());
+        let (_, fee) = mock::swap_tao_to_alpha(root, StakeThreshold::<Test>::get());
         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
             &parent,
             &coldkey,
@@ -2494,12 +2494,12 @@ fn test_do_set_child_registration_disabled() {
         add_network(netuid, 13, 0);
         register_ok_neuron(netuid, parent, coldkey, 0);
 
-		let reserve = 1_000_000_000_000_000;
-		mock::setup_reserves(netuid, reserve, reserve);
+        let reserve = 1_000_000_000_000_000;
+        mock::setup_reserves(netuid, reserve, reserve);
 
         // Set minimum stake for setting children
         StakeThreshold::<Test>::put(1_000_000_000_000);
-		let (_, fee) = mock::swap_tao_to_alpha(netuid, StakeThreshold::<Test>::get());
+        let (_, fee) = mock::swap_tao_to_alpha(netuid, StakeThreshold::<Test>::get());
         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
             &parent,
             &coldkey,
diff --git a/pallets/subtensor/src/tests/coinbase.rs b/pallets/subtensor/src/tests/coinbase.rs
index f8c405edbd..2636d0f3d8 100644
--- a/pallets/subtensor/src/tests/coinbase.rs
+++ b/pallets/subtensor/src/tests/coinbase.rs
@@ -1980,8 +1980,8 @@ fn test_run_coinbase_not_started() {
         // Set weight-set limit to 0.
         SubtensorModule::set_weights_set_rate_limit(netuid, 0);
 
-		let reserve = init_stake * 1000;
-		mock::setup_reserves(netuid, reserve, reserve);
+        let reserve = init_stake * 1000;
+        mock::setup_reserves(netuid, reserve, reserve);
 
         register_ok_neuron(netuid, hotkey, coldkey, 0);
         register_ok_neuron(netuid, miner_hk, miner_ck, 0);
diff --git a/pallets/subtensor/src/tests/mock.rs b/pallets/subtensor/src/tests/mock.rs
index 9bce02b12b..cc6753b552 100644
--- a/pallets/subtensor/src/tests/mock.rs
+++ b/pallets/subtensor/src/tests/mock.rs
@@ -899,4 +899,3 @@ pub(crate) fn swap_alpha_to_tao(netuid: u16, alpha: u64) -> (u64, u64) {
 
     (result.amount_paid_out, result.fee_paid)
 }
-
diff --git a/pallets/subtensor/src/tests/senate.rs b/pallets/subtensor/src/tests/senate.rs
index 1efefc6130..64eaef266c 100644
--- a/pallets/subtensor/src/tests/senate.rs
+++ b/pallets/subtensor/src/tests/senate.rs
@@ -191,19 +191,19 @@ fn test_senate_vote_works() {
             stake
         ));
 
-		let approx_expected = stake - fee;
+        let approx_expected = stake - fee;
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
                 &hotkey_account_id,
                 &staker_coldkey,
                 netuid
             ),
-			approx_expected,
+            approx_expected,
             epsilon = approx_expected / 1000
         );
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_on_subnet(&hotkey_account_id, netuid),
-			approx_expected,
+            approx_expected,
             epsilon = approx_expected / 1000
         );
 
diff --git a/pallets/subtensor/src/tests/swap_hotkey.rs b/pallets/subtensor/src/tests/swap_hotkey.rs
index 059e489a04..d93ca0c6c3 100644
--- a/pallets/subtensor/src/tests/swap_hotkey.rs
+++ b/pallets/subtensor/src/tests/swap_hotkey.rs
@@ -79,7 +79,7 @@ fn test_swap_total_hotkey_stake() {
 
         // Add stake
         let (expected_alpha, _) = mock::swap_tao_to_alpha(netuid, amount);
-		assert!(expected_alpha > 0);
+        assert!(expected_alpha > 0);
         assert_ok!(SubtensorModule::add_stake(
             RuntimeOrigin::signed(coldkey),
             old_hotkey,
@@ -88,7 +88,10 @@ fn test_swap_total_hotkey_stake() {
         ));
 
         // Check if stake has increased
-        assert_eq!(TotalHotkeyAlpha::<Test>::get(old_hotkey, netuid), expected_alpha);
+        assert_eq!(
+            TotalHotkeyAlpha::<Test>::get(old_hotkey, netuid),
+            expected_alpha
+        );
         assert_abs_diff_eq!(
             SubtensorModule::get_total_stake_for_hotkey(&new_hotkey),
             0,
@@ -109,7 +112,10 @@ fn test_swap_total_hotkey_stake() {
             0,
             epsilon = 1,
         );
-        assert_eq!(TotalHotkeyAlpha::<Test>::get(new_hotkey, netuid), expected_alpha);
+        assert_eq!(
+            TotalHotkeyAlpha::<Test>::get(new_hotkey, netuid),
+            expected_alpha
+        );
     });
 }
 
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index feb8a4bcd8..7ff4bcce76 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -7,7 +7,7 @@ use sp_arithmetic::helpers_128bit;
 use sp_runtime::traits::AccountIdConversion;
 use substrate_fixed::types::{U64F64, U96F32};
 use subtensor_swap_interface::{
-    LiquidityDataProvider, UpdateLiquidityResult, SwapHandler, SwapResult,
+    LiquidityDataProvider, SwapHandler, SwapResult, UpdateLiquidityResult,
 };
 
 use super::pallet::*;
@@ -90,14 +90,14 @@ impl<T: Config> SwapStep<T> {
                     lq = one.safe_div(TickIndex::min_sqrt_price());
                 }
                 lq
-            },
+            }
             OrderType::Buy => {
                 let mut lq = TickIndex::max_sqrt_price().min(sqrt_price_limit.into());
                 if lq < current_price {
                     lq = TickIndex::max_sqrt_price();
                 }
                 lq
-            },
+            }
         };
 
         Self {
@@ -228,10 +228,8 @@ impl<T: Config> SwapStep<T> {
             delta_fixed.saturating_mul(u16_max.safe_div(u16_max.saturating_sub(fee_rate)));
 
         // Hold the fees
-        let fee = Pallet::<T>::calculate_fee_amount(
-            self.netuid,
-            total_cost.saturating_to_num::<u64>(),
-        );
+        let fee =
+            Pallet::<T>::calculate_fee_amount(self.netuid, total_cost.saturating_to_num::<u64>());
         Pallet::<T>::add_fees(self.netuid, self.order_type, fee);
         let delta_out = Pallet::<T>::convert_deltas(self.netuid, self.order_type, self.delta_in);
 
@@ -336,14 +334,11 @@ impl<T: Config> Pallet<T> {
         let epsilon = U64F64::saturating_from_num(0.000001);
 
         let current_sqrt_price = price.checked_sqrt(epsilon).unwrap_or(U64F64::from_num(0));
-        AlphaSqrtPrice::<T>::set(
-            netuid,
-            current_sqrt_price,
-        );
+        AlphaSqrtPrice::<T>::set(netuid, current_sqrt_price);
 
         // Set current tick
         let current_tick = TickIndex::from_sqrt_price_bounded(current_sqrt_price);
-        CurrentTick::<T>::set(netuid, current_tick);        
+        CurrentTick::<T>::set(netuid, current_tick);
 
         // Set initial (protocol owned) liquidity and positions
         // Protocol liquidity makes one position from TickIndex::MIN to TickIndex::MAX
@@ -1174,8 +1169,14 @@ impl<T: Config> SwapHandler<T::AccountId> for Pallet<T> {
         position_id: u128,
         liquidity_delta: i64,
     ) -> Result<UpdateLiquidityResult, DispatchError> {
-        Self::modify_position(netuid.into(), coldkey_account_id, hotkey_account_id, position_id.into(), liquidity_delta)
-            .map_err(Into::into)
+        Self::modify_position(
+            netuid.into(),
+            coldkey_account_id,
+            hotkey_account_id,
+            position_id.into(),
+            liquidity_delta,
+        )
+        .map_err(Into::into)
     }
 
     fn approx_fee_amount(netuid: u16, amount: u64) -> u64 {
@@ -1298,7 +1299,7 @@ mod tests {
             assert_eq!(sqrt_price, expected_sqrt_price);
 
             // Verify that current tick is set
-            let current_tick = CurrentTick::<Test>::get(netuid);            
+            let current_tick = CurrentTick::<Test>::get(netuid);
             let expected_current_tick = TickIndex::from_sqrt_price_bounded(expected_sqrt_price);
             assert_eq!(current_tick, expected_current_tick);
 
@@ -1729,15 +1730,14 @@ mod tests {
 
                 // Modify liquidity (also causes claiming of fees)
                 let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
-                let modify_result =
-                    Pallet::<Test>::modify_position(
-                        netuid,
-                        &OK_COLDKEY_ACCOUNT_ID,
-                        &OK_HOTKEY_ACCOUNT_ID,
-                        position_id,
-                        -1_i64 * ((liquidity / 10) as i64),
-                    )
-                    .unwrap();
+                let modify_result = Pallet::<Test>::modify_position(
+                    netuid,
+                    &OK_COLDKEY_ACCOUNT_ID,
+                    &OK_HOTKEY_ACCOUNT_ID,
+                    position_id,
+                    -1_i64 * ((liquidity / 10) as i64),
+                )
+                .unwrap();
                 assert_abs_diff_eq!(modify_result.alpha, alpha / 10, epsilon = alpha / 1000);
                 assert!(modify_result.fee_tao > 0);
                 assert_eq!(modify_result.fee_alpha, 0);
@@ -1753,22 +1753,20 @@ mod tests {
 
                 // Position liquidity is reduced
                 let position =
-                    Positions::<Test>::get(&(netuid, OK_COLDKEY_ACCOUNT_ID, position_id))
-                        .unwrap();
+                    Positions::<Test>::get(&(netuid, OK_COLDKEY_ACCOUNT_ID, position_id)).unwrap();
                 assert_eq!(position.liquidity, liquidity * 9 / 10);
                 assert_eq!(position.tick_low, tick_low);
                 assert_eq!(position.tick_high, tick_high);
 
                 // Modify liquidity again (ensure fees aren't double-collected)
-                let modify_result =
-                    Pallet::<Test>::modify_position(
-                        netuid,
-                        &OK_COLDKEY_ACCOUNT_ID,
-                        &OK_HOTKEY_ACCOUNT_ID,
-                        position_id,
-                        -1_i64 * ((liquidity / 100) as i64),
-                    )
-                    .unwrap();
+                let modify_result = Pallet::<Test>::modify_position(
+                    netuid,
+                    &OK_COLDKEY_ACCOUNT_ID,
+                    &OK_HOTKEY_ACCOUNT_ID,
+                    position_id,
+                    -1_i64 * ((liquidity / 100) as i64),
+                )
+                .unwrap();
 
                 assert_abs_diff_eq!(modify_result.alpha, alpha / 100, epsilon = alpha / 1000);
                 assert_eq!(modify_result.fee_tao, 0);
@@ -1913,9 +1911,10 @@ mod tests {
                     }
 
                     // Assert that current tick is updated
-                    let current_tick = CurrentTick::<Test>::get(netuid);            
-                    let expected_current_tick = TickIndex::from_sqrt_price_bounded(sqrt_current_price_after);
-                    assert_eq!(current_tick, expected_current_tick);                    
+                    let current_tick = CurrentTick::<Test>::get(netuid);
+                    let expected_current_tick =
+                        TickIndex::from_sqrt_price_bounded(sqrt_current_price_after);
+                    assert_eq!(current_tick, expected_current_tick);
                 },
             );
         });
@@ -2390,6 +2389,7 @@ mod tests {
 
             let current_price = SqrtPrice::from_num(0.50000051219212275465);
             let tick = TickIndex::try_from_sqrt_price(current_price).unwrap();
+
             let round_trip_price = TickIndex::try_to_sqrt_price(&tick).unwrap();
             assert!(round_trip_price <= current_price);
 
@@ -2397,6 +2397,4 @@ mod tests {
             assert!(tick == roundtrip_tick);
         });
     }
-
-
 }
diff --git a/pallets/swap/src/pallet/mod.rs b/pallets/swap/src/pallet/mod.rs
index 46ad895e9d..3a44cb4601 100644
--- a/pallets/swap/src/pallet/mod.rs
+++ b/pallets/swap/src/pallet/mod.rs
@@ -170,8 +170,8 @@ mod pallet {
         /// Provided liquidity parameter is invalid (likely too small)
         InvalidLiquidityValue,
 
-		/// Reserves too low for operation.
-		ReservesTooLow,
+        /// Reserves too low for operation.
+        ReservesTooLow,
     }
 
     #[pallet::call]
diff --git a/pallets/swap/src/position.rs b/pallets/swap/src/position.rs
index 4039e9f191..8f1ef69d4d 100644
--- a/pallets/swap/src/position.rs
+++ b/pallets/swap/src/position.rs
@@ -107,7 +107,10 @@ impl Position {
         fee_tao = liquidity_frac.saturating_mul(fee_tao);
         fee_alpha = liquidity_frac.saturating_mul(fee_alpha);
 
-        (fee_tao.saturating_to_num::<u64>(), fee_alpha.saturating_to_num::<u64>())
+        (
+            fee_tao.saturating_to_num::<u64>(),
+            fee_alpha.saturating_to_num::<u64>(),
+        )
     }
 
     /// Get fees in a position's range
diff --git a/pallets/swap/src/tick.rs b/pallets/swap/src/tick.rs
index 7c4d9b22cb..2526914711 100644
--- a/pallets/swap/src/tick.rs
+++ b/pallets/swap/src/tick.rs
@@ -5,7 +5,7 @@ use core::fmt;
 use core::hash::Hash;
 use core::ops::{Add, AddAssign, BitOr, Deref, Neg, Shl, Shr, Sub, SubAssign};
 
-use alloy_primitives::{I256, U256};
+use alloy_primitives::{I256, U256, uint};
 use codec::{Decode, Encode, MaxEncodedLen};
 use frame_support::pallet_prelude::*;
 use safe_math::*;
@@ -443,17 +443,25 @@ impl TickIndex {
     /// tick index matches the price by the following inequality:
     ///    sqrt_lower_price <= sqrt_price < sqrt_higher_price
     pub fn try_from_sqrt_price(sqrt_price: SqrtPrice) -> Result<Self, TickMathError> {
-        let tick = get_tick_at_sqrt_ratio(u64f64_to_u256_q64_96(sqrt_price))?;
+        // price in the native Q64.96 integer format
+        let price_x96 = u64f64_to_u256_q64_96(sqrt_price);
 
-        // Correct for rounding error during conversions between different fixed-point formats
-        if tick == 0 {
-            Ok(Self(tick))
+        // first‑pass estimate from the log calculation
+        let mut tick = get_tick_at_sqrt_ratio(price_x96)?;
+
+        // post‑verification, *both* directions
+        let price_at_tick = get_sqrt_ratio_at_tick(tick)?;
+        if price_at_tick > price_x96 {
+            tick -= 1; // estimate was too high
         } else {
-            match (tick + 1).into_tick_index() {
-                Ok(incremented) => Ok(incremented),
-                Err(e) => Err(e),
+            // it may still be one too low
+            let price_at_tick_plus = get_sqrt_ratio_at_tick(tick + 1)?;
+            if price_at_tick_plus <= price_x96 {
+                tick += 1; // step up when required
             }
         }
+
+        tick.into_tick_index()
     }
 }
 
@@ -905,12 +913,13 @@ fn get_sqrt_ratio_at_tick(tick: i32) -> Result<U256, TickMathError> {
         ratio = U256::MAX / ratio;
     }
 
-    Ok((ratio >> 32)
-        + if (ratio.wrapping_rem(U256_1 << 32)).is_zero() {
-            U256::ZERO
-        } else {
-            U256_1
-        })
+    let shifted = ratio >> 32;
+    let ceil = if ratio & U256::from((1u128 << 32) - 1) != U256::ZERO {
+        shifted + U256_1
+    } else {
+        shifted
+    };
+    Ok(ceil)
 }
 
 fn get_tick_at_sqrt_ratio(sqrt_price_x_96: U256) -> Result<i32, TickMathError> {
@@ -1025,7 +1034,7 @@ fn get_tick_at_sqrt_ratio(sqrt_price_x_96: U256) -> Result<i32, TickMathError> {
 /// * `value` - The U256 value in Q64.96 format
 ///
 /// # Returns
-/// * `Result<U64F64, &'static str>` - Converted value or error if too large
+/// * `Result<U64F64, TickMathError>` - Converted value or error if too large
 fn u256_to_u64f64(value: U256, source_fractional_bits: u32) -> Result<U64F64, TickMathError> {
     if value > U256::from(u128::MAX) {
         return Err(TickMathError::ConversionError);
@@ -1049,6 +1058,11 @@ fn u256_to_u64f64(value: U256, source_fractional_bits: u32) -> Result<U64F64, Ti
     Ok(U64F64::from_bits(value))
 }
 
+// Convert U64F64 to U256 in Q64.96 format (Uniswap's sqrt price format)
+fn u64f64_to_u256_q64_96(value: U64F64) -> U256 {
+    u64f64_to_u256(value, 96)
+}
+
 /// Convert U64F64 to U256
 ///
 /// # Arguments
@@ -1075,12 +1089,32 @@ fn u64f64_to_u256(value: U64F64, target_fractional_bits: u32) -> U256 {
 
 /// Convert U256 in Q64.96 format (Uniswap's sqrt price format) to U64F64
 fn u256_q64_96_to_u64f64(value: U256) -> Result<U64F64, TickMathError> {
-    u256_to_u64f64(value, 96)
+    q_to_u64f64(value, 96)
 }
 
-/// Convert U64F64 to U256 in Q64.96 format (Uniswap's sqrt price format)
-fn u64f64_to_u256_q64_96(value: U64F64) -> U256 {
-    u64f64_to_u256(value, 96)
+fn q_to_u64f64(x: U256, frac_bits: u32) -> Result<U64F64, TickMathError> {
+    let diff = frac_bits.checked_sub(64).unwrap_or(0);
+
+    // 1. shift right diff bits
+    let shifted = if diff != 0 { x >> diff } else { x };
+
+    // 2. **round up** if we threw away any 1‑bits
+    let mask = if diff != 0 {
+        (U256_1 << diff) - U256_1
+    } else {
+        U256::ZERO
+    };
+    let rounded = if diff != 0 && (x & mask) != U256::ZERO {
+        shifted + U256_1
+    } else {
+        shifted
+    };
+
+    // 3. check that it fits in 128 bits and transmute
+    if (rounded >> 128) != U256::ZERO {
+        return Err(TickMathError::Overflow);
+    }
+    Ok(U64F64::from_bits(rounded.to::<u128>()))
 }
 
 #[derive(Debug, PartialEq, Eq)]
@@ -1110,6 +1144,7 @@ impl Error for TickMathError {}
 mod tests {
     use std::{ops::Sub, str::FromStr};
 
+    use approx::assert_abs_diff_eq;
     use safe_math::FixedExt;
 
     use super::*;
@@ -1361,18 +1396,31 @@ mod tests {
         assert_eq!(tick_index, TickIndex::new_unchecked(0));
 
         // Test with sqrt price equal to tick_spacing_tao (should be tick index 2)
-        let tick_index = TickIndex::try_from_sqrt_price(tick_spacing).unwrap();
-        assert_eq!(tick_index, TickIndex::new_unchecked(2));
+        let epsilon = SqrtPrice::from_num(0.0000000000000001);
+        assert!(
+            TickIndex::new_unchecked(2)
+                .to_sqrt_price_bounded()
+                .abs_diff(tick_spacing)
+                < epsilon
+        );
 
         // Test with sqrt price equal to tick_spacing_tao^2 (should be tick index 4)
         let sqrt_price = tick_spacing * tick_spacing;
-        let tick_index = TickIndex::try_from_sqrt_price(sqrt_price).unwrap();
-        assert_eq!(tick_index, TickIndex::new_unchecked(4));
+        assert!(
+            TickIndex::new_unchecked(4)
+                .to_sqrt_price_bounded()
+                .abs_diff(sqrt_price)
+                < epsilon
+        );
 
         // Test with sqrt price equal to tick_spacing_tao^5 (should be tick index 10)
         let sqrt_price = tick_spacing.checked_pow(5).unwrap();
-        let tick_index = TickIndex::try_from_sqrt_price(sqrt_price).unwrap();
-        assert_eq!(tick_index, TickIndex::new_unchecked(10));
+        assert!(
+            TickIndex::new_unchecked(10)
+                .to_sqrt_price_bounded()
+                .abs_diff(sqrt_price)
+                < epsilon
+        );
     }
 
     #[test]
@@ -1392,9 +1440,9 @@ mod tests {
             1000,
             TickIndex::MAX.get(),
         ]
-        .iter()
+        .into_iter()
         {
-            let tick_index = TickIndex(*i32_value);
+            let tick_index = TickIndex::new_unchecked(i32_value);
             let sqrt_price = tick_index.try_to_sqrt_price().unwrap();
             let round_trip_tick_index = TickIndex::try_from_sqrt_price(sqrt_price).unwrap();
             assert_eq!(round_trip_tick_index, tick_index);

From 41df934e1c0365c95eaf5385a20ec5bfe4f7ddf5 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Fri, 9 May 2025 17:24:21 -0400
Subject: [PATCH 138/418] Fix get_total_stake_for_hotkey

---
 pallets/subtensor/src/staking/helpers.rs     | 24 +++++++-------------
 pallets/subtensor/src/tests/epoch.rs         |  1 -
 pallets/subtensor/src/tests/recycle_alpha.rs |  2 --
 pallets/subtensor/src/tests/registration.rs  |  1 -
 pallets/swap/src/tick.rs                     |  2 +-
 5 files changed, 9 insertions(+), 21 deletions(-)

diff --git a/pallets/subtensor/src/staking/helpers.rs b/pallets/subtensor/src/staking/helpers.rs
index e875228a06..539ade078f 100644
--- a/pallets/subtensor/src/staking/helpers.rs
+++ b/pallets/subtensor/src/staking/helpers.rs
@@ -47,23 +47,15 @@ impl<T: Config> Pallet<T> {
         Self::get_all_subnet_netuids()
             .into_iter()
             .map(|netuid| {
-                let alpha = Self::get_stake_for_hotkey_on_subnet(hotkey, netuid);
-                T::SwapInterface::swap(
-                    netuid,
-                    OrderType::Sell,
-                    alpha,
-                    T::SwapInterface::max_price(),
-                    true,
-                )
-                .map(|r| {
-                    let fee: u64 = U96F32::saturating_from_num(r.fee_paid)
-                        .saturating_mul(T::SwapInterface::current_alpha_price(netuid))
-                        .saturating_to_num();
-                    r.amount_paid_out.saturating_add(fee)
-                })
-                .unwrap_or_default()
+                let alpha = U96F32::saturating_from_num(Self::get_stake_for_hotkey_on_subnet(
+                    hotkey, netuid,
+                ));
+                let alpha_price =
+                    U96F32::saturating_from_num(T::SwapInterface::current_alpha_price(netuid));
+                alpha.saturating_mul(alpha_price)
             })
-            .sum()
+            .sum::<U96F32>()
+            .saturating_to_num::<u64>()
     }
 
     // Returns the total amount of stake under a coldkey
diff --git a/pallets/subtensor/src/tests/epoch.rs b/pallets/subtensor/src/tests/epoch.rs
index 03cedd19de..b6ddefdef1 100644
--- a/pallets/subtensor/src/tests/epoch.rs
+++ b/pallets/subtensor/src/tests/epoch.rs
@@ -13,7 +13,6 @@ use sp_core::{Get, U256};
 use substrate_fixed::types::I32F32;
 use subtensor_swap_interface::SwapHandler;
 
-use super::mock;
 use super::mock::*;
 use crate::epoch::math::safe_exp;
 use crate::*;
diff --git a/pallets/subtensor/src/tests/recycle_alpha.rs b/pallets/subtensor/src/tests/recycle_alpha.rs
index 51ab9782ec..6621074c6a 100644
--- a/pallets/subtensor/src/tests/recycle_alpha.rs
+++ b/pallets/subtensor/src/tests/recycle_alpha.rs
@@ -1,8 +1,6 @@
 use approx::assert_abs_diff_eq;
 use frame_support::{assert_noop, assert_ok, traits::Currency};
-use serde::de::Expected;
 use sp_core::U256;
-use sp_core::bytes::ExpectedLen;
 
 use super::mock;
 use super::mock::*;
diff --git a/pallets/subtensor/src/tests/registration.rs b/pallets/subtensor/src/tests/registration.rs
index 0d71ea98af..5ce1b6b148 100644
--- a/pallets/subtensor/src/tests/registration.rs
+++ b/pallets/subtensor/src/tests/registration.rs
@@ -8,7 +8,6 @@ use frame_support::{assert_err, assert_noop, assert_ok};
 use frame_system::Config;
 use sp_core::U256;
 use sp_runtime::traits::{DispatchInfoOf, SignedExtension};
-use subtensor_swap_interface::SwapHandler;
 
 use super::mock;
 use super::mock::*;
diff --git a/pallets/swap/src/tick.rs b/pallets/swap/src/tick.rs
index 2526914711..6892cc8444 100644
--- a/pallets/swap/src/tick.rs
+++ b/pallets/swap/src/tick.rs
@@ -5,7 +5,7 @@ use core::fmt;
 use core::hash::Hash;
 use core::ops::{Add, AddAssign, BitOr, Deref, Neg, Shl, Shr, Sub, SubAssign};
 
-use alloy_primitives::{I256, U256, uint};
+use alloy_primitives::{I256, U256};
 use codec::{Decode, Encode, MaxEncodedLen};
 use frame_support::pallet_prelude::*;
 use safe_math::*;

From 491949537d62c55fd19da7bad4a51be5a1faebef Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Mon, 12 May 2025 17:35:29 +0800
Subject: [PATCH 139/418] fix typo

---
 pallets/subtensor/src/rpc_info/metagraph.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pallets/subtensor/src/rpc_info/metagraph.rs b/pallets/subtensor/src/rpc_info/metagraph.rs
index 52c2790d1a..8238e972f1 100644
--- a/pallets/subtensor/src/rpc_info/metagraph.rs
+++ b/pallets/subtensor/src/rpc_info/metagraph.rs
@@ -806,7 +806,7 @@ impl<T: Config> Pallet<T> {
             None
         } else {
             if validator_only {
-                return Some(Self::get_valiators(netuid));
+                return Some(Self::get_validators(netuid));
             }
             let mut result = SelectiveMetagraph::default();
             for index in metagraph_indexes.iter() {
@@ -1377,7 +1377,7 @@ impl<T: Config> Pallet<T> {
         }
     }
 
-    fn get_valiators(netuid: u16) -> SelectiveMetagraph<T::AccountId> {
+    fn get_validators(netuid: u16) -> SelectiveMetagraph<T::AccountId> {
         let stake_threshold = Self::get_stake_threshold();
         let hotkeys: Vec<(u16, T::AccountId)> =
             <Keys<T> as IterableStorageDoubleMap<u16, u16, T::AccountId>>::iter_prefix(netuid)

From a5251770fc408813173c82d5db4977ddb367b212 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Mon, 12 May 2025 16:54:34 -0400
Subject: [PATCH 140/418] Remove refund field from swap step

---
 pallets/swap-interface/src/lib.rs |  1 -
 pallets/swap/src/pallet/impls.rs  | 28 +++++++++++-----------------
 2 files changed, 11 insertions(+), 18 deletions(-)

diff --git a/pallets/swap-interface/src/lib.rs b/pallets/swap-interface/src/lib.rs
index 4ea291cea3..264219e17f 100644
--- a/pallets/swap-interface/src/lib.rs
+++ b/pallets/swap-interface/src/lib.rs
@@ -47,7 +47,6 @@ pub trait SwapHandler<AccountId> {
 pub struct SwapResult {
     pub amount_paid_out: u64,
     pub fee_paid: u64,
-    pub refund: u64,
     // calculated new tao/alpha reserves
     pub new_tao_reserve: u64,
     pub new_alpha_reserve: u64,
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 7ff4bcce76..1b5fccda7c 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -40,7 +40,7 @@ struct SwapStep<T: frame_system::Config> {
     action: SwapStepAction,
     delta_in: u64,
     final_price: SqrtPrice,
-    stop_and_refund: bool,
+    stop: bool,
 
     // Phantom data to use T
     _phantom: PhantomData<T>,
@@ -115,7 +115,7 @@ impl<T: Config> SwapStep<T> {
             action: SwapStepAction::StopIn,
             delta_in: 0,
             final_price: sqrt_price_target,
-            stop_and_refund: false,
+            stop: false,
             _phantom: PhantomData,
         }
     }
@@ -130,15 +130,12 @@ impl<T: Config> SwapStep<T> {
     fn determine_action(&mut self) {
         // Case 1: target_quantity < edge_quantity
         if self.target_quantity < self.edge_quantity {
+            self.action = SwapStepAction::StopIn;
             if self.target_quantity <= self.lim_quantity {
-                // Stop at target price (no refund needed)
-                self.action = SwapStepAction::StopIn;
                 self.delta_in = self.possible_delta_in;
                 self.final_price = self.sqrt_price_target;
-                self.stop_and_refund = false;
+                self.stop = false;
             } else {
-                // Stop at limit price (refund needed)
-                self.action = SwapStepAction::StopIn;
                 self.delta_in = Self::delta_in(
                     self.order_type,
                     self.current_liquidity,
@@ -146,7 +143,7 @@ impl<T: Config> SwapStep<T> {
                     self.sqrt_price_limit,
                 );
                 self.final_price = self.sqrt_price_limit;
-                self.stop_and_refund = true;
+                self.stop = true;
             }
         }
         // Case 2: target_quantity > edge_quantity
@@ -161,7 +158,7 @@ impl<T: Config> SwapStep<T> {
                     self.sqrt_price_edge,
                 );
                 self.final_price = self.sqrt_price_edge;
-                self.stop_and_refund = false;
+                self.stop = false;
             } else if self.edge_quantity > self.lim_quantity {
                 // Stop at limit price (refund needed)
                 self.action = SwapStepAction::StopIn;
@@ -172,7 +169,7 @@ impl<T: Config> SwapStep<T> {
                     self.sqrt_price_limit,
                 );
                 self.final_price = self.sqrt_price_limit;
-                self.stop_and_refund = true;
+                self.stop = true;
             } else {
                 // Stop on edge (refund needed)
                 self.action = SwapStepAction::StopOn;
@@ -183,7 +180,7 @@ impl<T: Config> SwapStep<T> {
                     self.sqrt_price_edge,
                 );
                 self.final_price = self.sqrt_price_edge;
-                self.stop_and_refund = true;
+                self.stop = true;
             }
         }
         // Case 3: target_quantity = edge_quantity
@@ -202,7 +199,7 @@ impl<T: Config> SwapStep<T> {
                 } else {
                     SwapStepAction::Crossing
                 };
-                self.stop_and_refund = false;
+                self.stop = false;
             } else {
                 // Stop at limit price (refund needed)
                 self.action = SwapStepAction::StopIn;
@@ -213,7 +210,7 @@ impl<T: Config> SwapStep<T> {
                     self.sqrt_price_limit,
                 );
                 self.final_price = self.sqrt_price_limit;
-                self.stop_and_refund = true;
+                self.stop = true;
             }
         }
     }
@@ -404,7 +401,6 @@ impl<T: Config> Pallet<T> {
 
         let mut amount_remaining = amount;
         let mut amount_paid_out: u64 = 0;
-        let mut refund: u64 = 0;
         let mut iteration_counter: u16 = 0;
         let mut in_acc: u64 = 0;
 
@@ -420,8 +416,7 @@ impl<T: Config> Pallet<T> {
             amount_remaining = amount_remaining.saturating_sub(swap_result.amount_to_take);
             amount_paid_out = amount_paid_out.saturating_add(swap_result.delta_out);
 
-            if swap_step.stop_and_refund {
-                refund = amount_remaining;
+            if swap_step.stop {
                 amount_remaining = 0;
             }
 
@@ -467,7 +462,6 @@ impl<T: Config> Pallet<T> {
         Ok(SwapResult {
             amount_paid_out,
             fee_paid,
-            refund,
             new_tao_reserve,
             new_alpha_reserve,
         })

From 896a1392961e58eb1a9057c02cd668c09b5f668d Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Tue, 13 May 2025 21:09:12 +0800
Subject: [PATCH 141/418] bump version

---
 runtime/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index d348b97fbc..9b644c3b8d 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -209,7 +209,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
     //   `spec_version`, and `authoring_version` are the same between Wasm and native.
     // This value is set to 100 to notify Polkadot-JS App (https://polkadot.js.org/apps) to use
     //   the compatible custom types.
-    spec_version: 267,
+    spec_version: 268,
     impl_version: 1,
     apis: RUNTIME_API_VERSIONS,
     transaction_version: 1,

From 04d07f8c7d25faaf8be611d0843936d075c0115a Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Tue, 13 May 2025 21:24:02 +0800
Subject: [PATCH 142/418] bump runtime version

---
 runtime/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index 9b644c3b8d..dfcbeedae7 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -209,7 +209,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
     //   `spec_version`, and `authoring_version` are the same between Wasm and native.
     // This value is set to 100 to notify Polkadot-JS App (https://polkadot.js.org/apps) to use
     //   the compatible custom types.
-    spec_version: 268,
+    spec_version: 269,
     impl_version: 1,
     apis: RUNTIME_API_VERSIONS,
     transaction_version: 1,

From 1e10cb7e51cc7fbbef8d2f6fabb881237b1c623b Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Tue, 13 May 2025 10:43:01 -0400
Subject: [PATCH 143/418] Fix price edge issues in swap tests

---
 pallets/swap/src/pallet/impls.rs | 230 +++++++++++++------------------
 pallets/swap/src/tick.rs         |   2 -
 2 files changed, 92 insertions(+), 140 deletions(-)

diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 1b5fccda7c..5568731561 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -40,7 +40,6 @@ struct SwapStep<T: frame_system::Config> {
     action: SwapStepAction,
     delta_in: u64,
     final_price: SqrtPrice,
-    stop: bool,
 
     // Phantom data to use T
     _phantom: PhantomData<T>,
@@ -112,10 +111,9 @@ impl<T: Config> SwapStep<T> {
             target_quantity,
             edge_quantity,
             lim_quantity,
-            action: SwapStepAction::StopIn,
+            action: SwapStepAction::Stop,
             delta_in: 0,
             final_price: sqrt_price_target,
-            stop: false,
             _phantom: PhantomData,
         }
     }
@@ -128,90 +126,47 @@ impl<T: Config> SwapStep<T> {
 
     /// Determine the appropriate action for this swap step
     fn determine_action(&mut self) {
-        // Case 1: target_quantity < edge_quantity
-        if self.target_quantity < self.edge_quantity {
-            self.action = SwapStepAction::StopIn;
-            if self.target_quantity <= self.lim_quantity {
-                self.delta_in = self.possible_delta_in;
-                self.final_price = self.sqrt_price_target;
-                self.stop = false;
-            } else {
-                self.delta_in = Self::delta_in(
-                    self.order_type,
-                    self.current_liquidity,
-                    self.current_price,
-                    self.sqrt_price_limit,
-                );
-                self.final_price = self.sqrt_price_limit;
-                self.stop = true;
-            }
-        }
-        // Case 2: target_quantity > edge_quantity
-        else if self.target_quantity > self.edge_quantity {
-            if self.edge_quantity < self.lim_quantity {
-                // Cross at edge price
-                self.action = SwapStepAction::Crossing;
-                self.delta_in = Self::delta_in(
-                    self.order_type,
-                    self.current_liquidity,
-                    self.current_price,
-                    self.sqrt_price_edge,
-                );
-                self.final_price = self.sqrt_price_edge;
-                self.stop = false;
-            } else if self.edge_quantity > self.lim_quantity {
-                // Stop at limit price (refund needed)
-                self.action = SwapStepAction::StopIn;
-                self.delta_in = Self::delta_in(
-                    self.order_type,
-                    self.current_liquidity,
-                    self.current_price,
-                    self.sqrt_price_limit,
-                );
-                self.final_price = self.sqrt_price_limit;
-                self.stop = true;
-            } else {
-                // Stop on edge (refund needed)
-                self.action = SwapStepAction::StopOn;
-                self.delta_in = Self::delta_in(
-                    self.order_type,
-                    self.current_liquidity,
-                    self.current_price,
-                    self.sqrt_price_edge,
-                );
-                self.final_price = self.sqrt_price_edge;
-                self.stop = true;
-            }
+        // Calculate the stopping price: The price at which we either reach the limit price, 
+        // exchange the full amount, or reach the edge price.
+
+        if (self.target_quantity <= self.lim_quantity) && (self.target_quantity <= self.edge_quantity) {
+            // Case 1. target_quantity is the lowest
+            // The trade completely happens within one tick, no tick crossing happens.
+            self.action = SwapStepAction::Stop;
+            self.final_price = self.sqrt_price_target;
+            self.delta_in = self.possible_delta_in;
+        } else if (self.lim_quantity <= self.target_quantity) && (self.lim_quantity <= self.edge_quantity) {
+            // Case 2. lim_quantity is the lowest
+            // The trade also completely happens within one tick, no tick crossing happens.
+            self.action = SwapStepAction::Stop;
+            self.final_price = self.sqrt_price_limit;
+            self.delta_in = Self::delta_in(
+                self.order_type,
+                self.current_liquidity,
+                self.current_price,
+                self.sqrt_price_limit,
+            );
+        } else if (self.edge_quantity <= self.target_quantity) && (self.edge_quantity <= self.lim_quantity) {
+            // Case 3. edge_quantity is the lowest
+            // Tick crossing is likely
+            self.action = SwapStepAction::Crossing;
+            self.delta_in = Self::delta_in(
+                self.order_type,
+                self.current_liquidity,
+                self.current_price,
+                self.sqrt_price_edge,
+            );
+            self.final_price = self.sqrt_price_edge;
         }
-        // Case 3: target_quantity = edge_quantity
-        else {
-            if self.target_quantity <= self.lim_quantity {
-                // Stop on edge price
-                self.delta_in = Self::delta_in(
-                    self.order_type,
-                    self.current_liquidity,
-                    self.current_price,
-                    self.sqrt_price_edge,
-                );
-                self.final_price = self.sqrt_price_edge;
-                self.action = if self.delta_in > 0 {
-                    SwapStepAction::StopOn
-                } else {
-                    SwapStepAction::Crossing
-                };
-                self.stop = false;
-            } else {
-                // Stop at limit price (refund needed)
-                self.action = SwapStepAction::StopIn;
-                self.delta_in = Self::delta_in(
-                    self.order_type,
-                    self.current_liquidity,
-                    self.current_price,
-                    self.sqrt_price_limit,
-                );
-                self.final_price = self.sqrt_price_limit;
-                self.stop = true;
-            }
+
+        // Now correct the action if we stopped exactly at the edge no matter what was the case above
+        // Because order type buy moves the price up and tick semi-open interval doesn't include its right 
+        // point, we cross on buys and stop on sells. 
+        if self.final_price == self.sqrt_price_edge {
+            self.action = match self.order_type {
+                OrderType::Buy => SwapStepAction::Crossing,
+                OrderType::Sell => SwapStepAction::Stop,
+            };
         }
     }
 
@@ -233,47 +188,24 @@ impl<T: Config> SwapStep<T> {
         // Get current tick
         let current_tick_index = TickIndex::current_bounded::<T>(self.netuid);
 
-        match self.action {
-            SwapStepAction::Crossing => {
-                let mut tick = match self.order_type {
-                    OrderType::Sell => {
-                        Pallet::<T>::find_closest_lower_active_tick(self.netuid, current_tick_index)
-                    }
-                    OrderType::Buy => Pallet::<T>::find_closest_higher_active_tick(
-                        self.netuid,
-                        current_tick_index,
-                    ),
+        if self.action == SwapStepAction::Crossing {
+            let mut tick = match self.order_type {
+                OrderType::Sell => {
+                    Pallet::<T>::find_closest_lower_active_tick(self.netuid, current_tick_index)
                 }
-                .ok_or(Error::<T>::InsufficientLiquidity)?;
-
-                tick.fees_out_tao =
-                    FeeGlobalTao::<T>::get(self.netuid).saturating_sub(tick.fees_out_tao);
-                tick.fees_out_alpha =
-                    FeeGlobalAlpha::<T>::get(self.netuid).saturating_sub(tick.fees_out_alpha);
-                Pallet::<T>::update_liquidity_at_crossing(self.netuid, self.order_type)?;
-                Ticks::<T>::insert(self.netuid, current_tick_index, tick);
+                OrderType::Buy => Pallet::<T>::find_closest_higher_active_tick(
+                    self.netuid,
+                    current_tick_index,
+                ),
             }
-
-            SwapStepAction::StopOn => match self.order_type {
-                OrderType::Buy => {
-                    Pallet::<T>::update_liquidity_at_crossing(self.netuid, self.order_type)?;
-                    let Some(mut tick) = Pallet::<T>::find_closest_higher_active_tick(
-                        self.netuid,
-                        current_tick_index,
-                    ) else {
-                        return Err(Error::<T>::InsufficientLiquidity);
-                    };
-
-                    tick.fees_out_tao =
-                        FeeGlobalTao::<T>::get(self.netuid).saturating_sub(tick.fees_out_tao);
-                    tick.fees_out_alpha =
-                        FeeGlobalAlpha::<T>::get(self.netuid).saturating_sub(tick.fees_out_alpha);
-                    Ticks::<T>::insert(self.netuid, current_tick_index, tick);
-                }
-                OrderType::Sell => {}
-            },
-
-            SwapStepAction::StopIn => {}
+            .ok_or(Error::<T>::InsufficientLiquidity)?;
+
+            tick.fees_out_tao =
+                FeeGlobalTao::<T>::get(self.netuid).saturating_sub(tick.fees_out_tao);
+            tick.fees_out_alpha =
+                FeeGlobalAlpha::<T>::get(self.netuid).saturating_sub(tick.fees_out_alpha);
+            Pallet::<T>::update_liquidity_at_crossing(self.netuid, self.order_type)?;
+            Ticks::<T>::insert(self.netuid, current_tick_index, tick);
         }
 
         // Update current price
@@ -328,7 +260,7 @@ impl<T: Config> Pallet<T> {
         let price = U64F64::saturating_from_num(tao_reserve)
             .safe_div(U64F64::saturating_from_num(alpha_reserve));
 
-        let epsilon = U64F64::saturating_from_num(0.000001);
+        let epsilon = U64F64::saturating_from_num(0.000000000001);
 
         let current_sqrt_price = price.checked_sqrt(epsilon).unwrap_or(U64F64::from_num(0));
         AlphaSqrtPrice::<T>::set(netuid, current_sqrt_price);
@@ -416,7 +348,7 @@ impl<T: Config> Pallet<T> {
             amount_remaining = amount_remaining.saturating_sub(swap_result.amount_to_take);
             amount_paid_out = amount_paid_out.saturating_add(swap_result.delta_out);
 
-            if swap_step.stop {
+            if swap_step.action == SwapStepAction::Stop {
                 amount_remaining = 0;
             }
 
@@ -1214,8 +1146,7 @@ struct SwapStepResult {
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub enum SwapStepAction {
     Crossing,
-    StopOn,
-    StopIn,
+    Stop,
 }
 
 // cargo test --package pallet-subtensor-swap --lib -- pallet::impls::tests --show-output
@@ -1254,6 +1185,23 @@ mod tests {
         }
     }
 
+    fn get_ticked_prices_around_current_price() -> (f64, f64) {
+        // Get current price, ticks around it, and prices on the tick edges for test cases
+        let netuid = NetUid::from(1);
+        assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
+        let current_price_sqrt = AlphaSqrtPrice::<Test>::get(netuid);
+        let tick_index_for_current_price_low = TickIndex::try_from_sqrt_price(current_price_sqrt).unwrap();
+        let tick_index_for_current_price_high = tick_index_for_current_price_low.next().unwrap().next().unwrap();
+
+        // Low and high prices that match to a lower and higher tick that doesn't contain the current price
+        let current_price_low_sqrt = TickIndex::try_to_sqrt_price(&tick_index_for_current_price_low).unwrap().to_num::<f64>();
+        let current_price_high_sqrt = TickIndex::try_to_sqrt_price(&tick_index_for_current_price_high).unwrap().to_num::<f64>();
+        let current_price_low = current_price_low_sqrt * current_price_low_sqrt;
+        let current_price_high = current_price_high_sqrt * current_price_high_sqrt;
+
+        (current_price_low, current_price_high)
+    }
+
     // this function is used to convert tick index NON-SQRT (!) price. it's only utility for
     // testing, all the implementation logic is based on sqrt prices
     fn tick_to_price(tick: TickIndex) -> f64 {
@@ -1286,11 +1234,12 @@ mod tests {
 
             // Verify current price is set
             let sqrt_price = AlphaSqrtPrice::<Test>::get(netuid);
-            let expected_sqrt_price = U64F64::from_num(tao)
-                .safe_div(U64F64::from_num(alpha))
-                .checked_sqrt(U64F64::from_num(0.000001))
-                .unwrap();
-            assert_eq!(sqrt_price, expected_sqrt_price);
+            let expected_sqrt_price = U64F64::from_num(0.5_f64);
+            assert_abs_diff_eq!(
+                sqrt_price.to_num::<f64>(),
+                expected_sqrt_price.to_num::<f64>(),
+                epsilon = 0.000000001
+            );
 
             // Verify that current tick is set
             let current_tick = CurrentTick::<Test>::get(netuid);
@@ -1341,6 +1290,8 @@ mod tests {
             let current_price = 0.25;
             assert_eq!(max_tick, TickIndex::MAX);
 
+            let (current_price_low, current_price_high) = get_ticked_prices_around_current_price();
+
             // As a user add liquidity with all possible corner cases
             //   - Initial price is 0.25
             //   - liquidity is expressed in RAO units
@@ -1355,9 +1306,9 @@ mod tests {
                     4_000_000_000_u64,
                 ),
                 // Repeat the protocol liquidity at current to max range: Expect the same alpha
-                (0.25, max_price, 2_000_000_000_u64, 0, 4_000_000_000),
+                (current_price_high, max_price, 2_000_000_000_u64, 0, 4_000_000_000),
                 // Repeat the protocol liquidity at min to current range: Expect all the same tao
-                (min_price, 0.24999, 2_000_000_000_u64, 1_000_000_000, 0),
+                (min_price, current_price_low, 2_000_000_000_u64, 1_000_000_000, 0),
                 // Half to double price - just some sane wothdraw amounts
                 (0.125, 0.5, 2_000_000_000_u64, 293_000_000, 1_171_000_000),
                 // Both below price - tao is non-zero, alpha is zero
@@ -1540,6 +1491,7 @@ mod tests {
         });
     }
 
+    // cargo test --package pallet-subtensor-swap --lib -- pallet::impls::tests::test_remove_liquidity_basic --exact --show-output
     #[test]
     fn test_remove_liquidity_basic() {
         new_test_ext().execute_with(|| {
@@ -1548,6 +1500,8 @@ mod tests {
             let max_tick = price_to_tick(max_price);
             assert_eq!(max_tick, TickIndex::MAX);
 
+            let (current_price_low, current_price_high) = get_ticked_prices_around_current_price();
+
             // As a user add liquidity with all possible corner cases
             //   - Initial price is 0.25
             //   - liquidity is expressed in RAO units
@@ -1562,9 +1516,9 @@ mod tests {
                     4_000_000_000_u64,
                 ),
                 // Repeat the protocol liquidity at current to max range: Expect the same alpha
-                (0.25, max_price, 2_000_000_000_u64, 0, 4_000_000_000),
+                (current_price_high, max_price, 2_000_000_000_u64, 0, 4_000_000_000),
                 // Repeat the protocol liquidity at min to current range: Expect all the same tao
-                (min_price, 0.24999, 2_000_000_000_u64, 1_000_000_000, 0),
+                (min_price, current_price_low, 2_000_000_000_u64, 1_000_000_000, 0),
                 // Half to double price - just some sane wothdraw amounts
                 (0.125, 0.5, 2_000_000_000_u64, 293_000_000, 1_171_000_000),
                 // Both below price - tao is non-zero, alpha is zero
diff --git a/pallets/swap/src/tick.rs b/pallets/swap/src/tick.rs
index 6892cc8444..7352fd7d7a 100644
--- a/pallets/swap/src/tick.rs
+++ b/pallets/swap/src/tick.rs
@@ -1143,8 +1143,6 @@ impl Error for TickMathError {}
 #[cfg(test)]
 mod tests {
     use std::{ops::Sub, str::FromStr};
-
-    use approx::assert_abs_diff_eq;
     use safe_math::FixedExt;
 
     use super::*;

From ea431ba04f2a31e85a31af493e9aecd784ae8a01 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Tue, 13 May 2025 23:17:25 +0800
Subject: [PATCH 144/418] commit Cargo.lock

---
 pallets/subtensor/src/rpc_info/metagraph.rs | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/pallets/subtensor/src/rpc_info/metagraph.rs b/pallets/subtensor/src/rpc_info/metagraph.rs
index 8238e972f1..674c5addc9 100644
--- a/pallets/subtensor/src/rpc_info/metagraph.rs
+++ b/pallets/subtensor/src/rpc_info/metagraph.rs
@@ -365,9 +365,6 @@ where
             Some(SelectiveMetagraphIndex::AlphaDividendsPerHotkey) => {
                 self.alpha_dividends_per_hotkey = other.alpha_dividends_per_hotkey.clone()
             }
-
-            Some(SelectiveMetagraphIndex::Validators) => self.validators = other.validators.clone(),
-
             None => {}
         };
     }
@@ -529,7 +526,6 @@ pub enum SelectiveMetagraphIndex {
     TotalStake,
     TaoDividendsPerHotkey,
     AlphaDividendsPerHotkey,
-    Validators,
 }
 
 impl SelectiveMetagraphIndex {
@@ -607,7 +603,6 @@ impl SelectiveMetagraphIndex {
             69 => Some(SelectiveMetagraphIndex::TotalStake),
             70 => Some(SelectiveMetagraphIndex::TaoDividendsPerHotkey),
             71 => Some(SelectiveMetagraphIndex::AlphaDividendsPerHotkey),
-            72 => Some(SelectiveMetagraphIndex::Validators),
             _ => None,
         }
     }

From 853abba862763309fc1c35f94b1bd3af3fc21ea6 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Tue, 13 May 2025 23:37:42 +0800
Subject: [PATCH 145/418] bump runtime version

---
 runtime/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index c274fe57ee..3d7573c687 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -209,7 +209,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
     //   `spec_version`, and `authoring_version` are the same between Wasm and native.
     // This value is set to 100 to notify Polkadot-JS App (https://polkadot.js.org/apps) to use
     //   the compatible custom types.
-    spec_version: 268,
+    spec_version: 269,
     impl_version: 1,
     apis: RUNTIME_API_VERSIONS,
     transaction_version: 1,

From 0109dd2ee621020ce12a91d7bc15e9c730d910db Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Tue, 13 May 2025 17:54:52 -0400
Subject: [PATCH 146/418] Fix more tests where edge price was an issue

---
 pallets/swap/src/pallet/impls.rs | 153 ++++++++++++++++++++-----------
 1 file changed, 98 insertions(+), 55 deletions(-)

diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 5568731561..925236348f 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -61,6 +61,10 @@ impl<T: Config> SwapStep<T> {
         let possible_delta_in = amount_remaining
             .saturating_sub(Pallet::<T>::calculate_fee_amount(netuid, amount_remaining));
 
+        // println!("Swap step amount_remaining = {:?}", amount_remaining);
+        // println!("Swap step current_price = {:?}", current_price);
+        // println!("Swap step sqrt_price_edge = {:?}", sqrt_price_edge);
+
         // Target price and quantities
         let sqrt_price_target = Pallet::<T>::sqrt_price_target(
             order_type,
@@ -75,6 +79,10 @@ impl<T: Config> SwapStep<T> {
             possible_delta_in,
         );
 
+        // println!("Swap step sqrt_price_target = {:?}", sqrt_price_target);
+        // println!("Swap step possible_delta_in = {:?}", possible_delta_in);
+
+
         // Quantities for comparison
         let edge_quantity = match order_type {
             OrderType::Buy => sqrt_price_edge.into(),
@@ -99,6 +107,11 @@ impl<T: Config> SwapStep<T> {
             }
         };
 
+        // println!("Swap step edge_quantity = {:?}", edge_quantity);
+        // println!("Swap step lim_quantity = {:?}", lim_quantity);
+        // println!("Swap step target_quantity = {:?}", target_quantity);
+
+
         Self {
             netuid,
             order_type,
@@ -132,12 +145,18 @@ impl<T: Config> SwapStep<T> {
         if (self.target_quantity <= self.lim_quantity) && (self.target_quantity <= self.edge_quantity) {
             // Case 1. target_quantity is the lowest
             // The trade completely happens within one tick, no tick crossing happens.
+
+            // println!("==== Case 1");
+
             self.action = SwapStepAction::Stop;
             self.final_price = self.sqrt_price_target;
             self.delta_in = self.possible_delta_in;
         } else if (self.lim_quantity <= self.target_quantity) && (self.lim_quantity <= self.edge_quantity) {
             // Case 2. lim_quantity is the lowest
             // The trade also completely happens within one tick, no tick crossing happens.
+
+            // println!("==== Case 2");
+
             self.action = SwapStepAction::Stop;
             self.final_price = self.sqrt_price_limit;
             self.delta_in = Self::delta_in(
@@ -149,6 +168,9 @@ impl<T: Config> SwapStep<T> {
         } else if (self.edge_quantity <= self.target_quantity) && (self.edge_quantity <= self.lim_quantity) {
             // Case 3. edge_quantity is the lowest
             // Tick crossing is likely
+
+            // println!("==== Case 3");
+
             self.action = SwapStepAction::Crossing;
             self.delta_in = Self::delta_in(
                 self.order_type,
@@ -161,8 +183,13 @@ impl<T: Config> SwapStep<T> {
 
         // Now correct the action if we stopped exactly at the edge no matter what was the case above
         // Because order type buy moves the price up and tick semi-open interval doesn't include its right 
-        // point, we cross on buys and stop on sells. 
-        if self.final_price == self.sqrt_price_edge {
+        // point, we cross on buys and stop on sells.
+        let natural_reason_stop_price = if self.lim_quantity <= self.target_quantity {
+            self.sqrt_price_limit
+        } else {
+            self.sqrt_price_target
+        };
+        if natural_reason_stop_price == self.sqrt_price_edge {
             self.action = match self.order_type {
                 OrderType::Buy => SwapStepAction::Crossing,
                 OrderType::Sell => SwapStepAction::Stop,
@@ -185,6 +212,9 @@ impl<T: Config> SwapStep<T> {
         Pallet::<T>::add_fees(self.netuid, self.order_type, fee);
         let delta_out = Pallet::<T>::convert_deltas(self.netuid, self.order_type, self.delta_in);
 
+        // println!("Swap step delta_in = {:?}, delta_out = {:?}", self.delta_in, delta_out);
+        // println!("Swap step action = {:?}", self.action);
+
         // Get current tick
         let current_tick_index = TickIndex::current_bounded::<T>(self.netuid);
 
@@ -522,6 +552,11 @@ impl<T: Config> Pallet<T> {
     }
 
     /// Get the target square root price based on the input amount
+    /// 
+    /// This is the price that would be reached if
+    ///    - There are no liquidity positions other than protocol liquidity
+    ///    - Full delta_in amount is executed
+    /// 
     fn sqrt_price_target(
         order_type: OrderType,
         liquidity_curr: U64F64,
@@ -531,9 +566,12 @@ impl<T: Config> Pallet<T> {
         let delta_fixed = U64F64::saturating_from_num(delta_in);
         let one = U64F64::saturating_from_num(1);
 
+        // No liquidity means that price should go to the limit
         if liquidity_curr == 0 {
-            // No liquidity means price should remain current
-            return sqrt_price_curr;
+            return match order_type {
+                OrderType::Sell => SqrtPrice::saturating_from_num(Self::min_price()),
+                OrderType::Buy => SqrtPrice::saturating_from_num(Self::max_price()),
+            };
         }
 
         match order_type {
@@ -1621,28 +1659,15 @@ mod tests {
             let max_tick = price_to_tick(max_price);
             let limit_price = 1000.0_f64;
             assert_eq!(max_tick, TickIndex::MAX);
+            let (_current_price_low, current_price_high) = get_ticked_prices_around_current_price();
 
             // As a user add liquidity with all possible corner cases
             //   - Initial price is 0.25
             //   - liquidity is expressed in RAO units
             // Test case is (price_low, price_high, liquidity, tao, alpha)
             [
-                // // Repeat the protocol liquidity at maximum range: Expect all the same values
-                // (
-                //     min_price,
-                //     max_price,
-                //     2_000_000_000_u64,
-                //     1_000_000_000_u64,
-                //     4_000_000_000_u64,
-                // ),
-                // // Repeat the protocol liquidity at current to max range: Expect the same alpha
-                (0.25, max_price, 2_000_000_000_u64, 4_000_000_000),
-                // Half to double price - just some sane wothdraw amounts
-                // (0.125, 0.5, 2_000_000_000_u64, 1_171_000_000),
-                // // Both below price - tao is non-zero, alpha is zero
-                // (0.12, 0.13, 2_000_000_000_u64, 28_270_000, 0),
-                // // Both above price - tao is zero, alpha is non-zero
-                // (0.3, 0.4, 2_000_000_000_u64, 0, 489_200_000),
+                // Repeat the protocol liquidity at current to max range: Expect the same alpha
+                (current_price_high, max_price, 2_000_000_000_u64, 4_000_000_000),
             ]
             .into_iter()
             .enumerate()
@@ -1879,6 +1904,14 @@ mod tests {
         let netuid = NetUid(1);
         assert_eq!(max_tick, TickIndex::MAX);
 
+        let mut current_price_low = 0_f64;
+        let mut current_price_high = 0_f64;
+        new_test_ext().execute_with(|| {
+            let (low, high) = get_ticked_prices_around_current_price();
+            current_price_low = low;
+            current_price_high = high;
+        });
+
         // Current price is 0.25
         // The test case is based on the current price and position prices are defined as a price
         // offset from the current price
@@ -1893,9 +1926,9 @@ mod tests {
                 2_000_000_000_u64,
             ),
             // Repeat the protocol liquidity at current to max range
-            (0.0, max_price - current_price, 2_000_000_000_u64),
+            (current_price_high - current_price, max_price - current_price, 2_000_000_000_u64),
             // Repeat the protocol liquidity at min to current range
-            (min_price - current_price, 0.0, 2_000_000_000_u64),
+            (min_price - current_price, current_price_low - current_price, 2_000_000_000_u64),
             // Half to double price
             (-0.125, 0.25, 2_000_000_000_u64),
             // A few other price ranges and liquidity volumes
@@ -1908,25 +1941,25 @@ mod tests {
         .into_iter()
         .for_each(
             |(price_low_offset, price_high_offset, position_liquidity)| {
-                // Inner part of test case is Order: (order_type, order_liquidity, limit_price, output_amount)
+                // Inner part of test case is Order: (order_type, order_liquidity, limit_price)
                 // order_liquidity is represented as a fraction of position_liquidity
                 [
-                    (OrderType::Buy, 0.0001, 1000.0_f64),
-                    (OrderType::Sell, 0.0001, 0.0001_f64),
-                    (OrderType::Buy, 0.001, 1000.0_f64),
-                    (OrderType::Sell, 0.001, 0.0001_f64),
-                    (OrderType::Buy, 0.01, 1000.0_f64),
-                    (OrderType::Sell, 0.01, 0.0001_f64),
-                    (OrderType::Buy, 0.1, 1000.0),
+                    // (OrderType::Buy, 0.0001, 1000.0_f64),
+                    // (OrderType::Sell, 0.0001, 0.0001_f64),
+                    // (OrderType::Buy, 0.001, 1000.0_f64),
+                    // (OrderType::Sell, 0.001, 0.0001_f64),
+                    // (OrderType::Buy, 0.01, 1000.0_f64),
+                    // (OrderType::Sell, 0.01, 0.0001_f64),
+                    (OrderType::Buy, 0.1, 1000.0_f64),
                     (OrderType::Sell, 0.1, 0.0001),
-                    (OrderType::Buy, 0.2, 1000.0_f64),
-                    (OrderType::Sell, 0.2, 0.0001),
-                    (OrderType::Buy, 0.5, 1000.0),
-                    (OrderType::Sell, 0.5, 0.0001),
-                    (OrderType::Buy, 0.9999, 1000.0),
-                    (OrderType::Sell, 0.9999, 0.0001),
-                    (OrderType::Buy, 1.0, 1000.0),
-                    (OrderType::Sell, 1.0, 0.0001),
+                    // (OrderType::Buy, 0.2, 1000.0_f64),
+                    // (OrderType::Sell, 0.2, 0.0001),
+                    // (OrderType::Buy, 0.5, 1000.0),
+                    // (OrderType::Sell, 0.5, 0.0001),
+                    // (OrderType::Buy, 0.9999, 1000.0),
+                    // (OrderType::Sell, 0.9999, 0.0001),
+                    // (OrderType::Buy, 1.0, 1000.0),
+                    // (OrderType::Sell, 1.0, 0.0001),
                 ]
                 .into_iter()
                 .for_each(|(order_type, order_liquidity_fraction, limit_price)| {
@@ -1972,7 +2005,7 @@ mod tests {
                         assert_abs_diff_eq!(
                             liquidity_before as f64,
                             protocol_liquidity + position_liquidity as f64,
-                            epsilon = liquidity_before as f64 / 10000.
+                            epsilon = liquidity_before as f64 / 1000.
                         );
 
                         //////////////////////////////////////////////
@@ -1981,6 +2014,11 @@ mod tests {
                         // Calculate the expected output amount for the cornercase of one step
                         let order_liquidity = order_liquidity_fraction * position_liquidity as f64;
 
+                        // println!("order_liquidity = {:?}", order_liquidity);
+                        // println!("liquidity_before = {:?}", liquidity_before);
+                        // println!("order_type = {:?}", order_type);
+                        // println!("current_price = {:?}", current_price);
+
                         let output_amount = match order_type {
                             OrderType::Buy => {
                                 let denom = sqrt_current_price.to_num::<f64>()
@@ -2000,6 +2038,8 @@ mod tests {
                                 per_order_liq * order_liquidity
                             }
                         };
+                        // println!("output_amount = {:?}", output_amount);
+
 
                         // Do the swap
                         let sqrt_limit_price = SqrtPrice::from_num((limit_price).sqrt());
@@ -2017,10 +2057,7 @@ mod tests {
                             epsilon = output_amount / 10.
                         );
 
-                        if (order_liquidity_fraction <= 0.001)
-                            && (price_low_offset != 0.0)
-                            && (price_high_offset != 0.0)
-                        {
+                        if order_liquidity_fraction <= 0.001 {
                             let tao_reserve_f64 = tao_reserve as f64;
                             let alpha_reserve_f64 = alpha_reserve as f64;
                             let (tao_expected, alpha_expected) = match order_type {
@@ -2056,14 +2093,14 @@ mod tests {
 
                         // Assert that for small amounts price stays within the user position
                         if (order_liquidity_fraction <= 0.001)
-                            && (price_low_offset != 0.0)
-                            && (price_high_offset != 0.0)
+                            && (price_low_offset > 0.0001)
+                            && (price_high_offset > 0.0001)
                         {
                             assert!(current_price_after <= price_high);
                             assert!(current_price_after >= price_low);
                         }
 
-                        // Check that low and high ticks' fees were updated properly, and liquidity values were not updated
+                        // Check that low and high ticks' fees were updated properly
                         let tick_low_info = Ticks::<Test>::get(netuid, tick_low).unwrap();
                         let tick_high_info = Ticks::<Test>::get(netuid, tick_high).unwrap();
                         let expected_liquidity_net_low = tick_low_info_before.liquidity_net;
@@ -2080,7 +2117,7 @@ mod tests {
 
                         // Expected fee amount
                         let fee_rate = FeeRate::<Test>::get(netuid) as f64 / u16::MAX as f64;
-                        let expected_fee = (order_liquidity as f64 * fee_rate) as u64;
+                        let expected_fee = (order_liquidity as f64 - order_liquidity as f64 / (1.0 + fee_rate)) as u64;
 
                         // Global fees should be updated
                         let actual_global_fee = ((match order_type {
@@ -2090,11 +2127,23 @@ mod tests {
                         .to_num::<f64>()
                             * (liquidity_before as f64))
                             as u64;
-                        assert!((swap_result.fee_paid as i64 - expected_fee as i64).abs() <= 1);
+
+                        // println!("swap_result.fee_paid = {:?}", swap_result.fee_paid);
+                        // println!("expected_fee = {:?}", expected_fee);
+                        // println!("actual_global_fee = {:?}", actual_global_fee);
+                        // println!("order_liquidity = {:?}", order_liquidity);
+                        // println!("fee_rate = {:?}", fee_rate);
+
+
+                        assert_abs_diff_eq!(
+                            swap_result.fee_paid,
+                            expected_fee,
+                            epsilon = expected_fee / 100
+                        );
                         assert_abs_diff_eq!(
                             actual_global_fee,
                             expected_fee,
-                            epsilon = expected_fee / 1_000_000
+                            epsilon = expected_fee / 100
                         );
 
                         // Tick fees should be updated
@@ -2110,9 +2159,6 @@ mod tests {
                         assert_eq!(position.tick_high, tick_high);
                         assert_eq!(position.fees_alpha, 0);
                         assert_eq!(position.fees_tao, 0);
-
-                        // Current liquidity is not updated
-                        assert_eq!(CurrentLiquidity::<Test>::get(netuid), liquidity_before);
                     });
                 });
             },
@@ -2286,9 +2332,6 @@ mod tests {
                     OrderType::Buy => assert!(current_price_after > current_price),
                     OrderType::Sell => assert!(current_price_after < current_price),
                 }
-
-                // Current liquidity is not updated
-                assert_eq!(CurrentLiquidity::<Test>::get(netuid), liquidity_before);
             });
 
             // Current price shouldn't be much different from the original

From 091d630580d7a2a8265b86ea57974a5ef2cdd722 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Wed, 14 May 2025 08:25:21 +0800
Subject: [PATCH 147/418] update interface, take validator as new index

---
 pallets/subtensor/rpc/src/lib.rs            |  4 +---
 pallets/subtensor/src/rpc_info/metagraph.rs | 10 +++++-----
 runtime/src/lib.rs                          |  4 ++--
 3 files changed, 8 insertions(+), 10 deletions(-)

diff --git a/pallets/subtensor/rpc/src/lib.rs b/pallets/subtensor/rpc/src/lib.rs
index e9b7da2d04..b3b60206dd 100644
--- a/pallets/subtensor/rpc/src/lib.rs
+++ b/pallets/subtensor/rpc/src/lib.rs
@@ -69,7 +69,6 @@ pub trait SubtensorCustomApi<BlockHash> {
         &self,
         netuid: u16,
         metagraph_index: Vec<u16>,
-        validator_only: bool,
         at: Option<BlockHash>,
     ) -> RpcResult<Vec<u8>>;
 }
@@ -403,13 +402,12 @@ where
         &self,
         netuid: u16,
         metagraph_index: Vec<u16>,
-        validator_only: bool,
         at: Option<<Block as BlockT>::Hash>,
     ) -> RpcResult<Vec<u8>> {
         let api = self.client.runtime_api();
         let at = at.unwrap_or_else(|| self.client.info().best_hash);
 
-        match api.get_selective_metagraph(at, netuid, metagraph_index, validator_only) {
+        match api.get_selective_metagraph(at, netuid, metagraph_index) {
             Ok(result) => Ok(result.encode()),
             Err(e) => Err(Error::RuntimeError(format!(
                 "Unable to get selective metagraph: {:?}",
diff --git a/pallets/subtensor/src/rpc_info/metagraph.rs b/pallets/subtensor/src/rpc_info/metagraph.rs
index 674c5addc9..9d61d12470 100644
--- a/pallets/subtensor/src/rpc_info/metagraph.rs
+++ b/pallets/subtensor/src/rpc_info/metagraph.rs
@@ -365,6 +365,7 @@ where
             Some(SelectiveMetagraphIndex::AlphaDividendsPerHotkey) => {
                 self.alpha_dividends_per_hotkey = other.alpha_dividends_per_hotkey.clone()
             }
+            Some(SelectiveMetagraphIndex::Validators) => self.validators = other.validators.clone(),
             None => {}
         };
     }
@@ -526,6 +527,7 @@ pub enum SelectiveMetagraphIndex {
     TotalStake,
     TaoDividendsPerHotkey,
     AlphaDividendsPerHotkey,
+    Validators,
 }
 
 impl SelectiveMetagraphIndex {
@@ -603,6 +605,7 @@ impl SelectiveMetagraphIndex {
             69 => Some(SelectiveMetagraphIndex::TotalStake),
             70 => Some(SelectiveMetagraphIndex::TaoDividendsPerHotkey),
             71 => Some(SelectiveMetagraphIndex::AlphaDividendsPerHotkey),
+            72 => Some(SelectiveMetagraphIndex::Validators),
             _ => None,
         }
     }
@@ -795,14 +798,10 @@ impl<T: Config> Pallet<T> {
     pub fn get_selective_metagraph(
         netuid: u16,
         metagraph_indexes: Vec<u16>,
-        validator_only: bool,
     ) -> Option<SelectiveMetagraph<T::AccountId>> {
         if !Self::if_subnet_exist(netuid) {
             None
         } else {
-            if validator_only {
-                return Some(Self::get_validators(netuid));
-            }
             let mut result = SelectiveMetagraph::default();
             for index in metagraph_indexes.iter() {
                 let value = Self::get_single_selective_metagraph(netuid, *index);
@@ -1364,7 +1363,8 @@ impl<T: Config> Pallet<T> {
                     ..Default::default()
                 }
             }
-            _ => SelectiveMetagraph {
+            Some(SelectiveMetagraphIndex::Validators) => Self::get_validators(netuid),
+            None => SelectiveMetagraph {
                 // Subnet index
                 netuid: netuid.into(),
                 ..Default::default()
diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index 3d7573c687..e162af4487 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -2221,8 +2221,8 @@ impl_runtime_apis! {
             SubtensorModule::get_all_dynamic_info()
         }
 
-        fn get_selective_metagraph(netuid: u16, metagraph_indexes: Vec<u16>, validator_only: bool) -> Option<SelectiveMetagraph<AccountId32>> {
-            SubtensorModule::get_selective_metagraph(netuid, metagraph_indexes, validator_only)
+        fn get_selective_metagraph(netuid: u16, metagraph_indexes: Vec<u16>) -> Option<SelectiveMetagraph<AccountId32>> {
+            SubtensorModule::get_selective_metagraph(netuid, metagraph_indexes)
         }
 
     }

From 89db1dfbc770235d1cd11a586192955dee4666b6 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Wed, 14 May 2025 08:26:46 +0800
Subject: [PATCH 148/418] update interface definition

---
 pallets/subtensor/runtime-api/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pallets/subtensor/runtime-api/src/lib.rs b/pallets/subtensor/runtime-api/src/lib.rs
index 45402f8be9..1a2f34aa9e 100644
--- a/pallets/subtensor/runtime-api/src/lib.rs
+++ b/pallets/subtensor/runtime-api/src/lib.rs
@@ -40,7 +40,7 @@ sp_api::decl_runtime_apis! {
         fn get_metagraph(netuid: u16) -> Option<Metagraph<AccountId32>>;
         fn get_dynamic_info(netuid: u16) -> Option<DynamicInfo<AccountId32>>;
         fn get_subnet_state(netuid: u16) -> Option<SubnetState<AccountId32>>;
-        fn get_selective_metagraph(netuid: u16, metagraph_indexes: Vec<u16>, validator_only: bool) -> Option<SelectiveMetagraph<AccountId32>>;
+        fn get_selective_metagraph(netuid: u16, metagraph_indexes: Vec<u16>) -> Option<SelectiveMetagraph<AccountId32>>;
     }
 
     pub trait StakeInfoRuntimeApi {

From 11dd779e671d01376a68c86929872c4c152feab9 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Wed, 14 May 2025 17:04:18 +0200
Subject: [PATCH 149/418] Rewrite convert_deltas with safe math

---
 pallets/swap/src/pallet/impls.rs | 213 +++++++++++++++++++++++++------
 1 file changed, 172 insertions(+), 41 deletions(-)

diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 925236348f..c0f7adb32e 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -82,7 +82,6 @@ impl<T: Config> SwapStep<T> {
         // println!("Swap step sqrt_price_target = {:?}", sqrt_price_target);
         // println!("Swap step possible_delta_in = {:?}", possible_delta_in);
 
-
         // Quantities for comparison
         let edge_quantity = match order_type {
             OrderType::Buy => sqrt_price_edge.into(),
@@ -111,7 +110,6 @@ impl<T: Config> SwapStep<T> {
         // println!("Swap step lim_quantity = {:?}", lim_quantity);
         // println!("Swap step target_quantity = {:?}", target_quantity);
 
-
         Self {
             netuid,
             order_type,
@@ -139,10 +137,12 @@ impl<T: Config> SwapStep<T> {
 
     /// Determine the appropriate action for this swap step
     fn determine_action(&mut self) {
-        // Calculate the stopping price: The price at which we either reach the limit price, 
+        // Calculate the stopping price: The price at which we either reach the limit price,
         // exchange the full amount, or reach the edge price.
 
-        if (self.target_quantity <= self.lim_quantity) && (self.target_quantity <= self.edge_quantity) {
+        if (self.target_quantity <= self.lim_quantity)
+            && (self.target_quantity <= self.edge_quantity)
+        {
             // Case 1. target_quantity is the lowest
             // The trade completely happens within one tick, no tick crossing happens.
 
@@ -151,7 +151,9 @@ impl<T: Config> SwapStep<T> {
             self.action = SwapStepAction::Stop;
             self.final_price = self.sqrt_price_target;
             self.delta_in = self.possible_delta_in;
-        } else if (self.lim_quantity <= self.target_quantity) && (self.lim_quantity <= self.edge_quantity) {
+        } else if (self.lim_quantity <= self.target_quantity)
+            && (self.lim_quantity <= self.edge_quantity)
+        {
             // Case 2. lim_quantity is the lowest
             // The trade also completely happens within one tick, no tick crossing happens.
 
@@ -165,7 +167,9 @@ impl<T: Config> SwapStep<T> {
                 self.current_price,
                 self.sqrt_price_limit,
             );
-        } else if (self.edge_quantity <= self.target_quantity) && (self.edge_quantity <= self.lim_quantity) {
+        } else if (self.edge_quantity <= self.target_quantity)
+            && (self.edge_quantity <= self.lim_quantity)
+        {
             // Case 3. edge_quantity is the lowest
             // Tick crossing is likely
 
@@ -182,7 +186,7 @@ impl<T: Config> SwapStep<T> {
         }
 
         // Now correct the action if we stopped exactly at the edge no matter what was the case above
-        // Because order type buy moves the price up and tick semi-open interval doesn't include its right 
+        // Because order type buy moves the price up and tick semi-open interval doesn't include its right
         // point, we cross on buys and stop on sells.
         let natural_reason_stop_price = if self.lim_quantity <= self.target_quantity {
             self.sqrt_price_limit
@@ -223,10 +227,9 @@ impl<T: Config> SwapStep<T> {
                 OrderType::Sell => {
                     Pallet::<T>::find_closest_lower_active_tick(self.netuid, current_tick_index)
                 }
-                OrderType::Buy => Pallet::<T>::find_closest_higher_active_tick(
-                    self.netuid,
-                    current_tick_index,
-                ),
+                OrderType::Buy => {
+                    Pallet::<T>::find_closest_higher_active_tick(self.netuid, current_tick_index)
+                }
             }
             .ok_or(Error::<T>::InsufficientLiquidity)?;
 
@@ -534,29 +537,39 @@ impl<T: Config> Pallet<T> {
         // Using safe math operations throughout to prevent overflows
         let result = match order_type {
             OrderType::Sell => {
-                // TODO: This needs to be reimplemented in full precision non-overflowing math:
-                let a = liquidity_curr / (liquidity_curr / sqrt_price_curr + delta_fixed);
-                let b = a * sqrt_price_curr;
-                let c = delta_fixed * b;
-                c
+                // liquidity_curr / (liquidity_curr / sqrt_price_curr + delta_fixed);
+                let denom = liquidity_curr
+                    .safe_div(sqrt_price_curr)
+                    .saturating_add(delta_fixed);
+                let a = liquidity_curr.safe_div(denom);
+                // a * sqrt_price_curr;
+                let b = a.saturating_mul(sqrt_price_curr);
+
+                // delta_fixed * b;
+                delta_fixed.saturating_mul(b)
             }
             OrderType::Buy => {
-                let a = (liquidity_curr * sqrt_price_curr + delta_fixed) * sqrt_price_curr;
-                let b = liquidity_curr / a;
-                let c = b * delta_fixed;
-                c
+                // (liquidity_curr * sqrt_price_curr + delta_fixed) * sqrt_price_curr;
+                let a = liquidity_curr
+                    .saturating_mul(sqrt_price_curr)
+                    .saturating_add(delta_fixed)
+                    .saturating_mul(sqrt_price_curr);
+                // liquidity_curr / a;
+                let b = liquidity_curr.safe_div(a);
+                // b * delta_fixed;
+                b.saturating_mul(delta_fixed)
             }
         };
 
-        result.to_num::<u64>()
+        result.saturating_to_num::<u64>()
     }
 
     /// Get the target square root price based on the input amount
-    /// 
+    ///
     /// This is the price that would be reached if
     ///    - There are no liquidity positions other than protocol liquidity
     ///    - Full delta_in amount is executed
-    /// 
+    ///
     fn sqrt_price_target(
         order_type: OrderType,
         liquidity_curr: U64F64,
@@ -891,10 +904,12 @@ impl<T: Config> Pallet<T> {
         };
 
         // Calculate token amounts for the liquidity change
-        // TODO: Rewrite in non-overflowing math
-        let alpha = SqrtPrice::from_num(delta_liquidity_abs)
-            * (SqrtPrice::from_num(1) / sqrt_price_box - SqrtPrice::from_num(1) / sqrt_pb);
-        let tao = SqrtPrice::from_num(delta_liquidity_abs) * (sqrt_price_box - sqrt_pa);
+        let mul = SqrtPrice::from_num(1)
+            .safe_div(sqrt_price_box)
+            .saturating_sub(SqrtPrice::from_num(1).safe_div(sqrt_pb));
+        let alpha = SqrtPrice::saturating_from_num(delta_liquidity_abs).saturating_mul(mul);
+        let tao = SqrtPrice::saturating_from_num(delta_liquidity_abs)
+            .saturating_mul(sqrt_price_box.saturating_sub(sqrt_pa));
 
         // Validate delta
         if liquidity_delta > 0 {
@@ -1228,12 +1243,23 @@ mod tests {
         let netuid = NetUid::from(1);
         assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
         let current_price_sqrt = AlphaSqrtPrice::<Test>::get(netuid);
-        let tick_index_for_current_price_low = TickIndex::try_from_sqrt_price(current_price_sqrt).unwrap();
-        let tick_index_for_current_price_high = tick_index_for_current_price_low.next().unwrap().next().unwrap();
+        let tick_index_for_current_price_low =
+            TickIndex::try_from_sqrt_price(current_price_sqrt).unwrap();
+        let tick_index_for_current_price_high = tick_index_for_current_price_low
+            .next()
+            .unwrap()
+            .next()
+            .unwrap();
 
         // Low and high prices that match to a lower and higher tick that doesn't contain the current price
-        let current_price_low_sqrt = TickIndex::try_to_sqrt_price(&tick_index_for_current_price_low).unwrap().to_num::<f64>();
-        let current_price_high_sqrt = TickIndex::try_to_sqrt_price(&tick_index_for_current_price_high).unwrap().to_num::<f64>();
+        let current_price_low_sqrt =
+            TickIndex::try_to_sqrt_price(&tick_index_for_current_price_low)
+                .unwrap()
+                .to_num::<f64>();
+        let current_price_high_sqrt =
+            TickIndex::try_to_sqrt_price(&tick_index_for_current_price_high)
+                .unwrap()
+                .to_num::<f64>();
         let current_price_low = current_price_low_sqrt * current_price_low_sqrt;
         let current_price_high = current_price_high_sqrt * current_price_high_sqrt;
 
@@ -1344,9 +1370,21 @@ mod tests {
                     4_000_000_000_u64,
                 ),
                 // Repeat the protocol liquidity at current to max range: Expect the same alpha
-                (current_price_high, max_price, 2_000_000_000_u64, 0, 4_000_000_000),
+                (
+                    current_price_high,
+                    max_price,
+                    2_000_000_000_u64,
+                    0,
+                    4_000_000_000,
+                ),
                 // Repeat the protocol liquidity at min to current range: Expect all the same tao
-                (min_price, current_price_low, 2_000_000_000_u64, 1_000_000_000, 0),
+                (
+                    min_price,
+                    current_price_low,
+                    2_000_000_000_u64,
+                    1_000_000_000,
+                    0,
+                ),
                 // Half to double price - just some sane wothdraw amounts
                 (0.125, 0.5, 2_000_000_000_u64, 293_000_000, 1_171_000_000),
                 // Both below price - tao is non-zero, alpha is zero
@@ -1554,9 +1592,21 @@ mod tests {
                     4_000_000_000_u64,
                 ),
                 // Repeat the protocol liquidity at current to max range: Expect the same alpha
-                (current_price_high, max_price, 2_000_000_000_u64, 0, 4_000_000_000),
+                (
+                    current_price_high,
+                    max_price,
+                    2_000_000_000_u64,
+                    0,
+                    4_000_000_000,
+                ),
                 // Repeat the protocol liquidity at min to current range: Expect all the same tao
-                (min_price, current_price_low, 2_000_000_000_u64, 1_000_000_000, 0),
+                (
+                    min_price,
+                    current_price_low,
+                    2_000_000_000_u64,
+                    1_000_000_000,
+                    0,
+                ),
                 // Half to double price - just some sane wothdraw amounts
                 (0.125, 0.5, 2_000_000_000_u64, 293_000_000, 1_171_000_000),
                 // Both below price - tao is non-zero, alpha is zero
@@ -1667,7 +1717,12 @@ mod tests {
             // Test case is (price_low, price_high, liquidity, tao, alpha)
             [
                 // Repeat the protocol liquidity at current to max range: Expect the same alpha
-                (current_price_high, max_price, 2_000_000_000_u64, 4_000_000_000),
+                (
+                    current_price_high,
+                    max_price,
+                    2_000_000_000_u64,
+                    4_000_000_000,
+                ),
             ]
             .into_iter()
             .enumerate()
@@ -1926,9 +1981,17 @@ mod tests {
                 2_000_000_000_u64,
             ),
             // Repeat the protocol liquidity at current to max range
-            (current_price_high - current_price, max_price - current_price, 2_000_000_000_u64),
+            (
+                current_price_high - current_price,
+                max_price - current_price,
+                2_000_000_000_u64,
+            ),
             // Repeat the protocol liquidity at min to current range
-            (min_price - current_price, current_price_low - current_price, 2_000_000_000_u64),
+            (
+                min_price - current_price,
+                current_price_low - current_price,
+                2_000_000_000_u64,
+            ),
             // Half to double price
             (-0.125, 0.25, 2_000_000_000_u64),
             // A few other price ranges and liquidity volumes
@@ -2040,7 +2103,6 @@ mod tests {
                         };
                         // println!("output_amount = {:?}", output_amount);
 
-
                         // Do the swap
                         let sqrt_limit_price = SqrtPrice::from_num((limit_price).sqrt());
                         let swap_result = Pallet::<Test>::do_swap(
@@ -2117,7 +2179,9 @@ mod tests {
 
                         // Expected fee amount
                         let fee_rate = FeeRate::<Test>::get(netuid) as f64 / u16::MAX as f64;
-                        let expected_fee = (order_liquidity as f64 - order_liquidity as f64 / (1.0 + fee_rate)) as u64;
+                        let expected_fee = (order_liquidity as f64
+                            - order_liquidity as f64 / (1.0 + fee_rate))
+                            as u64;
 
                         // Global fees should be updated
                         let actual_global_fee = ((match order_type {
@@ -2134,7 +2198,6 @@ mod tests {
                         // println!("order_liquidity = {:?}", order_liquidity);
                         // println!("fee_rate = {:?}", fee_rate);
 
-
                         assert_abs_diff_eq!(
                             swap_result.fee_paid,
                             expected_fee,
@@ -2388,4 +2451,72 @@ mod tests {
             assert!(tick == roundtrip_tick);
         });
     }
+
+    #[test]
+    fn test_convert_deltas() {
+        new_test_ext().execute_with(|| {
+            let netuid = NetUid::from(1);
+            assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
+
+            for (sqrt_price, delta_in, expected_buy, expected_sell) in [
+                (SqrtPrice::from_num(1.5), 1, 0, 2),
+                (SqrtPrice::from_num(1.5), 10000, 4444, 22500),
+                (SqrtPrice::from_num(1.5), 1000000, 444444, 2250000),
+                (
+                    SqrtPrice::from_num(1.5),
+                    u64::MAX,
+                    2000000000000,
+                    3000000000000,
+                ),
+                (
+                    TickIndex::MIN.to_sqrt_price_bounded(),
+                    1,
+                    18406523739291577836,
+                    465,
+                ),
+                (TickIndex::MIN.to_sqrt_price_bounded(), 10000, u64::MAX, 465),
+                (
+                    TickIndex::MIN.to_sqrt_price_bounded(),
+                    1000000,
+                    u64::MAX,
+                    465,
+                ),
+                (
+                    TickIndex::MIN.to_sqrt_price_bounded(),
+                    u64::MAX,
+                    u64::MAX,
+                    464,
+                ),
+                (
+                    TickIndex::MAX.to_sqrt_price_bounded(),
+                    1,
+                    0,
+                    18406523745214495085,
+                ),
+                (TickIndex::MAX.to_sqrt_price_bounded(), 10000, 0, u64::MAX),
+                (TickIndex::MAX.to_sqrt_price_bounded(), 1000000, 0, u64::MAX),
+                (
+                    TickIndex::MAX.to_sqrt_price_bounded(),
+                    u64::MAX,
+                    2000000000000,
+                    u64::MAX,
+                ),
+            ] {
+                {
+                    AlphaSqrtPrice::<Test>::insert(netuid, sqrt_price);
+
+                    assert_abs_diff_eq!(
+                        Pallet::<Test>::convert_deltas(netuid, OrderType::Sell, delta_in),
+                        expected_sell,
+                        epsilon = 2
+                    );
+                    assert_abs_diff_eq!(
+                        Pallet::<Test>::convert_deltas(netuid, OrderType::Buy, delta_in),
+                        expected_buy,
+                        epsilon = 2
+                    );
+                }
+            }
+        });
+    }
 }

From d0792a8251361dfcb3311ba185aa6031ad09cfcf Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Wed, 14 May 2025 12:24:53 -0400
Subject: [PATCH 150/418] Fix swap step action calculation

---
 pallets/swap/README.md           |  20 +++++
 pallets/swap/src/mock.rs         |   4 +-
 pallets/swap/src/pallet/impls.rs | 141 ++++++-------------------------
 pallets/swap/src/tick.rs         |   1 +
 4 files changed, 49 insertions(+), 117 deletions(-)
 create mode 100644 pallets/swap/README.md

diff --git a/pallets/swap/README.md b/pallets/swap/README.md
new file mode 100644
index 0000000000..2a9ca39ec4
--- /dev/null
+++ b/pallets/swap/README.md
@@ -0,0 +1,20 @@
+# Swap pallet
+
+This pallet implements uniswap v3 algorithm. Below is the basic description of it.
+
+## Glossary
+
+### Ticks
+
+### Liquidity Positions
+
+### Active Ticks
+
+### Current Price and Tick
+
+### Current Liquidity
+
+
+
+## Executing Swap 
+
diff --git a/pallets/swap/src/mock.rs b/pallets/swap/src/mock.rs
index dd59a9d232..5ad5362e35 100644
--- a/pallets/swap/src/mock.rs
+++ b/pallets/swap/src/mock.rs
@@ -76,14 +76,14 @@ pub struct MockLiquidityProvider;
 impl LiquidityDataProvider<AccountId> for MockLiquidityProvider {
     fn tao_reserve(netuid: u16) -> u64 {
         match netuid {
-            123 => 1_000,
+            123 => 10_000,
             _ => 1_000_000_000_000,
         }
     }
 
     fn alpha_reserve(netuid: u16) -> u64 {
         match netuid {
-            123 => 1,
+            123 => 10_000,
             _ => 4_000_000_000_000,
         }
     }
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 925236348f..b2ab4c2654 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -32,9 +32,6 @@ struct SwapStep<T: frame_system::Config> {
     sqrt_price_edge: SqrtPrice,
     possible_delta_in: u64,
     sqrt_price_target: SqrtPrice,
-    target_quantity: SqrtPrice,
-    edge_quantity: U64F64,
-    lim_quantity: U64F64,
 
     // Result values
     action: SwapStepAction,
@@ -53,7 +50,6 @@ impl<T: Config> SwapStep<T> {
         amount_remaining: u64,
         sqrt_price_limit: SqrtPrice,
     ) -> Self {
-        let one = U64F64::from_num(1);
         let current_price = AlphaSqrtPrice::<T>::get(netuid);
         let current_liquidity = Pallet::<T>::current_liquidity_safe(netuid);
         let sqrt_price_edge = Pallet::<T>::sqrt_price_edge(netuid, current_price, order_type);
@@ -61,10 +57,6 @@ impl<T: Config> SwapStep<T> {
         let possible_delta_in = amount_remaining
             .saturating_sub(Pallet::<T>::calculate_fee_amount(netuid, amount_remaining));
 
-        // println!("Swap step amount_remaining = {:?}", amount_remaining);
-        // println!("Swap step current_price = {:?}", current_price);
-        // println!("Swap step sqrt_price_edge = {:?}", sqrt_price_edge);
-
         // Target price and quantities
         let sqrt_price_target = Pallet::<T>::sqrt_price_target(
             order_type,
@@ -72,45 +64,6 @@ impl<T: Config> SwapStep<T> {
             current_price,
             possible_delta_in,
         );
-        let target_quantity = Pallet::<T>::target_quantity(
-            order_type,
-            current_liquidity,
-            current_price,
-            possible_delta_in,
-        );
-
-        // println!("Swap step sqrt_price_target = {:?}", sqrt_price_target);
-        // println!("Swap step possible_delta_in = {:?}", possible_delta_in);
-
-
-        // Quantities for comparison
-        let edge_quantity = match order_type {
-            OrderType::Buy => sqrt_price_edge.into(),
-            OrderType::Sell => one.safe_div(sqrt_price_edge.into()),
-        };
-        let lim_quantity = match order_type {
-            OrderType::Sell => {
-                let mut lq = one
-                    .safe_div(TickIndex::min_sqrt_price())
-                    .min(one.safe_div(sqrt_price_limit.into()));
-                if lq < one.safe_div(current_price) {
-                    lq = one.safe_div(TickIndex::min_sqrt_price());
-                }
-                lq
-            }
-            OrderType::Buy => {
-                let mut lq = TickIndex::max_sqrt_price().min(sqrt_price_limit.into());
-                if lq < current_price {
-                    lq = TickIndex::max_sqrt_price();
-                }
-                lq
-            }
-        };
-
-        // println!("Swap step edge_quantity = {:?}", edge_quantity);
-        // println!("Swap step lim_quantity = {:?}", lim_quantity);
-        // println!("Swap step target_quantity = {:?}", target_quantity);
-
 
         Self {
             netuid,
@@ -121,9 +74,6 @@ impl<T: Config> SwapStep<T> {
             sqrt_price_edge,
             possible_delta_in,
             sqrt_price_target,
-            target_quantity,
-            edge_quantity,
-            lim_quantity,
             action: SwapStepAction::Stop,
             delta_in: 0,
             final_price: sqrt_price_target,
@@ -137,26 +87,32 @@ impl<T: Config> SwapStep<T> {
         self.process_swap()
     }
 
+    /// Returns True is price1 is closer to the current price than price2
+    /// in terms of order direction.
+    ///    For buying:  price1 <= price2
+    ///    For selling: price1 >= price2
+    /// 
+    fn price_is_closer(&self, price1: &SqrtPrice, price2: &SqrtPrice) -> bool {
+        match self.order_type {
+            OrderType::Buy => price1 <= price2,
+            OrderType::Sell => price1 >= price2,
+        }
+    }
+
     /// Determine the appropriate action for this swap step
     fn determine_action(&mut self) {
         // Calculate the stopping price: The price at which we either reach the limit price, 
         // exchange the full amount, or reach the edge price.
 
-        if (self.target_quantity <= self.lim_quantity) && (self.target_quantity <= self.edge_quantity) {
+        if self.price_is_closer(&self.sqrt_price_target, &self.sqrt_price_limit) && self.price_is_closer(&self.sqrt_price_target, &self.sqrt_price_edge) {
             // Case 1. target_quantity is the lowest
             // The trade completely happens within one tick, no tick crossing happens.
-
-            // println!("==== Case 1");
-
             self.action = SwapStepAction::Stop;
             self.final_price = self.sqrt_price_target;
             self.delta_in = self.possible_delta_in;
-        } else if (self.lim_quantity <= self.target_quantity) && (self.lim_quantity <= self.edge_quantity) {
+        } else if self.price_is_closer(&self.sqrt_price_limit, &self.sqrt_price_target) && self.price_is_closer(&self.sqrt_price_limit, &self.sqrt_price_edge) {
             // Case 2. lim_quantity is the lowest
             // The trade also completely happens within one tick, no tick crossing happens.
-
-            // println!("==== Case 2");
-
             self.action = SwapStepAction::Stop;
             self.final_price = self.sqrt_price_limit;
             self.delta_in = Self::delta_in(
@@ -165,12 +121,9 @@ impl<T: Config> SwapStep<T> {
                 self.current_price,
                 self.sqrt_price_limit,
             );
-        } else if (self.edge_quantity <= self.target_quantity) && (self.edge_quantity <= self.lim_quantity) {
+        } else {
             // Case 3. edge_quantity is the lowest
             // Tick crossing is likely
-
-            // println!("==== Case 3");
-
             self.action = SwapStepAction::Crossing;
             self.delta_in = Self::delta_in(
                 self.order_type,
@@ -184,7 +137,7 @@ impl<T: Config> SwapStep<T> {
         // Now correct the action if we stopped exactly at the edge no matter what was the case above
         // Because order type buy moves the price up and tick semi-open interval doesn't include its right 
         // point, we cross on buys and stop on sells.
-        let natural_reason_stop_price = if self.lim_quantity <= self.target_quantity {
+        let natural_reason_stop_price = if self.price_is_closer(&self.sqrt_price_limit, &self.sqrt_price_target) {
             self.sqrt_price_limit
         } else {
             self.sqrt_price_target
@@ -212,9 +165,6 @@ impl<T: Config> SwapStep<T> {
         Pallet::<T>::add_fees(self.netuid, self.order_type, fee);
         let delta_out = Pallet::<T>::convert_deltas(self.netuid, self.order_type, self.delta_in);
 
-        // println!("Swap step delta_in = {:?}, delta_out = {:?}", self.delta_in, delta_out);
-        // println!("Swap step action = {:?}", self.action);
-
         // Get current tick
         let current_tick_index = TickIndex::current_bounded::<T>(self.netuid);
 
@@ -455,6 +405,7 @@ impl<T: Config> Pallet<T> {
 
         let current_price_tick =
             TickIndex::try_from_sqrt_price(current_price).unwrap_or(fallback_tick);
+        let roundtrip_current_price = current_price_tick.try_to_sqrt_price().unwrap_or(SqrtPrice::from_num(0));
 
         (match order_type {
             OrderType::Buy => {
@@ -468,8 +419,13 @@ impl<T: Config> Pallet<T> {
                 }
             }
             OrderType::Sell => {
-                ActiveTickIndexManager::find_closest_lower::<T>(netuid, current_price_tick)
-                    .unwrap_or(TickIndex::MIN)
+                let mut lower_tick = ActiveTickIndexManager::find_closest_lower::<T>(netuid, current_price_tick)
+                    .unwrap_or(TickIndex::MIN);
+
+                if current_price == roundtrip_current_price {
+                    lower_tick = ActiveTickIndexManager::find_closest_lower::<T>(netuid, lower_tick.prev().unwrap_or(TickIndex::MIN)).unwrap_or(TickIndex::MIN);
+                }
+                lower_tick
             }
         })
         .try_to_sqrt_price()
@@ -586,37 +542,6 @@ impl<T: Config> Pallet<T> {
         }
     }
 
-    /// Get the target quantity, which is
-    ///     `1 / (target square root price)` in case of sell order
-    ///     `target square root price` in case of buy order
-    ///
-    /// ...based on the input amount, current liquidity, and current alpha price
-    fn target_quantity(
-        order_type: OrderType,
-        liquidity_curr: U64F64,
-        sqrt_price_curr: U64F64,
-        delta_in: u64,
-    ) -> SqrtPrice {
-        let delta_fixed = U64F64::saturating_from_num(delta_in);
-        let one = U64F64::saturating_from_num(1);
-
-        if liquidity_curr == 0 {
-            // No liquidity means zero
-            return SqrtPrice::saturating_from_num(0);
-        }
-
-        match order_type {
-            OrderType::Buy => delta_fixed
-                .safe_div(liquidity_curr)
-                .saturating_add(sqrt_price_curr)
-                .into(),
-            OrderType::Sell => delta_fixed
-                .safe_div(liquidity_curr)
-                .saturating_add(one.safe_div(sqrt_price_curr))
-                .into(),
-        }
-    }
-
     /// Update liquidity when crossing a tick
     fn update_liquidity_at_crossing(netuid: NetUid, order_type: OrderType) -> Result<(), Error<T>> {
         let mut liquidity_curr = CurrentLiquidity::<T>::get(netuid);
@@ -2014,11 +1939,6 @@ mod tests {
                         // Calculate the expected output amount for the cornercase of one step
                         let order_liquidity = order_liquidity_fraction * position_liquidity as f64;
 
-                        // println!("order_liquidity = {:?}", order_liquidity);
-                        // println!("liquidity_before = {:?}", liquidity_before);
-                        // println!("order_type = {:?}", order_type);
-                        // println!("current_price = {:?}", current_price);
-
                         let output_amount = match order_type {
                             OrderType::Buy => {
                                 let denom = sqrt_current_price.to_num::<f64>()
@@ -2038,8 +1958,6 @@ mod tests {
                                 per_order_liq * order_liquidity
                             }
                         };
-                        // println!("output_amount = {:?}", output_amount);
-
 
                         // Do the swap
                         let sqrt_limit_price = SqrtPrice::from_num((limit_price).sqrt());
@@ -2128,22 +2046,15 @@ mod tests {
                             * (liquidity_before as f64))
                             as u64;
 
-                        // println!("swap_result.fee_paid = {:?}", swap_result.fee_paid);
-                        // println!("expected_fee = {:?}", expected_fee);
-                        // println!("actual_global_fee = {:?}", actual_global_fee);
-                        // println!("order_liquidity = {:?}", order_liquidity);
-                        // println!("fee_rate = {:?}", fee_rate);
-
-
                         assert_abs_diff_eq!(
                             swap_result.fee_paid,
                             expected_fee,
-                            epsilon = expected_fee / 100
+                            epsilon = expected_fee / 10
                         );
                         assert_abs_diff_eq!(
                             actual_global_fee,
                             expected_fee,
-                            epsilon = expected_fee / 100
+                            epsilon = expected_fee / 10
                         );
 
                         // Tick fees should be updated
diff --git a/pallets/swap/src/tick.rs b/pallets/swap/src/tick.rs
index 7352fd7d7a..61e33f70ea 100644
--- a/pallets/swap/src/tick.rs
+++ b/pallets/swap/src/tick.rs
@@ -1035,6 +1035,7 @@ fn get_tick_at_sqrt_ratio(sqrt_price_x_96: U256) -> Result<i32, TickMathError> {
 ///
 /// # Returns
 /// * `Result<U64F64, TickMathError>` - Converted value or error if too large
+#[allow(dead_code)]
 fn u256_to_u64f64(value: U256, source_fractional_bits: u32) -> Result<U64F64, TickMathError> {
     if value > U256::from(u128::MAX) {
         return Err(TickMathError::ConversionError);

From 0613741dad0bdf957fc751d3b779d7512a23a502 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Wed, 14 May 2025 19:22:06 -0400
Subject: [PATCH 151/418] Swap - fixing tests in progress

---
 pallets/admin-utils/src/lib.rs                |   4 +-
 pallets/subtensor/src/coinbase/block_step.rs  |   2 +-
 .../subtensor/src/coinbase/run_coinbase.rs    |  42 ++--
 pallets/subtensor/src/staking/helpers.rs      |  32 +--
 pallets/subtensor/src/staking/remove_stake.rs |  14 +-
 pallets/subtensor/src/staking/stake_utils.rs  | 198 ++++++++++++------
 pallets/subtensor/src/tests/children.rs       |  40 ++--
 pallets/subtensor/src/tests/coinbase.rs       |  54 +++--
 pallets/subtensor/src/tests/staking.rs        |   4 +-
 pallets/swap/src/pallet/impls.rs              |  10 +
 10 files changed, 252 insertions(+), 148 deletions(-)

diff --git a/pallets/admin-utils/src/lib.rs b/pallets/admin-utils/src/lib.rs
index 32c96fb213..0a76f2f712 100644
--- a/pallets/admin-utils/src/lib.rs
+++ b/pallets/admin-utils/src/lib.rs
@@ -1016,8 +1016,8 @@ pub mod pallet {
             log::trace!("Setting minimum stake to: {}", min_stake);
             pallet_subtensor::Pallet::<T>::set_nominator_min_required_stake(min_stake);
             if min_stake > prev_min_stake {
-                log::trace!("Clearing small nominations");
-                pallet_subtensor::Pallet::<T>::clear_small_nominations()?;
+                log::trace!("Clearing small nominations if possible");
+                pallet_subtensor::Pallet::<T>::clear_small_nominations();
                 log::trace!("Small nominations cleared");
             }
             Ok(())
diff --git a/pallets/subtensor/src/coinbase/block_step.rs b/pallets/subtensor/src/coinbase/block_step.rs
index e28bcb597f..a7e658e89a 100644
--- a/pallets/subtensor/src/coinbase/block_step.rs
+++ b/pallets/subtensor/src/coinbase/block_step.rs
@@ -15,7 +15,7 @@ impl<T: Config + pallet_drand::Config> Pallet<T> {
             U96F32::saturating_from_num(Self::get_block_emission().unwrap_or(0));
         log::debug!("Block emission: {:?}", block_emission);
         // --- 3. Run emission through network.
-        Self::run_coinbase(block_emission).map_err(Into::<&'static str>::into)?;
+        Self::run_coinbase(block_emission);
         // --- 4. Set pending children on the epoch; but only after the coinbase has been run.
         Self::try_set_pending_children(block_number);
         // Return ok.
diff --git a/pallets/subtensor/src/coinbase/run_coinbase.rs b/pallets/subtensor/src/coinbase/run_coinbase.rs
index e7126f65f6..406405d961 100644
--- a/pallets/subtensor/src/coinbase/run_coinbase.rs
+++ b/pallets/subtensor/src/coinbase/run_coinbase.rs
@@ -33,7 +33,7 @@ macro_rules! tou64 {
 }
 
 impl<T: Config> Pallet<T> {
-    pub fn run_coinbase(block_emission: U96F32) -> DispatchResult {
+    pub fn run_coinbase(block_emission: U96F32) {
         // --- 0. Get current block.
         let current_block: u64 = Self::get_current_block_as_u64();
         log::debug!("Current block: {:?}", current_block);
@@ -192,25 +192,29 @@ impl<T: Config> Pallet<T> {
             let pending_alpha: U96F32 = alpha_out_i.saturating_sub(root_alpha);
             log::debug!("pending_alpha: {:?}", pending_alpha);
             // Sell root emission through the pool.
-            let root_tao: u64 = Self::swap_alpha_for_tao(
+
+            let swap_result = Self::swap_alpha_for_tao(
                 *netuid_i,
                 tou64!(root_alpha),
-                T::SwapInterface::max_price(),
-            )?
-            .amount_paid_out;
-            log::debug!("root_tao: {:?}", root_tao);
-            // Accumulate alpha emission in pending.
-            PendingAlphaSwapped::<T>::mutate(*netuid_i, |total| {
-                *total = total.saturating_add(tou64!(root_alpha));
-            });
-            // Accumulate alpha emission in pending.
-            PendingEmission::<T>::mutate(*netuid_i, |total| {
-                *total = total.saturating_add(tou64!(pending_alpha));
-            });
-            // Accumulate root divs for subnet.
-            PendingRootDivs::<T>::mutate(*netuid_i, |total| {
-                *total = total.saturating_add(root_tao);
-            });
+                T::SwapInterface::min_price(),
+            );
+            if let Ok(ok_result) = swap_result {
+                let root_tao: u64 = ok_result.amount_paid_out;
+
+                log::debug!("root_tao: {:?}", root_tao);
+                // Accumulate alpha emission in pending.
+                PendingAlphaSwapped::<T>::mutate(*netuid_i, |total| {
+                    *total = total.saturating_add(tou64!(root_alpha));
+                });
+                // Accumulate alpha emission in pending.
+                PendingEmission::<T>::mutate(*netuid_i, |total| {
+                    *total = total.saturating_add(tou64!(pending_alpha));
+                });
+                // Accumulate root divs for subnet.
+                PendingRootDivs::<T>::mutate(*netuid_i, |total| {
+                    *total = total.saturating_add(root_tao);
+                });
+            }
         }
 
         // --- 7 Update moving prices after using them in the emission calculation.
@@ -266,8 +270,6 @@ impl<T: Config> Pallet<T> {
                 BlocksSinceLastStep::<T>::mutate(netuid, |total| *total = total.saturating_add(1));
             }
         }
-
-        Ok(())
     }
 
     pub fn calculate_dividends_and_incentives(
diff --git a/pallets/subtensor/src/staking/helpers.rs b/pallets/subtensor/src/staking/helpers.rs
index 539ade078f..500cc01f0f 100644
--- a/pallets/subtensor/src/staking/helpers.rs
+++ b/pallets/subtensor/src/staking/helpers.rs
@@ -1,7 +1,7 @@
 use super::*;
 use safe_math::*;
 use substrate_fixed::types::U96F32;
-use subtensor_swap_interface::{OrderType, SwapHandler};
+use subtensor_swap_interface::SwapHandler;
 
 use frame_support::traits::{
     Imbalance,
@@ -70,12 +70,9 @@ impl<T: Config> Pallet<T> {
                         let alpha_stake = Self::get_stake_for_hotkey_and_coldkey_on_subnet(
                             hotkey, coldkey, netuid,
                         );
-                        T::SwapInterface::swap(
+                        Self::sim_swap_alpha_for_tao(
                             netuid,
-                            OrderType::Sell,
                             alpha_stake,
-                            T::SwapInterface::max_price(),
-                            true,
                         )
                         .map(|r| {
                             let fee: u64 = U96F32::saturating_from_num(r.fee_paid)
@@ -177,7 +174,7 @@ impl<T: Config> Pallet<T> {
         hotkey: &T::AccountId,
         coldkey: &T::AccountId,
         netuid: u16,
-    ) -> DispatchResult {
+    ) {
         // Verify if the account is a nominator account by checking ownership of the hotkey by the coldkey.
         if !Self::coldkey_owns_hotkey(coldkey, hotkey) {
             // If the stake is below the minimum required, it's considered a small nomination and needs to be cleared.
@@ -189,32 +186,35 @@ impl<T: Config> Pallet<T> {
                 // Remove the stake from the nominator account. (this is a more forceful unstake operation which )
                 // Actually deletes the staking account.
                 // Do not apply any fees
-                let cleared_stake = Self::unstake_from_subnet(
+                let maybe_cleared_stake = Self::unstake_from_subnet(
                     hotkey,
                     coldkey,
                     netuid,
                     stake,
                     T::SwapInterface::max_price(),
-                )?;
-                // Add the stake to the coldkey account.
-                Self::add_balance_to_coldkey_account(coldkey, cleared_stake);
+                );
+
+                if let Ok(cleared_stake) = maybe_cleared_stake {
+                    // Add the stake to the coldkey account.
+                    Self::add_balance_to_coldkey_account(coldkey, cleared_stake);
+                } else {
+                    // Just clear small alpha
+                    let alpha = Self::get_stake_for_hotkey_and_coldkey_on_subnet(hotkey, coldkey, netuid);
+                    Self::decrease_stake_for_hotkey_and_coldkey_on_subnet(hotkey, coldkey, netuid, alpha);
+                }
             }
         }
-
-        Ok(())
     }
 
     /// Clears small nominations for all accounts.
     ///
     /// WARN: This is an O(N) operation, where N is the number of staking accounts. It should be
     /// used with caution.
-    pub fn clear_small_nominations() -> DispatchResult {
+    pub fn clear_small_nominations() {
         // Loop through all staking accounts to identify and clear nominations below the minimum stake.
         for ((hotkey, coldkey, netuid), _) in Alpha::<T>::iter() {
-            Self::clear_small_nomination_if_required(&hotkey, &coldkey, netuid)?;
+            Self::clear_small_nomination_if_required(&hotkey, &coldkey, netuid);
         }
-
-        Ok(())
     }
 
     pub fn add_balance_to_coldkey_account(
diff --git a/pallets/subtensor/src/staking/remove_stake.rs b/pallets/subtensor/src/staking/remove_stake.rs
index 39d6f925c5..1bf9b0b998 100644
--- a/pallets/subtensor/src/staking/remove_stake.rs
+++ b/pallets/subtensor/src/staking/remove_stake.rs
@@ -47,6 +47,8 @@ impl<T: Config> Pallet<T> {
             alpha_unstaked
         );
 
+        // println!("alpha to be unstaked = {:?}", alpha_unstaked);
+
         // 2. Validate the user input
         Self::validate_remove_stake(
             &coldkey,
@@ -63,14 +65,16 @@ impl<T: Config> Pallet<T> {
             &coldkey,
             netuid,
             alpha_unstaked,
-            T::SwapInterface::max_price(),
+            T::SwapInterface::min_price(),
         )?;
 
+        // println!("tao_unstaked = {:?}, alpha_unstaked = {:?}", tao_unstaked, alpha_unstaked);
+
         // 4. We add the balance to the coldkey. If the above fails we will not credit this coldkey.
         Self::add_balance_to_coldkey_account(&coldkey, tao_unstaked);
 
         // 5. If the stake is below the minimum, we clear the nomination from storage.
-        Self::clear_small_nomination_if_required(&hotkey, &coldkey, netuid)?;
+        Self::clear_small_nomination_if_required(&hotkey, &coldkey, netuid);
 
         // 6. Check if stake lowered below MinStake and remove Pending children if it did
         if Self::get_total_stake_for_hotkey(&hotkey) < StakeThreshold::<T>::get() {
@@ -161,7 +165,7 @@ impl<T: Config> Pallet<T> {
                 Self::add_balance_to_coldkey_account(&coldkey, tao_unstaked);
 
                 // If the stake is below the minimum, we clear the nomination from storage.
-                Self::clear_small_nomination_if_required(&hotkey, &coldkey, netuid)?;
+                Self::clear_small_nomination_if_required(&hotkey, &coldkey, netuid);
             }
         }
 
@@ -250,7 +254,7 @@ impl<T: Config> Pallet<T> {
                     total_tao_unstaked = total_tao_unstaked.saturating_add(tao_unstaked);
 
                     // If the stake is below the minimum, we clear the nomination from storage.
-                    Self::clear_small_nomination_if_required(&hotkey, &coldkey, netuid)?;
+                    Self::clear_small_nomination_if_required(&hotkey, &coldkey, netuid);
                 }
             }
         }
@@ -354,7 +358,7 @@ impl<T: Config> Pallet<T> {
         Self::add_balance_to_coldkey_account(&coldkey, tao_unstaked);
 
         // 6. If the stake is below the minimum, we clear the nomination from storage.
-        Self::clear_small_nomination_if_required(&hotkey, &coldkey, netuid)?;
+        Self::clear_small_nomination_if_required(&hotkey, &coldkey, netuid);
 
         // 7. Check if stake lowered below MinStake and remove Pending children if it did
         if Self::get_total_stake_for_hotkey(&hotkey) < StakeThreshold::<T>::get() {
diff --git a/pallets/subtensor/src/staking/stake_utils.rs b/pallets/subtensor/src/staking/stake_utils.rs
index 0dd71620d1..3756a01835 100644
--- a/pallets/subtensor/src/staking/stake_utils.rs
+++ b/pallets/subtensor/src/staking/stake_utils.rs
@@ -596,6 +596,70 @@ impl<T: Config> Pallet<T> {
         actual_alpha.neg().max(0).unsigned_abs()
     }
 
+    /// Calculates Some(Alpha) returned from pool by staking operation
+    /// if liquidity allows that. If not, returns None.
+    ///
+    /// If new alpha_reserve is about to drop below DefaultMinimumPoolLiquidity,
+    /// then don't do it.
+    ///
+    pub fn sim_swap_tao_for_alpha(netuid: u16, tao: u64) -> Result<SwapResult, DispatchError> {
+        // Step 1: Get the mechanism type for the subnet (0 for Stable, 1 for Dynamic)
+        let mechanism_id: u16 = SubnetMechanism::<T>::get(netuid);
+        // Step 2: Simulate swapping tao and attain alpha
+        if mechanism_id == 1 {
+            let swap_result = T::SwapInterface::swap(
+                netuid,
+                OrderType::Buy,
+                tao,
+                T::SwapInterface::max_price(),
+                true,
+            )
+            .map_err(|_| Error::<T>::InsufficientLiquidity)?;
+
+            Ok(swap_result)
+        } else {
+            // Step 3.b.1: Stable mechanism, just return the value 1:1
+            Ok(SwapResult {
+                amount_paid_out: tao,
+                fee_paid: 0,
+                new_tao_reserve: 0,
+                new_alpha_reserve: 0,
+            })
+        }
+    }
+
+    /// Calculates Some(Tao) returned from pool by unstaking operation
+    /// if liquidity allows that. If not, returns None.
+    ///
+    /// If new tao_reserve is about to drop below DefaultMinimumPoolLiquidity,
+    /// then don't do it.
+    ///
+    pub fn sim_swap_alpha_for_tao(netuid: u16, alpha: u64) -> Result<SwapResult, DispatchError> {
+        // Step 1: Get the mechanism type for the subnet (0 for Stable, 1 for Dynamic)
+        let mechanism_id: u16 = SubnetMechanism::<T>::get(netuid);
+        // Step 2: Simulate swapping alpha and attain tao
+        if mechanism_id == 1 {
+            let swap_result = T::SwapInterface::swap(
+                netuid,
+                OrderType::Sell,
+                alpha,
+                T::SwapInterface::min_price(),
+                true,
+            )
+            .map_err(|_| Error::<T>::InsufficientLiquidity)?;
+
+            Ok(swap_result)
+        } else {
+            // Step 3.b.1: Stable mechanism, just return the value 1:1
+            Ok(SwapResult {
+                amount_paid_out: alpha,
+                fee_paid: 0,
+                new_tao_reserve: 0,
+                new_alpha_reserve: 0,
+            })
+        }
+    }
+
     /// Swaps TAO for the alpha token on the subnet.
     ///
     /// Updates TaoIn, AlphaIn, and AlphaOut
@@ -604,29 +668,41 @@ impl<T: Config> Pallet<T> {
         tao: u64,
         price_limit: u64,
     ) -> Result<SwapResult, DispatchError> {
-        let swap_result = T::SwapInterface::swap(netuid, OrderType::Buy, tao, price_limit, false)?;
-
-        // update Alpha reserves.
-        SubnetAlphaIn::<T>::set(netuid, swap_result.new_alpha_reserve);
-
-        // Increase Alpha outstanding.
-        SubnetAlphaOut::<T>::mutate(netuid, |total| {
-            *total = total.saturating_add(swap_result.amount_paid_out);
-        });
-
-        // update Tao reserves.
-        SubnetTAO::<T>::set(netuid, swap_result.new_tao_reserve);
-
-        // Increase Total Tao reserves.
-        TotalStake::<T>::mutate(|total| *total = total.saturating_add(tao));
-
-        // Increase total subnet TAO volume.
-        SubnetVolume::<T>::mutate(netuid, |total| {
-            *total = total.saturating_add(tao.into());
-        });
-
-        // Return the alpha received.
-        Ok(swap_result)
+        // Step 1: Get the mechanism type for the subnet (0 for Stable, 1 for Dynamic)
+        let mechanism_id: u16 = SubnetMechanism::<T>::get(netuid);
+        if mechanism_id == 1 {
+            let swap_result = T::SwapInterface::swap(netuid, OrderType::Buy, tao, price_limit, false)?;
+
+            // update Alpha reserves.
+            SubnetAlphaIn::<T>::set(netuid, swap_result.new_alpha_reserve);
+    
+            // Increase Alpha outstanding.
+            SubnetAlphaOut::<T>::mutate(netuid, |total| {
+                *total = total.saturating_add(swap_result.amount_paid_out);
+            });
+    
+            // update Tao reserves.
+            SubnetTAO::<T>::set(netuid, swap_result.new_tao_reserve);
+    
+            // Increase Total Tao reserves.
+            TotalStake::<T>::mutate(|total| *total = total.saturating_add(tao));
+    
+            // Increase total subnet TAO volume.
+            SubnetVolume::<T>::mutate(netuid, |total| {
+                *total = total.saturating_add(tao.into());
+            });
+    
+            // Return the alpha received.
+            Ok(swap_result)
+        } else {
+            // Step 3.b.1: Stable mechanism, just return the value 1:1
+            Ok(SwapResult {
+                amount_paid_out: tao,
+                fee_paid: 0,
+                new_tao_reserve: 0,
+                new_alpha_reserve: 0,
+            })
+        }
     }
 
     /// Swaps a subnet's Alpba token for TAO.
@@ -637,30 +713,42 @@ impl<T: Config> Pallet<T> {
         alpha: u64,
         price_limit: u64,
     ) -> Result<SwapResult, DispatchError> {
-        let swap_result =
-            T::SwapInterface::swap(netuid, OrderType::Sell, alpha, price_limit, false)?;
+        // Step 1: Get the mechanism type for the subnet (0 for Stable, 1 for Dynamic)
+        let mechanism_id: u16 = SubnetMechanism::<T>::get(netuid);
+        // Step 2: Swap alpha and attain tao
+        if mechanism_id == 1 {
+            let swap_result = T::SwapInterface::swap(netuid, OrderType::Sell, alpha, price_limit, false)?;
 
-        // Increase Alpha reserves.
-        SubnetAlphaIn::<T>::set(netuid, swap_result.new_alpha_reserve);
+            // Increase Alpha reserves.
+            SubnetAlphaIn::<T>::set(netuid, swap_result.new_alpha_reserve);
 
-        // Decrease Alpha outstanding.
-        SubnetAlphaOut::<T>::mutate(netuid, |total| {
-            *total = total.saturating_sub(alpha);
-        });
+            // Decrease Alpha outstanding.
+            SubnetAlphaOut::<T>::mutate(netuid, |total| {
+                *total = total.saturating_sub(alpha);
+            });
 
-        // Decrease tao reserves.
-        SubnetTAO::<T>::set(netuid, swap_result.new_tao_reserve);
+            // Decrease tao reserves.
+            SubnetTAO::<T>::set(netuid, swap_result.new_tao_reserve);
 
-        // Reduce total TAO reserves.
-        TotalStake::<T>::mutate(|total| *total = total.saturating_sub(swap_result.amount_paid_out));
+            // Reduce total TAO reserves.
+            TotalStake::<T>::mutate(|total| *total = total.saturating_sub(swap_result.amount_paid_out));
 
-        // Increase total subnet TAO volume.
-        SubnetVolume::<T>::mutate(netuid, |total| {
-            *total = total.saturating_add(swap_result.amount_paid_out.into())
-        });
+            // Increase total subnet TAO volume.
+            SubnetVolume::<T>::mutate(netuid, |total| {
+                *total = total.saturating_add(swap_result.amount_paid_out.into())
+            });
 
-        // Return the tao received.
-        Ok(swap_result)
+            // Return the tao received.
+            Ok(swap_result)
+        } else {
+            // Step 3.b.1: Stable mechanism, just return the value 1:1
+            Ok(SwapResult {
+                amount_paid_out: alpha,
+                fee_paid: 0,
+                new_tao_reserve: 0,
+                new_alpha_reserve: 0,
+            })
+        }
     }
 
     /// Unstakes alpha from a subnet for a given hotkey and coldkey pair.
@@ -801,17 +889,14 @@ impl<T: Config> Pallet<T> {
 
         // Get the minimum balance (and amount) that satisfies the transaction
         let min_amount = {
-            let default_stake = DefaultMinStake::<T>::get();
-            let fee = T::SwapInterface::swap(
+            let min_stake = DefaultMinStake::<T>::get();
+            let fee = Self::sim_swap_tao_for_alpha(
                 netuid,
-                OrderType::Buy,
-                default_stake,
-                T::SwapInterface::max_price(),
-                true,
+                min_stake,
             )
             .map(|res| res.fee_paid)
-            .unwrap_or(T::SwapInterface::approx_fee_amount(netuid, default_stake));
-            default_stake.saturating_add(fee)
+            .unwrap_or(T::SwapInterface::approx_fee_amount(netuid, min_stake));
+            min_stake.saturating_add(fee)
         };
 
         // Ensure that the stake_to_be_added is at least the min_amount
@@ -835,12 +920,9 @@ impl<T: Config> Pallet<T> {
             Error::<T>::HotKeyAccountNotExists
         );
 
-        let expected_alpha = T::SwapInterface::swap(
+        let expected_alpha = Self::sim_swap_tao_for_alpha(
             netuid,
-            OrderType::Buy,
             stake_to_be_added,
-            T::SwapInterface::max_price(),
-            true,
         )
         .map_err(|_| Error::<T>::InsufficientLiquidity)?;
 
@@ -874,12 +956,9 @@ impl<T: Config> Pallet<T> {
         ensure!(Self::if_subnet_exist(netuid), Error::<T>::SubnetNotExists);
 
         // Ensure that the stake amount to be removed is above the minimum in tao equivalent.
-        match T::SwapInterface::swap(
+        match Self::sim_swap_alpha_for_tao(
             netuid,
-            OrderType::Sell,
             alpha_unstaked,
-            T::SwapInterface::max_price(),
-            true,
         ) {
             Ok(res) => ensure!(
                 res.amount_paid_out > DefaultMinStake::<T>::get(),
@@ -960,12 +1039,9 @@ impl<T: Config> Pallet<T> {
         );
 
         // Ensure that the stake amount to be removed is above the minimum in tao equivalent.
-        let tao_equivalent = T::SwapInterface::swap(
+        let tao_equivalent = Self::sim_swap_alpha_for_tao(
             origin_netuid,
-            OrderType::Sell,
             alpha_amount,
-            T::SwapInterface::max_price(),
-            true,
         )
         .map(|res| res.amount_paid_out)
         .map_err(|_| Error::<T>::InsufficientLiquidity)?;
diff --git a/pallets/subtensor/src/tests/children.rs b/pallets/subtensor/src/tests/children.rs
index d29fd91184..216f7dee20 100644
--- a/pallets/subtensor/src/tests/children.rs
+++ b/pallets/subtensor/src/tests/children.rs
@@ -2202,53 +2202,55 @@ fn test_do_remove_stake_clears_pending_childkeys() {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
         let child = U256::from(3);
-        let netuid: u16 = 0;
-        let child_netuid: u16 = 1;
+        let netuid: u16 = 1;
         let proportion: u64 = 1000;
 
         // Add network and register hotkey
         add_network(netuid, 13, 0);
-        add_network(child_netuid, 13, 0);
-        register_ok_neuron(child_netuid, hotkey, coldkey, 0);
+        register_ok_neuron(netuid, hotkey, coldkey, 0);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, 10_000_000_000_000);
 
         let reserve = 1_000_000_000_000_000;
         mock::setup_reserves(netuid, reserve, reserve);
-        mock::setup_reserves(child_netuid, reserve, reserve);
 
         // Set non-default value for childkey stake threshold
         StakeThreshold::<Test>::set(1_000_000_000_000);
 
-        let (_, fee) = mock::swap_tao_to_alpha(netuid, StakeThreshold::<Test>::get());
-        SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
-            &hotkey,
-            &coldkey,
+        assert_ok!(SubtensorModule::do_add_stake(
+            RuntimeOrigin::signed(coldkey),
+            hotkey,
             netuid,
-            StakeThreshold::<Test>::get() + fee,
-        );
+            StakeThreshold::<Test>::get() * 2
+        ));
+
+        let alpha = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid);
+
+        println!("StakeThreshold::<Test>::get() = {:?}", StakeThreshold::<Test>::get());
+        println!("alpha                         = {:?}", alpha);
 
         // Attempt to set child
         assert_ok!(SubtensorModule::do_schedule_children(
             RuntimeOrigin::signed(coldkey),
             hotkey,
-            child_netuid,
+            netuid,
             vec![(proportion, child)]
         ));
 
         // Check that pending child exists
-        let pending_before = PendingChildKeys::<Test>::get(child_netuid, hotkey);
+        let pending_before = PendingChildKeys::<Test>::get(netuid, hotkey);
         assert!(!pending_before.0.is_empty());
         assert!(pending_before.1 > 0);
 
         // Remove stake
-        let _ = SubtensorModule::do_remove_stake(
+        assert_ok!(SubtensorModule::do_remove_stake(
             RuntimeOrigin::signed(coldkey),
             hotkey,
             netuid,
-            100_000_000_000,
-        );
+            alpha,
+        ));
 
         // Assert that pending child is removed
-        let pending_after = PendingChildKeys::<Test>::get(child_netuid, hotkey);
+        let pending_after = PendingChildKeys::<Test>::get(netuid, hotkey);
         close(
             pending_after.0.len() as u64,
             0,
@@ -2830,7 +2832,7 @@ fn test_childkey_take_drain() {
 
             // Add network, register hotkeys, and setup network parameters
             add_network(netuid, subnet_tempo, 0);
-            mock::setup_reserves(netuid, stake * 10, stake * 10);
+            mock::setup_reserves(netuid, stake * 10_000, stake * 10_000);
             register_ok_neuron(netuid, child_hotkey, child_coldkey, 0);
             register_ok_neuron(netuid, parent_hotkey, parent_coldkey, 1);
             register_ok_neuron(netuid, miner_hotkey, miner_coldkey, 1);
@@ -3056,7 +3058,7 @@ fn test_parent_child_chain_emission() {
         PendingEmission::<Test>::insert(netuid, 0);
 
         // Run epoch with emission value
-        SubtensorModule::run_coinbase(emission).unwrap();
+        SubtensorModule::run_coinbase(emission);
 
         // Log new stake
         let stake_a_new: u64 = SubtensorModule::get_total_stake_for_hotkey(&hotkey_a);
diff --git a/pallets/subtensor/src/tests/coinbase.rs b/pallets/subtensor/src/tests/coinbase.rs
index 2636d0f3d8..7adcd05896 100644
--- a/pallets/subtensor/src/tests/coinbase.rs
+++ b/pallets/subtensor/src/tests/coinbase.rs
@@ -74,7 +74,7 @@ fn test_dynamic_function_various_values() {
 #[test]
 fn test_coinbase_basecase() {
     new_test_ext(1).execute_with(|| {
-        SubtensorModule::run_coinbase(U96F32::from_num(0.0)).unwrap();
+        SubtensorModule::run_coinbase(U96F32::from_num(0.0));
     });
 }
 
@@ -91,7 +91,7 @@ fn test_coinbase_tao_issuance_base() {
         let emission: u64 = 1_234_567;
         add_network(netuid, 1, 0);
         assert_eq!(SubnetTAO::<Test>::get(netuid), 0);
-        SubtensorModule::run_coinbase(U96F32::from_num(emission)).unwrap();
+        SubtensorModule::run_coinbase(U96F32::from_num(emission));
         assert_eq!(SubnetTAO::<Test>::get(netuid), emission);
         assert_eq!(TotalIssuance::<Test>::get(), emission);
         assert_eq!(TotalStake::<Test>::get(), emission);
@@ -106,7 +106,7 @@ fn test_coinbase_tao_issuance_base_low() {
         let emission: u64 = 1;
         add_network(netuid, 1, 0);
         assert_eq!(SubnetTAO::<Test>::get(netuid), 0);
-        SubtensorModule::run_coinbase(U96F32::from_num(emission)).unwrap();
+        SubtensorModule::run_coinbase(U96F32::from_num(emission));
         assert_eq!(SubnetTAO::<Test>::get(netuid), emission);
         assert_eq!(TotalIssuance::<Test>::get(), emission);
         assert_eq!(TotalStake::<Test>::get(), emission);
@@ -133,7 +133,7 @@ fn test_coinbase_tao_issuance_multiple() {
         assert_eq!(SubnetTAO::<Test>::get(netuid1), 0);
         assert_eq!(SubnetTAO::<Test>::get(netuid2), 0);
         assert_eq!(SubnetTAO::<Test>::get(netuid3), 0);
-        SubtensorModule::run_coinbase(U96F32::from_num(emission)).unwrap();
+        SubtensorModule::run_coinbase(U96F32::from_num(emission));
         assert_eq!(SubnetTAO::<Test>::get(netuid1), emission / 3);
         assert_eq!(SubnetTAO::<Test>::get(netuid2), emission / 3);
         assert_eq!(SubnetTAO::<Test>::get(netuid3), emission / 3);
@@ -166,7 +166,7 @@ fn test_coinbase_tao_issuance_different_prices() {
         assert_eq!(SubnetTAO::<Test>::get(netuid1), 0);
         assert_eq!(SubnetTAO::<Test>::get(netuid2), 0);
         // Run the coinbase with the emission amount.
-        SubtensorModule::run_coinbase(U96F32::from_num(emission)).unwrap();
+        SubtensorModule::run_coinbase(U96F32::from_num(emission));
         // Assert tao emission is split evenly.
         assert_eq!(SubnetTAO::<Test>::get(netuid1), emission / 3);
         assert_eq!(SubnetTAO::<Test>::get(netuid2), emission / 3 + emission / 3);
@@ -306,7 +306,7 @@ fn test_coinbase_alpha_issuance_base() {
         SubnetTAO::<Test>::insert(netuid2, initial);
         SubnetAlphaIn::<Test>::insert(netuid2, initial);
         // Check initial
-        SubtensorModule::run_coinbase(U96F32::from_num(emission)).unwrap();
+        SubtensorModule::run_coinbase(U96F32::from_num(emission));
         // tao_in = 500_000
         // alpha_in = 500_000/price = 500_000
         assert_eq!(SubnetAlphaIn::<Test>::get(netuid1), initial + emission / 2);
@@ -341,7 +341,7 @@ fn test_coinbase_alpha_issuance_different() {
         SubnetMovingPrice::<Test>::insert(netuid1, I96F32::from_num(1));
         SubnetMovingPrice::<Test>::insert(netuid2, I96F32::from_num(2));
         // Run coinbase
-        SubtensorModule::run_coinbase(U96F32::from_num(emission)).unwrap();
+        SubtensorModule::run_coinbase(U96F32::from_num(emission));
         // tao_in = 333_333
         // alpha_in = 333_333/price = 333_333 + initial
         assert_eq!(SubnetAlphaIn::<Test>::get(netuid1), initial + emission / 3);
@@ -377,7 +377,7 @@ fn test_coinbase_alpha_issuance_with_cap_trigger() {
         SubnetMovingPrice::<Test>::insert(netuid1, I96F32::from_num(1));
         SubnetMovingPrice::<Test>::insert(netuid2, I96F32::from_num(2));
         // Run coinbase
-        SubtensorModule::run_coinbase(U96F32::from_num(emission)).unwrap();
+        SubtensorModule::run_coinbase(U96F32::from_num(emission));
         // tao_in = 333_333
         // alpha_in = 333_333/price > 1_000_000_000 --> 1_000_000_000 + initial_alpha
         assert_eq!(
@@ -421,7 +421,7 @@ fn test_coinbase_alpha_issuance_with_cap_trigger_and_block_emission() {
         SubnetMovingPrice::<Test>::insert(netuid1, I96F32::from_num(1));
         SubnetMovingPrice::<Test>::insert(netuid2, I96F32::from_num(2));
         // Run coinbase
-        SubtensorModule::run_coinbase(U96F32::from_num(emission)).unwrap();
+        SubtensorModule::run_coinbase(U96F32::from_num(emission));
         // tao_in = 333_333
         // alpha_in = 333_333/price > 1_000_000_000 --> 0 + initial_alpha
         assert_eq!(SubnetAlphaIn::<Test>::get(netuid1), initial_alpha);
@@ -443,10 +443,10 @@ fn test_owner_cut_base() {
         mock::setup_reserves(netuid, 1_000_000_000_000, 1_000_000_000_000);
         SubtensorModule::set_tempo(netuid, 10000); // Large number (dont drain)
         SubtensorModule::set_subnet_owner_cut(0);
-        SubtensorModule::run_coinbase(U96F32::from_num(0)).unwrap();
+        SubtensorModule::run_coinbase(U96F32::from_num(0));
         assert_eq!(PendingOwnerCut::<Test>::get(netuid), 0); // No cut
         SubtensorModule::set_subnet_owner_cut(u16::MAX);
-        SubtensorModule::run_coinbase(U96F32::from_num(0)).unwrap();
+        SubtensorModule::run_coinbase(U96F32::from_num(0));
         assert_eq!(PendingOwnerCut::<Test>::get(netuid), 1_000_000_000); // Full cut.
     });
 }
@@ -458,21 +458,31 @@ fn test_pending_swapped() {
         let netuid: u16 = 1;
         let emission: u64 = 1_000_000;
         add_network(netuid, 1, 0);
-        mock::setup_reserves(netuid, 1_000_000_000_000, 1_000_000_000_000);
-        SubtensorModule::run_coinbase(U96F32::from_num(0)).unwrap();
+        mock::setup_reserves(netuid, 1_000_000, 1);
+        SubtensorModule::run_coinbase(U96F32::from_num(0));
         assert_eq!(PendingAlphaSwapped::<Test>::get(netuid), 0); // Zero tao weight and no root.
         SubnetTAO::<Test>::insert(0, 1_000_000_000); // Add root weight.
-        SubtensorModule::run_coinbase(U96F32::from_num(0)).unwrap();
+        SubtensorModule::run_coinbase(U96F32::from_num(0));
         assert_eq!(PendingAlphaSwapped::<Test>::get(netuid), 0); // Zero tao weight with 1 root.
         SubtensorModule::set_tempo(netuid, 10000); // Large number (dont drain)
         SubtensorModule::set_tao_weight(u64::MAX); // Set TAO weight to 1.0
-        SubtensorModule::run_coinbase(U96F32::from_num(0)).unwrap();
-        assert_eq!(PendingAlphaSwapped::<Test>::get(netuid), 125000000); // 1 TAO / ( 1 + 3 ) = 0.25 * 1 / 2 = 125000000
-        assert_eq!(
+        SubtensorModule::run_coinbase(U96F32::from_num(0));
+        // 1 TAO / ( 1 + 3 ) = 0.25 * 1 / 2 = 125000000
+        assert_abs_diff_eq!(
+            PendingAlphaSwapped::<Test>::get(netuid),
+            125000000,
+            epsilon = 1
+        );
+        assert_abs_diff_eq!(
             PendingEmission::<Test>::get(netuid),
-            1_000_000_000 - 125000000
+            1_000_000_000 - 125000000,
+            epsilon = 1
         ); // 1 - swapped.
-        assert_eq!(PendingRootDivs::<Test>::get(netuid), 125000000); // swapped * (price = 1)
+        assert_abs_diff_eq!(
+            PendingRootDivs::<Test>::get(netuid),
+            125000000,
+            epsilon = 1
+        ); // swapped * (price = 1)
     });
 }
 
@@ -2024,7 +2034,7 @@ fn test_run_coinbase_not_started() {
         assert!(SubtensorModule::should_run_epoch(netuid, current_block));
 
         // Run coinbase with emission.
-        SubtensorModule::run_coinbase(U96F32::saturating_from_num(100_000_000)).unwrap();
+        SubtensorModule::run_coinbase(U96F32::saturating_from_num(100_000_000));
 
         // We expect that the epoch ran.
         assert_eq!(BlocksSinceLastStep::<Test>::get(netuid), 0);
@@ -2106,7 +2116,7 @@ fn test_run_coinbase_not_started_start_after() {
         assert!(SubtensorModule::should_run_epoch(netuid, current_block));
 
         // Run coinbase with emission.
-        SubtensorModule::run_coinbase(U96F32::saturating_from_num(100_000_000)).unwrap();
+        SubtensorModule::run_coinbase(U96F32::saturating_from_num(100_000_000));
         // We expect that the epoch ran.
         assert_eq!(BlocksSinceLastStep::<Test>::get(netuid), 0);
 
@@ -2126,7 +2136,7 @@ fn test_run_coinbase_not_started_start_after() {
         );
 
         // Run coinbase with emission.
-        SubtensorModule::run_coinbase(U96F32::saturating_from_num(100_000_000)).unwrap();
+        SubtensorModule::run_coinbase(U96F32::saturating_from_num(100_000_000));
         // We expect that the epoch ran.
         assert_eq!(BlocksSinceLastStep::<Test>::get(netuid), 0);
 
diff --git a/pallets/subtensor/src/tests/staking.rs b/pallets/subtensor/src/tests/staking.rs
index e77be3384e..32908e63a2 100644
--- a/pallets/subtensor/src/tests/staking.rs
+++ b/pallets/subtensor/src/tests/staking.rs
@@ -1492,7 +1492,7 @@ fn test_clear_small_nominations() {
         // Run clear all small nominations when min stake is zero (noop)
         SubtensorModule::set_nominator_min_required_stake(0);
         assert_eq!(SubtensorModule::get_nominator_min_required_stake(), 0);
-        SubtensorModule::clear_small_nominations().unwrap();
+        SubtensorModule::clear_small_nominations();
         assert_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hot1, &cold1, netuid),
             100
@@ -1519,7 +1519,7 @@ fn test_clear_small_nominations() {
         SubtensorModule::set_nominator_min_required_stake(1000);
 
         // Run clear all small nominations (removes delegations under 10)
-        SubtensorModule::clear_small_nominations().unwrap();
+        SubtensorModule::clear_small_nominations();
         assert_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hot1, &cold1, netuid),
             100
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index b2ab4c2654..46abdf8dfc 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -110,6 +110,8 @@ impl<T: Config> SwapStep<T> {
             self.action = SwapStepAction::Stop;
             self.final_price = self.sqrt_price_target;
             self.delta_in = self.possible_delta_in;
+
+            // println!("Case 1. Delta in = {:?}", self.delta_in);
         } else if self.price_is_closer(&self.sqrt_price_limit, &self.sqrt_price_target) && self.price_is_closer(&self.sqrt_price_limit, &self.sqrt_price_edge) {
             // Case 2. lim_quantity is the lowest
             // The trade also completely happens within one tick, no tick crossing happens.
@@ -121,6 +123,8 @@ impl<T: Config> SwapStep<T> {
                 self.current_price,
                 self.sqrt_price_limit,
             );
+            // println!("Case 2. Delta in = {:?}", self.delta_in);
+            // println!("Case 2. sqrt_price_limit = {:?}", self.sqrt_price_limit);
         } else {
             // Case 3. edge_quantity is the lowest
             // Tick crossing is likely
@@ -132,6 +136,7 @@ impl<T: Config> SwapStep<T> {
                 self.sqrt_price_edge,
             );
             self.final_price = self.sqrt_price_edge;
+            // println!("Case 3. Delta in = {:?}", self.delta_in);
         }
 
         // Now correct the action if we stopped exactly at the edge no matter what was the case above
@@ -159,6 +164,9 @@ impl<T: Config> SwapStep<T> {
         let total_cost =
             delta_fixed.saturating_mul(u16_max.safe_div(u16_max.saturating_sub(fee_rate)));
 
+        // println!("Executing swap step. order_type = {:?}", self.order_type);
+        // println!("Executing swap step. delta_in = {:?}", self.delta_in);
+
         // Hold the fees
         let fee =
             Pallet::<T>::calculate_fee_amount(self.netuid, total_cost.saturating_to_num::<u64>());
@@ -311,6 +319,8 @@ impl<T: Config> Pallet<T> {
 
         Self::maybe_initialize_v3(netuid)?;
 
+        // println!("swap_inner amount = {:?}", amount);
+
         let mut amount_remaining = amount;
         let mut amount_paid_out: u64 = 0;
         let mut iteration_counter: u16 = 0;

From b04169101ee205c182d0b25c27b6d66c61159e25 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Thu, 15 May 2025 10:25:50 +0800
Subject: [PATCH 152/418] init solution

---
 Cargo.lock                                    | 13 ++++
 Cargo.toml                                    |  1 +
 precompiles/Cargo.toml                        |  1 +
 precompiles/src/extensions.rs                 |  3 +
 precompiles/src/lib.rs                        | 68 ++++++++++++++++++-
 precompiles/src/runtime_call_query.rs         | 53 +++++++++++++++
 precompiles/src/solidity/runtimeCallQuery.abi | 34 ++++++++++
 precompiles/src/solidity/runtimeCallQuery.sol | 14 ++++
 precompiles/src/uid_lookup.rs                 |  4 +-
 9 files changed, 188 insertions(+), 3 deletions(-)
 create mode 100644 precompiles/src/runtime_call_query.rs
 create mode 100644 precompiles/src/solidity/runtimeCallQuery.abi
 create mode 100644 precompiles/src/solidity/runtimeCallQuery.sol

diff --git a/Cargo.lock b/Cargo.lock
index b0c56ffb2e..42dc2f1b20 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6235,6 +6235,18 @@ dependencies = [
  "scale-info",
 ]
 
+[[package]]
+name = "pallet-evm-precompile-dispatch"
+version = "2.0.0-dev"
+source = "git+https://github.com/opentensor/frontier?rev=cd6bca14a3#cd6bca14a366cc7cb1c3b1b1d7bc8213667e4126"
+dependencies = [
+ "fp-evm",
+ "frame-support",
+ "pallet-evm",
+ "parity-scale-codec",
+ "sp-runtime",
+]
+
 [[package]]
 name = "pallet-evm-precompile-modexp"
 version = "2.0.0-dev"
@@ -11070,6 +11082,7 @@ dependencies = [
  "pallet-admin-utils",
  "pallet-balances",
  "pallet-evm",
+ "pallet-evm-precompile-dispatch",
  "pallet-evm-precompile-modexp",
  "pallet-evm-precompile-sha3fips",
  "pallet-evm-precompile-simple",
diff --git a/Cargo.toml b/Cargo.toml
index 548bc5af63..4599d36c23 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -207,6 +207,7 @@ pallet-base-fee = { git = "https://github.com/opentensor/frontier", rev = "cd6bc
 pallet-dynamic-fee = { git = "https://github.com/opentensor/frontier", rev = "cd6bca14a3", default-features = false }
 pallet-ethereum = { git = "https://github.com/opentensor/frontier", rev = "cd6bca14a3", default-features = false }
 pallet-evm = { git = "https://github.com/opentensor/frontier", rev = "cd6bca14a3", default-features = false }
+pallet-evm-precompile-dispatch = { git = "https://github.com/opentensor/frontier", rev = "cd6bca14a3", default-features = false }
 pallet-evm-chain-id = { git = "https://github.com/opentensor/frontier", rev = "cd6bca14a3", default-features = false }
 pallet-evm-precompile-modexp = { git = "https://github.com/opentensor/frontier", rev = "cd6bca14a3", default-features = false }
 pallet-evm-precompile-sha3fips = { git = "https://github.com/opentensor/frontier", rev = "cd6bca14a3", default-features = false }
diff --git a/precompiles/Cargo.toml b/precompiles/Cargo.toml
index ec46e6aee2..b3d318da14 100644
--- a/precompiles/Cargo.toml
+++ b/precompiles/Cargo.toml
@@ -18,6 +18,7 @@ frame-system = { workspace = true }
 log = { workspace = true }
 pallet-balances = { workspace = true }
 pallet-evm = { workspace = true }
+pallet-evm-precompile-dispatch = { workspace = true }
 pallet-evm-precompile-modexp = { workspace = true }
 pallet-evm-precompile-sha3fips = { workspace = true }
 pallet-evm-precompile-simple = { workspace = true }
diff --git a/precompiles/src/extensions.rs b/precompiles/src/extensions.rs
index 1c90922c57..0e1a8490c3 100644
--- a/precompiles/src/extensions.rs
+++ b/precompiles/src/extensions.rs
@@ -9,6 +9,7 @@ use pallet_evm::{
     AddressMapping, BalanceConverter, EvmBalance, ExitError, GasWeightMapping, Precompile,
     PrecompileFailure, PrecompileHandle, PrecompileResult,
 };
+use pallet_evm_precompile_dispatch::Dispatch;
 use precompile_utils::EvmResult;
 use sp_core::{H160, U256, blake2_256};
 use sp_runtime::traits::Dispatchable;
@@ -137,6 +138,8 @@ pub(crate) trait PrecompileExt<AccountId: From<[u8; 32]>>: Precompile {
         R: frame_system::Config + pallet_admin_utils::Config,
     {
         if PrecompileEnable::<R>::get(&precompile_enum) {
+            // Some(Dispatch::<R>::execute(handle))
+
             Some(Self::execute(handle))
         } else {
             Some(Err(PrecompileFailure::Error {
diff --git a/precompiles/src/lib.rs b/precompiles/src/lib.rs
index ca52831323..3ea8bb49dc 100644
--- a/precompiles/src/lib.rs
+++ b/precompiles/src/lib.rs
@@ -4,11 +4,15 @@ extern crate alloc;
 
 use core::marker::PhantomData;
 
-use frame_support::dispatch::{GetDispatchInfo, PostDispatchInfo};
+use frame_support::{
+    dispatch::{GetDispatchInfo, PostDispatchInfo},
+    traits::ConstU32,
+};
 use pallet_evm::{
     AddressMapping, IsPrecompileResult, Precompile, PrecompileHandle, PrecompileResult,
     PrecompileSet,
 };
+use pallet_evm_precompile_dispatch::Dispatch;
 use pallet_evm_precompile_modexp::Modexp;
 use pallet_evm_precompile_sha3fips::Sha3FIPS256;
 use pallet_evm_precompile_simple::{ECRecover, ECRecoverPublicKey, Identity, Ripemd160, Sha256};
@@ -39,6 +43,8 @@ mod uid_lookup;
 
 pub struct Precompiles<R>(PhantomData<R>);
 
+type DecodeLimit = ConstU32<8>;
+
 impl<R> Default for Precompiles<R>
 where
     R: frame_system::Config
@@ -132,6 +138,7 @@ where
             a if a == hash(3) => Some(Ripemd160::execute(handle)),
             a if a == hash(4) => Some(Identity::execute(handle)),
             a if a == hash(5) => Some(Modexp::execute(handle)),
+            // a if a == hash(6) => Some(Dispatch::<R>::execute(handle)),
             // Non-Frontier specific nor Ethereum precompiles :
             a if a == hash(1024) => Some(Sha3FIPS256::execute(handle)),
             a if a == hash(1025) => Some(ECRecoverPublicKey::execute(handle)),
@@ -178,3 +185,62 @@ where
 fn hash(a: u64) -> H160 {
     H160::from_low_u64_be(a)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    struct A;
+    impl PrecompileHandle for A {
+        fn gas_limit(&self) -> Option<u64> {
+            Some(1000000)
+        }
+
+        fn code_address(&self) -> H160 {
+            hash(1)
+        }
+
+        fn input(&self) -> &[u8] {
+            &[0]
+        }
+
+        fn context(&self) -> &fp_evm::Context {
+            unimplemented!()
+        }
+
+        fn is_static(&self) -> bool {
+            false
+        }
+
+        fn remaining_gas(&self) -> u64 {
+            1000000
+        }
+        fn call(
+            &mut self,
+            to: H160,
+            transfer: Option<fp_evm::Transfer>,
+            input: Vec<u8>,
+            gas_limit: Option<u64>,
+            is_static: bool,
+            context: &fp_evm::Context,
+        ) -> (fp_evm::ExitReason, Vec<u8>) {
+            unimplemented!()
+        }
+        fn record_cost(&mut self, cost: u64) -> Result<(), fp_evm::ExitError> {
+            unimplemented!()
+        }
+    }
+
+    #[test]
+    fn test_hash() {
+        let a = A {};
+        let compiles = Precompiles::default();
+        let hash = compiles.execute(&mut a);
+        // assert_eq!(hash, H160::from_low_u64_be(1));
+    }
+
+    #[test]
+    fn test_hash_2() {
+        let hash = hash(2);
+        assert_eq!(hash, H160::from_low_u64_be(2));
+    }
+}
diff --git a/precompiles/src/runtime_call_query.rs b/precompiles/src/runtime_call_query.rs
new file mode 100644
index 0000000000..61fb9d6d7f
--- /dev/null
+++ b/precompiles/src/runtime_call_query.rs
@@ -0,0 +1,53 @@
+use core::marker::PhantomData;
+
+use frame_support::dispatch::{GetDispatchInfo, PostDispatchInfo};
+use pallet_evm::PrecompileHandle;
+use precompile_utils::{EvmResult, prelude::Address};
+use sp_runtime::traits::{Dispatchable, StaticLookup};
+use sp_std::vec::Vec;
+
+use crate::PrecompileExt;
+
+pub(crate) struct UidLookupPrecompile<R>(PhantomData<R>);
+
+impl<R> PrecompileExt<R::AccountId> for UidLookupPrecompile<R>
+where
+    R: frame_system::Config + pallet_subtensor::Config + pallet_evm::Config,
+    R::AccountId: From<[u8; 32]>,
+    <R as frame_system::Config>::RuntimeCall:
+        GetDispatchInfo + Dispatchable<PostInfo = PostDispatchInfo>,
+    <R as frame_system::Config>::RuntimeCall: From<pallet_subtensor::Call<R>>
+        + GetDispatchInfo
+        + Dispatchable<PostInfo = PostDispatchInfo>,
+    <<R as frame_system::Config>::Lookup as StaticLookup>::Source: From<R::AccountId>,
+{
+    const INDEX: u64 = 2054;
+}
+
+#[precompile_utils::precompile]
+impl<R> UidLookupPrecompile<R>
+where
+    R: frame_system::Config + pallet_subtensor::Config + pallet_evm::Config,
+    R::AccountId: From<[u8; 32]>,
+    <R as frame_system::Config>::RuntimeCall:
+        GetDispatchInfo + Dispatchable<PostInfo = PostDispatchInfo>,
+    <R as frame_system::Config>::RuntimeCall: From<pallet_subtensor::Call<R>>
+        + GetDispatchInfo
+        + Dispatchable<PostInfo = PostDispatchInfo>,
+    <<R as frame_system::Config>::Lookup as StaticLookup>::Source: From<R::AccountId>,
+{
+    #[precompile::public("uidLookup(uint16,address,uint16)")]
+    #[precompile::view]
+    fn uid_lookup(
+        _handle: &mut impl PrecompileHandle,
+        netuid: u16,
+        evm_address: Address,
+        limit: u16,
+    ) -> EvmResult<Vec<(u16, u64)>> {
+        Ok(pallet_subtensor::Pallet::<R>::uid_lookup(
+            netuid,
+            evm_address.0,
+            limit,
+        ))
+    }
+}
diff --git a/precompiles/src/solidity/runtimeCallQuery.abi b/precompiles/src/solidity/runtimeCallQuery.abi
new file mode 100644
index 0000000000..ad33075ffc
--- /dev/null
+++ b/precompiles/src/solidity/runtimeCallQuery.abi
@@ -0,0 +1,34 @@
+[
+    {
+        "inputs": [
+            {
+                "internalType": "bytes",
+                "name": "call",
+                "type": "bytes"
+            }
+        ],
+        "name": "call",
+        "outputs": [],
+        "stateMutability": "payable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "bytes",
+                "name": "key",
+                "type": "bytes"
+            }
+        ],
+        "name": "query",
+        "outputs": [
+            {
+                "internalType": "bytes",
+                "name": "result",
+                "type": "bytes"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    }
+]
\ No newline at end of file
diff --git a/precompiles/src/solidity/runtimeCallQuery.sol b/precompiles/src/solidity/runtimeCallQuery.sol
new file mode 100644
index 0000000000..8ae03d1e17
--- /dev/null
+++ b/precompiles/src/solidity/runtimeCallQuery.sol
@@ -0,0 +1,14 @@
+pragma solidity ^0.8.0;
+
+address constant IUID_LOOKUP_ADDRESS = 0x0000000000000000000000000000000000000807;
+
+interface IRuntimeCallQuery {
+    function call(
+        bytes memory call,
+    ) external payable;
+
+    function query(
+        bytes memory key,
+    ) external view returns (bytes memory result);
+}
+
diff --git a/precompiles/src/uid_lookup.rs b/precompiles/src/uid_lookup.rs
index 61fb9d6d7f..3c14e9438f 100644
--- a/precompiles/src/uid_lookup.rs
+++ b/precompiles/src/uid_lookup.rs
@@ -1,13 +1,13 @@
 use core::marker::PhantomData;
 
+use crate::PrecompileExt;
 use frame_support::dispatch::{GetDispatchInfo, PostDispatchInfo};
 use pallet_evm::PrecompileHandle;
+
 use precompile_utils::{EvmResult, prelude::Address};
 use sp_runtime::traits::{Dispatchable, StaticLookup};
 use sp_std::vec::Vec;
 
-use crate::PrecompileExt;
-
 pub(crate) struct UidLookupPrecompile<R>(PhantomData<R>);
 
 impl<R> PrecompileExt<R::AccountId> for UidLookupPrecompile<R>

From 4a6d525c3b9324cf1b4366b509cd74f91b5ae3ee Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Thu, 15 May 2025 10:30:23 +0800
Subject: [PATCH 153/418] call dispatch

---
 precompiles/src/extensions.rs         |  3 --
 precompiles/src/lib.rs                | 61 +--------------------------
 precompiles/src/runtime_call_query.rs | 34 ++-------------
 3 files changed, 4 insertions(+), 94 deletions(-)

diff --git a/precompiles/src/extensions.rs b/precompiles/src/extensions.rs
index 0e1a8490c3..1c90922c57 100644
--- a/precompiles/src/extensions.rs
+++ b/precompiles/src/extensions.rs
@@ -9,7 +9,6 @@ use pallet_evm::{
     AddressMapping, BalanceConverter, EvmBalance, ExitError, GasWeightMapping, Precompile,
     PrecompileFailure, PrecompileHandle, PrecompileResult,
 };
-use pallet_evm_precompile_dispatch::Dispatch;
 use precompile_utils::EvmResult;
 use sp_core::{H160, U256, blake2_256};
 use sp_runtime::traits::Dispatchable;
@@ -138,8 +137,6 @@ pub(crate) trait PrecompileExt<AccountId: From<[u8; 32]>>: Precompile {
         R: frame_system::Config + pallet_admin_utils::Config,
     {
         if PrecompileEnable::<R>::get(&precompile_enum) {
-            // Some(Dispatch::<R>::execute(handle))
-
             Some(Self::execute(handle))
         } else {
             Some(Err(PrecompileFailure::Error {
diff --git a/precompiles/src/lib.rs b/precompiles/src/lib.rs
index 3ea8bb49dc..a9f238310a 100644
--- a/precompiles/src/lib.rs
+++ b/precompiles/src/lib.rs
@@ -138,7 +138,7 @@ where
             a if a == hash(3) => Some(Ripemd160::execute(handle)),
             a if a == hash(4) => Some(Identity::execute(handle)),
             a if a == hash(5) => Some(Modexp::execute(handle)),
-            // a if a == hash(6) => Some(Dispatch::<R>::execute(handle)),
+            a if a == hash(6) => Some(Dispatch::<R>::execute(handle)),
             // Non-Frontier specific nor Ethereum precompiles :
             a if a == hash(1024) => Some(Sha3FIPS256::execute(handle)),
             a if a == hash(1025) => Some(ECRecoverPublicKey::execute(handle)),
@@ -185,62 +185,3 @@ where
 fn hash(a: u64) -> H160 {
     H160::from_low_u64_be(a)
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    struct A;
-    impl PrecompileHandle for A {
-        fn gas_limit(&self) -> Option<u64> {
-            Some(1000000)
-        }
-
-        fn code_address(&self) -> H160 {
-            hash(1)
-        }
-
-        fn input(&self) -> &[u8] {
-            &[0]
-        }
-
-        fn context(&self) -> &fp_evm::Context {
-            unimplemented!()
-        }
-
-        fn is_static(&self) -> bool {
-            false
-        }
-
-        fn remaining_gas(&self) -> u64 {
-            1000000
-        }
-        fn call(
-            &mut self,
-            to: H160,
-            transfer: Option<fp_evm::Transfer>,
-            input: Vec<u8>,
-            gas_limit: Option<u64>,
-            is_static: bool,
-            context: &fp_evm::Context,
-        ) -> (fp_evm::ExitReason, Vec<u8>) {
-            unimplemented!()
-        }
-        fn record_cost(&mut self, cost: u64) -> Result<(), fp_evm::ExitError> {
-            unimplemented!()
-        }
-    }
-
-    #[test]
-    fn test_hash() {
-        let a = A {};
-        let compiles = Precompiles::default();
-        let hash = compiles.execute(&mut a);
-        // assert_eq!(hash, H160::from_low_u64_be(1));
-    }
-
-    #[test]
-    fn test_hash_2() {
-        let hash = hash(2);
-        assert_eq!(hash, H160::from_low_u64_be(2));
-    }
-}
diff --git a/precompiles/src/runtime_call_query.rs b/precompiles/src/runtime_call_query.rs
index 61fb9d6d7f..ecc1e2693c 100644
--- a/precompiles/src/runtime_call_query.rs
+++ b/precompiles/src/runtime_call_query.rs
@@ -8,9 +8,9 @@ use sp_std::vec::Vec;
 
 use crate::PrecompileExt;
 
-pub(crate) struct UidLookupPrecompile<R>(PhantomData<R>);
+pub(crate) struct RuntimeCallQueryPrecompile<R>(PhantomData<R>);
 
-impl<R> PrecompileExt<R::AccountId> for UidLookupPrecompile<R>
+impl<R> PrecompileExt<R::AccountId> for RuntimeCallQueryPrecompile<R>
 where
     R: frame_system::Config + pallet_subtensor::Config + pallet_evm::Config,
     R::AccountId: From<[u8; 32]>,
@@ -21,33 +21,5 @@ where
         + Dispatchable<PostInfo = PostDispatchInfo>,
     <<R as frame_system::Config>::Lookup as StaticLookup>::Source: From<R::AccountId>,
 {
-    const INDEX: u64 = 2054;
-}
-
-#[precompile_utils::precompile]
-impl<R> UidLookupPrecompile<R>
-where
-    R: frame_system::Config + pallet_subtensor::Config + pallet_evm::Config,
-    R::AccountId: From<[u8; 32]>,
-    <R as frame_system::Config>::RuntimeCall:
-        GetDispatchInfo + Dispatchable<PostInfo = PostDispatchInfo>,
-    <R as frame_system::Config>::RuntimeCall: From<pallet_subtensor::Call<R>>
-        + GetDispatchInfo
-        + Dispatchable<PostInfo = PostDispatchInfo>,
-    <<R as frame_system::Config>::Lookup as StaticLookup>::Source: From<R::AccountId>,
-{
-    #[precompile::public("uidLookup(uint16,address,uint16)")]
-    #[precompile::view]
-    fn uid_lookup(
-        _handle: &mut impl PrecompileHandle,
-        netuid: u16,
-        evm_address: Address,
-        limit: u16,
-    ) -> EvmResult<Vec<(u16, u64)>> {
-        Ok(pallet_subtensor::Pallet::<R>::uid_lookup(
-            netuid,
-            evm_address.0,
-            limit,
-        ))
-    }
+    const INDEX: u64 = 2055;
 }

From ae8591320a19de3132930daae44f7f34eef052b3 Mon Sep 17 00:00:00 2001
From: Keith <keith@opentensor.dev>
Date: Fri, 16 May 2025 00:11:57 +0800
Subject: [PATCH 154/418] Add missing trait bounds

---
 precompiles/src/lib.rs | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/precompiles/src/lib.rs b/precompiles/src/lib.rs
index a9f238310a..9968596f32 100644
--- a/precompiles/src/lib.rs
+++ b/precompiles/src/lib.rs
@@ -6,6 +6,7 @@ use core::marker::PhantomData;
 
 use frame_support::{
     dispatch::{GetDispatchInfo, PostDispatchInfo},
+    pallet_prelude::Decode,
     traits::ConstU32,
 };
 use pallet_evm::{
@@ -43,8 +44,6 @@ mod uid_lookup;
 
 pub struct Precompiles<R>(PhantomData<R>);
 
-type DecodeLimit = ConstU32<8>;
-
 impl<R> Default for Precompiles<R>
 where
     R: frame_system::Config
@@ -125,7 +124,10 @@ where
         + From<pallet_balances::Call<R>>
         + From<pallet_admin_utils::Call<R>>
         + GetDispatchInfo
-        + Dispatchable<PostInfo = PostDispatchInfo>,
+        + Dispatchable<PostInfo = PostDispatchInfo>
+        + Decode,
+    <<R as frame_system::Config>::RuntimeCall as Dispatchable>::RuntimeOrigin:
+        From<Option<R::AccountId>>,
     <R as pallet_evm::Config>::AddressMapping: AddressMapping<R::AccountId>,
     <R as pallet_balances::Config>::Balance: TryFrom<U256>,
     <<R as frame_system::Config>::Lookup as StaticLookup>::Source: From<R::AccountId>,

From e51657e0c69fb8b98a749073cf66caf1718fa2eb Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Thu, 15 May 2025 20:13:45 +0200
Subject: [PATCH 155/418] Move swap-related extrinsics to swap pallet

---
 pallets/subtensor/src/lib.rs               |  48 ++++
 pallets/subtensor/src/macros/dispatches.rs | 229 +-----------------
 pallets/subtensor/src/macros/events.rs     |  36 ---
 pallets/subtensor/src/tests/mock.rs        |   1 +
 pallets/swap-interface/src/lib.rs          |  42 ++--
 pallets/swap/src/mock.rs                   |  33 ++-
 pallets/swap/src/pallet/impls.rs           | 123 ++++------
 pallets/swap/src/pallet/mod.rs             | 264 ++++++++++++++++++++-
 runtime/src/lib.rs                         |   1 +
 9 files changed, 407 insertions(+), 370 deletions(-)

diff --git a/pallets/subtensor/src/lib.rs b/pallets/subtensor/src/lib.rs
index c7a28502aa..481e42f384 100644
--- a/pallets/subtensor/src/lib.rs
+++ b/pallets/subtensor/src/lib.rs
@@ -2432,6 +2432,14 @@ impl<T: Config + pallet_balances::Config<Balance = u64>>
         SubnetAlphaIn::<T>::get(netuid)
     }
 
+    fn subnet_exist(netuid: u16) -> bool {
+        Self::if_subnet_exist(netuid)
+    }
+}
+
+impl<T: Config + pallet_balances::Config<Balance = u64>>
+    subtensor_swap_interface::BalanceOps<T::AccountId> for Pallet<T>
+{
     fn tao_balance(account_id: &T::AccountId) -> u64 {
         pallet_balances::Pallet::<T>::free_balance(account_id)
     }
@@ -2439,4 +2447,44 @@ impl<T: Config + pallet_balances::Config<Balance = u64>>
     fn alpha_balance(netuid: u16, coldkey: &T::AccountId, hotkey: &T::AccountId) -> u64 {
         Self::get_stake_for_hotkey_and_coldkey_on_subnet(hotkey, coldkey, netuid)
     }
+
+    fn increase_balance(coldkey: &T::AccountId, tao: u64) {
+        Self::add_balance_to_coldkey_account(&coldkey, tao)
+    }
+
+    fn decrease_balance(coldkey: &T::AccountId, tao: u64) -> Result<u64, DispatchError> {
+        Self::remove_balance_from_coldkey_account(&coldkey, tao)
+    }
+
+    fn increase_stake(
+        coldkey: &T::AccountId,
+        hotkey: &T::AccountId,
+        netuid: u16,
+        alpha: u64,
+    ) -> Result<(), DispatchError> {
+        ensure!(
+            Self::hotkey_account_exists(&hotkey),
+            Error::<T>::HotKeyAccountNotExists
+        );
+
+        Self::increase_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid, alpha);
+
+        Ok(())
+    }
+
+    fn decrease_stake(
+        coldkey: &T::AccountId,
+        hotkey: &T::AccountId,
+        netuid: u16,
+        alpha: u64,
+    ) -> Result<u64, DispatchError> {
+        ensure!(
+            Self::hotkey_account_exists(&hotkey),
+            Error::<T>::HotKeyAccountNotExists
+        );
+
+        Ok(Self::decrease_stake_for_hotkey_and_coldkey_on_subnet(
+            &hotkey, &coldkey, netuid, alpha,
+        ))
+    }
 }
diff --git a/pallets/subtensor/src/macros/dispatches.rs b/pallets/subtensor/src/macros/dispatches.rs
index fcc086eb58..7a25cf2b4f 100644
--- a/pallets/subtensor/src/macros/dispatches.rs
+++ b/pallets/subtensor/src/macros/dispatches.rs
@@ -2023,232 +2023,5 @@ mod dispatches {
         ) -> DispatchResult {
             Self::do_burn_alpha(origin, hotkey, amount, netuid)
         }
-
-        /// Add liquidity to a specific price range for a subnet.
-        ///
-        /// Parameters:
-        /// - origin: The origin of the transaction
-        /// - netuid: Subnet ID
-        /// - tick_low: Lower bound of the price range
-        /// - tick_high: Upper bound of the price range
-        /// - liquidity: Amount of liquidity to add
-        ///
-        /// Emits `Event::LiquidityAdded` on success
-        #[pallet::call_index(103)]
-        #[pallet::weight((
-		Weight::from_parts(50_000_000, 0)
-			.saturating_add(T::DbWeight::get().reads(5))
-			.saturating_add(T::DbWeight::get().writes(4)),
-            DispatchClass::Operational,
-            Pays::Yes
-        ))]
-        pub fn add_liquidity(
-            origin: OriginFor<T>,
-            hotkey: T::AccountId,
-            netuid: u16,
-            tick_low: i32,
-            tick_high: i32,
-            liquidity: u64,
-        ) -> DispatchResult {
-            let coldkey = ensure_signed(origin)?;
-
-            // Ensure that the subnet exists.
-            ensure!(
-                Self::if_subnet_exist(netuid),
-                Error::<T>::SubNetworkDoesNotExist
-            );
-
-            let (position_id, tao, alpha) = T::SwapInterface::add_liquidity(
-                netuid, &coldkey, &hotkey, tick_low, tick_high, liquidity,
-            )?;
-
-            // Remove TAO and Alpha balances or fail transaction if they can't be removed exactly
-            let tao_provided = Self::remove_balance_from_coldkey_account(&coldkey, tao)?;
-            ensure!(tao_provided == tao, Error::<T>::InsufficientBalance);
-
-            let alpha_provided = Self::decrease_stake_for_hotkey_and_coldkey_on_subnet(
-                &hotkey, &coldkey, netuid, alpha,
-            );
-            ensure!(alpha_provided == alpha, Error::<T>::InsufficientBalance);
-
-            // Emit an event
-            Self::deposit_event(Event::LiquidityAdded {
-                coldkey,
-                hotkey,
-                netuid,
-                position_id,
-                liquidity,
-                tao,
-                alpha,
-            });
-
-            Ok(())
-        }
-
-        /// Remove liquidity from a specific position.
-        ///
-        /// Parameters:
-        /// - origin: The origin of the transaction
-        /// - netuid: Subnet ID
-        /// - position_id: ID of the position to remove
-        ///
-        /// Emits `Event::LiquidityRemoved` on success
-        #[pallet::call_index(104)]
-        #[pallet::weight((
-		Weight::from_parts(50_000_000, 0)
-			.saturating_add(T::DbWeight::get().reads(4))
-			.saturating_add(T::DbWeight::get().writes(4)),
-            DispatchClass::Operational,
-            Pays::Yes
-        ))]
-        pub fn remove_liquidity(
-            origin: OriginFor<T>,
-            hotkey: T::AccountId,
-            netuid: u16,
-            position_id: u128,
-        ) -> DispatchResult {
-            let coldkey = ensure_signed(origin)?;
-
-            // Ensure that the subnet exists.
-            ensure!(
-                Self::if_subnet_exist(netuid),
-                Error::<T>::SubNetworkDoesNotExist
-            );
-
-            // Ensure the hotkey account exists
-            ensure!(
-                Self::hotkey_account_exists(&hotkey),
-                Error::<T>::HotKeyAccountNotExists
-            );
-
-            // Remove liquidity
-            let result = T::SwapInterface::remove_liquidity(netuid, &coldkey, position_id)?;
-
-            // Credit the returned tao and alpha to the account
-            Self::add_balance_to_coldkey_account(
-                &coldkey,
-                result.tao.saturating_add(result.fee_tao),
-            );
-            Self::increase_stake_for_hotkey_and_coldkey_on_subnet(
-                &hotkey,
-                &coldkey,
-                netuid,
-                result.alpha.saturating_add(result.fee_alpha),
-            );
-
-            // Emit an event
-            Self::deposit_event(Event::LiquidityRemoved {
-                coldkey,
-                netuid: netuid.into(),
-                position_id,
-                tao: result.tao,
-                alpha: result.alpha,
-                fee_tao: result.fee_tao,
-                fee_alpha: result.fee_alpha,
-            });
-
-            Ok(())
-        }
-
-        /// Modify a liquidity position.
-        ///
-        /// Parameters:
-        /// - origin: The origin of the transaction
-        /// - netuid: Subnet ID
-        /// - position_id: ID of the position to remove
-        /// - liquidity_delta: Liquidity to add (if positive) or remove (if negative)
-        ///
-        /// Emits `Event::LiquidityRemoved` on success
-        #[pallet::call_index(105)]
-        #[pallet::weight((
-		Weight::from_parts(50_000_000, 0)
-			.saturating_add(T::DbWeight::get().reads(4))
-			.saturating_add(T::DbWeight::get().writes(4)),
-            DispatchClass::Operational,
-            Pays::Yes
-        ))]
-        pub fn modify_position(
-            origin: OriginFor<T>,
-            hotkey: T::AccountId,
-            netuid: u16,
-            position_id: u128,
-            liquidity_delta: i64,
-        ) -> DispatchResult {
-            let coldkey = ensure_signed(origin)?;
-
-            // Ensure that the subnet exists.
-            ensure!(
-                Self::if_subnet_exist(netuid),
-                Error::<T>::SubNetworkDoesNotExist
-            );
-
-            // Ensure the hotkey account exists
-            ensure!(
-                Self::hotkey_account_exists(&hotkey),
-                Error::<T>::HotKeyAccountNotExists
-            );
-
-            // Add or remove liquidity
-            let result = T::SwapInterface::modify_position(
-                netuid,
-                &coldkey,
-                &hotkey,
-                position_id,
-                liquidity_delta,
-            )?;
-
-            if liquidity_delta > 0 {
-                // Remove TAO and Alpha balances or fail transaction if they can't be removed exactly
-                let tao_provided = Self::remove_balance_from_coldkey_account(&coldkey, result.tao)?;
-                ensure!(tao_provided == result.tao, Error::<T>::InsufficientBalance);
-
-                let alpha_provided = Self::decrease_stake_for_hotkey_and_coldkey_on_subnet(
-                    &hotkey,
-                    &coldkey,
-                    netuid,
-                    result.alpha,
-                );
-                ensure!(
-                    alpha_provided == result.alpha,
-                    Error::<T>::InsufficientBalance
-                );
-
-                // Emit an event
-                Self::deposit_event(Event::LiquidityAdded {
-                    coldkey,
-                    hotkey,
-                    netuid,
-                    position_id,
-                    liquidity: liquidity_delta as u64,
-                    tao: result.tao,
-                    alpha: result.alpha,
-                });
-            } else {
-                // Credit the returned tao and alpha to the account
-                Self::add_balance_to_coldkey_account(
-                    &coldkey,
-                    result.tao.saturating_add(result.fee_tao),
-                );
-                Self::increase_stake_for_hotkey_and_coldkey_on_subnet(
-                    &hotkey,
-                    &coldkey,
-                    netuid,
-                    result.alpha.saturating_add(result.fee_alpha),
-                );
-
-                // Emit an event
-                Self::deposit_event(Event::LiquidityRemoved {
-                    coldkey,
-                    netuid: netuid.into(),
-                    position_id,
-                    tao: result.tao,
-                    alpha: result.alpha,
-                    fee_tao: result.fee_tao,
-                    fee_alpha: result.fee_alpha,
-                });
-            }
-
-            Ok(())
-        }
-    }
+	}
 }
diff --git a/pallets/subtensor/src/macros/events.rs b/pallets/subtensor/src/macros/events.rs
index 90d68ed8ea..8c2e863d0e 100644
--- a/pallets/subtensor/src/macros/events.rs
+++ b/pallets/subtensor/src/macros/events.rs
@@ -323,41 +323,5 @@ mod events {
         /// - **netuid**: The network identifier.
         /// - **Enabled**: Is Commit-Reveal enabled.
         CommitRevealEnabled(u16, bool),
-
-        /// Event emitted when liquidity is added to a subnet's liquidity pool.
-        LiquidityAdded {
-            /// The coldkey account that owns the position
-            coldkey: T::AccountId,
-            /// The hotkey account associated with the position
-            hotkey: T::AccountId,
-            /// The subnet identifier
-            netuid: u16,
-            /// Unique identifier for the liquidity position
-            position_id: u128,
-            /// The amount of liquidity added to the position
-            liquidity: u64,
-            /// The amount of TAO tokens committed to the position
-            tao: u64,
-            /// The amount of Alpha tokens committed to the position
-            alpha: u64,
-        },
-
-        /// Event emitted when liquidity is removed from a subnet's liquidity pool.
-        LiquidityRemoved {
-            /// The coldkey account that owns the position
-            coldkey: T::AccountId,
-            /// The subnet identifier
-            netuid: u16,
-            /// Unique identifier for the liquidity position
-            position_id: u128,
-            /// The amount of TAO tokens returned to the user
-            tao: u64,
-            /// The amount of Alpha tokens returned to the user
-            alpha: u64,
-            /// The amount of TAO fees earned from the position
-            fee_tao: u64,
-            /// The amount of Alpha fees earned from the position
-            fee_alpha: u64,
-        },
     }
 }
diff --git a/pallets/subtensor/src/tests/mock.rs b/pallets/subtensor/src/tests/mock.rs
index cc6753b552..7e5c437e43 100644
--- a/pallets/subtensor/src/tests/mock.rs
+++ b/pallets/subtensor/src/tests/mock.rs
@@ -432,6 +432,7 @@ impl pallet_subtensor_swap::Config for Test {
     type RuntimeEvent = RuntimeEvent;
     type AdminOrigin = EnsureRoot<AccountId>;
     type LiquidityDataProvider = SubtensorModule;
+    type BalanceOps = SubtensorModule;
     type ProtocolId = SwapProtocolId;
     type MaxFeeRate = SwapMaxFeeRate;
     type MaxPositions = SwapMaxPositions;
diff --git a/pallets/swap-interface/src/lib.rs b/pallets/swap-interface/src/lib.rs
index 264219e17f..9d3ca776d5 100644
--- a/pallets/swap-interface/src/lib.rs
+++ b/pallets/swap-interface/src/lib.rs
@@ -17,26 +17,6 @@ pub trait SwapHandler<AccountId> {
         price_limit: u64,
         should_rollback: bool,
     ) -> Result<SwapResult, DispatchError>;
-    fn add_liquidity(
-        netuid: u16,
-        coldkey_account_id: &AccountId,
-        hotkey_account_id: &AccountId,
-        tick_low: i32,
-        tick_high: i32,
-        liquidity: u64,
-    ) -> Result<(u128, u64, u64), DispatchError>;
-    fn remove_liquidity(
-        netuid: u16,
-        coldkey_account_id: &AccountId,
-        position_id: u128,
-    ) -> Result<UpdateLiquidityResult, DispatchError>;
-    fn modify_position(
-        netuid: u16,
-        coldkey_account_id: &AccountId,
-        hotkey_account_id: &AccountId,
-        position_id: u128,
-        liquidity_delta: i64,
-    ) -> Result<UpdateLiquidityResult, DispatchError>;
     fn approx_fee_amount(netuid: u16, amount: u64) -> u64;
     fn current_alpha_price(netuid: u16) -> U96F32;
     fn max_price() -> u64;
@@ -63,10 +43,24 @@ pub struct UpdateLiquidityResult {
 pub trait LiquidityDataProvider<AccountId> {
     fn tao_reserve(netuid: u16) -> u64;
     fn alpha_reserve(netuid: u16) -> u64;
+    fn subnet_exist(netuid: u16) -> bool;
+}
+
+pub trait BalanceOps<AccountId> {
     fn tao_balance(account_id: &AccountId) -> u64;
-    fn alpha_balance(
+    fn alpha_balance(netuid: u16, coldkey: &AccountId, hotkey: &AccountId) -> u64;
+    fn increase_balance(coldkey: &AccountId, tao: u64);
+    fn decrease_balance(coldkey: &AccountId, tao: u64) -> Result<u64, DispatchError>;
+    fn increase_stake(
+        coldkey: &AccountId,
+        hotkey: &AccountId,
+        netuid: u16,
+        alpha: u64,
+    ) -> Result<(), DispatchError>;
+    fn decrease_stake(
+        coldkey: &AccountId,
+        hotkey: &AccountId,
         netuid: u16,
-        coldkey_account_id: &AccountId,
-        hotkey_account_id: &AccountId,
-    ) -> u64;
+        alpha: u64,
+    ) -> Result<u64, DispatchError>;
 }
diff --git a/pallets/swap/src/mock.rs b/pallets/swap/src/mock.rs
index 5ad5362e35..4fe12926a4 100644
--- a/pallets/swap/src/mock.rs
+++ b/pallets/swap/src/mock.rs
@@ -1,6 +1,7 @@
 use core::num::NonZeroU64;
 
 use frame_support::construct_runtime;
+use frame_support::pallet_prelude::*;
 use frame_support::{
     PalletId, parameter_types,
     traits::{ConstU32, Everything},
@@ -11,7 +12,7 @@ use sp_runtime::{
     BuildStorage,
     traits::{BlakeTwo256, IdentityLookup},
 };
-use subtensor_swap_interface::LiquidityDataProvider;
+use subtensor_swap_interface::{BalanceOps, LiquidityDataProvider};
 
 construct_runtime!(
     pub enum Test {
@@ -88,6 +89,14 @@ impl LiquidityDataProvider<AccountId> for MockLiquidityProvider {
         }
     }
 
+    fn subnet_exist(_netuid: u16) -> bool {
+        true
+    }
+}
+
+pub struct MockBalanceOps;
+
+impl BalanceOps<AccountId> for MockBalanceOps {
     fn tao_balance(account_id: &AccountId) -> u64 {
         if *account_id == OK_COLDKEY_ACCOUNT_ID {
             100_000_000_000_000
@@ -105,12 +114,34 @@ impl LiquidityDataProvider<AccountId> for MockLiquidityProvider {
             1_000_000_000
         }
     }
+
+    fn increase_balance(_coldkey: &AccountId, _tao: u64) {}
+    fn decrease_balance(_coldkey: &AccountId, _tao: u64) -> Result<u64, DispatchError> {
+        Ok(0)
+    }
+    fn increase_stake(
+        _coldkey: &AccountId,
+        _hotkey: &AccountId,
+        _netuid: u16,
+        _alpha: u64,
+    ) -> Result<(), DispatchError> {
+        Ok(())
+    }
+    fn decrease_stake(
+        _coldkey: &AccountId,
+        _hotkey: &AccountId,
+        _netuid: u16,
+        _alpha: u64,
+    ) -> Result<u64, DispatchError> {
+        Ok(0)
+    }
 }
 
 impl crate::pallet::Config for Test {
     type RuntimeEvent = RuntimeEvent;
     type AdminOrigin = EnsureRoot<AccountId>;
     type LiquidityDataProvider = MockLiquidityProvider;
+    type BalanceOps = MockBalanceOps;
     type ProtocolId = SwapProtocolId;
     type MaxFeeRate = MaxFeeRate;
     type MaxPositions = MaxPositions;
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 15dd1090e7..b1078d2565 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -7,7 +7,7 @@ use sp_arithmetic::helpers_128bit;
 use sp_runtime::traits::AccountIdConversion;
 use substrate_fixed::types::{U64F64, U96F32};
 use subtensor_swap_interface::{
-    LiquidityDataProvider, SwapHandler, SwapResult, UpdateLiquidityResult,
+    BalanceOps, LiquidityDataProvider, SwapHandler, SwapResult, UpdateLiquidityResult,
 };
 
 use super::pallet::*;
@@ -104,13 +104,17 @@ impl<T: Config> SwapStep<T> {
         // Calculate the stopping price: The price at which we either reach the limit price,
         // exchange the full amount, or reach the edge price.
 
-        if self.price_is_closer(&self.sqrt_price_target, &self.sqrt_price_limit) && self.price_is_closer(&self.sqrt_price_target, &self.sqrt_price_edge) {
+        if self.price_is_closer(&self.sqrt_price_target, &self.sqrt_price_limit)
+            && self.price_is_closer(&self.sqrt_price_target, &self.sqrt_price_edge)
+        {
             // Case 1. target_quantity is the lowest
             // The trade completely happens within one tick, no tick crossing happens.
             self.action = SwapStepAction::Stop;
             self.final_price = self.sqrt_price_target;
             self.delta_in = self.possible_delta_in;
-        } else if self.price_is_closer(&self.sqrt_price_limit, &self.sqrt_price_target) && self.price_is_closer(&self.sqrt_price_limit, &self.sqrt_price_edge) {
+        } else if self.price_is_closer(&self.sqrt_price_limit, &self.sqrt_price_target)
+            && self.price_is_closer(&self.sqrt_price_limit, &self.sqrt_price_edge)
+        {
             // Case 2. lim_quantity is the lowest
             // The trade also completely happens within one tick, no tick crossing happens.
             self.action = SwapStepAction::Stop;
@@ -137,11 +141,12 @@ impl<T: Config> SwapStep<T> {
         // Now correct the action if we stopped exactly at the edge no matter what was the case above
         // Because order type buy moves the price up and tick semi-open interval doesn't include its right
         // point, we cross on buys and stop on sells.
-        let natural_reason_stop_price = if self.price_is_closer(&self.sqrt_price_limit, &self.sqrt_price_target) {
-            self.sqrt_price_limit
-        } else {
-            self.sqrt_price_target
-        };
+        let natural_reason_stop_price =
+            if self.price_is_closer(&self.sqrt_price_limit, &self.sqrt_price_target) {
+                self.sqrt_price_limit
+            } else {
+                self.sqrt_price_target
+            };
         if natural_reason_stop_price == self.sqrt_price_edge {
             self.action = match self.order_type {
                 OrderType::Buy => SwapStepAction::Crossing,
@@ -404,7 +409,9 @@ impl<T: Config> Pallet<T> {
 
         let current_price_tick =
             TickIndex::try_from_sqrt_price(current_price).unwrap_or(fallback_tick);
-        let roundtrip_current_price = current_price_tick.try_to_sqrt_price().unwrap_or(SqrtPrice::from_num(0));
+        let roundtrip_current_price = current_price_tick
+            .try_to_sqrt_price()
+            .unwrap_or(SqrtPrice::from_num(0));
 
         (match order_type {
             OrderType::Buy => {
@@ -418,11 +425,16 @@ impl<T: Config> Pallet<T> {
                 }
             }
             OrderType::Sell => {
-                let mut lower_tick = ActiveTickIndexManager::find_closest_lower::<T>(netuid, current_price_tick)
-                    .unwrap_or(TickIndex::MIN);
+                let mut lower_tick =
+                    ActiveTickIndexManager::find_closest_lower::<T>(netuid, current_price_tick)
+                        .unwrap_or(TickIndex::MIN);
 
                 if current_price == roundtrip_current_price {
-                    lower_tick = ActiveTickIndexManager::find_closest_lower::<T>(netuid, lower_tick.prev().unwrap_or(TickIndex::MIN)).unwrap_or(TickIndex::MIN);
+                    lower_tick = ActiveTickIndexManager::find_closest_lower::<T>(
+                        netuid,
+                        lower_tick.prev().unwrap_or(TickIndex::MIN),
+                    )
+                    .unwrap_or(TickIndex::MIN);
                 }
                 lower_tick
             }
@@ -626,7 +638,7 @@ impl<T: Config> Pallet<T> {
     /// - [`SwapError::InsufficientBalance`] if the account does not have enough balance.
     /// - [`SwapError::InvalidTickRange`] if `tick_low` is greater than or equal to `tick_high`.
     /// - Other [`SwapError`] variants as applicable.
-    pub fn add_liquidity(
+    pub fn do_add_liquidity(
         netuid: NetUid,
         coldkey_account_id: &T::AccountId,
         hotkey_account_id: &T::AccountId,
@@ -644,8 +656,8 @@ impl<T: Config> Pallet<T> {
         let position_id = position.id;
 
         ensure!(
-            T::LiquidityDataProvider::tao_balance(coldkey_account_id) >= tao
-                && T::LiquidityDataProvider::alpha_balance(
+            T::BalanceOps::tao_balance(coldkey_account_id) >= tao
+                && T::BalanceOps::alpha_balance(
                     netuid.into(),
                     coldkey_account_id,
                     hotkey_account_id
@@ -729,7 +741,7 @@ impl<T: Config> Pallet<T> {
     /// Remove liquidity and credit balances back to (coldkey_account_id, hotkey_account_id) stake
     ///
     /// Account ID and Position ID identify position in the storage map
-    pub fn remove_liquidity(
+    pub fn do_remove_liquidity(
         netuid: NetUid,
         coldkey_account_id: &T::AccountId,
         position_id: PositionId,
@@ -779,7 +791,7 @@ impl<T: Config> Pallet<T> {
         })
     }
 
-    pub fn modify_position(
+    pub fn do_modify_position(
         netuid: NetUid,
         coldkey_account_id: &T::AccountId,
         hotkey_account_id: &T::AccountId,
@@ -836,8 +848,8 @@ impl<T: Config> Pallet<T> {
         if liquidity_delta > 0 {
             // Check that user has enough balances
             ensure!(
-                T::LiquidityDataProvider::tao_balance(coldkey_account_id) >= tao
-                    && T::LiquidityDataProvider::alpha_balance(
+                T::BalanceOps::tao_balance(coldkey_account_id) >= tao
+                    && T::BalanceOps::alpha_balance(
                         netuid.into(),
                         coldkey_account_id,
                         hotkey_account_id
@@ -1030,55 +1042,6 @@ impl<T: Config> SwapHandler<T::AccountId> for Pallet<T> {
         .map_err(Into::into)
     }
 
-    fn add_liquidity(
-        netuid: u16,
-        coldkey_account_id: &T::AccountId,
-        hotkey_account_id: &T::AccountId,
-        tick_low: i32,
-        tick_high: i32,
-        liquidity: u64,
-    ) -> Result<(u128, u64, u64), DispatchError> {
-        let tick_low = TickIndex::new(tick_low).map_err(|_| Error::<T>::InvalidTickRange)?;
-        let tick_high = TickIndex::new(tick_high).map_err(|_| Error::<T>::InvalidTickRange)?;
-
-        Self::add_liquidity(
-            NetUid::from(netuid),
-            coldkey_account_id,
-            hotkey_account_id,
-            tick_low,
-            tick_high,
-            liquidity,
-        )
-        .map(|(pid, t, a)| (pid.into(), t, a))
-        .map_err(Into::into)
-    }
-
-    fn remove_liquidity(
-        netuid: u16,
-        coldkey_account_id: &T::AccountId,
-        position_id: u128,
-    ) -> Result<UpdateLiquidityResult, DispatchError> {
-        Self::remove_liquidity(netuid.into(), coldkey_account_id, position_id.into())
-            .map_err(Into::into)
-    }
-
-    fn modify_position(
-        netuid: u16,
-        coldkey_account_id: &T::AccountId,
-        hotkey_account_id: &T::AccountId,
-        position_id: u128,
-        liquidity_delta: i64,
-    ) -> Result<UpdateLiquidityResult, DispatchError> {
-        Self::modify_position(
-            netuid.into(),
-            coldkey_account_id,
-            hotkey_account_id,
-            position_id.into(),
-            liquidity_delta,
-        )
-        .map_err(Into::into)
-    }
-
     fn approx_fee_amount(netuid: u16, amount: u64) -> u64 {
         Self::calculate_fee_amount(netuid.into(), amount)
     }
@@ -1332,7 +1295,7 @@ mod tests {
                     let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
 
                     // Add liquidity
-                    let (position_id, tao, alpha) = Pallet::<Test>::add_liquidity(
+                    let (position_id, tao, alpha) = Pallet::<Test>::do_add_liquidity(
                         netuid,
                         &OK_COLDKEY_ACCOUNT_ID,
                         &OK_HOTKEY_ACCOUNT_ID,
@@ -1434,7 +1397,7 @@ mod tests {
 
                 // Add liquidity
                 assert_err!(
-                    Swap::add_liquidity(
+                    Swap::do_add_liquidity(
                         netuid,
                         &OK_COLDKEY_ACCOUNT_ID,
                         &OK_HOTKEY_ACCOUNT_ID,
@@ -1474,7 +1437,7 @@ mod tests {
 
                 // Add liquidity
                 assert_err!(
-                    Pallet::<Test>::add_liquidity(
+                    Pallet::<Test>::do_add_liquidity(
                         netuid,
                         &coldkey_account_id,
                         &hotkey_account_id,
@@ -1547,7 +1510,7 @@ mod tests {
                 let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
 
                 // Add liquidity
-                let (position_id, _, _) = Pallet::<Test>::add_liquidity(
+                let (position_id, _, _) = Pallet::<Test>::do_add_liquidity(
                     netuid,
                     &OK_COLDKEY_ACCOUNT_ID,
                     &OK_HOTKEY_ACCOUNT_ID,
@@ -1559,7 +1522,7 @@ mod tests {
 
                 // Remove liquidity
                 let remove_result =
-                    Pallet::<Test>::remove_liquidity(netuid, &OK_COLDKEY_ACCOUNT_ID, position_id)
+                    Pallet::<Test>::do_remove_liquidity(netuid, &OK_COLDKEY_ACCOUNT_ID, position_id)
                         .unwrap();
                 assert_abs_diff_eq!(remove_result.tao, tao, epsilon = tao / 1000);
                 assert_abs_diff_eq!(remove_result.alpha, alpha, epsilon = alpha / 1000);
@@ -1600,7 +1563,7 @@ mod tests {
             assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
 
             // Add liquidity
-            assert_ok!(Pallet::<Test>::add_liquidity(
+            assert_ok!(Pallet::<Test>::do_add_liquidity(
                 netuid,
                 &OK_COLDKEY_ACCOUNT_ID,
                 &OK_HOTKEY_ACCOUNT_ID,
@@ -1613,7 +1576,7 @@ mod tests {
 
             // Remove liquidity
             assert_err!(
-                Pallet::<Test>::remove_liquidity(
+                Pallet::<Test>::do_remove_liquidity(
                     netuid,
                     &OK_COLDKEY_ACCOUNT_ID,
                     PositionId::new::<Test>()
@@ -1656,7 +1619,7 @@ mod tests {
                 assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
 
                 // Add liquidity
-                let (position_id, _, _) = Pallet::<Test>::add_liquidity(
+                let (position_id, _, _) = Pallet::<Test>::do_add_liquidity(
                     netuid,
                     &OK_COLDKEY_ACCOUNT_ID,
                     &OK_HOTKEY_ACCOUNT_ID,
@@ -1679,7 +1642,7 @@ mod tests {
 
                 // Modify liquidity (also causes claiming of fees)
                 let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
-                let modify_result = Pallet::<Test>::modify_position(
+                let modify_result = Pallet::<Test>::do_modify_position(
                     netuid,
                     &OK_COLDKEY_ACCOUNT_ID,
                     &OK_HOTKEY_ACCOUNT_ID,
@@ -1708,7 +1671,7 @@ mod tests {
                 assert_eq!(position.tick_high, tick_high);
 
                 // Modify liquidity again (ensure fees aren't double-collected)
-                let modify_result = Pallet::<Test>::modify_position(
+                let modify_result = Pallet::<Test>::do_modify_position(
                     netuid,
                     &OK_COLDKEY_ACCOUNT_ID,
                     &OK_HOTKEY_ACCOUNT_ID,
@@ -1964,7 +1927,7 @@ mod tests {
                         let price_high = price_high_offset + current_price;
                         let tick_low = price_to_tick(price_low);
                         let tick_high = price_to_tick(price_high);
-                        let (_position_id, _tao, _alpha) = Pallet::<Test>::add_liquidity(
+                        let (_position_id, _tao, _alpha) = Pallet::<Test>::do_add_liquidity(
                             netuid,
                             &OK_COLDKEY_ACCOUNT_ID,
                             &OK_HOTKEY_ACCOUNT_ID,
@@ -2197,7 +2160,7 @@ mod tests {
                     let price_high = price_high_offset + current_price;
                     let tick_low = price_to_tick(price_low);
                     let tick_high = price_to_tick(price_high);
-                    let (_position_id, _tao, _alpha) = Pallet::<Test>::add_liquidity(
+                    let (_position_id, _tao, _alpha) = Pallet::<Test>::do_add_liquidity(
                         netuid,
                         &OK_COLDKEY_ACCOUNT_ID,
                         &OK_HOTKEY_ACCOUNT_ID,
diff --git a/pallets/swap/src/pallet/mod.rs b/pallets/swap/src/pallet/mod.rs
index 3a44cb4601..bcf7e16f00 100644
--- a/pallets/swap/src/pallet/mod.rs
+++ b/pallets/swap/src/pallet/mod.rs
@@ -3,7 +3,7 @@ use core::num::NonZeroU64;
 use frame_support::{PalletId, pallet_prelude::*, traits::Get};
 use frame_system::pallet_prelude::*;
 use substrate_fixed::types::U64F64;
-use subtensor_swap_interface::LiquidityDataProvider;
+use subtensor_swap_interface::{BalanceOps, LiquidityDataProvider};
 
 use crate::{
     NetUid,
@@ -37,6 +37,10 @@ mod pallet {
         /// [`LiquidityDataProvider`](subtensor_swap_interface::LiquidityDataProvider).
         type LiquidityDataProvider: LiquidityDataProvider<Self::AccountId>;
 
+        /// Implementor of
+        /// [`BalanceOps`](subtensor_swap_interface::BalanceOps).
+        type BalanceOps: BalanceOps<Self::AccountId>;
+
         /// This type is used to derive protocol accoun ID.
         #[pallet::constant]
         type ProtocolId: Get<PalletId>;
@@ -135,6 +139,42 @@ mod pallet {
     pub enum Event<T: Config> {
         /// Event emitted when the fee rate has been updated for a subnet
         FeeRateSet { netuid: NetUid, rate: u16 },
+
+        /// Event emitted when liquidity is added to a subnet's liquidity pool.
+        LiquidityAdded {
+            /// The coldkey account that owns the position
+            coldkey: T::AccountId,
+            /// The hotkey account associated with the position
+            hotkey: T::AccountId,
+            /// The subnet identifier
+            netuid: u16,
+            /// Unique identifier for the liquidity position
+            position_id: u128,
+            /// The amount of liquidity added to the position
+            liquidity: u64,
+            /// The amount of TAO tokens committed to the position
+            tao: u64,
+            /// The amount of Alpha tokens committed to the position
+            alpha: u64,
+        },
+
+        /// Event emitted when liquidity is removed from a subnet's liquidity pool.
+        LiquidityRemoved {
+            /// The coldkey account that owns the position
+            coldkey: T::AccountId,
+            /// The subnet identifier
+            netuid: u16,
+            /// Unique identifier for the liquidity position
+            position_id: u128,
+            /// The amount of TAO tokens returned to the user
+            tao: u64,
+            /// The amount of Alpha tokens returned to the user
+            alpha: u64,
+            /// The amount of TAO fees earned from the position
+            fee_tao: u64,
+            /// The amount of Alpha fees earned from the position
+            fee_alpha: u64,
+        },
     }
 
     #[pallet::error]
@@ -172,6 +212,9 @@ mod pallet {
 
         /// Reserves too low for operation.
         ReservesTooLow,
+
+        /// The subnet does not exist.
+        SubNetworkDoesNotExist,
     }
 
     #[pallet::call]
@@ -185,6 +228,12 @@ mod pallet {
         pub fn set_fee_rate(origin: OriginFor<T>, netuid: u16, rate: u16) -> DispatchResult {
             T::AdminOrigin::ensure_origin(origin)?;
 
+            // Ensure that the subnet exists.
+            ensure!(
+                T::LiquidityDataProvider::subnet_exist(netuid),
+                Error::<T>::SubNetworkDoesNotExist
+            );
+
             // using u16 for compatibility
             let netuid = netuid.into();
 
@@ -196,6 +245,219 @@ mod pallet {
 
             Ok(())
         }
+
+        /// Add liquidity to a specific price range for a subnet.
+        ///
+        /// Parameters:
+        /// - origin: The origin of the transaction
+        /// - netuid: Subnet ID
+        /// - tick_low: Lower bound of the price range
+        /// - tick_high: Upper bound of the price range
+        /// - liquidity: Amount of liquidity to add
+        ///
+        /// Emits `Event::LiquidityAdded` on success
+        #[pallet::call_index(1)]
+        #[pallet::weight((
+		Weight::from_parts(50_000_000, 0)
+			.saturating_add(T::DbWeight::get().reads(5))
+			.saturating_add(T::DbWeight::get().writes(4)),
+            DispatchClass::Operational,
+            Pays::Yes
+        ))]
+        pub fn add_liquidity(
+            origin: OriginFor<T>,
+            hotkey: T::AccountId,
+            netuid: u16,
+            tick_low: i32,
+            tick_high: i32,
+            liquidity: u64,
+        ) -> DispatchResult {
+            let coldkey = ensure_signed(origin)?;
+
+            // Ensure that the subnet exists.
+            ensure!(
+                T::LiquidityDataProvider::subnet_exist(netuid),
+                Error::<T>::SubNetworkDoesNotExist
+            );
+
+            let tick_low = TickIndex::new(tick_low).map_err(|_| Error::<T>::InvalidTickRange)?;
+            let tick_high = TickIndex::new(tick_high).map_err(|_| Error::<T>::InvalidTickRange)?;
+            let (position_id, tao, alpha) = Self::do_add_liquidity(
+                netuid.into(),
+                &coldkey,
+                &hotkey,
+                tick_low,
+                tick_high,
+                liquidity,
+            )?;
+
+            // Remove TAO and Alpha balances or fail transaction if they can't be removed exactly
+            let tao_provided = T::BalanceOps::decrease_balance(&coldkey, tao)?;
+            ensure!(tao_provided == tao, Error::<T>::InsufficientBalance);
+
+            let alpha_provided = T::BalanceOps::decrease_stake(&coldkey, &hotkey, netuid, alpha)?;
+            ensure!(alpha_provided == alpha, Error::<T>::InsufficientBalance);
+
+            // Emit an event
+            Self::deposit_event(Event::LiquidityAdded {
+                coldkey,
+                hotkey,
+                netuid,
+                position_id: position_id.into(),
+                liquidity,
+                tao,
+                alpha,
+            });
+
+            Ok(())
+        }
+
+        /// Remove liquidity from a specific position.
+        ///
+        /// Parameters:
+        /// - origin: The origin of the transaction
+        /// - netuid: Subnet ID
+        /// - position_id: ID of the position to remove
+        ///
+        /// Emits `Event::LiquidityRemoved` on success
+        #[pallet::call_index(2)]
+        #[pallet::weight((
+		Weight::from_parts(50_000_000, 0)
+			.saturating_add(T::DbWeight::get().reads(4))
+			.saturating_add(T::DbWeight::get().writes(4)),
+            DispatchClass::Operational,
+            Pays::Yes
+        ))]
+        pub fn remove_liquidity(
+            origin: OriginFor<T>,
+            hotkey: T::AccountId,
+            netuid: u16,
+            position_id: u128,
+        ) -> DispatchResult {
+            let coldkey = ensure_signed(origin)?;
+
+            // Ensure that the subnet exists.
+            ensure!(
+                T::LiquidityDataProvider::subnet_exist(netuid),
+                Error::<T>::SubNetworkDoesNotExist
+            );
+
+            // Remove liquidity
+            let result = Self::do_remove_liquidity(netuid.into(), &coldkey, position_id.into())?;
+
+            // Credit the returned tao and alpha to the account
+            T::BalanceOps::increase_balance(&coldkey, result.tao.saturating_add(result.fee_tao));
+            T::BalanceOps::increase_stake(
+                &coldkey,
+                &hotkey,
+                netuid,
+                result.alpha.saturating_add(result.fee_alpha),
+            )?;
+
+            // Emit an event
+            Self::deposit_event(Event::LiquidityRemoved {
+                coldkey,
+                netuid: netuid.into(),
+                position_id,
+                tao: result.tao,
+                alpha: result.alpha,
+                fee_tao: result.fee_tao,
+                fee_alpha: result.fee_alpha,
+            });
+
+            Ok(())
+        }
+
+        /// Modify a liquidity position.
+        ///
+        /// Parameters:
+        /// - origin: The origin of the transaction
+        /// - netuid: Subnet ID
+        /// - position_id: ID of the position to remove
+        /// - liquidity_delta: Liquidity to add (if positive) or remove (if negative)
+        ///
+        /// Emits `Event::LiquidityRemoved` on success
+        #[pallet::call_index(3)]
+        #[pallet::weight((
+		Weight::from_parts(50_000_000, 0)
+			.saturating_add(T::DbWeight::get().reads(4))
+			.saturating_add(T::DbWeight::get().writes(4)),
+            DispatchClass::Operational,
+            Pays::Yes
+        ))]
+        pub fn modify_position(
+            origin: OriginFor<T>,
+            hotkey: T::AccountId,
+            netuid: u16,
+            position_id: u128,
+            liquidity_delta: i64,
+        ) -> DispatchResult {
+            let coldkey = ensure_signed(origin)?;
+
+            // Ensure that the subnet exists.
+            ensure!(
+                T::LiquidityDataProvider::subnet_exist(netuid),
+                Error::<T>::SubNetworkDoesNotExist
+            );
+
+            // Add or remove liquidity
+            let result = Self::do_modify_position(
+                netuid.into(),
+                &coldkey,
+                &hotkey,
+                position_id.into(),
+                liquidity_delta,
+            )?;
+
+            if liquidity_delta > 0 {
+                // Remove TAO and Alpha balances or fail transaction if they can't be removed exactly
+                let tao_provided = T::BalanceOps::decrease_balance(&coldkey, result.tao)?;
+                ensure!(tao_provided == result.tao, Error::<T>::InsufficientBalance);
+
+                let alpha_provided =
+                    T::BalanceOps::decrease_stake(&coldkey, &hotkey, netuid, result.alpha)?;
+                ensure!(
+                    alpha_provided == result.alpha,
+                    Error::<T>::InsufficientBalance
+                );
+
+                // Emit an event
+                Self::deposit_event(Event::LiquidityAdded {
+                    coldkey,
+                    hotkey,
+                    netuid,
+                    position_id,
+                    liquidity: liquidity_delta as u64,
+                    tao: result.tao,
+                    alpha: result.alpha,
+                });
+            } else {
+                // Credit the returned tao and alpha to the account
+                T::BalanceOps::increase_balance(
+                    &coldkey,
+                    result.tao.saturating_add(result.fee_tao),
+                );
+                T::BalanceOps::increase_stake(
+                    &coldkey,
+                    &hotkey,
+                    netuid,
+                    result.alpha.saturating_add(result.fee_alpha),
+                )?;
+
+                // Emit an event
+                Self::deposit_event(Event::LiquidityRemoved {
+                    coldkey,
+                    netuid: netuid.into(),
+                    position_id,
+                    tao: result.tao,
+                    alpha: result.alpha,
+                    fee_tao: result.fee_tao,
+                    fee_alpha: result.fee_alpha,
+                });
+            }
+
+            Ok(())
+        }
     }
 }
 
diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index 4bef958ebe..fc32639868 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -1132,6 +1132,7 @@ impl pallet_subtensor_swap::Config for Runtime {
     type RuntimeEvent = RuntimeEvent;
     type AdminOrigin = EnsureRoot<AccountId>;
     type LiquidityDataProvider = SubtensorModule;
+	type BalanceOps = SubtensorModule;
     type ProtocolId = SwapProtocolId;
     type MaxFeeRate = SwapMaxFeeRate;
     type MaxPositions = SwapMaxPositions;

From 95c63ebdd1c5d5f88bd8f108a8249fbf9614fa5f Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Thu, 15 May 2025 18:12:54 -0400
Subject: [PATCH 156/418] Swap tests and cleanup in progress

---
 pallets/subtensor/src/lib.rs                  |   4 +
 pallets/subtensor/src/staking/add_stake.rs    |  44 +---
 pallets/subtensor/src/staking/helpers.rs      |   2 +-
 pallets/subtensor/src/staking/move_stake.rs   |   2 +-
 pallets/subtensor/src/staking/remove_stake.rs |  52 +----
 pallets/subtensor/src/staking/stake_utils.rs  |   4 +
 pallets/subtensor/src/tests/epoch.rs          |  19 +-
 pallets/subtensor/src/tests/mock.rs           |  73 +++---
 pallets/subtensor/src/tests/move_stake.rs     |   4 +-
 pallets/subtensor/src/tests/senate.rs         |  59 ++---
 pallets/subtensor/src/tests/staking.rs        | 220 +++++++++---------
 pallets/swap-interface/src/lib.rs             |   2 +
 pallets/swap/src/mock.rs                      |   8 +
 pallets/swap/src/pallet/impls.rs              |  44 ++--
 14 files changed, 250 insertions(+), 287 deletions(-)

diff --git a/pallets/subtensor/src/lib.rs b/pallets/subtensor/src/lib.rs
index c7a28502aa..20e82ebb22 100644
--- a/pallets/subtensor/src/lib.rs
+++ b/pallets/subtensor/src/lib.rs
@@ -2439,4 +2439,8 @@ impl<T: Config + pallet_balances::Config<Balance = u64>>
     fn alpha_balance(netuid: u16, coldkey: &T::AccountId, hotkey: &T::AccountId) -> u64 {
         Self::get_stake_for_hotkey_and_coldkey_on_subnet(hotkey, coldkey, netuid)
     }
+
+    fn subnet_mechanism(netuid: u16) -> u16 {
+        SubnetMechanism::<T>::get(netuid)
+    }
 }
diff --git a/pallets/subtensor/src/staking/add_stake.rs b/pallets/subtensor/src/staking/add_stake.rs
index 4852efc2c5..631abac6fc 100644
--- a/pallets/subtensor/src/staking/add_stake.rs
+++ b/pallets/subtensor/src/staking/add_stake.rs
@@ -1,6 +1,6 @@
 use super::*;
 use substrate_fixed::types::I96F32;
-use subtensor_swap_interface::SwapHandler;
+use subtensor_swap_interface::{SwapHandler, OrderType};
 
 impl<T: Config> Pallet<T> {
     /// ---- The implementation for the extrinsic add_stake: Adds stake to a hotkey account.
@@ -184,44 +184,12 @@ impl<T: Config> Pallet<T> {
             }
         }
 
-        // Corner case: SubnetAlphaIn is zero. Staking can't happen, so max amount is zero.
-        let alpha_in = SubnetAlphaIn::<T>::get(netuid);
-        if alpha_in == 0 {
-            return 0;
-        }
-        let alpha_in_u128 = alpha_in as u128;
-
-        // Corner case: SubnetTAO is zero. Staking can't happen, so max amount is zero.
-        let tao_reserve = SubnetTAO::<T>::get(netuid);
-        if tao_reserve == 0 {
-            return 0;
-        }
-        let tao_reserve_u128 = tao_reserve as u128;
-
-        // Corner case: limit_price < current_price (price cannot decrease with staking)
-        let tao = 1_000_000_000_u128;
-        let limit_price_u128 = limit_price as u128;
-        if (limit_price_u128
-            < T::SwapInterface::current_alpha_price(netuid)
-                .saturating_to_num::<u128>()
-                .saturating_mul(tao))
-            || (limit_price == 0u64)
-        {
-            return 0;
-        }
-
-        // Main case: return limit_price * SubnetAlphaIn - SubnetTAO
-        // Non overflowing calculation: limit_price * alpha_in <= u64::MAX * u64::MAX <= u128::MAX
-        // May overflow result, then it will be capped at u64::MAX, which is OK because that matches balance u64 size.
-        let result = limit_price_u128
-            .saturating_mul(alpha_in_u128)
-            .checked_div(tao)
-            .unwrap_or(0)
-            .saturating_sub(tao_reserve_u128);
-        if result < u64::MAX as u128 {
-            result as u64
+        // Use reverting swap to estimate max limit amount
+        if let Ok(swap_result) = T::SwapInterface::swap(netuid, OrderType::Buy, u64::MAX, limit_price, true) {
+            swap_result.amount_paid_in.saturating_add(swap_result.fee_paid)
         } else {
-            u64::MAX
+            0
         }
     }
 }
+
diff --git a/pallets/subtensor/src/staking/helpers.rs b/pallets/subtensor/src/staking/helpers.rs
index 500cc01f0f..995f16afb3 100644
--- a/pallets/subtensor/src/staking/helpers.rs
+++ b/pallets/subtensor/src/staking/helpers.rs
@@ -191,7 +191,7 @@ impl<T: Config> Pallet<T> {
                     coldkey,
                     netuid,
                     stake,
-                    T::SwapInterface::max_price(),
+                    T::SwapInterface::min_price(),
                 );
 
                 if let Ok(cleared_stake) = maybe_cleared_stake {
diff --git a/pallets/subtensor/src/staking/move_stake.rs b/pallets/subtensor/src/staking/move_stake.rs
index 64fb3130d0..1207a41340 100644
--- a/pallets/subtensor/src/staking/move_stake.rs
+++ b/pallets/subtensor/src/staking/move_stake.rs
@@ -343,7 +343,7 @@ impl<T: Config> Pallet<T> {
             origin_coldkey,
             origin_netuid,
             move_amount,
-            T::SwapInterface::max_price(),
+            T::SwapInterface::min_price(),
         )?;
 
         // Stake the unstaked amount into the destination.
diff --git a/pallets/subtensor/src/staking/remove_stake.rs b/pallets/subtensor/src/staking/remove_stake.rs
index 1bf9b0b998..c2d0ff61f2 100644
--- a/pallets/subtensor/src/staking/remove_stake.rs
+++ b/pallets/subtensor/src/staking/remove_stake.rs
@@ -1,5 +1,5 @@
 use super::*;
-use subtensor_swap_interface::SwapHandler;
+use subtensor_swap_interface::{SwapHandler, OrderType};
 
 impl<T: Config> Pallet<T> {
     /// ---- The implementation for the extrinsic remove_stake: Removes stake from a hotkey account and adds it onto a coldkey.
@@ -384,53 +384,11 @@ impl<T: Config> Pallet<T> {
             }
         }
 
-        // Corner case: SubnetAlphaIn is zero. Staking can't happen, so max amount is zero.
-        let alpha_in = SubnetAlphaIn::<T>::get(netuid);
-        if alpha_in == 0 {
-            return 0;
-        }
-        let alpha_in_u128 = alpha_in as u128;
-
-        // Corner case: SubnetTAO is zero. Staking can't happen, so max amount is zero.
-        let tao_reserve = SubnetTAO::<T>::get(netuid);
-        if tao_reserve == 0 {
-            return 0;
-        }
-        let tao_reserve_u128 = tao_reserve as u128;
-
-        // Corner case: limit_price == 0 (because there's division by limit price)
-        // => can sell all
-        if limit_price == 0 {
-            return u64::MAX;
-        }
-
-        // Corner case: limit_price >= current_price (price cannot increase with unstaking)
-        // No overflows: alpha_price * tao <= u64::MAX * u64::MAX
-        // Alpha price is U96F32 size, but it is calculated as u64/u64, so it never uses all 96 bits.
-        let limit_price_u128 = limit_price as u128;
-        let tao = 1_000_000_000_u128;
-        if limit_price_u128
-            >= tao_reserve_u128
-                .saturating_mul(tao)
-                .checked_div(alpha_in_u128)
-                .unwrap_or(0)
-        {
-            return 0;
-        }
-
-        // Main case: SubnetTAO / limit_price - SubnetAlphaIn
-        // Non overflowing calculation: tao_reserve * tao <= u64::MAX * u64::MAX <= u128::MAX
-        // May overflow result, then it will be capped at u64::MAX, which is OK because that matches Alpha u64 size.
-        let result = tao_reserve_u128
-            .saturating_mul(tao)
-            .checked_div(limit_price_u128)
-            .unwrap_or(0)
-            .saturating_sub(alpha_in_u128);
-
-        if result < u64::MAX as u128 {
-            result as u64
+        // Use reverting swap to estimate max limit amount
+        if let Ok(swap_result) = T::SwapInterface::swap(netuid, OrderType::Sell, u64::MAX, limit_price, true) {
+            swap_result.amount_paid_in.saturating_add(swap_result.fee_paid)
         } else {
-            u64::MAX
+            0
         }
     }
 }
diff --git a/pallets/subtensor/src/staking/stake_utils.rs b/pallets/subtensor/src/staking/stake_utils.rs
index 3756a01835..2a7b72da8f 100644
--- a/pallets/subtensor/src/staking/stake_utils.rs
+++ b/pallets/subtensor/src/staking/stake_utils.rs
@@ -620,6 +620,7 @@ impl<T: Config> Pallet<T> {
         } else {
             // Step 3.b.1: Stable mechanism, just return the value 1:1
             Ok(SwapResult {
+                amount_paid_in: tao,
                 amount_paid_out: tao,
                 fee_paid: 0,
                 new_tao_reserve: 0,
@@ -652,6 +653,7 @@ impl<T: Config> Pallet<T> {
         } else {
             // Step 3.b.1: Stable mechanism, just return the value 1:1
             Ok(SwapResult {
+                amount_paid_in: alpha,
                 amount_paid_out: alpha,
                 fee_paid: 0,
                 new_tao_reserve: 0,
@@ -697,6 +699,7 @@ impl<T: Config> Pallet<T> {
         } else {
             // Step 3.b.1: Stable mechanism, just return the value 1:1
             Ok(SwapResult {
+                amount_paid_in: tao,
                 amount_paid_out: tao,
                 fee_paid: 0,
                 new_tao_reserve: 0,
@@ -743,6 +746,7 @@ impl<T: Config> Pallet<T> {
         } else {
             // Step 3.b.1: Stable mechanism, just return the value 1:1
             Ok(SwapResult {
+                amount_paid_in: alpha,
                 amount_paid_out: alpha,
                 fee_paid: 0,
                 new_tao_reserve: 0,
diff --git a/pallets/subtensor/src/tests/epoch.rs b/pallets/subtensor/src/tests/epoch.rs
index b6ddefdef1..4c3a3bc2d2 100644
--- a/pallets/subtensor/src/tests/epoch.rs
+++ b/pallets/subtensor/src/tests/epoch.rs
@@ -560,17 +560,20 @@ fn test_1_graph() {
         let coldkey = U256::from(0);
         let hotkey = U256::from(0);
         let uid: u16 = 0;
-        let stake_amount: u64 = 1;
+        let stake_amount: u64 = 1_000_000_000;
         add_network(netuid, u16::MAX - 1, 0); // set higher tempo to avoid built-in epoch, then manual epoch instead
         SubtensorModule::set_max_allowed_uids(netuid, 1);
-        SubtensorModule::add_balance_to_coldkey_account(&coldkey, stake_amount);
-        SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
-            &hotkey,
-            &coldkey,
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, stake_amount + ExistentialDeposit::get());
+        register_ok_neuron(netuid, hotkey, coldkey, 1);
+        SubtensorModule::set_weights_set_rate_limit(netuid, 0);
+
+        assert_ok!(SubtensorModule::add_stake(
+            RuntimeOrigin::signed(coldkey),
+            hotkey,
             netuid,
-            stake_amount,
-        );
-        SubtensorModule::append_neuron(netuid, &hotkey, 0);
+            stake_amount
+        ));
+
         assert_eq!(SubtensorModule::get_subnetwork_n(netuid), 1);
         run_to_block(1); // run to next block to ensure weights are set on nodes after their registration block
         assert_ok!(SubtensorModule::set_weights(
diff --git a/pallets/subtensor/src/tests/mock.rs b/pallets/subtensor/src/tests/mock.rs
index cc6753b552..f784d32571 100644
--- a/pallets/subtensor/src/tests/mock.rs
+++ b/pallets/subtensor/src/tests/mock.rs
@@ -863,39 +863,56 @@ pub(crate) fn setup_reserves(netuid: u16, tao: u64, alpha: u64) {
 }
 
 pub(crate) fn swap_tao_to_alpha(netuid: u16, tao: u64) -> (u64, u64) {
-    let result = <Test as pallet::Config>::SwapInterface::swap(
-        netuid,
-        OrderType::Buy,
-        tao,
-        <Test as pallet::Config>::SwapInterface::max_price(),
-        true,
-    );
-
-    assert_ok!(&result);
-
-    let result = result.unwrap();
-
-    // we don't want to have silent 0 comparissons in tests
-    assert!(result.amount_paid_out > 0);
-
-    (result.amount_paid_out, result.fee_paid)
+    match netuid {
+        0 => {
+            (tao, 0)
+        },
+        _ => {
+            let result = <Test as pallet::Config>::SwapInterface::swap(
+                netuid,
+                OrderType::Buy,
+                tao,
+                <Test as pallet::Config>::SwapInterface::max_price(),
+                true,
+            );
+        
+            assert_ok!(&result);
+        
+            let result = result.unwrap();
+        
+            // we don't want to have silent 0 comparissons in tests
+            assert!(result.amount_paid_out > 0);
+        
+            (result.amount_paid_out, result.fee_paid)
+        }        
+    }
 }
 
 pub(crate) fn swap_alpha_to_tao(netuid: u16, alpha: u64) -> (u64, u64) {
-    let result = <Test as pallet::Config>::SwapInterface::swap(
-        netuid,
-        OrderType::Sell,
-        alpha,
-        <Test as pallet::Config>::SwapInterface::max_price(),
-        true,
-    );
+    match netuid {
+        0 => {
+            (alpha, 0)
+        },
+        _ => {
+
+            println!("<Test as pallet::Config>::SwapInterface::min_price() = {:?}", <Test as pallet::Config>::SwapInterface::min_price());
 
-    assert_ok!(&result);
+            let result = <Test as pallet::Config>::SwapInterface::swap(
+                netuid,
+                OrderType::Sell,
+                alpha,
+                <Test as pallet::Config>::SwapInterface::min_price(),
+                true,
+            );
 
-    let result = result.unwrap();
+            assert_ok!(&result);
 
-    // we don't want to have silent 0 comparissons in tests
-    assert!(result.amount_paid_out > 0);
+            let result = result.unwrap();
 
-    (result.amount_paid_out, result.fee_paid)
+            // we don't want to have silent 0 comparissons in tests
+            assert!(result.amount_paid_out > 0);
+
+            (result.amount_paid_out, result.fee_paid)
+        }
+    }
 }
diff --git a/pallets/subtensor/src/tests/move_stake.rs b/pallets/subtensor/src/tests/move_stake.rs
index 4f6ccb6d7f..30186c3300 100644
--- a/pallets/subtensor/src/tests/move_stake.rs
+++ b/pallets/subtensor/src/tests/move_stake.rs
@@ -868,7 +868,7 @@ fn test_do_move_max_values() {
                 netuid
             ),
             alpha_after_fee,
-            epsilon = alpha_after_fee / 1_000_000
+            epsilon = alpha_after_fee / 100_000
         );
     });
 }
@@ -1808,7 +1808,7 @@ fn test_stake_transfers_disabled_validate() {
 }
 
 #[test]
-// RUST_LOG=info cargo test --package pallet-subtensor --lib -- tests::staking::test_move_stake_specific_stake_into_subnet_fail --exact --show-output
+// RUST_LOG=info cargo test --package pallet-subtensor --lib -- tests::move_stake::test_move_stake_specific_stake_into_subnet_fail --exact --show-output
 fn test_move_stake_specific_stake_into_subnet_fail() {
     new_test_ext(1).execute_with(|| {
         let sn_owner_coldkey = U256::from(55453);
diff --git a/pallets/subtensor/src/tests/senate.rs b/pallets/subtensor/src/tests/senate.rs
index 64eaef266c..8030d59022 100644
--- a/pallets/subtensor/src/tests/senate.rs
+++ b/pallets/subtensor/src/tests/senate.rs
@@ -75,7 +75,7 @@ fn test_senate_join_works() {
         // Give it some $$$ in his coldkey balance
         SubtensorModule::add_balance_to_coldkey_account(&coldkey_account_id, 10000);
 
-        let reserve = stake * 1000;
+        let reserve = 1_000_000_000;
         mock::setup_reserves(netuid, reserve, reserve);
 
         // Subscribe and check extrinsic output
@@ -103,7 +103,6 @@ fn test_senate_join_works() {
         let staker_coldkey = U256::from(7);
         SubtensorModule::add_balance_to_coldkey_account(&staker_coldkey, stake);
 
-        let (_, fee) = mock::swap_tao_to_alpha(netuid, stake);
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(staker_coldkey),
             hotkey_account_id,
@@ -111,21 +110,19 @@ fn test_senate_join_works() {
             stake
         ));
 
-        let approx_expected = stake - fee;
-
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
                 &hotkey_account_id,
                 &staker_coldkey,
                 netuid
             ),
-            approx_expected,
-            epsilon = approx_expected / 1000
+            stake,
+            epsilon = 1
         );
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_on_subnet(&hotkey_account_id, netuid),
-            approx_expected,
-            epsilon = approx_expected / 1000
+            stake,
+            epsilon = 1
         );
 
         assert_ok!(SubtensorModule::root_register(
@@ -183,7 +180,6 @@ fn test_senate_vote_works() {
         let stake = DefaultMinStake::<Test>::get() * 10;
         SubtensorModule::add_balance_to_coldkey_account(&staker_coldkey, stake);
 
-        let (_, fee) = mock::swap_tao_to_alpha(netuid, stake);
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(staker_coldkey),
             hotkey_account_id,
@@ -191,20 +187,19 @@ fn test_senate_vote_works() {
             stake
         ));
 
-        let approx_expected = stake - fee;
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
                 &hotkey_account_id,
                 &staker_coldkey,
                 netuid
             ),
-            approx_expected,
-            epsilon = approx_expected / 1000
+            stake,
+            epsilon = 1
         );
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_on_subnet(&hotkey_account_id, netuid),
-            approx_expected,
-            epsilon = approx_expected / 1000
+            stake,
+            epsilon = 1
         );
 
         assert_ok!(SubtensorModule::root_register(
@@ -364,7 +359,6 @@ fn test_senate_leave_works() {
         let staker_coldkey = U256::from(7);
         SubtensorModule::add_balance_to_coldkey_account(&staker_coldkey, stake);
 
-        let (_, fee) = mock::swap_tao_to_alpha(netuid, stake);
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(staker_coldkey),
             hotkey_account_id,
@@ -372,20 +366,19 @@ fn test_senate_leave_works() {
             stake
         ));
 
-        let approx_expected = stake - fee;
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
                 &hotkey_account_id,
                 &staker_coldkey,
                 netuid
             ),
-            approx_expected,
-            epsilon = approx_expected / 1000
+            stake,
+            epsilon = 1
         );
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_on_subnet(&hotkey_account_id, netuid),
-            approx_expected,
-            epsilon = approx_expected / 1000
+            stake,
+            epsilon = 1
         );
 
         assert_ok!(SubtensorModule::root_register(
@@ -444,7 +437,6 @@ fn test_senate_leave_vote_removal() {
         let staker_coldkey = U256::from(7);
         SubtensorModule::add_balance_to_coldkey_account(&staker_coldkey, stake);
 
-        let (_, fee) = mock::swap_tao_to_alpha(netuid, stake);
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(staker_coldkey),
             hotkey_account_id,
@@ -452,21 +444,19 @@ fn test_senate_leave_vote_removal() {
             stake
         ));
 
-        let approx_expected = stake - fee;
-
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
                 &hotkey_account_id,
                 &staker_coldkey,
                 netuid
             ),
-            approx_expected,
-            epsilon = approx_expected / 1000
+            stake,
+            epsilon = 1
         );
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_on_subnet(&hotkey_account_id, netuid),
-            approx_expected,
-            epsilon = approx_expected / 1000
+            stake,
+            epsilon = 1
         );
 
         assert_ok!(SubtensorModule::root_register(
@@ -598,8 +588,6 @@ fn test_senate_not_leave_when_stake_removed() {
         let stake_amount: u64 = DefaultMinStake::<Test>::get() * 10;
         SubtensorModule::add_balance_to_coldkey_account(&staker_coldkey, stake_amount);
 
-        let (_, fee) = mock::swap_tao_to_alpha(netuid, stake_amount);
-
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(staker_coldkey),
             hotkey_account_id,
@@ -607,20 +595,19 @@ fn test_senate_not_leave_when_stake_removed() {
             stake_amount
         ));
 
-        let approx_expected = stake_amount - fee;
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
                 &hotkey_account_id,
                 &staker_coldkey,
                 netuid
             ),
-            approx_expected,
-            epsilon = approx_expected / 1000
+            stake_amount,
+            epsilon = 1
         );
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_on_subnet(&hotkey_account_id, netuid),
-            approx_expected,
-            epsilon = approx_expected / 1000
+            stake_amount,
+            epsilon = 1
         );
 
         assert_ok!(SubtensorModule::root_register(
@@ -757,7 +744,7 @@ fn test_adjust_senate_events() {
         SubtensorModule::set_max_registrations_per_block(root_netuid, max_senate_size + 1);
         SubtensorModule::set_target_registrations_per_interval(root_netuid, max_senate_size + 1);
 
-        let reserve = 1_000_000_000_000;
+        let reserve = 100_000_000_000_000;
         mock::setup_reserves(netuid, reserve, reserve);
 
         // Subscribe and check extrinsic output
@@ -847,7 +834,7 @@ fn test_adjust_senate_events() {
         // Add/delegate enough stake to join the senate
         let stake = DefaultMinStake::<Test>::get() * 10;
 
-        let reserve = stake * 1000;
+        let reserve = 100_000_000_000_000;
         mock::setup_reserves(root_netuid, reserve, reserve);
 
         let (_, fee) = mock::swap_tao_to_alpha(root_netuid, stake);
diff --git a/pallets/subtensor/src/tests/staking.rs b/pallets/subtensor/src/tests/staking.rs
index 32908e63a2..85165286b7 100644
--- a/pallets/subtensor/src/tests/staking.rs
+++ b/pallets/subtensor/src/tests/staking.rs
@@ -51,7 +51,7 @@ fn test_add_stake_ok_no_emission() {
         //add network
         let netuid = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
 
-        mock::setup_reserves(netuid, amount * 10, amount * 100);
+        mock::setup_reserves(netuid, amount * 1_000_000, amount * 10_000_000);
 
         // Give it some $$$ in his coldkey balance
         SubtensorModule::add_balance_to_coldkey_account(&coldkey_account_id, amount);
@@ -2872,119 +2872,116 @@ fn test_max_amount_add_stable() {
 // cargo test --package pallet-subtensor --lib -- tests::staking::test_max_amount_add_dynamic --exact --show-output
 #[test]
 fn test_max_amount_add_dynamic() {
-    new_test_ext(0).execute_with(|| {
-        let subnet_owner_coldkey = U256::from(1001);
-        let subnet_owner_hotkey = U256::from(1002);
-        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
-
-        // Test cases are generated with help with this limit-staking calculator:
-        // https://docs.google.com/spreadsheets/d/1pfU-PVycd3I4DbJIc0GjtPohy4CbhdV6CWqgiy__jKE
-        // This is for reference only; verify before use.
-        //
-        // CSV backup for this spreadhsheet:
-        //
-        // SubnetTAO,AlphaIn,initial price,limit price,max swappable
-        // 100,100,=A2/B2,4,=B8*D8-A8
-        //
-        // tao_in, alpha_in, limit_price, expected_max_swappable
-        [
-            // Zero handling (no panics)
-            (0, 1_000_000_000, 100, 0),
-            (1_000_000_000, 0, 100, 0),
-            (1_000_000_000, 1_000_000_000, 0, 0),
-            // Low bounds
-            (1, 1, 0, 0),
-            (1, 1, 1, 0),
-            (1, 1, 2, 0),
-            (1, 1, 50_000_000_000, 49),
-            // Basic math
-            (1_000, 1_000, 2_000_000_000, 1_000),
-            (1_000, 1_000, 4_000_000_000, 3_000),
-            (1_000, 1_000, 16_000_000_000, 15_000),
-            (
-                1_000_000_000_000,
-                1_000_000_000_000,
-                16_000_000_000,
-                15_000_000_000_000,
-            ),
-            // Normal range values with edge cases
-            (150_000_000_000, 100_000_000_000, 0, 0),
-            (150_000_000_000, 100_000_000_000, 100_000_000, 0),
-            (150_000_000_000, 100_000_000_000, 500_000_000, 0),
-            (150_000_000_000, 100_000_000_000, 1_499_999_999, 0),
-            (150_000_000_000, 100_000_000_000, 1_500_000_000, 0),
-            (150_000_000_000, 100_000_000_000, 1_500_000_001, 100),
-            (
-                150_000_000_000,
-                100_000_000_000,
-                3_000_000_000,
-                150_000_000_000,
-            ),
-            // Miscellaneous overflows and underflows
-            (150_000_000_000, 100_000_000_000, u64::MAX, u64::MAX),
-            (150_000_000_000, 100_000_000_000, u64::MAX / 2, u64::MAX),
-            (1_000_000, 1_000_000_000_000_000_000_u64, 1, 999_000_000),
-            (1_000_000, 1_000_000_000_000_000_000_u64, 2, 1_999_000_000),
-            (
-                1_000_000,
-                1_000_000_000_000_000_000_u64,
-                10_000,
-                9_999_999_000_000,
-            ),
-            (
-                1_000_000,
-                1_000_000_000_000_000_000_u64,
-                100_000,
-                99_999_999_000_000,
-            ),
-            (
-                1_000_000,
-                1_000_000_000_000_000_000_u64,
-                1_000_000,
-                999_999_999_000_000,
-            ),
-            (
-                1_000_000,
-                1_000_000_000_000_000_000_u64,
-                1_000_000_000,
-                999_999_999_999_000_000,
-            ),
-            (
-                21_000_000_000_000_000,
-                10_000_000,
-                4_200_000_000_000_000_000,
-                21_000_000_000_000_000,
-            ),
-            (
-                21_000_000_000_000_000,
-                1_000_000_000_000_000_000_u64,
-                u64::MAX,
-                u64::MAX,
-            ),
-            (
-                21_000_000_000_000_000,
-                1_000_000_000_000_000_000_u64,
-                42_000_000,
-                21_000_000_000_000_000,
-            ),
-        ]
-        .iter()
-        .for_each(|&(tao_in, alpha_in, limit_price, expected_max_swappable)| {
+    // tao_in, alpha_in, limit_price, expected_max_swappable
+    [
+        // Zero handling (no panics)
+        (1_000_000_000, 1_000_000_000, 0, 0),
+        // Low bounds
+        (100, 100, 1_100_000_000, 0),
+        (1_000, 1_000, 1_100_000_000, 0),
+        (10_000, 10_000, 1_100_000_000, 440),
+        // Basic math
+        (1_000_000, 1_000_000, 4_000_000_000, 1_000_000),
+        (1_000_000, 1_000_000, 9_000_000_000, 2_000_000),
+        (1_000_000, 1_000_000, 16_000_000_000, 3_000_000),
+        (
+            1_000_000_000_000,
+            1_000_000_000_000,
+            16_000_000_000,
+            3_000_000_000_000,
+        ),
+        // Normal range values with edge cases
+        (150_000_000_000, 100_000_000_000, 0, 0),
+        (150_000_000_000, 100_000_000_000, 100_000_000, 0),
+        (150_000_000_000, 100_000_000_000, 500_000_000, 0),
+        (150_000_000_000, 100_000_000_000, 1_499_999_999, 0),
+        (150_000_000_000, 100_000_000_000, 1_500_000_000, 5),
+        (150_000_000_000, 100_000_000_000, 1_500_000_001, 51),
+        (
+            150_000_000_000,
+            100_000_000_000,
+            6_000_000_000,
+            150_000_000_000,
+        ),
+        // Miscellaneous overflows and underflows
+        (u64::MAX/2, u64::MAX, u64::MAX, u64::MAX),
+        // (150_000_000_000, 100_000_000_000, u64::MAX / 2, u64::MAX),
+        // (1_000_000, 1_000_000_000_000_000_000_u64, 1, 999_000_000),
+        // (1_000_000, 1_000_000_000_000_000_000_u64, 2, 1_999_000_000),
+        // (
+        //     1_000_000,
+        //     1_000_000_000_000_000_000_u64,
+        //     10_000,
+        //     9_999_999_000_000,
+        // ),
+        // (
+        //     1_000_000,
+        //     1_000_000_000_000_000_000_u64,
+        //     100_000,
+        //     99_999_999_000_000,
+        // ),
+        // (
+        //     1_000_000,
+        //     1_000_000_000_000_000_000_u64,
+        //     1_000_000,
+        //     999_999_999_000_000,
+        // ),
+        // (
+        //     1_000_000,
+        //     1_000_000_000_000_000_000_u64,
+        //     1_000_000_000,
+        //     999_999_999_999_000_000,
+        // ),
+        // (
+        //     21_000_000_000_000_000,
+        //     10_000_000,
+        //     4_200_000_000_000_000_000,
+        //     21_000_000_000_000_000,
+        // ),
+        // (
+        //     21_000_000_000_000_000,
+        //     1_000_000_000_000_000_000_u64,
+        //     u64::MAX,
+        //     u64::MAX,
+        // ),
+        // (
+        //     21_000_000_000_000_000,
+        //     1_000_000_000_000_000_000_u64,
+        //     42_000_000,
+        //     21_000_000_000_000_000,
+        // ),
+    ]
+    .iter()
+    .for_each(|&(tao_in, alpha_in, limit_price, expected_max_swappable)| {
+        new_test_ext(0).execute_with(|| {
+            let subnet_owner_coldkey = U256::from(1001);
+            let subnet_owner_hotkey = U256::from(1002);
+            let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+        
             // Forse-set alpha in and tao reserve to achieve relative price of subnets
             SubnetTAO::<Test>::insert(netuid, tao_in);
             SubnetAlphaIn::<Test>::insert(netuid, alpha_in);
 
+            // Force the swap to initialize
+            SubtensorModule::swap_tao_for_alpha(
+                netuid,
+                0,
+                1_000_000_000_000
+            ).unwrap();
+
             if alpha_in != 0 {
-                let expected_price = I96F32::from_num(tao_in) / I96F32::from_num(alpha_in);
-                assert_eq!(
-                    <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid),
-                    expected_price
+                let expected_price = U96F32::from_num(tao_in) / U96F32::from_num(alpha_in);
+                assert_abs_diff_eq!(
+                    <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid).to_num::<f64>(),
+                    expected_price.to_num::<f64>(),
+                    epsilon = expected_price.to_num::<f64>() / 1_000_000_000_f64
                 );
             }
 
-            assert_eq!(
+            assert_abs_diff_eq!(
                 SubtensorModule::get_max_amount_add(netuid, limit_price),
                 expected_max_swappable,
+                epsilon = expected_max_swappable / 100
             );
         });
     });
@@ -3638,7 +3635,7 @@ fn test_add_stake_limit_ok() {
         // Setup limit price so that it doesn't peak above 4x of current price
         // The amount that can be executed at this price is 450 TAO only
         // Alpha produced will be equal to 75 = 450*100/(450+150)
-        let limit_price = 6_000_000_000;
+        let limit_price = 24_000_000_000;
         let expected_executed_stake = 75_000_000_000;
 
         // Add stake with slippage safety and check if the result is ok
@@ -3650,7 +3647,7 @@ fn test_add_stake_limit_ok() {
             limit_price,
             true
         ));
-
+        
         // Check if stake has increased only by 75 Alpha
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
@@ -3662,11 +3659,12 @@ fn test_add_stake_limit_ok() {
             epsilon = expected_executed_stake / 1000,
         );
 
-        // Check that 450 TAO balance still remains free on coldkey
+        // Check that 450 TAO less fees balance still remains free on coldkey
+        let fee = <tests::mock::Test as pallet::Config>::SwapInterface::approx_fee_amount(netuid, amount / 2) as f64;
         assert_abs_diff_eq!(
             SubtensorModule::get_coldkey_balance(&coldkey_account_id),
-            450_000_000_000,
-            epsilon = 10_000
+            amount / 2 - fee as u64,
+            epsilon = amount / 2 / 1000
         );
 
         // Check that price has updated to ~24 = (150+450) / (100 - 75)
@@ -3675,7 +3673,7 @@ fn test_add_stake_limit_ok() {
         assert_abs_diff_eq!(
             exp_price.to_num::<f64>(),
             current_price.to_num::<f64>(),
-            epsilon = 0.2, // because of the new swap, epsilon should be quite big
+            epsilon = 0.0001,
         );
     });
 }
@@ -3706,7 +3704,7 @@ fn test_add_stake_limit_fill_or_kill() {
         // Setup limit price so that it doesn't peak above 4x of current price
         // The amount that can be executed at this price is 450 TAO only
         // Alpha produced will be equal to 25 = 100 - 450*100/(150+450)
-        let limit_price = 6_000_000_000;
+        let limit_price = 24_000_000_000;
 
         // Add stake with slippage safety and check if it fails
         assert_noop!(
diff --git a/pallets/swap-interface/src/lib.rs b/pallets/swap-interface/src/lib.rs
index 264219e17f..1bd9c51657 100644
--- a/pallets/swap-interface/src/lib.rs
+++ b/pallets/swap-interface/src/lib.rs
@@ -45,6 +45,7 @@ pub trait SwapHandler<AccountId> {
 
 #[derive(Debug, PartialEq)]
 pub struct SwapResult {
+    pub amount_paid_in: u64,
     pub amount_paid_out: u64,
     pub fee_paid: u64,
     // calculated new tao/alpha reserves
@@ -69,4 +70,5 @@ pub trait LiquidityDataProvider<AccountId> {
         coldkey_account_id: &AccountId,
         hotkey_account_id: &AccountId,
     ) -> u64;
+    fn subnet_mechanism(netuid: u16) -> u16;
 }
diff --git a/pallets/swap/src/mock.rs b/pallets/swap/src/mock.rs
index 5ad5362e35..6eec7f92af 100644
--- a/pallets/swap/src/mock.rs
+++ b/pallets/swap/src/mock.rs
@@ -105,6 +105,14 @@ impl LiquidityDataProvider<AccountId> for MockLiquidityProvider {
             1_000_000_000
         }
     }
+
+    fn subnet_mechanism(netuid: u16) -> u16 {
+        if netuid == 0 {
+            0
+        } else {
+            1
+        }
+    }
 }
 
 impl crate::pallet::Config for Test {
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 46abdf8dfc..cd6a82ff7b 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -57,6 +57,9 @@ impl<T: Config> SwapStep<T> {
         let possible_delta_in = amount_remaining
             .saturating_sub(Pallet::<T>::calculate_fee_amount(netuid, amount_remaining));
 
+        // println!("SwapStep::new order_type = {:?}", order_type);
+        // println!("SwapStep::new sqrt_price_limit = {:?}", sqrt_price_limit);
+
         // Target price and quantities
         let sqrt_price_target = Pallet::<T>::sqrt_price_target(
             order_type,
@@ -205,6 +208,7 @@ impl<T: Config> SwapStep<T> {
 
         Ok(SwapStepResult {
             amount_to_take: total_cost.saturating_to_num::<u64>(),
+            fee_paid: fee,
             delta_in: self.delta_in,
             delta_out,
         })
@@ -319,12 +323,11 @@ impl<T: Config> Pallet<T> {
 
         Self::maybe_initialize_v3(netuid)?;
 
-        // println!("swap_inner amount = {:?}", amount);
-
         let mut amount_remaining = amount;
         let mut amount_paid_out: u64 = 0;
         let mut iteration_counter: u16 = 0;
         let mut in_acc: u64 = 0;
+        let mut fee_acc: u64 = 0;
 
         // Swap one tick at a time until we reach one of the stop conditions
         while amount_remaining > 0 {
@@ -335,6 +338,7 @@ impl<T: Config> Pallet<T> {
             let swap_result = swap_step.execute()?;
 
             in_acc = in_acc.saturating_add(swap_result.delta_in);
+            fee_acc = fee_acc.saturating_add(swap_result.fee_paid);
             amount_remaining = amount_remaining.saturating_sub(swap_result.amount_to_take);
             amount_paid_out = amount_paid_out.saturating_add(swap_result.delta_out);
 
@@ -379,11 +383,10 @@ impl<T: Config> Pallet<T> {
             ),
         };
 
-        let fee_paid = amount.saturating_sub(in_acc);
-
         Ok(SwapResult {
+            amount_paid_in: in_acc,
             amount_paid_out,
-            fee_paid,
+            fee_paid: fee_acc,
             new_tao_reserve,
             new_alpha_reserve,
         })
@@ -1016,7 +1019,8 @@ impl<T: Config> SwapHandler<T::AccountId> for Pallet<T> {
         should_rollback: bool,
     ) -> Result<SwapResult, DispatchError> {
         let sqrt_price_limit = SqrtPrice::saturating_from_num(price_limit)
-            .checked_sqrt(SqrtPrice::saturating_from_num(2))
+            .safe_div(SqrtPrice::saturating_from_num(1_000_000_000))
+            .checked_sqrt(SqrtPrice::saturating_from_num(0.0000000001))
             .ok_or(Error::<T>::PriceLimitExceeded)?;
 
         Self::do_swap(
@@ -1083,27 +1087,36 @@ impl<T: Config> SwapHandler<T::AccountId> for Pallet<T> {
     }
 
     fn current_alpha_price(netuid: u16) -> U96F32 {
-        let sqrt_price = AlphaSqrtPrice::<T>::get(NetUid::from(netuid));
-        let tao_reserve = T::LiquidityDataProvider::tao_reserve(netuid);
-        let alpha_reserve = T::LiquidityDataProvider::alpha_reserve(netuid);
-
-        if sqrt_price == 0 && tao_reserve > 0 && alpha_reserve > 0 {
-            U96F32::saturating_from_num(tao_reserve)
-                .saturating_div(U96F32::saturating_from_num(alpha_reserve))
-        } else {
-            U96F32::saturating_from_num(sqrt_price.saturating_mul(sqrt_price))
+        match T::LiquidityDataProvider::subnet_mechanism(netuid) {
+            1 => {
+                let sqrt_price = AlphaSqrtPrice::<T>::get(NetUid::from(netuid));
+                let tao_reserve = T::LiquidityDataProvider::tao_reserve(netuid);
+                let alpha_reserve = T::LiquidityDataProvider::alpha_reserve(netuid);
+        
+                if sqrt_price == 0 && tao_reserve > 0 && alpha_reserve > 0 {
+                    U96F32::saturating_from_num(tao_reserve)
+                        .saturating_div(U96F32::saturating_from_num(alpha_reserve))
+                } else {
+                    U96F32::saturating_from_num(sqrt_price.saturating_mul(sqrt_price))
+                }
+            },
+            _ => {
+                U96F32::saturating_from_num(1)
+            }
         }
     }
 
     fn min_price() -> u64 {
         TickIndex::min_sqrt_price()
             .saturating_mul(TickIndex::min_sqrt_price())
+            .saturating_mul(SqrtPrice::saturating_from_num(1_000_000_000))
             .saturating_to_num()
     }
 
     fn max_price() -> u64 {
         TickIndex::max_sqrt_price()
             .saturating_mul(TickIndex::max_sqrt_price())
+            .saturating_mul(SqrtPrice::saturating_from_num(1_000_000_000))
             .saturating_round()
             .saturating_to_num()
     }
@@ -1112,6 +1125,7 @@ impl<T: Config> SwapHandler<T::AccountId> for Pallet<T> {
 #[derive(Debug, PartialEq)]
 struct SwapStepResult {
     amount_to_take: u64,
+    fee_paid: u64,
     delta_in: u64,
     delta_out: u64,
 }

From 49b68af14a45be8fae89a272809e7218bb191549 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Thu, 15 May 2025 21:43:24 -0400
Subject: [PATCH 157/418] Merge uniswap branch in

---
 Cargo.lock                            |  1 +
 pallets/admin-utils/Cargo.toml        |  1 +
 pallets/admin-utils/src/tests/mock.rs |  1 +
 pallets/subtensor/src/lib.rs          | 10 +++++-----
 pallets/swap/src/mock.rs              | 16 ++++++++--------
 5 files changed, 16 insertions(+), 13 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 8a1ce271d4..f04d84623b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6393,6 +6393,7 @@ dependencies = [
  "sp-weights",
  "substrate-fixed",
  "subtensor-macros",
+ "subtensor-swap-interface",
 ]
 
 [[package]]
diff --git a/pallets/admin-utils/Cargo.toml b/pallets/admin-utils/Cargo.toml
index c45f2648d7..8c150a7e60 100644
--- a/pallets/admin-utils/Cargo.toml
+++ b/pallets/admin-utils/Cargo.toml
@@ -32,6 +32,7 @@ substrate-fixed = { workspace = true }
 pallet-evm-chain-id = { workspace = true }
 pallet-drand = { workspace = true, default-features = false }
 sp-consensus-grandpa = { workspace = true }
+subtensor-swap-interface = { workspace = true }
 
 [dev-dependencies]
 sp-core = { workspace = true }
diff --git a/pallets/admin-utils/src/tests/mock.rs b/pallets/admin-utils/src/tests/mock.rs
index e9f4655825..709ea1506b 100644
--- a/pallets/admin-utils/src/tests/mock.rs
+++ b/pallets/admin-utils/src/tests/mock.rs
@@ -276,6 +276,7 @@ impl pallet_subtensor_swap::Config for Test {
     type RuntimeEvent = RuntimeEvent;
     type AdminOrigin = EnsureRoot<AccountId>;
     type LiquidityDataProvider = SubtensorModule;
+    type BalanceOps = SubtensorModule;    
     type ProtocolId = SwapProtocolId;
     type MaxFeeRate = SwapMaxFeeRate;
     type MaxPositions = SwapMaxPositions;
diff --git a/pallets/subtensor/src/lib.rs b/pallets/subtensor/src/lib.rs
index 703dbc921e..ae125ff6d4 100644
--- a/pallets/subtensor/src/lib.rs
+++ b/pallets/subtensor/src/lib.rs
@@ -2435,6 +2435,10 @@ impl<T: Config + pallet_balances::Config<Balance = u64>>
     fn subnet_exist(netuid: u16) -> bool {
         Self::if_subnet_exist(netuid)
     }
+
+    fn subnet_mechanism(netuid: u16) -> u16 {
+        SubnetMechanism::<T>::get(netuid)
+    }    
 }
 
 impl<T: Config + pallet_balances::Config<Balance = u64>>
@@ -2486,9 +2490,5 @@ impl<T: Config + pallet_balances::Config<Balance = u64>>
         Ok(Self::decrease_stake_for_hotkey_and_coldkey_on_subnet(
             &hotkey, &coldkey, netuid, alpha,
         ))
-    }
-
-    fn subnet_mechanism(netuid: u16) -> u16 {
-        SubnetMechanism::<T>::get(netuid)
-    }    
+    }  
 }
diff --git a/pallets/swap/src/mock.rs b/pallets/swap/src/mock.rs
index f79df47e29..45fd3d8187 100644
--- a/pallets/swap/src/mock.rs
+++ b/pallets/swap/src/mock.rs
@@ -92,6 +92,14 @@ impl LiquidityDataProvider<AccountId> for MockLiquidityProvider {
     fn subnet_exist(_netuid: u16) -> bool {
         true
     }
+
+    fn subnet_mechanism(netuid: u16) -> u16 {
+        if netuid == 0 {
+            0
+        } else {
+            1
+        }
+    }    
 }
 
 pub struct MockBalanceOps;
@@ -135,14 +143,6 @@ impl BalanceOps<AccountId> for MockBalanceOps {
     ) -> Result<u64, DispatchError> {
         Ok(0)
     }
-
-    fn subnet_mechanism(netuid: u16) -> u16 {
-        if netuid == 0 {
-            0
-        } else {
-            1
-        }
-    }    
 }
 
 impl crate::pallet::Config for Test {

From fb9ca431a2619cbf891c2e16f912d69fae1e2b1e Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Fri, 16 May 2025 13:06:27 +0800
Subject: [PATCH 158/418] evm test part

---
 Cargo.lock                                    |  1 +
 evm-tests/package-lock.json                   |  6 +-
 evm-tests/package.json                        |  3 +-
 evm-tests/src/config.ts                       |  6 +-
 .../test/runtime.call.precompile.test.ts      | 69 +++++++++++++++++++
 precompiles/Cargo.toml                        |  2 +
 precompiles/src/lib.rs                        | 11 ++-
 precompiles/src/runtime_call_query.rs         | 25 -------
 precompiles/src/storage_query.rs              | 54 +++++++++++++++
 9 files changed, 146 insertions(+), 31 deletions(-)
 create mode 100644 evm-tests/test/runtime.call.precompile.test.ts
 delete mode 100644 precompiles/src/runtime_call_query.rs
 create mode 100644 precompiles/src/storage_query.rs

diff --git a/Cargo.lock b/Cargo.lock
index 42dc2f1b20..1ec256be62 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -11090,6 +11090,7 @@ dependencies = [
  "pallet-subtensor",
  "precompile-utils",
  "sp-core",
+ "sp-io",
  "sp-runtime",
  "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7)",
  "subtensor-runtime-common",
diff --git a/evm-tests/package-lock.json b/evm-tests/package-lock.json
index ce2766fb4e..68fae940bf 100644
--- a/evm-tests/package-lock.json
+++ b/evm-tests/package-lock.json
@@ -6,6 +6,7 @@
     "": {
       "license": "ISC",
       "dependencies": {
+        "@polkadot-api/descriptors": "file:.papi/descriptors",
         "@polkadot-labs/hdkd": "^0.0.10",
         "@polkadot-labs/hdkd-helpers": "^0.0.11",
         "@polkadot/api": "15.1.1",
@@ -32,7 +33,6 @@
     ".papi/descriptors": {
       "name": "@polkadot-api/descriptors",
       "version": "0.1.0-autogenerated.7914363913476982777",
-      "extraneous": true,
       "peerDependencies": {
         "polkadot-api": "*"
       }
@@ -731,6 +731,10 @@
         "@polkadot-api/utils": "0.1.2"
       }
     },
+    "node_modules/@polkadot-api/descriptors": {
+      "resolved": ".papi/descriptors",
+      "link": true
+    },
     "node_modules/@polkadot-api/ink-contracts": {
       "version": "0.2.6",
       "resolved": "https://registry.npmjs.org/@polkadot-api/ink-contracts/-/ink-contracts-0.2.6.tgz",
diff --git a/evm-tests/package.json b/evm-tests/package.json
index 0e90cdb976..b3ab563ef5 100644
--- a/evm-tests/package.json
+++ b/evm-tests/package.json
@@ -1,11 +1,12 @@
 {
   "scripts": {
-    "test": "mocha --timeout 999999 --retries 3 --file src/setup.ts --require ts-node/register test/*test.ts"
+    "test": "mocha --timeout 999999 --file src/setup.ts --require ts-node/register test/runtime*test.ts"
   },
   "keywords": [],
   "author": "",
   "license": "ISC",
   "dependencies": {
+    "@polkadot-api/descriptors": "file:.papi/descriptors",
     "@polkadot-labs/hdkd": "^0.0.10",
     "@polkadot-labs/hdkd-helpers": "^0.0.11",
     "@polkadot/api": "15.1.1",
diff --git a/evm-tests/src/config.ts b/evm-tests/src/config.ts
index 00b942f802..7fb40e67cb 100644
--- a/evm-tests/src/config.ts
+++ b/evm-tests/src/config.ts
@@ -35,4 +35,8 @@ export const IBalanceTransferABI = [
         stateMutability: "payable",
         type: "function",
     },
-];
\ No newline at end of file
+];
+
+export const IDISPATCH_ADDRESS = "0x0000000000000000000000000000000000000006";
+
+export const ISTORAGE_QUERY_ADDRESS = "0x0000000000000000000000000000000000000807";
\ No newline at end of file
diff --git a/evm-tests/test/runtime.call.precompile.test.ts b/evm-tests/test/runtime.call.precompile.test.ts
new file mode 100644
index 0000000000..8876dbdad8
--- /dev/null
+++ b/evm-tests/test/runtime.call.precompile.test.ts
@@ -0,0 +1,69 @@
+
+
+
+import * as assert from "assert";
+
+import { getAliceSigner, getDevnetApi } from "../src/substrate"
+import {  generateRandomEthersWallet, getPublicClient } from "../src/utils";
+import { IDISPATCH_ADDRESS, ISTORAGE_QUERY_ADDRESS, ETH_LOCAL_URL } from "../src/config";
+import { devnet } from "@polkadot-api/descriptors"
+import { PublicClient } from "viem";
+import { PolkadotSigner, TypedApi } from "polkadot-api";
+import { convertPublicKeyToSs58 } from "../src/address-utils"
+import { forceSetBalanceToEthAddress } from "../src/subtensor";
+
+describe("Test the dispatch precompile", () => {
+    let publicClient: PublicClient;
+     // init eth part
+    const wallet1 = generateRandomEthersWallet();
+
+    let api: TypedApi<typeof devnet>
+    let alice: PolkadotSigner;
+
+    before(async () => {
+        publicClient = await getPublicClient(ETH_LOCAL_URL)
+        api = await getDevnetApi()
+        alice = await getAliceSigner()
+        await forceSetBalanceToEthAddress(api, wallet1.address)
+        console.log("wallet1 address: ", wallet1.address)
+    })
+
+    // it("Dispatch transfer call via precompile contract works correctly", async () => {
+    //     // 0x050300d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d02286bee
+    //     // call for transfer 1 token to alice
+    //     const transferAmount = BigInt(1000000000);
+    //     const transferCall = "0x050300d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d02286bee"
+    //     const aliceBalance =  (await api.query.System.Account.getValue( convertPublicKeyToSs58(alice.publicKey))).data.free
+
+    //     console.log("alice balance before transfer: ", aliceBalance.toString())
+    //     const txResponse = await wallet1.sendTransaction({
+    //         to: IDISPATCH_ADDRESS,
+    //         data: transferCall,
+    //     })
+    //     await txResponse.wait()
+
+    //     const aliceBalanceAfterTransfer =  (await api.query.System.Account.getValue( convertPublicKeyToSs58(alice.publicKey))).data.free
+
+    //     assert.equal(aliceBalance + transferAmount, aliceBalanceAfterTransfer)
+
+    //     console.log("alice balance after transfer: ", aliceBalanceAfterTransfer.toString())
+    // })
+
+    
+
+    it("Storage query call via precompile contract works correctly", async () => {
+        // 0x658faa385070e074c85bf6b568cf0555f14f14d903e9994045ff1902b3e513dc
+    // key for min child key take
+        const storageQuery = "0x658faa385070e074c85bf6b568cf0555f14f14d903e9994045ff1902b3e513dc"
+
+        const rawCallResponse = await publicClient.call({
+            to: ISTORAGE_QUERY_ADDRESS,
+            data: storageQuery,
+        })
+        const rawResultData = rawCallResponse.data;
+        console.log("Raw result data:", rawResultData);
+
+
+        
+    })
+});
diff --git a/precompiles/Cargo.toml b/precompiles/Cargo.toml
index b3d318da14..91f3955a8d 100644
--- a/precompiles/Cargo.toml
+++ b/precompiles/Cargo.toml
@@ -25,6 +25,7 @@ pallet-evm-precompile-simple = { workspace = true }
 pallet-proxy = { workspace = true }
 precompile-utils = { workspace = true }
 sp-core = { workspace = true }
+sp-io = { workspace = true }
 sp-runtime = { workspace = true }
 sp-std = { workspace = true }
 subtensor-runtime-common = { workspace = true }
@@ -53,6 +54,7 @@ std = [
 	"pallet-subtensor/std",
 	"precompile-utils/std",
 	"sp-core/std",
+	"sp-io/std",
 	"sp-runtime/std",
 	"sp-std/std",
 	"subtensor-runtime-common/std",
diff --git a/precompiles/src/lib.rs b/precompiles/src/lib.rs
index 9968596f32..3bdf417d8d 100644
--- a/precompiles/src/lib.rs
+++ b/precompiles/src/lib.rs
@@ -7,7 +7,6 @@ use core::marker::PhantomData;
 use frame_support::{
     dispatch::{GetDispatchInfo, PostDispatchInfo},
     pallet_prelude::Decode,
-    traits::ConstU32,
 };
 use pallet_evm::{
     AddressMapping, IsPrecompileResult, Precompile, PrecompileHandle, PrecompileResult,
@@ -30,6 +29,7 @@ use crate::extensions::*;
 use crate::metagraph::*;
 use crate::neuron::*;
 use crate::staking::*;
+use crate::storage_query::*;
 use crate::subnet::*;
 use crate::uid_lookup::*;
 
@@ -39,9 +39,9 @@ mod extensions;
 mod metagraph;
 mod neuron;
 mod staking;
+mod storage_query;
 mod subnet;
 mod uid_lookup;
-
 pub struct Precompiles<R>(PhantomData<R>);
 
 impl<R> Default for Precompiles<R>
@@ -91,13 +91,14 @@ where
         Self(Default::default())
     }
 
-    pub fn used_addresses() -> [H160; 14] {
+    pub fn used_addresses() -> [H160; 16] {
         [
             hash(1),
             hash(2),
             hash(3),
             hash(4),
             hash(5),
+            hash(6),
             hash(1024),
             hash(1025),
             hash(Ed25519Verify::<R::AccountId>::INDEX),
@@ -107,6 +108,7 @@ where
             hash(MetagraphPrecompile::<R>::INDEX),
             hash(NeuronPrecompile::<R>::INDEX),
             hash(StakingPrecompileV2::<R>::INDEX),
+            hash(StorageQueryPrecompile::<R>::INDEX),
         ]
     }
 }
@@ -172,6 +174,9 @@ where
             a if a == hash(UidLookupPrecompile::<R>::INDEX) => {
                 UidLookupPrecompile::<R>::try_execute::<R>(handle, PrecompileEnum::UidLookup)
             }
+            a if a == hash(StorageQueryPrecompile::<R>::INDEX) => {
+                Some(StorageQueryPrecompile::<R>::execute(handle))
+            }
             _ => None,
         }
     }
diff --git a/precompiles/src/runtime_call_query.rs b/precompiles/src/runtime_call_query.rs
deleted file mode 100644
index ecc1e2693c..0000000000
--- a/precompiles/src/runtime_call_query.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-use core::marker::PhantomData;
-
-use frame_support::dispatch::{GetDispatchInfo, PostDispatchInfo};
-use pallet_evm::PrecompileHandle;
-use precompile_utils::{EvmResult, prelude::Address};
-use sp_runtime::traits::{Dispatchable, StaticLookup};
-use sp_std::vec::Vec;
-
-use crate::PrecompileExt;
-
-pub(crate) struct RuntimeCallQueryPrecompile<R>(PhantomData<R>);
-
-impl<R> PrecompileExt<R::AccountId> for RuntimeCallQueryPrecompile<R>
-where
-    R: frame_system::Config + pallet_subtensor::Config + pallet_evm::Config,
-    R::AccountId: From<[u8; 32]>,
-    <R as frame_system::Config>::RuntimeCall:
-        GetDispatchInfo + Dispatchable<PostInfo = PostDispatchInfo>,
-    <R as frame_system::Config>::RuntimeCall: From<pallet_subtensor::Call<R>>
-        + GetDispatchInfo
-        + Dispatchable<PostInfo = PostDispatchInfo>,
-    <<R as frame_system::Config>::Lookup as StaticLookup>::Source: From<R::AccountId>,
-{
-    const INDEX: u64 = 2055;
-}
diff --git a/precompiles/src/storage_query.rs b/precompiles/src/storage_query.rs
new file mode 100644
index 0000000000..1062e78e95
--- /dev/null
+++ b/precompiles/src/storage_query.rs
@@ -0,0 +1,54 @@
+use core::marker::PhantomData;
+
+use frame_support::dispatch::{GetDispatchInfo, PostDispatchInfo};
+use pallet_evm::{ExitSucceed, Precompile, PrecompileHandle, PrecompileOutput};
+use sp_runtime::traits::{Dispatchable, StaticLookup};
+use sp_std::vec::Vec;
+
+use crate::PrecompileExt;
+
+pub(crate) struct StorageQueryPrecompile<R>(PhantomData<R>);
+
+impl<R> PrecompileExt<R::AccountId> for StorageQueryPrecompile<R>
+where
+    R: frame_system::Config + pallet_subtensor::Config + pallet_evm::Config,
+    R::AccountId: From<[u8; 32]>,
+    <R as frame_system::Config>::RuntimeCall:
+        GetDispatchInfo + Dispatchable<PostInfo = PostDispatchInfo>,
+    <R as frame_system::Config>::RuntimeCall: From<pallet_subtensor::Call<R>>
+        + GetDispatchInfo
+        + Dispatchable<PostInfo = PostDispatchInfo>,
+    <<R as frame_system::Config>::Lookup as StaticLookup>::Source: From<R::AccountId>,
+{
+    const INDEX: u64 = 2055;
+}
+
+impl<R> Precompile for StorageQueryPrecompile<R>
+where
+    R: frame_system::Config + pallet_subtensor::Config + pallet_evm::Config,
+    R::AccountId: From<[u8; 32]>,
+    <R as frame_system::Config>::RuntimeCall:
+        GetDispatchInfo + Dispatchable<PostInfo = PostDispatchInfo>,
+    <R as frame_system::Config>::RuntimeCall: From<pallet_subtensor::Call<R>>
+        + GetDispatchInfo
+        + Dispatchable<PostInfo = PostDispatchInfo>,
+    <<R as frame_system::Config>::Lookup as StaticLookup>::Source: From<R::AccountId>,
+{
+    fn execute(handle: &mut impl PrecompileHandle) -> fp_evm::PrecompileResult {
+        let input = handle.input();
+        let data = sp_io::storage::get(&input[..]);
+        match data {
+            Some(value) => {
+                let result = value.to_vec();
+                Ok(PrecompileOutput {
+                    exit_status: ExitSucceed::Returned,
+                    output: result,
+                })
+            }
+            None => Ok(PrecompileOutput {
+                exit_status: ExitSucceed::Returned,
+                output: Vec::new(),
+            }),
+        }
+    }
+}

From 6a6f073c1086c7e35015ba8970fa2464b8412394 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Fri, 16 May 2025 16:00:33 +0200
Subject: [PATCH 159/418] Clean up

---
 pallets/subtensor/src/staking/stake_utils.rs | 20 +++++++-------------
 1 file changed, 7 insertions(+), 13 deletions(-)

diff --git a/pallets/subtensor/src/staking/stake_utils.rs b/pallets/subtensor/src/staking/stake_utils.rs
index 2a7b72da8f..d190dc3a5e 100644
--- a/pallets/subtensor/src/staking/stake_utils.rs
+++ b/pallets/subtensor/src/staking/stake_utils.rs
@@ -607,16 +607,13 @@ impl<T: Config> Pallet<T> {
         let mechanism_id: u16 = SubnetMechanism::<T>::get(netuid);
         // Step 2: Simulate swapping tao and attain alpha
         if mechanism_id == 1 {
-            let swap_result = T::SwapInterface::swap(
+            T::SwapInterface::swap(
                 netuid,
                 OrderType::Buy,
                 tao,
                 T::SwapInterface::max_price(),
                 true,
             )
-            .map_err(|_| Error::<T>::InsufficientLiquidity)?;
-
-            Ok(swap_result)
         } else {
             // Step 3.b.1: Stable mechanism, just return the value 1:1
             Ok(SwapResult {
@@ -640,16 +637,13 @@ impl<T: Config> Pallet<T> {
         let mechanism_id: u16 = SubnetMechanism::<T>::get(netuid);
         // Step 2: Simulate swapping alpha and attain tao
         if mechanism_id == 1 {
-            let swap_result = T::SwapInterface::swap(
+            T::SwapInterface::swap(
                 netuid,
                 OrderType::Sell,
                 alpha,
                 T::SwapInterface::min_price(),
                 true,
             )
-            .map_err(|_| Error::<T>::InsufficientLiquidity)?;
-
-            Ok(swap_result)
         } else {
             // Step 3.b.1: Stable mechanism, just return the value 1:1
             Ok(SwapResult {
@@ -677,23 +671,23 @@ impl<T: Config> Pallet<T> {
 
             // update Alpha reserves.
             SubnetAlphaIn::<T>::set(netuid, swap_result.new_alpha_reserve);
-    
+
             // Increase Alpha outstanding.
             SubnetAlphaOut::<T>::mutate(netuid, |total| {
                 *total = total.saturating_add(swap_result.amount_paid_out);
             });
-    
+
             // update Tao reserves.
             SubnetTAO::<T>::set(netuid, swap_result.new_tao_reserve);
-    
+
             // Increase Total Tao reserves.
             TotalStake::<T>::mutate(|total| *total = total.saturating_add(tao));
-    
+
             // Increase total subnet TAO volume.
             SubnetVolume::<T>::mutate(netuid, |total| {
                 *total = total.saturating_add(tao.into());
             });
-    
+
             // Return the alpha received.
             Ok(swap_result)
         } else {

From e5f2a5156abe43738ba10f9935f1bdfb5d8dc523 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Fri, 16 May 2025 17:12:54 +0200
Subject: [PATCH 160/418] Setup benchmarks for all extrinsics in swap

---
 pallets/swap/src/benchmarking.rs | 110 ++++++++++++++++++++++++++++++-
 pallets/swap/src/mock.rs         |  19 +++---
 pallets/swap/src/pallet/impls.rs |  15 +++--
 pallets/swap/src/pallet/mod.rs   |  24 +------
 pallets/swap/src/tick.rs         |   2 +-
 pallets/swap/src/weights.rs      |  42 ++++++++++++
 6 files changed, 171 insertions(+), 41 deletions(-)

diff --git a/pallets/swap/src/benchmarking.rs b/pallets/swap/src/benchmarking.rs
index e1d75304ae..133a0ef5bc 100644
--- a/pallets/swap/src/benchmarking.rs
+++ b/pallets/swap/src/benchmarking.rs
@@ -2,13 +2,24 @@
 #![cfg(feature = "runtime-benchmarks")]
 #![allow(clippy::arithmetic_side_effects)]
 
-use crate::pallet::{Call, Config, Pallet};
 use frame_benchmarking::v2::*;
+use frame_support::traits::Get;
 use frame_system::RawOrigin;
+use substrate_fixed::types::U64F64;
+
+use crate::{
+    NetUid,
+    pallet::{
+        AlphaSqrtPrice, Call, Config, CurrentLiquidity, CurrentTick, Pallet, Positions,
+        SwapV3Initialized,
+    },
+    position::{Position, PositionId},
+    tick::TickIndex,
+};
 
 #[benchmarks(where T: Config)]
 mod benchmarks {
-    use super::*; // Use imports from outer scope
+    use super::*;
 
     #[benchmark]
     fn set_fee_rate() {
@@ -19,5 +30,100 @@ mod benchmarks {
         set_fee_rate(RawOrigin::Root, netuid, rate);
     }
 
+    #[benchmark]
+    fn add_liquidity() {
+        let netuid = NetUid::from(1);
+
+        if !SwapV3Initialized::<T>::get(netuid) {
+            SwapV3Initialized::<T>::insert(netuid, true);
+            AlphaSqrtPrice::<T>::insert(netuid, U64F64::from_num(1));
+            CurrentTick::<T>::insert(netuid, TickIndex::new(0).unwrap());
+            CurrentLiquidity::<T>::insert(netuid, T::MinimumLiquidity::get());
+        }
+
+        let caller: T::AccountId = whitelisted_caller();
+        let hotkey: T::AccountId = account("hotkey", 0, 0);
+
+        #[extrinsic_call]
+        add_liquidity(
+            RawOrigin::Signed(caller),
+            hotkey,
+            netuid.into(),
+            -10000,
+            10000,
+            1000,
+        );
+    }
+
+    #[benchmark]
+    fn remove_liquidity() {
+        let netuid = NetUid::from(1);
+
+        if !SwapV3Initialized::<T>::get(netuid) {
+            SwapV3Initialized::<T>::insert(netuid, true);
+            AlphaSqrtPrice::<T>::insert(netuid, U64F64::from_num(1));
+            CurrentTick::<T>::insert(netuid, TickIndex::new(0).unwrap());
+            CurrentLiquidity::<T>::insert(netuid, T::MinimumLiquidity::get());
+        }
+
+        let caller: T::AccountId = whitelisted_caller();
+        let hotkey: T::AccountId = account("hotkey", 0, 0);
+        let id = PositionId::from(1u128);
+
+        Positions::<T>::insert(
+            (netuid, caller.clone(), id),
+            Position {
+                id,
+                netuid,
+                tick_low: TickIndex::new(-10000).unwrap(),
+                tick_high: TickIndex::new(10000).unwrap(),
+                liquidity: 1000,
+                fees_tao: U64F64::from_num(0),
+                fees_alpha: U64F64::from_num(0),
+            },
+        );
+
+        #[extrinsic_call]
+        remove_liquidity(RawOrigin::Signed(caller), hotkey, netuid.into(), id.into());
+    }
+
+    #[benchmark]
+    fn modify_position() {
+        let netuid = NetUid::from(1);
+
+        if !SwapV3Initialized::<T>::get(netuid) {
+            SwapV3Initialized::<T>::insert(netuid, true);
+            AlphaSqrtPrice::<T>::insert(netuid, U64F64::from_num(1));
+            CurrentTick::<T>::insert(netuid, TickIndex::new(0).unwrap());
+            CurrentLiquidity::<T>::insert(netuid, T::MinimumLiquidity::get());
+        }
+
+        let caller: T::AccountId = whitelisted_caller();
+        let hotkey: T::AccountId = account("hotkey", 0, 0);
+        let id = PositionId::from(1u128);
+
+        Positions::<T>::insert(
+            (netuid, caller.clone(), id),
+            Position {
+                id,
+                netuid: netuid,
+                tick_low: TickIndex::new(-10000).unwrap(),
+                tick_high: TickIndex::new(10000).unwrap(),
+                liquidity: 10000,
+                fees_tao: U64F64::from_num(0),
+                fees_alpha: U64F64::from_num(0),
+            },
+        );
+
+        #[extrinsic_call]
+        modify_position(
+            RawOrigin::Signed(caller),
+            hotkey,
+            netuid.into(),
+            id.into(),
+            -5000,
+        );
+    }
+
     impl_benchmark_test_suite!(Pallet, crate::mock::new_test_ext(), crate::mock::Test);
 }
diff --git a/pallets/swap/src/mock.rs b/pallets/swap/src/mock.rs
index 45fd3d8187..52c9e1c77a 100644
--- a/pallets/swap/src/mock.rs
+++ b/pallets/swap/src/mock.rs
@@ -94,12 +94,8 @@ impl LiquidityDataProvider<AccountId> for MockLiquidityProvider {
     }
 
     fn subnet_mechanism(netuid: u16) -> u16 {
-        if netuid == 0 {
-            0
-        } else {
-            1
-        }
-    }    
+        if netuid == 0 { 0 } else { 1 }
+    }
 }
 
 pub struct MockBalanceOps;
@@ -124,9 +120,11 @@ impl BalanceOps<AccountId> for MockBalanceOps {
     }
 
     fn increase_balance(_coldkey: &AccountId, _tao: u64) {}
-    fn decrease_balance(_coldkey: &AccountId, _tao: u64) -> Result<u64, DispatchError> {
-        Ok(0)
+
+    fn decrease_balance(_coldkey: &AccountId, tao: u64) -> Result<u64, DispatchError> {
+        Ok(tao)
     }
+
     fn increase_stake(
         _coldkey: &AccountId,
         _hotkey: &AccountId,
@@ -135,13 +133,14 @@ impl BalanceOps<AccountId> for MockBalanceOps {
     ) -> Result<(), DispatchError> {
         Ok(())
     }
+
     fn decrease_stake(
         _coldkey: &AccountId,
         _hotkey: &AccountId,
         _netuid: u16,
-        _alpha: u64,
+        alpha: u64,
     ) -> Result<u64, DispatchError> {
-        Ok(0)
+        Ok(alpha)
     }
 }
 
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 3bddf64d21..b722872269 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -1064,17 +1064,15 @@ impl<T: Config> SwapHandler<T::AccountId> for Pallet<T> {
                 let sqrt_price = AlphaSqrtPrice::<T>::get(NetUid::from(netuid));
                 let tao_reserve = T::LiquidityDataProvider::tao_reserve(netuid);
                 let alpha_reserve = T::LiquidityDataProvider::alpha_reserve(netuid);
-        
+
                 if sqrt_price == 0 && tao_reserve > 0 && alpha_reserve > 0 {
                     U96F32::saturating_from_num(tao_reserve)
                         .saturating_div(U96F32::saturating_from_num(alpha_reserve))
                 } else {
                     U96F32::saturating_from_num(sqrt_price.saturating_mul(sqrt_price))
                 }
-            },
-            _ => {
-                U96F32::saturating_from_num(1)
             }
+            _ => U96F32::saturating_from_num(1),
         }
     }
 
@@ -1543,9 +1541,12 @@ mod tests {
                 .unwrap();
 
                 // Remove liquidity
-                let remove_result =
-                    Pallet::<Test>::do_remove_liquidity(netuid, &OK_COLDKEY_ACCOUNT_ID, position_id)
-                        .unwrap();
+                let remove_result = Pallet::<Test>::do_remove_liquidity(
+                    netuid,
+                    &OK_COLDKEY_ACCOUNT_ID,
+                    position_id,
+                )
+                .unwrap();
                 assert_abs_diff_eq!(remove_result.tao, tao, epsilon = tao / 1000);
                 assert_abs_diff_eq!(remove_result.alpha, alpha, epsilon = alpha / 1000);
                 assert_eq!(remove_result.fee_tao, 0);
diff --git a/pallets/swap/src/pallet/mod.rs b/pallets/swap/src/pallet/mod.rs
index bcf7e16f00..ab35bd452b 100644
--- a/pallets/swap/src/pallet/mod.rs
+++ b/pallets/swap/src/pallet/mod.rs
@@ -257,13 +257,7 @@ mod pallet {
         ///
         /// Emits `Event::LiquidityAdded` on success
         #[pallet::call_index(1)]
-        #[pallet::weight((
-		Weight::from_parts(50_000_000, 0)
-			.saturating_add(T::DbWeight::get().reads(5))
-			.saturating_add(T::DbWeight::get().writes(4)),
-            DispatchClass::Operational,
-            Pays::Yes
-        ))]
+        #[pallet::weight(<T as pallet::Config>::WeightInfo::add_liquidity())]
         pub fn add_liquidity(
             origin: OriginFor<T>,
             hotkey: T::AccountId,
@@ -321,13 +315,7 @@ mod pallet {
         ///
         /// Emits `Event::LiquidityRemoved` on success
         #[pallet::call_index(2)]
-        #[pallet::weight((
-		Weight::from_parts(50_000_000, 0)
-			.saturating_add(T::DbWeight::get().reads(4))
-			.saturating_add(T::DbWeight::get().writes(4)),
-            DispatchClass::Operational,
-            Pays::Yes
-        ))]
+        #[pallet::weight(<T as pallet::Config>::WeightInfo::remove_liquidity())]
         pub fn remove_liquidity(
             origin: OriginFor<T>,
             hotkey: T::AccountId,
@@ -378,13 +366,7 @@ mod pallet {
         ///
         /// Emits `Event::LiquidityRemoved` on success
         #[pallet::call_index(3)]
-        #[pallet::weight((
-		Weight::from_parts(50_000_000, 0)
-			.saturating_add(T::DbWeight::get().reads(4))
-			.saturating_add(T::DbWeight::get().writes(4)),
-            DispatchClass::Operational,
-            Pays::Yes
-        ))]
+        #[pallet::weight(<T as pallet::Config>::WeightInfo::modify_position())]
         pub fn modify_position(
             origin: OriginFor<T>,
             hotkey: T::AccountId,
diff --git a/pallets/swap/src/tick.rs b/pallets/swap/src/tick.rs
index 7352fd7d7a..435960e4bb 100644
--- a/pallets/swap/src/tick.rs
+++ b/pallets/swap/src/tick.rs
@@ -1142,8 +1142,8 @@ impl Error for TickMathError {}
 
 #[cfg(test)]
 mod tests {
-    use std::{ops::Sub, str::FromStr};
     use safe_math::FixedExt;
+    use std::{ops::Sub, str::FromStr};
 
     use super::*;
     use crate::mock::*;
diff --git a/pallets/swap/src/weights.rs b/pallets/swap/src/weights.rs
index 210bf1dc6d..7577383d19 100644
--- a/pallets/swap/src/weights.rs
+++ b/pallets/swap/src/weights.rs
@@ -15,6 +15,9 @@ use sp_std::marker::PhantomData;
 /// Weight functions needed for pallet_subtensor_swap.
 pub trait WeightInfo {
     fn set_fee_rate() -> Weight;
+    fn add_liquidity() -> Weight;
+    fn remove_liquidity() -> Weight;
+    fn modify_position() -> Weight;
 }
 
 /// Default weights for pallet_subtensor_swap.
@@ -26,6 +29,27 @@ impl<T: frame_system::Config> WeightInfo for DefaultWeight<T> {
             .saturating_add(T::DbWeight::get().reads(1))
             .saturating_add(T::DbWeight::get().writes(1))
     }
+
+    fn add_liquidity() -> Weight {
+        // Conservative weight estimate for add_liquidity
+        Weight::from_parts(50_000_000, 0)
+            .saturating_add(T::DbWeight::get().reads(5))
+            .saturating_add(T::DbWeight::get().writes(4))
+    }
+
+    fn remove_liquidity() -> Weight {
+        // Conservative weight estimate for remove_liquidity
+        Weight::from_parts(50_000_000, 0)
+            .saturating_add(T::DbWeight::get().reads(4))
+            .saturating_add(T::DbWeight::get().writes(4))
+    }
+
+    fn modify_position() -> Weight {
+        // Conservative weight estimate for modify_position
+        Weight::from_parts(50_000_000, 0)
+            .saturating_add(T::DbWeight::get().reads(4))
+            .saturating_add(T::DbWeight::get().writes(4))
+    }
 }
 
 // For backwards compatibility and tests
@@ -35,4 +59,22 @@ impl WeightInfo for () {
             .saturating_add(RocksDbWeight::get().reads(1))
             .saturating_add(RocksDbWeight::get().writes(1))
     }
+
+    fn add_liquidity() -> Weight {
+        Weight::from_parts(50_000_000, 0)
+            .saturating_add(RocksDbWeight::get().reads(5))
+            .saturating_add(RocksDbWeight::get().writes(4))
+    }
+
+    fn remove_liquidity() -> Weight {
+        Weight::from_parts(50_000_000, 0)
+            .saturating_add(RocksDbWeight::get().reads(4))
+            .saturating_add(RocksDbWeight::get().writes(4))
+    }
+
+    fn modify_position() -> Weight {
+        Weight::from_parts(50_000_000, 0)
+            .saturating_add(RocksDbWeight::get().reads(4))
+            .saturating_add(RocksDbWeight::get().writes(4))
+    }
 }

From 8adfd0bff8a2819ba9ae1f6400eae9e95116f277 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Fri, 16 May 2025 17:15:57 +0200
Subject: [PATCH 161/418] Clean up

---
 pallets/swap/src/tick.rs | 44 ----------------------------------------
 1 file changed, 44 deletions(-)

diff --git a/pallets/swap/src/tick.rs b/pallets/swap/src/tick.rs
index 435960e4bb..a3be3a5b3b 100644
--- a/pallets/swap/src/tick.rs
+++ b/pallets/swap/src/tick.rs
@@ -1028,36 +1028,6 @@ fn get_tick_at_sqrt_ratio(sqrt_price_x_96: U256) -> Result<i32, TickMathError> {
     Ok(tick)
 }
 
-/// Convert U256 to U64F64
-///
-/// # Arguments
-/// * `value` - The U256 value in Q64.96 format
-///
-/// # Returns
-/// * `Result<U64F64, TickMathError>` - Converted value or error if too large
-fn u256_to_u64f64(value: U256, source_fractional_bits: u32) -> Result<U64F64, TickMathError> {
-    if value > U256::from(u128::MAX) {
-        return Err(TickMathError::ConversionError);
-    }
-
-    let mut value: u128 = value
-        .try_into()
-        .map_err(|_| TickMathError::ConversionError)?;
-
-    // Adjust to 64 fractional bits (U64F64 format)
-    if source_fractional_bits < 64 {
-        // Shift left to add more fractional bits
-        value = value
-            .checked_shl(64 - source_fractional_bits)
-            .ok_or(TickMathError::Overflow)?;
-    } else if source_fractional_bits > 64 {
-        // Shift right to remove excess fractional bits
-        value = value >> (source_fractional_bits - 64);
-    }
-
-    Ok(U64F64::from_bits(value))
-}
-
 // Convert U64F64 to U256 in Q64.96 format (Uniswap's sqrt price format)
 fn u64f64_to_u256_q64_96(value: U64F64) -> U256 {
     u64f64_to_u256(value, 96)
@@ -1323,20 +1293,6 @@ mod tests {
         assert_eq!(back_to_u256, tick0_sqrt_price);
     }
 
-    #[test]
-    fn test_u256_with_other_formats() {
-        // Test with a value that has 32 fractional bits
-        let value_32frac = U256::from(123456789u128 << 32); // 123456789.0 in Q96.32
-        let fixed_value = u256_to_u64f64(value_32frac, 32).unwrap();
-
-        // Should be 123456789.0 in U64F64
-        assert_eq!(fixed_value, U64F64::from_num(123456789.0));
-
-        // Round trip back to U256 with 32 fractional bits
-        let back_to_u256 = u64f64_to_u256(fixed_value, 32);
-        assert_eq!(back_to_u256, value_32frac);
-    }
-
     #[test]
     fn test_tick_index_to_sqrt_price() {
         let tick_spacing = SqrtPrice::from_num(1.0001);

From 4296586a7f60f1934f9c18c742723902bed5bebd Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Fri, 16 May 2025 21:09:57 -0400
Subject: [PATCH 162/418] Fixing swap tests in progress

---
 .../subtensor/src/coinbase/run_coinbase.rs    |   1 -
 pallets/subtensor/src/staking/move_stake.rs   |   2 +
 pallets/subtensor/src/staking/remove_stake.rs |   6 +-
 pallets/subtensor/src/staking/stake_utils.rs  |   6 +
 pallets/subtensor/src/tests/staking.rs        | 234 +++++++++---------
 pallets/subtensor/src/tests/swap_coldkey.rs   |  43 +++-
 pallets/swap/src/pallet/impls.rs              |   1 +
 7 files changed, 161 insertions(+), 132 deletions(-)

diff --git a/pallets/subtensor/src/coinbase/run_coinbase.rs b/pallets/subtensor/src/coinbase/run_coinbase.rs
index 406405d961..07725f07a1 100644
--- a/pallets/subtensor/src/coinbase/run_coinbase.rs
+++ b/pallets/subtensor/src/coinbase/run_coinbase.rs
@@ -192,7 +192,6 @@ impl<T: Config> Pallet<T> {
             let pending_alpha: U96F32 = alpha_out_i.saturating_sub(root_alpha);
             log::debug!("pending_alpha: {:?}", pending_alpha);
             // Sell root emission through the pool.
-
             let swap_result = Self::swap_alpha_for_tao(
                 *netuid_i,
                 tou64!(root_alpha),
diff --git a/pallets/subtensor/src/staking/move_stake.rs b/pallets/subtensor/src/staking/move_stake.rs
index 1207a41340..843f403029 100644
--- a/pallets/subtensor/src/staking/move_stake.rs
+++ b/pallets/subtensor/src/staking/move_stake.rs
@@ -388,6 +388,8 @@ impl<T: Config> Pallet<T> {
     ///
     /// In the corner case when SubnetTAO(2) == SubnetTAO(1), no slippage is going to occur.
     ///
+    /// TODO: This formula only works for a single swap step, so it is not 100% correct for swap v3. We need an updated one.
+    /// 
     pub fn get_max_amount_move(
         origin_netuid: u16,
         destination_netuid: u16,
diff --git a/pallets/subtensor/src/staking/remove_stake.rs b/pallets/subtensor/src/staking/remove_stake.rs
index c2d0ff61f2..045c4ac013 100644
--- a/pallets/subtensor/src/staking/remove_stake.rs
+++ b/pallets/subtensor/src/staking/remove_stake.rs
@@ -158,7 +158,7 @@ impl<T: Config> Pallet<T> {
                     &coldkey,
                     netuid,
                     alpha_unstaked,
-                    T::SwapInterface::max_price(),
+                    T::SwapInterface::min_price(),
                 )?;
 
                 // Add the balance to the coldkey. If the above fails we will not credit this coldkey.
@@ -247,7 +247,7 @@ impl<T: Config> Pallet<T> {
                         &coldkey,
                         netuid,
                         alpha_unstaked,
-                        T::SwapInterface::max_price(),
+                        T::SwapInterface::min_price(),
                     )?;
 
                     // Increment total
@@ -351,7 +351,7 @@ impl<T: Config> Pallet<T> {
             &coldkey,
             netuid,
             possible_alpha,
-            T::SwapInterface::max_price(),
+            limit_price,
         )?;
 
         // 5. We add the balance to the coldkey. If the above fails we will not credit this coldkey.
diff --git a/pallets/subtensor/src/staking/stake_utils.rs b/pallets/subtensor/src/staking/stake_utils.rs
index 2a7b72da8f..af4aba3b5b 100644
--- a/pallets/subtensor/src/staking/stake_utils.rs
+++ b/pallets/subtensor/src/staking/stake_utils.rs
@@ -772,6 +772,12 @@ impl<T: Config> Pallet<T> {
         // Swap the alpha for TAO.
         let swap_result = Self::swap_alpha_for_tao(netuid, actual_alpha_decrease, price_limit)?;
 
+        // Refund the unused alpha (in case if limit price is hit)
+        let refund = actual_alpha_decrease.saturating_sub(
+            swap_result.amount_paid_in.saturating_add(swap_result.fee_paid)
+        );
+        Self::increase_stake_for_hotkey_and_coldkey_on_subnet(hotkey, coldkey, netuid, refund);
+
         // Step 3: Update StakingHotkeys if the hotkey's total alpha, across all subnets, is zero
         // TODO const: fix.
         // if Self::get_stake(hotkey, coldkey) == 0 {
diff --git a/pallets/subtensor/src/tests/staking.rs b/pallets/subtensor/src/tests/staking.rs
index 85165286b7..5d78d9ed7a 100644
--- a/pallets/subtensor/src/tests/staking.rs
+++ b/pallets/subtensor/src/tests/staking.rs
@@ -3062,53 +3062,46 @@ fn test_max_amount_remove_dynamic() {
         let subnet_owner_hotkey = U256::from(1002);
         let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
 
-        // Test cases are generated with help with this limit-staking calculator:
-        // https://docs.google.com/spreadsheets/d/1pfU-PVycd3I4DbJIc0GjtPohy4CbhdV6CWqgiy__jKE
-        // This is for reference only; verify before use.
-        //
-        // CSV backup for this spreadhsheet:
-        //
-        // SubnetTAO,AlphaIn,initial price,limit price,max swappable
-        // 100,100,=A2/B2,4,=A2/D2-B2
-        //
         // tao_in, alpha_in, limit_price, expected_max_swappable
         [
             // Zero handling (no panics)
             (0, 1_000_000_000, 100, 0),
             (1_000_000_000, 0, 100, 0),
-            (1_000_000_000, 1_000_000_000, 0, u64::MAX),
-            // Low bounds
-            (1, 1, 0, u64::MAX),
-            (1, 1, 1, 999_999_999),
-            (1, 1, 2, 499_999_999),
-            (1, 1, 250_000_000, 3),
+            (10_000_000_000, 10_000_000_000, 0, u64::MAX),
+            // Low bounds (numbers are empirical, it is only important that result 
+            // is sharply decreasing when limit price increases)
+            (1_000, 1_000, 0, 0),
+            (1_001, 1_001, 0, 4_307_770_117),
+            (1_001, 1_001, 1, 31_715),
+            (1_001, 1_001, 2, 22_426),
+            (1_001, 1_001, 1_001, 1_000),
             // Basic math
-            (1_000, 1_000, 250_000_000, 3_000),
-            (1_000, 1_000, 62_500_000, 15_000),
+            (1_000_000, 1_000_000, 250_000_000, 1_000_000),
+            (1_000_000, 1_000_000, 62_500_000, 3_000_000),
             (
                 1_000_000_000_000,
                 1_000_000_000_000,
                 62_500_000,
-                15_000_000_000_000,
+                3_000_000_000_000,
             ),
-            // Normal range values with edge cases
+            // Normal range values with edge cases and sanity checks
             (200_000_000_000, 100_000_000_000, 0, u64::MAX),
             (
                 200_000_000_000,
                 100_000_000_000,
-                1_000_000_000,
+                500_000_000,
                 100_000_000_000,
             ),
             (
                 200_000_000_000,
                 100_000_000_000,
-                500_000_000,
+                125_000_000,
                 300_000_000_000,
             ),
             (200_000_000_000, 100_000_000_000, 2_000_000_000, 0),
             (200_000_000_000, 100_000_000_000, 2_000_000_001, 0),
-            (200_000_000_000, 100_000_000_000, 1_999_999_999, 50),
-            (200_000_000_000, 100_000_000_000, 1_999_999_990, 500),
+            (200_000_000_000, 100_000_000_000, 1_999_999_999, 24),
+            (200_000_000_000, 100_000_000_000, 1_999_999_990, 252),
             // Miscellaneous overflows and underflows
             (2_000_000_000_000, 100_000_000_000, u64::MAX, 0),
             (200_000_000_000, 100_000_000_000, u64::MAX / 2, 0),
@@ -3121,20 +3114,32 @@ fn test_max_amount_remove_dynamic() {
                 21_000_000_000_000_000,
                 1_000_000,
                 21_000_000_000_000_000,
-                999_000_000,
+                30_700_000,
             ),
-            (21_000_000_000_000_000, 1_000_000, u64::MAX, 138_412),
+            (21_000_000_000_000_000, 1_000_000, u64::MAX, 67_164),
             (
                 21_000_000_000_000_000,
-                1_000_000_000_000_000_000_u64,
+                1_000_000_000_000_000_000,
                 u64::MAX,
                 0,
             ),
             (
                 21_000_000_000_000_000,
-                1_000_000_000_000_000_000_u64,
+                1_000_000_000_000_000_000,
                 20_000_000,
-                50_000_000_000_000_000,
+                24_800_000_000_000_000,
+            ),
+            (
+                21_000_000_000_000_000,
+                21_000_000_000_000_000,
+                999_999_999,
+                10_500_000,
+            ),
+            (
+                21_000_000_000_000_000,
+                21_000_000_000_000_000,
+                0,
+                u64::MAX,
             ),
         ]
         .iter()
@@ -3151,9 +3156,11 @@ fn test_max_amount_remove_dynamic() {
                 );
             }
 
-            assert_eq!(
+            let expected = expected_max_swappable.saturating_add((expected_max_swappable as f64 * 0.003) as u64);
+            assert_abs_diff_eq!(
                 SubtensorModule::get_max_amount_remove(netuid, limit_price),
-                expected_max_swappable,
+                expected,
+                epsilon = expected / 100
             );
         });
     });
@@ -3247,7 +3254,7 @@ fn test_max_amount_move_stable_dynamic() {
         let subnet_owner_hotkey = U256::from(1002);
         let dynamic_netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
 
-        // Forse-set alpha in and tao reserve to make price equal 0.5
+        // Force-set alpha in and tao reserve to make price equal 0.5
         let tao_reserve: U96F32 = U96F32::from_num(50_000_000_000_u64);
         let alpha_in: U96F32 = U96F32::from_num(100_000_000_000_u64);
         SubnetTAO::<Test>::insert(dynamic_netuid, tao_reserve.to_num::<u64>());
@@ -3277,10 +3284,11 @@ fn test_max_amount_move_stable_dynamic() {
         );
 
         // 2x price => max is 1x TAO
+        let tao_reserve_u64 = tao_reserve.to_num::<u64>();
         assert_abs_diff_eq!(
-            SubtensorModule::get_max_amount_move(stable_netuid, dynamic_netuid, 1_000_000_000),
-            50_000_000_000,
-            epsilon = 10_000,
+            SubtensorModule::get_max_amount_move(stable_netuid, dynamic_netuid, 500_000_000),
+            tao_reserve_u64 + (tao_reserve_u64 as f64 * 0.003) as u64,
+            epsilon = tao_reserve_u64 / 100,
         );
 
         // Precision test:
@@ -3353,11 +3361,12 @@ fn test_max_amount_move_dynamic_stable() {
             epsilon = 10_000
         );
 
-        // 1/2 price => max is 1x Alpha
+        // 1/4 price => max is 1x Alpha
+        let alpha_in_u64 = alpha_in.to_num::<u64>();
         assert_abs_diff_eq!(
-            SubtensorModule::get_max_amount_move(dynamic_netuid, stable_netuid, 750_000_000),
-            100_000_000_000,
-            epsilon = 10_000,
+            SubtensorModule::get_max_amount_move(dynamic_netuid, stable_netuid, 375_000_000),
+            alpha_in_u64 + (alpha_in_u64 as f64 * 0.003) as u64,
+            epsilon = alpha_in_u64 / 1000,
         );
 
         // Precision test:
@@ -3738,58 +3747,58 @@ fn test_remove_stake_limit_ok() {
         let hotkey_account_id = U256::from(533453);
         let coldkey_account_id = U256::from(55453);
         let stake_amount = 300_000_000_000;
-        let unstake_amount = 150_000_000_000;
-        let fee: u64 = 0; // FIXME: DefaultStakingFee is deprecated
 
         // add network
         let netuid: u16 = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey_account_id, stake_amount + ExistentialDeposit::get());
 
-        // Give the neuron some stake to remove
-        SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
-            &hotkey_account_id,
-            &coldkey_account_id,
+        // Forse-set sufficient reserves
+        let tao_reserve: U96F32 = U96F32::from_num(100_000_000_000_u64);
+        let alpha_in: U96F32 = U96F32::from_num(100_000_000_000_u64);
+        SubnetTAO::<Test>::insert(netuid, tao_reserve.to_num::<u64>());
+        SubnetAlphaIn::<Test>::insert(netuid, alpha_in.to_num::<u64>());
+
+        // Stake to hotkey account, and check if the result is ok
+        assert_ok!(SubtensorModule::add_stake(
+            RuntimeOrigin::signed(coldkey_account_id),
+            hotkey_account_id,
             netuid,
-            stake_amount,
-        );
+            stake_amount
+        ));
         let alpha_before = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
             &hotkey_account_id,
             &coldkey_account_id,
             netuid,
         );
 
-        // Forse-set alpha in and tao reserve to make price equal 1.5
-        let tao_reserve: U96F32 = U96F32::from_num(150_000_000_000_u64);
-        let alpha_in: U96F32 = U96F32::from_num(100_000_000_000_u64);
-        SubnetTAO::<Test>::insert(netuid, tao_reserve.to_num::<u64>());
-        SubnetAlphaIn::<Test>::insert(netuid, alpha_in.to_num::<u64>());
+        // Setup limit price to 99% of current price
         let current_price = <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid);
-        assert_eq!(current_price, U96F32::from_num(1.5));
-
-        // Setup limit price so resulting average price doesn't drop by more than 10% from current price
-        let limit_price = 1_350_000_000;
+        let limit_price = (current_price.to_num::<f64>() * 990_000_000_f64) as u64;
 
-        // Alpha unstaked = 150 / 1.35 - 100 ~ 11.1
-        let expected_alpha_reduction = 11_111_111_111;
+        // Alpha unstaked - calculated using formula from delta_in()
+        let expected_alpha_reduction = (0.00138 * alpha_in.to_num::<f64>()) as u64;
+        let fee: u64 = (expected_alpha_reduction as f64 * 0.003) as u64;
 
         // Remove stake with slippage safety
         assert_ok!(SubtensorModule::remove_stake_limit(
             RuntimeOrigin::signed(coldkey_account_id),
             hotkey_account_id,
             netuid,
-            unstake_amount,
+            alpha_before / 2,
             limit_price,
             true
         ));
+        let alpha_after = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+            &hotkey_account_id,
+            &coldkey_account_id,
+            netuid,
+        );
 
-        // Check if stake has decreased only by
+        // Check if stake has decreased properly
         assert_abs_diff_eq!(
-            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
-                &hotkey_account_id,
-                &coldkey_account_id,
-                netuid
-            ),
-            alpha_before - expected_alpha_reduction - fee,
-            epsilon = expected_alpha_reduction / 1_000,
+            alpha_before - alpha_after,
+            expected_alpha_reduction + fee,
+            epsilon = expected_alpha_reduction / 10,
         );
     });
 }
@@ -4285,40 +4294,44 @@ fn test_unstake_all_alpha_hits_liquidity_min() {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
 
-        let stake_amount = 190_000_000_000; // 190 Alpha
+        let stake_amount = 100_000_000_000; // 100 TAO
 
         let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
         register_ok_neuron(netuid, hotkey, coldkey, 192213123);
-        // Give the neuron some stake to remove
-        SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
-            &hotkey,
+        SubtensorModule::add_balance_to_coldkey_account(
             &coldkey,
-            netuid,
-            stake_amount,
+            stake_amount + ExistentialDeposit::get(),
         );
+        // Give the neuron some stake to remove
+        assert_ok!(SubtensorModule::add_stake(
+            RuntimeOrigin::signed(coldkey),
+            hotkey,
+            netuid,
+            stake_amount
+        ));
 
-        // Setup the Alpha pool so that removing all the Alpha will bring liqudity below the minimum
+        // Setup the pool so that removing all the TAO will bring liqudity below the minimum
         let remaining_tao = I96F32::from_num(u64::from(mock::SwapMinimumReserve::get()) - 1)
             .saturating_sub(I96F32::from(1));
-        let alpha_reserves = I110F18::from(stake_amount + 10_000_000);
-        let alpha = stake_amount;
+        let alpha = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid);
+        let alpha_reserves = I110F18::from(alpha + 10_000_000);
 
         let k = I110F18::from_fixed(remaining_tao)
             .saturating_mul(alpha_reserves.saturating_add(I110F18::from(alpha)));
         let tao_reserves = k.safe_div(alpha_reserves);
 
-        mock::setup_reserves(netuid, tao_reserves.to_num(), alpha_reserves.to_num());
+        mock::setup_reserves(netuid, tao_reserves.to_num::<u64>() / 100_u64, alpha_reserves.to_num());
 
         // Try to unstake, but we reduce liquidity too far
 
-        assert!(
-            SubtensorModule::unstake_all_alpha(RuntimeOrigin::signed(coldkey), hotkey,).is_err()
+        assert_ok!(
+            SubtensorModule::unstake_all_alpha(RuntimeOrigin::signed(coldkey), hotkey)
         );
 
         // Expect nothing to be unstaked
         let new_alpha =
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid);
-        assert_eq!(new_alpha, stake_amount);
+        assert_eq!(new_alpha, alpha);
     });
 }
 
@@ -4330,29 +4343,25 @@ fn test_unstake_all_alpha_works() {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
 
-        let stake_amount = 190_000_000_000; // 190 Alpha
+        let stake_amount = 190_000_000_000; // 190 TAO
 
         let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
         register_ok_neuron(netuid, hotkey, coldkey, 192213123);
-
-        // Give the neuron some stake to remove
-        SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
-            &hotkey,
+        SubtensorModule::add_balance_to_coldkey_account(
             &coldkey,
-            netuid,
-            stake_amount,
+            stake_amount + ExistentialDeposit::get(),
         );
 
-        // Setup the Alpha pool so that removing all the Alpha will keep liq above min
-        let alpha_reserves = stake_amount + u64::from(mock::SwapMinimumReserve::get());
-        let (tao_reserves, fee) = mock::swap_alpha_to_tao(netuid, alpha_reserves);
-        let fee: u64 = <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid)
-            .saturating_mul(U96F32::from_num(fee))
-            .to_num();
-        let tao_reserves = tao_reserves + fee;
+        // Give the neuron some stake to remove
+        assert_ok!(SubtensorModule::add_stake(
+            RuntimeOrigin::signed(coldkey),
+            hotkey,
+            netuid,
+            stake_amount
+        ));
 
-        mock::setup_reserves(netuid, tao_reserves, alpha_reserves);
-        mock::setup_reserves(0, tao_reserves, alpha_reserves);
+        // Setup the pool so that removing all the TAO will keep liq above min
+        mock::setup_reserves(netuid, stake_amount * 10, stake_amount * 100);
 
         // Unstake all alpha to root
         assert_ok!(SubtensorModule::unstake_all_alpha(
@@ -4377,34 +4386,27 @@ fn test_unstake_all_works() {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
 
-        let stake_amount = 190_000_000_000; // 190 Alpha
+        let stake_amount = 190_000_000_000; // 190 TAO
 
         let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
         register_ok_neuron(netuid, hotkey, coldkey, 192213123);
-        // Give the neuron some stake to remove
-        SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
-            &hotkey,
+        SubtensorModule::add_balance_to_coldkey_account(
             &coldkey,
-            netuid,
-            stake_amount,
+            stake_amount + ExistentialDeposit::get(),
         );
 
-        // Setup the Alpha pool so that removing all the Alpha will keep liq above min
-        let remaining_tao = I96F32::from_num(u64::from(mock::SwapMinimumReserve::get()) - 1)
-            .saturating_add(I96F32::from(10_000_000));
-        let alpha_reserves = I110F18::from(stake_amount + 10_000_000);
-        let alpha = stake_amount;
-
-        let k = I110F18::from_fixed(remaining_tao)
-            .saturating_mul(alpha_reserves.saturating_add(I110F18::from(alpha)));
-        let tao_reserves: I110F18 = k.safe_div(alpha_reserves);
-
-        mock::setup_reserves(netuid, tao_reserves.to_num(), alpha_reserves.to_num());
+        // Give the neuron some stake to remove
+        assert_ok!(SubtensorModule::add_stake(
+            RuntimeOrigin::signed(coldkey),
+            hotkey,
+            netuid,
+            stake_amount
+        ));
 
-        SubnetTAO::<Test>::insert(netuid, tao_reserves.to_num::<u64>());
-        SubnetAlphaIn::<Test>::insert(netuid, alpha_reserves.to_num::<u64>());
+        // Setup the pool so that removing all the TAO will keep liq above min
+        mock::setup_reserves(netuid, stake_amount * 10, stake_amount * 100);
 
-        // Unstake all alpha to root
+        // Unstake all alpha to free balance
         assert_ok!(SubtensorModule::unstake_all(
             RuntimeOrigin::signed(coldkey),
             hotkey,
@@ -4412,7 +4414,7 @@ fn test_unstake_all_works() {
 
         let new_alpha =
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid);
-        assert_abs_diff_eq!(new_alpha, 0, epsilon = 1_000,);
+        assert_abs_diff_eq!(new_alpha, 0, epsilon = 1_000);
         let new_balance = SubtensorModule::get_coldkey_balance(&coldkey);
         assert!(new_balance > 100_000);
     });
diff --git a/pallets/subtensor/src/tests/swap_coldkey.rs b/pallets/subtensor/src/tests/swap_coldkey.rs
index 3727b9d2af..5fb2bf0f59 100644
--- a/pallets/subtensor/src/tests/swap_coldkey.rs
+++ b/pallets/subtensor/src/tests/swap_coldkey.rs
@@ -442,14 +442,17 @@ fn test_swap_with_non_existent_new_coldkey() {
         mock::setup_reserves(netuid, reserve, reserve);
 
         // Stake to hotkey.
-
-        let (_, fee) = mock::swap_tao_to_alpha(netuid, stake);
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(old_coldkey),
             hotkey,
             netuid,
             stake
         ));
+        let expected_stake = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+            &hotkey,
+            &old_coldkey,
+            netuid,
+        );
 
         let mut weight = Weight::zero();
         assert_ok!(SubtensorModule::perform_swap_coldkey(
@@ -462,9 +465,14 @@ fn test_swap_with_non_existent_new_coldkey() {
             SubtensorModule::get_total_stake_for_coldkey(&old_coldkey),
             0
         );
-        let expected_stake = stake - fee;
+
+        let actual_stake = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+            &hotkey,
+            &new_coldkey,
+            netuid,
+        );
         assert_abs_diff_eq!(
-            SubtensorModule::get_total_stake_for_coldkey(&new_coldkey),
+            actual_stake,
             expected_stake,
             epsilon = expected_stake / 1000
         );
@@ -576,7 +584,6 @@ fn test_swap_concurrent_modifications() {
         );
         register_ok_neuron(netuid, hotkey, new_coldkey, 1001000);
 
-        let (initial_stake_alpha, _) = mock::swap_tao_to_alpha(netuid, initial_stake);
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(new_coldkey),
             hotkey,
@@ -591,13 +598,9 @@ fn test_swap_concurrent_modifications() {
             netuid,
         );
 
-        assert_eq!(stake_before_swap, initial_stake_alpha);
-
         // Wait some blocks
         step_block(10);
 
-        let (additional_stake_alpha, _) = mock::swap_tao_to_alpha(netuid, additional_stake);
-
         // Simulate concurrent stake addition
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(new_coldkey),
@@ -606,6 +609,12 @@ fn test_swap_concurrent_modifications() {
             additional_stake
         ));
 
+        let stake_with_additional = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+            &hotkey,
+            &new_coldkey,
+            netuid,
+        );
+
         let mut weight = Weight::zero();
         assert_ok!(SubtensorModule::perform_swap_coldkey(
             &old_coldkey,
@@ -619,8 +628,9 @@ fn test_swap_concurrent_modifications() {
                 &new_coldkey,
                 netuid
             ),
-            stake_before_swap + additional_stake_alpha
+            stake_with_additional
         );
+        assert!(stake_with_additional > stake_before_swap);
         assert!(!Alpha::<Test>::contains_key((hotkey, old_coldkey, netuid)));
     });
 }
@@ -1097,8 +1107,6 @@ fn test_swap_delegated_stake_for_coldkey() {
             stake_amount1 + stake_amount2 + 1_000_000,
         );
 
-        let (expected_stake_alpha1, fee) = mock::swap_tao_to_alpha(netuid, stake_amount1);
-
         // === Stake to hotkeys ===
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(old_coldkey),
@@ -1106,6 +1114,11 @@ fn test_swap_delegated_stake_for_coldkey() {
             netuid,
             stake_amount1
         ));
+        let expected_stake_alpha1 = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+            &hotkey1,
+            &old_coldkey,
+            netuid,
+        );
 
         let (expected_stake_alpha2, fee) = mock::swap_tao_to_alpha(netuid, stake_amount2);
         assert_ok!(SubtensorModule::add_stake(
@@ -1114,6 +1127,12 @@ fn test_swap_delegated_stake_for_coldkey() {
             netuid,
             stake_amount2
         ));
+        let expected_stake_alpha2 = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+            &hotkey2,
+            &old_coldkey,
+            netuid,
+        );
+        let fee = (expected_stake_alpha2 as f64 * 0.003) as u64;
 
         // Record initial values
         let initial_total_issuance = SubtensorModule::get_total_issuance();
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 3bddf64d21..602fb7a496 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -115,6 +115,7 @@ impl<T: Config> SwapStep<T> {
             self.action = SwapStepAction::Stop;
             self.final_price = self.sqrt_price_target;
             self.delta_in = self.possible_delta_in;
+            // println!("Case 1. Delta in = {:?}", self.delta_in);
         } else if self.price_is_closer(&self.sqrt_price_limit, &self.sqrt_price_target)
             && self.price_is_closer(&self.sqrt_price_limit, &self.sqrt_price_edge)
         {

From da050d83c1ae703ea65b612fd0543afae2932e05 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Sat, 17 May 2025 21:03:30 +0800
Subject: [PATCH 163/418] test is done

---
 evm-tests/src/subtensor.ts                    | 10 ++++
 .../test/runtime.call.precompile.test.ts      | 55 +++++++++++--------
 pallets/subtensor/src/tests/batch_tx.rs       | 45 ++++++++++++++-
 precompiles/src/lib.rs                        |  1 +
 precompiles/src/storage_query.rs              | 15 +++++
 5 files changed, 102 insertions(+), 24 deletions(-)

diff --git a/evm-tests/src/subtensor.ts b/evm-tests/src/subtensor.ts
index 3111d90544..dd5161933a 100644
--- a/evm-tests/src/subtensor.ts
+++ b/evm-tests/src/subtensor.ts
@@ -343,4 +343,14 @@ export async function startCall(api: TypedApi<typeof devnet>, netuid: number, ke
     const callStarted = await api.query.SubtensorModule.FirstEmissionBlockNumber
         .getValue(netuid);
     assert.notEqual(callStarted, undefined);
+}
+
+// sudo_set_max_childkey_take
+
+export async function setMaxChildkeyTake(api: TypedApi<typeof devnet>, take: number) {
+    const alice = getAliceSigner()
+    const internalCall = api.tx.SubtensorModule.sudo_set_max_childkey_take({ take })
+    const tx = api.tx.Sudo.sudo({ call: internalCall.decodedCall })
+
+    await waitForTransactionWithRetry(api, tx, alice)
 }
\ No newline at end of file
diff --git a/evm-tests/test/runtime.call.precompile.test.ts b/evm-tests/test/runtime.call.precompile.test.ts
index 8876dbdad8..8bd1eb1702 100644
--- a/evm-tests/test/runtime.call.precompile.test.ts
+++ b/evm-tests/test/runtime.call.precompile.test.ts
@@ -7,10 +7,10 @@ import { getAliceSigner, getDevnetApi } from "../src/substrate"
 import {  generateRandomEthersWallet, getPublicClient } from "../src/utils";
 import { IDISPATCH_ADDRESS, ISTORAGE_QUERY_ADDRESS, ETH_LOCAL_URL } from "../src/config";
 import { devnet } from "@polkadot-api/descriptors"
-import { PublicClient } from "viem";
+import { hexToBigInt, hexToNumber, PublicClient } from "viem";
 import { PolkadotSigner, TypedApi } from "polkadot-api";
 import { convertPublicKeyToSs58 } from "../src/address-utils"
-import { forceSetBalanceToEthAddress } from "../src/subtensor";
+import { forceSetBalanceToEthAddress, setMaxChildkeyTake } from "../src/subtensor";
 
 describe("Test the dispatch precompile", () => {
     let publicClient: PublicClient;
@@ -25,43 +25,54 @@ describe("Test the dispatch precompile", () => {
         api = await getDevnetApi()
         alice = await getAliceSigner()
         await forceSetBalanceToEthAddress(api, wallet1.address)
+        
         console.log("wallet1 address: ", wallet1.address)
     })
 
-    // it("Dispatch transfer call via precompile contract works correctly", async () => {
-    //     // 0x050300d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d02286bee
-    //     // call for transfer 1 token to alice
-    //     const transferAmount = BigInt(1000000000);
-    //     const transferCall = "0x050300d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d02286bee"
-    //     const aliceBalance =  (await api.query.System.Account.getValue( convertPublicKeyToSs58(alice.publicKey))).data.free
-
-    //     console.log("alice balance before transfer: ", aliceBalance.toString())
-    //     const txResponse = await wallet1.sendTransaction({
-    //         to: IDISPATCH_ADDRESS,
-    //         data: transferCall,
-    //     })
-    //     await txResponse.wait()
-
-    //     const aliceBalanceAfterTransfer =  (await api.query.System.Account.getValue( convertPublicKeyToSs58(alice.publicKey))).data.free
+    it("Dispatch transfer call via precompile contract works correctly", async () => {
+        // 0x050300d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d02286bee
+        // call for transfer 1 token to alice
+        const transferAmount = BigInt(1000000000);
+        const transferCall = "0x050300d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d02286bee"
+        const aliceBalance =  (await api.query.System.Account.getValue( convertPublicKeyToSs58(alice.publicKey))).data.free
+
+        console.log("alice balance before transfer: ", aliceBalance.toString())
+        const txResponse = await wallet1.sendTransaction({
+            to: IDISPATCH_ADDRESS,
+            data: transferCall,
+        })
+        await txResponse.wait()
 
-    //     assert.equal(aliceBalance + transferAmount, aliceBalanceAfterTransfer)
+        const aliceBalanceAfterTransfer =  (await api.query.System.Account.getValue( convertPublicKeyToSs58(alice.publicKey))).data.free
 
-    //     console.log("alice balance after transfer: ", aliceBalanceAfterTransfer.toString())
-    // })
+        assert.equal(aliceBalance + transferAmount, aliceBalanceAfterTransfer)
+    })
 
     
 
     it("Storage query call via precompile contract works correctly", async () => {
+        let maxChildkeyTake = 257;
+        await setMaxChildkeyTake(api, maxChildkeyTake)
+        // sudo_set_max_childkey_take
         // 0x658faa385070e074c85bf6b568cf0555f14f14d903e9994045ff1902b3e513dc
     // key for min child key take
-        const storageQuery = "0x658faa385070e074c85bf6b568cf0555f14f14d903e9994045ff1902b3e513dc"
+
+        const storageQuery = "0x658faa385070e074c85bf6b568cf0555dba018859cab7e989f77669457b394be"
+
+        api.query.SubtensorModule.MaxChildkeyTake.getValue();
+
+        // api.apis.
 
         const rawCallResponse = await publicClient.call({
             to: ISTORAGE_QUERY_ADDRESS,
             data: storageQuery,
         })
         const rawResultData = rawCallResponse.data;
-        console.log("Raw result data:", rawResultData);
+        if (rawResultData === undefined) {
+            throw new Error("rawResultData is undefined");
+        }
+        let value = hexToNumber(rawResultData);
+        assert.equal(value, maxChildkeyTake, "value should be 257")
 
 
         
diff --git a/pallets/subtensor/src/tests/batch_tx.rs b/pallets/subtensor/src/tests/batch_tx.rs
index 512fa9b368..9147d9f39a 100644
--- a/pallets/subtensor/src/tests/batch_tx.rs
+++ b/pallets/subtensor/src/tests/batch_tx.rs
@@ -1,8 +1,10 @@
+use crate::MaxChildkeyTake;
+
 use super::mock::*;
-use frame_support::{assert_ok, traits::Currency};
+use frame_support::{StorageHasher, Twox128, assert_ok, traits::Currency};
 use frame_system::Config;
 use sp_core::U256;
-
+use sp_io::hashing::twox_128;
 // SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor --lib -- tests::batch_tx::test_batch_txs --exact --show-output --nocapture
 #[test]
 fn test_batch_txs() {
@@ -33,3 +35,42 @@ fn test_batch_txs() {
         assert_eq!(Balances::total_balance(&charlie), 2_000_000_000);
     });
 }
+
+// [101, 143, 170, 56, 80, 112, 224, 116, 200, 91, 246, 181, 104, 207, 5, 85, 219, 160, 24, 133, 156, 171, 126, 152, 159, 119, 102, 148, 87, 179, 148, 190]
+#[test]
+fn test_batch_txs2() {
+    let alice = U256::from(0);
+    let bob = U256::from(1);
+    let charlie = U256::from(2);
+    let initial_balances = vec![
+        (alice, 8_000_000_000),
+        (bob, 1_000_000_000),
+        (charlie, 1_000_000_000),
+    ];
+    test_ext_with_balances(initial_balances).execute_with(|| {
+        let init_value = SubtensorModule::get_max_childkey_take();
+        log::error!("Storage value: {:?}", init_value);
+
+        SubtensorModule::set_max_childkey_take(1000);
+
+        // let mut final_key = [0u8; 32];
+        // final_key[16..].copy_from_slice(twox_128(b"Subtensor"));
+        // final_key[..16].copy_from_slice(twox_128(b"MaxChildkeyTake"));
+        let final_key = [twox_128(b"SubtensorModule"), twox_128(b"MaxChildkeyTake")].concat();
+        log::error!("Storage value: {:?}", final_key);
+
+        let hash_key = MaxChildkeyTake::<Test>::hashed_key();
+        log::error!("Storage value: {:?}", hash_key);
+        // let key = [
+        //     101, 143, 170, 56, 80, 112, 224, 116, 200, 91, 246, 181, 104, 207, 5, 85, 219, 160, 24,
+        //     133, 156, 171, 126, 152, 159, 119, 102, 148, 87, 179, 148, 190,
+        // ];
+        let value = sp_io::storage::get(&final_key[..]);
+        log::error!("Storage value: {:?}", value);
+        assert_eq!(value, None);
+
+        sp_io::storage::set(&final_key[..], &[0u8; 32][..]);
+        let init_value = SubtensorModule::get_max_childkey_take();
+        log::error!("Storage value: {:?}", init_value);
+    });
+}
diff --git a/precompiles/src/lib.rs b/precompiles/src/lib.rs
index 3bdf417d8d..2b7e720f08 100644
--- a/precompiles/src/lib.rs
+++ b/precompiles/src/lib.rs
@@ -175,6 +175,7 @@ where
                 UidLookupPrecompile::<R>::try_execute::<R>(handle, PrecompileEnum::UidLookup)
             }
             a if a == hash(StorageQueryPrecompile::<R>::INDEX) => {
+                log::error!("StorageQueryPrecompile::execute {} {}", file!(), line!());
                 Some(StorageQueryPrecompile::<R>::execute(handle))
             }
             _ => None,
diff --git a/precompiles/src/storage_query.rs b/precompiles/src/storage_query.rs
index 1062e78e95..3534b2b739 100644
--- a/precompiles/src/storage_query.rs
+++ b/precompiles/src/storage_query.rs
@@ -35,11 +35,26 @@ where
     <<R as frame_system::Config>::Lookup as StaticLookup>::Source: From<R::AccountId>,
 {
     fn execute(handle: &mut impl PrecompileHandle) -> fp_evm::PrecompileResult {
+        log::error!("StorageQueryPrecompile::execute {} {}", file!(), line!());
+
         let input = handle.input();
         let data = sp_io::storage::get(&input[..]);
+        log::error!(
+            "============================= StorageQueryPrecompile::execute {:?} {:?}",
+            input,
+            data
+        );
+
+        log::error!("StorageQueryPrecompile::execute {} {}", file!(), line!());
+
         match data {
             Some(value) => {
                 let result = value.to_vec();
+                log::error!(
+                    "============================= StorageQueryPrecompile::execute  {:?}",
+                    result
+                );
+
                 Ok(PrecompileOutput {
                     exit_status: ExitSucceed::Returned,
                     output: result,

From 8270040007f7d5af6a8342935ffb85dd75c1baae Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Sat, 17 May 2025 21:25:19 +0800
Subject: [PATCH 164/418] clean up code

---
 evm-tests/package.json                        |  2 +-
 .../test/runtime.call.precompile.test.ts      | 21 +--------
 pallets/subtensor/src/tests/batch_tx.rs       | 44 +------------------
 precompiles/src/storage_query.rs              | 13 ------
 4 files changed, 4 insertions(+), 76 deletions(-)

diff --git a/evm-tests/package.json b/evm-tests/package.json
index b3ab563ef5..ca35fe2d1b 100644
--- a/evm-tests/package.json
+++ b/evm-tests/package.json
@@ -1,6 +1,6 @@
 {
   "scripts": {
-    "test": "mocha --timeout 999999 --file src/setup.ts --require ts-node/register test/runtime*test.ts"
+    "test": "mocha --timeout 999999 --retries 3 --file src/setup.ts --require ts-node/register test/*test.ts"
   },
   "keywords": [],
   "author": "",
diff --git a/evm-tests/test/runtime.call.precompile.test.ts b/evm-tests/test/runtime.call.precompile.test.ts
index 8bd1eb1702..e1da4a0b57 100644
--- a/evm-tests/test/runtime.call.precompile.test.ts
+++ b/evm-tests/test/runtime.call.precompile.test.ts
@@ -1,22 +1,16 @@
-
-
-
 import * as assert from "assert";
-
 import { getAliceSigner, getDevnetApi } from "../src/substrate"
 import {  generateRandomEthersWallet, getPublicClient } from "../src/utils";
 import { IDISPATCH_ADDRESS, ISTORAGE_QUERY_ADDRESS, ETH_LOCAL_URL } from "../src/config";
 import { devnet } from "@polkadot-api/descriptors"
-import { hexToBigInt, hexToNumber, PublicClient } from "viem";
+import { hexToNumber, PublicClient } from "viem";
 import { PolkadotSigner, TypedApi } from "polkadot-api";
 import { convertPublicKeyToSs58 } from "../src/address-utils"
 import { forceSetBalanceToEthAddress, setMaxChildkeyTake } from "../src/subtensor";
 
 describe("Test the dispatch precompile", () => {
     let publicClient: PublicClient;
-     // init eth part
     const wallet1 = generateRandomEthersWallet();
-
     let api: TypedApi<typeof devnet>
     let alice: PolkadotSigner;
 
@@ -25,8 +19,6 @@ describe("Test the dispatch precompile", () => {
         api = await getDevnetApi()
         alice = await getAliceSigner()
         await forceSetBalanceToEthAddress(api, wallet1.address)
-        
-        console.log("wallet1 address: ", wallet1.address)
     })
 
     it("Dispatch transfer call via precompile contract works correctly", async () => {
@@ -35,8 +27,6 @@ describe("Test the dispatch precompile", () => {
         const transferAmount = BigInt(1000000000);
         const transferCall = "0x050300d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d02286bee"
         const aliceBalance =  (await api.query.System.Account.getValue( convertPublicKeyToSs58(alice.publicKey))).data.free
-
-        console.log("alice balance before transfer: ", aliceBalance.toString())
         const txResponse = await wallet1.sendTransaction({
             to: IDISPATCH_ADDRESS,
             data: transferCall,
@@ -53,16 +43,12 @@ describe("Test the dispatch precompile", () => {
     it("Storage query call via precompile contract works correctly", async () => {
         let maxChildkeyTake = 257;
         await setMaxChildkeyTake(api, maxChildkeyTake)
-        // sudo_set_max_childkey_take
         // 0x658faa385070e074c85bf6b568cf0555f14f14d903e9994045ff1902b3e513dc
-    // key for min child key take
+        // key for min child key take
 
         const storageQuery = "0x658faa385070e074c85bf6b568cf0555dba018859cab7e989f77669457b394be"
 
         api.query.SubtensorModule.MaxChildkeyTake.getValue();
-
-        // api.apis.
-
         const rawCallResponse = await publicClient.call({
             to: ISTORAGE_QUERY_ADDRESS,
             data: storageQuery,
@@ -73,8 +59,5 @@ describe("Test the dispatch precompile", () => {
         }
         let value = hexToNumber(rawResultData);
         assert.equal(value, maxChildkeyTake, "value should be 257")
-
-
-        
     })
 });
diff --git a/pallets/subtensor/src/tests/batch_tx.rs b/pallets/subtensor/src/tests/batch_tx.rs
index 9147d9f39a..8c2e3a42ad 100644
--- a/pallets/subtensor/src/tests/batch_tx.rs
+++ b/pallets/subtensor/src/tests/batch_tx.rs
@@ -1,10 +1,7 @@
-use crate::MaxChildkeyTake;
-
 use super::mock::*;
-use frame_support::{StorageHasher, Twox128, assert_ok, traits::Currency};
+use frame_support::{assert_ok, traits::Currency};
 use frame_system::Config;
 use sp_core::U256;
-use sp_io::hashing::twox_128;
 // SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor --lib -- tests::batch_tx::test_batch_txs --exact --show-output --nocapture
 #[test]
 fn test_batch_txs() {
@@ -35,42 +32,3 @@ fn test_batch_txs() {
         assert_eq!(Balances::total_balance(&charlie), 2_000_000_000);
     });
 }
-
-// [101, 143, 170, 56, 80, 112, 224, 116, 200, 91, 246, 181, 104, 207, 5, 85, 219, 160, 24, 133, 156, 171, 126, 152, 159, 119, 102, 148, 87, 179, 148, 190]
-#[test]
-fn test_batch_txs2() {
-    let alice = U256::from(0);
-    let bob = U256::from(1);
-    let charlie = U256::from(2);
-    let initial_balances = vec![
-        (alice, 8_000_000_000),
-        (bob, 1_000_000_000),
-        (charlie, 1_000_000_000),
-    ];
-    test_ext_with_balances(initial_balances).execute_with(|| {
-        let init_value = SubtensorModule::get_max_childkey_take();
-        log::error!("Storage value: {:?}", init_value);
-
-        SubtensorModule::set_max_childkey_take(1000);
-
-        // let mut final_key = [0u8; 32];
-        // final_key[16..].copy_from_slice(twox_128(b"Subtensor"));
-        // final_key[..16].copy_from_slice(twox_128(b"MaxChildkeyTake"));
-        let final_key = [twox_128(b"SubtensorModule"), twox_128(b"MaxChildkeyTake")].concat();
-        log::error!("Storage value: {:?}", final_key);
-
-        let hash_key = MaxChildkeyTake::<Test>::hashed_key();
-        log::error!("Storage value: {:?}", hash_key);
-        // let key = [
-        //     101, 143, 170, 56, 80, 112, 224, 116, 200, 91, 246, 181, 104, 207, 5, 85, 219, 160, 24,
-        //     133, 156, 171, 126, 152, 159, 119, 102, 148, 87, 179, 148, 190,
-        // ];
-        let value = sp_io::storage::get(&final_key[..]);
-        log::error!("Storage value: {:?}", value);
-        assert_eq!(value, None);
-
-        sp_io::storage::set(&final_key[..], &[0u8; 32][..]);
-        let init_value = SubtensorModule::get_max_childkey_take();
-        log::error!("Storage value: {:?}", init_value);
-    });
-}
diff --git a/precompiles/src/storage_query.rs b/precompiles/src/storage_query.rs
index 3534b2b739..b29219b033 100644
--- a/precompiles/src/storage_query.rs
+++ b/precompiles/src/storage_query.rs
@@ -35,25 +35,12 @@ where
     <<R as frame_system::Config>::Lookup as StaticLookup>::Source: From<R::AccountId>,
 {
     fn execute(handle: &mut impl PrecompileHandle) -> fp_evm::PrecompileResult {
-        log::error!("StorageQueryPrecompile::execute {} {}", file!(), line!());
-
         let input = handle.input();
         let data = sp_io::storage::get(&input[..]);
-        log::error!(
-            "============================= StorageQueryPrecompile::execute {:?} {:?}",
-            input,
-            data
-        );
-
-        log::error!("StorageQueryPrecompile::execute {} {}", file!(), line!());
 
         match data {
             Some(value) => {
                 let result = value.to_vec();
-                log::error!(
-                    "============================= StorageQueryPrecompile::execute  {:?}",
-                    result
-                );
 
                 Ok(PrecompileOutput {
                     exit_status: ExitSucceed::Returned,

From 1f9fbb1d322b0a30fece3e2883136669fd7a8a2b Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Sat, 17 May 2025 21:27:43 +0800
Subject: [PATCH 165/418] clean up code

---
 evm-tests/src/subtensor.ts | 2 --
 precompiles/src/lib.rs     | 1 -
 2 files changed, 3 deletions(-)

diff --git a/evm-tests/src/subtensor.ts b/evm-tests/src/subtensor.ts
index dd5161933a..e3d5526268 100644
--- a/evm-tests/src/subtensor.ts
+++ b/evm-tests/src/subtensor.ts
@@ -345,8 +345,6 @@ export async function startCall(api: TypedApi<typeof devnet>, netuid: number, ke
     assert.notEqual(callStarted, undefined);
 }
 
-// sudo_set_max_childkey_take
-
 export async function setMaxChildkeyTake(api: TypedApi<typeof devnet>, take: number) {
     const alice = getAliceSigner()
     const internalCall = api.tx.SubtensorModule.sudo_set_max_childkey_take({ take })
diff --git a/precompiles/src/lib.rs b/precompiles/src/lib.rs
index 2b7e720f08..3bdf417d8d 100644
--- a/precompiles/src/lib.rs
+++ b/precompiles/src/lib.rs
@@ -175,7 +175,6 @@ where
                 UidLookupPrecompile::<R>::try_execute::<R>(handle, PrecompileEnum::UidLookup)
             }
             a if a == hash(StorageQueryPrecompile::<R>::INDEX) => {
-                log::error!("StorageQueryPrecompile::execute {} {}", file!(), line!());
                 Some(StorageQueryPrecompile::<R>::execute(handle))
             }
             _ => None,

From 919c9e03273482b3ec7f39ec9420faa67146531b Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Sat, 17 May 2025 21:29:58 +0800
Subject: [PATCH 166/418] remove contract definition

---
 precompiles/src/solidity/runtimeCallQuery.abi | 34 -------------------
 precompiles/src/solidity/runtimeCallQuery.sol | 14 --------
 2 files changed, 48 deletions(-)
 delete mode 100644 precompiles/src/solidity/runtimeCallQuery.abi
 delete mode 100644 precompiles/src/solidity/runtimeCallQuery.sol

diff --git a/precompiles/src/solidity/runtimeCallQuery.abi b/precompiles/src/solidity/runtimeCallQuery.abi
deleted file mode 100644
index ad33075ffc..0000000000
--- a/precompiles/src/solidity/runtimeCallQuery.abi
+++ /dev/null
@@ -1,34 +0,0 @@
-[
-    {
-        "inputs": [
-            {
-                "internalType": "bytes",
-                "name": "call",
-                "type": "bytes"
-            }
-        ],
-        "name": "call",
-        "outputs": [],
-        "stateMutability": "payable",
-        "type": "function"
-    },
-    {
-        "inputs": [
-            {
-                "internalType": "bytes",
-                "name": "key",
-                "type": "bytes"
-            }
-        ],
-        "name": "query",
-        "outputs": [
-            {
-                "internalType": "bytes",
-                "name": "result",
-                "type": "bytes"
-            }
-        ],
-        "stateMutability": "view",
-        "type": "function"
-    }
-]
\ No newline at end of file
diff --git a/precompiles/src/solidity/runtimeCallQuery.sol b/precompiles/src/solidity/runtimeCallQuery.sol
deleted file mode 100644
index 8ae03d1e17..0000000000
--- a/precompiles/src/solidity/runtimeCallQuery.sol
+++ /dev/null
@@ -1,14 +0,0 @@
-pragma solidity ^0.8.0;
-
-address constant IUID_LOOKUP_ADDRESS = 0x0000000000000000000000000000000000000807;
-
-interface IRuntimeCallQuery {
-    function call(
-        bytes memory call,
-    ) external payable;
-
-    function query(
-        bytes memory key,
-    ) external view returns (bytes memory result);
-}
-

From b855e7de4fd0fd2209b77c39c567a8404ad68ff1 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Sat, 17 May 2025 21:31:57 +0800
Subject: [PATCH 167/418] format code

---
 precompiles/src/uid_lookup.rs | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/precompiles/src/uid_lookup.rs b/precompiles/src/uid_lookup.rs
index 3c14e9438f..0a330566d8 100644
--- a/precompiles/src/uid_lookup.rs
+++ b/precompiles/src/uid_lookup.rs
@@ -1,13 +1,10 @@
-use core::marker::PhantomData;
-
 use crate::PrecompileExt;
+use core::marker::PhantomData;
 use frame_support::dispatch::{GetDispatchInfo, PostDispatchInfo};
 use pallet_evm::PrecompileHandle;
-
 use precompile_utils::{EvmResult, prelude::Address};
 use sp_runtime::traits::{Dispatchable, StaticLookup};
 use sp_std::vec::Vec;
-
 pub(crate) struct UidLookupPrecompile<R>(PhantomData<R>);
 
 impl<R> PrecompileExt<R::AccountId> for UidLookupPrecompile<R>

From 00d7ca7b327923f7ee8c75f4bef10d0bd31fc916 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Sat, 17 May 2025 21:33:19 +0800
Subject: [PATCH 168/418] cargo clippy

---
 precompiles/src/storage_query.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/precompiles/src/storage_query.rs b/precompiles/src/storage_query.rs
index b29219b033..b9455ae708 100644
--- a/precompiles/src/storage_query.rs
+++ b/precompiles/src/storage_query.rs
@@ -36,7 +36,7 @@ where
 {
     fn execute(handle: &mut impl PrecompileHandle) -> fp_evm::PrecompileResult {
         let input = handle.input();
-        let data = sp_io::storage::get(&input[..]);
+        let data = sp_io::storage::get(input);
 
         match data {
             Some(value) => {

From 7094c4f35d03692e56c762b8701949339703402e Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Sat, 17 May 2025 22:01:50 +0800
Subject: [PATCH 169/418] not include the descriptos

---
 evm-tests/package.json | 1 -
 1 file changed, 1 deletion(-)

diff --git a/evm-tests/package.json b/evm-tests/package.json
index ca35fe2d1b..0e90cdb976 100644
--- a/evm-tests/package.json
+++ b/evm-tests/package.json
@@ -6,7 +6,6 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@polkadot-api/descriptors": "file:.papi/descriptors",
     "@polkadot-labs/hdkd": "^0.0.10",
     "@polkadot-labs/hdkd-helpers": "^0.0.11",
     "@polkadot/api": "15.1.1",

From 6b53c5fba63fe471a9cf6030ce10e69012dd2785 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Sat, 17 May 2025 22:03:13 +0800
Subject: [PATCH 170/418] revert lock file

---
 evm-tests/package-lock.json | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/evm-tests/package-lock.json b/evm-tests/package-lock.json
index 68fae940bf..ce2766fb4e 100644
--- a/evm-tests/package-lock.json
+++ b/evm-tests/package-lock.json
@@ -6,7 +6,6 @@
     "": {
       "license": "ISC",
       "dependencies": {
-        "@polkadot-api/descriptors": "file:.papi/descriptors",
         "@polkadot-labs/hdkd": "^0.0.10",
         "@polkadot-labs/hdkd-helpers": "^0.0.11",
         "@polkadot/api": "15.1.1",
@@ -33,6 +32,7 @@
     ".papi/descriptors": {
       "name": "@polkadot-api/descriptors",
       "version": "0.1.0-autogenerated.7914363913476982777",
+      "extraneous": true,
       "peerDependencies": {
         "polkadot-api": "*"
       }
@@ -731,10 +731,6 @@
         "@polkadot-api/utils": "0.1.2"
       }
     },
-    "node_modules/@polkadot-api/descriptors": {
-      "resolved": ".papi/descriptors",
-      "link": true
-    },
     "node_modules/@polkadot-api/ink-contracts": {
       "version": "0.2.6",
       "resolved": "https://registry.npmjs.org/@polkadot-api/ink-contracts/-/ink-contracts-0.2.6.tgz",

From 227220b8f7c7688798ef782ee1f40e57f56c45c7 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Sat, 17 May 2025 22:14:22 +0800
Subject: [PATCH 171/418] revert unnecessary change

---
 pallets/subtensor/src/tests/batch_tx.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/pallets/subtensor/src/tests/batch_tx.rs b/pallets/subtensor/src/tests/batch_tx.rs
index 8c2e3a42ad..512fa9b368 100644
--- a/pallets/subtensor/src/tests/batch_tx.rs
+++ b/pallets/subtensor/src/tests/batch_tx.rs
@@ -2,6 +2,7 @@ use super::mock::*;
 use frame_support::{assert_ok, traits::Currency};
 use frame_system::Config;
 use sp_core::U256;
+
 // SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor --lib -- tests::batch_tx::test_batch_txs --exact --show-output --nocapture
 #[test]
 fn test_batch_txs() {

From a6154824f46adfd9c9ed0c777feeef76f405f789 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Sat, 17 May 2025 22:15:36 +0800
Subject: [PATCH 172/418] revert unnecessary change

---
 precompiles/src/uid_lookup.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/precompiles/src/uid_lookup.rs b/precompiles/src/uid_lookup.rs
index 0a330566d8..61fb9d6d7f 100644
--- a/precompiles/src/uid_lookup.rs
+++ b/precompiles/src/uid_lookup.rs
@@ -1,10 +1,13 @@
-use crate::PrecompileExt;
 use core::marker::PhantomData;
+
 use frame_support::dispatch::{GetDispatchInfo, PostDispatchInfo};
 use pallet_evm::PrecompileHandle;
 use precompile_utils::{EvmResult, prelude::Address};
 use sp_runtime::traits::{Dispatchable, StaticLookup};
 use sp_std::vec::Vec;
+
+use crate::PrecompileExt;
+
 pub(crate) struct UidLookupPrecompile<R>(PhantomData<R>);
 
 impl<R> PrecompileExt<R::AccountId> for UidLookupPrecompile<R>

From dd8d8ab340e87d6ba3445bd35a86e95b40ca0f0a Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Sat, 17 May 2025 22:26:17 +0800
Subject: [PATCH 173/418] cargo fix

---
 precompiles/Cargo.toml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/precompiles/Cargo.toml b/precompiles/Cargo.toml
index 91f3955a8d..f19e8f2d1e 100644
--- a/precompiles/Cargo.toml
+++ b/precompiles/Cargo.toml
@@ -46,6 +46,7 @@ std = [
 	"log/std",
 	"pallet-admin-utils/std",
 	"pallet-balances/std",
+	"pallet-evm-precompile-dispatch/std",
 	"pallet-evm-precompile-modexp/std",
 	"pallet-evm-precompile-sha3fips/std",
 	"pallet-evm-precompile-simple/std",

From cf56ee2f8118b8ceb1ef50344b76e68199e5dd79 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Sun, 18 May 2025 21:08:06 +0800
Subject: [PATCH 174/418] use hash function to get the key

---
 evm-tests/test/runtime.call.precompile.test.ts | 16 ++++++++++------
 1 file changed, 10 insertions(+), 6 deletions(-)

diff --git a/evm-tests/test/runtime.call.precompile.test.ts b/evm-tests/test/runtime.call.precompile.test.ts
index e1da4a0b57..135900808b 100644
--- a/evm-tests/test/runtime.call.precompile.test.ts
+++ b/evm-tests/test/runtime.call.precompile.test.ts
@@ -7,6 +7,8 @@ import { hexToNumber, PublicClient } from "viem";
 import { PolkadotSigner, TypedApi } from "polkadot-api";
 import { convertPublicKeyToSs58 } from "../src/address-utils"
 import { forceSetBalanceToEthAddress, setMaxChildkeyTake } from "../src/subtensor";
+import { xxhashAsU8a } from '@polkadot/util-crypto';
+import { u8aToHex } from '@polkadot/util';
 
 describe("Test the dispatch precompile", () => {
     let publicClient: PublicClient;
@@ -38,20 +40,22 @@ describe("Test the dispatch precompile", () => {
         assert.equal(aliceBalance + transferAmount, aliceBalanceAfterTransfer)
     })
 
-    
 
     it("Storage query call via precompile contract works correctly", async () => {
+        const palletPrefixBytes = xxhashAsU8a("SubtensorModule", 128);
+        const storageItemPrefixBytes = xxhashAsU8a("MaxChildkeyTake", 128);
+        const fullStorageKeyBytes = new Uint8Array([...palletPrefixBytes, ...storageItemPrefixBytes]);
+        // 0x658faa385070e074c85bf6b568cf0555dba018859cab7e989f77669457b394be
+        // key for max child key take
+        const fullStorageKeyHex = u8aToHex(fullStorageKeyBytes);
+
         let maxChildkeyTake = 257;
         await setMaxChildkeyTake(api, maxChildkeyTake)
-        // 0x658faa385070e074c85bf6b568cf0555f14f14d903e9994045ff1902b3e513dc
-        // key for min child key take
-
-        const storageQuery = "0x658faa385070e074c85bf6b568cf0555dba018859cab7e989f77669457b394be"
 
         api.query.SubtensorModule.MaxChildkeyTake.getValue();
         const rawCallResponse = await publicClient.call({
             to: ISTORAGE_QUERY_ADDRESS,
-            data: storageQuery,
+            data: fullStorageKeyHex,
         })
         const rawResultData = rawCallResponse.data;
         if (rawResultData === undefined) {

From 7904b1014218439a1749554ee994d257e1814f42 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Sun, 18 May 2025 21:43:44 +0800
Subject: [PATCH 175/418] add generate call data process

---
 evm-tests/test/runtime.call.precompile.test.ts | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/evm-tests/test/runtime.call.precompile.test.ts b/evm-tests/test/runtime.call.precompile.test.ts
index 135900808b..4cd7690724 100644
--- a/evm-tests/test/runtime.call.precompile.test.ts
+++ b/evm-tests/test/runtime.call.precompile.test.ts
@@ -2,7 +2,7 @@ import * as assert from "assert";
 import { getAliceSigner, getDevnetApi } from "../src/substrate"
 import {  generateRandomEthersWallet, getPublicClient } from "../src/utils";
 import { IDISPATCH_ADDRESS, ISTORAGE_QUERY_ADDRESS, ETH_LOCAL_URL } from "../src/config";
-import { devnet } from "@polkadot-api/descriptors"
+import { devnet, MultiAddress } from "@polkadot-api/descriptors"
 import { hexToNumber, PublicClient } from "viem";
 import { PolkadotSigner, TypedApi } from "polkadot-api";
 import { convertPublicKeyToSs58 } from "../src/address-utils"
@@ -24,10 +24,18 @@ describe("Test the dispatch precompile", () => {
     })
 
     it("Dispatch transfer call via precompile contract works correctly", async () => {
-        // 0x050300d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d02286bee
         // call for transfer 1 token to alice
         const transferAmount = BigInt(1000000000);
-        const transferCall = "0x050300d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d02286bee"
+
+        const unsignedTx = api.tx.Balances.transfer_keep_alive({
+            dest: MultiAddress.Id(convertPublicKeyToSs58(alice.publicKey)),
+            value: transferAmount,
+        });
+        const encodedCallDataBytes = await unsignedTx.getEncodedData();
+
+        // encoded call should be 0x050300d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d02286bee
+        const transferCall = encodedCallDataBytes.asHex()
+
         const aliceBalance =  (await api.query.System.Account.getValue( convertPublicKeyToSs58(alice.publicKey))).data.free
         const txResponse = await wallet1.sendTransaction({
             to: IDISPATCH_ADDRESS,

From 3dc0eb9a10ccd0de10f260d30c485d52e9a06d15 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Mon, 19 May 2025 19:13:31 +0200
Subject: [PATCH 176/418] Replace arithmetic operations with non-panicking api

---
 pallets/swap/src/pallet/impls.rs |  42 +++---
 pallets/swap/src/tick.rs         | 248 +++++++++++++++++++++----------
 2 files changed, 191 insertions(+), 99 deletions(-)

diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index b722872269..70c0516288 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -1,4 +1,5 @@
 use core::marker::PhantomData;
+use core::ops::Neg;
 
 use frame_support::storage::{TransactionOutcome, transactional};
 use frame_support::{ensure, pallet_prelude::DispatchError, traits::Get};
@@ -776,7 +777,7 @@ impl<T: Config> Pallet<T> {
             netuid,
             position.tick_low,
             position.tick_high,
-            -(position.liquidity as i128),
+            (position.liquidity as i128).neg(),
         );
 
         // Remove user position
@@ -820,7 +821,7 @@ impl<T: Config> Pallet<T> {
             liquidity_delta.abs() >= T::MinimumLiquidity::get() as i64,
             Error::<T>::InvalidLiquidityValue
         );
-        let mut delta_liquidity_abs = liquidity_delta.abs() as u64;
+        let mut delta_liquidity_abs = liquidity_delta.unsigned_abs();
 
         // Determine the effective price for token calculations
         let current_price = AlphaSqrtPrice::<T>::get(netuid);
@@ -922,7 +923,7 @@ impl<T: Config> Pallet<T> {
     fn add_liquidity_at_index(netuid: NetUid, tick_index: TickIndex, liquidity: u64, upper: bool) {
         // Convert liquidity to signed value, negating it for upper bounds
         let net_liquidity_change = if upper {
-            -(liquidity as i128)
+            (liquidity as i128).neg()
         } else {
             liquidity as i128
         };
@@ -955,7 +956,7 @@ impl<T: Config> Pallet<T> {
     ) {
         // Calculate net liquidity addition
         let net_reduction = if upper {
-            -(liquidity as i128)
+            (liquidity as i128).neg()
         } else {
             liquidity as i128
         };
@@ -1005,7 +1006,7 @@ impl<T: Config> Pallet<T> {
     /// Clamps the subnet's sqrt price when tick index is outside of valid bounds
     fn clamp_sqrt_price(netuid: NetUid, tick_index: TickIndex) {
         if tick_index >= TickIndex::MAX || tick_index <= TickIndex::MIN {
-            let corrected_price = tick_index.to_sqrt_price_bounded();
+            let corrected_price = tick_index.as_sqrt_price_bounded();
             AlphaSqrtPrice::<T>::set(netuid, corrected_price);
         }
     }
@@ -1360,7 +1361,7 @@ mod tests {
                     );
 
                     let position =
-                        Positions::<Test>::get(&(netuid, OK_COLDKEY_ACCOUNT_ID, position_id))
+                        Positions::<Test>::get((netuid, OK_COLDKEY_ACCOUNT_ID, position_id))
                             .unwrap();
                     assert_eq!(position.liquidity, liquidity);
                     assert_eq!(position.tick_low, tick_low);
@@ -1670,7 +1671,7 @@ mod tests {
                     &OK_COLDKEY_ACCOUNT_ID,
                     &OK_HOTKEY_ACCOUNT_ID,
                     position_id,
-                    -1_i64 * ((liquidity / 10) as i64),
+                    -((liquidity / 10) as i64),
                 )
                 .unwrap();
                 assert_abs_diff_eq!(modify_result.alpha, alpha / 10, epsilon = alpha / 1000);
@@ -1688,7 +1689,7 @@ mod tests {
 
                 // Position liquidity is reduced
                 let position =
-                    Positions::<Test>::get(&(netuid, OK_COLDKEY_ACCOUNT_ID, position_id)).unwrap();
+                    Positions::<Test>::get((netuid, OK_COLDKEY_ACCOUNT_ID, position_id)).unwrap();
                 assert_eq!(position.liquidity, liquidity * 9 / 10);
                 assert_eq!(position.tick_low, tick_low);
                 assert_eq!(position.tick_high, tick_high);
@@ -1699,7 +1700,7 @@ mod tests {
                     &OK_COLDKEY_ACCOUNT_ID,
                     &OK_HOTKEY_ACCOUNT_ID,
                     position_id,
-                    -1_i64 * ((liquidity / 100) as i64),
+                    -((liquidity / 100) as i64),
                 )
                 .unwrap();
 
@@ -2080,9 +2081,8 @@ mod tests {
 
                         // Expected fee amount
                         let fee_rate = FeeRate::<Test>::get(netuid) as f64 / u16::MAX as f64;
-                        let expected_fee = (order_liquidity as f64
-                            - order_liquidity as f64 / (1.0 + fee_rate))
-                            as u64;
+                        let expected_fee =
+                            (order_liquidity - order_liquidity / (1.0 + fee_rate)) as u64;
 
                         // Global fees should be updated
                         let actual_global_fee = ((match order_type {
@@ -2336,7 +2336,7 @@ mod tests {
             // Setup swap
             assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
 
-            let current_price = SqrtPrice::from_num(0.50000051219212275465);
+            let current_price = SqrtPrice::from_num(0.500_000_512_192_122_7);
             let tick = TickIndex::try_from_sqrt_price(current_price).unwrap();
 
             let round_trip_price = TickIndex::try_to_sqrt_price(&tick).unwrap();
@@ -2364,34 +2364,34 @@ mod tests {
                     3000000000000,
                 ),
                 (
-                    TickIndex::MIN.to_sqrt_price_bounded(),
+                    TickIndex::MIN.as_sqrt_price_bounded(),
                     1,
                     18406523739291577836,
                     465,
                 ),
-                (TickIndex::MIN.to_sqrt_price_bounded(), 10000, u64::MAX, 465),
+                (TickIndex::MIN.as_sqrt_price_bounded(), 10000, u64::MAX, 465),
                 (
-                    TickIndex::MIN.to_sqrt_price_bounded(),
+                    TickIndex::MIN.as_sqrt_price_bounded(),
                     1000000,
                     u64::MAX,
                     465,
                 ),
                 (
-                    TickIndex::MIN.to_sqrt_price_bounded(),
+                    TickIndex::MIN.as_sqrt_price_bounded(),
                     u64::MAX,
                     u64::MAX,
                     464,
                 ),
                 (
-                    TickIndex::MAX.to_sqrt_price_bounded(),
+                    TickIndex::MAX.as_sqrt_price_bounded(),
                     1,
                     0,
                     18406523745214495085,
                 ),
-                (TickIndex::MAX.to_sqrt_price_bounded(), 10000, 0, u64::MAX),
-                (TickIndex::MAX.to_sqrt_price_bounded(), 1000000, 0, u64::MAX),
+                (TickIndex::MAX.as_sqrt_price_bounded(), 10000, 0, u64::MAX),
+                (TickIndex::MAX.as_sqrt_price_bounded(), 1000000, 0, u64::MAX),
                 (
-                    TickIndex::MAX.to_sqrt_price_bounded(),
+                    TickIndex::MAX.as_sqrt_price_bounded(),
                     u64::MAX,
                     2000000000000,
                     u64::MAX,
diff --git a/pallets/swap/src/tick.rs b/pallets/swap/src/tick.rs
index a3be3a5b3b..5d85fe1b6e 100644
--- a/pallets/swap/src/tick.rs
+++ b/pallets/swap/src/tick.rs
@@ -1,4 +1,5 @@
 //! The math is adapted from github.com/0xKitsune/uniswap-v3-math
+use core::cmp::Ordering;
 use core::convert::TryFrom;
 use core::error::Error;
 use core::fmt;
@@ -114,6 +115,7 @@ pub struct TickIndex(i32);
 impl Add<TickIndex> for TickIndex {
     type Output = Self;
 
+    #[allow(clippy::arithmetic_side_effects)]
     fn add(self, rhs: Self) -> Self::Output {
         // Note: This assumes the result is within bounds.
         // For a safer implementation, consider using checked_add.
@@ -124,6 +126,7 @@ impl Add<TickIndex> for TickIndex {
 impl Sub<TickIndex> for TickIndex {
     type Output = Self;
 
+    #[allow(clippy::arithmetic_side_effects)]
     fn sub(self, rhs: Self) -> Self::Output {
         // Note: This assumes the result is within bounds.
         // For a safer implementation, consider using checked_sub.
@@ -132,12 +135,14 @@ impl Sub<TickIndex> for TickIndex {
 }
 
 impl AddAssign<TickIndex> for TickIndex {
+    #[allow(clippy::arithmetic_side_effects)]
     fn add_assign(&mut self, rhs: Self) {
         *self = Self::new_unchecked(self.get() + rhs.get());
     }
 }
 
 impl SubAssign<TickIndex> for TickIndex {
+    #[allow(clippy::arithmetic_side_effects)]
     fn sub_assign(&mut self, rhs: Self) {
         *self = Self::new_unchecked(self.get() - rhs.get());
     }
@@ -178,12 +183,12 @@ impl TickIndex {
     /// Minimum value of the tick index
     /// The tick_math library uses different bitness, so we have to divide by 2.
     /// It's unsafe to change this value to something else.
-    pub const MIN: Self = Self(MIN_TICK / 2);
+    pub const MIN: Self = Self(MIN_TICK.saturating_div(2));
 
     /// Maximum value of the tick index
     /// The tick_math library uses different bitness, so we have to divide by 2.
     /// It's unsafe to change this value to something else.
-    pub const MAX: Self = Self(MAX_TICK / 2);
+    pub const MAX: Self = Self(MAX_TICK.saturating_div(2));
 
     /// All tick indexes are offset by this value for storage needs
     /// so that tick indexes are positive, which simplifies bit logic
@@ -195,6 +200,7 @@ impl TickIndex {
     }
 
     /// The MAX sqrt price, which is calculated at Self::MAX
+    #[allow(clippy::excessive_precision)]
     pub fn max_sqrt_price() -> SqrtPrice {
         SqrtPrice::saturating_from_num(4294886577.20989222513899790805)
     }
@@ -272,7 +278,7 @@ impl TickIndex {
         match Self::try_from_sqrt_price(sqrt_price) {
             Ok(index) => index,
             Err(_) => {
-                let max_price = Self::MAX.to_sqrt_price_bounded();
+                let max_price = Self::MAX.as_sqrt_price_bounded();
 
                 if sqrt_price > max_price {
                     Self::MAX
@@ -290,7 +296,7 @@ impl TickIndex {
     ///
     /// # Returns
     /// * `SqrtPrice` - A sqrt price that is guaranteed to be a valid value
-    pub fn to_sqrt_price_bounded(&self) -> SqrtPrice {
+    pub fn as_sqrt_price_bounded(&self) -> SqrtPrice {
         self.try_to_sqrt_price().unwrap_or_else(|_| {
             if *self >= Self::MAX {
                 Self::max_sqrt_price()
@@ -328,28 +334,29 @@ impl TickIndex {
     /// # Returns
     /// * `Result<TickIndex, TickMathError>` - The corresponding TickIndex if within valid bounds
     pub fn from_offset_index(offset_index: u32) -> Result<Self, TickMathError> {
-        let signed_index = (offset_index as i64 - Self::OFFSET.get() as i64) as i32;
+        // while it's safe, we use saturating math to mute the linter and just in case
+        let signed_index = ((offset_index as i64).saturating_sub(Self::OFFSET.get() as i64)) as i32;
         Self::new(signed_index)
     }
 
     /// Get the next tick index (incrementing by 1)
     pub fn next(&self) -> Result<Self, TickMathError> {
-        Self::new(self.0 + 1)
+        Self::new(self.0.saturating_add(1))
     }
 
     /// Get the previous tick index (decrementing by 1)
     pub fn prev(&self) -> Result<Self, TickMathError> {
-        Self::new(self.0 - 1)
+        Self::new(self.0.saturating_sub(1))
     }
 
     /// Add a value to this tick index with bounds checking
     pub fn checked_add(&self, value: i32) -> Result<Self, TickMathError> {
-        Self::new(self.0 + value)
+        Self::new(self.0.saturating_add(value))
     }
 
     /// Subtract a value from this tick index with bounds checking
     pub fn checked_sub(&self, value: i32) -> Result<Self, TickMathError> {
-        Self::new(self.0 - value)
+        Self::new(self.0.saturating_sub(value))
     }
 
     /// Add a value to this tick index, saturating at the bounds instead of overflowing
@@ -381,11 +388,12 @@ impl TickIndex {
     }
 
     /// Divide the tick index by a value with bounds checking
+    #[allow(clippy::arithmetic_side_effects)]
     pub fn checked_div(&self, value: i32) -> Result<Self, TickMathError> {
         if value == 0 {
             return Err(TickMathError::DivisionByZero);
         }
-        Self::new(self.0 / value)
+        Self::new(self.0.saturating_div(value))
     }
 
     /// Divide the tick index by a value, saturating at the bounds
@@ -452,12 +460,12 @@ impl TickIndex {
         // post‑verification, *both* directions
         let price_at_tick = get_sqrt_ratio_at_tick(tick)?;
         if price_at_tick > price_x96 {
-            tick -= 1; // estimate was too high
+            tick = tick.saturating_sub(1); // estimate was too high
         } else {
             // it may still be one too low
-            let price_at_tick_plus = get_sqrt_ratio_at_tick(tick + 1)?;
+            let price_at_tick_plus = get_sqrt_ratio_at_tick(tick.saturating_add(1))?;
             if price_at_tick_plus <= price_x96 {
-                tick += 1; // step up when required
+                tick = tick.saturating_add(1); // step up when required
             }
         }
 
@@ -621,12 +629,10 @@ impl ActiveTickIndexManager {
             let word1_index = TickIndexBitmap::layer_to_index(BitmapLayer::new(0, *closest_bit_l0));
 
             // Layer 1 words are different, shift the bit to the word edge
-            let start_from_l1_bit = if word1_index < layer1_word {
-                127
-            } else if word1_index > layer1_word {
-                0
-            } else {
-                layer1_bit
+            let start_from_l1_bit = match word1_index.cmp(&layer1_word) {
+                Ordering::Less => 127,
+                Ordering::Greater => 0,
+                _ => layer1_bit,
             };
             let word1_value =
                 TickIndexBitmapWords::<T>::get((netuid, LayerLevel::Middle, word1_index));
@@ -643,12 +649,10 @@ impl ActiveTickIndexManager {
                     TickIndexBitmap::layer_to_index(BitmapLayer::new(word1_index, *closest_bit_l1));
 
                 // Layer 2 words are different, shift the bit to the word edge
-                let start_from_l2_bit = if word2_index < layer2_word {
-                    127
-                } else if word2_index > layer2_word {
-                    0
-                } else {
-                    layer2_bit
+                let start_from_l2_bit = match word2_index.cmp(&layer2_word) {
+                    Ordering::Less => 127,
+                    Ordering::Greater => 0,
+                    _ => layer2_bit,
                 };
 
                 let word2_value =
@@ -660,11 +664,13 @@ impl ActiveTickIndexManager {
                     lower,
                 );
 
-                if closest_bits_l2.len() > 0 {
+                if !closest_bits_l2.is_empty() {
                     // The active tick is found, restore its full index and return
                     let offset_found_index = TickIndexBitmap::layer_to_index(BitmapLayer::new(
                         word2_index,
-                        closest_bits_l2[0],
+                        // it's safe to unwrap, because the len is > 0, but to prevent errors in
+                        // refactoring, we use default fallback here for extra safety
+                        closest_bits_l2.first().copied().unwrap_or_default(),
                     ));
 
                     if lower {
@@ -830,6 +836,7 @@ impl From<TickIndex> for TickIndexBitmap {
     }
 }
 
+#[allow(clippy::arithmetic_side_effects)]
 fn get_sqrt_ratio_at_tick(tick: i32) -> Result<U256, TickMathError> {
     let abs_tick = if tick < 0 {
         U256::from(tick.neg())
@@ -848,80 +855,168 @@ fn get_sqrt_ratio_at_tick(tick: i32) -> Result<U256, TickMathError> {
     };
 
     if !(abs_tick & U256_2).is_zero() {
-        ratio = (ratio * U256::from_limbs([6459403834229662010, 18444899583751176498, 0, 0])) >> 128
+        ratio = (ratio.saturating_mul(U256::from_limbs([
+            6459403834229662010,
+            18444899583751176498,
+            0,
+            0,
+        ]))) >> 128
     }
     if !(abs_tick & U256_4).is_zero() {
-        ratio =
-            (ratio * U256::from_limbs([17226890335427755468, 18443055278223354162, 0, 0])) >> 128
+        ratio = (ratio.saturating_mul(U256::from_limbs([
+            17226890335427755468,
+            18443055278223354162,
+            0,
+            0,
+        ]))) >> 128
     }
     if !(abs_tick & U256_8).is_zero() {
-        ratio = (ratio * U256::from_limbs([2032852871939366096, 18439367220385604838, 0, 0])) >> 128
+        ratio = (ratio.saturating_mul(U256::from_limbs([
+            2032852871939366096,
+            18439367220385604838,
+            0,
+            0,
+        ]))) >> 128
     }
     if !(abs_tick & U256_16).is_zero() {
-        ratio =
-            (ratio * U256::from_limbs([14545316742740207172, 18431993317065449817, 0, 0])) >> 128
+        ratio = (ratio.saturating_mul(U256::from_limbs([
+            14545316742740207172,
+            18431993317065449817,
+            0,
+            0,
+        ]))) >> 128
     }
     if !(abs_tick & U256_32).is_zero() {
-        ratio = (ratio * U256::from_limbs([5129152022828963008, 18417254355718160513, 0, 0])) >> 128
+        ratio = (ratio.saturating_mul(U256::from_limbs([
+            5129152022828963008,
+            18417254355718160513,
+            0,
+            0,
+        ]))) >> 128
     }
     if !(abs_tick & U256_64).is_zero() {
-        ratio = (ratio * U256::from_limbs([4894419605888772193, 18387811781193591352, 0, 0])) >> 128
+        ratio = (ratio.saturating_mul(U256::from_limbs([
+            4894419605888772193,
+            18387811781193591352,
+            0,
+            0,
+        ]))) >> 128
     }
     if !(abs_tick & U256_128).is_zero() {
-        ratio = (ratio * U256::from_limbs([1280255884321894483, 18329067761203520168, 0, 0])) >> 128
+        ratio = (ratio.saturating_mul(U256::from_limbs([
+            1280255884321894483,
+            18329067761203520168,
+            0,
+            0,
+        ]))) >> 128
     }
     if !(abs_tick & U256_256).is_zero() {
-        ratio =
-            (ratio * U256::from_limbs([15924666964335305636, 18212142134806087854, 0, 0])) >> 128
+        ratio = (ratio.saturating_mul(U256::from_limbs([
+            15924666964335305636,
+            18212142134806087854,
+            0,
+            0,
+        ]))) >> 128
     }
     if !(abs_tick & U256_512).is_zero() {
-        ratio = (ratio * U256::from_limbs([8010504389359918676, 17980523815641551639, 0, 0])) >> 128
+        ratio = (ratio.saturating_mul(U256::from_limbs([
+            8010504389359918676,
+            17980523815641551639,
+            0,
+            0,
+        ]))) >> 128
     }
     if !(abs_tick & U256_1024).is_zero() {
-        ratio =
-            (ratio * U256::from_limbs([10668036004952895731, 17526086738831147013, 0, 0])) >> 128
+        ratio = (ratio.saturating_mul(U256::from_limbs([
+            10668036004952895731,
+            17526086738831147013,
+            0,
+            0,
+        ]))) >> 128
     }
     if !(abs_tick & U256_2048).is_zero() {
-        ratio = (ratio * U256::from_limbs([4878133418470705625, 16651378430235024244, 0, 0])) >> 128
+        ratio = (ratio.saturating_mul(U256::from_limbs([
+            4878133418470705625,
+            16651378430235024244,
+            0,
+            0,
+        ]))) >> 128
     }
     if !(abs_tick & U256_4096).is_zero() {
-        ratio = (ratio * U256::from_limbs([9537173718739605541, 15030750278693429944, 0, 0])) >> 128
+        ratio = (ratio.saturating_mul(U256::from_limbs([
+            9537173718739605541,
+            15030750278693429944,
+            0,
+            0,
+        ]))) >> 128
     }
     if !(abs_tick & U256_8192).is_zero() {
-        ratio = (ratio * U256::from_limbs([9972618978014552549, 12247334978882834399, 0, 0])) >> 128
+        ratio = (ratio.saturating_mul(U256::from_limbs([
+            9972618978014552549,
+            12247334978882834399,
+            0,
+            0,
+        ]))) >> 128
     }
     if !(abs_tick & U256_16384).is_zero() {
-        ratio = (ratio * U256::from_limbs([10428997489610666743, 8131365268884726200, 0, 0])) >> 128
+        ratio = (ratio.saturating_mul(U256::from_limbs([
+            10428997489610666743,
+            8131365268884726200,
+            0,
+            0,
+        ]))) >> 128
     }
     if !(abs_tick & U256_32768).is_zero() {
-        ratio = (ratio * U256::from_limbs([9305304367709015974, 3584323654723342297, 0, 0])) >> 128
+        ratio = (ratio.saturating_mul(U256::from_limbs([
+            9305304367709015974,
+            3584323654723342297,
+            0,
+            0,
+        ]))) >> 128
     }
     if !(abs_tick & U256_65536).is_zero() {
-        ratio = (ratio * U256::from_limbs([14301143598189091785, 696457651847595233, 0, 0])) >> 128
+        ratio = (ratio.saturating_mul(U256::from_limbs([
+            14301143598189091785,
+            696457651847595233,
+            0,
+            0,
+        ]))) >> 128
     }
     if !(abs_tick & U256_131072).is_zero() {
-        ratio = (ratio * U256::from_limbs([7393154844743099908, 26294789957452057, 0, 0])) >> 128
+        ratio = (ratio.saturating_mul(U256::from_limbs([
+            7393154844743099908,
+            26294789957452057,
+            0,
+            0,
+        ]))) >> 128
     }
     if !(abs_tick & U256_262144).is_zero() {
-        ratio = (ratio * U256::from_limbs([2209338891292245656, 37481735321082, 0, 0])) >> 128
+        ratio = (ratio.saturating_mul(U256::from_limbs([
+            2209338891292245656,
+            37481735321082,
+            0,
+            0,
+        ]))) >> 128
     }
     if !(abs_tick & U256_524288).is_zero() {
-        ratio = (ratio * U256::from_limbs([10518117631919034274, 76158723, 0, 0])) >> 128
+        ratio =
+            (ratio.saturating_mul(U256::from_limbs([10518117631919034274, 76158723, 0, 0]))) >> 128
     }
 
     if tick > 0 {
         ratio = U256::MAX / ratio;
     }
 
-    let shifted = ratio >> 32;
+    let shifted: U256 = ratio >> 32;
     let ceil = if ratio & U256::from((1u128 << 32) - 1) != U256::ZERO {
-        shifted + U256_1
+        shifted.saturating_add(U256_1)
     } else {
         shifted
     };
     Ok(ceil)
 }
 
+#[allow(clippy::arithmetic_side_effects)]
 fn get_tick_at_sqrt_ratio(sqrt_price_x_96: U256) -> Result<i32, TickMathError> {
     if !(sqrt_price_x_96 >= MIN_SQRT_RATIO && sqrt_price_x_96 < MAX_SQRT_RATIO) {
         return Err(TickMathError::SqrtPriceOutOfBounds);
@@ -992,12 +1087,13 @@ fn get_tick_at_sqrt_ratio(sqrt_price_x_96: U256) -> Result<i32, TickMathError> {
     msb = msb.bitor(f);
 
     r = if msb >= U256_128 {
-        ratio.shr(msb - U256_127)
+        ratio.shr(msb.saturating_sub(U256_127))
     } else {
-        ratio.shl(U256_127 - msb)
+        ratio.shl(U256_127.saturating_sub(msb))
     };
 
-    let mut log_2: I256 = (I256::from_raw(msb) - I256::from_limbs([128, 0, 0, 0])).shl(64);
+    let mut log_2: I256 =
+        (I256::from_raw(msb).saturating_sub(I256::from_limbs([128, 0, 0, 0]))).shl(64);
 
     for i in (51..=63).rev() {
         r = r.overflowing_mul(r).0.shr(U256_127);
@@ -1013,9 +1109,9 @@ fn get_tick_at_sqrt_ratio(sqrt_price_x_96: U256) -> Result<i32, TickMathError> {
 
     let log_sqrt10001 = log_2.wrapping_mul(SQRT_10001);
 
-    let tick_low = ((log_sqrt10001 - TICK_LOW) >> 128_u8).low_i32();
+    let tick_low = (log_sqrt10001.saturating_sub(TICK_LOW) >> 128_u8).low_i32();
 
-    let tick_high = ((log_sqrt10001 + TICK_HIGH) >> 128_u8).low_i32();
+    let tick_high = (log_sqrt10001.saturating_add(TICK_HIGH) >> 128_u8).low_i32();
 
     let tick = if tick_low == tick_high {
         tick_low
@@ -1041,20 +1137,15 @@ fn u64f64_to_u256_q64_96(value: U64F64) -> U256 {
 ///
 /// # Returns
 /// * `U256` - Converted value
+#[allow(clippy::arithmetic_side_effects)]
 fn u64f64_to_u256(value: U64F64, target_fractional_bits: u32) -> U256 {
-    let mut bits = value.to_bits();
+    let raw = U256::from(value.to_bits());
 
-    // Adjust to target fractional bits
-    if target_fractional_bits < 64 {
-        // Shift right to remove excess fractional bits
-        bits = bits >> (64 - target_fractional_bits);
-    } else if target_fractional_bits > 64 {
-        // Shift left to add more fractional bits
-        bits = bits << (target_fractional_bits - 64);
+    match target_fractional_bits.cmp(&64) {
+        Ordering::Less => raw >> (64 - target_fractional_bits),
+        Ordering::Greater => raw.saturating_shl((target_fractional_bits - 64) as usize),
+        Ordering::Equal => raw,
     }
-
-    // Create U256
-    U256::from(bits)
 }
 
 /// Convert U256 in Q64.96 format (Uniswap's sqrt price format) to U64F64
@@ -1062,20 +1153,21 @@ fn u256_q64_96_to_u64f64(value: U256) -> Result<U64F64, TickMathError> {
     q_to_u64f64(value, 96)
 }
 
+#[allow(clippy::arithmetic_side_effects)]
 fn q_to_u64f64(x: U256, frac_bits: u32) -> Result<U64F64, TickMathError> {
-    let diff = frac_bits.checked_sub(64).unwrap_or(0);
+    let diff = frac_bits.saturating_sub(64) as usize;
 
     // 1. shift right diff bits
     let shifted = if diff != 0 { x >> diff } else { x };
 
     // 2. **round up** if we threw away any 1‑bits
     let mask = if diff != 0 {
-        (U256_1 << diff) - U256_1
+        (U256_1.saturating_shl(diff)).saturating_sub(U256_1)
     } else {
         U256::ZERO
     };
     let rounded = if diff != 0 && (x & mask) != U256::ZERO {
-        shifted + U256_1
+        shifted.saturating_add(U256_1)
     } else {
         shifted
     };
@@ -1310,13 +1402,13 @@ mod tests {
 
         assert!(
             TickIndex::MAX.try_to_sqrt_price().unwrap().abs_diff(
-                TickIndex::new_unchecked(TickIndex::MAX.get() + 1).to_sqrt_price_bounded()
+                TickIndex::new_unchecked(TickIndex::MAX.get() + 1).as_sqrt_price_bounded()
             ) < SqrtPrice::from_num(1e-6)
         );
 
         assert!(
             TickIndex::MIN.try_to_sqrt_price().unwrap().abs_diff(
-                TickIndex::new_unchecked(TickIndex::MIN.get() - 1).to_sqrt_price_bounded()
+                TickIndex::new_unchecked(TickIndex::MIN.get() - 1).as_sqrt_price_bounded()
             ) < SqrtPrice::from_num(1e-6)
         );
 
@@ -1353,7 +1445,7 @@ mod tests {
         let epsilon = SqrtPrice::from_num(0.0000000000000001);
         assert!(
             TickIndex::new_unchecked(2)
-                .to_sqrt_price_bounded()
+                .as_sqrt_price_bounded()
                 .abs_diff(tick_spacing)
                 < epsilon
         );
@@ -1362,7 +1454,7 @@ mod tests {
         let sqrt_price = tick_spacing * tick_spacing;
         assert!(
             TickIndex::new_unchecked(4)
-                .to_sqrt_price_bounded()
+                .as_sqrt_price_bounded()
                 .abs_diff(sqrt_price)
                 < epsilon
         );
@@ -1371,7 +1463,7 @@ mod tests {
         let sqrt_price = tick_spacing.checked_pow(5).unwrap();
         assert!(
             TickIndex::new_unchecked(10)
-                .to_sqrt_price_bounded()
+                .as_sqrt_price_bounded()
                 .abs_diff(sqrt_price)
                 < epsilon
         );
@@ -1458,12 +1550,12 @@ mod tests {
     #[test]
     fn test_to_sqrt_price_bounded() {
         assert_eq!(
-            TickIndex::MAX.to_sqrt_price_bounded(),
+            TickIndex::MAX.as_sqrt_price_bounded(),
             TickIndex::MAX.try_to_sqrt_price().unwrap()
         );
 
         assert_eq!(
-            TickIndex::MIN.to_sqrt_price_bounded(),
+            TickIndex::MIN.as_sqrt_price_bounded(),
             TickIndex::MIN.try_to_sqrt_price().unwrap()
         );
     }

From 324a31eb34b2a6f806f84af0d53e5d528889f86a Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Mon, 19 May 2025 16:24:00 -0400
Subject: [PATCH 177/418] Fix swap coldkey tests (swap v3)

---
 pallets/subtensor/src/tests/swap_coldkey.rs | 85 +++++++++------------
 1 file changed, 37 insertions(+), 48 deletions(-)

diff --git a/pallets/subtensor/src/tests/swap_coldkey.rs b/pallets/subtensor/src/tests/swap_coldkey.rs
index 5fb2bf0f59..538b3736ca 100644
--- a/pallets/subtensor/src/tests/swap_coldkey.rs
+++ b/pallets/subtensor/src/tests/swap_coldkey.rs
@@ -372,21 +372,29 @@ fn test_swap_with_max_values() {
         mock::setup_reserves(netuid2, reserve, reserve);
 
         // Stake to hotkey on each subnet.
-        let (_, fee) = mock::swap_tao_to_alpha(netuid2, max_stake);
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(old_coldkey),
             hotkey,
             netuid,
             max_stake
         ));
+        let expected_stake1 = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+            &hotkey,
+            &old_coldkey,
+            netuid
+        );
 
-        let (_, fee) = mock::swap_tao_to_alpha(netuid2, max_stake);
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(old_coldkey2),
             hotkey2,
             netuid2,
             max_stake
         ));
+        let expected_stake2 = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+            &hotkey2,
+            &old_coldkey2,
+            netuid2
+        );
 
         let mut weight = Weight::zero();
         assert_ok!(SubtensorModule::perform_swap_coldkey(
@@ -400,16 +408,14 @@ fn test_swap_with_max_values() {
             &mut weight
         ));
 
-        let expected_stake = max_stake - fee;
-
         assert_eq!(
             SubtensorModule::get_total_stake_for_coldkey(&old_coldkey),
             0
         );
         assert_abs_diff_eq!(
             SubtensorModule::get_total_stake_for_coldkey(&new_coldkey),
-            expected_stake,
-            epsilon = expected_stake / 1000
+            expected_stake1,
+            epsilon = expected_stake1 / 1000
         );
         assert_eq!(
             SubtensorModule::get_total_stake_for_coldkey(&old_coldkey2),
@@ -417,8 +423,8 @@ fn test_swap_with_max_values() {
         );
         assert_abs_diff_eq!(
             SubtensorModule::get_total_stake_for_coldkey(&new_coldkey2),
-            expected_stake,
-            epsilon = expected_stake / 1000
+            expected_stake2,
+            epsilon = expected_stake2 / 1000
         );
     });
 }
@@ -870,52 +876,45 @@ fn test_swap_stake_for_coldkey() {
         mock::setup_reserves(netuid, reserve, reserve);
 
         // Stake to hotkeys
-        let (expected_stake_alpha1, _) = mock::swap_tao_to_alpha(netuid, stake_amount1);
-
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(old_coldkey),
             hotkey1,
             netuid,
             stake_amount1
         ));
+        let expected_stake_alpha1 = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+            &hotkey1,
+            &old_coldkey,
+            netuid
+        );
 
-        let (expected_stake_alpha2, _) = mock::swap_tao_to_alpha(netuid, stake_amount2);
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(old_coldkey),
             hotkey2,
             netuid,
             stake_amount2
         ));
-
-        // Verify stakes
-        assert_eq!(
-            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
-                &hotkey1,
-                &old_coldkey,
-                netuid
-            ),
-            expected_stake_alpha1
-        );
-        assert_eq!(
-            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
-                &hotkey2,
-                &old_coldkey,
-                netuid
-            ),
-            expected_stake_alpha2
+        let expected_stake_alpha2 = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+            &hotkey2,
+            &old_coldkey,
+            netuid
         );
 
         // Insert existing for same hotkey1
         // give new coldkey some balance
         SubtensorModule::add_balance_to_coldkey_account(&new_coldkey, stake_amount3 + 1_000_000);
         // Stake to hotkey1
-        let (expected_stake_alpha3, _) = mock::swap_tao_to_alpha(netuid, stake_amount3);
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(new_coldkey),
             hotkey1,
             netuid,
             stake_amount3
         ));
+        let expected_stake_alpha3 = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+            &hotkey1,
+            &new_coldkey,
+            netuid
+        );
 
         // Record initial values
         let initial_total_issuance = SubtensorModule::get_total_issuance();
@@ -1031,38 +1030,28 @@ fn test_swap_staking_hotkeys_for_coldkey() {
         mock::setup_reserves(netuid, reserve, reserve);
 
         // Stake to hotkeys
-        let (expected_stake_alpha1, fee) = mock::swap_tao_to_alpha(netuid, stake_amount1);
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(old_coldkey),
             hotkey1,
             netuid,
             stake_amount1
         ));
+        let expected_stake_alpha1 = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+            &hotkey1,
+            &old_coldkey,
+            netuid
+        );
 
-        let (expected_stake_alpha2, fee) = mock::swap_tao_to_alpha(netuid, stake_amount2);
         assert_ok!(SubtensorModule::add_stake(
             <<Test as Config>::RuntimeOrigin>::signed(old_coldkey),
             hotkey2,
             netuid,
             stake_amount2
         ));
-
-        // Verify stakes
-        assert_eq!(
-            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
-                &hotkey1,
-                &old_coldkey,
-                netuid
-            ),
-            expected_stake_alpha1
-        );
-        assert_eq!(
-            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
-                &hotkey2,
-                &old_coldkey,
-                netuid
-            ),
-            expected_stake_alpha2
+        let expected_stake_alpha2 = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+            &hotkey2,
+            &old_coldkey,
+            netuid
         );
 
         // Perform the swap

From 02ed7f9336697cefab32f261c5fbe79256801fb8 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Mon, 19 May 2025 17:30:12 -0400
Subject: [PATCH 178/418] Fix weights tests (swap v3)

---
 pallets/subtensor/src/tests/weights.rs | 47 +++++++++++---------------
 1 file changed, 20 insertions(+), 27 deletions(-)

diff --git a/pallets/subtensor/src/tests/weights.rs b/pallets/subtensor/src/tests/weights.rs
index bb40c6645d..438b7ad0c2 100644
--- a/pallets/subtensor/src/tests/weights.rs
+++ b/pallets/subtensor/src/tests/weights.rs
@@ -211,17 +211,22 @@ fn test_commit_weights_validate() {
         let reserve = min_stake * 1000;
         mock::setup_reserves(netuid, reserve, reserve);
 
-        let (_, fee) = mock::swap_tao_to_alpha(netuid, min_stake);
+        // Stake some TAO and read what get_total_stake_for_hotkey it gets
+        // It will be a different value due to the slippage
+        assert_ok!(SubtensorModule::do_add_stake(
+            RuntimeOrigin::signed(hotkey),
+            hotkey,
+            netuid,
+            min_stake
+        ));
+        let min_stake_with_slippage = SubtensorModule::get_total_stake_for_hotkey(&hotkey);
 
-        // Set the minimum stake
-        SubtensorModule::set_stake_threshold(min_stake);
+        // Set the minimum stake above what hotkey has
+        SubtensorModule::set_stake_threshold(min_stake_with_slippage + 1);
 
-        // Verify stake is less than minimum
-        assert!(SubtensorModule::get_total_stake_for_hotkey(&hotkey) < min_stake);
+        // Submit to the signed extension validate function
         let info = crate::DispatchInfoOf::<<Test as frame_system::Config>::RuntimeCall>::default();
-
         let extension = crate::SubtensorSignedExtension::<Test>::new();
-        // Submit to the signed extension validate function
         let result_no_stake = extension.validate(&who, &call.clone(), &info, 10);
         // Should fail
         assert_err!(
@@ -230,19 +235,8 @@ fn test_commit_weights_validate() {
             crate::TransactionValidityError::Invalid(crate::InvalidTransaction::Custom(1))
         );
 
-        // Increase the stake to be equal to the minimum
-        assert_ok!(SubtensorModule::do_add_stake(
-            RuntimeOrigin::signed(hotkey),
-            hotkey,
-            netuid,
-            min_stake + fee
-        ));
-
-        // Verify stake is equal to minimum
-        assert_eq!(
-            SubtensorModule::get_total_stake_for_hotkey(&hotkey),
-            min_stake
-        );
+        // Set the minimum stake equal to what hotkey has
+        SubtensorModule::set_stake_threshold(min_stake_with_slippage);
 
         // Submit to the signed extension validate function
         let result_min_stake = extension.validate(&who, &call.clone(), &info, 10);
@@ -258,7 +252,7 @@ fn test_commit_weights_validate() {
         ));
 
         // Verify stake is more than minimum
-        assert!(SubtensorModule::get_total_stake_for_hotkey(&hotkey) > min_stake);
+        assert!(SubtensorModule::get_total_stake_for_hotkey(&hotkey) > min_stake_with_slippage);
 
         let result_more_stake = extension.validate(&who, &call.clone(), &info, 10);
         // The call should still pass
@@ -321,6 +315,7 @@ fn test_set_weights_validate() {
         SubtensorModule::add_balance_to_coldkey_account(&hotkey, u64::MAX);
 
         let min_stake = 500_000_000_000;
+
         // Set the minimum stake
         SubtensorModule::set_stake_threshold(min_stake);
 
@@ -340,7 +335,7 @@ fn test_set_weights_validate() {
             ))
         );
 
-        // Increase the stake to be equal to the minimum
+        // Increase the stake and make it to be equal to the minimum threshold
         let fee = <Test as pallet::Config>::SwapInterface::approx_fee_amount(netuid, min_stake);
         assert_ok!(SubtensorModule::do_add_stake(
             RuntimeOrigin::signed(hotkey),
@@ -348,12 +343,10 @@ fn test_set_weights_validate() {
             netuid,
             min_stake + fee
         ));
+        let min_stake_with_slippage = SubtensorModule::get_total_stake_for_hotkey(&hotkey);
 
-        // Verify stake is equal to minimum
-        assert_eq!(
-            SubtensorModule::get_total_stake_for_hotkey(&hotkey),
-            min_stake
-        );
+        // Set the minimum stake to what the hotkey has
+        SubtensorModule::set_stake_threshold(min_stake_with_slippage);
 
         // Submit to the signed extension validate function
         let result_min_stake = extension.validate(&who, &call.clone(), &info, 10);

From 9681d071893c8a9b8662c294fb3583123ca0615f Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Mon, 19 May 2025 17:30:25 -0400
Subject: [PATCH 179/418] Format

---
 pallets/admin-utils/src/tests/mock.rs         |  2 +-
 pallets/subtensor/src/lib.rs                  |  4 +-
 pallets/subtensor/src/macros/dispatches.rs    |  2 +-
 pallets/subtensor/src/staking/add_stake.rs    | 11 ++--
 pallets/subtensor/src/staking/helpers.rs      | 26 ++++-----
 pallets/subtensor/src/staking/move_stake.rs   |  2 +-
 pallets/subtensor/src/staking/remove_stake.rs | 19 ++++---
 pallets/subtensor/src/staking/stake_utils.rs  | 54 +++++++++----------
 pallets/subtensor/src/tests/children.rs       |  8 ++-
 pallets/subtensor/src/tests/coinbase.rs       |  6 +--
 pallets/subtensor/src/tests/epoch.rs          |  5 +-
 pallets/subtensor/src/tests/mock.rs           | 24 ++++-----
 pallets/subtensor/src/tests/staking.rs        | 53 +++++++++---------
 pallets/subtensor/src/tests/swap_coldkey.rs   | 14 ++---
 pallets/swap-interface/src/lib.rs             |  2 +-
 pallets/swap/src/mock.rs                      |  8 +--
 pallets/swap/src/pallet/impls.rs              | 15 +++---
 pallets/swap/src/tick.rs                      |  2 +-
 runtime/src/lib.rs                            |  2 +-
 19 files changed, 129 insertions(+), 130 deletions(-)

diff --git a/pallets/admin-utils/src/tests/mock.rs b/pallets/admin-utils/src/tests/mock.rs
index 709ea1506b..ff7ef14e7a 100644
--- a/pallets/admin-utils/src/tests/mock.rs
+++ b/pallets/admin-utils/src/tests/mock.rs
@@ -276,7 +276,7 @@ impl pallet_subtensor_swap::Config for Test {
     type RuntimeEvent = RuntimeEvent;
     type AdminOrigin = EnsureRoot<AccountId>;
     type LiquidityDataProvider = SubtensorModule;
-    type BalanceOps = SubtensorModule;    
+    type BalanceOps = SubtensorModule;
     type ProtocolId = SwapProtocolId;
     type MaxFeeRate = SwapMaxFeeRate;
     type MaxPositions = SwapMaxPositions;
diff --git a/pallets/subtensor/src/lib.rs b/pallets/subtensor/src/lib.rs
index ae125ff6d4..3371b7f804 100644
--- a/pallets/subtensor/src/lib.rs
+++ b/pallets/subtensor/src/lib.rs
@@ -2438,7 +2438,7 @@ impl<T: Config + pallet_balances::Config<Balance = u64>>
 
     fn subnet_mechanism(netuid: u16) -> u16 {
         SubnetMechanism::<T>::get(netuid)
-    }    
+    }
 }
 
 impl<T: Config + pallet_balances::Config<Balance = u64>>
@@ -2490,5 +2490,5 @@ impl<T: Config + pallet_balances::Config<Balance = u64>>
         Ok(Self::decrease_stake_for_hotkey_and_coldkey_on_subnet(
             &hotkey, &coldkey, netuid, alpha,
         ))
-    }  
+    }
 }
diff --git a/pallets/subtensor/src/macros/dispatches.rs b/pallets/subtensor/src/macros/dispatches.rs
index 7a25cf2b4f..4ea03c957b 100644
--- a/pallets/subtensor/src/macros/dispatches.rs
+++ b/pallets/subtensor/src/macros/dispatches.rs
@@ -2023,5 +2023,5 @@ mod dispatches {
         ) -> DispatchResult {
             Self::do_burn_alpha(origin, hotkey, amount, netuid)
         }
-	}
+    }
 }
diff --git a/pallets/subtensor/src/staking/add_stake.rs b/pallets/subtensor/src/staking/add_stake.rs
index 631abac6fc..d848397513 100644
--- a/pallets/subtensor/src/staking/add_stake.rs
+++ b/pallets/subtensor/src/staking/add_stake.rs
@@ -1,6 +1,6 @@
 use super::*;
 use substrate_fixed::types::I96F32;
-use subtensor_swap_interface::{SwapHandler, OrderType};
+use subtensor_swap_interface::{OrderType, SwapHandler};
 
 impl<T: Config> Pallet<T> {
     /// ---- The implementation for the extrinsic add_stake: Adds stake to a hotkey account.
@@ -185,11 +185,14 @@ impl<T: Config> Pallet<T> {
         }
 
         // Use reverting swap to estimate max limit amount
-        if let Ok(swap_result) = T::SwapInterface::swap(netuid, OrderType::Buy, u64::MAX, limit_price, true) {
-            swap_result.amount_paid_in.saturating_add(swap_result.fee_paid)
+        if let Ok(swap_result) =
+            T::SwapInterface::swap(netuid, OrderType::Buy, u64::MAX, limit_price, true)
+        {
+            swap_result
+                .amount_paid_in
+                .saturating_add(swap_result.fee_paid)
         } else {
             0
         }
     }
 }
-
diff --git a/pallets/subtensor/src/staking/helpers.rs b/pallets/subtensor/src/staking/helpers.rs
index 995f16afb3..1e105e46b2 100644
--- a/pallets/subtensor/src/staking/helpers.rs
+++ b/pallets/subtensor/src/staking/helpers.rs
@@ -70,17 +70,14 @@ impl<T: Config> Pallet<T> {
                         let alpha_stake = Self::get_stake_for_hotkey_and_coldkey_on_subnet(
                             hotkey, coldkey, netuid,
                         );
-                        Self::sim_swap_alpha_for_tao(
-                            netuid,
-                            alpha_stake,
-                        )
-                        .map(|r| {
-                            let fee: u64 = U96F32::saturating_from_num(r.fee_paid)
-                                .saturating_mul(T::SwapInterface::current_alpha_price(netuid))
-                                .saturating_to_num();
-                            r.amount_paid_out.saturating_add(fee)
-                        })
-                        .unwrap_or_default()
+                        Self::sim_swap_alpha_for_tao(netuid, alpha_stake)
+                            .map(|r| {
+                                let fee: u64 = U96F32::saturating_from_num(r.fee_paid)
+                                    .saturating_mul(T::SwapInterface::current_alpha_price(netuid))
+                                    .saturating_to_num();
+                                r.amount_paid_out.saturating_add(fee)
+                            })
+                            .unwrap_or_default()
                     })
                     .sum::<u64>()
             })
@@ -199,8 +196,11 @@ impl<T: Config> Pallet<T> {
                     Self::add_balance_to_coldkey_account(coldkey, cleared_stake);
                 } else {
                     // Just clear small alpha
-                    let alpha = Self::get_stake_for_hotkey_and_coldkey_on_subnet(hotkey, coldkey, netuid);
-                    Self::decrease_stake_for_hotkey_and_coldkey_on_subnet(hotkey, coldkey, netuid, alpha);
+                    let alpha =
+                        Self::get_stake_for_hotkey_and_coldkey_on_subnet(hotkey, coldkey, netuid);
+                    Self::decrease_stake_for_hotkey_and_coldkey_on_subnet(
+                        hotkey, coldkey, netuid, alpha,
+                    );
                 }
             }
         }
diff --git a/pallets/subtensor/src/staking/move_stake.rs b/pallets/subtensor/src/staking/move_stake.rs
index 843f403029..af63d1bdd0 100644
--- a/pallets/subtensor/src/staking/move_stake.rs
+++ b/pallets/subtensor/src/staking/move_stake.rs
@@ -389,7 +389,7 @@ impl<T: Config> Pallet<T> {
     /// In the corner case when SubnetTAO(2) == SubnetTAO(1), no slippage is going to occur.
     ///
     /// TODO: This formula only works for a single swap step, so it is not 100% correct for swap v3. We need an updated one.
-    /// 
+    ///
     pub fn get_max_amount_move(
         origin_netuid: u16,
         destination_netuid: u16,
diff --git a/pallets/subtensor/src/staking/remove_stake.rs b/pallets/subtensor/src/staking/remove_stake.rs
index 045c4ac013..3907f16553 100644
--- a/pallets/subtensor/src/staking/remove_stake.rs
+++ b/pallets/subtensor/src/staking/remove_stake.rs
@@ -1,5 +1,5 @@
 use super::*;
-use subtensor_swap_interface::{SwapHandler, OrderType};
+use subtensor_swap_interface::{OrderType, SwapHandler};
 
 impl<T: Config> Pallet<T> {
     /// ---- The implementation for the extrinsic remove_stake: Removes stake from a hotkey account and adds it onto a coldkey.
@@ -346,13 +346,8 @@ impl<T: Config> Pallet<T> {
         )?;
 
         // 4. Swap the alpha to tao and update counters for this subnet.
-        let tao_unstaked = Self::unstake_from_subnet(
-            &hotkey,
-            &coldkey,
-            netuid,
-            possible_alpha,
-            limit_price,
-        )?;
+        let tao_unstaked =
+            Self::unstake_from_subnet(&hotkey, &coldkey, netuid, possible_alpha, limit_price)?;
 
         // 5. We add the balance to the coldkey. If the above fails we will not credit this coldkey.
         Self::add_balance_to_coldkey_account(&coldkey, tao_unstaked);
@@ -385,8 +380,12 @@ impl<T: Config> Pallet<T> {
         }
 
         // Use reverting swap to estimate max limit amount
-        if let Ok(swap_result) = T::SwapInterface::swap(netuid, OrderType::Sell, u64::MAX, limit_price, true) {
-            swap_result.amount_paid_in.saturating_add(swap_result.fee_paid)
+        if let Ok(swap_result) =
+            T::SwapInterface::swap(netuid, OrderType::Sell, u64::MAX, limit_price, true)
+        {
+            swap_result
+                .amount_paid_in
+                .saturating_add(swap_result.fee_paid)
         } else {
             0
         }
diff --git a/pallets/subtensor/src/staking/stake_utils.rs b/pallets/subtensor/src/staking/stake_utils.rs
index af4aba3b5b..36e50e3d41 100644
--- a/pallets/subtensor/src/staking/stake_utils.rs
+++ b/pallets/subtensor/src/staking/stake_utils.rs
@@ -673,27 +673,28 @@ impl<T: Config> Pallet<T> {
         // Step 1: Get the mechanism type for the subnet (0 for Stable, 1 for Dynamic)
         let mechanism_id: u16 = SubnetMechanism::<T>::get(netuid);
         if mechanism_id == 1 {
-            let swap_result = T::SwapInterface::swap(netuid, OrderType::Buy, tao, price_limit, false)?;
+            let swap_result =
+                T::SwapInterface::swap(netuid, OrderType::Buy, tao, price_limit, false)?;
 
             // update Alpha reserves.
             SubnetAlphaIn::<T>::set(netuid, swap_result.new_alpha_reserve);
-    
+
             // Increase Alpha outstanding.
             SubnetAlphaOut::<T>::mutate(netuid, |total| {
                 *total = total.saturating_add(swap_result.amount_paid_out);
             });
-    
+
             // update Tao reserves.
             SubnetTAO::<T>::set(netuid, swap_result.new_tao_reserve);
-    
+
             // Increase Total Tao reserves.
             TotalStake::<T>::mutate(|total| *total = total.saturating_add(tao));
-    
+
             // Increase total subnet TAO volume.
             SubnetVolume::<T>::mutate(netuid, |total| {
                 *total = total.saturating_add(tao.into());
             });
-    
+
             // Return the alpha received.
             Ok(swap_result)
         } else {
@@ -720,7 +721,8 @@ impl<T: Config> Pallet<T> {
         let mechanism_id: u16 = SubnetMechanism::<T>::get(netuid);
         // Step 2: Swap alpha and attain tao
         if mechanism_id == 1 {
-            let swap_result = T::SwapInterface::swap(netuid, OrderType::Sell, alpha, price_limit, false)?;
+            let swap_result =
+                T::SwapInterface::swap(netuid, OrderType::Sell, alpha, price_limit, false)?;
 
             // Increase Alpha reserves.
             SubnetAlphaIn::<T>::set(netuid, swap_result.new_alpha_reserve);
@@ -734,7 +736,9 @@ impl<T: Config> Pallet<T> {
             SubnetTAO::<T>::set(netuid, swap_result.new_tao_reserve);
 
             // Reduce total TAO reserves.
-            TotalStake::<T>::mutate(|total| *total = total.saturating_sub(swap_result.amount_paid_out));
+            TotalStake::<T>::mutate(|total| {
+                *total = total.saturating_sub(swap_result.amount_paid_out)
+            });
 
             // Increase total subnet TAO volume.
             SubnetVolume::<T>::mutate(netuid, |total| {
@@ -774,7 +778,9 @@ impl<T: Config> Pallet<T> {
 
         // Refund the unused alpha (in case if limit price is hit)
         let refund = actual_alpha_decrease.saturating_sub(
-            swap_result.amount_paid_in.saturating_add(swap_result.fee_paid)
+            swap_result
+                .amount_paid_in
+                .saturating_add(swap_result.fee_paid),
         );
         Self::increase_stake_for_hotkey_and_coldkey_on_subnet(hotkey, coldkey, netuid, refund);
 
@@ -900,12 +906,9 @@ impl<T: Config> Pallet<T> {
         // Get the minimum balance (and amount) that satisfies the transaction
         let min_amount = {
             let min_stake = DefaultMinStake::<T>::get();
-            let fee = Self::sim_swap_tao_for_alpha(
-                netuid,
-                min_stake,
-            )
-            .map(|res| res.fee_paid)
-            .unwrap_or(T::SwapInterface::approx_fee_amount(netuid, min_stake));
+            let fee = Self::sim_swap_tao_for_alpha(netuid, min_stake)
+                .map(|res| res.fee_paid)
+                .unwrap_or(T::SwapInterface::approx_fee_amount(netuid, min_stake));
             min_stake.saturating_add(fee)
         };
 
@@ -930,11 +933,8 @@ impl<T: Config> Pallet<T> {
             Error::<T>::HotKeyAccountNotExists
         );
 
-        let expected_alpha = Self::sim_swap_tao_for_alpha(
-            netuid,
-            stake_to_be_added,
-        )
-        .map_err(|_| Error::<T>::InsufficientLiquidity)?;
+        let expected_alpha = Self::sim_swap_tao_for_alpha(netuid, stake_to_be_added)
+            .map_err(|_| Error::<T>::InsufficientLiquidity)?;
 
         ensure!(
             expected_alpha.amount_paid_out > 0,
@@ -966,10 +966,7 @@ impl<T: Config> Pallet<T> {
         ensure!(Self::if_subnet_exist(netuid), Error::<T>::SubnetNotExists);
 
         // Ensure that the stake amount to be removed is above the minimum in tao equivalent.
-        match Self::sim_swap_alpha_for_tao(
-            netuid,
-            alpha_unstaked,
-        ) {
+        match Self::sim_swap_alpha_for_tao(netuid, alpha_unstaked) {
             Ok(res) => ensure!(
                 res.amount_paid_out > DefaultMinStake::<T>::get(),
                 Error::<T>::AmountTooLow
@@ -1049,12 +1046,9 @@ impl<T: Config> Pallet<T> {
         );
 
         // Ensure that the stake amount to be removed is above the minimum in tao equivalent.
-        let tao_equivalent = Self::sim_swap_alpha_for_tao(
-            origin_netuid,
-            alpha_amount,
-        )
-        .map(|res| res.amount_paid_out)
-        .map_err(|_| Error::<T>::InsufficientLiquidity)?;
+        let tao_equivalent = Self::sim_swap_alpha_for_tao(origin_netuid, alpha_amount)
+            .map(|res| res.amount_paid_out)
+            .map_err(|_| Error::<T>::InsufficientLiquidity)?;
         ensure!(
             tao_equivalent > DefaultMinStake::<T>::get(),
             Error::<T>::AmountTooLow
diff --git a/pallets/subtensor/src/tests/children.rs b/pallets/subtensor/src/tests/children.rs
index 216f7dee20..d0f327b194 100644
--- a/pallets/subtensor/src/tests/children.rs
+++ b/pallets/subtensor/src/tests/children.rs
@@ -2223,9 +2223,13 @@ fn test_do_remove_stake_clears_pending_childkeys() {
             StakeThreshold::<Test>::get() * 2
         ));
 
-        let alpha = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid);
+        let alpha =
+            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid);
 
-        println!("StakeThreshold::<Test>::get() = {:?}", StakeThreshold::<Test>::get());
+        println!(
+            "StakeThreshold::<Test>::get() = {:?}",
+            StakeThreshold::<Test>::get()
+        );
         println!("alpha                         = {:?}", alpha);
 
         // Attempt to set child
diff --git a/pallets/subtensor/src/tests/coinbase.rs b/pallets/subtensor/src/tests/coinbase.rs
index 7adcd05896..f93872cb06 100644
--- a/pallets/subtensor/src/tests/coinbase.rs
+++ b/pallets/subtensor/src/tests/coinbase.rs
@@ -478,11 +478,7 @@ fn test_pending_swapped() {
             1_000_000_000 - 125000000,
             epsilon = 1
         ); // 1 - swapped.
-        assert_abs_diff_eq!(
-            PendingRootDivs::<Test>::get(netuid),
-            125000000,
-            epsilon = 1
-        ); // swapped * (price = 1)
+        assert_abs_diff_eq!(PendingRootDivs::<Test>::get(netuid), 125000000, epsilon = 1); // swapped * (price = 1)
     });
 }
 
diff --git a/pallets/subtensor/src/tests/epoch.rs b/pallets/subtensor/src/tests/epoch.rs
index 4c3a3bc2d2..0be2307dbd 100644
--- a/pallets/subtensor/src/tests/epoch.rs
+++ b/pallets/subtensor/src/tests/epoch.rs
@@ -563,7 +563,10 @@ fn test_1_graph() {
         let stake_amount: u64 = 1_000_000_000;
         add_network(netuid, u16::MAX - 1, 0); // set higher tempo to avoid built-in epoch, then manual epoch instead
         SubtensorModule::set_max_allowed_uids(netuid, 1);
-        SubtensorModule::add_balance_to_coldkey_account(&coldkey, stake_amount + ExistentialDeposit::get());
+        SubtensorModule::add_balance_to_coldkey_account(
+            &coldkey,
+            stake_amount + ExistentialDeposit::get(),
+        );
         register_ok_neuron(netuid, hotkey, coldkey, 1);
         SubtensorModule::set_weights_set_rate_limit(netuid, 0);
 
diff --git a/pallets/subtensor/src/tests/mock.rs b/pallets/subtensor/src/tests/mock.rs
index faa51353bb..e61ae02720 100644
--- a/pallets/subtensor/src/tests/mock.rs
+++ b/pallets/subtensor/src/tests/mock.rs
@@ -865,9 +865,7 @@ pub(crate) fn setup_reserves(netuid: u16, tao: u64, alpha: u64) {
 
 pub(crate) fn swap_tao_to_alpha(netuid: u16, tao: u64) -> (u64, u64) {
     match netuid {
-        0 => {
-            (tao, 0)
-        },
+        0 => (tao, 0),
         _ => {
             let result = <Test as pallet::Config>::SwapInterface::swap(
                 netuid,
@@ -876,27 +874,27 @@ pub(crate) fn swap_tao_to_alpha(netuid: u16, tao: u64) -> (u64, u64) {
                 <Test as pallet::Config>::SwapInterface::max_price(),
                 true,
             );
-        
+
             assert_ok!(&result);
-        
+
             let result = result.unwrap();
-        
+
             // we don't want to have silent 0 comparissons in tests
             assert!(result.amount_paid_out > 0);
-        
+
             (result.amount_paid_out, result.fee_paid)
-        }        
+        }
     }
 }
 
 pub(crate) fn swap_alpha_to_tao(netuid: u16, alpha: u64) -> (u64, u64) {
     match netuid {
-        0 => {
-            (alpha, 0)
-        },
+        0 => (alpha, 0),
         _ => {
-
-            println!("<Test as pallet::Config>::SwapInterface::min_price() = {:?}", <Test as pallet::Config>::SwapInterface::min_price());
+            println!(
+                "<Test as pallet::Config>::SwapInterface::min_price() = {:?}",
+                <Test as pallet::Config>::SwapInterface::min_price()
+            );
 
             let result = <Test as pallet::Config>::SwapInterface::swap(
                 netuid,
diff --git a/pallets/subtensor/src/tests/staking.rs b/pallets/subtensor/src/tests/staking.rs
index 5d78d9ed7a..a40979439a 100644
--- a/pallets/subtensor/src/tests/staking.rs
+++ b/pallets/subtensor/src/tests/staking.rs
@@ -2904,7 +2904,7 @@ fn test_max_amount_add_dynamic() {
             150_000_000_000,
         ),
         // Miscellaneous overflows and underflows
-        (u64::MAX/2, u64::MAX, u64::MAX, u64::MAX),
+        (u64::MAX / 2, u64::MAX, u64::MAX, u64::MAX),
         // (150_000_000_000, 100_000_000_000, u64::MAX / 2, u64::MAX),
         // (1_000_000, 1_000_000_000_000_000_000_u64, 1, 999_000_000),
         // (1_000_000, 1_000_000_000_000_000_000_u64, 2, 1_999_000_000),
@@ -2957,22 +2957,19 @@ fn test_max_amount_add_dynamic() {
             let subnet_owner_coldkey = U256::from(1001);
             let subnet_owner_hotkey = U256::from(1002);
             let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
-        
+
             // Forse-set alpha in and tao reserve to achieve relative price of subnets
             SubnetTAO::<Test>::insert(netuid, tao_in);
             SubnetAlphaIn::<Test>::insert(netuid, alpha_in);
 
             // Force the swap to initialize
-            SubtensorModule::swap_tao_for_alpha(
-                netuid,
-                0,
-                1_000_000_000_000
-            ).unwrap();
+            SubtensorModule::swap_tao_for_alpha(netuid, 0, 1_000_000_000_000).unwrap();
 
             if alpha_in != 0 {
                 let expected_price = U96F32::from_num(tao_in) / U96F32::from_num(alpha_in);
                 assert_abs_diff_eq!(
-                    <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid).to_num::<f64>(),
+                    <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid)
+                        .to_num::<f64>(),
                     expected_price.to_num::<f64>(),
                     epsilon = expected_price.to_num::<f64>() / 1_000_000_000_f64
                 );
@@ -3068,7 +3065,7 @@ fn test_max_amount_remove_dynamic() {
             (0, 1_000_000_000, 100, 0),
             (1_000_000_000, 0, 100, 0),
             (10_000_000_000, 10_000_000_000, 0, u64::MAX),
-            // Low bounds (numbers are empirical, it is only important that result 
+            // Low bounds (numbers are empirical, it is only important that result
             // is sharply decreasing when limit price increases)
             (1_000, 1_000, 0, 0),
             (1_001, 1_001, 0, 4_307_770_117),
@@ -3135,12 +3132,7 @@ fn test_max_amount_remove_dynamic() {
                 999_999_999,
                 10_500_000,
             ),
-            (
-                21_000_000_000_000_000,
-                21_000_000_000_000_000,
-                0,
-                u64::MAX,
-            ),
+            (21_000_000_000_000_000, 21_000_000_000_000_000, 0, u64::MAX),
         ]
         .iter()
         .for_each(|&(tao_in, alpha_in, limit_price, expected_max_swappable)| {
@@ -3156,7 +3148,8 @@ fn test_max_amount_remove_dynamic() {
                 );
             }
 
-            let expected = expected_max_swappable.saturating_add((expected_max_swappable as f64 * 0.003) as u64);
+            let expected = expected_max_swappable
+                .saturating_add((expected_max_swappable as f64 * 0.003) as u64);
             assert_abs_diff_eq!(
                 SubtensorModule::get_max_amount_remove(netuid, limit_price),
                 expected,
@@ -3656,7 +3649,7 @@ fn test_add_stake_limit_ok() {
             limit_price,
             true
         ));
-        
+
         // Check if stake has increased only by 75 Alpha
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
@@ -3669,7 +3662,10 @@ fn test_add_stake_limit_ok() {
         );
 
         // Check that 450 TAO less fees balance still remains free on coldkey
-        let fee = <tests::mock::Test as pallet::Config>::SwapInterface::approx_fee_amount(netuid, amount / 2) as f64;
+        let fee = <tests::mock::Test as pallet::Config>::SwapInterface::approx_fee_amount(
+            netuid,
+            amount / 2,
+        ) as f64;
         assert_abs_diff_eq!(
             SubtensorModule::get_coldkey_balance(&coldkey_account_id),
             amount / 2 - fee as u64,
@@ -3750,7 +3746,10 @@ fn test_remove_stake_limit_ok() {
 
         // add network
         let netuid: u16 = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
-        SubtensorModule::add_balance_to_coldkey_account(&coldkey_account_id, stake_amount + ExistentialDeposit::get());
+        SubtensorModule::add_balance_to_coldkey_account(
+            &coldkey_account_id,
+            stake_amount + ExistentialDeposit::get(),
+        );
 
         // Forse-set sufficient reserves
         let tao_reserve: U96F32 = U96F32::from_num(100_000_000_000_u64);
@@ -4313,20 +4312,26 @@ fn test_unstake_all_alpha_hits_liquidity_min() {
         // Setup the pool so that removing all the TAO will bring liqudity below the minimum
         let remaining_tao = I96F32::from_num(u64::from(mock::SwapMinimumReserve::get()) - 1)
             .saturating_sub(I96F32::from(1));
-        let alpha = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid);
+        let alpha =
+            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid);
         let alpha_reserves = I110F18::from(alpha + 10_000_000);
 
         let k = I110F18::from_fixed(remaining_tao)
             .saturating_mul(alpha_reserves.saturating_add(I110F18::from(alpha)));
         let tao_reserves = k.safe_div(alpha_reserves);
 
-        mock::setup_reserves(netuid, tao_reserves.to_num::<u64>() / 100_u64, alpha_reserves.to_num());
+        mock::setup_reserves(
+            netuid,
+            tao_reserves.to_num::<u64>() / 100_u64,
+            alpha_reserves.to_num(),
+        );
 
         // Try to unstake, but we reduce liquidity too far
 
-        assert_ok!(
-            SubtensorModule::unstake_all_alpha(RuntimeOrigin::signed(coldkey), hotkey)
-        );
+        assert_ok!(SubtensorModule::unstake_all_alpha(
+            RuntimeOrigin::signed(coldkey),
+            hotkey
+        ));
 
         // Expect nothing to be unstaked
         let new_alpha =
diff --git a/pallets/subtensor/src/tests/swap_coldkey.rs b/pallets/subtensor/src/tests/swap_coldkey.rs
index 538b3736ca..74bc0a45c5 100644
--- a/pallets/subtensor/src/tests/swap_coldkey.rs
+++ b/pallets/subtensor/src/tests/swap_coldkey.rs
@@ -381,7 +381,7 @@ fn test_swap_with_max_values() {
         let expected_stake1 = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
             &hotkey,
             &old_coldkey,
-            netuid
+            netuid,
         );
 
         assert_ok!(SubtensorModule::add_stake(
@@ -393,7 +393,7 @@ fn test_swap_with_max_values() {
         let expected_stake2 = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
             &hotkey2,
             &old_coldkey2,
-            netuid2
+            netuid2,
         );
 
         let mut weight = Weight::zero();
@@ -885,7 +885,7 @@ fn test_swap_stake_for_coldkey() {
         let expected_stake_alpha1 = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
             &hotkey1,
             &old_coldkey,
-            netuid
+            netuid,
         );
 
         assert_ok!(SubtensorModule::add_stake(
@@ -897,7 +897,7 @@ fn test_swap_stake_for_coldkey() {
         let expected_stake_alpha2 = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
             &hotkey2,
             &old_coldkey,
-            netuid
+            netuid,
         );
 
         // Insert existing for same hotkey1
@@ -913,7 +913,7 @@ fn test_swap_stake_for_coldkey() {
         let expected_stake_alpha3 = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
             &hotkey1,
             &new_coldkey,
-            netuid
+            netuid,
         );
 
         // Record initial values
@@ -1039,7 +1039,7 @@ fn test_swap_staking_hotkeys_for_coldkey() {
         let expected_stake_alpha1 = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
             &hotkey1,
             &old_coldkey,
-            netuid
+            netuid,
         );
 
         assert_ok!(SubtensorModule::add_stake(
@@ -1051,7 +1051,7 @@ fn test_swap_staking_hotkeys_for_coldkey() {
         let expected_stake_alpha2 = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
             &hotkey2,
             &old_coldkey,
-            netuid
+            netuid,
         );
 
         // Perform the swap
diff --git a/pallets/swap-interface/src/lib.rs b/pallets/swap-interface/src/lib.rs
index a7640d12d0..e937883285 100644
--- a/pallets/swap-interface/src/lib.rs
+++ b/pallets/swap-interface/src/lib.rs
@@ -45,7 +45,7 @@ pub trait LiquidityDataProvider<AccountId> {
     fn tao_reserve(netuid: u16) -> u64;
     fn alpha_reserve(netuid: u16) -> u64;
     fn subnet_exist(netuid: u16) -> bool;
-    fn subnet_mechanism(netuid: u16) -> u16;    
+    fn subnet_mechanism(netuid: u16) -> u16;
 }
 
 pub trait BalanceOps<AccountId> {
diff --git a/pallets/swap/src/mock.rs b/pallets/swap/src/mock.rs
index 45fd3d8187..37d5214bb2 100644
--- a/pallets/swap/src/mock.rs
+++ b/pallets/swap/src/mock.rs
@@ -94,12 +94,8 @@ impl LiquidityDataProvider<AccountId> for MockLiquidityProvider {
     }
 
     fn subnet_mechanism(netuid: u16) -> u16 {
-        if netuid == 0 {
-            0
-        } else {
-            1
-        }
-    }    
+        if netuid == 0 { 0 } else { 1 }
+    }
 }
 
 pub struct MockBalanceOps;
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 602fb7a496..052a4e5470 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -1065,17 +1065,15 @@ impl<T: Config> SwapHandler<T::AccountId> for Pallet<T> {
                 let sqrt_price = AlphaSqrtPrice::<T>::get(NetUid::from(netuid));
                 let tao_reserve = T::LiquidityDataProvider::tao_reserve(netuid);
                 let alpha_reserve = T::LiquidityDataProvider::alpha_reserve(netuid);
-        
+
                 if sqrt_price == 0 && tao_reserve > 0 && alpha_reserve > 0 {
                     U96F32::saturating_from_num(tao_reserve)
                         .saturating_div(U96F32::saturating_from_num(alpha_reserve))
                 } else {
                     U96F32::saturating_from_num(sqrt_price.saturating_mul(sqrt_price))
                 }
-            },
-            _ => {
-                U96F32::saturating_from_num(1)
             }
+            _ => U96F32::saturating_from_num(1),
         }
     }
 
@@ -1544,9 +1542,12 @@ mod tests {
                 .unwrap();
 
                 // Remove liquidity
-                let remove_result =
-                    Pallet::<Test>::do_remove_liquidity(netuid, &OK_COLDKEY_ACCOUNT_ID, position_id)
-                        .unwrap();
+                let remove_result = Pallet::<Test>::do_remove_liquidity(
+                    netuid,
+                    &OK_COLDKEY_ACCOUNT_ID,
+                    position_id,
+                )
+                .unwrap();
                 assert_abs_diff_eq!(remove_result.tao, tao, epsilon = tao / 1000);
                 assert_abs_diff_eq!(remove_result.alpha, alpha, epsilon = alpha / 1000);
                 assert_eq!(remove_result.fee_tao, 0);
diff --git a/pallets/swap/src/tick.rs b/pallets/swap/src/tick.rs
index 7352fd7d7a..435960e4bb 100644
--- a/pallets/swap/src/tick.rs
+++ b/pallets/swap/src/tick.rs
@@ -1142,8 +1142,8 @@ impl Error for TickMathError {}
 
 #[cfg(test)]
 mod tests {
-    use std::{ops::Sub, str::FromStr};
     use safe_math::FixedExt;
+    use std::{ops::Sub, str::FromStr};
 
     use super::*;
     use crate::mock::*;
diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index fc32639868..78b32986c0 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -1132,7 +1132,7 @@ impl pallet_subtensor_swap::Config for Runtime {
     type RuntimeEvent = RuntimeEvent;
     type AdminOrigin = EnsureRoot<AccountId>;
     type LiquidityDataProvider = SubtensorModule;
-	type BalanceOps = SubtensorModule;
+    type BalanceOps = SubtensorModule;
     type ProtocolId = SwapProtocolId;
     type MaxFeeRate = SwapMaxFeeRate;
     type MaxPositions = SwapMaxPositions;

From d537112a07f54caa599b46d6991d6dcb8e6286a8 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Tue, 20 May 2025 14:57:25 +0200
Subject: [PATCH 180/418] Rename LiquidityDataProvider to SubnetInfo

---
 pallets/admin-utils/src/tests/mock.rs       |  2 +-
 pallets/subtensor/src/lib.rs                |  6 +++---
 pallets/subtensor/src/tests/mock.rs         |  2 +-
 pallets/subtensor/src/tests/swap_coldkey.rs |  2 +-
 pallets/swap-interface/src/lib.rs           |  6 +++---
 pallets/swap/src/mock.rs                    | 12 ++++++------
 pallets/swap/src/pallet/impls.rs            | 21 ++++++++++-----------
 pallets/swap/src/pallet/mod.rs              | 14 +++++++-------
 runtime/src/lib.rs                          |  2 +-
 9 files changed, 33 insertions(+), 34 deletions(-)

diff --git a/pallets/admin-utils/src/tests/mock.rs b/pallets/admin-utils/src/tests/mock.rs
index ff7ef14e7a..57d086b538 100644
--- a/pallets/admin-utils/src/tests/mock.rs
+++ b/pallets/admin-utils/src/tests/mock.rs
@@ -275,7 +275,7 @@ parameter_types! {
 impl pallet_subtensor_swap::Config for Test {
     type RuntimeEvent = RuntimeEvent;
     type AdminOrigin = EnsureRoot<AccountId>;
-    type LiquidityDataProvider = SubtensorModule;
+    type SubnetInfo = SubtensorModule;
     type BalanceOps = SubtensorModule;
     type ProtocolId = SwapProtocolId;
     type MaxFeeRate = SwapMaxFeeRate;
diff --git a/pallets/subtensor/src/lib.rs b/pallets/subtensor/src/lib.rs
index 3371b7f804..6fef4dc6ee 100644
--- a/pallets/subtensor/src/lib.rs
+++ b/pallets/subtensor/src/lib.rs
@@ -2422,7 +2422,7 @@ impl<T, H, P> CollectiveInterface<T, H, P> for () {
 }
 
 impl<T: Config + pallet_balances::Config<Balance = u64>>
-    subtensor_swap_interface::LiquidityDataProvider<T::AccountId> for Pallet<T>
+    subtensor_swap_interface::SubnetInfo<T::AccountId> for Pallet<T>
 {
     fn tao_reserve(netuid: u16) -> u64 {
         SubnetTAO::<T>::get(netuid)
@@ -2432,11 +2432,11 @@ impl<T: Config + pallet_balances::Config<Balance = u64>>
         SubnetAlphaIn::<T>::get(netuid)
     }
 
-    fn subnet_exist(netuid: u16) -> bool {
+    fn exists(netuid: u16) -> bool {
         Self::if_subnet_exist(netuid)
     }
 
-    fn subnet_mechanism(netuid: u16) -> u16 {
+    fn mechanism(netuid: u16) -> u16 {
         SubnetMechanism::<T>::get(netuid)
     }
 }
diff --git a/pallets/subtensor/src/tests/mock.rs b/pallets/subtensor/src/tests/mock.rs
index e61ae02720..1f30b115ef 100644
--- a/pallets/subtensor/src/tests/mock.rs
+++ b/pallets/subtensor/src/tests/mock.rs
@@ -431,7 +431,7 @@ parameter_types! {
 impl pallet_subtensor_swap::Config for Test {
     type RuntimeEvent = RuntimeEvent;
     type AdminOrigin = EnsureRoot<AccountId>;
-    type LiquidityDataProvider = SubtensorModule;
+    type SubnetInfo = SubtensorModule;
     type BalanceOps = SubtensorModule;
     type ProtocolId = SwapProtocolId;
     type MaxFeeRate = SwapMaxFeeRate;
diff --git a/pallets/subtensor/src/tests/swap_coldkey.rs b/pallets/subtensor/src/tests/swap_coldkey.rs
index 74bc0a45c5..f796b9d88a 100644
--- a/pallets/subtensor/src/tests/swap_coldkey.rs
+++ b/pallets/subtensor/src/tests/swap_coldkey.rs
@@ -12,7 +12,7 @@ use frame_system::{Config, RawOrigin};
 use sp_core::{Get, H256, U256};
 use sp_runtime::DispatchError;
 use substrate_fixed::types::U96F32;
-use subtensor_swap_interface::{LiquidityDataProvider, OrderType, SwapHandler};
+use subtensor_swap_interface::{OrderType, SubnetInfo, SwapHandler};
 
 use super::mock;
 use super::mock::*;
diff --git a/pallets/swap-interface/src/lib.rs b/pallets/swap-interface/src/lib.rs
index e937883285..8ab9c5d1cc 100644
--- a/pallets/swap-interface/src/lib.rs
+++ b/pallets/swap-interface/src/lib.rs
@@ -41,11 +41,11 @@ pub struct UpdateLiquidityResult {
     pub fee_alpha: u64,
 }
 
-pub trait LiquidityDataProvider<AccountId> {
+pub trait SubnetInfo<AccountId> {
     fn tao_reserve(netuid: u16) -> u64;
     fn alpha_reserve(netuid: u16) -> u64;
-    fn subnet_exist(netuid: u16) -> bool;
-    fn subnet_mechanism(netuid: u16) -> u16;
+    fn exists(netuid: u16) -> bool;
+    fn mechanism(netuid: u16) -> u16;
 }
 
 pub trait BalanceOps<AccountId> {
diff --git a/pallets/swap/src/mock.rs b/pallets/swap/src/mock.rs
index 52c9e1c77a..e30c1978cc 100644
--- a/pallets/swap/src/mock.rs
+++ b/pallets/swap/src/mock.rs
@@ -12,7 +12,7 @@ use sp_runtime::{
     BuildStorage,
     traits::{BlakeTwo256, IdentityLookup},
 };
-use subtensor_swap_interface::{BalanceOps, LiquidityDataProvider};
+use subtensor_swap_interface::{BalanceOps, SubnetInfo};
 
 construct_runtime!(
     pub enum Test {
@@ -71,10 +71,10 @@ parameter_types! {
     pub const MinimumReserves: NonZeroU64 = NonZeroU64::new(1).unwrap();
 }
 
-// Mock implementor of LiquidityDataProvider trait
+// Mock implementor of SubnetInfo trait
 pub struct MockLiquidityProvider;
 
-impl LiquidityDataProvider<AccountId> for MockLiquidityProvider {
+impl SubnetInfo<AccountId> for MockLiquidityProvider {
     fn tao_reserve(netuid: u16) -> u64 {
         match netuid {
             123 => 10_000,
@@ -89,11 +89,11 @@ impl LiquidityDataProvider<AccountId> for MockLiquidityProvider {
         }
     }
 
-    fn subnet_exist(_netuid: u16) -> bool {
+    fn exists(_netuid: u16) -> bool {
         true
     }
 
-    fn subnet_mechanism(netuid: u16) -> u16 {
+    fn mechanism(netuid: u16) -> u16 {
         if netuid == 0 { 0 } else { 1 }
     }
 }
@@ -147,7 +147,7 @@ impl BalanceOps<AccountId> for MockBalanceOps {
 impl crate::pallet::Config for Test {
     type RuntimeEvent = RuntimeEvent;
     type AdminOrigin = EnsureRoot<AccountId>;
-    type LiquidityDataProvider = MockLiquidityProvider;
+    type SubnetInfo = MockLiquidityProvider;
     type BalanceOps = MockBalanceOps;
     type ProtocolId = SwapProtocolId;
     type MaxFeeRate = MaxFeeRate;
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index d9ee8a5d8f..1732fa2950 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -8,7 +8,7 @@ use sp_arithmetic::helpers_128bit;
 use sp_runtime::traits::AccountIdConversion;
 use substrate_fixed::types::{U64F64, U96F32};
 use subtensor_swap_interface::{
-    BalanceOps, LiquidityDataProvider, SwapHandler, SwapResult, UpdateLiquidityResult,
+    BalanceOps, SubnetInfo, SwapHandler, SwapResult, UpdateLiquidityResult,
 };
 
 use super::pallet::*;
@@ -249,8 +249,8 @@ impl<T: Config> Pallet<T> {
 
         // Initialize the v3:
         // Reserves are re-purposed, nothing to set, just query values for liquidity and price calculation
-        let tao_reserve = <T as Config>::LiquidityDataProvider::tao_reserve(netuid.into());
-        let alpha_reserve = <T as Config>::LiquidityDataProvider::alpha_reserve(netuid.into());
+        let tao_reserve = <T as Config>::SubnetInfo::tao_reserve(netuid.into());
+        let alpha_reserve = <T as Config>::SubnetInfo::alpha_reserve(netuid.into());
 
         // Set price
         let price = U64F64::saturating_from_num(tao_reserve)
@@ -319,9 +319,8 @@ impl<T: Config> Pallet<T> {
         sqrt_price_limit: SqrtPrice,
     ) -> Result<SwapResult, Error<T>> {
         ensure!(
-            T::LiquidityDataProvider::tao_reserve(netuid.into()) >= T::MinimumReserve::get().get()
-                && T::LiquidityDataProvider::alpha_reserve(netuid.into())
-                    >= T::MinimumReserve::get().get(),
+            T::SubnetInfo::tao_reserve(netuid.into()) >= T::MinimumReserve::get().get()
+                && T::SubnetInfo::alpha_reserve(netuid.into()) >= T::MinimumReserve::get().get(),
             Error::<T>::ReservesTooLow
         );
 
@@ -363,8 +362,8 @@ impl<T: Config> Pallet<T> {
             );
         }
 
-        let tao_reserve = T::LiquidityDataProvider::tao_reserve(netuid.into());
-        let alpha_reserve = T::LiquidityDataProvider::alpha_reserve(netuid.into());
+        let tao_reserve = T::SubnetInfo::tao_reserve(netuid.into());
+        let alpha_reserve = T::SubnetInfo::alpha_reserve(netuid.into());
 
         let checked_reserve = match order_type {
             OrderType::Buy => alpha_reserve,
@@ -1061,11 +1060,11 @@ impl<T: Config> SwapHandler<T::AccountId> for Pallet<T> {
     }
 
     fn current_alpha_price(netuid: u16) -> U96F32 {
-        match T::LiquidityDataProvider::subnet_mechanism(netuid) {
+        match T::SubnetInfo::mechanism(netuid) {
             1 => {
                 let sqrt_price = AlphaSqrtPrice::<T>::get(NetUid::from(netuid));
-                let tao_reserve = T::LiquidityDataProvider::tao_reserve(netuid);
-                let alpha_reserve = T::LiquidityDataProvider::alpha_reserve(netuid);
+                let tao_reserve = T::SubnetInfo::tao_reserve(netuid);
+                let alpha_reserve = T::SubnetInfo::alpha_reserve(netuid);
 
                 if sqrt_price == 0 && tao_reserve > 0 && alpha_reserve > 0 {
                     U96F32::saturating_from_num(tao_reserve)
diff --git a/pallets/swap/src/pallet/mod.rs b/pallets/swap/src/pallet/mod.rs
index ab35bd452b..082ce508fb 100644
--- a/pallets/swap/src/pallet/mod.rs
+++ b/pallets/swap/src/pallet/mod.rs
@@ -3,7 +3,7 @@ use core::num::NonZeroU64;
 use frame_support::{PalletId, pallet_prelude::*, traits::Get};
 use frame_system::pallet_prelude::*;
 use substrate_fixed::types::U64F64;
-use subtensor_swap_interface::{BalanceOps, LiquidityDataProvider};
+use subtensor_swap_interface::{BalanceOps, SubnetInfo};
 
 use crate::{
     NetUid,
@@ -34,8 +34,8 @@ mod pallet {
         type AdminOrigin: EnsureOrigin<Self::RuntimeOrigin>;
 
         /// Implementor of
-        /// [`LiquidityDataProvider`](subtensor_swap_interface::LiquidityDataProvider).
-        type LiquidityDataProvider: LiquidityDataProvider<Self::AccountId>;
+        /// [`SubnetInfo`](subtensor_swap_interface::SubnetInfo).
+        type SubnetInfo: SubnetInfo<Self::AccountId>;
 
         /// Implementor of
         /// [`BalanceOps`](subtensor_swap_interface::BalanceOps).
@@ -230,7 +230,7 @@ mod pallet {
 
             // Ensure that the subnet exists.
             ensure!(
-                T::LiquidityDataProvider::subnet_exist(netuid),
+                T::SubnetInfo::exists(netuid),
                 Error::<T>::SubNetworkDoesNotExist
             );
 
@@ -270,7 +270,7 @@ mod pallet {
 
             // Ensure that the subnet exists.
             ensure!(
-                T::LiquidityDataProvider::subnet_exist(netuid),
+                T::SubnetInfo::exists(netuid),
                 Error::<T>::SubNetworkDoesNotExist
             );
 
@@ -326,7 +326,7 @@ mod pallet {
 
             // Ensure that the subnet exists.
             ensure!(
-                T::LiquidityDataProvider::subnet_exist(netuid),
+                T::SubnetInfo::exists(netuid),
                 Error::<T>::SubNetworkDoesNotExist
             );
 
@@ -378,7 +378,7 @@ mod pallet {
 
             // Ensure that the subnet exists.
             ensure!(
-                T::LiquidityDataProvider::subnet_exist(netuid),
+                T::SubnetInfo::exists(netuid),
                 Error::<T>::SubNetworkDoesNotExist
             );
 
diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index 78b32986c0..e037f31d76 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -1131,7 +1131,7 @@ parameter_types! {
 impl pallet_subtensor_swap::Config for Runtime {
     type RuntimeEvent = RuntimeEvent;
     type AdminOrigin = EnsureRoot<AccountId>;
-    type LiquidityDataProvider = SubtensorModule;
+    type SubnetInfo = SubtensorModule;
     type BalanceOps = SubtensorModule;
     type ProtocolId = SwapProtocolId;
     type MaxFeeRate = SwapMaxFeeRate;

From 11ee3defdfb25409f873170b6f8289732839f934 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Tue, 20 May 2025 15:48:38 +0200
Subject: [PATCH 181/418] Move sim_swap into swap pallet

---
 pallets/subtensor/src/lib.rs                 | 12 ++--
 pallets/subtensor/src/staking/helpers.rs     | 12 ++--
 pallets/subtensor/src/staking/stake_utils.rs | 68 ++------------------
 pallets/swap-interface/src/lib.rs            |  5 ++
 pallets/swap/src/pallet/impls.rs             | 20 ++++++
 5 files changed, 41 insertions(+), 76 deletions(-)

diff --git a/pallets/subtensor/src/lib.rs b/pallets/subtensor/src/lib.rs
index 6fef4dc6ee..cb5c4bb0a8 100644
--- a/pallets/subtensor/src/lib.rs
+++ b/pallets/subtensor/src/lib.rs
@@ -2453,11 +2453,11 @@ impl<T: Config + pallet_balances::Config<Balance = u64>>
     }
 
     fn increase_balance(coldkey: &T::AccountId, tao: u64) {
-        Self::add_balance_to_coldkey_account(&coldkey, tao)
+        Self::add_balance_to_coldkey_account(coldkey, tao)
     }
 
     fn decrease_balance(coldkey: &T::AccountId, tao: u64) -> Result<u64, DispatchError> {
-        Self::remove_balance_from_coldkey_account(&coldkey, tao)
+        Self::remove_balance_from_coldkey_account(coldkey, tao)
     }
 
     fn increase_stake(
@@ -2467,11 +2467,11 @@ impl<T: Config + pallet_balances::Config<Balance = u64>>
         alpha: u64,
     ) -> Result<(), DispatchError> {
         ensure!(
-            Self::hotkey_account_exists(&hotkey),
+            Self::hotkey_account_exists(hotkey),
             Error::<T>::HotKeyAccountNotExists
         );
 
-        Self::increase_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid, alpha);
+        Self::increase_stake_for_hotkey_and_coldkey_on_subnet(hotkey, coldkey, netuid, alpha);
 
         Ok(())
     }
@@ -2483,12 +2483,12 @@ impl<T: Config + pallet_balances::Config<Balance = u64>>
         alpha: u64,
     ) -> Result<u64, DispatchError> {
         ensure!(
-            Self::hotkey_account_exists(&hotkey),
+            Self::hotkey_account_exists(hotkey),
             Error::<T>::HotKeyAccountNotExists
         );
 
         Ok(Self::decrease_stake_for_hotkey_and_coldkey_on_subnet(
-            &hotkey, &coldkey, netuid, alpha,
+            hotkey, coldkey, netuid, alpha,
         ))
     }
 }
diff --git a/pallets/subtensor/src/staking/helpers.rs b/pallets/subtensor/src/staking/helpers.rs
index 1e105e46b2..edabf4d64c 100644
--- a/pallets/subtensor/src/staking/helpers.rs
+++ b/pallets/subtensor/src/staking/helpers.rs
@@ -1,8 +1,3 @@
-use super::*;
-use safe_math::*;
-use substrate_fixed::types::U96F32;
-use subtensor_swap_interface::SwapHandler;
-
 use frame_support::traits::{
     Imbalance,
     tokens::{
@@ -10,6 +5,11 @@ use frame_support::traits::{
         fungible::{Balanced as _, Inspect as _},
     },
 };
+use safe_math::*;
+use substrate_fixed::types::U96F32;
+use subtensor_swap_interface::{OrderType, SwapHandler};
+
+use super::*;
 
 impl<T: Config> Pallet<T> {
     // Returns true if the passed hotkey allow delegative staking.
@@ -70,7 +70,7 @@ impl<T: Config> Pallet<T> {
                         let alpha_stake = Self::get_stake_for_hotkey_and_coldkey_on_subnet(
                             hotkey, coldkey, netuid,
                         );
-                        Self::sim_swap_alpha_for_tao(netuid, alpha_stake)
+                        T::SwapInterface::sim_swap(netuid, OrderType::Sell, alpha_stake)
                             .map(|r| {
                                 let fee: u64 = U96F32::saturating_from_num(r.fee_paid)
                                     .saturating_mul(T::SwapInterface::current_alpha_price(netuid))
diff --git a/pallets/subtensor/src/staking/stake_utils.rs b/pallets/subtensor/src/staking/stake_utils.rs
index 14bf659655..4495e521c8 100644
--- a/pallets/subtensor/src/staking/stake_utils.rs
+++ b/pallets/subtensor/src/staking/stake_utils.rs
@@ -596,66 +596,6 @@ impl<T: Config> Pallet<T> {
         actual_alpha.neg().max(0).unsigned_abs()
     }
 
-    /// Calculates Some(Alpha) returned from pool by staking operation
-    /// if liquidity allows that. If not, returns None.
-    ///
-    /// If new alpha_reserve is about to drop below DefaultMinimumPoolLiquidity,
-    /// then don't do it.
-    ///
-    pub fn sim_swap_tao_for_alpha(netuid: u16, tao: u64) -> Result<SwapResult, DispatchError> {
-        // Step 1: Get the mechanism type for the subnet (0 for Stable, 1 for Dynamic)
-        let mechanism_id: u16 = SubnetMechanism::<T>::get(netuid);
-        // Step 2: Simulate swapping tao and attain alpha
-        if mechanism_id == 1 {
-            T::SwapInterface::swap(
-                netuid,
-                OrderType::Buy,
-                tao,
-                T::SwapInterface::max_price(),
-                true,
-            )
-        } else {
-            // Step 3.b.1: Stable mechanism, just return the value 1:1
-            Ok(SwapResult {
-                amount_paid_in: tao,
-                amount_paid_out: tao,
-                fee_paid: 0,
-                new_tao_reserve: 0,
-                new_alpha_reserve: 0,
-            })
-        }
-    }
-
-    /// Calculates Some(Tao) returned from pool by unstaking operation
-    /// if liquidity allows that. If not, returns None.
-    ///
-    /// If new tao_reserve is about to drop below DefaultMinimumPoolLiquidity,
-    /// then don't do it.
-    ///
-    pub fn sim_swap_alpha_for_tao(netuid: u16, alpha: u64) -> Result<SwapResult, DispatchError> {
-        // Step 1: Get the mechanism type for the subnet (0 for Stable, 1 for Dynamic)
-        let mechanism_id: u16 = SubnetMechanism::<T>::get(netuid);
-        // Step 2: Simulate swapping alpha and attain tao
-        if mechanism_id == 1 {
-            T::SwapInterface::swap(
-                netuid,
-                OrderType::Sell,
-                alpha,
-                T::SwapInterface::min_price(),
-                true,
-            )
-        } else {
-            // Step 3.b.1: Stable mechanism, just return the value 1:1
-            Ok(SwapResult {
-                amount_paid_in: alpha,
-                amount_paid_out: alpha,
-                fee_paid: 0,
-                new_tao_reserve: 0,
-                new_alpha_reserve: 0,
-            })
-        }
-    }
-
     /// Swaps TAO for the alpha token on the subnet.
     ///
     /// Updates TaoIn, AlphaIn, and AlphaOut
@@ -900,7 +840,7 @@ impl<T: Config> Pallet<T> {
         // Get the minimum balance (and amount) that satisfies the transaction
         let min_amount = {
             let min_stake = DefaultMinStake::<T>::get();
-            let fee = Self::sim_swap_tao_for_alpha(netuid, min_stake)
+            let fee = T::SwapInterface::sim_swap(netuid, OrderType::Buy, min_stake)
                 .map(|res| res.fee_paid)
                 .unwrap_or(T::SwapInterface::approx_fee_amount(netuid, min_stake));
             min_stake.saturating_add(fee)
@@ -927,7 +867,7 @@ impl<T: Config> Pallet<T> {
             Error::<T>::HotKeyAccountNotExists
         );
 
-        let expected_alpha = Self::sim_swap_tao_for_alpha(netuid, stake_to_be_added)
+        let expected_alpha = T::SwapInterface::sim_swap(netuid, OrderType::Buy, stake_to_be_added)
             .map_err(|_| Error::<T>::InsufficientLiquidity)?;
 
         ensure!(
@@ -960,7 +900,7 @@ impl<T: Config> Pallet<T> {
         ensure!(Self::if_subnet_exist(netuid), Error::<T>::SubnetNotExists);
 
         // Ensure that the stake amount to be removed is above the minimum in tao equivalent.
-        match Self::sim_swap_alpha_for_tao(netuid, alpha_unstaked) {
+        match T::SwapInterface::sim_swap(netuid, OrderType::Sell, alpha_unstaked) {
             Ok(res) => ensure!(
                 res.amount_paid_out > DefaultMinStake::<T>::get(),
                 Error::<T>::AmountTooLow
@@ -1040,7 +980,7 @@ impl<T: Config> Pallet<T> {
         );
 
         // Ensure that the stake amount to be removed is above the minimum in tao equivalent.
-        let tao_equivalent = Self::sim_swap_alpha_for_tao(origin_netuid, alpha_amount)
+        let tao_equivalent = T::SwapInterface::sim_swap(origin_netuid, OrderType::Sell, alpha_amount)
             .map(|res| res.amount_paid_out)
             .map_err(|_| Error::<T>::InsufficientLiquidity)?;
         ensure!(
diff --git a/pallets/swap-interface/src/lib.rs b/pallets/swap-interface/src/lib.rs
index 8ab9c5d1cc..5f6213e534 100644
--- a/pallets/swap-interface/src/lib.rs
+++ b/pallets/swap-interface/src/lib.rs
@@ -17,6 +17,11 @@ pub trait SwapHandler<AccountId> {
         price_limit: u64,
         should_rollback: bool,
     ) -> Result<SwapResult, DispatchError>;
+    fn sim_swap(
+        netuid: u16,
+        order_t: OrderType,
+        amount: u64,
+    ) -> Result<SwapResult, DispatchError>;
     fn approx_fee_amount(netuid: u16, amount: u64) -> u64;
     fn current_alpha_price(netuid: u16) -> U96F32;
     fn max_price() -> u64;
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 1732fa2950..a70c23f1c3 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -1055,6 +1055,26 @@ impl<T: Config> SwapHandler<T::AccountId> for Pallet<T> {
         .map_err(Into::into)
     }
 
+    fn sim_swap(netuid: u16, order_t: OrderType, amount: u64) -> Result<SwapResult, DispatchError> {
+        match T::SubnetInfo::mechanism(netuid) {
+            1 => {
+                let price_limit = match order_t {
+                    OrderType::Buy => Self::max_price(),
+                    OrderType::Sell => Self::min_price(),
+                };
+
+                Self::swap(netuid, order_t, amount, price_limit, true)
+            }
+            _ => Ok(SwapResult {
+                amount_paid_in: amount,
+                amount_paid_out: amount,
+                fee_paid: 0,
+                new_tao_reserve: 0,
+                new_alpha_reserve: 0,
+            }),
+        }
+    }
+
     fn approx_fee_amount(netuid: u16, amount: u64) -> u64 {
         Self::calculate_fee_amount(netuid.into(), amount)
     }

From 7d6dcf55e0936c367b94ef06e8b917fbe631058f Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Tue, 20 May 2025 16:47:53 +0200
Subject: [PATCH 182/418] Add RPC for current alpha price

---
 Cargo.lock                                   | 29 +++++++
 Cargo.toml                                   |  2 +
 node/Cargo.toml                              |  2 +
 node/src/rpc.rs                              |  4 +
 pallets/subtensor/src/staking/stake_utils.rs |  7 +-
 pallets/swap-interface/src/lib.rs            |  6 +-
 pallets/swap/Cargo.toml                      |  2 +
 pallets/swap/rpc/Cargo.toml                  | 24 ++++++
 pallets/swap/rpc/src/lib.rs                  | 79 ++++++++++++++++++++
 pallets/swap/runtime-api/Cargo.toml          | 22 ++++++
 pallets/swap/runtime-api/src/lib.rs          |  9 +++
 pallets/swap/src/pallet/impls.rs             | 34 +++++----
 runtime/Cargo.toml                           |  4 +
 runtime/src/lib.rs                           |  6 ++
 14 files changed, 207 insertions(+), 23 deletions(-)
 create mode 100644 pallets/swap/rpc/Cargo.toml
 create mode 100644 pallets/swap/rpc/src/lib.rs
 create mode 100644 pallets/swap/runtime-api/Cargo.toml
 create mode 100644 pallets/swap/runtime-api/src/lib.rs

diff --git a/Cargo.lock b/Cargo.lock
index f04d84623b..00dcf72db7 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5932,6 +5932,8 @@ dependencies = [
  "num-traits",
  "pallet-commitments",
  "pallet-drand",
+ "pallet-subtensor-swap-rpc",
+ "pallet-subtensor-swap-runtime-api",
  "pallet-transaction-payment",
  "pallet-transaction-payment-rpc",
  "pallet-transaction-payment-rpc-runtime-api",
@@ -6032,6 +6034,7 @@ dependencies = [
  "pallet-scheduler",
  "pallet-subtensor",
  "pallet-subtensor-swap",
+ "pallet-subtensor-swap-runtime-api",
  "pallet-sudo",
  "pallet-timestamp",
  "pallet-transaction-payment",
@@ -6059,6 +6062,7 @@ dependencies = [
  "sp-tracing 17.0.1",
  "sp-transaction-pool",
  "sp-version",
+ "substrate-fixed",
  "substrate-wasm-builder",
  "subtensor-custom-rpc-runtime-api",
  "subtensor-macros",
@@ -6890,6 +6894,7 @@ dependencies = [
  "frame-benchmarking",
  "frame-support",
  "frame-system",
+ "pallet-subtensor-swap-runtime-api",
  "parity-scale-codec",
  "safe-math",
  "scale-info",
@@ -6904,6 +6909,30 @@ dependencies = [
  "subtensor-swap-interface",
 ]
 
+[[package]]
+name = "pallet-subtensor-swap-rpc"
+version = "1.0.0"
+dependencies = [
+ "jsonrpsee",
+ "pallet-subtensor-swap-runtime-api",
+ "parity-scale-codec",
+ "sp-api",
+ "sp-blockchain",
+ "sp-runtime",
+ "substrate-fixed",
+]
+
+[[package]]
+name = "pallet-subtensor-swap-runtime-api"
+version = "1.0.0"
+dependencies = [
+ "parity-scale-codec",
+ "scale-info",
+ "sp-api",
+ "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409)",
+ "substrate-fixed",
+]
+
 [[package]]
 name = "pallet-sudo"
 version = "38.0.0"
diff --git a/Cargo.toml b/Cargo.toml
index 747d3a9c17..e56b5f1951 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -52,6 +52,8 @@ pallet-commitments = { default-features = false, path = "pallets/commitments" }
 pallet-registry = { default-features = false, path = "pallets/registry" }
 pallet-subtensor = { default-features = false, path = "pallets/subtensor" }
 pallet-subtensor-swap = { default-features = false, path = "pallets/swap" }
+pallet-subtensor-swap-runtime-api = { default-features = false, path = "pallets/swap/runtime-api" }
+pallet-subtensor-swap-rpc = { default-features = false, path = "pallets/swap/rpc" }
 safe-math = { default-features = false, path = "primitives/safe-math" }
 subtensor-custom-rpc = { default-features = false, path = "pallets/subtensor/rpc" }
 subtensor-custom-rpc-runtime-api = { default-features = false, path = "pallets/subtensor/runtime-api" }
diff --git a/node/Cargo.toml b/node/Cargo.toml
index 6cea8f6950..54be202dc5 100644
--- a/node/Cargo.toml
+++ b/node/Cargo.toml
@@ -109,6 +109,8 @@ node-subtensor-runtime = { workspace = true, features = ["std"] }
 subtensor-runtime-common = { workspace = true, features = ["std"] }
 subtensor-custom-rpc = { workspace = true, features = ["std"] }
 subtensor-custom-rpc-runtime-api = { workspace = true, features = ["std"] }
+pallet-subtensor-swap-rpc = { workspace = true, features = ["std"] }
+pallet-subtensor-swap-runtime-api = { workspace = true, features = ["std"] }
 
 [build-dependencies]
 substrate-build-script-utils = { workspace = true }
diff --git a/node/src/rpc.rs b/node/src/rpc.rs
index 0d4cd355de..a14a01ebbc 100644
--- a/node/src/rpc.rs
+++ b/node/src/rpc.rs
@@ -111,6 +111,7 @@ where
     CIDP: CreateInherentDataProviders<Block, ()> + Send + Clone + 'static,
     CT: fp_rpc::ConvertTransaction<<Block as BlockT>::Extrinsic> + Send + Sync + Clone + 'static,
 {
+    use pallet_subtensor_swap_rpc::{Swap, SwapRpcApiServer};
     use pallet_transaction_payment_rpc::{TransactionPayment, TransactionPaymentApiServer};
     use sc_consensus_manual_seal::rpc::{ManualSeal, ManualSealApiServer};
     use substrate_frame_rpc_system::{System, SystemApiServer};
@@ -127,6 +128,9 @@ where
     // Custom RPC methods for Paratensor
     module.merge(SubtensorCustom::new(client.clone()).into_rpc())?;
 
+    // Swap RPC
+    module.merge(Swap::new(client.clone()).into_rpc())?;
+
     module.merge(System::new(client.clone(), pool.clone()).into_rpc())?;
     module.merge(TransactionPayment::new(client).into_rpc())?;
 
diff --git a/pallets/subtensor/src/staking/stake_utils.rs b/pallets/subtensor/src/staking/stake_utils.rs
index 4495e521c8..af5a08d1a3 100644
--- a/pallets/subtensor/src/staking/stake_utils.rs
+++ b/pallets/subtensor/src/staking/stake_utils.rs
@@ -980,9 +980,10 @@ impl<T: Config> Pallet<T> {
         );
 
         // Ensure that the stake amount to be removed is above the minimum in tao equivalent.
-        let tao_equivalent = T::SwapInterface::sim_swap(origin_netuid, OrderType::Sell, alpha_amount)
-            .map(|res| res.amount_paid_out)
-            .map_err(|_| Error::<T>::InsufficientLiquidity)?;
+        let tao_equivalent =
+            T::SwapInterface::sim_swap(origin_netuid, OrderType::Sell, alpha_amount)
+                .map(|res| res.amount_paid_out)
+                .map_err(|_| Error::<T>::InsufficientLiquidity)?;
         ensure!(
             tao_equivalent > DefaultMinStake::<T>::get(),
             Error::<T>::AmountTooLow
diff --git a/pallets/swap-interface/src/lib.rs b/pallets/swap-interface/src/lib.rs
index 5f6213e534..c4735d7050 100644
--- a/pallets/swap-interface/src/lib.rs
+++ b/pallets/swap-interface/src/lib.rs
@@ -17,11 +17,7 @@ pub trait SwapHandler<AccountId> {
         price_limit: u64,
         should_rollback: bool,
     ) -> Result<SwapResult, DispatchError>;
-    fn sim_swap(
-        netuid: u16,
-        order_t: OrderType,
-        amount: u64,
-    ) -> Result<SwapResult, DispatchError>;
+    fn sim_swap(netuid: u16, order_t: OrderType, amount: u64) -> Result<SwapResult, DispatchError>;
     fn approx_fee_amount(netuid: u16, amount: u64) -> u64;
     fn current_alpha_price(netuid: u16) -> U96F32;
     fn max_price() -> u64;
diff --git a/pallets/swap/Cargo.toml b/pallets/swap/Cargo.toml
index 7be8c6aa6f..eca30d7b29 100644
--- a/pallets/swap/Cargo.toml
+++ b/pallets/swap/Cargo.toml
@@ -20,6 +20,7 @@ sp-runtime = { workspace = true }
 sp-std = { workspace = true }
 substrate-fixed = { workspace = true }
 
+pallet-subtensor-swap-runtime-api = { workspace = true }
 subtensor-swap-interface = { workspace = true }
 subtensor-macros = { workspace = true }
 
@@ -34,6 +35,7 @@ std = [
 	"frame-benchmarking/std",
 	"frame-support/std",
 	"frame-system/std",
+	"pallet-subtensor-swap-runtime-api/std",
 	"safe-math/std",
 	"scale-info/std",
 	"serde/std",
diff --git a/pallets/swap/rpc/Cargo.toml b/pallets/swap/rpc/Cargo.toml
new file mode 100644
index 0000000000..944c425335
--- /dev/null
+++ b/pallets/swap/rpc/Cargo.toml
@@ -0,0 +1,24 @@
+[package]
+name = "pallet-subtensor-swap-rpc"
+version = "1.0.0"
+description = "RPC interface for the Swap pallet"
+edition = { workspace = true }
+
+[dependencies]
+codec = { workspace = true }
+jsonrpsee = { workspace = true }
+sp-api = { workspace = true }
+sp-blockchain = { workspace = true }
+sp-runtime = { workspace = true }
+pallet-subtensor-swap-runtime-api = { workspace = true }
+substrate-fixed = { workspace = true }
+
+[features]
+default = ["std"]
+std = [
+	"codec/std",
+	"pallet-subtensor-swap-runtime-api/std",
+	"sp-api/std",
+	"sp-runtime/std",
+	"substrate-fixed/std",
+]
diff --git a/pallets/swap/rpc/src/lib.rs b/pallets/swap/rpc/src/lib.rs
new file mode 100644
index 0000000000..bb44371788
--- /dev/null
+++ b/pallets/swap/rpc/src/lib.rs
@@ -0,0 +1,79 @@
+//! RPC interface for the Swap pallet
+
+use std::sync::Arc;
+
+use jsonrpsee::{
+    core::RpcResult,
+    proc_macros::rpc,
+    types::{ErrorObjectOwned, error::ErrorObject},
+};
+use sp_api::ProvideRuntimeApi;
+use sp_blockchain::HeaderBackend;
+use sp_runtime::traits::Block as BlockT;
+use substrate_fixed::types::U96F32;
+
+pub use pallet_subtensor_swap_runtime_api::SwapRuntimeApi;
+
+#[rpc(client, server)]
+pub trait SwapRpcApi<BlockHash> {
+    #[method(name = "swap_currentAlphaPrice")]
+    fn current_alpha_price(&self, netuid: u16, at: Option<BlockHash>) -> RpcResult<U96F32>;
+}
+
+/// Error type of this RPC api.
+pub enum Error {
+    /// The call to runtime failed.
+    RuntimeError(String),
+}
+
+impl From<Error> for ErrorObjectOwned {
+    fn from(e: Error) -> Self {
+        match e {
+            Error::RuntimeError(e) => ErrorObject::owned(1, e, None::<()>),
+        }
+    }
+}
+
+impl From<Error> for i32 {
+    fn from(e: Error) -> i32 {
+        match e {
+            Error::RuntimeError(_) => 1,
+        }
+    }
+}
+
+/// Swap RPC implementation.
+pub struct Swap<C, Block> {
+    client: Arc<C>,
+    _marker: std::marker::PhantomData<Block>,
+}
+
+impl<C, Block> Swap<C, Block> {
+    /// Create new `Swap` instance with the given reference to the client.
+    pub fn new(client: Arc<C>) -> Self {
+        Self {
+            client,
+            _marker: Default::default(),
+        }
+    }
+}
+
+impl<C, Block> SwapRpcApiServer<<Block as BlockT>::Hash> for Swap<C, Block>
+where
+    Block: BlockT,
+    C: ProvideRuntimeApi<Block> + HeaderBackend<Block> + Send + Sync + 'static,
+    C::Api: SwapRuntimeApi<Block>,
+{
+    fn current_alpha_price(
+        &self,
+        netuid: u16,
+        at: Option<<Block as BlockT>::Hash>,
+    ) -> RpcResult<U96F32> {
+        let api = self.client.runtime_api();
+        let at = at.unwrap_or_else(|| self.client.info().best_hash);
+
+        api.current_alpha_price(at, netuid).map_err(|e| {
+            Error::RuntimeError(format!("Unable to get current alpha price: {:?}", e)).into()
+        })
+    }
+}
diff --git a/pallets/swap/runtime-api/Cargo.toml b/pallets/swap/runtime-api/Cargo.toml
new file mode 100644
index 0000000000..0a3da77ab2
--- /dev/null
+++ b/pallets/swap/runtime-api/Cargo.toml
@@ -0,0 +1,22 @@
+[package]
+name = "pallet-subtensor-swap-runtime-api"
+version = "1.0.0"
+description = "Runtime API for the Swap pallet"
+edition = { workspace = true }
+
+[dependencies]
+codec = { workspace = true }
+scale-info = { workspace = true }
+substrate-fixed = { workspace = true }
+sp-api = { workspace = true }
+sp-std = { workspace = true }
+
+[features]
+default = ["std"]
+std = [
+	"codec/std",
+	"scale-info/std",
+	"sp-api/std",
+	"sp-std/std",
+	"substrate-fixed/std",
+]
diff --git a/pallets/swap/runtime-api/src/lib.rs b/pallets/swap/runtime-api/src/lib.rs
new file mode 100644
index 0000000000..402b210613
--- /dev/null
+++ b/pallets/swap/runtime-api/src/lib.rs
@@ -0,0 +1,9 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use substrate_fixed::types::U96F32;
+
+sp_api::decl_runtime_apis! {
+    pub trait SwapRuntimeApi {
+        fn current_alpha_price(netuid: u16) -> U96F32;
+    }
+}
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index a70c23f1c3..e7e9044f5a 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -241,6 +241,24 @@ impl<T: Config> SwapStep<T> {
 }
 
 impl<T: Config> Pallet<T> {
+    pub fn current_price(netuid: NetUid) -> U96F32 {
+        match T::SubnetInfo::mechanism(netuid.into()) {
+            1 => {
+                let sqrt_price = AlphaSqrtPrice::<T>::get(NetUid::from(netuid));
+                let tao_reserve = T::SubnetInfo::tao_reserve(netuid.into());
+                let alpha_reserve = T::SubnetInfo::alpha_reserve(netuid.into());
+
+                if sqrt_price == 0 && tao_reserve > 0 && alpha_reserve > 0 {
+                    U96F32::saturating_from_num(tao_reserve)
+                        .saturating_div(U96F32::saturating_from_num(alpha_reserve))
+                } else {
+                    U96F32::saturating_from_num(sqrt_price.saturating_mul(sqrt_price))
+                }
+            }
+            _ => U96F32::saturating_from_num(1),
+        }
+    }
+
     // initializes V3 swap for a subnet if needed
     fn maybe_initialize_v3(netuid: NetUid) -> Result<(), Error<T>> {
         if SwapV3Initialized::<T>::get(netuid) {
@@ -1080,21 +1098,7 @@ impl<T: Config> SwapHandler<T::AccountId> for Pallet<T> {
     }
 
     fn current_alpha_price(netuid: u16) -> U96F32 {
-        match T::SubnetInfo::mechanism(netuid) {
-            1 => {
-                let sqrt_price = AlphaSqrtPrice::<T>::get(NetUid::from(netuid));
-                let tao_reserve = T::SubnetInfo::tao_reserve(netuid);
-                let alpha_reserve = T::SubnetInfo::alpha_reserve(netuid);
-
-                if sqrt_price == 0 && tao_reserve > 0 && alpha_reserve > 0 {
-                    U96F32::saturating_from_num(tao_reserve)
-                        .saturating_div(U96F32::saturating_from_num(alpha_reserve))
-                } else {
-                    U96F32::saturating_from_num(sqrt_price.saturating_mul(sqrt_price))
-                }
-            }
-            _ => U96F32::saturating_from_num(1),
-        }
+        Self::current_price(netuid.into())
     }
 
     fn min_price() -> u64 {
diff --git a/runtime/Cargo.toml b/runtime/Cargo.toml
index a1e26e5ac3..099e24ad7a 100644
--- a/runtime/Cargo.toml
+++ b/runtime/Cargo.toml
@@ -33,6 +33,8 @@ pallet-aura = { workspace = true }
 pallet-balances = { workspace = true }
 pallet-subtensor = { workspace = true }
 pallet-subtensor-swap = { workspace = true }
+pallet-subtensor-swap-runtime-api = { workspace = true }
+substrate-fixed = { workspace = true }
 subtensor-swap-interface = { workspace = true }
 frame-support = { workspace = true }
 pallet-grandpa = { workspace = true }
@@ -153,6 +155,8 @@ std = [
 	"frame-try-runtime/std",
 	"pallet-subtensor/std",
 	"pallet-subtensor-swap/std",
+	"pallet-subtensor-swap-runtime-api/std",
+	"substrate-fixed/std",
 	"subtensor-swap-interface/std",
 	"pallet-aura/std",
 	"pallet-balances/std",
diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index e037f31d76..a5f3fc0b90 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -2140,6 +2140,12 @@ impl_runtime_apis! {
             SubtensorModule::get_network_lock_cost()
         }
     }
+
+    impl pallet_subtensor_swap_runtime_api::SwapRuntimeApi<Block> for Runtime {
+        fn current_alpha_price(netuid: u16) -> substrate_fixed::types::U96F32 {
+            pallet_subtensor_swap::Pallet::<Runtime>::current_price(netuid.into())
+        }
+    }
 }
 
 #[test]

From b0af896b3d63618c6d8ddcad24a9c9f163568fe0 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Tue, 20 May 2025 19:01:31 +0200
Subject: [PATCH 183/418] Reformat

---
 pallets/subtensor/src/tests/staking.rs | 2 +-
 pallets/swap/src/benchmarking.rs       | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/pallets/subtensor/src/tests/staking.rs b/pallets/subtensor/src/tests/staking.rs
index a40979439a..ca942bf049 100644
--- a/pallets/subtensor/src/tests/staking.rs
+++ b/pallets/subtensor/src/tests/staking.rs
@@ -2762,7 +2762,7 @@ fn test_unstake_low_liquidity_validate() {
         let subnet_owner_hotkey = U256::from(1002);
         let hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let amount_staked = DefaultMinStake::<Test>::get() * 10 + 0; // FIXME: DefaultStakingFee is deprecated
+        let amount_staked = DefaultMinStake::<Test>::get() * 10; // FIXME: DefaultStakingFee is deprecated
 
         let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
         SubtensorModule::create_account_if_non_existent(&coldkey, &hotkey);
diff --git a/pallets/swap/src/benchmarking.rs b/pallets/swap/src/benchmarking.rs
index 133a0ef5bc..e39d9cf7e7 100644
--- a/pallets/swap/src/benchmarking.rs
+++ b/pallets/swap/src/benchmarking.rs
@@ -106,7 +106,7 @@ mod benchmarks {
             (netuid, caller.clone(), id),
             Position {
                 id,
-                netuid: netuid,
+                netuid,
                 tick_low: TickIndex::new(-10000).unwrap(),
                 tick_high: TickIndex::new(10000).unwrap(),
                 liquidity: 10000,

From 2b50e6889b3b079b48a9723e3044b1292692aee3 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Tue, 20 May 2025 19:19:34 +0200
Subject: [PATCH 184/418] Change current price to u64 in RPC

---
 Cargo.lock                          |  2 --
 pallets/swap/rpc/Cargo.toml         |  2 --
 pallets/swap/rpc/src/lib.rs         |  5 ++---
 pallets/swap/runtime-api/Cargo.toml |  2 --
 pallets/swap/runtime-api/src/lib.rs |  4 +---
 pallets/swap/src/benchmarking.rs    |  4 ++--
 runtime/src/lib.rs                  | 10 ++++++++--
 7 files changed, 13 insertions(+), 16 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 00dcf72db7..f72955a4de 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6919,7 +6919,6 @@ dependencies = [
  "sp-api",
  "sp-blockchain",
  "sp-runtime",
- "substrate-fixed",
 ]
 
 [[package]]
@@ -6930,7 +6929,6 @@ dependencies = [
  "scale-info",
  "sp-api",
  "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409)",
- "substrate-fixed",
 ]
 
 [[package]]
diff --git a/pallets/swap/rpc/Cargo.toml b/pallets/swap/rpc/Cargo.toml
index 944c425335..cc5fbc9067 100644
--- a/pallets/swap/rpc/Cargo.toml
+++ b/pallets/swap/rpc/Cargo.toml
@@ -11,7 +11,6 @@ sp-api = { workspace = true }
 sp-blockchain = { workspace = true }
 sp-runtime = { workspace = true }
 pallet-subtensor-swap-runtime-api = { workspace = true }
-substrate-fixed = { workspace = true }
 
 [features]
 default = ["std"]
@@ -20,5 +19,4 @@ std = [
 	"pallet-subtensor-swap-runtime-api/std",
 	"sp-api/std",
 	"sp-runtime/std",
-	"substrate-fixed/std",
 ]
diff --git a/pallets/swap/rpc/src/lib.rs b/pallets/swap/rpc/src/lib.rs
index bb44371788..e8fa85493d 100644
--- a/pallets/swap/rpc/src/lib.rs
+++ b/pallets/swap/rpc/src/lib.rs
@@ -10,14 +10,13 @@ use jsonrpsee::{
 use sp_api::ProvideRuntimeApi;
 use sp_blockchain::HeaderBackend;
 use sp_runtime::traits::Block as BlockT;
-use substrate_fixed::types::U96F32;
 
 pub use pallet_subtensor_swap_runtime_api::SwapRuntimeApi;
 
 #[rpc(client, server)]
 pub trait SwapRpcApi<BlockHash> {
     #[method(name = "swap_currentAlphaPrice")]
-    fn current_alpha_price(&self, netuid: u16, at: Option<BlockHash>) -> RpcResult<U96F32>;
+    fn current_alpha_price(&self, netuid: u16, at: Option<BlockHash>) -> RpcResult<u64>;
 }
 
 /// Error type of this RPC api.
@@ -68,7 +67,7 @@ where
         &self,
         netuid: u16,
         at: Option<<Block as BlockT>::Hash>,
-    ) -> RpcResult<U96F32> {
+    ) -> RpcResult<u64> {
         let api = self.client.runtime_api();
         let at = at.unwrap_or_else(|| self.client.info().best_hash);
 
diff --git a/pallets/swap/runtime-api/Cargo.toml b/pallets/swap/runtime-api/Cargo.toml
index 0a3da77ab2..d871adb651 100644
--- a/pallets/swap/runtime-api/Cargo.toml
+++ b/pallets/swap/runtime-api/Cargo.toml
@@ -7,7 +7,6 @@ edition = { workspace = true }
 [dependencies]
 codec = { workspace = true }
 scale-info = { workspace = true }
-substrate-fixed = { workspace = true }
 sp-api = { workspace = true }
 sp-std = { workspace = true }
 
@@ -18,5 +17,4 @@ std = [
 	"scale-info/std",
 	"sp-api/std",
 	"sp-std/std",
-	"substrate-fixed/std",
 ]
diff --git a/pallets/swap/runtime-api/src/lib.rs b/pallets/swap/runtime-api/src/lib.rs
index 402b210613..5db91a5a26 100644
--- a/pallets/swap/runtime-api/src/lib.rs
+++ b/pallets/swap/runtime-api/src/lib.rs
@@ -1,9 +1,7 @@
 #![cfg_attr(not(feature = "std"), no_std)]
 
-use substrate_fixed::types::U96F32;
-
 sp_api::decl_runtime_apis! {
     pub trait SwapRuntimeApi {
-        fn current_alpha_price(netuid: u16) -> U96F32;
+        fn current_alpha_price(netuid: u16) -> u64;
     }
 }
diff --git a/pallets/swap/src/benchmarking.rs b/pallets/swap/src/benchmarking.rs
index e39d9cf7e7..6f3327d00e 100644
--- a/pallets/swap/src/benchmarking.rs
+++ b/pallets/swap/src/benchmarking.rs
@@ -1,6 +1,6 @@
 //! Benchmarking setup for pallet-subtensor-swap
-#![cfg(feature = "runtime-benchmarks")]
-#![allow(clippy::arithmetic_side_effects)]
+#![allow(clippy::unwrap_used)]
+#![allow(clippy::multiple_bound_locations)]
 
 use frame_benchmarking::v2::*;
 use frame_support::traits::Get;
diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index a5f3fc0b90..c89c075bc1 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -1125,7 +1125,8 @@ parameter_types! {
     pub const SwapMaxFeeRate: u16 = 10000; // 15.26%
     pub const SwapMaxPositions: u32 = 100;
     pub const SwapMinimumLiquidity: u64 = 1_000;
-    pub const SwapMinimumReserve: NonZeroU64 = NonZeroU64::new(1_000_000).unwrap();
+    pub const SwapMinimumReserve: NonZeroU64 = NonZeroU64::new(1_000_000)
+        .expect("1_000_000 fits NonZeroU64");
 }
 
 impl pallet_subtensor_swap::Config for Runtime {
@@ -2141,9 +2142,14 @@ impl_runtime_apis! {
         }
     }
 
+
     impl pallet_subtensor_swap_runtime_api::SwapRuntimeApi<Block> for Runtime {
-        fn current_alpha_price(netuid: u16) -> substrate_fixed::types::U96F32 {
+        fn current_alpha_price(netuid: u16) -> u64 {
+            use substrate_fixed::types::U96F32;
+
             pallet_subtensor_swap::Pallet::<Runtime>::current_price(netuid.into())
+                .saturating_mul(U96F32::from_num(1_000_000_000))
+                .saturating_to_num()
         }
     }
 }

From 67a592275ab21f13b3b5e06cf8f8c10e875ee368 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Wed, 21 May 2025 17:10:24 +0200
Subject: [PATCH 185/418] Fix clippy

---
 pallets/subtensor/src/tests/move_stake.rs | 2 ++
 pallets/subtensor/src/tests/staking2.rs   | 2 ++
 pallets/swap/src/mock.rs                  | 2 ++
 pallets/swap/src/pallet/impls.rs          | 3 +++
 pallets/swap/src/tick.rs                  | 1 +
 5 files changed, 10 insertions(+)

diff --git a/pallets/subtensor/src/tests/move_stake.rs b/pallets/subtensor/src/tests/move_stake.rs
index 30186c3300..2264453a4d 100644
--- a/pallets/subtensor/src/tests/move_stake.rs
+++ b/pallets/subtensor/src/tests/move_stake.rs
@@ -1,3 +1,5 @@
+#![allow(clippy::unwrap_used)]
+
 use approx::assert_abs_diff_eq;
 use frame_support::{assert_err, assert_noop, assert_ok};
 use sp_core::{Get, U256};
diff --git a/pallets/subtensor/src/tests/staking2.rs b/pallets/subtensor/src/tests/staking2.rs
index aaf57b2e7b..e5bc16dd0a 100644
--- a/pallets/subtensor/src/tests/staking2.rs
+++ b/pallets/subtensor/src/tests/staking2.rs
@@ -1,3 +1,5 @@
+#![allow(clippy::unwrap_used)]
+
 use frame_support::{
     assert_ok,
     dispatch::{GetDispatchInfo, Pays},
diff --git a/pallets/swap/src/mock.rs b/pallets/swap/src/mock.rs
index e30c1978cc..e439f5be67 100644
--- a/pallets/swap/src/mock.rs
+++ b/pallets/swap/src/mock.rs
@@ -1,3 +1,5 @@
+#![allow(clippy::unwrap_used)]
+
 use core::num::NonZeroU64;
 
 use frame_support::construct_runtime;
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index e7e9044f5a..e3c7b3a4ed 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -1132,6 +1132,9 @@ pub enum SwapStepAction {
 }
 
 // cargo test --package pallet-subtensor-swap --lib -- pallet::impls::tests --show-output
+#[allow(clippy::unwrap_used)]
+#[allow(clippy::indexing_slicing)]
+#[allow(clippy::arithmetic_side_effects)]
 #[cfg(test)]
 mod tests {
     use approx::assert_abs_diff_eq;
diff --git a/pallets/swap/src/tick.rs b/pallets/swap/src/tick.rs
index 5d85fe1b6e..667764f63b 100644
--- a/pallets/swap/src/tick.rs
+++ b/pallets/swap/src/tick.rs
@@ -1202,6 +1202,7 @@ impl fmt::Display for TickMathError {
 
 impl Error for TickMathError {}
 
+#[allow(clippy::unwrap_used)]
 #[cfg(test)]
 mod tests {
     use safe_math::FixedExt;

From dac63e4c17f0fd5ef16055b9756702da650f69e5 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Wed, 21 May 2025 17:16:33 +0200
Subject: [PATCH 186/418] Fix zepter

---
 pallets/admin-utils/Cargo.toml | 4 +++-
 pallets/swap/Cargo.toml        | 1 +
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/pallets/admin-utils/Cargo.toml b/pallets/admin-utils/Cargo.toml
index 8c150a7e60..1390a2da13 100644
--- a/pallets/admin-utils/Cargo.toml
+++ b/pallets/admin-utils/Cargo.toml
@@ -58,6 +58,7 @@ std = [
 	"pallet-evm-chain-id/std",
 	"pallet-grandpa/std",
 	"pallet-scheduler/std",
+	"pallet-subtensor-swap/std",
 	"pallet-subtensor/std",
 	"scale-info/std",
 	"sp-consensus-aura/std",
@@ -69,7 +70,7 @@ std = [
 	"sp-tracing/std",
 	"sp-weights/std",
 	"substrate-fixed/std",
-	"pallet-subtensor-swap/std",
+	"subtensor-swap-interface/std",
 ]
 runtime-benchmarks = [
 	"frame-benchmarking/runtime-benchmarks",
@@ -80,6 +81,7 @@ runtime-benchmarks = [
 	"pallet-grandpa/runtime-benchmarks",
 	"pallet-scheduler/runtime-benchmarks",
 	"pallet-subtensor/runtime-benchmarks",
+	"pallet-subtensor-swap/runtime-benchmarks",
 	"sp-runtime/runtime-benchmarks",
 ]
 try-runtime = [
diff --git a/pallets/swap/Cargo.toml b/pallets/swap/Cargo.toml
index eca30d7b29..df7ee91686 100644
--- a/pallets/swap/Cargo.toml
+++ b/pallets/swap/Cargo.toml
@@ -51,4 +51,5 @@ runtime-benchmarks = [
 	"frame-benchmarking/runtime-benchmarks",
 	"frame-support/runtime-benchmarks",
 	"frame-system/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
 ]

From 233f856270d643e262912f579ae76723b3e29c05 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Thu, 22 May 2025 18:18:29 +0200
Subject: [PATCH 187/418] Add swap v3 switch extrinsic

---
 pallets/swap/src/benchmarking.rs |  16 ++++-
 pallets/swap/src/mock.rs         |  17 ++++-
 pallets/swap/src/pallet/impls.rs | 118 +++++++++++++++++++++++--------
 pallets/swap/src/pallet/mod.rs   |  76 +++++++++++++++++---
 pallets/swap/src/weights.rs      |  14 ++++
 5 files changed, 200 insertions(+), 41 deletions(-)

diff --git a/pallets/swap/src/benchmarking.rs b/pallets/swap/src/benchmarking.rs
index 6f3327d00e..117a2dd86f 100644
--- a/pallets/swap/src/benchmarking.rs
+++ b/pallets/swap/src/benchmarking.rs
@@ -10,8 +10,8 @@ use substrate_fixed::types::U64F64;
 use crate::{
     NetUid,
     pallet::{
-        AlphaSqrtPrice, Call, Config, CurrentLiquidity, CurrentTick, Pallet, Positions,
-        SwapV3Initialized,
+        AlphaSqrtPrice, Call, Config, CurrentLiquidity, CurrentTick, EnabledUserLiquidity, Pallet,
+        Positions, SwapV3Initialized,
     },
     position::{Position, PositionId},
     tick::TickIndex,
@@ -125,5 +125,17 @@ mod benchmarks {
         );
     }
 
+    #[benchmark]
+    fn set_enabled_user_liquidity() {
+        let netuid = NetUid::from(101);
+
+        assert!(!EnabledUserLiquidity::<T>::get(netuid));
+
+        #[extrinsic_call]
+        set_enabled_user_liquidity(RawOrigin::Root, netuid.into());
+
+        assert!(EnabledUserLiquidity::<T>::get(netuid));
+    }
+
     impl_benchmark_test_suite!(Pallet, crate::mock::new_test_ext(), crate::mock::Test);
 }
diff --git a/pallets/swap/src/mock.rs b/pallets/swap/src/mock.rs
index e439f5be67..755cf03244 100644
--- a/pallets/swap/src/mock.rs
+++ b/pallets/swap/src/mock.rs
@@ -16,6 +16,8 @@ use sp_runtime::{
 };
 use subtensor_swap_interface::{BalanceOps, SubnetInfo};
 
+use crate::{NetUid, pallet::EnabledUserLiquidity};
+
 construct_runtime!(
     pub enum Test {
         System: frame_system = 0,
@@ -27,6 +29,7 @@ pub type Block = frame_system::mocking::MockBlock<Test>;
 pub type AccountId = u32;
 pub const OK_COLDKEY_ACCOUNT_ID: AccountId = 1;
 pub const OK_HOTKEY_ACCOUNT_ID: AccountId = 1000;
+pub const NON_EXISTENT_NETUID: u16 = 999;
 
 parameter_types! {
     pub const BlockHashCount: u64 = 250;
@@ -91,7 +94,10 @@ impl SubnetInfo<AccountId> for MockLiquidityProvider {
         }
     }
 
-    fn exists(_netuid: u16) -> bool {
+    fn exists(netuid: u16) -> bool {
+        if netuid == NON_EXISTENT_NETUID {
+            return false;
+        }
         true
     }
 
@@ -165,6 +171,13 @@ pub fn new_test_ext() -> sp_io::TestExternalities {
         .build_storage()
         .unwrap();
     let mut ext = sp_io::TestExternalities::new(storage);
-    ext.execute_with(|| System::set_block_number(1));
+    ext.execute_with(|| {
+        System::set_block_number(1);
+
+        for netuid in 0u16..=100 {
+            // enable V3 for this range of netuids
+            EnabledUserLiquidity::<Test>::set(NetUid::from(netuid), true);
+        }
+    });
     ext
 }
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index e3c7b3a4ed..8d3b4ca521 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -676,6 +676,11 @@ impl<T: Config> Pallet<T> {
         tick_high: TickIndex,
         liquidity: u64,
     ) -> Result<(PositionId, u64, u64), Error<T>> {
+        ensure!(
+            EnabledUserLiquidity::<T>::get(netuid),
+            Error::<T>::UserLiquidityDisabled
+        );
+
         let (position, tao, alpha) = Self::add_liquidity_not_insert(
             netuid,
             coldkey_account_id,
@@ -747,22 +752,6 @@ impl<T: Config> Pallet<T> {
         let current_price = AlphaSqrtPrice::<T>::get(netuid);
         let (tao, alpha) = position.to_token_amounts(current_price)?;
 
-        // If this is a user transaction, withdraw balances and update reserves
-        // TODO this should be returned (tao, alpha) from this function to prevent
-        // mutation of outside storage - the logic should be passed to the user of
-        // subtensor_swap_interface
-        // if !protocol {
-        //     let current_price = self.state_ops.get_alpha_sqrt_price();
-        //     let (tao, alpha) = position.to_token_amounts(current_price)?;
-        //     self.state_ops.withdraw_balances(coldkey_account_id, tao, alpha)?;
-
-        //     // Update reserves
-        //     let new_tao_reserve = self.state_ops.get_tao_reserve().saturating_add(tao);
-        //     self.state_ops.set_tao_reserve(new_tao_reserve);
-        //     let new_alpha_reserve = self.state_ops.get_alpha_reserve().saturating_add(alpha);
-        //     self.state_ops.set_alpha_reserve(new_alpha_reserve);
-        // }
-
         SwapV3Initialized::<T>::set(netuid, true);
 
         Ok((position, tao, alpha))
@@ -776,6 +765,11 @@ impl<T: Config> Pallet<T> {
         coldkey_account_id: &T::AccountId,
         position_id: PositionId,
     ) -> Result<UpdateLiquidityResult, Error<T>> {
+        ensure!(
+            EnabledUserLiquidity::<T>::get(netuid),
+            Error::<T>::UserLiquidityDisabled
+        );
+
         let Some(mut position) = Positions::<T>::get((netuid, coldkey_account_id, position_id))
         else {
             return Err(Error::<T>::LiquidityNotFound);
@@ -801,18 +795,6 @@ impl<T: Config> Pallet<T> {
         // Remove user position
         Positions::<T>::remove((netuid, coldkey_account_id, position_id));
 
-        {
-            // TODO we move this logic to the outside depender to prevent mutating its state
-            //     // Deposit balances
-            //     self.state_ops.deposit_balances(account_id, tao, alpha);
-
-            //     // Update reserves
-            //     let new_tao_reserve = self.state_ops.get_tao_reserve().saturating_sub(tao);
-            //     self.state_ops.set_tao_reserve(new_tao_reserve);
-            //     let new_alpha_reserve = self.state_ops.get_alpha_reserve().saturating_sub(alpha);
-            //     self.state_ops.set_alpha_reserve(new_alpha_reserve);
-        }
-
         Ok(UpdateLiquidityResult {
             tao,
             alpha,
@@ -828,6 +810,11 @@ impl<T: Config> Pallet<T> {
         position_id: PositionId,
         liquidity_delta: i64,
     ) -> Result<UpdateLiquidityResult, Error<T>> {
+        ensure!(
+            EnabledUserLiquidity::<T>::get(netuid),
+            Error::<T>::UserLiquidityDisabled
+        );
+
         // Find the position
         let Some(mut position) = Positions::<T>::get((netuid, coldkey_account_id, position_id))
         else {
@@ -1138,7 +1125,7 @@ pub enum SwapStepAction {
 #[cfg(test)]
 mod tests {
     use approx::assert_abs_diff_eq;
-    use frame_support::{assert_err, assert_ok};
+    use frame_support::{assert_err, assert_noop, assert_ok};
     use sp_arithmetic::helpers_128bit;
 
     use super::*;
@@ -2441,4 +2428,77 @@ mod tests {
             }
         });
     }
+
+    #[test]
+    fn test_user_liquidity_disabled() {
+        new_test_ext().execute_with(|| {
+            // Use a netuid above 100 since our mock enables liquidity for 0-100
+            let netuid = NetUid::from(101);
+            let tick_low = TickIndex::new_unchecked(-1000);
+            let tick_high = TickIndex::new_unchecked(1000);
+            let position_id = 1;
+            let liquidity = 1_000_000_000;
+            let liquidity_delta = 500_000_000;
+
+            assert!(!EnabledUserLiquidity::<Test>::get(netuid));
+
+            assert_noop!(
+                Swap::do_add_liquidity(
+                    netuid,
+                    &OK_COLDKEY_ACCOUNT_ID,
+                    &OK_HOTKEY_ACCOUNT_ID,
+                    tick_low,
+                    tick_high,
+                    liquidity
+                ),
+                Error::<Test>::UserLiquidityDisabled
+            );
+
+            assert_noop!(
+                Swap::do_remove_liquidity(netuid, &OK_COLDKEY_ACCOUNT_ID, position_id.into()),
+                Error::<Test>::UserLiquidityDisabled
+            );
+
+            assert_noop!(
+                Swap::modify_position(
+                    RuntimeOrigin::signed(OK_COLDKEY_ACCOUNT_ID),
+                    OK_HOTKEY_ACCOUNT_ID,
+                    netuid.into(),
+                    position_id,
+                    liquidity_delta
+                ),
+                Error::<Test>::UserLiquidityDisabled
+            );
+
+            assert_ok!(Swap::set_enabled_user_liquidity(
+                RuntimeOrigin::root(),
+                netuid.into()
+            ));
+
+            let position_id = Swap::do_add_liquidity(
+                netuid,
+                &OK_COLDKEY_ACCOUNT_ID,
+                &OK_HOTKEY_ACCOUNT_ID,
+                tick_low,
+                tick_high,
+                liquidity,
+            )
+            .unwrap()
+            .0;
+
+            assert_ok!(Swap::do_modify_position(
+                netuid.into(),
+                &OK_COLDKEY_ACCOUNT_ID,
+                &OK_HOTKEY_ACCOUNT_ID,
+                position_id,
+                liquidity_delta,
+            ));
+
+            assert_ok!(Swap::do_remove_liquidity(
+                netuid.into(),
+                &OK_COLDKEY_ACCOUNT_ID,
+                position_id,
+            ));
+        });
+    }
 }
diff --git a/pallets/swap/src/pallet/mod.rs b/pallets/swap/src/pallet/mod.rs
index 082ce508fb..11245e5ebd 100644
--- a/pallets/swap/src/pallet/mod.rs
+++ b/pallets/swap/src/pallet/mod.rs
@@ -103,6 +103,12 @@ mod pallet {
     #[pallet::storage]
     pub type CurrentLiquidity<T> = StorageMap<_, Twox64Concat, NetUid, u64, ValueQuery>;
 
+    /// Indicates whether a subnet has been switched to V3 swap from V2.
+    /// If `true`, the subnet is permanently on V3 swap mode allowing add/remove liquidity
+    /// operations. Once set to `true` for a subnet, it cannot be changed back to `false`.
+    #[pallet::storage]
+    pub type EnabledUserLiquidity<T> = StorageMap<_, Twox64Concat, NetUid, bool, ValueQuery>;
+
     /// Storage for user positions, using subnet ID and account ID as keys
     /// The value is a bounded vector of Position structs with details about the liquidity positions
     #[pallet::storage]
@@ -140,6 +146,10 @@ mod pallet {
         /// Event emitted when the fee rate has been updated for a subnet
         FeeRateSet { netuid: NetUid, rate: u16 },
 
+        /// Event emitted when user liquidity operations are enabled for a subnet.
+        /// This indicates a permanent switch from V2 to V3 swap.
+        UserLiquidityEnabled { netuid: NetUid },
+
         /// Event emitted when liquidity is added to a subnet's liquidity pool.
         LiquidityAdded {
             /// The coldkey account that owns the position
@@ -215,6 +225,9 @@ mod pallet {
 
         /// The subnet does not exist.
         SubNetworkDoesNotExist,
+
+        /// User liquidity operations are disabled for this subnet
+        UserLiquidityDisabled,
     }
 
     #[pallet::call]
@@ -246,6 +259,29 @@ mod pallet {
             Ok(())
         }
 
+        /// Enable user liquidity operations for a specific subnet. This permanently switches the
+        /// subnet from V2 to V3 swap mode. Once enabled, it cannot be disabled.
+        ///
+        /// Only callable by the admin origin
+        #[pallet::call_index(4)]
+        #[pallet::weight(<T as pallet::Config>::WeightInfo::set_enabled_user_liquidity())]
+        pub fn set_enabled_user_liquidity(origin: OriginFor<T>, netuid: u16) -> DispatchResult {
+            T::AdminOrigin::ensure_origin(origin)?;
+
+            ensure!(
+                T::SubnetInfo::exists(netuid),
+                Error::<T>::SubNetworkDoesNotExist
+            );
+
+            let netuid = netuid.into();
+
+            EnabledUserLiquidity::<T>::insert(netuid, true);
+
+            Self::deposit_event(Event::UserLiquidityEnabled { netuid });
+
+            Ok(())
+        }
+
         /// Add liquidity to a specific price range for a subnet.
         ///
         /// Parameters:
@@ -445,12 +481,14 @@ mod pallet {
 
 #[cfg(test)]
 mod tests {
+    use frame_support::{assert_noop, assert_ok};
+    use sp_runtime::DispatchError;
+
     use crate::{
         NetUid,
         mock::*,
-        pallet::{Error, FeeRate, Pallet as SwapModule},
+        pallet::{EnabledUserLiquidity, Error, FeeRate},
     };
-    use frame_support::{assert_noop, assert_ok};
 
     #[test]
     fn test_set_fee_rate() {
@@ -460,11 +498,7 @@ mod tests {
             let fee_rate = 500; // 0.76% fee
 
             // Set fee rate (requires admin/root origin)
-            assert_ok!(SwapModule::<Test>::set_fee_rate(
-                RuntimeOrigin::root(),
-                netuid,
-                fee_rate
-            ));
+            assert_ok!(Swap::set_fee_rate(RuntimeOrigin::root(), netuid, fee_rate));
 
             // Check that fee rate was set correctly
             let netuid_struct = NetUid::from(netuid);
@@ -473,9 +507,35 @@ mod tests {
             // Verify fee rate validation - should fail if too high
             let too_high_fee = MaxFeeRate::get() + 1;
             assert_noop!(
-                SwapModule::<Test>::set_fee_rate(RuntimeOrigin::root(), netuid, too_high_fee),
+                Swap::set_fee_rate(RuntimeOrigin::root(), netuid, too_high_fee),
                 Error::<Test>::FeeRateTooHigh
             );
         });
     }
+
+    #[test]
+    fn test_set_enabled_user_liquidity() {
+        new_test_ext().execute_with(|| {
+            let netuid = NetUid::from(101);
+
+            assert!(!EnabledUserLiquidity::<Test>::get(netuid));
+
+            assert_ok!(Swap::set_enabled_user_liquidity(
+                RuntimeOrigin::root(),
+                netuid.into()
+            ));
+
+            assert!(EnabledUserLiquidity::<Test>::get(netuid));
+
+            assert_noop!(
+                Swap::set_enabled_user_liquidity(RuntimeOrigin::signed(1), netuid.into()),
+                DispatchError::BadOrigin
+            );
+
+            assert_noop!(
+                Swap::set_enabled_user_liquidity(RuntimeOrigin::root(), NON_EXISTENT_NETUID),
+                Error::<Test>::SubNetworkDoesNotExist
+            );
+        });
+    }
 }
diff --git a/pallets/swap/src/weights.rs b/pallets/swap/src/weights.rs
index 7577383d19..045bd551cc 100644
--- a/pallets/swap/src/weights.rs
+++ b/pallets/swap/src/weights.rs
@@ -18,6 +18,7 @@ pub trait WeightInfo {
     fn add_liquidity() -> Weight;
     fn remove_liquidity() -> Weight;
     fn modify_position() -> Weight;
+    fn set_enabled_user_liquidity() -> Weight;
 }
 
 /// Default weights for pallet_subtensor_swap.
@@ -50,6 +51,13 @@ impl<T: frame_system::Config> WeightInfo for DefaultWeight<T> {
             .saturating_add(T::DbWeight::get().reads(4))
             .saturating_add(T::DbWeight::get().writes(4))
     }
+
+    fn set_enabled_user_liquidity() -> Weight {
+        // Conservative weight estimate: one read and one write
+        Weight::from_parts(10_000_000, 0)
+            .saturating_add(T::DbWeight::get().reads(1))
+            .saturating_add(T::DbWeight::get().writes(1))
+    }
 }
 
 // For backwards compatibility and tests
@@ -77,4 +85,10 @@ impl WeightInfo for () {
             .saturating_add(RocksDbWeight::get().reads(4))
             .saturating_add(RocksDbWeight::get().writes(4))
     }
+
+    fn set_enabled_user_liquidity() -> Weight {
+        Weight::from_parts(10_000_000, 0)
+            .saturating_add(RocksDbWeight::get().reads(1))
+            .saturating_add(RocksDbWeight::get().writes(1))
+    }
 }

From f5600db7b7bb12192d7c76be9f8ed73115880093 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Thu, 22 May 2025 16:58:51 -0400
Subject: [PATCH 188/418] Tests for stake_into_subnet and unstake_from_subnet

---
 pallets/subtensor/src/tests/staking.rs | 324 +++++++++++++++++++++++++
 1 file changed, 324 insertions(+)

diff --git a/pallets/subtensor/src/tests/staking.rs b/pallets/subtensor/src/tests/staking.rs
index ca942bf049..fd608085d9 100644
--- a/pallets/subtensor/src/tests/staking.rs
+++ b/pallets/subtensor/src/tests/staking.rs
@@ -11,6 +11,7 @@ use sp_core::{Get, H256, U256};
 use substrate_fixed::traits::FromFixed;
 use substrate_fixed::types::{I96F32, I110F18, U64F64, U96F32};
 use subtensor_swap_interface::{OrderType, SwapHandler};
+use pallet_subtensor_swap::NetUid;
 
 use super::mock;
 use super::mock::*;
@@ -4424,3 +4425,326 @@ fn test_unstake_all_works() {
         assert!(new_balance > 100_000);
     });
 }
+
+#[test]
+fn test_stake_into_subnet_ok() {
+    new_test_ext(1).execute_with(|| {
+        let owner_hotkey = U256::from(1);
+        let owner_coldkey = U256::from(2);
+        let hotkey = U256::from(3);
+        let coldkey = U256::from(4);
+        let amount = 100_000_000;
+
+        // add network
+        let netuid: u16 = add_dynamic_network(&owner_hotkey, &owner_coldkey);
+
+        // Forse-set alpha in and tao reserve to make price equal 0.01
+        let tao_reserve = U96F32::from_num(100_000_000_000_u64);
+        let alpha_in = U96F32::from_num(1_000_000_000_000_u64);
+        mock::setup_reserves(netuid, tao_reserve.to_num(), alpha_in.to_num());
+        let current_price = <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid).to_num::<f64>();
+
+        // Initialize swap v3
+        assert_ok!(<tests::mock::Test as pallet::Config>::SwapInterface::swap(netuid, OrderType::Buy, 0, 0, true));
+
+        // Add stake with slippage safety and check if the result is ok
+        assert_ok!(SubtensorModule::stake_into_subnet(
+            &hotkey,
+            &coldkey,
+            netuid,
+            amount,
+            u64::MAX,
+        ));
+        let expected_stake = (amount as f64) * 0.997 / current_price;
+
+        // Check if stake has increased
+        assert_abs_diff_eq!(
+            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+                &hotkey,
+                &coldkey,
+                netuid
+            ) as f64,
+            expected_stake,
+            epsilon = expected_stake / 1000.,
+        );
+    });
+}
+
+#[test]
+fn test_stake_into_subnet_low_amount() {
+    new_test_ext(1).execute_with(|| {
+        let owner_hotkey = U256::from(1);
+        let owner_coldkey = U256::from(2);
+        let hotkey = U256::from(3);
+        let coldkey = U256::from(4);
+        let amount = 10;
+
+        // add network
+        let netuid: u16 = add_dynamic_network(&owner_hotkey, &owner_coldkey);
+
+        // Forse-set alpha in and tao reserve to make price equal 0.01
+        let tao_reserve = U96F32::from_num(100_000_000_000_u64);
+        let alpha_in = U96F32::from_num(1_000_000_000_000_u64);
+        mock::setup_reserves(netuid, tao_reserve.to_num(), alpha_in.to_num());
+        let current_price = <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid).to_num::<f64>();
+
+        // Initialize swap v3
+        assert_ok!(<tests::mock::Test as pallet::Config>::SwapInterface::swap(netuid, OrderType::Buy, 0, 0, true));
+
+        // Add stake with slippage safety and check if the result is ok
+        assert_ok!(SubtensorModule::stake_into_subnet(
+            &hotkey,
+            &coldkey,
+            netuid,
+            amount,
+            u64::MAX,
+        ));
+        let expected_stake = ((amount as f64) * 0.997 / current_price) as u64;
+
+        // Check if stake has increased
+        assert_abs_diff_eq!(
+            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+                &hotkey,
+                &coldkey,
+                netuid
+            ) as u64,
+            expected_stake,
+            epsilon = expected_stake / 100,
+        );
+    });
+}
+
+#[test]
+fn test_unstake_from_subnet_low_amount() {
+    new_test_ext(1).execute_with(|| {
+        let owner_hotkey = U256::from(1);
+        let owner_coldkey = U256::from(2);
+        let hotkey = U256::from(3);
+        let coldkey = U256::from(4);
+        let amount = 10;
+
+        // add network
+        let netuid: u16 = add_dynamic_network(&owner_hotkey, &owner_coldkey);
+
+        // Forse-set alpha in and tao reserve to make price equal 0.01
+        let tao_reserve = U96F32::from_num(100_000_000_000_u64);
+        let alpha_in = U96F32::from_num(1_000_000_000_000_u64);
+        mock::setup_reserves(netuid, tao_reserve.to_num(), alpha_in.to_num());
+
+        // Initialize swap v3
+        assert_ok!(<tests::mock::Test as pallet::Config>::SwapInterface::swap(netuid, OrderType::Buy, 0, 0, true));
+
+        // Add stake and check if the result is ok
+        assert_ok!(SubtensorModule::stake_into_subnet(
+            &hotkey,
+            &coldkey,
+            netuid,
+            amount,
+            u64::MAX,
+        ));
+
+        // Remove stake
+        let alpha = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+            &hotkey,
+            &coldkey,
+            netuid
+        );
+        assert_ok!(SubtensorModule::unstake_from_subnet(
+            &hotkey,
+            &coldkey,
+            netuid,
+            alpha,
+            u64::MIN,
+        ));
+
+        // Check if stake is zero
+        assert_eq!(
+            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+                &hotkey,
+                &coldkey,
+                netuid
+            ),
+            0,
+        );
+    });
+}
+
+#[test]
+fn test_stake_into_subnet_prohibitive_limit() {
+    new_test_ext(1).execute_with(|| {
+        let owner_hotkey = U256::from(1);
+        let owner_coldkey = U256::from(2);
+        let coldkey = U256::from(4);
+        let amount = 100_000_000;
+
+        // add network
+        let netuid: u16 = add_dynamic_network(&owner_hotkey, &owner_coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, amount);
+
+        // Forse-set alpha in and tao reserve to make price equal 0.01
+        let tao_reserve = U96F32::from_num(100_000_000_000_u64);
+        let alpha_in = U96F32::from_num(1_000_000_000_000_u64);
+        mock::setup_reserves(netuid, tao_reserve.to_num(), alpha_in.to_num());
+
+        // Initialize swap v3
+        assert_ok!(<tests::mock::Test as pallet::Config>::SwapInterface::swap(netuid, OrderType::Buy, 0, 0, true));
+
+        // Add stake and check if the result is ok
+        // Use prohibitive limit price
+        assert_ok!(SubtensorModule::add_stake_limit(
+            RuntimeOrigin::signed(coldkey),
+            owner_hotkey,
+            netuid,
+            amount,
+            u64::MIN,
+            true,
+        ));
+
+        // Check if stake has NOT increased
+        assert_eq!(
+            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+                &owner_hotkey,
+                &coldkey,
+                netuid
+            ),
+            0_u64
+        );
+
+        // Check if balance has NOT decreased
+        assert_eq!(
+            SubtensorModule::get_coldkey_balance(&coldkey),
+            amount
+        );
+    });
+}
+
+#[test]
+fn test_unstake_from_subnet_prohibitive_limit() {
+    new_test_ext(1).execute_with(|| {
+        let owner_hotkey = U256::from(1);
+        let owner_coldkey = U256::from(2);
+        let coldkey = U256::from(4);
+        let amount = 100_000_000;
+
+        // add network
+        let netuid: u16 = add_dynamic_network(&owner_hotkey, &owner_coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, amount);
+
+        // Forse-set alpha in and tao reserve to make price equal 0.01
+        let tao_reserve = U96F32::from_num(100_000_000_000_u64);
+        let alpha_in = U96F32::from_num(1_000_000_000_000_u64);
+        mock::setup_reserves(netuid, tao_reserve.to_num(), alpha_in.to_num());
+
+        // Initialize swap v3
+        assert_ok!(<tests::mock::Test as pallet::Config>::SwapInterface::swap(netuid, OrderType::Buy, 0, 0, true));
+
+        // Add stake and check if the result is ok
+        assert_ok!(SubtensorModule::stake_into_subnet(
+            &owner_hotkey,
+            &coldkey,
+            netuid,
+            amount,
+            u64::MAX,
+        ));
+
+        // Remove stake
+        // Use prohibitive limit price
+        let balance_before = SubtensorModule::get_coldkey_balance(&coldkey);
+        let alpha = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+            &owner_hotkey,
+            &coldkey,
+            netuid
+        );
+        assert_ok!(SubtensorModule::remove_stake_limit(
+            RuntimeOrigin::signed(coldkey),
+            owner_hotkey,
+            netuid,
+            alpha,
+            u64::MAX,
+            true,
+        ));
+
+        // Check if stake has NOT decreased
+        assert_eq!(
+            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+                &owner_hotkey,
+                &coldkey,
+                netuid
+            ),
+            alpha
+        );
+
+        // Check if balance has NOT increased
+        assert_eq!(
+            SubtensorModule::get_coldkey_balance(&coldkey),
+            balance_before,
+        );
+    });
+}
+
+#[test]
+fn test_unstake_full_amount() {
+    new_test_ext(1).execute_with(|| {
+        let owner_hotkey = U256::from(1);
+        let owner_coldkey = U256::from(2);
+        let coldkey = U256::from(4);
+        let amount = 100_000_000;
+
+        // add network
+        let netuid: u16 = add_dynamic_network(&owner_hotkey, &owner_coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, amount);
+
+        // Forse-set alpha in and tao reserve to make price equal 0.01
+        let tao_reserve = U96F32::from_num(100_000_000_000_u64);
+        let alpha_in = U96F32::from_num(1_000_000_000_000_u64);
+        mock::setup_reserves(netuid, tao_reserve.to_num(), alpha_in.to_num());
+
+        // Initialize swap v3
+        assert_ok!(<tests::mock::Test as pallet::Config>::SwapInterface::swap(netuid, OrderType::Buy, 0, 0, true));
+
+        // Add stake and check if the result is ok
+        assert_ok!(SubtensorModule::stake_into_subnet(
+            &owner_hotkey,
+            &coldkey,
+            netuid,
+            amount,
+            u64::MAX,
+        ));
+
+        // Remove stake
+        // Use prohibitive limit price
+        let balance_before = SubtensorModule::get_coldkey_balance(&coldkey);
+        let alpha = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+            &owner_hotkey,
+            &coldkey,
+            netuid
+        );
+        assert_ok!(SubtensorModule::remove_stake(
+            RuntimeOrigin::signed(coldkey),
+            owner_hotkey,
+            netuid,
+            alpha,
+        ));
+
+        // Check if stake is zero
+        assert_eq!(
+            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+                &owner_hotkey,
+                &coldkey,
+                netuid
+            ),
+            0
+        );
+
+        // Check if balance has increased accordingly
+        let balance_after = SubtensorModule::get_coldkey_balance(&coldkey);
+        let actual_balance_increase = (balance_after - balance_before) as f64;
+        let fee_rate = pallet_subtensor_swap::FeeRate::<Test>::get(NetUid::from(netuid)) as f64 / u16::MAX as f64;
+        let expected_balance_increase = amount as f64 * (1. - fee_rate) / (1. + fee_rate);
+        assert_abs_diff_eq!(
+            actual_balance_increase,
+            expected_balance_increase,
+            epsilon = expected_balance_increase / 10_000.
+        );
+    });
+}
\ No newline at end of file

From 5505242ff2e0ce2d48b765fdce556a8a947697e7 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Sun, 25 May 2025 23:39:32 +0800
Subject: [PATCH 189/418] change the default registration to 0.1 TAO

---
 runtime/src/lib.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index 95b032f9e6..48a45fd416 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -209,7 +209,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
     //   `spec_version`, and `authoring_version` are the same between Wasm and native.
     // This value is set to 100 to notify Polkadot-JS App (https://polkadot.js.org/apps) to use
     //   the compatible custom types.
-    spec_version: 272,
+    spec_version: 273,
     impl_version: 1,
     apis: RUNTIME_API_VERSIONS,
     transaction_version: 1,
@@ -1065,7 +1065,7 @@ parameter_types! {
     pub const SubtensorInitialMinDifficulty: u64 = 10_000_000;
     pub const SubtensorInitialMaxDifficulty: u64 = u64::MAX / 4;
     pub const SubtensorInitialServingRateLimit: u64 = 50;
-    pub const SubtensorInitialBurn: u64 = 1_000_000_000; // 1 tao
+    pub const SubtensorInitialBurn: u64 = 100_000_000; // 0.1 tao
     pub const SubtensorInitialMinBurn: u64 = 500_000; // 500k RAO
     pub const SubtensorInitialMaxBurn: u64 = 100_000_000_000; // 100 tao
     pub const SubtensorInitialTxRateLimit: u64 = 1000;

From 842108c7578f6dba6f6340384e47eedb4c2e5165 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Mon, 26 May 2025 08:24:26 +0800
Subject: [PATCH 190/418] allow axon ip as 0

---
 pallets/subtensor/src/subnets/serving.rs | 18 +++++-----------
 pallets/subtensor/src/tests/serving.rs   | 27 ++++++++++++++++--------
 2 files changed, 23 insertions(+), 22 deletions(-)

diff --git a/pallets/subtensor/src/subnets/serving.rs b/pallets/subtensor/src/subnets/serving.rs
index c8c89bc011..bee81bfae6 100644
--- a/pallets/subtensor/src/subnets/serving.rs
+++ b/pallets/subtensor/src/subnets/serving.rs
@@ -172,7 +172,7 @@ impl<T: Config> Pallet<T> {
         // Check the ip signature validity.
         ensure!(Self::is_valid_ip_type(ip_type), Error::<T>::InvalidIpType);
         ensure!(
-            Self::is_valid_ip_address(ip_type, ip),
+            Self::is_valid_ip_address(ip_type, ip, false),
             Error::<T>::InvalidIpAddress
         );
 
@@ -276,17 +276,11 @@ impl<T: Config> Pallet<T> {
     }
 
     // @todo (Parallax 2-1-2021) : Implement exclusion of private IP ranges
-    pub fn is_valid_ip_address(ip_type: u8, addr: u128) -> bool {
-        if !Self::is_valid_ip_type(ip_type) {
-            return false;
-        }
-        if addr == 0 {
+    pub fn is_valid_ip_address(ip_type: u8, addr: u128, allow_zero: bool) -> bool {
+        if !allow_zero && addr == 0 {
             return false;
         }
         if ip_type == 4 {
-            if addr == 0 {
-                return false;
-            }
             if addr >= u32::MAX as u128 {
                 return false;
             }
@@ -295,9 +289,6 @@ impl<T: Config> Pallet<T> {
             } // Localhost
         }
         if ip_type == 6 {
-            if addr == 0x0 {
-                return false;
-            }
             if addr == u128::MAX {
                 return false;
             }
@@ -346,7 +337,8 @@ impl<T: Config> Pallet<T> {
         // Check the ip signature validity.
         ensure!(Self::is_valid_ip_type(ip_type), Error::<T>::InvalidIpType);
         ensure!(
-            Self::is_valid_ip_address(ip_type, ip),
+            // allow axon to be served with a zero ip address for testing purposes
+            Self::is_valid_ip_address(ip_type, ip, true),
             Error::<T>::InvalidIpAddress
         );
 
diff --git a/pallets/subtensor/src/tests/serving.rs b/pallets/subtensor/src/tests/serving.rs
index 251dde2078..269d70485b 100644
--- a/pallets/subtensor/src/tests/serving.rs
+++ b/pallets/subtensor/src/tests/serving.rs
@@ -555,7 +555,8 @@ fn test_serving_is_valid_ip_address_ipv4() {
     new_test_ext(1).execute_with(|| {
         assert!(SubtensorModule::is_valid_ip_address(
             4,
-            test::ipv4(8, 8, 8, 8)
+            test::ipv4(8, 8, 8, 8),
+            false
         ));
     });
 }
@@ -565,11 +566,13 @@ fn test_serving_is_valid_ip_address_ipv6() {
     new_test_ext(1).execute_with(|| {
         assert!(SubtensorModule::is_valid_ip_address(
             6,
-            test::ipv6(1, 2, 3, 4, 5, 6, 7, 8)
+            test::ipv6(1, 2, 3, 4, 5, 6, 7, 8),
+            false
         ));
         assert!(SubtensorModule::is_valid_ip_address(
             6,
-            test::ipv6(1, 2, 3, 4, 5, 6, 7, 8)
+            test::ipv6(1, 2, 3, 4, 5, 6, 7, 8),
+            false
         ));
     });
 }
@@ -579,19 +582,23 @@ fn test_serving_is_invalid_ipv4_address() {
     new_test_ext(1).execute_with(|| {
         assert!(!SubtensorModule::is_valid_ip_address(
             4,
-            test::ipv4(0, 0, 0, 0)
+            test::ipv4(0, 0, 0, 0),
+            false
         ));
         assert!(!SubtensorModule::is_valid_ip_address(
             4,
-            test::ipv4(255, 255, 255, 255)
+            test::ipv4(255, 255, 255, 255),
+            false
         ));
         assert!(!SubtensorModule::is_valid_ip_address(
             4,
-            test::ipv4(127, 0, 0, 1)
+            test::ipv4(127, 0, 0, 1),
+            false
         ));
         assert!(!SubtensorModule::is_valid_ip_address(
             4,
-            test::ipv6(0xffff, 2, 3, 4, 5, 6, 7, 8)
+            test::ipv6(0xffff, 2, 3, 4, 5, 6, 7, 8),
+            false
         ));
     });
 }
@@ -601,13 +608,15 @@ fn test_serving_is_invalid_ipv6_address() {
     new_test_ext(1).execute_with(|| {
         assert!(!SubtensorModule::is_valid_ip_address(
             6,
-            test::ipv6(0, 0, 0, 0, 0, 0, 0, 0)
+            test::ipv6(0, 0, 0, 0, 0, 0, 0, 0),
+            false
         ));
         assert!(!SubtensorModule::is_valid_ip_address(
             4,
             test::ipv6(
                 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff
-            )
+            ),
+            false
         ));
     });
 }

From 493832fd6891e5bb9eb4756a160b9308eeb18f5d Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Mon, 26 May 2025 08:38:08 +0800
Subject: [PATCH 191/418] add more tests

---
 pallets/subtensor/src/tests/serving.rs | 33 ++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/pallets/subtensor/src/tests/serving.rs b/pallets/subtensor/src/tests/serving.rs
index 269d70485b..6711862a6b 100644
--- a/pallets/subtensor/src/tests/serving.rs
+++ b/pallets/subtensor/src/tests/serving.rs
@@ -558,6 +558,12 @@ fn test_serving_is_valid_ip_address_ipv4() {
             test::ipv4(8, 8, 8, 8),
             false
         ));
+
+        assert!(SubtensorModule::is_valid_ip_address(
+            4,
+            test::ipv4(0, 0, 0, 0),
+            true
+        ));
     });
 }
 
@@ -574,6 +580,11 @@ fn test_serving_is_valid_ip_address_ipv6() {
             test::ipv6(1, 2, 3, 4, 5, 6, 7, 8),
             false
         ));
+        assert!(SubtensorModule::is_valid_ip_address(
+            6,
+            test::ipv6(0, 0, 0, 0, 0, 0, 0, 0),
+            true
+        ));
     });
 }
 
@@ -600,6 +611,21 @@ fn test_serving_is_invalid_ipv4_address() {
             test::ipv6(0xffff, 2, 3, 4, 5, 6, 7, 8),
             false
         ));
+        assert!(!SubtensorModule::is_valid_ip_address(
+            4,
+            test::ipv4(255, 255, 255, 255),
+            true
+        ));
+        assert!(!SubtensorModule::is_valid_ip_address(
+            4,
+            test::ipv4(127, 0, 0, 1),
+            true
+        ));
+        assert!(!SubtensorModule::is_valid_ip_address(
+            4,
+            test::ipv6(0xffff, 2, 3, 4, 5, 6, 7, 8),
+            true
+        ));
     });
 }
 
@@ -618,6 +644,13 @@ fn test_serving_is_invalid_ipv6_address() {
             ),
             false
         ));
+        assert!(!SubtensorModule::is_valid_ip_address(
+            4,
+            test::ipv6(
+                0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff
+            ),
+            true
+        ));
     });
 }
 

From f27d15565434ecfc8beb2929503c03e59e91f6f5 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Mon, 26 May 2025 13:18:15 +0800
Subject: [PATCH 192/418] update version

---
 runtime/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index 95b032f9e6..5e099d1ce2 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -209,7 +209,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
     //   `spec_version`, and `authoring_version` are the same between Wasm and native.
     // This value is set to 100 to notify Polkadot-JS App (https://polkadot.js.org/apps) to use
     //   the compatible custom types.
-    spec_version: 272,
+    spec_version: 273,
     impl_version: 1,
     apis: RUNTIME_API_VERSIONS,
     transaction_version: 1,

From ed156ab41774afd54f6061dc99e4e56dbb95e99d Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Mon, 26 May 2025 17:06:36 +0200
Subject: [PATCH 193/418] Fix origin check in swap pallet

---
 pallets/admin-utils/src/tests/mock.rs |  1 -
 pallets/subtensor/src/lib.rs          |  4 +++
 pallets/subtensor/src/tests/mock.rs   |  1 -
 pallets/swap-interface/src/lib.rs     |  1 +
 pallets/swap/src/mock.rs              | 13 ++++----
 pallets/swap/src/pallet/mod.rs        | 45 +++++++++++++++++++++------
 runtime/src/lib.rs                    |  1 -
 7 files changed, 47 insertions(+), 19 deletions(-)

diff --git a/pallets/admin-utils/src/tests/mock.rs b/pallets/admin-utils/src/tests/mock.rs
index 57d086b538..e72c77a0fb 100644
--- a/pallets/admin-utils/src/tests/mock.rs
+++ b/pallets/admin-utils/src/tests/mock.rs
@@ -274,7 +274,6 @@ parameter_types! {
 
 impl pallet_subtensor_swap::Config for Test {
     type RuntimeEvent = RuntimeEvent;
-    type AdminOrigin = EnsureRoot<AccountId>;
     type SubnetInfo = SubtensorModule;
     type BalanceOps = SubtensorModule;
     type ProtocolId = SwapProtocolId;
diff --git a/pallets/subtensor/src/lib.rs b/pallets/subtensor/src/lib.rs
index cb5c4bb0a8..15b2dfe7fb 100644
--- a/pallets/subtensor/src/lib.rs
+++ b/pallets/subtensor/src/lib.rs
@@ -2439,6 +2439,10 @@ impl<T: Config + pallet_balances::Config<Balance = u64>>
     fn mechanism(netuid: u16) -> u16 {
         SubnetMechanism::<T>::get(netuid)
     }
+
+    fn is_owner(account_id: &T::AccountId, netuid: u16) -> bool {
+        SubnetOwner::<T>::get(netuid) == *account_id
+    }
 }
 
 impl<T: Config + pallet_balances::Config<Balance = u64>>
diff --git a/pallets/subtensor/src/tests/mock.rs b/pallets/subtensor/src/tests/mock.rs
index 1f30b115ef..4dd4ff202a 100644
--- a/pallets/subtensor/src/tests/mock.rs
+++ b/pallets/subtensor/src/tests/mock.rs
@@ -430,7 +430,6 @@ parameter_types! {
 
 impl pallet_subtensor_swap::Config for Test {
     type RuntimeEvent = RuntimeEvent;
-    type AdminOrigin = EnsureRoot<AccountId>;
     type SubnetInfo = SubtensorModule;
     type BalanceOps = SubtensorModule;
     type ProtocolId = SwapProtocolId;
diff --git a/pallets/swap-interface/src/lib.rs b/pallets/swap-interface/src/lib.rs
index c4735d7050..78d80a8e1b 100644
--- a/pallets/swap-interface/src/lib.rs
+++ b/pallets/swap-interface/src/lib.rs
@@ -47,6 +47,7 @@ pub trait SubnetInfo<AccountId> {
     fn alpha_reserve(netuid: u16) -> u64;
     fn exists(netuid: u16) -> bool;
     fn mechanism(netuid: u16) -> u16;
+    fn is_owner(account_id: &AccountId, netuid: u16) -> bool;
 }
 
 pub trait BalanceOps<AccountId> {
diff --git a/pallets/swap/src/mock.rs b/pallets/swap/src/mock.rs
index 755cf03244..9c9e9bc1ce 100644
--- a/pallets/swap/src/mock.rs
+++ b/pallets/swap/src/mock.rs
@@ -8,7 +8,7 @@ use frame_support::{
     PalletId, parameter_types,
     traits::{ConstU32, Everything},
 };
-use frame_system::{self as system, EnsureRoot};
+use frame_system::{self as system};
 use sp_core::H256;
 use sp_runtime::{
     BuildStorage,
@@ -29,6 +29,7 @@ pub type Block = frame_system::mocking::MockBlock<Test>;
 pub type AccountId = u32;
 pub const OK_COLDKEY_ACCOUNT_ID: AccountId = 1;
 pub const OK_HOTKEY_ACCOUNT_ID: AccountId = 1000;
+pub const NOT_SUBNET_OWNER: AccountId = 666;
 pub const NON_EXISTENT_NETUID: u16 = 999;
 
 parameter_types! {
@@ -95,15 +96,16 @@ impl SubnetInfo<AccountId> for MockLiquidityProvider {
     }
 
     fn exists(netuid: u16) -> bool {
-        if netuid == NON_EXISTENT_NETUID {
-            return false;
-        }
-        true
+        netuid != NON_EXISTENT_NETUID
     }
 
     fn mechanism(netuid: u16) -> u16 {
         if netuid == 0 { 0 } else { 1 }
     }
+
+    fn is_owner(account_id: &AccountId, _netuid: u16) -> bool {
+        *account_id != NOT_SUBNET_OWNER
+    }
 }
 
 pub struct MockBalanceOps;
@@ -154,7 +156,6 @@ impl BalanceOps<AccountId> for MockBalanceOps {
 
 impl crate::pallet::Config for Test {
     type RuntimeEvent = RuntimeEvent;
-    type AdminOrigin = EnsureRoot<AccountId>;
     type SubnetInfo = MockLiquidityProvider;
     type BalanceOps = MockBalanceOps;
     type ProtocolId = SwapProtocolId;
diff --git a/pallets/swap/src/pallet/mod.rs b/pallets/swap/src/pallet/mod.rs
index 11245e5ebd..f506174101 100644
--- a/pallets/swap/src/pallet/mod.rs
+++ b/pallets/swap/src/pallet/mod.rs
@@ -20,6 +20,7 @@ mod impls;
 #[frame_support::pallet]
 mod pallet {
     use super::*;
+    use frame_system::{ensure_root, ensure_signed};
 
     #[pallet::pallet]
     pub struct Pallet<T>(_);
@@ -30,9 +31,6 @@ mod pallet {
         /// Because this pallet emits events, it depends on the runtime's definition of an event.
         type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
 
-        /// The origin which may configure the swap parameters
-        type AdminOrigin: EnsureOrigin<Self::RuntimeOrigin>;
-
         /// Implementor of
         /// [`SubnetInfo`](subtensor_swap_interface::SubnetInfo).
         type SubnetInfo: SubnetInfo<Self::AccountId>;
@@ -239,7 +237,13 @@ mod pallet {
         #[pallet::call_index(0)]
         #[pallet::weight(<T as pallet::Config>::WeightInfo::set_fee_rate())]
         pub fn set_fee_rate(origin: OriginFor<T>, netuid: u16, rate: u16) -> DispatchResult {
-            T::AdminOrigin::ensure_origin(origin)?;
+            if ensure_root(origin.clone()).is_err() {
+                let account_id: T::AccountId = ensure_signed(origin)?;
+                ensure!(
+                    T::SubnetInfo::is_owner(&account_id, netuid),
+                    DispatchError::BadOrigin
+                );
+            }
 
             // Ensure that the subnet exists.
             ensure!(
@@ -266,7 +270,13 @@ mod pallet {
         #[pallet::call_index(4)]
         #[pallet::weight(<T as pallet::Config>::WeightInfo::set_enabled_user_liquidity())]
         pub fn set_enabled_user_liquidity(origin: OriginFor<T>, netuid: u16) -> DispatchResult {
-            T::AdminOrigin::ensure_origin(origin)?;
+            if ensure_root(origin.clone()).is_err() {
+                let account_id: T::AccountId = ensure_signed(origin)?;
+                ensure!(
+                    T::SubnetInfo::is_owner(&account_id, netuid),
+                    DispatchError::BadOrigin
+                );
+            }
 
             ensure!(
                 T::SubnetInfo::exists(netuid),
@@ -493,16 +503,26 @@ mod tests {
     #[test]
     fn test_set_fee_rate() {
         new_test_ext().execute_with(|| {
-            // Create a test subnet
             let netuid = 1u16;
             let fee_rate = 500; // 0.76% fee
 
-            // Set fee rate (requires admin/root origin)
+            assert_noop!(
+                Swap::set_fee_rate(RuntimeOrigin::signed(666), netuid.into(), fee_rate),
+                DispatchError::BadOrigin
+            );
+
             assert_ok!(Swap::set_fee_rate(RuntimeOrigin::root(), netuid, fee_rate));
 
             // Check that fee rate was set correctly
-            let netuid_struct = NetUid::from(netuid);
-            assert_eq!(FeeRate::<Test>::get(netuid_struct), fee_rate);
+            assert_eq!(FeeRate::<Test>::get(NetUid::from(netuid)), fee_rate);
+
+            let fee_rate = fee_rate * 2;
+            assert_ok!(Swap::set_fee_rate(
+                RuntimeOrigin::signed(1),
+                netuid,
+                fee_rate
+            ));
+            assert_eq!(FeeRate::<Test>::get(NetUid::from(netuid)), fee_rate);
 
             // Verify fee rate validation - should fail if too high
             let too_high_fee = MaxFeeRate::get() + 1;
@@ -528,10 +548,15 @@ mod tests {
             assert!(EnabledUserLiquidity::<Test>::get(netuid));
 
             assert_noop!(
-                Swap::set_enabled_user_liquidity(RuntimeOrigin::signed(1), netuid.into()),
+                Swap::set_enabled_user_liquidity(RuntimeOrigin::signed(666), netuid.into()),
                 DispatchError::BadOrigin
             );
 
+            assert_ok!(Swap::set_enabled_user_liquidity(
+                RuntimeOrigin::signed(1),
+                netuid.into()
+            ));
+
             assert_noop!(
                 Swap::set_enabled_user_liquidity(RuntimeOrigin::root(), NON_EXISTENT_NETUID),
                 Error::<Test>::SubNetworkDoesNotExist
diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index c89c075bc1..b6b0e4c0f7 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -1131,7 +1131,6 @@ parameter_types! {
 
 impl pallet_subtensor_swap::Config for Runtime {
     type RuntimeEvent = RuntimeEvent;
-    type AdminOrigin = EnsureRoot<AccountId>;
     type SubnetInfo = SubtensorModule;
     type BalanceOps = SubtensorModule;
     type ProtocolId = SwapProtocolId;

From 32852901c8d1d6509e3e578ad9a55e8b9beeef76 Mon Sep 17 00:00:00 2001
From: kenobijon <kenjonmiyachi@gmail.com>
Date: Mon, 26 May 2025 20:45:02 -0500
Subject: [PATCH 194/418] alpha precompiles

---
 Cargo.lock                         |   1 +
 pallets/admin-utils/src/lib.rs     |   2 +
 precompiles/Cargo.toml             |   2 +-
 precompiles/src/alpha.rs           | 126 +++++++++++++++
 precompiles/src/lib.rs             |   8 +-
 precompiles/src/solidity/alpha.abi | 247 +++++++++++++++++++++++++++++
 precompiles/src/solidity/alpha.sol |  70 ++++++++
 7 files changed, 454 insertions(+), 2 deletions(-)
 create mode 100644 precompiles/src/alpha.rs
 create mode 100644 precompiles/src/solidity/alpha.abi
 create mode 100644 precompiles/src/solidity/alpha.sol

diff --git a/Cargo.lock b/Cargo.lock
index b0c56ffb2e..1fb1812260 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -11079,6 +11079,7 @@ dependencies = [
  "sp-core",
  "sp-runtime",
  "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7)",
+ "substrate-fixed",
  "subtensor-runtime-common",
 ]
 
diff --git a/pallets/admin-utils/src/lib.rs b/pallets/admin-utils/src/lib.rs
index 2b41539816..d3fcc4d671 100644
--- a/pallets/admin-utils/src/lib.rs
+++ b/pallets/admin-utils/src/lib.rs
@@ -113,6 +113,8 @@ pub mod pallet {
         Neuron,
         /// Enum for UID lookup precompile
         UidLookup,
+        /// Enum for alpha precompile
+        Alpha,
     }
 
     #[pallet::type_value]
diff --git a/precompiles/Cargo.toml b/precompiles/Cargo.toml
index ec46e6aee2..c1455d2781 100644
--- a/precompiles/Cargo.toml
+++ b/precompiles/Cargo.toml
@@ -27,7 +27,7 @@ sp-core = { workspace = true }
 sp-runtime = { workspace = true }
 sp-std = { workspace = true }
 subtensor-runtime-common = { workspace = true }
-
+substrate-fixed = { workspace = true }
 pallet-subtensor = { workspace = true }
 pallet-admin-utils = { workspace = true }
 
diff --git a/precompiles/src/alpha.rs b/precompiles/src/alpha.rs
new file mode 100644
index 0000000000..ca21ffa842
--- /dev/null
+++ b/precompiles/src/alpha.rs
@@ -0,0 +1,126 @@
+use core::marker::PhantomData;
+
+use pallet_evm::PrecompileHandle;
+use precompile_utils::EvmResult;
+use sp_core::U256;
+use substrate_fixed::types::U96F32;
+
+use crate::PrecompileExt;
+
+pub struct AlphaPrecompile<R>(PhantomData<R>);
+
+impl<R> PrecompileExt<R::AccountId> for AlphaPrecompile<R>
+where
+    R: frame_system::Config + pallet_subtensor::Config,
+    R::AccountId: From<[u8; 32]>,
+{
+    const INDEX: u64 = 2054;
+}
+
+#[precompile_utils::precompile]
+impl<R> AlphaPrecompile<R>
+where
+    R: frame_system::Config + pallet_subtensor::Config,
+{
+    #[precompile::public("getAlphaPrice(uint16)")]
+    #[precompile::view]
+    fn get_alpha_price(_handle: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<U256> {
+        let price: U96F32 = pallet_subtensor::Pallet::<R>::get_alpha_price(netuid);
+        Ok(U256::from(price.saturating_to_num::<u64>()))
+    }
+
+    #[precompile::public("getMovingAlphaPrice(uint16)")]
+    #[precompile::view]
+    fn get_moving_alpha_price(_handle: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<U256> {
+        let price: U96F32 = pallet_subtensor::Pallet::<R>::get_moving_alpha_price(netuid);
+        Ok(U256::from(price.saturating_to_num::<u64>()))
+    }
+
+    #[precompile::public("getTaoInPool(uint16)")]
+    #[precompile::view]
+    fn get_tao_in_pool(_handle: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<u64> {
+        Ok(pallet_subtensor::SubnetTAO::<R>::get(netuid))
+    }
+
+    #[precompile::public("getAlphaInPool(uint16)")]
+    #[precompile::view]
+    fn get_alpha_in_pool(_handle: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<u64> {
+        Ok(pallet_subtensor::SubnetAlphaIn::<R>::get(netuid))
+    }
+
+    #[precompile::public("getAlphaOutPool(uint16)")]
+    #[precompile::view]
+    fn get_alpha_out_pool(_handle: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<u64> {
+        Ok(pallet_subtensor::SubnetAlphaOut::<R>::get(netuid))
+    }
+
+    #[precompile::public("getAlphaIssuance(uint16)")]
+    #[precompile::view]
+    fn get_alpha_issuance(_handle: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<u64> {
+        Ok(pallet_subtensor::Pallet::<R>::get_alpha_issuance(netuid))
+    }
+
+    #[precompile::public("getTaoWeight()")]
+    #[precompile::view]
+    fn get_tao_weight(_handle: &mut impl PrecompileHandle) -> EvmResult<U256> {
+        let weight: U96F32 = pallet_subtensor::Pallet::<R>::get_tao_weight();
+        Ok(U256::from(weight.saturating_to_num::<u64>()))
+    }
+
+    #[precompile::public("simSwapTaoForAlpha(uint16,uint64)")]
+    #[precompile::view]
+    fn sim_swap_tao_for_alpha(
+        _handle: &mut impl PrecompileHandle,
+        netuid: u16,
+        tao: u64,
+    ) -> EvmResult<U256> {
+        let alpha_option = pallet_subtensor::Pallet::<R>::sim_swap_tao_for_alpha(netuid, tao);
+        let result = match alpha_option {
+            Some(alpha) => alpha,
+            None => 0,
+        };
+        Ok(U256::from(result))
+    }
+
+    #[precompile::public("simSwapAlphaForTao(uint16,uint64)")]
+    #[precompile::view]
+    fn sim_swap_alpha_for_tao(
+        _handle: &mut impl PrecompileHandle,
+        netuid: u16,
+        alpha: u64,
+    ) -> EvmResult<U256> {
+        let tao_option = pallet_subtensor::Pallet::<R>::sim_swap_alpha_for_tao(netuid, alpha);
+        let result = match tao_option {
+            Some(tao) => tao,
+            None => 0,
+        };
+        Ok(U256::from(result))
+    }
+
+    #[precompile::public("getSubnetMechanism(uint16)")]
+    #[precompile::view]
+    fn get_subnet_mechanism(_handle: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<u16> {
+        Ok(pallet_subtensor::SubnetMechanism::<R>::get(netuid))
+    }
+
+    #[precompile::public("getRootNetuid()")]
+    #[precompile::view]
+    fn get_root_netuid(_handle: &mut impl PrecompileHandle) -> EvmResult<u16> {
+        Ok(pallet_subtensor::Pallet::<R>::get_root_netuid())
+    }
+
+    #[precompile::public("getEMAPriceHalvingBlocks(uint16)")]
+    #[precompile::view]
+    fn get_ema_price_halving_blocks(
+        _handle: &mut impl PrecompileHandle,
+        netuid: u16,
+    ) -> EvmResult<u64> {
+        Ok(pallet_subtensor::EMAPriceHalvingBlocks::<R>::get(netuid))
+    }
+
+    #[precompile::public("getSubnetVolume(uint16)")]
+    #[precompile::view]
+    fn get_subnet_volume(_handle: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<U256> {
+        Ok(U256::from(pallet_subtensor::SubnetVolume::<R>::get(netuid)))
+    }
+}
diff --git a/precompiles/src/lib.rs b/precompiles/src/lib.rs
index 4c6824e07b..4153f76b6d 100644
--- a/precompiles/src/lib.rs
+++ b/precompiles/src/lib.rs
@@ -19,6 +19,7 @@ use subtensor_runtime_common::ProxyType;
 
 use pallet_admin_utils::PrecompileEnum;
 
+use crate::alpha::*;
 use crate::balance_transfer::*;
 use crate::ed25519::*;
 use crate::extensions::*;
@@ -28,6 +29,7 @@ use crate::staking::*;
 use crate::subnet::*;
 use crate::uid_lookup::*;
 
+mod alpha;
 mod balance_transfer;
 mod ed25519;
 mod extensions;
@@ -86,7 +88,7 @@ where
         Self(Default::default())
     }
 
-    pub fn used_addresses() -> [H160; 15] {
+    pub fn used_addresses() -> [H160; 16] {
         [
             hash(1),
             hash(2),
@@ -103,6 +105,7 @@ where
             hash(NeuronPrecompile::<R>::INDEX),
             hash(StakingPrecompileV2::<R>::INDEX),
             hash(UidLookupPrecompile::<R>::INDEX),
+            hash(AlphaPrecompile::<R>::INDEX),
         ]
     }
 }
@@ -164,6 +167,9 @@ where
             a if a == hash(UidLookupPrecompile::<R>::INDEX) => {
                 UidLookupPrecompile::<R>::try_execute::<R>(handle, PrecompileEnum::UidLookup)
             }
+            a if a == hash(AlphaPrecompile::<R>::INDEX) => {
+                AlphaPrecompile::<R>::try_execute::<R>(handle, PrecompileEnum::Alpha)
+            }
             _ => None,
         }
     }
diff --git a/precompiles/src/solidity/alpha.abi b/precompiles/src/solidity/alpha.abi
new file mode 100644
index 0000000000..feb2b518af
--- /dev/null
+++ b/precompiles/src/solidity/alpha.abi
@@ -0,0 +1,247 @@
+[
+  {
+    "inputs": [
+      {
+        "internalType": "uint16",
+        "name": "netuid",
+        "type": "uint16"
+      }
+    ],
+    "name": "getAlphaPrice",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint16",
+        "name": "netuid",
+        "type": "uint16"
+      }
+    ],
+    "name": "getMovingAlphaPrice",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint16",
+        "name": "netuid",
+        "type": "uint16"
+      }
+    ],
+    "name": "getTaoInPool",
+    "outputs": [
+      {
+        "internalType": "uint64",
+        "name": "",
+        "type": "uint64"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint16",
+        "name": "netuid",
+        "type": "uint16"
+      }
+    ],
+    "name": "getAlphaInPool",
+    "outputs": [
+      {
+        "internalType": "uint64",
+        "name": "",
+        "type": "uint64"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint16",
+        "name": "netuid",
+        "type": "uint16"
+      }
+    ],
+    "name": "getAlphaOutPool",
+    "outputs": [
+      {
+        "internalType": "uint64",
+        "name": "",
+        "type": "uint64"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint16",
+        "name": "netuid",
+        "type": "uint16"
+      }
+    ],
+    "name": "getAlphaIssuance",
+    "outputs": [
+      {
+        "internalType": "uint64",
+        "name": "",
+        "type": "uint64"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "getTaoWeight",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint16",
+        "name": "netuid",
+        "type": "uint16"
+      },
+      {
+        "internalType": "uint64",
+        "name": "tao",
+        "type": "uint64"
+      }
+    ],
+    "name": "simSwapTaoForAlpha",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint16",
+        "name": "netuid",
+        "type": "uint16"
+      },
+      {
+        "internalType": "uint64",
+        "name": "alpha",
+        "type": "uint64"
+      }
+    ],
+    "name": "simSwapAlphaForTao",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint16",
+        "name": "netuid",
+        "type": "uint16"
+      }
+    ],
+    "name": "getSubnetMechanism",
+    "outputs": [
+      {
+        "internalType": "uint16",
+        "name": "",
+        "type": "uint16"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "getRootNetuid",
+    "outputs": [
+      {
+        "internalType": "uint16",
+        "name": "",
+        "type": "uint16"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint16",
+        "name": "netuid",
+        "type": "uint16"
+      }
+    ],
+    "name": "getEMAPriceHalvingBlocks",
+    "outputs": [
+      {
+        "internalType": "uint64",
+        "name": "",
+        "type": "uint64"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint16",
+        "name": "netuid",
+        "type": "uint16"
+      }
+    ],
+    "name": "getSubnetVolume",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  }
+]
\ No newline at end of file
diff --git a/precompiles/src/solidity/alpha.sol b/precompiles/src/solidity/alpha.sol
new file mode 100644
index 0000000000..622757df78
--- /dev/null
+++ b/precompiles/src/solidity/alpha.sol
@@ -0,0 +1,70 @@
+pragma solidity ^0.8.0;
+
+address constant IALPHA_ADDRESS = 0x0000000000000000000000000000000000000806;
+
+interface IAlpha {
+    /// @dev Returns the current alpha price for a subnet.
+    /// @param netuid The subnet identifier.
+    /// @return The alpha price in RAO per alpha.
+    function getAlphaPrice(uint16 netuid) external view returns (uint256);
+
+    /// @dev Returns the moving (EMA) alpha price for a subnet.
+    /// @param netuid The subnet identifier.
+    /// @return The moving alpha price in RAO per alpha.
+    function getMovingAlphaPrice(uint16 netuid) external view returns (uint256);
+
+    /// @dev Returns the amount of TAO in the pool for a subnet.
+    /// @param netuid The subnet identifier.
+    /// @return The TAO amount in the pool.
+    function getTaoInPool(uint16 netuid) external view returns (uint64);
+
+    /// @dev Returns the amount of alpha in the pool for a subnet.
+    /// @param netuid The subnet identifier.
+    /// @return The alpha amount in the pool.
+    function getAlphaInPool(uint16 netuid) external view returns (uint64);
+
+    /// @dev Returns the amount of alpha outside the pool for a subnet.
+    /// @param netuid The subnet identifier.
+    /// @return The alpha amount outside the pool.
+    function getAlphaOutPool(uint16 netuid) external view returns (uint64);
+
+    /// @dev Returns the total alpha issuance for a subnet.
+    /// @param netuid The subnet identifier.
+    /// @return The total alpha issuance.
+    function getAlphaIssuance(uint16 netuid) external view returns (uint64);
+
+    /// @dev Returns the global TAO weight.
+    /// @return The TAO weight value.
+    function getTaoWeight() external view returns (uint256);
+
+    /// @dev Simulates swapping TAO for alpha.
+    /// @param netuid The subnet identifier.
+    /// @param tao The amount of TAO to swap.
+    /// @return The amount of alpha that would be received.
+    function simSwapTaoForAlpha(uint16 netuid, uint64 tao) external view returns (uint256);
+
+    /// @dev Simulates swapping alpha for TAO.
+    /// @param netuid The subnet identifier.
+    /// @param alpha The amount of alpha to swap.
+    /// @return The amount of TAO that would be received.
+    function simSwapAlphaForTao(uint16 netuid, uint64 alpha) external view returns (uint256);
+
+    /// @dev Returns the mechanism type for a subnet (0 for Stable, 1 for Dynamic).
+    /// @param netuid The subnet identifier.
+    /// @return The subnet mechanism type.
+    function getSubnetMechanism(uint16 netuid) external view returns (uint16);
+
+    /// @dev Returns the root subnet unique identifier.
+    /// @return The root subnet ID.
+    function getRootNetuid() external view returns (uint16);
+
+    /// @dev Returns the EMA price halving blocks parameter for a subnet.
+    /// @param netuid The subnet identifier.
+    /// @return The number of blocks for EMA price halving.
+    function getEMAPriceHalvingBlocks(uint16 netuid) external view returns (uint64);
+
+    /// @dev Returns the transaction volume for a subnet.
+    /// @param netuid The subnet identifier.
+    /// @return The subnet volume.
+    function getSubnetVolume(uint16 netuid) external view returns (uint256);
+}
\ No newline at end of file

From dbd845e13a730900eef74ed01d816f6189081142 Mon Sep 17 00:00:00 2001
From: kenobijon <kenjonmiyachi@gmail.com>
Date: Mon, 26 May 2025 22:01:22 -0500
Subject: [PATCH 195/418] Fixes linting errors and feature propagation for
 substrate-fixed

---
 precompiles/Cargo.toml   |  1 +
 precompiles/src/alpha.rs | 10 ++--------
 2 files changed, 3 insertions(+), 8 deletions(-)

diff --git a/precompiles/Cargo.toml b/precompiles/Cargo.toml
index c1455d2781..5bc8a094d6 100644
--- a/precompiles/Cargo.toml
+++ b/precompiles/Cargo.toml
@@ -54,5 +54,6 @@ std = [
 	"sp-core/std",
 	"sp-runtime/std",
 	"sp-std/std",
+	"substrate-fixed/std",
 	"subtensor-runtime-common/std",
 ]
diff --git a/precompiles/src/alpha.rs b/precompiles/src/alpha.rs
index ca21ffa842..1f01883d40 100644
--- a/precompiles/src/alpha.rs
+++ b/precompiles/src/alpha.rs
@@ -75,10 +75,7 @@ where
         tao: u64,
     ) -> EvmResult<U256> {
         let alpha_option = pallet_subtensor::Pallet::<R>::sim_swap_tao_for_alpha(netuid, tao);
-        let result = match alpha_option {
-            Some(alpha) => alpha,
-            None => 0,
-        };
+        let result = alpha_option.unwrap_or(0);
         Ok(U256::from(result))
     }
 
@@ -90,10 +87,7 @@ where
         alpha: u64,
     ) -> EvmResult<U256> {
         let tao_option = pallet_subtensor::Pallet::<R>::sim_swap_alpha_for_tao(netuid, alpha);
-        let result = match tao_option {
-            Some(tao) => tao,
-            None => 0,
-        };
+        let result = tao_option.unwrap_or(0);
         Ok(U256::from(result))
     }
 

From d9cdec0de082bd7d504a9fa7df5659f341caac96 Mon Sep 17 00:00:00 2001
From: kenobijon <kenjonmiyachi@gmail.com>
Date: Tue, 27 May 2025 01:13:18 -0500
Subject: [PATCH 196/418] basic unit functions

---
 evm-tests/package-lock.json             | 546 ++++++++++++++----------
 evm-tests/package.json                  |   4 +-
 evm-tests/src/contracts/alpha.ts        | 249 +++++++++++
 evm-tests/test/alpha.precompile.test.ts | 428 +++++++++++++++++++
 precompiles/src/alpha.rs                |   2 +-
 precompiles/src/solidity/alpha.sol      |   4 +-
 6 files changed, 1007 insertions(+), 226 deletions(-)
 create mode 100644 evm-tests/src/contracts/alpha.ts
 create mode 100644 evm-tests/test/alpha.precompile.test.ts

diff --git a/evm-tests/package-lock.json b/evm-tests/package-lock.json
index ce2766fb4e..9e318e9a24 100644
--- a/evm-tests/package-lock.json
+++ b/evm-tests/package-lock.json
@@ -6,6 +6,7 @@
     "": {
       "license": "ISC",
       "dependencies": {
+        "@polkadot-api/descriptors": "file:.papi/descriptors",
         "@polkadot-labs/hdkd": "^0.0.10",
         "@polkadot-labs/hdkd-helpers": "^0.0.11",
         "@polkadot/api": "15.1.1",
@@ -16,7 +17,8 @@
         "mocha": "^11.1.0",
         "polkadot-api": "^1.9.5",
         "scale-ts": "^1.6.1",
-        "viem": "2.23.4"
+        "viem": "2.23.4",
+        "ws": "^8.18.2"
       },
       "devDependencies": {
         "@types/bun": "^1.1.13",
@@ -31,10 +33,9 @@
     },
     ".papi/descriptors": {
       "name": "@polkadot-api/descriptors",
-      "version": "0.1.0-autogenerated.7914363913476982777",
-      "extraneous": true,
+      "version": "0.1.0-autogenerated.3055518094912556806",
       "peerDependencies": {
-        "polkadot-api": "*"
+        "polkadot-api": ">=1.11.2"
       }
     },
     "node_modules/@adraffy/ens-normalize": {
@@ -44,23 +45,23 @@
       "license": "MIT"
     },
     "node_modules/@babel/code-frame": {
-      "version": "7.26.2",
-      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.26.2.tgz",
-      "integrity": "sha512-RJlIHRueQgwWitWgF8OdFYGZX328Ax5BCemNGlqHfplnRT9ESi8JkFlvaVYbS+UubVY6dpv87Fs2u5M29iNFVQ==",
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.27.1.tgz",
+      "integrity": "sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-validator-identifier": "^7.25.9",
+        "@babel/helper-validator-identifier": "^7.27.1",
         "js-tokens": "^4.0.0",
-        "picocolors": "^1.0.0"
+        "picocolors": "^1.1.1"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/helper-validator-identifier": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.25.9.tgz",
-      "integrity": "sha512-Ed61U6XJc3CVRfkERJWDz4dJwKe7iLmmJsbOGu9wSloNSFttHV0I8g6UAgb7qnK5ly5bGLPd4oXZlxCdANBOWQ==",
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.27.1.tgz",
+      "integrity": "sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow==",
       "license": "MIT",
       "engines": {
         "node": ">=6.9.0"
@@ -89,9 +90,9 @@
       }
     },
     "node_modules/@esbuild/aix-ppc64": {
-      "version": "0.25.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.2.tgz",
-      "integrity": "sha512-wCIboOL2yXZym2cgm6mlA742s9QeJ8DjGVaL39dLN4rRwrOgOyYSnOaFPhKZGLb2ngj4EyfAFjsNJwPXZvseag==",
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.5.tgz",
+      "integrity": "sha512-9o3TMmpmftaCMepOdA5k/yDw8SfInyzWWTjYTFCX3kPSDJMROQTb8jg+h9Cnwnmm1vOzvxN7gIfB5V2ewpjtGA==",
       "cpu": [
         "ppc64"
       ],
@@ -105,9 +106,9 @@
       }
     },
     "node_modules/@esbuild/android-arm": {
-      "version": "0.25.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.2.tgz",
-      "integrity": "sha512-NQhH7jFstVY5x8CKbcfa166GoV0EFkaPkCKBQkdPJFvo5u+nGXLEH/ooniLb3QI8Fk58YAx7nsPLozUWfCBOJA==",
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.5.tgz",
+      "integrity": "sha512-AdJKSPeEHgi7/ZhuIPtcQKr5RQdo6OO2IL87JkianiMYMPbCtot9fxPbrMiBADOWWm3T2si9stAiVsGbTQFkbA==",
       "cpu": [
         "arm"
       ],
@@ -121,9 +122,9 @@
       }
     },
     "node_modules/@esbuild/android-arm64": {
-      "version": "0.25.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.2.tgz",
-      "integrity": "sha512-5ZAX5xOmTligeBaeNEPnPaeEuah53Id2tX4c2CVP3JaROTH+j4fnfHCkr1PjXMd78hMst+TlkfKcW/DlTq0i4w==",
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.5.tgz",
+      "integrity": "sha512-VGzGhj4lJO+TVGV1v8ntCZWJktV7SGCs3Pn1GRWI1SBFtRALoomm8k5E9Pmwg3HOAal2VDc2F9+PM/rEY6oIDg==",
       "cpu": [
         "arm64"
       ],
@@ -137,9 +138,9 @@
       }
     },
     "node_modules/@esbuild/android-x64": {
-      "version": "0.25.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.2.tgz",
-      "integrity": "sha512-Ffcx+nnma8Sge4jzddPHCZVRvIfQ0kMsUsCMcJRHkGJ1cDmhe4SsrYIjLUKn1xpHZybmOqCWwB0zQvsjdEHtkg==",
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.5.tgz",
+      "integrity": "sha512-D2GyJT1kjvO//drbRT3Hib9XPwQeWd9vZoBJn+bu/lVsOZ13cqNdDeqIF/xQ5/VmWvMduP6AmXvylO/PIc2isw==",
       "cpu": [
         "x64"
       ],
@@ -153,9 +154,9 @@
       }
     },
     "node_modules/@esbuild/darwin-arm64": {
-      "version": "0.25.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.2.tgz",
-      "integrity": "sha512-MpM6LUVTXAzOvN4KbjzU/q5smzryuoNjlriAIx+06RpecwCkL9JpenNzpKd2YMzLJFOdPqBpuub6eVRP5IgiSA==",
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.5.tgz",
+      "integrity": "sha512-GtaBgammVvdF7aPIgH2jxMDdivezgFu6iKpmT+48+F8Hhg5J/sfnDieg0aeG/jfSvkYQU2/pceFPDKlqZzwnfQ==",
       "cpu": [
         "arm64"
       ],
@@ -169,9 +170,9 @@
       }
     },
     "node_modules/@esbuild/darwin-x64": {
-      "version": "0.25.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.2.tgz",
-      "integrity": "sha512-5eRPrTX7wFyuWe8FqEFPG2cU0+butQQVNcT4sVipqjLYQjjh8a8+vUTfgBKM88ObB85ahsnTwF7PSIt6PG+QkA==",
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.5.tgz",
+      "integrity": "sha512-1iT4FVL0dJ76/q1wd7XDsXrSW+oLoquptvh4CLR4kITDtqi2e/xwXwdCVH8hVHU43wgJdsq7Gxuzcs6Iq/7bxQ==",
       "cpu": [
         "x64"
       ],
@@ -185,9 +186,9 @@
       }
     },
     "node_modules/@esbuild/freebsd-arm64": {
-      "version": "0.25.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.2.tgz",
-      "integrity": "sha512-mLwm4vXKiQ2UTSX4+ImyiPdiHjiZhIaE9QvC7sw0tZ6HoNMjYAqQpGyui5VRIi5sGd+uWq940gdCbY3VLvsO1w==",
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.5.tgz",
+      "integrity": "sha512-nk4tGP3JThz4La38Uy/gzyXtpkPW8zSAmoUhK9xKKXdBCzKODMc2adkB2+8om9BDYugz+uGV7sLmpTYzvmz6Sw==",
       "cpu": [
         "arm64"
       ],
@@ -201,9 +202,9 @@
       }
     },
     "node_modules/@esbuild/freebsd-x64": {
-      "version": "0.25.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.2.tgz",
-      "integrity": "sha512-6qyyn6TjayJSwGpm8J9QYYGQcRgc90nmfdUb0O7pp1s4lTY+9D0H9O02v5JqGApUyiHOtkz6+1hZNvNtEhbwRQ==",
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.5.tgz",
+      "integrity": "sha512-PrikaNjiXdR2laW6OIjlbeuCPrPaAl0IwPIaRv+SMV8CiM8i2LqVUHFC1+8eORgWyY7yhQY+2U2fA55mBzReaw==",
       "cpu": [
         "x64"
       ],
@@ -217,9 +218,9 @@
       }
     },
     "node_modules/@esbuild/linux-arm": {
-      "version": "0.25.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.2.tgz",
-      "integrity": "sha512-UHBRgJcmjJv5oeQF8EpTRZs/1knq6loLxTsjc3nxO9eXAPDLcWW55flrMVc97qFPbmZP31ta1AZVUKQzKTzb0g==",
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.5.tgz",
+      "integrity": "sha512-cPzojwW2okgh7ZlRpcBEtsX7WBuqbLrNXqLU89GxWbNt6uIg78ET82qifUy3W6OVww6ZWobWub5oqZOVtwolfw==",
       "cpu": [
         "arm"
       ],
@@ -233,9 +234,9 @@
       }
     },
     "node_modules/@esbuild/linux-arm64": {
-      "version": "0.25.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.2.tgz",
-      "integrity": "sha512-gq/sjLsOyMT19I8obBISvhoYiZIAaGF8JpeXu1u8yPv8BE5HlWYobmlsfijFIZ9hIVGYkbdFhEqC0NvM4kNO0g==",
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.5.tgz",
+      "integrity": "sha512-Z9kfb1v6ZlGbWj8EJk9T6czVEjjq2ntSYLY2cw6pAZl4oKtfgQuS4HOq41M/BcoLPzrUbNd+R4BXFyH//nHxVg==",
       "cpu": [
         "arm64"
       ],
@@ -249,9 +250,9 @@
       }
     },
     "node_modules/@esbuild/linux-ia32": {
-      "version": "0.25.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.2.tgz",
-      "integrity": "sha512-bBYCv9obgW2cBP+2ZWfjYTU+f5cxRoGGQ5SeDbYdFCAZpYWrfjjfYwvUpP8MlKbP0nwZ5gyOU/0aUzZ5HWPuvQ==",
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.5.tgz",
+      "integrity": "sha512-sQ7l00M8bSv36GLV95BVAdhJ2QsIbCuCjh/uYrWiMQSUuV+LpXwIqhgJDcvMTj+VsQmqAHL2yYaasENvJ7CDKA==",
       "cpu": [
         "ia32"
       ],
@@ -265,9 +266,9 @@
       }
     },
     "node_modules/@esbuild/linux-loong64": {
-      "version": "0.25.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.2.tgz",
-      "integrity": "sha512-SHNGiKtvnU2dBlM5D8CXRFdd+6etgZ9dXfaPCeJtz+37PIUlixvlIhI23L5khKXs3DIzAn9V8v+qb1TRKrgT5w==",
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.5.tgz",
+      "integrity": "sha512-0ur7ae16hDUC4OL5iEnDb0tZHDxYmuQyhKhsPBV8f99f6Z9KQM02g33f93rNH5A30agMS46u2HP6qTdEt6Q1kg==",
       "cpu": [
         "loong64"
       ],
@@ -281,9 +282,9 @@
       }
     },
     "node_modules/@esbuild/linux-mips64el": {
-      "version": "0.25.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.2.tgz",
-      "integrity": "sha512-hDDRlzE6rPeoj+5fsADqdUZl1OzqDYow4TB4Y/3PlKBD0ph1e6uPHzIQcv2Z65u2K0kpeByIyAjCmjn1hJgG0Q==",
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.5.tgz",
+      "integrity": "sha512-kB/66P1OsHO5zLz0i6X0RxlQ+3cu0mkxS3TKFvkb5lin6uwZ/ttOkP3Z8lfR9mJOBk14ZwZ9182SIIWFGNmqmg==",
       "cpu": [
         "mips64el"
       ],
@@ -297,9 +298,9 @@
       }
     },
     "node_modules/@esbuild/linux-ppc64": {
-      "version": "0.25.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.2.tgz",
-      "integrity": "sha512-tsHu2RRSWzipmUi9UBDEzc0nLc4HtpZEI5Ba+Omms5456x5WaNuiG3u7xh5AO6sipnJ9r4cRWQB2tUjPyIkc6g==",
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.5.tgz",
+      "integrity": "sha512-UZCmJ7r9X2fe2D6jBmkLBMQetXPXIsZjQJCjgwpVDz+YMcS6oFR27alkgGv3Oqkv07bxdvw7fyB71/olceJhkQ==",
       "cpu": [
         "ppc64"
       ],
@@ -313,9 +314,9 @@
       }
     },
     "node_modules/@esbuild/linux-riscv64": {
-      "version": "0.25.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.2.tgz",
-      "integrity": "sha512-k4LtpgV7NJQOml/10uPU0s4SAXGnowi5qBSjaLWMojNCUICNu7TshqHLAEbkBdAszL5TabfvQ48kK84hyFzjnw==",
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.5.tgz",
+      "integrity": "sha512-kTxwu4mLyeOlsVIFPfQo+fQJAV9mh24xL+y+Bm6ej067sYANjyEw1dNHmvoqxJUCMnkBdKpvOn0Ahql6+4VyeA==",
       "cpu": [
         "riscv64"
       ],
@@ -329,9 +330,9 @@
       }
     },
     "node_modules/@esbuild/linux-s390x": {
-      "version": "0.25.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.2.tgz",
-      "integrity": "sha512-GRa4IshOdvKY7M/rDpRR3gkiTNp34M0eLTaC1a08gNrh4u488aPhuZOCpkF6+2wl3zAN7L7XIpOFBhnaE3/Q8Q==",
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.5.tgz",
+      "integrity": "sha512-K2dSKTKfmdh78uJ3NcWFiqyRrimfdinS5ErLSn3vluHNeHVnBAFWC8a4X5N+7FgVE1EjXS1QDZbpqZBjfrqMTQ==",
       "cpu": [
         "s390x"
       ],
@@ -345,9 +346,9 @@
       }
     },
     "node_modules/@esbuild/linux-x64": {
-      "version": "0.25.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.2.tgz",
-      "integrity": "sha512-QInHERlqpTTZ4FRB0fROQWXcYRD64lAoiegezDunLpalZMjcUcld3YzZmVJ2H/Cp0wJRZ8Xtjtj0cEHhYc/uUg==",
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.5.tgz",
+      "integrity": "sha512-uhj8N2obKTE6pSZ+aMUbqq+1nXxNjZIIjCjGLfsWvVpy7gKCOL6rsY1MhRh9zLtUtAI7vpgLMK6DxjO8Qm9lJw==",
       "cpu": [
         "x64"
       ],
@@ -361,9 +362,9 @@
       }
     },
     "node_modules/@esbuild/netbsd-arm64": {
-      "version": "0.25.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.2.tgz",
-      "integrity": "sha512-talAIBoY5M8vHc6EeI2WW9d/CkiO9MQJ0IOWX8hrLhxGbro/vBXJvaQXefW2cP0z0nQVTdQ/eNyGFV1GSKrxfw==",
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.5.tgz",
+      "integrity": "sha512-pwHtMP9viAy1oHPvgxtOv+OkduK5ugofNTVDilIzBLpoWAM16r7b/mxBvfpuQDpRQFMfuVr5aLcn4yveGvBZvw==",
       "cpu": [
         "arm64"
       ],
@@ -377,9 +378,9 @@
       }
     },
     "node_modules/@esbuild/netbsd-x64": {
-      "version": "0.25.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.2.tgz",
-      "integrity": "sha512-voZT9Z+tpOxrvfKFyfDYPc4DO4rk06qamv1a/fkuzHpiVBMOhpjK+vBmWM8J1eiB3OLSMFYNaOaBNLXGChf5tg==",
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.5.tgz",
+      "integrity": "sha512-WOb5fKrvVTRMfWFNCroYWWklbnXH0Q5rZppjq0vQIdlsQKuw6mdSihwSo4RV/YdQ5UCKKvBy7/0ZZYLBZKIbwQ==",
       "cpu": [
         "x64"
       ],
@@ -393,9 +394,9 @@
       }
     },
     "node_modules/@esbuild/openbsd-arm64": {
-      "version": "0.25.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.2.tgz",
-      "integrity": "sha512-dcXYOC6NXOqcykeDlwId9kB6OkPUxOEqU+rkrYVqJbK2hagWOMrsTGsMr8+rW02M+d5Op5NNlgMmjzecaRf7Tg==",
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.5.tgz",
+      "integrity": "sha512-7A208+uQKgTxHd0G0uqZO8UjK2R0DDb4fDmERtARjSHWxqMTye4Erz4zZafx7Di9Cv+lNHYuncAkiGFySoD+Mw==",
       "cpu": [
         "arm64"
       ],
@@ -409,9 +410,9 @@
       }
     },
     "node_modules/@esbuild/openbsd-x64": {
-      "version": "0.25.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.2.tgz",
-      "integrity": "sha512-t/TkWwahkH0Tsgoq1Ju7QfgGhArkGLkF1uYz8nQS/PPFlXbP5YgRpqQR3ARRiC2iXoLTWFxc6DJMSK10dVXluw==",
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.5.tgz",
+      "integrity": "sha512-G4hE405ErTWraiZ8UiSoesH8DaCsMm0Cay4fsFWOOUcz8b8rC6uCvnagr+gnioEjWn0wC+o1/TAHt+It+MpIMg==",
       "cpu": [
         "x64"
       ],
@@ -425,9 +426,9 @@
       }
     },
     "node_modules/@esbuild/sunos-x64": {
-      "version": "0.25.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.2.tgz",
-      "integrity": "sha512-cfZH1co2+imVdWCjd+D1gf9NjkchVhhdpgb1q5y6Hcv9TP6Zi9ZG/beI3ig8TvwT9lH9dlxLq5MQBBgwuj4xvA==",
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.5.tgz",
+      "integrity": "sha512-l+azKShMy7FxzY0Rj4RCt5VD/q8mG/e+mDivgspo+yL8zW7qEwctQ6YqKX34DTEleFAvCIUviCFX1SDZRSyMQA==",
       "cpu": [
         "x64"
       ],
@@ -441,9 +442,9 @@
       }
     },
     "node_modules/@esbuild/win32-arm64": {
-      "version": "0.25.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.2.tgz",
-      "integrity": "sha512-7Loyjh+D/Nx/sOTzV8vfbB3GJuHdOQyrOryFdZvPHLf42Tk9ivBU5Aedi7iyX+x6rbn2Mh68T4qq1SDqJBQO5Q==",
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.5.tgz",
+      "integrity": "sha512-O2S7SNZzdcFG7eFKgvwUEZ2VG9D/sn/eIiz8XRZ1Q/DO5a3s76Xv0mdBzVM5j5R639lXQmPmSo0iRpHqUUrsxw==",
       "cpu": [
         "arm64"
       ],
@@ -457,9 +458,9 @@
       }
     },
     "node_modules/@esbuild/win32-ia32": {
-      "version": "0.25.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.2.tgz",
-      "integrity": "sha512-WRJgsz9un0nqZJ4MfhabxaD9Ft8KioqU3JMinOTvobbX6MOSUigSBlogP8QB3uxpJDsFS6yN+3FDBdqE5lg9kg==",
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.5.tgz",
+      "integrity": "sha512-onOJ02pqs9h1iMJ1PQphR+VZv8qBMQ77Klcsqv9CNW2w6yLqoURLcgERAIurY6QE63bbLuqgP9ATqajFLK5AMQ==",
       "cpu": [
         "ia32"
       ],
@@ -473,9 +474,9 @@
       }
     },
     "node_modules/@esbuild/win32-x64": {
-      "version": "0.25.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.2.tgz",
-      "integrity": "sha512-kM3HKb16VIXZyIeVrM1ygYmZBKybX8N4p754bw390wGO3Tf2j4L2/WYL+4suWujpgf6GBYs3jv7TyUivdd05JA==",
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.5.tgz",
+      "integrity": "sha512-TXv6YnJ8ZMVdX+SXWVBo/0p8LTcrUYngpWjvm91TMjjBQii7Oz11Lw5lbDV5Y0TzuhSJHwiH4hEtC1I42mMS0g==",
       "cpu": [
         "x64"
       ],
@@ -681,29 +682,29 @@
       }
     },
     "node_modules/@polkadot-api/cli": {
-      "version": "0.11.9",
-      "resolved": "https://registry.npmjs.org/@polkadot-api/cli/-/cli-0.11.9.tgz",
-      "integrity": "sha512-5Qt+YRf/kOCZGiFoWzgyxoZYA9OpN28AFE4jQ4nZI33lty8oH4FR62IF2iLF+KdafhgF9k9l1Kj24zuBFH3Vrw==",
+      "version": "0.13.0",
+      "resolved": "https://registry.npmjs.org/@polkadot-api/cli/-/cli-0.13.0.tgz",
+      "integrity": "sha512-uumqacO1+YxuhHYOr75czxvV0KmRxm3DaZtRKzxIf2zpICnj/QnBTpJwlxU56g+pQDU5P/hTR0Thh0vrnUTNVw==",
       "license": "MIT",
       "dependencies": {
         "@commander-js/extra-typings": "^13.1.0",
-        "@polkadot-api/codegen": "0.13.3",
-        "@polkadot-api/ink-contracts": "0.2.6",
+        "@polkadot-api/codegen": "0.16.0",
+        "@polkadot-api/ink-contracts": "0.3.2",
         "@polkadot-api/json-rpc-provider": "0.0.4",
-        "@polkadot-api/known-chains": "0.7.3",
-        "@polkadot-api/metadata-compatibility": "0.2.0",
-        "@polkadot-api/observable-client": "0.8.6",
+        "@polkadot-api/known-chains": "0.7.6",
+        "@polkadot-api/metadata-compatibility": "0.2.3",
+        "@polkadot-api/observable-client": "0.11.0",
         "@polkadot-api/polkadot-sdk-compat": "2.3.2",
         "@polkadot-api/sm-provider": "0.1.7",
         "@polkadot-api/smoldot": "0.3.8",
-        "@polkadot-api/substrate-bindings": "0.11.1",
+        "@polkadot-api/substrate-bindings": "0.13.0",
         "@polkadot-api/substrate-client": "0.3.0",
         "@polkadot-api/utils": "0.1.2",
         "@polkadot-api/wasm-executor": "^0.1.2",
         "@polkadot-api/ws-provider": "0.4.0",
-        "@types/node": "^22.14.0",
+        "@types/node": "^22.15.18",
         "commander": "^13.1.0",
-        "execa": "^9.5.2",
+        "execa": "^9.5.3",
         "fs.promises.exists": "^1.1.4",
         "ora": "^8.2.0",
         "read-pkg": "^9.0.1",
@@ -719,26 +720,30 @@
       }
     },
     "node_modules/@polkadot-api/codegen": {
-      "version": "0.13.3",
-      "resolved": "https://registry.npmjs.org/@polkadot-api/codegen/-/codegen-0.13.3.tgz",
-      "integrity": "sha512-+8mp9k5L9myFSLv6Ad5r63JSIeq80/tKbk67rczDq6Co0PlJHqxult+wZHohHuyJSdtu8dHW9JQktTtM2RZT1w==",
+      "version": "0.16.0",
+      "resolved": "https://registry.npmjs.org/@polkadot-api/codegen/-/codegen-0.16.0.tgz",
+      "integrity": "sha512-2Sq/fkB7a9Oi3t7nGc0EbTt1Nd8Pb8XGiKKS9i/wwFAdCLN2oXd33DxmRQTX0Hm2/nrBzXYh1zBuyxRUb9+Sdw==",
       "license": "MIT",
       "dependencies": {
-        "@polkadot-api/ink-contracts": "0.2.6",
-        "@polkadot-api/metadata-builders": "0.10.2",
-        "@polkadot-api/metadata-compatibility": "0.2.0",
-        "@polkadot-api/substrate-bindings": "0.11.1",
+        "@polkadot-api/ink-contracts": "0.3.2",
+        "@polkadot-api/metadata-builders": "0.12.1",
+        "@polkadot-api/metadata-compatibility": "0.2.3",
+        "@polkadot-api/substrate-bindings": "0.13.0",
         "@polkadot-api/utils": "0.1.2"
       }
     },
+    "node_modules/@polkadot-api/descriptors": {
+      "resolved": ".papi/descriptors",
+      "link": true
+    },
     "node_modules/@polkadot-api/ink-contracts": {
-      "version": "0.2.6",
-      "resolved": "https://registry.npmjs.org/@polkadot-api/ink-contracts/-/ink-contracts-0.2.6.tgz",
-      "integrity": "sha512-76oHO/rKRa48w1i4DEmB/9e/FmxKuhMJq7l1OhdnX6mbVO+bAif7FkRUHLfIgsWqCdhCdfLe5J474HRudKhU/A==",
+      "version": "0.3.2",
+      "resolved": "https://registry.npmjs.org/@polkadot-api/ink-contracts/-/ink-contracts-0.3.2.tgz",
+      "integrity": "sha512-ipWuClaySrPI7XHIomiswXhIZfU4q/EmHmLFIwLdn9iNhLd7YLuUtGF6kacSQu76YtWd3tkLe2rGx4cRRaLjOA==",
       "license": "MIT",
       "dependencies": {
-        "@polkadot-api/metadata-builders": "0.10.2",
-        "@polkadot-api/substrate-bindings": "0.11.1",
+        "@polkadot-api/metadata-builders": "0.12.1",
+        "@polkadot-api/substrate-bindings": "0.13.0",
         "@polkadot-api/utils": "0.1.2"
       }
     },
@@ -755,9 +760,9 @@
       "license": "MIT"
     },
     "node_modules/@polkadot-api/known-chains": {
-      "version": "0.7.3",
-      "resolved": "https://registry.npmjs.org/@polkadot-api/known-chains/-/known-chains-0.7.3.tgz",
-      "integrity": "sha512-yBRVbOLn0e36+EGWE2/hX8mhTKvfdZtbk2VCgTM9djkz28eDFfiDjEl6biQA8Q0Kd7t3iRzoNbBzpzyBwTMXUg==",
+      "version": "0.7.6",
+      "resolved": "https://registry.npmjs.org/@polkadot-api/known-chains/-/known-chains-0.7.6.tgz",
+      "integrity": "sha512-em+p9AVfTYulC4U10I+nO42wdczN9ZSAEyb5ppQsxxsKAxaJVPVe4xsDkWzlhheheEN6OBojNHnoYNBVG6X2bg==",
       "license": "MIT"
     },
     "node_modules/@polkadot-api/logs-provider": {
@@ -769,34 +774,45 @@
         "@polkadot-api/json-rpc-provider": "0.0.4"
       }
     },
+    "node_modules/@polkadot-api/merkleize-metadata": {
+      "version": "1.1.17",
+      "resolved": "https://registry.npmjs.org/@polkadot-api/merkleize-metadata/-/merkleize-metadata-1.1.17.tgz",
+      "integrity": "sha512-3wlLrYjpBluN5l8M1H9zgXlFHfJhqIXYvSVXTvkBYcEVKxZt0PO0f43Zgskeabg29Lx83OiPINcEHFWF8ndAzg==",
+      "license": "MIT",
+      "dependencies": {
+        "@polkadot-api/metadata-builders": "0.12.1",
+        "@polkadot-api/substrate-bindings": "0.13.0",
+        "@polkadot-api/utils": "0.1.2"
+      }
+    },
     "node_modules/@polkadot-api/metadata-builders": {
-      "version": "0.10.2",
-      "resolved": "https://registry.npmjs.org/@polkadot-api/metadata-builders/-/metadata-builders-0.10.2.tgz",
-      "integrity": "sha512-rtdihBFd25oT9/71Q+EOR9q6E6mCl1pPe/2He/LtlY0TyHiYqO2KpMZNXkoGcw1RHvrV+CAtDFMvK1j3n8aW8w==",
+      "version": "0.12.1",
+      "resolved": "https://registry.npmjs.org/@polkadot-api/metadata-builders/-/metadata-builders-0.12.1.tgz",
+      "integrity": "sha512-heGt+WgcxrS1CqMm9XwD2DC+fI6azMKJf2ToMP+H12yw6FAy++nijASDZ3MlV/0ZpA/QGZpuZmgQmxKh6jbxVg==",
       "license": "MIT",
       "dependencies": {
-        "@polkadot-api/substrate-bindings": "0.11.1",
+        "@polkadot-api/substrate-bindings": "0.13.0",
         "@polkadot-api/utils": "0.1.2"
       }
     },
     "node_modules/@polkadot-api/metadata-compatibility": {
-      "version": "0.2.0",
-      "resolved": "https://registry.npmjs.org/@polkadot-api/metadata-compatibility/-/metadata-compatibility-0.2.0.tgz",
-      "integrity": "sha512-ZvHj4KDQy/JFqV51UN6Gk5xnG0qt/BUS4kjYosLWT9y6p5bHg/4ge7QF5lMloInQqV3Rul9NQo4cKUz3SlSQMQ==",
+      "version": "0.2.3",
+      "resolved": "https://registry.npmjs.org/@polkadot-api/metadata-compatibility/-/metadata-compatibility-0.2.3.tgz",
+      "integrity": "sha512-rtym491RA2yl8qGdEDJVujiCya+DK0CW5AwB6InSo85Um04/WWMq7oboRiXQZmspwLkfm2vYBusl/Q9k4Rxshw==",
       "license": "MIT",
       "dependencies": {
-        "@polkadot-api/metadata-builders": "0.10.2",
-        "@polkadot-api/substrate-bindings": "0.11.1"
+        "@polkadot-api/metadata-builders": "0.12.1",
+        "@polkadot-api/substrate-bindings": "0.13.0"
       }
     },
     "node_modules/@polkadot-api/observable-client": {
-      "version": "0.8.6",
-      "resolved": "https://registry.npmjs.org/@polkadot-api/observable-client/-/observable-client-0.8.6.tgz",
-      "integrity": "sha512-ci5HC8TYjGxoTG/QM+LLuGrfIsn+dtR7BBQz483c/ML8K/Hxl9v+evgZzPi9xNMwZ25mytn9lhA5dovYSEauSA==",
+      "version": "0.11.0",
+      "resolved": "https://registry.npmjs.org/@polkadot-api/observable-client/-/observable-client-0.11.0.tgz",
+      "integrity": "sha512-cyXyih+RI73vPcUQ6GxyMelm1Z3bGDvBIow8W3MqBdpUy4mZ87QGQXGpyBC0Op/qnIxrUFP1cLyT38fUe0i6KQ==",
       "license": "MIT",
       "dependencies": {
-        "@polkadot-api/metadata-builders": "0.10.2",
-        "@polkadot-api/substrate-bindings": "0.11.1",
+        "@polkadot-api/metadata-builders": "0.12.1",
+        "@polkadot-api/substrate-bindings": "0.13.0",
         "@polkadot-api/utils": "0.1.2"
       },
       "peerDependencies": {
@@ -805,15 +821,15 @@
       }
     },
     "node_modules/@polkadot-api/pjs-signer": {
-      "version": "0.6.5",
-      "resolved": "https://registry.npmjs.org/@polkadot-api/pjs-signer/-/pjs-signer-0.6.5.tgz",
-      "integrity": "sha512-RQJtvuX8jNR77h9PFTNQPjC4ii0g0uGrfyu5cbTujojg2QboU/6ny26Ty45rzkSOL0GaBLsS7Uf+/7Vf9hCxig==",
+      "version": "0.6.8",
+      "resolved": "https://registry.npmjs.org/@polkadot-api/pjs-signer/-/pjs-signer-0.6.8.tgz",
+      "integrity": "sha512-YBp+uF2mPZFH4VjT5xgIU462EXbdLrFz09D6vY4SgoS2FRbPV7ktnqiNK2BykKJPGV4TiqpEjNB4OtX6ZLzafg==",
       "license": "MIT",
       "dependencies": {
-        "@polkadot-api/metadata-builders": "0.10.2",
+        "@polkadot-api/metadata-builders": "0.12.1",
         "@polkadot-api/polkadot-signer": "0.1.6",
-        "@polkadot-api/signers-common": "0.1.6",
-        "@polkadot-api/substrate-bindings": "0.11.1",
+        "@polkadot-api/signers-common": "0.1.9",
+        "@polkadot-api/substrate-bindings": "0.13.0",
         "@polkadot-api/utils": "0.1.2"
       }
     },
@@ -833,27 +849,40 @@
       "license": "MIT"
     },
     "node_modules/@polkadot-api/signer": {
-      "version": "0.1.15",
-      "resolved": "https://registry.npmjs.org/@polkadot-api/signer/-/signer-0.1.15.tgz",
-      "integrity": "sha512-FUFlHrICB4dGlFa6FeFju/ySr8kTAkhTE/aSmfSxW0rl/cTeDO2fbUS9WmIl8wLB0jsI14I2r5J/p13FvIe1BA==",
+      "version": "0.2.1",
+      "resolved": "https://registry.npmjs.org/@polkadot-api/signer/-/signer-0.2.1.tgz",
+      "integrity": "sha512-z3BPDIglLh/hghQExQVVHR3xgIijjEVcIA2P+xLan5vO4cglGm4U6vIBXgKBuU2oxKlG494ixH8BkXSv5F79zw==",
       "license": "MIT",
       "dependencies": {
-        "@noble/hashes": "^1.7.1",
+        "@noble/hashes": "^1.8.0",
+        "@polkadot-api/merkleize-metadata": "1.1.17",
         "@polkadot-api/polkadot-signer": "0.1.6",
-        "@polkadot-api/signers-common": "0.1.6",
-        "@polkadot-api/substrate-bindings": "0.11.1",
+        "@polkadot-api/signers-common": "0.1.9",
+        "@polkadot-api/substrate-bindings": "0.13.0",
         "@polkadot-api/utils": "0.1.2"
       }
     },
+    "node_modules/@polkadot-api/signer/node_modules/@noble/hashes": {
+      "version": "1.8.0",
+      "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.8.0.tgz",
+      "integrity": "sha512-jCs9ldd7NwzpgXDIf6P3+NrHh9/sD6CQdxHyjQI+h/6rDNo88ypBxxz45UDuZHz9r3tNz7N/VInSVoVdtXEI4A==",
+      "license": "MIT",
+      "engines": {
+        "node": "^14.21.3 || >=16"
+      },
+      "funding": {
+        "url": "https://paulmillr.com/funding/"
+      }
+    },
     "node_modules/@polkadot-api/signers-common": {
-      "version": "0.1.6",
-      "resolved": "https://registry.npmjs.org/@polkadot-api/signers-common/-/signers-common-0.1.6.tgz",
-      "integrity": "sha512-OEzqpu/AlZIHbvpvwQJ7dhoRIRTXI2D7wYEoT5j0COpAvt3A1L53smECb3xWzkzlb82gINuqpUW5dfhhJ5tQFQ==",
+      "version": "0.1.9",
+      "resolved": "https://registry.npmjs.org/@polkadot-api/signers-common/-/signers-common-0.1.9.tgz",
+      "integrity": "sha512-eOAPfnNpa0kJrtM/OPHOt+jlFP97c4CWZmzfcPzOqfrLUgyyLzVCFzgBipffpzPXNPQsToM6FM+7DQEgQmoDuA==",
       "license": "MIT",
       "dependencies": {
-        "@polkadot-api/metadata-builders": "0.10.2",
+        "@polkadot-api/metadata-builders": "0.12.1",
         "@polkadot-api/polkadot-signer": "0.1.6",
-        "@polkadot-api/substrate-bindings": "0.11.1",
+        "@polkadot-api/substrate-bindings": "0.13.0",
         "@polkadot-api/utils": "0.1.2"
       }
     },
@@ -890,17 +919,29 @@
       }
     },
     "node_modules/@polkadot-api/substrate-bindings": {
-      "version": "0.11.1",
-      "resolved": "https://registry.npmjs.org/@polkadot-api/substrate-bindings/-/substrate-bindings-0.11.1.tgz",
-      "integrity": "sha512-+oqAZB7y18KrP/DqKmU2P3nNmRzjCY7edtW7tyA1g1jPouF7HhRr/Q13lJseDX9sdE2FZGrKZtivzsw8XeXBng==",
+      "version": "0.13.0",
+      "resolved": "https://registry.npmjs.org/@polkadot-api/substrate-bindings/-/substrate-bindings-0.13.0.tgz",
+      "integrity": "sha512-M/60lXtHr4flwx4K7L4xv2jLk44EhD8UB4jvah+jbZM195I89nZGXKo2JOkgyR5DHoLj//TAoBkLedZmaaAiaQ==",
       "license": "MIT",
       "dependencies": {
-        "@noble/hashes": "^1.7.1",
+        "@noble/hashes": "^1.8.0",
         "@polkadot-api/utils": "0.1.2",
-        "@scure/base": "^1.2.4",
+        "@scure/base": "^1.2.5",
         "scale-ts": "^1.6.1"
       }
     },
+    "node_modules/@polkadot-api/substrate-bindings/node_modules/@noble/hashes": {
+      "version": "1.8.0",
+      "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.8.0.tgz",
+      "integrity": "sha512-jCs9ldd7NwzpgXDIf6P3+NrHh9/sD6CQdxHyjQI+h/6rDNo88ypBxxz45UDuZHz9r3tNz7N/VInSVoVdtXEI4A==",
+      "license": "MIT",
+      "engines": {
+        "node": "^14.21.3 || >=16"
+      },
+      "funding": {
+        "url": "https://paulmillr.com/funding/"
+      }
+    },
     "node_modules/@polkadot-api/substrate-client": {
       "version": "0.3.0",
       "resolved": "https://registry.npmjs.org/@polkadot-api/substrate-client/-/substrate-client-0.3.0.tgz",
@@ -1513,9 +1554,9 @@
       }
     },
     "node_modules/@scure/base": {
-      "version": "1.2.4",
-      "resolved": "https://registry.npmjs.org/@scure/base/-/base-1.2.4.tgz",
-      "integrity": "sha512-5Yy9czTO47mqz+/J8GM6GIId4umdCk1wc1q8rKERQulIoc8VP9pzDcghv10Tl2E7R96ZUx/PhND3ESYUQX8NuQ==",
+      "version": "1.2.5",
+      "resolved": "https://registry.npmjs.org/@scure/base/-/base-1.2.5.tgz",
+      "integrity": "sha512-9rE6EOVeIQzt5TSu4v+K523F8u6DhBsoZWPGKlnCshhlDhy0kJzUX4V+tr2dWmzF1GdekvThABoEQBGBQI7xZw==",
       "license": "MIT",
       "funding": {
         "url": "https://paulmillr.com/funding/"
@@ -1767,9 +1808,9 @@
       "license": "MIT"
     },
     "node_modules/@types/node": {
-      "version": "22.14.1",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-22.14.1.tgz",
-      "integrity": "sha512-u0HuPQwe/dHrItgHHpmw3N2fYCR6x4ivMNbPHRkBVP4CvN+kiRrKHWk3i8tXiO/joPwXLMYvF9TTF0eqgHIuOw==",
+      "version": "22.15.21",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-22.15.21.tgz",
+      "integrity": "sha512-EV/37Td6c+MgKAbkcLG6vqZ2zEYHD7bvSrzqqs2RIhbA6w3x+Dqz8MZM3sP6kGTeLrdoOgKZe+Xja7tUB2DNkQ==",
       "license": "MIT",
       "dependencies": {
         "undici-types": "~6.21.0"
@@ -1816,7 +1857,6 @@
       "version": "8.14.0",
       "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.14.0.tgz",
       "integrity": "sha512-cl669nCJTZBsL97OF4kUQm5g5hC2uihk0NxY3WENAC0TYdILVkAyHymAntgxGkl7K+t0cXIrH5siy5S4XkFycA==",
-      "dev": true,
       "license": "MIT",
       "bin": {
         "acorn": "bin/acorn"
@@ -2228,6 +2268,12 @@
         "node": ">=18"
       }
     },
+    "node_modules/confbox": {
+      "version": "0.1.8",
+      "resolved": "https://registry.npmjs.org/confbox/-/confbox-0.1.8.tgz",
+      "integrity": "sha512-RMtmw0iFkeR4YV+fUOSucriAQNb9g8zFR52MWCtl+cCZOFRNL6zeB395vPzFhEjjn4fMxXudmELnl/KF/WrK6w==",
+      "license": "MIT"
+    },
     "node_modules/consola": {
       "version": "3.4.2",
       "resolved": "https://registry.npmjs.org/consola/-/consola-3.4.2.tgz",
@@ -2449,9 +2495,9 @@
       }
     },
     "node_modules/esbuild": {
-      "version": "0.25.2",
-      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.2.tgz",
-      "integrity": "sha512-16854zccKPnC+toMywC+uKNeYSv+/eXkevRAfwRD/G9Cleq66m8XFIrigkbvauLLlCfDL45Q2cWegSg53gGBnQ==",
+      "version": "0.25.5",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.5.tgz",
+      "integrity": "sha512-P8OtKZRv/5J5hhz0cUAdu/cLuPIKXpQl1R9pZtvmHWQvrAUVd0UNIPT4IB4W3rNOqVO0rlqHmCIbSwxh/c9yUQ==",
       "hasInstallScript": true,
       "license": "MIT",
       "bin": {
@@ -2461,31 +2507,31 @@
         "node": ">=18"
       },
       "optionalDependencies": {
-        "@esbuild/aix-ppc64": "0.25.2",
-        "@esbuild/android-arm": "0.25.2",
-        "@esbuild/android-arm64": "0.25.2",
-        "@esbuild/android-x64": "0.25.2",
-        "@esbuild/darwin-arm64": "0.25.2",
-        "@esbuild/darwin-x64": "0.25.2",
-        "@esbuild/freebsd-arm64": "0.25.2",
-        "@esbuild/freebsd-x64": "0.25.2",
-        "@esbuild/linux-arm": "0.25.2",
-        "@esbuild/linux-arm64": "0.25.2",
-        "@esbuild/linux-ia32": "0.25.2",
-        "@esbuild/linux-loong64": "0.25.2",
-        "@esbuild/linux-mips64el": "0.25.2",
-        "@esbuild/linux-ppc64": "0.25.2",
-        "@esbuild/linux-riscv64": "0.25.2",
-        "@esbuild/linux-s390x": "0.25.2",
-        "@esbuild/linux-x64": "0.25.2",
-        "@esbuild/netbsd-arm64": "0.25.2",
-        "@esbuild/netbsd-x64": "0.25.2",
-        "@esbuild/openbsd-arm64": "0.25.2",
-        "@esbuild/openbsd-x64": "0.25.2",
-        "@esbuild/sunos-x64": "0.25.2",
-        "@esbuild/win32-arm64": "0.25.2",
-        "@esbuild/win32-ia32": "0.25.2",
-        "@esbuild/win32-x64": "0.25.2"
+        "@esbuild/aix-ppc64": "0.25.5",
+        "@esbuild/android-arm": "0.25.5",
+        "@esbuild/android-arm64": "0.25.5",
+        "@esbuild/android-x64": "0.25.5",
+        "@esbuild/darwin-arm64": "0.25.5",
+        "@esbuild/darwin-x64": "0.25.5",
+        "@esbuild/freebsd-arm64": "0.25.5",
+        "@esbuild/freebsd-x64": "0.25.5",
+        "@esbuild/linux-arm": "0.25.5",
+        "@esbuild/linux-arm64": "0.25.5",
+        "@esbuild/linux-ia32": "0.25.5",
+        "@esbuild/linux-loong64": "0.25.5",
+        "@esbuild/linux-mips64el": "0.25.5",
+        "@esbuild/linux-ppc64": "0.25.5",
+        "@esbuild/linux-riscv64": "0.25.5",
+        "@esbuild/linux-s390x": "0.25.5",
+        "@esbuild/linux-x64": "0.25.5",
+        "@esbuild/netbsd-arm64": "0.25.5",
+        "@esbuild/netbsd-x64": "0.25.5",
+        "@esbuild/openbsd-arm64": "0.25.5",
+        "@esbuild/openbsd-x64": "0.25.5",
+        "@esbuild/sunos-x64": "0.25.5",
+        "@esbuild/win32-arm64": "0.25.5",
+        "@esbuild/win32-ia32": "0.25.5",
+        "@esbuild/win32-x64": "0.25.5"
       }
     },
     "node_modules/escalade": {
@@ -2610,23 +2656,23 @@
       "license": "MIT"
     },
     "node_modules/execa": {
-      "version": "9.5.2",
-      "resolved": "https://registry.npmjs.org/execa/-/execa-9.5.2.tgz",
-      "integrity": "sha512-EHlpxMCpHWSAh1dgS6bVeoLAXGnJNdR93aabr4QCGbzOM73o5XmRfM/e5FUqsw3aagP8S8XEWUWFAxnRBnAF0Q==",
+      "version": "9.6.0",
+      "resolved": "https://registry.npmjs.org/execa/-/execa-9.6.0.tgz",
+      "integrity": "sha512-jpWzZ1ZhwUmeWRhS7Qv3mhpOhLfwI+uAX4e5fOcXqwMR7EcJ0pj2kV1CVzHVMX/LphnKWD3LObjZCoJ71lKpHw==",
       "license": "MIT",
       "dependencies": {
         "@sindresorhus/merge-streams": "^4.0.0",
-        "cross-spawn": "^7.0.3",
+        "cross-spawn": "^7.0.6",
         "figures": "^6.1.0",
         "get-stream": "^9.0.0",
-        "human-signals": "^8.0.0",
+        "human-signals": "^8.0.1",
         "is-plain-obj": "^4.1.0",
         "is-stream": "^4.0.1",
         "npm-run-path": "^6.0.0",
-        "pretty-ms": "^9.0.0",
+        "pretty-ms": "^9.2.0",
         "signal-exit": "^4.1.0",
         "strip-final-newline": "^4.0.0",
-        "yoctocolors": "^2.0.0"
+        "yoctocolors": "^2.1.1"
       },
       "engines": {
         "node": "^18.19.0 || >=20.5.0"
@@ -2701,6 +2747,17 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/fix-dts-default-cjs-exports": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/fix-dts-default-cjs-exports/-/fix-dts-default-cjs-exports-1.0.1.tgz",
+      "integrity": "sha512-pVIECanWFC61Hzl2+oOCtoJ3F17kglZC/6N94eRWycFgBH35hHx0Li604ZIzhseh97mf2p0cv7vVrOZGoqhlEg==",
+      "license": "MIT",
+      "dependencies": {
+        "magic-string": "^0.30.17",
+        "mlly": "^1.7.4",
+        "rollup": "^4.34.8"
+      }
+    },
     "node_modules/flat": {
       "version": "5.0.2",
       "resolved": "https://registry.npmjs.org/flat/-/flat-5.0.2.tgz",
@@ -3417,6 +3474,15 @@
       "integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==",
       "license": "ISC"
     },
+    "node_modules/magic-string": {
+      "version": "0.30.17",
+      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.17.tgz",
+      "integrity": "sha512-sNPKHvyjVf7gyjwS4xGTaW/mCnF8wnjtifKBEhxfZ7E/S8tQ0rssrwGNn6q8JH/ohItJfSQp9mBtQYuTlH5QnA==",
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.0"
+      }
+    },
     "node_modules/make-error": {
       "version": "1.3.6",
       "resolved": "https://registry.npmjs.org/make-error/-/make-error-1.3.6.tgz",
@@ -3519,6 +3585,18 @@
         "node": ">=16 || 14 >=14.17"
       }
     },
+    "node_modules/mlly": {
+      "version": "1.7.4",
+      "resolved": "https://registry.npmjs.org/mlly/-/mlly-1.7.4.tgz",
+      "integrity": "sha512-qmdSIPC4bDJXgZTCR7XosJiNKySV7O215tsPtDN9iEO/7q/76b/ijtgRu/+epFXSJhijtTCCGp3DWS549P3xKw==",
+      "license": "MIT",
+      "dependencies": {
+        "acorn": "^8.14.0",
+        "pathe": "^2.0.1",
+        "pkg-types": "^1.3.0",
+        "ufo": "^1.5.4"
+      }
+    },
     "node_modules/mocha": {
       "version": "11.1.0",
       "resolved": "https://registry.npmjs.org/mocha/-/mocha-11.1.0.tgz",
@@ -4017,6 +4095,12 @@
         "url": "https://github.com/sponsors/isaacs"
       }
     },
+    "node_modules/pathe": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz",
+      "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==",
+      "license": "MIT"
+    },
     "node_modules/pathval": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/pathval/-/pathval-2.0.0.tgz",
@@ -4054,27 +4138,38 @@
         "node": ">= 6"
       }
     },
+    "node_modules/pkg-types": {
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/pkg-types/-/pkg-types-1.3.1.tgz",
+      "integrity": "sha512-/Jm5M4RvtBFVkKWRu2BLUTNP8/M2a+UwuAX+ae4770q1qVGtfjG+WTCupoZixokjmHiry8uI+dlY8KXYV5HVVQ==",
+      "license": "MIT",
+      "dependencies": {
+        "confbox": "^0.1.8",
+        "mlly": "^1.7.4",
+        "pathe": "^2.0.1"
+      }
+    },
     "node_modules/polkadot-api": {
-      "version": "1.9.12",
-      "resolved": "https://registry.npmjs.org/polkadot-api/-/polkadot-api-1.9.12.tgz",
-      "integrity": "sha512-gYhpef5YnLEPZ3Uxeha5sHIIejINONSGBXTgFyEWsYi4y2DEUlv2ISlNZ9/0AGG6b6ZFDd56mLop/Fohl8vA4Q==",
+      "version": "1.12.0",
+      "resolved": "https://registry.npmjs.org/polkadot-api/-/polkadot-api-1.12.0.tgz",
+      "integrity": "sha512-CstKp0ySE3JRVnG4nzl6hDhYLf4Qs/XpVk1xJrypYMqVbTu8FwjBK3l3j4pHhEttVudlEjK2hoVzQ1MdxMLeEg==",
       "license": "MIT",
       "dependencies": {
-        "@polkadot-api/cli": "0.11.9",
-        "@polkadot-api/ink-contracts": "0.2.6",
+        "@polkadot-api/cli": "0.13.0",
+        "@polkadot-api/ink-contracts": "0.3.2",
         "@polkadot-api/json-rpc-provider": "0.0.4",
-        "@polkadot-api/known-chains": "0.7.3",
+        "@polkadot-api/known-chains": "0.7.6",
         "@polkadot-api/logs-provider": "0.0.6",
-        "@polkadot-api/metadata-builders": "0.10.2",
-        "@polkadot-api/metadata-compatibility": "0.2.0",
-        "@polkadot-api/observable-client": "0.8.6",
-        "@polkadot-api/pjs-signer": "0.6.5",
+        "@polkadot-api/metadata-builders": "0.12.1",
+        "@polkadot-api/metadata-compatibility": "0.2.3",
+        "@polkadot-api/observable-client": "0.11.0",
+        "@polkadot-api/pjs-signer": "0.6.8",
         "@polkadot-api/polkadot-sdk-compat": "2.3.2",
         "@polkadot-api/polkadot-signer": "0.1.6",
-        "@polkadot-api/signer": "0.1.15",
+        "@polkadot-api/signer": "0.2.1",
         "@polkadot-api/sm-provider": "0.1.7",
         "@polkadot-api/smoldot": "0.3.8",
-        "@polkadot-api/substrate-bindings": "0.11.1",
+        "@polkadot-api/substrate-bindings": "0.13.0",
         "@polkadot-api/substrate-client": "0.3.0",
         "@polkadot-api/utils": "0.1.2",
         "@polkadot-api/ws-provider": "0.4.0",
@@ -4396,9 +4491,9 @@
       "license": "MIT"
     },
     "node_modules/semver": {
-      "version": "7.7.1",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.1.tgz",
-      "integrity": "sha512-hlq8tAfn0m/61p4BVRcPzIGr6LKiMwo4VM6dGi6pt4qcRkmNzTcWq6eCEjEh+qXjkMDvPlOFFSGwQjoEa6gyMA==",
+      "version": "7.7.2",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.2.tgz",
+      "integrity": "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==",
       "license": "ISC",
       "bin": {
         "semver": "bin/semver.js"
@@ -4710,12 +4805,12 @@
       "license": "MIT"
     },
     "node_modules/tinyglobby": {
-      "version": "0.2.12",
-      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.12.tgz",
-      "integrity": "sha512-qkf4trmKSIiMTs/E63cxH+ojC2unam7rJ0WrauAzpT3ECNTxGRMlaXxVbfxMUC/w0LaYk6jQ4y/nGR9uBO3tww==",
+      "version": "0.2.14",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.14.tgz",
+      "integrity": "sha512-tX5e7OM1HnYr2+a2C/4V0htOcSQcoSTH9KgJnVvNm5zm/cyEWKJ7j7YutsH9CxMdtOkkLFy2AHrMci9IM8IPZQ==",
       "license": "MIT",
       "dependencies": {
-        "fdir": "^6.4.3",
+        "fdir": "^6.4.4",
         "picomatch": "^4.0.2"
       },
       "engines": {
@@ -4726,9 +4821,9 @@
       }
     },
     "node_modules/tinyglobby/node_modules/fdir": {
-      "version": "6.4.3",
-      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.4.3.tgz",
-      "integrity": "sha512-PMXmW2y1hDDfTSRc9gaXIuCCRpuoz3Kaz8cUelp3smouvfT632ozg2vrT6lJsHKKOF59YLbOGfAWGUcKEfRMQw==",
+      "version": "6.4.4",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.4.4.tgz",
+      "integrity": "sha512-1NZP+GK4GfuAv3PqKvxQRDMjdSRZjnkq7KfhlNrCNNlZ0ygQFpebfrnfnq/W7fpUnAv9aGWmY1zKx7FYL3gwhg==",
       "license": "MIT",
       "peerDependencies": {
         "picomatch": "^3 || ^4"
@@ -4850,9 +4945,9 @@
       "license": "0BSD"
     },
     "node_modules/tsup": {
-      "version": "8.4.0",
-      "resolved": "https://registry.npmjs.org/tsup/-/tsup-8.4.0.tgz",
-      "integrity": "sha512-b+eZbPCjz10fRryaAA7C8xlIHnf8VnsaRqydheLIqwG/Mcpfk8Z5zp3HayX7GaTygkigHl5cBUs+IhcySiIexQ==",
+      "version": "8.5.0",
+      "resolved": "https://registry.npmjs.org/tsup/-/tsup-8.5.0.tgz",
+      "integrity": "sha512-VmBp77lWNQq6PfuMqCHD3xWl22vEoWsKajkF8t+yMBawlUS8JzEI+vOVMeuNZIuMML8qXRizFKi9oD5glKQVcQ==",
       "license": "MIT",
       "dependencies": {
         "bundle-require": "^5.1.0",
@@ -4861,6 +4956,7 @@
         "consola": "^3.4.0",
         "debug": "^4.4.0",
         "esbuild": "^0.25.0",
+        "fix-dts-default-cjs-exports": "^1.0.0",
         "joycon": "^3.1.1",
         "picocolors": "^1.1.1",
         "postcss-load-config": "^6.0.1",
@@ -4929,9 +5025,9 @@
       }
     },
     "node_modules/type-fest": {
-      "version": "4.40.0",
-      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-4.40.0.tgz",
-      "integrity": "sha512-ABHZ2/tS2JkvH1PEjxFDTUWC8dB5OsIGZP4IFLhR293GqT5Y5qB1WwL2kMPYhQW9DVgVD8Hd7I8gjwPIf5GFkw==",
+      "version": "4.41.0",
+      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-4.41.0.tgz",
+      "integrity": "sha512-TeTSQ6H5YHvpqVwBRcnLDCBnDOHWYu7IvGbHT6N8AOymcr9PJGjc1GTtiWZTYg0NCgYwvnYWEkVChQAr9bjfwA==",
       "license": "(MIT OR CC0-1.0)",
       "engines": {
         "node": ">=16"
@@ -4953,6 +5049,12 @@
         "node": ">=14.17"
       }
     },
+    "node_modules/ufo": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/ufo/-/ufo-1.6.1.tgz",
+      "integrity": "sha512-9a4/uxlTWJ4+a5i0ooc1rU7C7YOw3wT+UGqdeNNHWnOF9qcMBgLRS+4IYUqbczewFx4mLEig6gawh7X6mFlEkA==",
+      "license": "MIT"
+    },
     "node_modules/undici-types": {
       "version": "6.21.0",
       "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
@@ -5697,9 +5799,9 @@
       }
     },
     "node_modules/ws": {
-      "version": "8.18.1",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.1.tgz",
-      "integrity": "sha512-RKW2aJZMXeMxVpnZ6bck+RswznaxmzdULiBr6KY7XkTnW8uvt0iT9H5DkHUChXrc+uurzwa0rVI16n/Xzjdz1w==",
+      "version": "8.18.2",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.2.tgz",
+      "integrity": "sha512-DMricUmwGZUVr++AEAe2uiVM7UoO9MAVZMDu05UQOaUII0lp+zOzLLU4Xqh/JvTqklB1T4uELaaPBKyjE1r4fQ==",
       "license": "MIT",
       "engines": {
         "node": ">=10.0.0"
diff --git a/evm-tests/package.json b/evm-tests/package.json
index 0e90cdb976..9970967a88 100644
--- a/evm-tests/package.json
+++ b/evm-tests/package.json
@@ -6,6 +6,7 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
+    "@polkadot-api/descriptors": "file:.papi/descriptors",
     "@polkadot-labs/hdkd": "^0.0.10",
     "@polkadot-labs/hdkd-helpers": "^0.0.11",
     "@polkadot/api": "15.1.1",
@@ -16,7 +17,8 @@
     "mocha": "^11.1.0",
     "polkadot-api": "^1.9.5",
     "scale-ts": "^1.6.1",
-    "viem": "2.23.4"
+    "viem": "2.23.4",
+    "ws": "^8.18.2"
   },
   "devDependencies": {
     "@types/bun": "^1.1.13",
diff --git a/evm-tests/src/contracts/alpha.ts b/evm-tests/src/contracts/alpha.ts
new file mode 100644
index 0000000000..7dfb19be6c
--- /dev/null
+++ b/evm-tests/src/contracts/alpha.ts
@@ -0,0 +1,249 @@
+export const IALPHA_ADDRESS = "0x0000000000000000000000000000000000000807";
+
+export const IAlphaABI = [
+  {
+    "inputs": [
+      {
+        "internalType": "uint16",
+        "name": "netuid",
+        "type": "uint16"
+      }
+    ],
+    "name": "getAlphaPrice",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint16",
+        "name": "netuid",
+        "type": "uint16"
+      }
+    ],
+    "name": "getMovingAlphaPrice",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint16",
+        "name": "netuid",
+        "type": "uint16"
+      }
+    ],
+    "name": "getTaoInPool",
+    "outputs": [
+      {
+        "internalType": "uint64",
+        "name": "",
+        "type": "uint64"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint16",
+        "name": "netuid",
+        "type": "uint16"
+      }
+    ],
+    "name": "getAlphaInPool",
+    "outputs": [
+      {
+        "internalType": "uint64",
+        "name": "",
+        "type": "uint64"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint16",
+        "name": "netuid",
+        "type": "uint16"
+      }
+    ],
+    "name": "getAlphaOutPool",
+    "outputs": [
+      {
+        "internalType": "uint64",
+        "name": "",
+        "type": "uint64"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint16",
+        "name": "netuid",
+        "type": "uint16"
+      }
+    ],
+    "name": "getAlphaIssuance",
+    "outputs": [
+      {
+        "internalType": "uint64",
+        "name": "",
+        "type": "uint64"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "getTaoWeight",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint16",
+        "name": "netuid",
+        "type": "uint16"
+      },
+      {
+        "internalType": "uint64",
+        "name": "tao",
+        "type": "uint64"
+      }
+    ],
+    "name": "simSwapTaoForAlpha",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint16",
+        "name": "netuid",
+        "type": "uint16"
+      },
+      {
+        "internalType": "uint64",
+        "name": "alpha",
+        "type": "uint64"
+      }
+    ],
+    "name": "simSwapAlphaForTao",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint16",
+        "name": "netuid",
+        "type": "uint16"
+      }
+    ],
+    "name": "getSubnetMechanism",
+    "outputs": [
+      {
+        "internalType": "uint16",
+        "name": "",
+        "type": "uint16"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "getRootNetuid",
+    "outputs": [
+      {
+        "internalType": "uint16",
+        "name": "",
+        "type": "uint16"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint16",
+        "name": "netuid",
+        "type": "uint16"
+      }
+    ],
+    "name": "getEMAPriceHalvingBlocks",
+    "outputs": [
+      {
+        "internalType": "uint64",
+        "name": "",
+        "type": "uint64"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint16",
+        "name": "netuid",
+        "type": "uint16"
+      }
+    ],
+    "name": "getSubnetVolume",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  }
+]
\ No newline at end of file
diff --git a/evm-tests/test/alpha.precompile.test.ts b/evm-tests/test/alpha.precompile.test.ts
new file mode 100644
index 0000000000..85161aae92
--- /dev/null
+++ b/evm-tests/test/alpha.precompile.test.ts
@@ -0,0 +1,428 @@
+import * as assert from "assert";
+
+import { getAliceSigner, getDevnetApi, waitForTransactionCompletion, convertPublicKeyToMultiAddress, getRandomSubstrateKeypair, getSignerFromKeypair } from "../src/substrate"
+import { getPublicClient } from "../src/utils";
+import { ETH_LOCAL_URL, SUB_LOCAL_URL } from "../src/config";
+import { devnet } from "@polkadot-api/descriptors"
+import { PublicClient } from "viem";
+import { PolkadotSigner, TypedApi } from "polkadot-api";
+import { toViemAddress, convertPublicKeyToSs58 } from "../src/address-utils"
+import { IAlphaABI, IALPHA_ADDRESS } from "../src/contracts/alpha"
+
+describe("Test Alpha Precompile", () => {
+    // init substrate part
+    const hotkey = getRandomSubstrateKeypair();
+    const coldkey = getRandomSubstrateKeypair();
+    let publicClient: PublicClient;
+
+    let api: TypedApi<typeof devnet>;
+
+    // sudo account alice as signer
+    let alice: PolkadotSigner;
+
+    // init other variable
+    let subnetId = 0;
+
+    before(async () => {
+        // init variables got from await and async
+        publicClient = await getPublicClient(ETH_LOCAL_URL)
+        api = await getDevnetApi()
+        alice = await getAliceSigner();
+
+        // Fund the hotkey account
+        {
+            const multiAddress = convertPublicKeyToMultiAddress(hotkey.publicKey)
+            const internalCall = api.tx.Balances.force_set_balance({ who: multiAddress, new_free: BigInt(1e12) })
+            const tx = api.tx.Sudo.sudo({ call: internalCall.decodedCall })
+
+            await waitForTransactionCompletion(api, tx, alice)
+                .then(() => { })
+                .catch((error) => { console.log(`transaction error ${error}`) });
+        }
+
+        // Fund the coldkey account
+        {
+            const multiAddress = convertPublicKeyToMultiAddress(coldkey.publicKey)
+            const internalCall = api.tx.Balances.force_set_balance({ who: multiAddress, new_free: BigInt(1e12) })
+            const tx = api.tx.Sudo.sudo({ call: internalCall.decodedCall })
+
+            await waitForTransactionCompletion(api, tx, alice)
+                .then(() => { })
+                .catch((error) => { console.log(`transaction error ${error}`) });
+        }
+
+        // Register a new subnet
+        const signer = getSignerFromKeypair(coldkey)
+        const registerNetworkTx = api.tx.SubtensorModule.register_network({ hotkey: convertPublicKeyToSs58(hotkey.publicKey) })
+        await waitForTransactionCompletion(api, registerNetworkTx, signer)
+            .then(() => { })
+            .catch((error) => { console.log(`transaction error ${error}`) });
+
+        // Get the newly created subnet ID
+        let totalNetworks = await api.query.SubtensorModule.TotalNetworks.getValue()
+        assert.ok(totalNetworks > 1)
+        subnetId = totalNetworks - 1
+
+        // Register a neuron on the subnet if needed
+        let uid_count = await api.query.SubtensorModule.SubnetworkN.getValue(subnetId)
+        if (uid_count === 0) {
+            const tx = api.tx.SubtensorModule.burned_register({ hotkey: convertPublicKeyToSs58(hotkey.publicKey), netuid: subnetId })
+            await waitForTransactionCompletion(api, tx, signer)
+                .then(() => { })
+                .catch((error) => { console.log(`transaction error ${error}`) });
+        }
+    })
+
+    describe("Alpha Price Functions", () => {
+        it("getAlphaPrice returns valid price for subnet", async () => {
+            const alphaPrice = await publicClient.readContract({
+                abi: IAlphaABI,
+                address: toViemAddress(IALPHA_ADDRESS),
+                functionName: "getAlphaPrice",
+                args: [subnetId]
+            })
+
+            assert.ok(alphaPrice !== undefined, "Alpha price should be defined");
+            assert.ok(typeof alphaPrice === 'bigint', "Alpha price should be a bigint");
+            assert.ok(alphaPrice >= BigInt(0), "Alpha price should be non-negative");
+        });
+
+        it("getMovingAlphaPrice returns valid moving price for subnet", async () => {
+            const movingAlphaPrice = await publicClient.readContract({
+                abi: IAlphaABI,
+                address: toViemAddress(IALPHA_ADDRESS),
+                functionName: "getMovingAlphaPrice",
+                args: [subnetId]
+            })
+
+            assert.ok(movingAlphaPrice !== undefined, "Moving alpha price should be defined");
+            assert.ok(typeof movingAlphaPrice === 'bigint', "Moving alpha price should be a bigint");
+            assert.ok(movingAlphaPrice >= BigInt(0), "Moving alpha price should be non-negative");
+        });
+
+        it("alpha prices are consistent for same subnet", async () => {
+            const alphaPrice = await publicClient.readContract({
+                abi: IAlphaABI,
+                address: toViemAddress(IALPHA_ADDRESS),
+                functionName: "getAlphaPrice",
+                args: [subnetId]
+            })
+
+            const movingAlphaPrice = await publicClient.readContract({
+                abi: IAlphaABI,
+                address: toViemAddress(IALPHA_ADDRESS),
+                functionName: "getMovingAlphaPrice",
+                args: [subnetId]
+            })
+
+            // Both should be defined and valid
+            assert.ok(alphaPrice !== undefined && movingAlphaPrice !== undefined);
+        });
+    });
+
+    describe("Pool Data Functions", () => {
+        it("getTaoInPool returns valid TAO amount", async () => {
+            const taoInPool = await publicClient.readContract({
+                abi: IAlphaABI,
+                address: toViemAddress(IALPHA_ADDRESS),
+                functionName: "getTaoInPool",
+                args: [subnetId]
+            })
+
+            assert.ok(taoInPool !== undefined, "TAO in pool should be defined");
+            assert.ok(typeof taoInPool === 'bigint', "TAO in pool should be a bigint");
+            assert.ok(taoInPool >= BigInt(0), "TAO in pool should be non-negative");
+        });
+
+        it("getAlphaInPool returns valid Alpha amount", async () => {
+            const alphaInPool = await publicClient.readContract({
+                abi: IAlphaABI,
+                address: toViemAddress(IALPHA_ADDRESS),
+                functionName: "getAlphaInPool",
+                args: [subnetId]
+            })
+
+            assert.ok(alphaInPool !== undefined, "Alpha in pool should be defined");
+            assert.ok(typeof alphaInPool === 'bigint', "Alpha in pool should be a bigint");
+            assert.ok(alphaInPool >= BigInt(0), "Alpha in pool should be non-negative");
+        });
+
+        it("getAlphaOutPool returns valid Alpha out amount", async () => {
+            const alphaOutPool = await publicClient.readContract({
+                abi: IAlphaABI,
+                address: toViemAddress(IALPHA_ADDRESS),
+                functionName: "getAlphaOutPool",
+                args: [subnetId]
+            })
+
+            assert.ok(alphaOutPool !== undefined, "Alpha out pool should be defined");
+            assert.ok(typeof alphaOutPool === 'bigint', "Alpha out pool should be a bigint");
+            assert.ok(alphaOutPool >= BigInt(0), "Alpha out pool should be non-negative");
+        });
+
+        it("getAlphaIssuance returns valid issuance amount", async () => {
+            const alphaIssuance = await publicClient.readContract({
+                abi: IAlphaABI,
+                address: toViemAddress(IALPHA_ADDRESS),
+                functionName: "getAlphaIssuance",
+                args: [subnetId]
+            })
+
+            assert.ok(alphaIssuance !== undefined, "Alpha issuance should be defined");
+            assert.ok(typeof alphaIssuance === 'bigint', "Alpha issuance should be a bigint");
+            assert.ok(alphaIssuance >= BigInt(0), "Alpha issuance should be non-negative");
+        });
+    });
+
+    describe("Global Functions", () => {
+        it("getTaoWeight returns valid TAO weight", async () => {
+            const taoWeight = await publicClient.readContract({
+                abi: IAlphaABI,
+                address: toViemAddress(IALPHA_ADDRESS),
+                functionName: "getTaoWeight",
+                args: []
+            })
+
+            assert.ok(taoWeight !== undefined, "TAO weight should be defined");
+            assert.ok(typeof taoWeight === 'bigint', "TAO weight should be a bigint");
+            assert.ok(taoWeight >= BigInt(0), "TAO weight should be non-negative");
+        });
+
+        it("getRootNetuid returns correct root netuid", async () => {
+            const rootNetuid = await publicClient.readContract({
+                abi: IAlphaABI,
+                address: toViemAddress(IALPHA_ADDRESS),
+                functionName: "getRootNetuid",
+                args: []
+            })
+
+            assert.ok(rootNetuid !== undefined, "Root netuid should be defined");
+            assert.ok(typeof rootNetuid === 'number', "Root netuid should be a number");
+            assert.strictEqual(rootNetuid, 0, "Root netuid should be 0");
+        });
+    });
+
+    describe("Swap Simulation Functions", () => {
+        it("simSwapTaoForAlpha returns valid simulation", async () => {
+            const taoAmount = BigInt(1000000000); // 1 TAO in RAO
+            const simulatedAlpha = await publicClient.readContract({
+                abi: IAlphaABI,
+                address: toViemAddress(IALPHA_ADDRESS),
+                functionName: "simSwapTaoForAlpha",
+                args: [subnetId, taoAmount]
+            })
+
+            assert.ok(simulatedAlpha !== undefined, "Simulated alpha should be defined");
+            assert.ok(typeof simulatedAlpha === 'bigint', "Simulated alpha should be a bigint");
+            assert.ok(simulatedAlpha >= BigInt(0), "Simulated alpha should be non-negative");
+        });
+
+        it("simSwapAlphaForTao returns valid simulation", async () => {
+            const alphaAmount = BigInt(1000000000); // 1 Alpha
+            const simulatedTao = await publicClient.readContract({
+                abi: IAlphaABI,
+                address: toViemAddress(IALPHA_ADDRESS),
+                functionName: "simSwapAlphaForTao",
+                args: [subnetId, alphaAmount]
+            })
+
+            assert.ok(simulatedTao !== undefined, "Simulated tao should be defined");
+            assert.ok(typeof simulatedTao === 'bigint', "Simulated tao should be a bigint");
+            assert.ok(simulatedTao >= BigInt(0), "Simulated tao should be non-negative");
+        });
+
+        it("swap simulations handle zero amounts", async () => {
+            const zeroTaoForAlpha = await publicClient.readContract({
+                abi: IAlphaABI,
+                address: toViemAddress(IALPHA_ADDRESS),
+                functionName: "simSwapTaoForAlpha",
+                args: [subnetId, BigInt(0)]
+            })
+
+            const zeroAlphaForTao = await publicClient.readContract({
+                abi: IAlphaABI,
+                address: toViemAddress(IALPHA_ADDRESS),
+                functionName: "simSwapAlphaForTao",
+                args: [subnetId, BigInt(0)]
+            })
+
+            assert.strictEqual(zeroTaoForAlpha, BigInt(0), "Zero TAO should result in zero Alpha");
+            assert.strictEqual(zeroAlphaForTao, BigInt(0), "Zero Alpha should result in zero TAO");
+        });
+
+        it("swap simulations are internally consistent", async () => {
+            const taoAmount = BigInt(1000000000); // 1 TAO
+
+            // Simulate TAO -> Alpha
+            const simulatedAlpha = await publicClient.readContract({
+                abi: IAlphaABI,
+                address: toViemAddress(IALPHA_ADDRESS),
+                functionName: "simSwapTaoForAlpha",
+                args: [subnetId, taoAmount]
+            })
+
+            // If we got alpha, simulate Alpha -> TAO
+            if ((simulatedAlpha as bigint) > BigInt(0)) {
+                const simulatedTao = await publicClient.readContract({
+                    abi: IAlphaABI,
+                    address: toViemAddress(IALPHA_ADDRESS),
+                    functionName: "simSwapAlphaForTao",
+                    args: [subnetId, simulatedAlpha]
+                })
+
+                // Check if simulated values are reasonably close (allowing for rounding/fees)
+                if ((simulatedTao as bigint) > BigInt(0)) {
+                    const ratio = Number(taoAmount) / Number(simulatedTao);
+                    assert.ok(ratio >= 0.5 && ratio <= 2.0, "Swap simulation should be within reasonable bounds");
+                }
+            }
+        });
+    });
+
+    describe("Subnet Configuration Functions", () => {
+        it("getSubnetMechanism returns valid mechanism", async () => {
+            const mechanism = await publicClient.readContract({
+                abi: IAlphaABI,
+                address: toViemAddress(IALPHA_ADDRESS),
+                functionName: "getSubnetMechanism",
+                args: [subnetId]
+            })
+
+            assert.ok(mechanism !== undefined, "Subnet mechanism should be defined");
+            assert.ok(typeof mechanism === 'number', "Subnet mechanism should be a number");
+            assert.ok(mechanism >= 0, "Subnet mechanism should be non-negative");
+        });
+
+        it("getEMAPriceHalvingBlocks returns valid halving period", async () => {
+            const halvingBlocks = await publicClient.readContract({
+                abi: IAlphaABI,
+                address: toViemAddress(IALPHA_ADDRESS),
+                functionName: "getEMAPriceHalvingBlocks",
+                args: [subnetId]
+            })
+
+            assert.ok(halvingBlocks !== undefined, "EMA price halving blocks should be defined");
+            assert.ok(typeof halvingBlocks === 'bigint', "EMA halving blocks should be a bigint");
+            assert.ok(halvingBlocks >= BigInt(0), "EMA halving blocks should be non-negative");
+        });
+
+        it("getSubnetVolume returns valid volume data", async () => {
+            const subnetVolume = await publicClient.readContract({
+                abi: IAlphaABI,
+                address: toViemAddress(IALPHA_ADDRESS),
+                functionName: "getSubnetVolume",
+                args: [subnetId]
+            })
+
+            assert.ok(subnetVolume !== undefined, "Subnet volume should be defined");
+            assert.ok(typeof subnetVolume === 'bigint', "Subnet volume should be a bigint");
+            assert.ok(subnetVolume >= BigInt(0), "Subnet volume should be non-negative");
+        });
+    });
+
+    describe("Data Consistency with Pallet", () => {
+        it("precompile data matches pallet values", async () => {
+            // Get TAO in pool from precompile
+            const taoInPool = await publicClient.readContract({
+                abi: IAlphaABI,
+                address: toViemAddress(IALPHA_ADDRESS),
+                functionName: "getTaoInPool",
+                args: [subnetId]
+            })
+
+            // Get TAO in pool directly from the pallet
+            const taoInPoolFromPallet = await api.query.SubtensorModule.SubnetTAO.getValue(subnetId);
+
+            // Compare values
+            assert.strictEqual(taoInPool as bigint, taoInPoolFromPallet, "TAO in pool values should match");
+
+            // Get Alpha in pool from precompile
+            const alphaInPool = await publicClient.readContract({
+                abi: IAlphaABI,
+                address: toViemAddress(IALPHA_ADDRESS),
+                functionName: "getAlphaInPool",
+                args: [subnetId]
+            })
+
+            // Get Alpha in pool directly from the pallet
+            const alphaInPoolFromPallet = await api.query.SubtensorModule.SubnetAlphaIn.getValue(subnetId);
+
+            // Compare values
+            assert.strictEqual(alphaInPool as bigint, alphaInPoolFromPallet, "Alpha in pool values should match");
+
+            // Get Alpha out pool from precompile
+            const alphaOutPool = await publicClient.readContract({
+                abi: IAlphaABI,
+                address: toViemAddress(IALPHA_ADDRESS),
+                functionName: "getAlphaOutPool",
+                args: [subnetId]
+            })
+
+            // Get Alpha out pool directly from the pallet
+            const alphaOutPoolFromPallet = await api.query.SubtensorModule.SubnetAlphaOut.getValue(subnetId);
+
+            // Compare values
+            assert.strictEqual(alphaOutPool as bigint, alphaOutPoolFromPallet, "Alpha out pool values should match");
+        });
+
+        it("subnet volume data is consistent", async () => {
+            const subnetVolume = await publicClient.readContract({
+                abi: IAlphaABI,
+                address: toViemAddress(IALPHA_ADDRESS),
+                functionName: "getSubnetVolume",
+                args: [subnetId]
+            })
+
+            const subnetVolumeFromPallet = await api.query.SubtensorModule.SubnetVolume.getValue(subnetId);
+
+            assert.strictEqual(subnetVolume as bigint, subnetVolumeFromPallet, "Subnet volume values should match");
+        });
+    });
+
+    describe("Edge Cases and Error Handling", () => {
+        it("handles non-existent subnet gracefully", async () => {
+            const nonExistentSubnet = 9999;
+
+            // These should not throw but return default values
+            const alphaPrice = await publicClient.readContract({
+                abi: IAlphaABI,
+                address: toViemAddress(IALPHA_ADDRESS),
+                functionName: "getAlphaPrice",
+                args: [nonExistentSubnet]
+            })
+
+            const taoInPool = await publicClient.readContract({
+                abi: IAlphaABI,
+                address: toViemAddress(IALPHA_ADDRESS),
+                functionName: "getTaoInPool",
+                args: [nonExistentSubnet]
+            })
+
+            // Should return default values, not throw
+            assert.ok(alphaPrice !== undefined, "Should handle non-existent subnet gracefully");
+            assert.ok(taoInPool !== undefined, "Should handle non-existent subnet gracefully");
+        });
+
+        it("simulation functions handle large amounts", async () => {
+            const largeAmount = BigInt("1000000000000000000"); // Very large amount
+
+            const simulatedAlpha = await publicClient.readContract({
+                abi: IAlphaABI,
+                address: toViemAddress(IALPHA_ADDRESS),
+                functionName: "simSwapTaoForAlpha",
+                args: [subnetId, largeAmount]
+            })
+
+            const simulatedTao = await publicClient.readContract({
+                abi: IAlphaABI,
+                address: toViemAddress(IALPHA_ADDRESS),
+                functionName: "simSwapAlphaForTao",
+                args: [subnetId, largeAmount]
+            })
+
+            // Should handle large amounts without throwing
+            assert.ok(simulatedAlpha !== undefined, "Should handle large TAO amounts");
+            assert.ok(simulatedTao !== undefined, "Should handle large Alpha amounts");
+        });
+    });
+});
diff --git a/precompiles/src/alpha.rs b/precompiles/src/alpha.rs
index 1f01883d40..a806f9f07b 100644
--- a/precompiles/src/alpha.rs
+++ b/precompiles/src/alpha.rs
@@ -14,7 +14,7 @@ where
     R: frame_system::Config + pallet_subtensor::Config,
     R::AccountId: From<[u8; 32]>,
 {
-    const INDEX: u64 = 2054;
+    const INDEX: u64 = 2055;
 }
 
 #[precompile_utils::precompile]
diff --git a/precompiles/src/solidity/alpha.sol b/precompiles/src/solidity/alpha.sol
index 622757df78..cafbaa10cb 100644
--- a/precompiles/src/solidity/alpha.sol
+++ b/precompiles/src/solidity/alpha.sol
@@ -1,6 +1,6 @@
 pragma solidity ^0.8.0;
 
-address constant IALPHA_ADDRESS = 0x0000000000000000000000000000000000000806;
+address constant IALPHA_ADDRESS = 0x0000000000000000000000000000000000000807;
 
 interface IAlpha {
     /// @dev Returns the current alpha price for a subnet.
@@ -67,4 +67,4 @@ interface IAlpha {
     /// @param netuid The subnet identifier.
     /// @return The subnet volume.
     function getSubnetVolume(uint16 netuid) external view returns (uint256);
-}
\ No newline at end of file
+}

From bf5690b5589b8cb620155968095c1eb32213b0eb Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Tue, 27 May 2025 17:53:17 -0400
Subject: [PATCH 197/418] Add tests and fixes for fee correctness

---
 pallets/subtensor/src/staking/add_stake.rs   |  11 +-
 pallets/subtensor/src/staking/stake_utils.rs |   2 +
 pallets/subtensor/src/tests/staking.rs       | 241 +++++++++++++++----
 pallets/swap/src/lib.rs                      |   2 +-
 pallets/swap/src/pallet/impls.rs             | 148 +++++++++---
 5 files changed, 309 insertions(+), 95 deletions(-)

diff --git a/pallets/subtensor/src/staking/add_stake.rs b/pallets/subtensor/src/staking/add_stake.rs
index d848397513..7e629add3f 100644
--- a/pallets/subtensor/src/staking/add_stake.rs
+++ b/pallets/subtensor/src/staking/add_stake.rs
@@ -154,18 +154,11 @@ impl<T: Config> Pallet<T> {
         }
 
         // 5. Ensure the remove operation from the coldkey is a success.
-        let tao_staked: I96F32 =
-            Self::remove_balance_from_coldkey_account(&coldkey, possible_stake)?.into();
+        let tao_staked: u64 = Self::remove_balance_from_coldkey_account(&coldkey, possible_stake)?;
 
         // 6. Swap the stake into alpha on the subnet and increase counters.
         // Emit the staking event.
-        Self::stake_into_subnet(
-            &hotkey,
-            &coldkey,
-            netuid,
-            tao_staked.saturating_to_num::<u64>(),
-            limit_price,
-        )?;
+        Self::stake_into_subnet(&hotkey, &coldkey, netuid, tao_staked, limit_price)?;
 
         // Ok and return.
         Ok(())
diff --git a/pallets/subtensor/src/staking/stake_utils.rs b/pallets/subtensor/src/staking/stake_utils.rs
index af5a08d1a3..d6f8e0987d 100644
--- a/pallets/subtensor/src/staking/stake_utils.rs
+++ b/pallets/subtensor/src/staking/stake_utils.rs
@@ -764,6 +764,8 @@ impl<T: Config> Pallet<T> {
         // Swap the tao to alpha.
         let swap_result = Self::swap_tao_for_alpha(netuid, tao, price_limit)?;
 
+        ensure!(swap_result.amount_paid_out > 0, Error::<T>::AmountTooLow);
+
         ensure!(
             Self::try_increase_stake_for_hotkey_and_coldkey_on_subnet(
                 hotkey,
diff --git a/pallets/subtensor/src/tests/staking.rs b/pallets/subtensor/src/tests/staking.rs
index fd608085d9..57538b5291 100644
--- a/pallets/subtensor/src/tests/staking.rs
+++ b/pallets/subtensor/src/tests/staking.rs
@@ -6,12 +6,12 @@ use frame_support::dispatch::{DispatchClass, DispatchInfo, GetDispatchInfo, Pays
 use frame_support::sp_runtime::DispatchError;
 use frame_support::{assert_err, assert_noop, assert_ok, traits::Currency};
 use frame_system::RawOrigin;
+use pallet_subtensor_swap::{NetUid, tick::TickIndex};
 use safe_math::FixedExt;
 use sp_core::{Get, H256, U256};
 use substrate_fixed::traits::FromFixed;
 use substrate_fixed::types::{I96F32, I110F18, U64F64, U96F32};
 use subtensor_swap_interface::{OrderType, SwapHandler};
-use pallet_subtensor_swap::NetUid;
 
 use super::mock;
 use super::mock::*;
@@ -4329,10 +4329,10 @@ fn test_unstake_all_alpha_hits_liquidity_min() {
 
         // Try to unstake, but we reduce liquidity too far
 
-        assert_ok!(SubtensorModule::unstake_all_alpha(
-            RuntimeOrigin::signed(coldkey),
-            hotkey
-        ));
+        assert_err!(
+            SubtensorModule::unstake_all_alpha(RuntimeOrigin::signed(coldkey), hotkey),
+            Error::<Test>::AmountTooLow
+        );
 
         // Expect nothing to be unstaked
         let new_alpha =
@@ -4442,10 +4442,17 @@ fn test_stake_into_subnet_ok() {
         let tao_reserve = U96F32::from_num(100_000_000_000_u64);
         let alpha_in = U96F32::from_num(1_000_000_000_000_u64);
         mock::setup_reserves(netuid, tao_reserve.to_num(), alpha_in.to_num());
-        let current_price = <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid).to_num::<f64>();
+        let current_price =
+            <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid).to_num::<f64>();
 
         // Initialize swap v3
-        assert_ok!(<tests::mock::Test as pallet::Config>::SwapInterface::swap(netuid, OrderType::Buy, 0, 0, true));
+        assert_ok!(<tests::mock::Test as pallet::Config>::SwapInterface::swap(
+            netuid,
+            OrderType::Buy,
+            0,
+            0,
+            true
+        ));
 
         // Add stake with slippage safety and check if the result is ok
         assert_ok!(SubtensorModule::stake_into_subnet(
@@ -4459,11 +4466,8 @@ fn test_stake_into_subnet_ok() {
 
         // Check if stake has increased
         assert_abs_diff_eq!(
-            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
-                &hotkey,
-                &coldkey,
-                netuid
-            ) as f64,
+            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid)
+                as f64,
             expected_stake,
             epsilon = expected_stake / 1000.,
         );
@@ -4486,10 +4490,17 @@ fn test_stake_into_subnet_low_amount() {
         let tao_reserve = U96F32::from_num(100_000_000_000_u64);
         let alpha_in = U96F32::from_num(1_000_000_000_000_u64);
         mock::setup_reserves(netuid, tao_reserve.to_num(), alpha_in.to_num());
-        let current_price = <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid).to_num::<f64>();
+        let current_price =
+            <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid).to_num::<f64>();
 
         // Initialize swap v3
-        assert_ok!(<tests::mock::Test as pallet::Config>::SwapInterface::swap(netuid, OrderType::Buy, 0, 0, true));
+        assert_ok!(<tests::mock::Test as pallet::Config>::SwapInterface::swap(
+            netuid,
+            OrderType::Buy,
+            0,
+            0,
+            true
+        ));
 
         // Add stake with slippage safety and check if the result is ok
         assert_ok!(SubtensorModule::stake_into_subnet(
@@ -4503,11 +4514,8 @@ fn test_stake_into_subnet_low_amount() {
 
         // Check if stake has increased
         assert_abs_diff_eq!(
-            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
-                &hotkey,
-                &coldkey,
-                netuid
-            ) as u64,
+            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid)
+                as u64,
             expected_stake,
             epsilon = expected_stake / 100,
         );
@@ -4532,7 +4540,13 @@ fn test_unstake_from_subnet_low_amount() {
         mock::setup_reserves(netuid, tao_reserve.to_num(), alpha_in.to_num());
 
         // Initialize swap v3
-        assert_ok!(<tests::mock::Test as pallet::Config>::SwapInterface::swap(netuid, OrderType::Buy, 0, 0, true));
+        assert_ok!(<tests::mock::Test as pallet::Config>::SwapInterface::swap(
+            netuid,
+            OrderType::Buy,
+            0,
+            0,
+            true
+        ));
 
         // Add stake and check if the result is ok
         assert_ok!(SubtensorModule::stake_into_subnet(
@@ -4544,11 +4558,8 @@ fn test_unstake_from_subnet_low_amount() {
         ));
 
         // Remove stake
-        let alpha = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
-            &hotkey,
-            &coldkey,
-            netuid
-        );
+        let alpha =
+            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid);
         assert_ok!(SubtensorModule::unstake_from_subnet(
             &hotkey,
             &coldkey,
@@ -4559,11 +4570,7 @@ fn test_unstake_from_subnet_low_amount() {
 
         // Check if stake is zero
         assert_eq!(
-            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
-                &hotkey,
-                &coldkey,
-                netuid
-            ),
+            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid),
             0,
         );
     });
@@ -4587,18 +4594,27 @@ fn test_stake_into_subnet_prohibitive_limit() {
         mock::setup_reserves(netuid, tao_reserve.to_num(), alpha_in.to_num());
 
         // Initialize swap v3
-        assert_ok!(<tests::mock::Test as pallet::Config>::SwapInterface::swap(netuid, OrderType::Buy, 0, 0, true));
+        assert_ok!(<tests::mock::Test as pallet::Config>::SwapInterface::swap(
+            netuid,
+            OrderType::Buy,
+            0,
+            0,
+            true
+        ));
 
         // Add stake and check if the result is ok
         // Use prohibitive limit price
-        assert_ok!(SubtensorModule::add_stake_limit(
-            RuntimeOrigin::signed(coldkey),
-            owner_hotkey,
-            netuid,
-            amount,
-            u64::MIN,
-            true,
-        ));
+        assert_err!(
+            SubtensorModule::add_stake_limit(
+                RuntimeOrigin::signed(coldkey),
+                owner_hotkey,
+                netuid,
+                amount,
+                u64::MIN,
+                true,
+            ),
+            Error::<Test>::AmountTooLow
+        );
 
         // Check if stake has NOT increased
         assert_eq!(
@@ -4611,10 +4627,7 @@ fn test_stake_into_subnet_prohibitive_limit() {
         );
 
         // Check if balance has NOT decreased
-        assert_eq!(
-            SubtensorModule::get_coldkey_balance(&coldkey),
-            amount
-        );
+        assert_eq!(SubtensorModule::get_coldkey_balance(&coldkey), amount);
     });
 }
 
@@ -4636,7 +4649,13 @@ fn test_unstake_from_subnet_prohibitive_limit() {
         mock::setup_reserves(netuid, tao_reserve.to_num(), alpha_in.to_num());
 
         // Initialize swap v3
-        assert_ok!(<tests::mock::Test as pallet::Config>::SwapInterface::swap(netuid, OrderType::Buy, 0, 0, true));
+        assert_ok!(<tests::mock::Test as pallet::Config>::SwapInterface::swap(
+            netuid,
+            OrderType::Buy,
+            0,
+            0,
+            true
+        ));
 
         // Add stake and check if the result is ok
         assert_ok!(SubtensorModule::stake_into_subnet(
@@ -4653,7 +4672,7 @@ fn test_unstake_from_subnet_prohibitive_limit() {
         let alpha = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
             &owner_hotkey,
             &coldkey,
-            netuid
+            netuid,
         );
         assert_ok!(SubtensorModule::remove_stake_limit(
             RuntimeOrigin::signed(coldkey),
@@ -4700,7 +4719,13 @@ fn test_unstake_full_amount() {
         mock::setup_reserves(netuid, tao_reserve.to_num(), alpha_in.to_num());
 
         // Initialize swap v3
-        assert_ok!(<tests::mock::Test as pallet::Config>::SwapInterface::swap(netuid, OrderType::Buy, 0, 0, true));
+        assert_ok!(<tests::mock::Test as pallet::Config>::SwapInterface::swap(
+            netuid,
+            OrderType::Buy,
+            0,
+            0,
+            true
+        ));
 
         // Add stake and check if the result is ok
         assert_ok!(SubtensorModule::stake_into_subnet(
@@ -4717,7 +4742,7 @@ fn test_unstake_full_amount() {
         let alpha = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
             &owner_hotkey,
             &coldkey,
-            netuid
+            netuid,
         );
         assert_ok!(SubtensorModule::remove_stake(
             RuntimeOrigin::signed(coldkey),
@@ -4739,7 +4764,8 @@ fn test_unstake_full_amount() {
         // Check if balance has increased accordingly
         let balance_after = SubtensorModule::get_coldkey_balance(&coldkey);
         let actual_balance_increase = (balance_after - balance_before) as f64;
-        let fee_rate = pallet_subtensor_swap::FeeRate::<Test>::get(NetUid::from(netuid)) as f64 / u16::MAX as f64;
+        let fee_rate = pallet_subtensor_swap::FeeRate::<Test>::get(NetUid::from(netuid)) as f64
+            / u16::MAX as f64;
         let expected_balance_increase = amount as f64 * (1. - fee_rate) / (1. + fee_rate);
         assert_abs_diff_eq!(
             actual_balance_increase,
@@ -4747,4 +4773,121 @@ fn test_unstake_full_amount() {
             epsilon = expected_balance_increase / 10_000.
         );
     });
-}
\ No newline at end of file
+}
+
+fn price_to_tick(price: f64) -> TickIndex {
+    let price_sqrt: U64F64 = U64F64::from_num(price.sqrt());
+    // Handle potential errors in the conversion
+    match TickIndex::try_from_sqrt_price(price_sqrt) {
+        Ok(mut tick) => {
+            // Ensure the tick is within bounds
+            if tick > TickIndex::MAX {
+                tick = TickIndex::MAX;
+            } else if tick < TickIndex::MIN {
+                tick = TickIndex::MIN;
+            }
+            tick
+        }
+        // Default to a reasonable value when conversion fails
+        Err(_) => {
+            if price > 1.0 {
+                TickIndex::MAX
+            } else {
+                TickIndex::MIN
+            }
+        }
+    }
+}
+
+/// Test correctness of swap fees:
+///   1. TAO is not minted or burned
+///   2. Fees match FeeRate
+///
+#[test]
+fn test_swap_fees_tao_correctness() {
+    new_test_ext(1).execute_with(|| {
+        let owner_hotkey = U256::from(1);
+        let owner_coldkey = U256::from(2);
+        let coldkey = U256::from(4);
+        let amount = 1_000_000_000;
+        let owner_balance_before = amount * 10;
+        let user_balance_before = amount * 100;
+
+        // add network
+        let netuid: u16 = add_dynamic_network(&owner_hotkey, &owner_coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&owner_coldkey, owner_balance_before);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, user_balance_before);
+        let fee_rate = pallet_subtensor_swap::FeeRate::<Test>::get(NetUid::from(netuid)) as f64
+            / u16::MAX as f64;
+
+        // Forse-set alpha in and tao reserve to make price equal 0.25
+        let tao_reserve = U96F32::from_num(100_000_000_000_u64);
+        let alpha_in = U96F32::from_num(400_000_000_000_u64);
+        mock::setup_reserves(netuid, tao_reserve.to_num(), alpha_in.to_num());
+
+        // Check starting "total TAO"
+        let total_tao_before =
+            user_balance_before + owner_balance_before + SubnetTAO::<Test>::get(netuid);
+
+        // Get alpha for owner
+        assert_ok!(SubtensorModule::add_stake(
+            RuntimeOrigin::signed(owner_coldkey),
+            owner_hotkey,
+            netuid,
+            amount,
+        ));
+        let mut fees = (fee_rate * amount as f64) as u64;
+
+        // Add owner coldkey Alpha as concentrated liquidity
+        // between current price current price + 0.01
+        let current_price = <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid)
+            .to_num::<f64>()
+            + 0.0001;
+        let limit_price = current_price + 0.01;
+        let tick_low = price_to_tick(current_price);
+        let tick_high = price_to_tick(limit_price);
+        let liquidity = amount;
+
+        assert_ok!(<Test as pallet::Config>::SwapInterface::do_add_liquidity(
+            NetUid::from(netuid),
+            &owner_coldkey,
+            &owner_hotkey,
+            tick_low,
+            tick_high,
+            liquidity,
+        ));
+
+        // Limit-buy and then sell all alpha for user to hit owner liquidity
+        assert_ok!(SubtensorModule::add_stake_limit(
+            RuntimeOrigin::signed(coldkey),
+            owner_hotkey,
+            netuid,
+            amount,
+            (limit_price * u64::MAX as f64) as u64,
+            true
+        ));
+        fees += (fee_rate * amount as f64) as u64;
+
+        let user_alpha = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+            &owner_hotkey,
+            &coldkey,
+            netuid,
+        );
+        assert_ok!(SubtensorModule::remove_stake(
+            RuntimeOrigin::signed(coldkey),
+            owner_hotkey,
+            netuid,
+            user_alpha,
+        ));
+        // Do not add fees because selling feels are in alpha
+
+        // Check ending "total TAO"
+        let owner_balance_after = SubtensorModule::get_coldkey_balance(&owner_coldkey);
+        let user_balance_after = SubtensorModule::get_coldkey_balance(&coldkey);
+        let total_tao_after =
+            user_balance_after + owner_balance_after + SubnetTAO::<Test>::get(netuid) + fees;
+
+        // Total TAO does not change, leave some epsilon for rounding
+        assert_abs_diff_eq!(total_tao_before, total_tao_after, epsilon = 2,);
+    });
+}
diff --git a/pallets/swap/src/lib.rs b/pallets/swap/src/lib.rs
index c7c30e9d3b..823ea7cd72 100644
--- a/pallets/swap/src/lib.rs
+++ b/pallets/swap/src/lib.rs
@@ -8,7 +8,7 @@ use subtensor_swap_interface::OrderType;
 
 pub mod pallet;
 mod position;
-mod tick;
+pub mod tick;
 pub mod weights;
 
 pub use pallet::*;
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index e3c7b3a4ed..26dd42ef6c 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -38,6 +38,7 @@ struct SwapStep<T: frame_system::Config> {
     action: SwapStepAction,
     delta_in: u64,
     final_price: SqrtPrice,
+    fee: u64,
 
     // Phantom data to use T
     _phantom: PhantomData<T>,
@@ -55,8 +56,8 @@ impl<T: Config> SwapStep<T> {
         let current_liquidity = Pallet::<T>::current_liquidity_safe(netuid);
         let sqrt_price_edge = Pallet::<T>::sqrt_price_edge(netuid, current_price, order_type);
 
-        let possible_delta_in = amount_remaining
-            .saturating_sub(Pallet::<T>::calculate_fee_amount(netuid, amount_remaining));
+        let fee = Pallet::<T>::calculate_fee_amount(netuid, amount_remaining);
+        let possible_delta_in = amount_remaining.saturating_sub(fee);
 
         // println!("SwapStep::new order_type = {:?}", order_type);
         // println!("SwapStep::new sqrt_price_limit = {:?}", sqrt_price_limit);
@@ -81,6 +82,7 @@ impl<T: Config> SwapStep<T> {
             action: SwapStepAction::Stop,
             delta_in: 0,
             final_price: sqrt_price_target,
+            fee,
             _phantom: PhantomData,
         }
     }
@@ -91,7 +93,7 @@ impl<T: Config> SwapStep<T> {
         self.process_swap()
     }
 
-    /// Returns True is price1 is closer to the current price than price2
+    /// Returns True if price1 is closer to the current price than price2
     /// in terms of order direction.
     ///    For buying:  price1 <= price2
     ///    For selling: price1 >= price2
@@ -105,9 +107,10 @@ impl<T: Config> SwapStep<T> {
 
     /// Determine the appropriate action for this swap step
     fn determine_action(&mut self) {
+        let mut recalculate_fee = false;
+
         // Calculate the stopping price: The price at which we either reach the limit price,
         // exchange the full amount, or reach the edge price.
-
         if self.price_is_closer(&self.sqrt_price_target, &self.sqrt_price_limit)
             && self.price_is_closer(&self.sqrt_price_target, &self.sqrt_price_edge)
         {
@@ -130,6 +133,7 @@ impl<T: Config> SwapStep<T> {
                 self.current_price,
                 self.sqrt_price_limit,
             );
+            recalculate_fee = true;
             // println!("Case 2. Delta in = {:?}", self.delta_in);
             // println!("Case 2. sqrt_price_limit = {:?}", self.sqrt_price_limit);
         } else {
@@ -143,9 +147,21 @@ impl<T: Config> SwapStep<T> {
                 self.sqrt_price_edge,
             );
             self.final_price = self.sqrt_price_edge;
+            recalculate_fee = true;
             // println!("Case 3. Delta in = {:?}", self.delta_in);
         }
 
+        // Because on step creation we calculate fee off the total amount, we might need to recalculate it
+        // in case if we hit the limit price or the edge price.
+        if recalculate_fee {
+            let u16_max = U64F64::saturating_from_num(u16::MAX);
+            let fee_rate = U64F64::saturating_from_num(FeeRate::<T>::get(self.netuid));
+            let delta_fixed = U64F64::saturating_from_num(self.delta_in);
+            self.fee = delta_fixed
+                .saturating_mul(fee_rate.safe_div(u16_max.saturating_sub(fee_rate)))
+                .saturating_to_num::<u64>();
+        }
+
         // Now correct the action if we stopped exactly at the edge no matter what was the case above
         // Because order type buy moves the price up and tick semi-open interval doesn't include its right
         // point, we cross on buys and stop on sells.
@@ -165,20 +181,11 @@ impl<T: Config> SwapStep<T> {
 
     /// Process a single step of a swap
     fn process_swap(&self) -> Result<SwapStepResult, Error<T>> {
-        // total_cost = delta_in / (1 - self.fee_size)
-        let fee_rate = U64F64::saturating_from_num(FeeRate::<T>::get(self.netuid));
-        let u16_max = U64F64::saturating_from_num(u16::MAX);
-        let delta_fixed = U64F64::saturating_from_num(self.delta_in);
-        let total_cost =
-            delta_fixed.saturating_mul(u16_max.safe_div(u16_max.saturating_sub(fee_rate)));
-
         // println!("Executing swap step. order_type = {:?}", self.order_type);
         // println!("Executing swap step. delta_in = {:?}", self.delta_in);
 
         // Hold the fees
-        let fee =
-            Pallet::<T>::calculate_fee_amount(self.netuid, total_cost.saturating_to_num::<u64>());
-        Pallet::<T>::add_fees(self.netuid, self.order_type, fee);
+        Pallet::<T>::add_fees(self.netuid, self.order_type, self.fee);
         let delta_out = Pallet::<T>::convert_deltas(self.netuid, self.order_type, self.delta_in);
 
         // Get current tick
@@ -211,8 +218,8 @@ impl<T: Config> SwapStep<T> {
         CurrentTick::<T>::set(self.netuid, new_current_tick);
 
         Ok(SwapStepResult {
-            amount_to_take: total_cost.saturating_to_num::<u64>(),
-            fee_paid: fee,
+            amount_to_take: self.delta_in.saturating_add(self.fee),
+            fee_paid: self.fee,
             delta_in: self.delta_in,
             delta_out,
         })
@@ -319,8 +326,14 @@ impl<T: Config> Pallet<T> {
         should_rollback: bool,
     ) -> Result<SwapResult, DispatchError> {
         transactional::with_transaction(|| {
-            let result =
-                Self::swap_inner(netuid, order_type, amount, sqrt_price_limit).map_err(Into::into);
+            let result = Self::swap_inner(
+                netuid,
+                order_type,
+                amount,
+                sqrt_price_limit,
+                should_rollback,
+            )
+            .map_err(Into::into);
 
             if should_rollback || result.is_err() {
                 TransactionOutcome::Rollback(result)
@@ -335,6 +348,7 @@ impl<T: Config> Pallet<T> {
         order_type: OrderType,
         amount: u64,
         sqrt_price_limit: SqrtPrice,
+        simulate: bool,
     ) -> Result<SwapResult, Error<T>> {
         ensure!(
             T::SubnetInfo::tao_reserve(netuid.into()) >= T::MinimumReserve::get().get()
@@ -382,26 +396,29 @@ impl<T: Config> Pallet<T> {
 
         let tao_reserve = T::SubnetInfo::tao_reserve(netuid.into());
         let alpha_reserve = T::SubnetInfo::alpha_reserve(netuid.into());
+        let (new_tao_reserve, new_alpha_reserve) = if !simulate {
+            let checked_reserve = match order_type {
+                OrderType::Buy => alpha_reserve,
+                OrderType::Sell => tao_reserve,
+            };
 
-        let checked_reserve = match order_type {
-            OrderType::Buy => alpha_reserve,
-            OrderType::Sell => tao_reserve,
-        };
-
-        ensure!(
-            checked_reserve >= amount_paid_out,
-            Error::<T>::InsufficientLiquidity
-        );
+            ensure!(
+                checked_reserve >= amount_paid_out,
+                Error::<T>::InsufficientLiquidity
+            );
 
-        let (new_tao_reserve, new_alpha_reserve) = match order_type {
-            OrderType::Buy => (
-                tao_reserve.saturating_add(in_acc),
-                alpha_reserve.saturating_sub(amount_paid_out),
-            ),
-            OrderType::Sell => (
-                tao_reserve.saturating_sub(amount_paid_out),
-                alpha_reserve.saturating_add(in_acc),
-            ),
+            match order_type {
+                OrderType::Buy => (
+                    tao_reserve.saturating_add(in_acc),
+                    alpha_reserve.saturating_sub(amount_paid_out),
+                ),
+                OrderType::Sell => (
+                    tao_reserve.saturating_sub(amount_paid_out),
+                    alpha_reserve.saturating_add(in_acc),
+                ),
+            }
+        } else {
+            (tao_reserve, alpha_reserve)
         };
 
         Ok(SwapResult {
@@ -2441,4 +2458,63 @@ mod tests {
             }
         });
     }
+
+    /// Test correctness of swap fees:
+    ///   1. Fees are distribued to (concentrated) liquidity providers
+    ///
+    #[test]
+    fn test_swap_fee_correctness() {
+        new_test_ext().execute_with(|| {
+            let min_price = tick_to_price(TickIndex::MIN);
+            let max_price = tick_to_price(TickIndex::MAX);
+            let netuid = NetUid::from(1);
+
+            // Provide very spread liquidity at the range from min to max that matches protocol liquidity
+            let liquidity = 2_000_000_000_000_u64; // 1x of protocol liquidity
+
+            assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
+
+            // Calculate ticks
+            let tick_low = price_to_tick(min_price);
+            let tick_high = price_to_tick(max_price);
+
+            // Add user liquidity
+            let (position_id, _tao, _alpha) = Pallet::<Test>::do_add_liquidity(
+                netuid,
+                &OK_COLDKEY_ACCOUNT_ID,
+                &OK_HOTKEY_ACCOUNT_ID,
+                tick_low,
+                tick_high,
+                liquidity,
+            )
+            .unwrap();
+
+            // Swap buy and swap sell
+            Pallet::<Test>::do_swap(
+                netuid,
+                OrderType::Buy,
+                liquidity / 10,
+                u64::MAX.into(),
+                false,
+            )
+            .unwrap();
+            Pallet::<Test>::do_swap(netuid, OrderType::Sell, liquidity / 10, 0_u64.into(), false)
+                .unwrap();
+
+            // Get user position
+            let mut position =
+                Positions::<Test>::get((netuid, OK_COLDKEY_ACCOUNT_ID, position_id)).unwrap();
+            assert_eq!(position.liquidity, liquidity);
+            assert_eq!(position.tick_low, tick_low);
+            assert_eq!(position.tick_high, tick_high);
+
+            // Check that 50% of fees were credited to the position
+            let fee_rate = FeeRate::<Test>::get(NetUid::from(netuid)) as f64 / u16::MAX as f64;
+            let (actual_fee_tao, actual_fee_alpha) = position.collect_fees::<Test>();
+            let expected_fee = (fee_rate * (liquidity / 10) as f64 * 0.5) as u64;
+
+            assert_abs_diff_eq!(actual_fee_tao, expected_fee, epsilon = 1,);
+            assert_abs_diff_eq!(actual_fee_alpha, expected_fee, epsilon = 1,);
+        });
+    }
 }

From 90ba97893d1a21f984c50670793b96a32d9b945b Mon Sep 17 00:00:00 2001
From: kenobijon <kenjonmiyachi@gmail.com>
Date: Tue, 27 May 2025 19:45:36 -0500
Subject: [PATCH 198/418] remove descriptions from package.json

---
 evm-tests/package.json | 1 -
 1 file changed, 1 deletion(-)

diff --git a/evm-tests/package.json b/evm-tests/package.json
index 9970967a88..4834ef4e99 100644
--- a/evm-tests/package.json
+++ b/evm-tests/package.json
@@ -6,7 +6,6 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@polkadot-api/descriptors": "file:.papi/descriptors",
     "@polkadot-labs/hdkd": "^0.0.10",
     "@polkadot-labs/hdkd-helpers": "^0.0.11",
     "@polkadot/api": "15.1.1",

From f133f989dfb3d4c39dfdbc49193514fbd6d770e9 Mon Sep 17 00:00:00 2001
From: kenobijon <kenjonmiyachi@gmail.com>
Date: Tue, 27 May 2025 20:58:46 -0500
Subject: [PATCH 199/418] bumping runtime spec_version

---
 runtime/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index 95b032f9e6..5e099d1ce2 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -209,7 +209,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
     //   `spec_version`, and `authoring_version` are the same between Wasm and native.
     // This value is set to 100 to notify Polkadot-JS App (https://polkadot.js.org/apps) to use
     //   the compatible custom types.
-    spec_version: 272,
+    spec_version: 273,
     impl_version: 1,
     apis: RUNTIME_API_VERSIONS,
     transaction_version: 1,

From a689d98e9d4d3ca1db69ce4fddaf38c2b8f915fd Mon Sep 17 00:00:00 2001
From: Sam Johnson <sam@durosoft.com>
Date: Wed, 28 May 2025 12:12:08 -0400
Subject: [PATCH 200/418] update to rust 1.87

---
 rust-toolchain.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index d3d24f8f8c..8b497b3762 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,5 +1,5 @@
 [toolchain]
-channel = "1.86.0"
+channel = "1.87"
 components = [
 	"cargo",
 	"clippy",

From c921529eb91836a9dd03ce1b7dafa1be1262dfb8 Mon Sep 17 00:00:00 2001
From: Sam Johnson <sam@durosoft.com>
Date: Wed, 28 May 2025 12:21:57 -0400
Subject: [PATCH 201/418] allow clippy large error

---
 Cargo.toml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Cargo.toml b/Cargo.toml
index 548bc5af63..b429ac9341 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -39,6 +39,7 @@ arithmetic-side-effects = "deny"
 type_complexity = "allow"
 unwrap-used = "deny"
 manual_inspect = "allow"
+result_large_err = "allow"
 useless_conversion = "allow"     # until polkadot is patched
 
 [workspace.dependencies]

From 89313c1d3c9b28ed1c95e5ad5f3e30d7bc1cd0a1 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Wed, 28 May 2025 19:25:56 +0200
Subject: [PATCH 202/418] Fix compilation

---
 pallets/subtensor/src/staking/add_stake.rs    |  12 +-
 pallets/subtensor/src/staking/remove_stake.rs |  11 +-
 pallets/subtensor/src/tests/epoch.rs          |   2 +-
 pallets/subtensor/src/tests/move_stake.rs     |  17 +-
 pallets/subtensor/src/tests/staking.rs        | 182 ++++++++++++------
 pallets/subtensor/src/tests/subnet.rs         |   2 -
 rust-toolchain.toml                           |   2 +-
 7 files changed, 149 insertions(+), 79 deletions(-)

diff --git a/pallets/subtensor/src/staking/add_stake.rs b/pallets/subtensor/src/staking/add_stake.rs
index 0e1ee0aca5..aa3a939483 100644
--- a/pallets/subtensor/src/staking/add_stake.rs
+++ b/pallets/subtensor/src/staking/add_stake.rs
@@ -334,12 +334,12 @@ impl<T: Config> Pallet<T> {
         }
 
         // Use reverting swap to estimate max limit amount
-         let swap_result =
-            T::SwapInterface::swap(netuid, OrderType::Buy, u64::MAX, limit_price, true).map_err(|_| Error::ZeroMaxStakeAmount)?;
+        let swap_result =
+            T::SwapInterface::swap(netuid, OrderType::Buy, u64::MAX, limit_price, true)
+                .map_err(|_| Error::ZeroMaxStakeAmount)?;
 
-		 Ok(
-            swap_result
-                .amount_paid_in
-                .saturating_add(swap_result.fee_paid))
+        Ok(swap_result
+            .amount_paid_in
+            .saturating_add(swap_result.fee_paid))
     }
 }
diff --git a/pallets/subtensor/src/staking/remove_stake.rs b/pallets/subtensor/src/staking/remove_stake.rs
index 838cb02c0c..efef359bfe 100644
--- a/pallets/subtensor/src/staking/remove_stake.rs
+++ b/pallets/subtensor/src/staking/remove_stake.rs
@@ -614,11 +614,12 @@ impl<T: Config> Pallet<T> {
         }
 
         // Use reverting swap to estimate max limit amount
-         let swap_result =
-            T::SwapInterface::swap(netuid, OrderType::Sell, u64::MAX, limit_price, true).map_err(|_| Error::ZeroMaxStakeAmount)?;
+        let swap_result =
+            T::SwapInterface::swap(netuid, OrderType::Sell, u64::MAX, limit_price, true)
+                .map_err(|_| Error::ZeroMaxStakeAmount)?;
 
-		 Ok(swap_result
-                .amount_paid_in
-                .saturating_add(swap_result.fee_paid))
+        Ok(swap_result
+            .amount_paid_in
+            .saturating_add(swap_result.fee_paid))
     }
 }
diff --git a/pallets/subtensor/src/tests/epoch.rs b/pallets/subtensor/src/tests/epoch.rs
index db3eff5eaa..1a576869dd 100644
--- a/pallets/subtensor/src/tests/epoch.rs
+++ b/pallets/subtensor/src/tests/epoch.rs
@@ -14,7 +14,7 @@ use substrate_fixed::types::I32F32;
 use subtensor_swap_interface::SwapHandler;
 
 use super::mock::*;
-use crate::epoch::math::{safe_exp, fixed, u16_proportion_to_fixed};
+use crate::epoch::math::{fixed, u16_proportion_to_fixed};
 use crate::*;
 
 // Normalizes (sum to 1 except 0) the input vector directly in-place.
diff --git a/pallets/subtensor/src/tests/move_stake.rs b/pallets/subtensor/src/tests/move_stake.rs
index 5f73a101a5..840fab2198 100644
--- a/pallets/subtensor/src/tests/move_stake.rs
+++ b/pallets/subtensor/src/tests/move_stake.rs
@@ -1450,13 +1450,16 @@ fn test_do_swap_same_subnet() {
 
         let (tao_equivalent, _) = mock::swap_alpha_to_tao(netuid, alpha_before);
         let (expected_alpha, _) = mock::swap_tao_to_alpha(netuid, tao_equivalent);
-        assert_eq!(SubtensorModule::do_swap_stake(
-            RuntimeOrigin::signed(coldkey),
-            hotkey,
-            netuid,
-            netuid,
-            alpha_before
-        ), Err(Error::<Test>::SameNetuid.into()));
+        assert_eq!(
+            SubtensorModule::do_swap_stake(
+                RuntimeOrigin::signed(coldkey),
+                hotkey,
+                netuid,
+                netuid,
+                alpha_before
+            ),
+            Err(Error::<Test>::SameNetuid.into())
+        );
 
         let alpha_after =
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid);
diff --git a/pallets/subtensor/src/tests/staking.rs b/pallets/subtensor/src/tests/staking.rs
index b768ee015e..fc4d3db87d 100644
--- a/pallets/subtensor/src/tests/staking.rs
+++ b/pallets/subtensor/src/tests/staking.rs
@@ -3834,17 +3834,11 @@ fn test_unstake_all_validate() {
         // Simulate stake for hotkey
         SubnetTAO::<Test>::insert(netuid, u64::MAX / 1000);
         SubnetAlphaIn::<Test>::insert(netuid, u64::MAX / 1000);
-        SubtensorModule::stake_into_subnet(&hotkey, &coldkey, netuid, amount_staked, 0);
+        SubtensorModule::stake_into_subnet(&hotkey, &coldkey, netuid, amount_staked, 0).unwrap();
 
         // Set the liquidity at lowest possible value so that all staking requests fail
-        SubnetTAO::<Test>::insert(
-            netuid,
-            DefaultMinimumPoolLiquidity::<Test>::get().to_num::<u64>(),
-        );
-        SubnetAlphaIn::<Test>::insert(
-            netuid,
-            DefaultMinimumPoolLiquidity::<Test>::get().to_num::<u64>(),
-        );
+        SubnetTAO::<Test>::insert(netuid, mock::SwapMinimumLiquidity::get());
+        SubnetAlphaIn::<Test>::insert(netuid, mock::SwapMinimumLiquidity::get());
 
         // unstake_all call
         let call = RuntimeCall::SubtensorModule(SubtensorCall::unstake_all { hotkey });
@@ -3945,36 +3939,71 @@ fn test_max_amount_add_dynamic() {
     // tao_in, alpha_in, limit_price, expected_max_swappable
     [
         // Zero handling (no panics)
-        (1_000_000_000, 1_000_000_000, 0, 0),
+        (
+            1_000_000_000,
+            1_000_000_000,
+            0,
+            Err(Error::<Test>::ZeroMaxStakeAmount),
+        ),
         // Low bounds
-        (100, 100, 1_100_000_000, 0),
-        (1_000, 1_000, 1_100_000_000, 0),
-        (10_000, 10_000, 1_100_000_000, 440),
+        (
+            100,
+            100,
+            1_100_000_000,
+            Err(Error::<Test>::ZeroMaxStakeAmount),
+        ),
+        (
+            1_000,
+            1_000,
+            1_100_000_000,
+            Err(Error::<Test>::ZeroMaxStakeAmount),
+        ),
+        (10_000, 10_000, 1_100_000_000, Ok(440)),
         // Basic math
-        (1_000_000, 1_000_000, 4_000_000_000, 1_000_000),
-        (1_000_000, 1_000_000, 9_000_000_000, 2_000_000),
-        (1_000_000, 1_000_000, 16_000_000_000, 3_000_000),
+        (1_000_000, 1_000_000, 4_000_000_000, Ok(1_000_000)),
+        (1_000_000, 1_000_000, 9_000_000_000, Ok(2_000_000)),
+        (1_000_000, 1_000_000, 16_000_000_000, Ok(3_000_000)),
         (
             1_000_000_000_000,
             1_000_000_000_000,
             16_000_000_000,
-            3_000_000_000_000,
+            Ok(3_000_000_000_000),
         ),
         // Normal range values with edge cases
-        (150_000_000_000, 100_000_000_000, 0, 0),
-        (150_000_000_000, 100_000_000_000, 100_000_000, 0),
-        (150_000_000_000, 100_000_000_000, 500_000_000, 0),
-        (150_000_000_000, 100_000_000_000, 1_499_999_999, 0),
-        (150_000_000_000, 100_000_000_000, 1_500_000_000, 5),
-        (150_000_000_000, 100_000_000_000, 1_500_000_001, 51),
         (
             150_000_000_000,
             100_000_000_000,
-            6_000_000_000,
+            0,
+            Err(Error::<Test>::ZeroMaxStakeAmount),
+        ),
+        (
+            150_000_000_000,
+            100_000_000_000,
+            100_000_000,
+            Err(Error::<Test>::ZeroMaxStakeAmount),
+        ),
+        (
+            150_000_000_000,
+            100_000_000_000,
+            500_000_000,
+            Err(Error::<Test>::ZeroMaxStakeAmount),
+        ),
+        (
+            150_000_000_000,
+            100_000_000_000,
+            1_499_999_999,
+            Err(Error::<Test>::ZeroMaxStakeAmount),
+        ),
+        (150_000_000_000, 100_000_000_000, 1_500_000_000, Ok(5)),
+        (150_000_000_000, 100_000_000_000, 1_500_000_001, Ok(51)),
+        (
             150_000_000_000,
+            100_000_000_000,
+            6_000_000_000,
+            Ok(150_000_000_000),
         ),
         // Miscellaneous overflows and underflows
-        (u64::MAX / 2, u64::MAX, u64::MAX, u64::MAX),
+        (u64::MAX / 2, u64::MAX, u64::MAX, Ok(u64::MAX)),
         // (150_000_000_000, 100_000_000_000, u64::MAX / 2, u64::MAX),
         // (1_000_000, 1_000_000_000_000_000_000_u64, 1, 999_000_000),
         // (1_000_000, 1_000_000_000_000_000_000_u64, 2, 1_999_000_000),
@@ -4021,8 +4050,8 @@ fn test_max_amount_add_dynamic() {
         //     21_000_000_000_000_000,
         // ),
     ]
-    .iter()
-    .for_each(|&(tao_in, alpha_in, limit_price, expected_max_swappable)| {
+    .into_iter()
+    .for_each(|(tao_in, alpha_in, limit_price, expected_max_swappable)| {
         new_test_ext(0).execute_with(|| {
             let subnet_owner_coldkey = U256::from(1001);
             let subnet_owner_hotkey = U256::from(1002);
@@ -4045,11 +4074,14 @@ fn test_max_amount_add_dynamic() {
                 );
             }
 
-            assert_abs_diff_eq!(
-                SubtensorModule::get_max_amount_add(netuid, limit_price),
-                expected_max_swappable,
-                epsilon = expected_max_swappable / 100
-            );
+            match expected_max_swappable {
+                Err(e) => assert_err!(SubtensorModule::get_max_amount_add(netuid, limit_price), e,),
+                Ok(v) => assert_abs_diff_eq!(
+                    SubtensorModule::get_max_amount_add(netuid, limit_price).unwrap(),
+                    v,
+                    epsilon = v / 100
+                ),
+            }
         });
     });
 }
@@ -4141,8 +4173,18 @@ fn test_max_amount_remove_dynamic() {
         // tao_in, alpha_in, limit_price, expected_max_swappable
         [
             // Zero handling (no panics)
-            (0, 1_000_000_000, 100, Err(Error::<Test>::ZeroMaxStakeAmount)),
-            (1_000_000_000, 0, 100, Err(Error::<Test>::ZeroMaxStakeAmount)),
+            (
+                0,
+                1_000_000_000,
+                100,
+                Err(Error::<Test>::ZeroMaxStakeAmount),
+            ),
+            (
+                1_000_000_000,
+                0,
+                100,
+                Err(Error::<Test>::ZeroMaxStakeAmount),
+            ),
             (10_000_000_000, 10_000_000_000, 0, Ok(u64::MAX)),
             // Low bounds (numbers are empirical, it is only important that result
             // is sharply decreasing when limit price increases)
@@ -4158,7 +4200,7 @@ fn test_max_amount_remove_dynamic() {
                 1_000_000_000_000,
                 1_000_000_000_000,
                 62_500_000,
-                3_000_000_000_000,
+                Ok(3_000_000_000_000),
             ),
             // Normal range values with edge cases and sanity checks
             (200_000_000_000, 100_000_000_000, 0, Ok(u64::MAX)),
@@ -4172,10 +4214,20 @@ fn test_max_amount_remove_dynamic() {
                 200_000_000_000,
                 100_000_000_000,
                 125_000_000,
-                300_000_000_000,
+                Ok(300_000_000_000),
+            ),
+            (
+                200_000_000_000,
+                100_000_000_000,
+                2_000_000_000,
+                Err(Error::<Test>::ZeroMaxStakeAmount),
+            ),
+            (
+                200_000_000_000,
+                100_000_000_000,
+                2_000_000_001,
+                Err(Error::<Test>::ZeroMaxStakeAmount),
             ),
-            (200_000_000_000, 100_000_000_000, 2_000_000_000, Err(Error::<Test>::ZeroMaxStakeAmount)),
-            (200_000_000_000, 100_000_000_000, 2_000_000_001, Err(Error::<Test>::ZeroMaxStakeAmount)),
             (200_000_000_000, 100_000_000_000, 1_999_999_999, Ok(24)),
             (200_000_000_000, 100_000_000_000, 1_999_999_990, Ok(252)),
             // Miscellaneous overflows and underflows
@@ -4185,7 +4237,7 @@ fn test_max_amount_remove_dynamic() {
                 21_000_000_000_000_000,
                 Ok(30_700_000),
             ),
-            (21_000_000_000_000_000, 1_000_000, u64::MAX, 67_164),
+            (21_000_000_000_000_000, 1_000_000, u64::MAX, Ok(67_164)),
             (
                 21_000_000_000_000_000,
                 1_000_000_000_000_000_000,
@@ -4204,7 +4256,12 @@ fn test_max_amount_remove_dynamic() {
                 999_999_999,
                 Ok(10_500_000),
             ),
-            (21_000_000_000_000_000, 21_000_000_000_000_000, 0, Ok(u64::MAX)),
+            (
+                21_000_000_000_000_000,
+                21_000_000_000_000_000,
+                0,
+                Ok(u64::MAX),
+            ),
         ]
         .iter()
         .for_each(
@@ -4213,22 +4270,31 @@ fn test_max_amount_remove_dynamic() {
                 SubnetTAO::<Test>::insert(netuid, tao_in);
                 SubnetAlphaIn::<Test>::insert(netuid, alpha_in);
 
-            if alpha_in != 0 {
-                let expected_price = I96F32::from_num(tao_in) / I96F32::from_num(alpha_in);
-                assert_eq!(
-                    <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid),
-                    expected_price
-                );
-            }
+                if alpha_in != 0 {
+                    let expected_price = I96F32::from_num(tao_in) / I96F32::from_num(alpha_in);
+                    assert_eq!(
+                        <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid),
+                        expected_price
+                    );
+                }
 
-            let expected = expected_max_swappable
-                .saturating_add((expected_max_swappable as f64 * 0.003) as u64);
-            assert_abs_diff_eq!(
-                SubtensorModule::get_max_amount_remove(netuid, limit_price),
-                expected,
-                epsilon = expected / 100
-            );
-        });
+                match expected_max_swappable {
+                    Err(_) => assert_err!(
+                        SubtensorModule::get_max_amount_remove(netuid, limit_price),
+                        Error::<Test>::ZeroMaxStakeAmount
+                    ),
+                    Ok(v) => {
+                        let expected = v.saturating_add((*v as f64 * 0.003) as u64);
+
+                        assert_abs_diff_eq!(
+                            SubtensorModule::get_max_amount_remove(netuid, limit_price).unwrap(),
+                            expected,
+                            epsilon = expected / 100
+                        );
+                    }
+                }
+            },
+        );
     });
 }
 
@@ -4361,7 +4427,8 @@ fn test_max_amount_move_stable_dynamic() {
         // 2x price => max is 1x TAO
         let tao_reserve_u64 = tao_reserve.to_num::<u64>();
         assert_abs_diff_eq!(
-            SubtensorModule::get_max_amount_move(stable_netuid, dynamic_netuid, 500_000_000).unwrap(),
+            SubtensorModule::get_max_amount_move(stable_netuid, dynamic_netuid, 500_000_000)
+                .unwrap(),
             tao_reserve_u64 + (tao_reserve_u64 as f64 * 0.003) as u64,
             epsilon = tao_reserve_u64 / 100,
         );
@@ -4448,7 +4515,8 @@ fn test_max_amount_move_dynamic_stable() {
         // 1/4 price => max is 1x Alpha
         let alpha_in_u64 = alpha_in.to_num::<u64>();
         assert_abs_diff_eq!(
-            SubtensorModule::get_max_amount_move(dynamic_netuid, stable_netuid, 375_000_000).unwrap(),
+            SubtensorModule::get_max_amount_move(dynamic_netuid, stable_netuid, 375_000_000)
+                .unwrap(),
             alpha_in_u64 + (alpha_in_u64 as f64 * 0.003) as u64,
             epsilon = alpha_in_u64 / 1000,
         );
diff --git a/pallets/subtensor/src/tests/subnet.rs b/pallets/subtensor/src/tests/subnet.rs
index 3be74f273a..7df6df2ac4 100644
--- a/pallets/subtensor/src/tests/subnet.rs
+++ b/pallets/subtensor/src/tests/subnet.rs
@@ -60,7 +60,6 @@ fn test_do_start_call_fail_not_owner() {
         let netuid: u16 = 1;
         let tempo: u16 = 13;
         let coldkey_account_id = U256::from(0);
-        let hotkey_account_id = U256::from(1);
         let wrong_owner_account_id = U256::from(2);
         let burn_cost = 1000;
         //add network
@@ -92,7 +91,6 @@ fn test_do_start_call_fail_with_cannot_start_call_now() {
         let netuid: u16 = 1;
         let tempo: u16 = 13;
         let coldkey_account_id = U256::from(0);
-        let hotkey_account_id = U256::from(1);
         let burn_cost = 1000;
         //add network
         SubtensorModule::set_burn(netuid, burn_cost);
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index c741364b2a..8b497b3762 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,5 +1,5 @@
 [toolchain]
-channel = "1.86"
+channel = "1.87"
 components = [
 	"cargo",
 	"clippy",

From 64b2813c67ac01a372a60649971877d8f73ea4db Mon Sep 17 00:00:00 2001
From: Roman <roman@opentensor.dev>
Date: Wed, 28 May 2025 16:41:12 -0700
Subject: [PATCH 203/418] remove if with error

---
 pallets/drand/src/lib.rs | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/pallets/drand/src/lib.rs b/pallets/drand/src/lib.rs
index 08d728daa3..dd172befc0 100644
--- a/pallets/drand/src/lib.rs
+++ b/pallets/drand/src/lib.rs
@@ -288,10 +288,6 @@ pub mod pallet {
                     pulses_payload: payload,
                     signature,
                 } => {
-                    // Blacklist stale pulses in the txpool that can stall finalization.
-                    if payload.block_number < BlockNumberFor::<T>::from(5612500u32) {
-                        return InvalidTransaction::Stale.into();
-                    }
                     let signature = signature.as_ref().ok_or(InvalidTransaction::BadSigner)?;
                     Self::validate_signature_and_parameters(
                         payload,

From 7581c73c124fcdf6cf31ef1c4c19a7b64abe91a1 Mon Sep 17 00:00:00 2001
From: Roman <roman@opentensor.dev>
Date: Wed, 28 May 2025 16:41:30 -0700
Subject: [PATCH 204/418] bumping spec_version

---
 runtime/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index 0b64ee3cde..9bf932b298 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -209,7 +209,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
     //   `spec_version`, and `authoring_version` are the same between Wasm and native.
     // This value is set to 100 to notify Polkadot-JS App (https://polkadot.js.org/apps) to use
     //   the compatible custom types.
-    spec_version: 273,
+    spec_version: 274,
     impl_version: 1,
     apis: RUNTIME_API_VERSIONS,
     transaction_version: 1,

From e7cfc8324bbc9cfaf569d427a3d67209d4d6937c Mon Sep 17 00:00:00 2001
From: Roman <roman@opentensor.dev>
Date: Wed, 28 May 2025 17:24:10 -0700
Subject: [PATCH 205/418] add mirror for `apt-get update`

---
 Dockerfile-localnet | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Dockerfile-localnet b/Dockerfile-localnet
index 0de11cb866..d95a2f1a2c 100644
--- a/Dockerfile-localnet
+++ b/Dockerfile-localnet
@@ -15,6 +15,7 @@ LABEL ai.opentensor.image.authors="operations@opentensor.ai" \
 # Set up Rust environment
 ENV RUST_BACKTRACE=1
 
+RUN sed -i 's|http://archive.ubuntu.com/ubuntu|http://mirrors.edge.kernel.org/ubuntu|g' /etc/apt/sources.list
 RUN apt-get update
 RUN apt-get install -y curl build-essential protobuf-compiler clang git pkg-config libssl-dev llvm libudev-dev
 

From 86f1fc029757eb535dbc9982eb2d42a606d17cd8 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Thu, 29 May 2025 13:52:52 -0400
Subject: [PATCH 206/418] Fix test_swap_fees_tao_correctness and
 test_current_liquidity_updates

---
 pallets/subtensor/src/tests/staking.rs | 63 ++++++++++++++++++++++++
 pallets/swap/src/pallet/impls.rs       | 68 +++++++++++++++++++++++++-
 2 files changed, 130 insertions(+), 1 deletion(-)

diff --git a/pallets/subtensor/src/tests/staking.rs b/pallets/subtensor/src/tests/staking.rs
index 57538b5291..d69eb75406 100644
--- a/pallets/subtensor/src/tests/staking.rs
+++ b/pallets/subtensor/src/tests/staking.rs
@@ -4819,6 +4819,7 @@ fn test_swap_fees_tao_correctness() {
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, user_balance_before);
         let fee_rate = pallet_subtensor_swap::FeeRate::<Test>::get(NetUid::from(netuid)) as f64
             / u16::MAX as f64;
+        pallet_subtensor_swap::EnabledUserLiquidity::<Test>::insert(NetUid::from(netuid), true);
 
         // Forse-set alpha in and tao reserve to make price equal 0.25
         let tao_reserve = U96F32::from_num(100_000_000_000_u64);
@@ -4891,3 +4892,65 @@ fn test_swap_fees_tao_correctness() {
         assert_abs_diff_eq!(total_tao_before, total_tao_after, epsilon = 2,);
     });
 }
+
+/// This test verifies that minimum stake amount is sufficient to move price and apply
+/// non-zero staking fees
+#[test]
+fn test_default_min_stake_sufficiency() {
+    new_test_ext(1).execute_with(|| {
+        let owner_hotkey = U256::from(1);
+        let owner_coldkey = U256::from(2);
+        let coldkey = U256::from(4);
+        let min_tao_stake = DefaultMinStake::<Test>::get() * 2;
+        let amount = min_tao_stake;
+        let owner_balance_before = amount * 10;
+        let user_balance_before = amount * 100;
+
+        // add network
+        let netuid: u16 = add_dynamic_network(&owner_hotkey, &owner_coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&owner_coldkey, owner_balance_before);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, user_balance_before);
+        let fee_rate = pallet_subtensor_swap::FeeRate::<Test>::get(NetUid::from(netuid)) as f64
+            / u16::MAX as f64;
+
+        // Set some extreme, but realistic TAO and Alpha reserves to minimize slippage
+        // 1% of TAO max supply
+        // 0.01 Alpha price
+        let tao_reserve = U96F32::from_num(210_000_000_000_000_u64);
+        let alpha_in = U96F32::from_num(21_000_000_000_000_000_u64);
+        mock::setup_reserves(netuid, tao_reserve.to_num(), alpha_in.to_num());
+        let current_price_before =
+            <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid);
+
+        // Stake and unstake
+        assert_ok!(SubtensorModule::add_stake(
+            RuntimeOrigin::signed(coldkey),
+            owner_hotkey,
+            netuid,
+            amount,
+        ));
+        let fee_stake = (fee_rate * amount as f64) as u64;
+        let current_price_after_stake =
+            <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid);
+
+        let user_alpha = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+            &owner_hotkey,
+            &coldkey,
+            netuid,
+        );
+        assert_ok!(SubtensorModule::remove_stake(
+            RuntimeOrigin::signed(coldkey),
+            owner_hotkey,
+            netuid,
+            user_alpha,
+        ));
+        let fee_unstake = (fee_rate * user_alpha as f64) as u64;
+        let current_price_after_unstake =
+            <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid);
+
+        assert!(fee_stake > 0);
+        assert!(fee_unstake > 0);
+        assert!(current_price_after_stake > current_price_before);
+        assert!(current_price_after_stake > current_price_after_unstake);
+    });
+}
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 81ec74f183..e850d3b924 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -1012,7 +1012,7 @@ impl<T: Config> Pallet<T> {
         liquidity: i128,
     ) {
         let current_tick_index = TickIndex::current_bounded::<T>(netuid);
-        if (tick_low <= current_tick_index) && (current_tick_index <= tick_high) {
+        if (tick_low <= current_tick_index) && (current_tick_index < tick_high) {
             CurrentLiquidity::<T>::mutate(netuid, |current_liquidity| {
                 let is_neg = liquidity.is_negative();
                 let liquidity = liquidity.abs().min(u64::MAX as i128) as u64;
@@ -2577,4 +2577,70 @@ mod tests {
             assert_abs_diff_eq!(actual_fee_alpha, expected_fee, epsilon = 1,);
         });
     }
+
+    #[test]
+    fn test_current_liquidity_updates() {
+        let netuid = NetUid::from(1);
+        let liquidity = 1_000_000_000;
+
+        // Get current price
+        let (current_price, current_price_low, current_price_high) =
+            new_test_ext().execute_with(|| {
+                assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
+                let sqrt_current_price = AlphaSqrtPrice::<Test>::get(netuid);
+                let current_price = (sqrt_current_price * sqrt_current_price).to_num::<f64>();
+                let (current_price_low, current_price_high) =
+                    get_ticked_prices_around_current_price();
+                (current_price, current_price_low, current_price_high)
+            });
+
+        // Test case: (price_low, price_high, expect_to_update)
+        [
+            // Current price is out of position range (lower), no current lq update
+            (current_price * 2., current_price * 3., false),
+            // Current price is out of position range (higher), no current lq update
+            (current_price / 3., current_price / 2., false),
+            // Current price is just below position range, no current lq update
+            (current_price_high, current_price * 3., false),
+            // Position lower edge is just below the current price, current lq updates
+            (current_price_low, current_price * 3., true),
+            // Current price is exactly at lower edge of position range, current lq updates
+            (current_price, current_price * 3., true),
+            // Current price is exactly at higher edge of position range, no current lq update
+            (current_price / 2., current_price, false),
+        ]
+        .into_iter()
+        .for_each(|(price_low, price_high, expect_to_update)| {
+            new_test_ext().execute_with(|| {
+                assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
+
+                // Calculate ticks (assuming tick math is tested separately)
+                let tick_low = price_to_tick(price_low);
+                let tick_high = price_to_tick(price_high);
+                let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
+
+                // Add liquidity
+                assert_ok!(Pallet::<Test>::do_add_liquidity(
+                    netuid,
+                    &OK_COLDKEY_ACCOUNT_ID,
+                    &OK_HOTKEY_ACCOUNT_ID,
+                    tick_low,
+                    tick_high,
+                    liquidity,
+                ));
+
+                // Current liquidity is updated only when price range includes the current price
+                let expected_liquidity =
+                    if (price_high > current_price) && (price_low <= current_price) {
+                        assert!(expect_to_update);
+                        liquidity_before + liquidity
+                    } else {
+                        assert!(!expect_to_update);
+                        liquidity_before
+                    };
+
+                assert_eq!(CurrentLiquidity::<Test>::get(netuid), expected_liquidity)
+            });
+        });
+    }
 }

From 6c969d5709961e7502837ad04352020cfc2d6ec9 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Thu, 29 May 2025 19:57:52 +0200
Subject: [PATCH 207/418] Fix tests

---
 pallets/subtensor/src/staking/add_stake.rs    | 19 +++---
 pallets/subtensor/src/staking/remove_stake.rs | 20 +++---
 pallets/subtensor/src/tests/move_stake.rs     | 12 ++--
 pallets/subtensor/src/tests/staking.rs        | 68 ++++---------------
 pallets/subtensor/src/tests/subnet.rs         |  6 ++
 5 files changed, 49 insertions(+), 76 deletions(-)

diff --git a/pallets/subtensor/src/staking/add_stake.rs b/pallets/subtensor/src/staking/add_stake.rs
index aa3a939483..5a9e9c0678 100644
--- a/pallets/subtensor/src/staking/add_stake.rs
+++ b/pallets/subtensor/src/staking/add_stake.rs
@@ -1,7 +1,8 @@
-use super::*;
-use substrate_fixed::types::I96F32;
+use substrate_fixed::types::{I96F32, U96F32};
 use subtensor_swap_interface::{OrderType, SwapHandler};
 
+use super::*;
+
 impl<T: Config> Pallet<T> {
     /// ---- The implementation for the extrinsic add_stake: Adds stake to a hotkey account.
     ///
@@ -334,12 +335,14 @@ impl<T: Config> Pallet<T> {
         }
 
         // Use reverting swap to estimate max limit amount
-        let swap_result =
-            T::SwapInterface::swap(netuid, OrderType::Buy, u64::MAX, limit_price, true)
-                .map_err(|_| Error::ZeroMaxStakeAmount)?;
+        let result = T::SwapInterface::swap(netuid, OrderType::Buy, u64::MAX, limit_price, true)
+            .map(|r| r.amount_paid_in.saturating_add(r.fee_paid))
+            .map_err(|_| Error::ZeroMaxStakeAmount)?;
 
-        Ok(swap_result
-            .amount_paid_in
-            .saturating_add(swap_result.fee_paid))
+        if result != 0 {
+            Ok(result)
+        } else {
+            Err(Error::ZeroMaxStakeAmount)
+        }
     }
 }
diff --git a/pallets/subtensor/src/staking/remove_stake.rs b/pallets/subtensor/src/staking/remove_stake.rs
index efef359bfe..2bcd695d0c 100644
--- a/pallets/subtensor/src/staking/remove_stake.rs
+++ b/pallets/subtensor/src/staking/remove_stake.rs
@@ -1,6 +1,8 @@
-use super::*;
+use substrate_fixed::types::U96F32;
 use subtensor_swap_interface::{OrderType, SwapHandler};
 
+use super::*;
+
 impl<T: Config> Pallet<T> {
     /// ---- The implementation for the extrinsic remove_stake: Removes stake from a hotkey account and adds it onto a coldkey.
     ///
@@ -614,12 +616,14 @@ impl<T: Config> Pallet<T> {
         }
 
         // Use reverting swap to estimate max limit amount
-        let swap_result =
-            T::SwapInterface::swap(netuid, OrderType::Sell, u64::MAX, limit_price, true)
-                .map_err(|_| Error::ZeroMaxStakeAmount)?;
-
-        Ok(swap_result
-            .amount_paid_in
-            .saturating_add(swap_result.fee_paid))
+        let result = T::SwapInterface::swap(netuid, OrderType::Sell, u64::MAX, limit_price, true)
+            .map(|r| r.amount_paid_in.saturating_add(r.fee_paid))
+            .map_err(|_| Error::ZeroMaxStakeAmount)?;
+
+        if result != 0 {
+            Ok(result)
+        } else {
+            Err(Error::ZeroMaxStakeAmount)
+        }
     }
 }
diff --git a/pallets/subtensor/src/tests/move_stake.rs b/pallets/subtensor/src/tests/move_stake.rs
index 840fab2198..2718f3f548 100644
--- a/pallets/subtensor/src/tests/move_stake.rs
+++ b/pallets/subtensor/src/tests/move_stake.rs
@@ -1448,9 +1448,7 @@ fn test_do_swap_same_subnet() {
         let alpha_before =
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid);
 
-        let (tao_equivalent, _) = mock::swap_alpha_to_tao(netuid, alpha_before);
-        let (expected_alpha, _) = mock::swap_tao_to_alpha(netuid, tao_equivalent);
-        assert_eq!(
+        assert_err!(
             SubtensorModule::do_swap_stake(
                 RuntimeOrigin::signed(coldkey),
                 hotkey,
@@ -1458,12 +1456,12 @@ fn test_do_swap_same_subnet() {
                 netuid,
                 alpha_before
             ),
-            Err(Error::<Test>::SameNetuid.into())
+            DispatchError::from(Error::<Test>::SameNetuid)
         );
 
         let alpha_after =
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid);
-        assert_abs_diff_eq!(alpha_after, expected_alpha, epsilon = 1000);
+        assert_eq!(alpha_after, alpha_before);
     });
 }
 
@@ -1690,6 +1688,10 @@ fn test_swap_stake_limit_validate() {
         let hotkey = U256::from(2);
         let stake_amount = 100_000_000_000;
 
+        let reserve = 1_000_000_000_000;
+        mock::setup_reserves(origin_netuid, reserve, reserve);
+        mock::setup_reserves(destination_netuid, reserve, reserve);
+
         SubtensorModule::create_account_if_non_existent(&coldkey, &hotkey);
         let unstake_amount = SubtensorModule::stake_into_subnet(
             &hotkey,
diff --git a/pallets/subtensor/src/tests/staking.rs b/pallets/subtensor/src/tests/staking.rs
index fc4d3db87d..97ec31a6ca 100644
--- a/pallets/subtensor/src/tests/staking.rs
+++ b/pallets/subtensor/src/tests/staking.rs
@@ -4004,51 +4004,6 @@ fn test_max_amount_add_dynamic() {
         ),
         // Miscellaneous overflows and underflows
         (u64::MAX / 2, u64::MAX, u64::MAX, Ok(u64::MAX)),
-        // (150_000_000_000, 100_000_000_000, u64::MAX / 2, u64::MAX),
-        // (1_000_000, 1_000_000_000_000_000_000_u64, 1, 999_000_000),
-        // (1_000_000, 1_000_000_000_000_000_000_u64, 2, 1_999_000_000),
-        // (
-        //     1_000_000,
-        //     1_000_000_000_000_000_000_u64,
-        //     10_000,
-        //     9_999_999_000_000,
-        // ),
-        // (
-        //     1_000_000,
-        //     1_000_000_000_000_000_000_u64,
-        //     100_000,
-        //     99_999_999_000_000,
-        // ),
-        // (
-        //     1_000_000,
-        //     1_000_000_000_000_000_000_u64,
-        //     1_000_000,
-        //     999_999_999_000_000,
-        // ),
-        // (
-        //     1_000_000,
-        //     1_000_000_000_000_000_000_u64,
-        //     1_000_000_000,
-        //     999_999_999_999_000_000,
-        // ),
-        // (
-        //     21_000_000_000_000_000,
-        //     10_000_000,
-        //     4_200_000_000_000_000_000,
-        //     21_000_000_000_000_000,
-        // ),
-        // (
-        //     21_000_000_000_000_000,
-        //     1_000_000_000_000_000_000_u64,
-        //     u64::MAX,
-        //     u64::MAX,
-        // ),
-        // (
-        //     21_000_000_000_000_000,
-        //     1_000_000_000_000_000_000_u64,
-        //     42_000_000,
-        //     21_000_000_000_000_000,
-        // ),
     ]
     .into_iter()
     .for_each(|(tao_in, alpha_in, limit_price, expected_max_swappable)| {
@@ -6193,10 +6148,10 @@ fn test_stake_into_subnet_prohibitive_limit() {
                 owner_hotkey,
                 netuid,
                 amount,
-                u64::MIN,
+                0,
                 true,
             ),
-            Error::<Test>::AmountTooLow
+            Error::<Test>::ZeroMaxStakeAmount
         );
 
         // Check if stake has NOT increased
@@ -6257,14 +6212,17 @@ fn test_unstake_from_subnet_prohibitive_limit() {
             &coldkey,
             netuid,
         );
-        assert_ok!(SubtensorModule::remove_stake_limit(
-            RuntimeOrigin::signed(coldkey),
-            owner_hotkey,
-            netuid,
-            alpha,
-            u64::MAX,
-            true,
-        ));
+        assert_err!(
+            SubtensorModule::remove_stake_limit(
+                RuntimeOrigin::signed(coldkey),
+                owner_hotkey,
+                netuid,
+                alpha,
+                u64::MAX,
+                true,
+            ),
+            Error::<Test>::ZeroMaxStakeAmount
+        );
 
         // Check if stake has NOT decreased
         assert_eq!(
diff --git a/pallets/subtensor/src/tests/subnet.rs b/pallets/subtensor/src/tests/subnet.rs
index 7df6df2ac4..6c33b01af6 100644
--- a/pallets/subtensor/src/tests/subnet.rs
+++ b/pallets/subtensor/src/tests/subnet.rs
@@ -389,6 +389,12 @@ fn test_subtoken_enable_trading_ok_with_enable() {
 
         add_network(netuid, 10, 0);
         add_network(netuid2, 10, 0);
+
+        let reserve = 1_000_000_000_000_000;
+        mock::setup_reserves(0, reserve, reserve);
+        mock::setup_reserves(netuid, reserve, reserve);
+        mock::setup_reserves(netuid2, reserve, reserve);
+
         // Register so staking works
         register_ok_neuron(netuid, hotkey_account_id, coldkey_account_id, 0);
         register_ok_neuron(netuid2, hotkey_account_id, coldkey_account_id, 100);

From f0eda418685435d5db4616872be572be00ba8ccf Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Thu, 29 May 2025 21:20:03 +0200
Subject: [PATCH 208/418] Clean up lints

---
 Cargo.toml                                    | 1 +
 pallets/subtensor/src/staking/add_stake.rs    | 2 +-
 pallets/subtensor/src/staking/remove_stake.rs | 2 --
 pallets/swap/src/tick.rs                      | 4 ++--
 4 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 78f867a8e8..97c8afa226 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -43,6 +43,7 @@ type_complexity = "allow"
 unwrap-used = "deny"
 manual_inspect = "allow"
 useless_conversion = "allow"     # until polkadot is patched
+result_large_err = "allow"
 
 [workspace.dependencies]
 node-subtensor-runtime = { default-features = false, path = "runtime" }
diff --git a/pallets/subtensor/src/staking/add_stake.rs b/pallets/subtensor/src/staking/add_stake.rs
index 5a9e9c0678..243c7c3c36 100644
--- a/pallets/subtensor/src/staking/add_stake.rs
+++ b/pallets/subtensor/src/staking/add_stake.rs
@@ -1,4 +1,4 @@
-use substrate_fixed::types::{I96F32, U96F32};
+use substrate_fixed::types::I96F32;
 use subtensor_swap_interface::{OrderType, SwapHandler};
 
 use super::*;
diff --git a/pallets/subtensor/src/staking/remove_stake.rs b/pallets/subtensor/src/staking/remove_stake.rs
index fd6e0be323..bbd872c25f 100644
--- a/pallets/subtensor/src/staking/remove_stake.rs
+++ b/pallets/subtensor/src/staking/remove_stake.rs
@@ -1,4 +1,3 @@
-use substrate_fixed::types::U96F32;
 use subtensor_swap_interface::{OrderType, SwapHandler};
 
 use super::*;
@@ -212,7 +211,6 @@ impl<T: Config> Pallet<T> {
             // Ensure that the hotkey has enough stake to withdraw.
             let alpha_unstaked =
                 Self::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid);
-			dbg!(alpha_unstaked);
 
             if Self::validate_remove_stake(
                 &coldkey,
diff --git a/pallets/swap/src/tick.rs b/pallets/swap/src/tick.rs
index 667764f63b..52bb2c1a3d 100644
--- a/pallets/swap/src/tick.rs
+++ b/pallets/swap/src/tick.rs
@@ -781,8 +781,8 @@ impl TickIndexBitmap {
     /// # Arguments
     /// * `word` - The bitmap word to search within
     /// * `bit` - The bit position to start searching from
-    /// * `lower` - If true, search for lower bits (decreasing bit position),
-    ///             if false, search for higher bits (increasing bit position)
+    /// * `lower` - If true, search for lower bits (decreasing bit position), if false, search for
+    ///   higher bits (increasing bit position)
     ///
     /// # Returns
     /// * Exact match: Vec with [next_bit, bit]

From f7d24359099fde1d2442d15203caff24f1da3ef7 Mon Sep 17 00:00:00 2001
From: Shamil Gadelshin <shamilgadelshin@gmail.com>
Date: Fri, 30 May 2025 16:30:15 +0400
Subject: [PATCH 209/418] Fix migration weights

---
 pallets/subtensor/src/macros/hooks.rs | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/pallets/subtensor/src/macros/hooks.rs b/pallets/subtensor/src/macros/hooks.rs
index a0e2fc6e72..8dff0ed106 100644
--- a/pallets/subtensor/src/macros/hooks.rs
+++ b/pallets/subtensor/src/macros/hooks.rs
@@ -102,9 +102,7 @@ mod hooks {
                 // Remove all entries in TotalHotkeyColdkeyStakesThisInterval
                 .saturating_add(migrations::migrate_remove_total_hotkey_coldkey_stakes_this_interval::migrate_remove_total_hotkey_coldkey_stakes_this_interval::<T>())
                 // Wipe the deprecated RateLimit storage item in the commitments pallet
-                .saturating_add(migrations::migrate_remove_commitments_rate_limit::migrate_remove_commitments_rate_limit::<T>());
-
-            weight
+                .saturating_add(migrations::migrate_remove_commitments_rate_limit::migrate_remove_commitments_rate_limit::<T>())
                 // Remove all entries in orphaned storage items
                 .saturating_add(
                     migrations::migrate_orphaned_storage_items::migrate_orphaned_storage_items::<T>(

From 0d18c16d67983137694c2bbf06cbc77947ca20c6 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Fri, 30 May 2025 21:07:07 +0800
Subject: [PATCH 210/418] remove duplicated doc

---
 pallets/subtensor/src/macros/errors.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/pallets/subtensor/src/macros/errors.rs b/pallets/subtensor/src/macros/errors.rs
index c634a98182..6e701014ae 100644
--- a/pallets/subtensor/src/macros/errors.rs
+++ b/pallets/subtensor/src/macros/errors.rs
@@ -212,7 +212,6 @@ mod errors {
         SubtokenDisabled,
         /// Too frequent hotkey swap on subnet
         HotKeySwapOnSubnetIntervalNotPassed,
-        /// Estimating the maximum stake for limited staking operations returned zero.
         /// Zero max stake amount
         ZeroMaxStakeAmount,
         /// Invalid netuid duplication

From 13c6b362ba9fb2923595ec4a37c059a922516bc7 Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Fri, 30 May 2025 16:08:03 +0200
Subject: [PATCH 211/418] bump to polkadot-sdk-stable2412-5 + bump frontier rev

---
 Cargo.lock | 4393 ++++++++++++++++++++++++++++++++++++++--------------
 Cargo.toml |  198 +--
 2 files changed, 3316 insertions(+), 1275 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index b0c56ffb2e..fd60abf24a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -77,7 +77,7 @@ version = "0.7.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "891477e0c6a8957309ee5c45a6368af3ae14bb510732d2684ffa19af310920f9"
 dependencies = [
- "getrandom",
+ "getrandom 0.2.15",
  "once_cell",
  "version_check",
 ]
@@ -89,7 +89,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e89da841a80418a9b391ebaea17f5c112ffaaa96f621d2c285b5174da76b9011"
 dependencies = [
  "cfg-if",
- "getrandom",
+ "getrandom 0.2.15",
  "once_cell",
  "version_check",
  "zerocopy",
@@ -200,7 +200,7 @@ dependencies = [
  "proc-macro-error",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -533,7 +533,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "94893f1e0c6eeab764ade8dc4c0db24caf4fe7cbbaafc0eba0a9030f447b5185"
 dependencies = [
  "num-traits",
- "rand",
+ "rand 0.8.5",
  "rayon",
 ]
 
@@ -549,6 +549,15 @@ version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb"
 
+[[package]]
+name = "arrayvec"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd9fd44efafa8690358b7408d253adf110036b88f55672a933f01d616ad9b1b9"
+dependencies = [
+ "nodrop",
+]
+
 [[package]]
 name = "arrayvec"
 version = "0.7.6"
@@ -567,23 +576,23 @@ dependencies = [
  "nom",
  "num-traits",
  "rusticata-macros",
- "thiserror",
+ "thiserror 1.0.64",
  "time",
 ]
 
 [[package]]
 name = "asn1-rs"
-version = "0.6.2"
+version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5493c3bedbacf7fd7382c6346bbd66687d12bbaad3a89a2d2c303ee6cf20b048"
+checksum = "56624a96882bb8c26d61312ae18cb45868e5a9992ea73c58e45c3101e56a1e60"
 dependencies = [
- "asn1-rs-derive 0.5.1",
+ "asn1-rs-derive 0.6.0",
  "asn1-rs-impl 0.2.0",
  "displaydoc",
  "nom",
  "num-traits",
  "rusticata-macros",
- "thiserror",
+ "thiserror 2.0.12",
  "time",
 ]
 
@@ -601,13 +610,13 @@ dependencies = [
 
 [[package]]
 name = "asn1-rs-derive"
-version = "0.5.1"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "965c2d33e53cb6b267e148a4cb0760bc01f4904c1cd4bb4002a085bb016d1490"
+checksum = "3109e49b1e4909e9db6515a30c633684d68cdeaa252f215214cb4fa1a5bfee2c"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
  "synstructure 0.13.1",
 ]
 
@@ -630,7 +639,7 @@ checksum = "7b18050c2cd6fe86c3a76584ef5e0baf286d038cda203eb6223df2cc413565f7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -650,6 +659,43 @@ dependencies = [
  "futures-core",
 ]
 
+[[package]]
+name = "async-channel"
+version = "2.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "89b47800b0be77592da0afd425cc03468052844aff33b84e33cc696f64e77b6a"
+dependencies = [
+ "concurrent-queue",
+ "event-listener-strategy",
+ "futures-core",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "async-executor"
+version = "1.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb812ffb58524bdd10860d7d974e2f01cc0950c2438a74ee5ec2e2280c6c4ffa"
+dependencies = [
+ "async-task",
+ "concurrent-queue",
+ "fastrand",
+ "futures-lite",
+ "pin-project-lite",
+ "slab",
+]
+
+[[package]]
+name = "async-fs"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebcd09b382f40fcd159c2d695175b2ae620ffa5f3bd6f664131efff4e8b9e04a"
+dependencies = [
+ "async-lock",
+ "blocking",
+ "futures-lite",
+]
+
 [[package]]
 name = "async-io"
 version = "2.3.4"
@@ -680,15 +726,69 @@ dependencies = [
  "pin-project-lite",
 ]
 
+[[package]]
+name = "async-net"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b948000fad4873c1c9339d60f2623323a0cfd3816e5181033c6a5cb68b2accf7"
+dependencies = [
+ "async-io",
+ "blocking",
+ "futures-lite",
+]
+
+[[package]]
+name = "async-process"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63255f1dc2381611000436537bbedfe83183faa303a5a0edaf191edef06526bb"
+dependencies = [
+ "async-channel 2.3.1",
+ "async-io",
+ "async-lock",
+ "async-signal",
+ "async-task",
+ "blocking",
+ "cfg-if",
+ "event-listener 5.3.1",
+ "futures-lite",
+ "rustix 0.38.37",
+ "tracing",
+]
+
+[[package]]
+name = "async-signal"
+version = "0.2.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "637e00349800c0bdf8bfc21ebbc0b6524abea702b0da4168ac00d070d0c0b9f3"
+dependencies = [
+ "async-io",
+ "async-lock",
+ "atomic-waker",
+ "cfg-if",
+ "futures-core",
+ "futures-io",
+ "rustix 0.38.37",
+ "signal-hook-registry",
+ "slab",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "async-task"
+version = "4.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de"
+
 [[package]]
 name = "async-trait"
-version = "0.1.83"
+version = "0.1.88"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "721cae7de5c34fbb2acd27e21e6d2cf7b886dce0c27388d46c4e6c47ea4318dd"
+checksum = "e539d3fca749fcee5236ab05e93a52867dd549cc157c8cb7f99595f3cedffdb5"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -713,6 +813,12 @@ dependencies = [
  "num-traits",
 ]
 
+[[package]]
+name = "atomic-take"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8ab6b55fe97976e46f91ddbed8d147d966475dc29b2032757ba47e02376fbc3"
+
 [[package]]
 name = "atomic-waker"
 version = "1.1.2"
@@ -738,7 +844,7 @@ checksum = "3c87f3f15e7794432337fc718554eaa4dc8f04c9677a950ffe366f20a162ae42"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -774,6 +880,12 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf"
 
+[[package]]
+name = "base58"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6107fe1be6682a68940da878d9e9f5e90ca5745b3dec9fd1bb393c8777d4f581"
+
 [[package]]
 name = "base64"
 version = "0.13.1"
@@ -798,6 +910,25 @@ version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"
 
+[[package]]
+name = "beef"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a8241f3ebb85c056b509d4327ad0358fbbba6ffb340bf388f26350aeda225b1"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "binary-merkle-tree"
+version = "16.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+dependencies = [
+ "hash-db",
+ "log",
+ "parity-scale-codec",
+]
+
 [[package]]
 name = "bincode"
 version = "1.3.3"
@@ -819,13 +950,41 @@ dependencies = [
  "lazy_static",
  "lazycell",
  "peeking_take_while",
- "prettyplease 0.2.22",
+ "prettyplease",
  "proc-macro2",
  "quote",
  "regex",
  "rustc-hash 1.1.0",
  "shlex",
- "syn 2.0.90",
+ "syn 2.0.101",
+]
+
+[[package]]
+name = "bip32"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db40d3dfbeab4e031d78c844642fa0caa0b0db11ce1607ac9d2986dff1405c69"
+dependencies = [
+ "bs58",
+ "hmac 0.12.1",
+ "k256",
+ "rand_core 0.6.4",
+ "ripemd",
+ "secp256k1 0.27.0",
+ "sha2 0.10.8",
+ "subtle 2.6.1",
+ "zeroize",
+]
+
+[[package]]
+name = "bip39"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33415e24172c1b7d6066f6d999545375ab8e1d95421d6784bdfff9496f292387"
+dependencies = [
+ "bitcoin_hashes",
+ "serde",
+ "unicode-normalization",
 ]
 
 [[package]]
@@ -864,6 +1023,7 @@ checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
 dependencies = [
  "funty",
  "radium",
+ "serde",
  "tap",
  "wyz",
 ]
@@ -889,6 +1049,16 @@ dependencies = [
  "digest 0.10.7",
 ]
 
+[[package]]
+name = "blake2-rfc"
+version = "0.2.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d6d530bdd2d52966a6d03b7a964add7ae1a288d25214066fd4b600f0f796400"
+dependencies = [
+ "arrayvec 0.4.12",
+ "constant_time_eq 0.1.5",
+]
+
 [[package]]
 name = "blake2b_simd"
 version = "1.0.2"
@@ -896,8 +1066,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "23285ad32269793932e830392f2fe2f83e26488fd3ec778883a93c8323735780"
 dependencies = [
  "arrayref",
- "arrayvec",
- "constant_time_eq",
+ "arrayvec 0.7.6",
+ "constant_time_eq 0.3.1",
 ]
 
 [[package]]
@@ -907,8 +1077,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "94230421e395b9920d23df13ea5d77a20e1725331f90fbbf6df6040b33f756ae"
 dependencies = [
  "arrayref",
- "arrayvec",
- "constant_time_eq",
+ "arrayvec 0.7.6",
+ "constant_time_eq 0.3.1",
 ]
 
 [[package]]
@@ -918,10 +1088,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d82033247fd8e890df8f740e407ad4d038debb9eb1f40533fffb32e7d17dc6f7"
 dependencies = [
  "arrayref",
- "arrayvec",
+ "arrayvec 0.7.6",
  "cc",
  "cfg-if",
- "constant_time_eq",
+ "constant_time_eq 0.3.1",
 ]
 
 [[package]]
@@ -942,6 +1112,19 @@ dependencies = [
  "generic-array 0.14.7",
 ]
 
+[[package]]
+name = "blocking"
+version = "1.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "703f41c54fc768e63e091340b424302bb1c29ef4aa0c7f10fe849dfb114d29ea"
+dependencies = [
+ "async-channel 2.3.1",
+ "async-task",
+ "futures-io",
+ "futures-lite",
+ "piper",
+]
+
 [[package]]
 name = "bounded-collections"
 version = "0.2.0"
@@ -955,10 +1138,13 @@ dependencies = [
 ]
 
 [[package]]
-name = "bs58"
-version = "0.4.0"
+name = "bounded-vec"
+version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "771fe0050b883fcc3ea2359b1a96bcfbc090b7116eae7c3c512c7a083fdf23d3"
+checksum = "68534a48cbf63a4b1323c433cf21238c9ec23711e0df13b08c33e5c2082663ce"
+dependencies = [
+ "thiserror 1.0.64",
+]
 
 [[package]]
 name = "bs58"
@@ -966,6 +1152,7 @@ version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bf88ba1141d185c399bee5288d850d63b8369520c1eafc32a0430b5b6c287bf4"
 dependencies = [
+ "sha2 0.10.8",
  "tinyvec",
 ]
 
@@ -986,9 +1173,9 @@ checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c"
 
 [[package]]
 name = "byte-slice-cast"
-version = "1.2.2"
+version = "1.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3ac9f8b63eca6fd385229b3675f6cc0dc5c8a5c8a54a59d4f52ffd670d87b0c"
+checksum = "7575182f7272186991736b70173b0ea045398f984bf5ebbb3804736ce1330c9d"
 
 [[package]]
 name = "byte-tools"
@@ -1010,9 +1197,9 @@ checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 
 [[package]]
 name = "bytes"
-version = "1.7.2"
+version = "1.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "428d9aa8fbc0670b7b8d6030a7fadd0f86151cae55e4dbbece15f3780a3dfaf3"
+checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a"
 
 [[package]]
 name = "bzip2-sys"
@@ -1064,7 +1251,7 @@ dependencies = [
  "semver 1.0.23",
  "serde",
  "serde_json",
- "thiserror",
+ "thiserror 1.0.64",
 ]
 
 [[package]]
@@ -1084,6 +1271,12 @@ dependencies = [
  "shlex",
 ]
 
+[[package]]
+name = "cesu8"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d43a04d8753f35258c91f8ec639f792891f748a1edbd759cf1dcea3382ad83c"
+
 [[package]]
 name = "cexpr"
 version = "0.6.0"
@@ -1114,6 +1307,12 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fd16c4719339c4530435d38e511904438d07cce7950afa3718a84ac36c10e89e"
 
+[[package]]
+name = "cfg_aliases"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
+
 [[package]]
 name = "chacha"
 version = "0.3.0"
@@ -1178,15 +1377,14 @@ dependencies = [
 
 [[package]]
 name = "cid"
-version = "0.10.1"
+version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd94671561e36e4e7de75f753f577edafb0e7c05d6e4547229fdf7938fbcd2c3"
+checksum = "3147d8272e8fa0ccd29ce51194dd98f79ddfb8191ba9e3409884e751798acf3a"
 dependencies = [
  "core2",
  "multibase",
- "multihash 0.18.1",
- "serde",
- "unsigned-varint 0.7.2",
+ "multihash 0.19.2",
+ "unsigned-varint 0.8.0",
 ]
 
 [[package]]
@@ -1239,7 +1437,7 @@ dependencies = [
  "anstream",
  "anstyle",
  "clap_lex",
- "strsim",
+ "strsim 0.11.1",
  "terminal_size",
 ]
 
@@ -1252,7 +1450,7 @@ dependencies = [
  "heck 0.5.0",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -1261,6 +1459,17 @@ version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1462739cb27611015575c0c11df5df7601141071f07518d56fcc1be504cbec97"
 
+[[package]]
+name = "coarsetime"
+version = "0.1.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91849686042de1b41cd81490edc83afbcb0abe5a9b6f2c4114f23ce8cca1bcf4"
+dependencies = [
+ "libc",
+ "wasix",
+ "wasm-bindgen",
+]
+
 [[package]]
 name = "codespan-reporting"
 version = "0.11.1"
@@ -1326,6 +1535,19 @@ dependencies = [
  "windows-sys 0.52.0",
 ]
 
+[[package]]
+name = "const-hex"
+version = "1.14.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83e22e0ed40b96a48d3db274f72fd365bd78f67af39b6bbd47e8a15e1c6207ff"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "hex",
+ "proptest",
+ "serde",
+]
+
 [[package]]
 name = "const-oid"
 version = "0.9.6"
@@ -1347,11 +1569,37 @@ version = "0.1.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f9d839f2a20b0aee515dc581a6172f2321f96cab76c1a38a4c584a194955390e"
 dependencies = [
- "getrandom",
+ "getrandom 0.2.15",
  "once_cell",
  "tiny-keccak",
 ]
 
+[[package]]
+name = "const_format"
+version = "0.2.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "126f97965c8ad46d6d9163268ff28432e8f6a1196a55578867832e3049df63dd"
+dependencies = [
+ "const_format_proc_macros",
+]
+
+[[package]]
+name = "const_format_proc_macros"
+version = "0.2.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d57c2eccfb16dbac1f4e61e206105db5820c9d26c3c472bc17c774259ef7744"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-xid",
+]
+
+[[package]]
+name = "constant_time_eq"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "245097e9a4535ee1e3e3931fcfcd55a796a44c643e8596ff6566d68f09b87bbc"
+
 [[package]]
 name = "constant_time_eq"
 version = "0.3.1"
@@ -1380,6 +1628,16 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "core-foundation"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b55271e5c8c478ad3f38ad24ef34923091e0548492a266d19b3c0b4d82574c63"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
 [[package]]
 name = "core-foundation-sys"
 version = "0.8.7"
@@ -1582,7 +1840,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76"
 dependencies = [
  "generic-array 0.14.7",
- "rand_core",
+ "rand_core 0.6.4",
  "subtle 2.6.1",
  "zeroize",
 ]
@@ -1594,7 +1852,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
 dependencies = [
  "generic-array 0.14.7",
- "rand_core",
+ "rand_core 0.6.4",
  "typenum 1.17.0",
 ]
 
@@ -1628,49 +1886,143 @@ dependencies = [
 ]
 
 [[package]]
-name = "curve25519-dalek"
-version = "4.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97fb8b7c4503de7d6ae7b42ab72a5a59857b4c937ec27a3d4539dba95b5ab2be"
+name = "cumulus-client-parachain-inherent"
+version = "0.15.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
- "cfg-if",
- "cpufeatures",
- "curve25519-dalek-derive",
- "digest 0.10.7",
- "fiat-crypto",
- "rustc_version 0.4.1",
- "subtle 2.6.1",
- "zeroize",
+ "async-trait",
+ "cumulus-primitives-core",
+ "cumulus-primitives-parachain-inherent",
+ "cumulus-relay-chain-interface",
+ "cumulus-test-relay-sproof-builder",
+ "parity-scale-codec",
+ "sc-client-api",
+ "sp-api",
+ "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-inherents",
+ "sp-runtime",
+ "sp-state-machine",
+ "sp-storage 22.0.0",
+ "sp-trie",
+ "tracing",
 ]
 
 [[package]]
-name = "curve25519-dalek-derive"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3"
+name = "cumulus-primitives-core"
+version = "0.17.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.90",
+ "parity-scale-codec",
+ "polkadot-core-primitives",
+ "polkadot-parachain-primitives",
+ "polkadot-primitives",
+ "scale-info",
+ "sp-api",
+ "sp-runtime",
+ "sp-trie",
+ "staging-xcm",
 ]
 
 [[package]]
-name = "cxx"
-version = "1.0.128"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "54ccead7d199d584d139148b04b4a368d1ec7556a1d9ea2548febb1b9d49f9a4"
+name = "cumulus-primitives-parachain-inherent"
+version = "0.17.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
- "cc",
- "cxxbridge-flags",
- "cxxbridge-macro",
- "link-cplusplus",
+ "async-trait",
+ "cumulus-primitives-core",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-inherents",
+ "sp-trie",
 ]
 
 [[package]]
-name = "cxx-build"
-version = "1.0.128"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c77953e99f01508f89f55c494bfa867171ef3a6c8cea03d26975368f2121a5c1"
+name = "cumulus-primitives-proof-size-hostfunction"
+version = "0.11.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+dependencies = [
+ "sp-externalities 0.30.0",
+ "sp-runtime-interface 29.0.0",
+ "sp-trie",
+]
+
+[[package]]
+name = "cumulus-relay-chain-interface"
+version = "0.21.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+dependencies = [
+ "async-trait",
+ "cumulus-primitives-core",
+ "futures",
+ "jsonrpsee-core 0.24.7",
+ "parity-scale-codec",
+ "polkadot-overseer",
+ "sc-client-api",
+ "sp-api",
+ "sp-blockchain",
+ "sp-state-machine",
+ "sp-version",
+ "thiserror 1.0.64",
+]
+
+[[package]]
+name = "cumulus-test-relay-sproof-builder"
+version = "0.17.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+dependencies = [
+ "cumulus-primitives-core",
+ "parity-scale-codec",
+ "polkadot-primitives",
+ "sp-runtime",
+ "sp-state-machine",
+ "sp-trie",
+]
+
+[[package]]
+name = "curve25519-dalek"
+version = "4.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97fb8b7c4503de7d6ae7b42ab72a5a59857b4c937ec27a3d4539dba95b5ab2be"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "curve25519-dalek-derive",
+ "digest 0.10.7",
+ "fiat-crypto",
+ "rustc_version 0.4.1",
+ "subtle 2.6.1",
+ "zeroize",
+]
+
+[[package]]
+name = "curve25519-dalek-derive"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.101",
+]
+
+[[package]]
+name = "cxx"
+version = "1.0.128"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "54ccead7d199d584d139148b04b4a368d1ec7556a1d9ea2548febb1b9d49f9a4"
+dependencies = [
+ "cc",
+ "cxxbridge-flags",
+ "cxxbridge-macro",
+ "link-cplusplus",
+]
+
+[[package]]
+name = "cxx-build"
+version = "1.0.128"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c77953e99f01508f89f55c494bfa867171ef3a6c8cea03d26975368f2121a5c1"
 dependencies = [
  "cc",
  "codespan-reporting",
@@ -1678,7 +2030,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "scratch",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -1695,7 +2047,17 @@ checksum = "98532a60dedaebc4848cb2cba5023337cc9ea3af16a5b062633fabfd9f18fb60"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
+]
+
+[[package]]
+name = "darling"
+version = "0.14.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b750cb3417fd1b327431a470f388520309479ab0bf5e323505daf0290cd3850"
+dependencies = [
+ "darling_core 0.14.4",
+ "darling_macro 0.14.4",
 ]
 
 [[package]]
@@ -1704,8 +2066,22 @@ version = "0.20.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6f63b86c8a8826a49b8c21f08a2d07338eec8d900540f8630dc76284be802989"
 dependencies = [
- "darling_core",
- "darling_macro",
+ "darling_core 0.20.10",
+ "darling_macro 0.20.10",
+]
+
+[[package]]
+name = "darling_core"
+version = "0.14.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "109c1ca6e6b7f82cc233a97004ea8ed7ca123a9af07a8230878fcfda9b158bf0"
+dependencies = [
+ "fnv",
+ "ident_case",
+ "proc-macro2",
+ "quote",
+ "strsim 0.10.0",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -1718,8 +2094,19 @@ dependencies = [
  "ident_case",
  "proc-macro2",
  "quote",
- "strsim",
- "syn 2.0.90",
+ "strsim 0.11.1",
+ "syn 2.0.101",
+]
+
+[[package]]
+name = "darling_macro"
+version = "0.14.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4aab4dbc9f7611d8b55048a3a16d2d010c2c8334e46304b40ac1cc14bf3b48e"
+dependencies = [
+ "darling_core 0.14.4",
+ "quote",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -1728,9 +2115,9 @@ version = "0.20.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d336a2a514f6ccccaa3e09b02d41d35330c07ddf03a62165fcec10bb561c7806"
 dependencies = [
- "darling_core",
+ "darling_core 0.20.10",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -1798,11 +2185,11 @@ dependencies = [
 
 [[package]]
 name = "der-parser"
-version = "9.0.0"
+version = "10.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5cd0a5c643689626bec213c4d8bd4d96acc8ffdb4ad4bb6bc16abf27d5f4b553"
+checksum = "07da5016415d5a3c4dd39b11ed26f915f52fc4e0dc197d87908bc916e51bc1a6"
 dependencies = [
- "asn1-rs 0.6.2",
+ "asn1-rs 0.7.1",
  "displaydoc",
  "nom",
  "num-bigint",
@@ -1839,7 +2226,18 @@ checksum = "d65d7ce8132b7c0e54497a4d9a55a1c2a0912a0d786cf894472ba818fba45762"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
+]
+
+[[package]]
+name = "derive-where"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e73f2692d4bd3cac41dca28934a39894200c9fabf49586d77d0e5954af1d7902"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -1852,7 +2250,27 @@ dependencies = [
  "proc-macro2",
  "quote",
  "rustc_version 0.4.1",
- "syn 2.0.90",
+ "syn 2.0.101",
+]
+
+[[package]]
+name = "derive_more"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a9b99b9cbbe49445b21764dc0625032a89b145a2642e67603e1c936f5458d05"
+dependencies = [
+ "derive_more-impl",
+]
+
+[[package]]
+name = "derive_more-impl"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb7330aeadfbe296029522e6c40f315320aba36fc43a5b3632f3795348f3bd22"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -1941,23 +2359,23 @@ checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
 name = "docify"
-version = "0.2.8"
+version = "0.2.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43a2f138ad521dc4a2ced1a4576148a6a610b4c5923933b062a263130a6802ce"
+checksum = "a772b62b1837c8f060432ddcc10b17aae1453ef17617a99bc07789252d2a5896"
 dependencies = [
  "docify_macros",
 ]
 
 [[package]]
 name = "docify_macros"
-version = "0.2.8"
+version = "0.2.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a081e51fb188742f5a7a1164ad752121abcb22874b21e2c3b0dd040c515fdad"
+checksum = "60e6be249b0a462a14784a99b19bf35a667bb5e09de611738bb7362fa4c95ff7"
 dependencies = [
  "common-path",
  "derive-syn-parse",
@@ -1965,7 +2383,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "regex",
- "syn 2.0.90",
+ "syn 2.0.101",
  "termcolor",
  "toml 0.8.19",
  "walkdir",
@@ -1983,6 +2401,12 @@ version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1435fa1053d8b2fbbe9be7e97eca7f33d37b28409959813daefc1446a14247f1"
 
+[[package]]
+name = "downcast-rs"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75b325c5dbd37f80359721ad39aca5a29fb04c89279657cffdda8736d0c0b9d2"
+
 [[package]]
 name = "dtoa"
 version = "1.0.9"
@@ -2049,7 +2473,7 @@ checksum = "4a3daa8e81a3963a60642bcc1f90a670680bd4a77535faa384e9d1c79d620871"
 dependencies = [
  "curve25519-dalek",
  "ed25519",
- "rand_core",
+ "rand_core 0.6.4",
  "serde",
  "sha2 0.10.8",
  "subtle 2.6.1",
@@ -2066,7 +2490,7 @@ dependencies = [
  "ed25519",
  "hashbrown 0.14.5",
  "hex",
- "rand_core",
+ "rand_core 0.6.4",
  "sha2 0.10.8",
  "zeroize",
 ]
@@ -2093,7 +2517,7 @@ dependencies = [
  "generic-array 0.14.7",
  "group",
  "pkcs8",
- "rand_core",
+ "rand_core 0.6.4",
  "sec1",
  "serdect",
  "subtle 2.6.1",
@@ -2127,7 +2551,7 @@ dependencies = [
  "heck 0.5.0",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -2147,7 +2571,7 @@ checksum = "de0d48a183585823424a4ce1aa132d174a6a81bd540895822eb4c8373a8e49e8"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -2193,9 +2617,22 @@ checksum = "c22d4b5885b6aa2fe5e8b9329fb8d232bf739e434e6b87347c63bdd00c120f60"
 dependencies = [
  "crunchy",
  "fixed-hash",
- "impl-codec",
- "impl-rlp",
- "impl-serde",
+ "impl-rlp 0.3.0",
+ "impl-serde 0.4.0",
+ "tiny-keccak",
+]
+
+[[package]]
+name = "ethbloom"
+version = "0.14.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c321610643004cf908ec0f5f2aa0d8f1f8e14b540562a2887a1111ff1ecbf7b"
+dependencies = [
+ "crunchy",
+ "fixed-hash",
+ "impl-codec 0.7.1",
+ "impl-rlp 0.4.0",
+ "impl-serde 0.5.0",
  "scale-info",
  "tiny-keccak",
 ]
@@ -2203,15 +2640,14 @@ dependencies = [
 [[package]]
 name = "ethereum"
 version = "0.15.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e04d24d20b8ff2235cffbf242d5092de3aa45f77c5270ddbfadd2778ca13fea"
+source = "git+https://github.com/rust-ethereum/ethereum?rev=3be0d8fd4c2ad1ba216b69ef65b9382612efc8ba#3be0d8fd4c2ad1ba216b69ef65b9382612efc8ba"
 dependencies = [
  "bytes",
- "ethereum-types",
+ "ethereum-types 0.15.1",
  "hash-db",
  "hash256-std-hasher",
  "parity-scale-codec",
- "rlp",
+ "rlp 0.6.1",
  "scale-info",
  "serde",
  "sha3",
@@ -2224,14 +2660,28 @@ version = "0.14.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "02d215cbf040552efcbe99a38372fe80ab9d00268e20012b79fcd0f073edd8ee"
 dependencies = [
- "ethbloom",
+ "ethbloom 0.13.0",
+ "fixed-hash",
+ "impl-rlp 0.3.0",
+ "impl-serde 0.4.0",
+ "primitive-types 0.12.2",
+ "uint 0.9.5",
+]
+
+[[package]]
+name = "ethereum-types"
+version = "0.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ab15ed80916029f878e0267c3a9f92b67df55e79af370bf66199059ae2b4ee3"
+dependencies = [
+ "ethbloom 0.14.1",
  "fixed-hash",
- "impl-codec",
- "impl-rlp",
- "impl-serde",
- "primitive-types",
+ "impl-codec 0.7.1",
+ "impl-rlp 0.4.0",
+ "impl-serde 0.5.0",
+ "primitive-types 0.13.1",
  "scale-info",
- "uint",
+ "uint 0.10.0",
 ]
 
 [[package]]
@@ -2240,6 +2690,16 @@ version = "2.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0206175f82b8d6bf6652ff7d71a1e27fd2e4efde587fd368662814d6ec1d9ce0"
 
+[[package]]
+name = "event-listener"
+version = "4.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67b215c49b2b248c855fb73579eb1f4f26c38ffdc12973e20e07b91d78d5646e"
+dependencies = [
+ "concurrent-queue",
+ "pin-project-lite",
+]
+
 [[package]]
 name = "event-listener"
 version = "5.3.1"
@@ -2263,9 +2723,8 @@ dependencies = [
 
 [[package]]
 name = "evm"
-version = "0.41.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "767f43e9630cc36cf8ff2777cbb0121b055f0d1fd6eaaa13b46a1808f0d0e7e9"
+version = "0.42.0"
+source = "git+https://github.com/rust-ethereum/evm?rev=e81732d6bb47e3d3d68d233e43919c4522598361#e81732d6bb47e3d3d68d233e43919c4522598361"
 dependencies = [
  "auto_impl",
  "environmental",
@@ -2275,8 +2734,8 @@ dependencies = [
  "evm-runtime",
  "log",
  "parity-scale-codec",
- "primitive-types",
- "rlp",
+ "primitive-types 0.13.1",
+ "rlp 0.6.1",
  "scale-info",
  "serde",
  "sha3",
@@ -2284,38 +2743,35 @@ dependencies = [
 
 [[package]]
 name = "evm-core"
-version = "0.41.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d1da6cedc5cedb4208e59467106db0d1f50db01b920920589f8e672c02fdc04f"
+version = "0.42.0"
+source = "git+https://github.com/rust-ethereum/evm?rev=e81732d6bb47e3d3d68d233e43919c4522598361#e81732d6bb47e3d3d68d233e43919c4522598361"
 dependencies = [
  "parity-scale-codec",
- "primitive-types",
+ "primitive-types 0.13.1",
  "scale-info",
  "serde",
 ]
 
 [[package]]
 name = "evm-gasometer"
-version = "0.41.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1dc0eb591abc5cd7b05bef6a036c2bb6c66ab6c5e0c5ce94bfe377ab670b1fd7"
+version = "0.42.0"
+source = "git+https://github.com/rust-ethereum/evm?rev=e81732d6bb47e3d3d68d233e43919c4522598361#e81732d6bb47e3d3d68d233e43919c4522598361"
 dependencies = [
  "environmental",
  "evm-core",
  "evm-runtime",
- "primitive-types",
+ "primitive-types 0.13.1",
 ]
 
 [[package]]
 name = "evm-runtime"
-version = "0.41.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "84bbe09b64ae13a29514048c1bb6fda6374ac0b4f6a1f15a443348ab88ef42cd"
+version = "0.42.0"
+source = "git+https://github.com/rust-ethereum/evm?rev=e81732d6bb47e3d3d68d233e43919c4522598361#e81732d6bb47e3d3d68d233e43919c4522598361"
 dependencies = [
  "auto_impl",
  "environmental",
  "evm-core",
- "primitive-types",
+ "primitive-types 0.13.1",
  "sha3",
 ]
 
@@ -2337,10 +2793,10 @@ dependencies = [
  "blake2 0.10.6",
  "file-guard",
  "fs-err",
- "prettyplease 0.2.22",
+ "prettyplease",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -2361,10 +2817,34 @@ version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e8c02a5121d4ea3eb16a80748c74f5549a5665e4c21333c6098f283870fbdea6"
 
+[[package]]
+name = "fatality"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec6f82451ff7f0568c6181287189126d492b5654e30a788add08027b6363d019"
+dependencies = [
+ "fatality-proc-macro",
+ "thiserror 1.0.64",
+]
+
+[[package]]
+name = "fatality-proc-macro"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb42427514b063d97ce21d5199f36c0c307d981434a6be32582bc79fe5bd2303"
+dependencies = [
+ "expander",
+ "indexmap 2.9.0",
+ "proc-macro-crate 3.2.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.101",
+]
+
 [[package]]
 name = "fc-api"
 version = "1.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=cd6bca14a3#cd6bca14a366cc7cb1c3b1b1d7bc8213667e4126"
+source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
 dependencies = [
  "async-trait",
  "fp-storage",
@@ -2376,7 +2856,7 @@ dependencies = [
 [[package]]
 name = "fc-aura"
 version = "1.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=cd6bca14a3#cd6bca14a366cc7cb1c3b1b1d7bc8213667e4126"
+source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
 dependencies = [
  "fc-rpc",
  "fp-storage",
@@ -2392,7 +2872,7 @@ dependencies = [
 [[package]]
 name = "fc-consensus"
 version = "2.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=cd6bca14a3#cd6bca14a366cc7cb1c3b1b1d7bc8213667e4126"
+source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
 dependencies = [
  "async-trait",
  "fp-consensus",
@@ -2402,13 +2882,13 @@ dependencies = [
  "sp-block-builder",
  "sp-consensus",
  "sp-runtime",
- "thiserror",
+ "thiserror 1.0.64",
 ]
 
 [[package]]
 name = "fc-db"
 version = "2.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=cd6bca14a3#cd6bca14a366cc7cb1c3b1b1d7bc8213667e4126"
+source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
 dependencies = [
  "async-trait",
  "ethereum",
@@ -2438,7 +2918,7 @@ dependencies = [
 [[package]]
 name = "fc-mapping-sync"
 version = "2.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=cd6bca14a3#cd6bca14a366cc7cb1c3b1b1d7bc8213667e4126"
+source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
 dependencies = [
  "fc-db",
  "fc-storage",
@@ -2461,10 +2941,10 @@ dependencies = [
 [[package]]
 name = "fc-rpc"
 version = "2.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=cd6bca14a3#cd6bca14a366cc7cb1c3b1b1d7bc8213667e4126"
+source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
 dependencies = [
  "ethereum",
- "ethereum-types",
+ "ethereum-types 0.15.1",
  "evm",
  "fc-api",
  "fc-mapping-sync",
@@ -2475,14 +2955,14 @@ dependencies = [
  "fp-storage",
  "futures",
  "hex",
- "jsonrpsee",
+ "jsonrpsee 0.24.7",
  "libsecp256k1",
  "log",
  "pallet-evm",
  "parity-scale-codec",
  "prometheus",
- "rand",
- "rlp",
+ "rand 0.8.5",
+ "rlp 0.6.1",
  "sc-client-api",
  "sc-network",
  "sc-network-sync",
@@ -2498,39 +2978,39 @@ dependencies = [
  "sp-blockchain",
  "sp-consensus",
  "sp-core",
- "sp-externalities 0.29.0",
+ "sp-externalities 0.30.0",
  "sp-inherents",
  "sp-io",
  "sp-runtime",
  "sp-state-machine",
- "sp-storage 21.0.0",
+ "sp-storage 22.0.0",
  "substrate-prometheus-endpoint",
- "thiserror",
+ "thiserror 1.0.64",
  "tokio",
 ]
 
 [[package]]
 name = "fc-rpc-core"
 version = "1.1.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=cd6bca14a3#cd6bca14a366cc7cb1c3b1b1d7bc8213667e4126"
+source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
 dependencies = [
  "ethereum",
- "ethereum-types",
- "jsonrpsee",
- "rlp",
+ "ethereum-types 0.15.1",
+ "jsonrpsee 0.24.7",
+ "rlp 0.6.1",
  "rustc-hex",
  "serde",
  "serde_json",
- "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7)",
+ "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
 ]
 
 [[package]]
 name = "fc-storage"
 version = "1.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=cd6bca14a3#cd6bca14a366cc7cb1c3b1b1d7bc8213667e4126"
+source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
 dependencies = [
  "ethereum",
- "ethereum-types",
+ "ethereum-types 0.15.1",
  "fp-rpc",
  "fp-storage",
  "parity-scale-codec",
@@ -2538,7 +3018,7 @@ dependencies = [
  "sp-api",
  "sp-io",
  "sp-runtime",
- "sp-storage 21.0.0",
+ "sp-storage 22.0.0",
 ]
 
 [[package]]
@@ -2548,7 +3028,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e182f7dbc2ef73d9ef67351c5fbbea084729c48362d3ce9dd44c28e32e277fe5"
 dependencies = [
  "libc",
- "thiserror",
+ "thiserror 1.0.64",
 ]
 
 [[package]]
@@ -2557,7 +3037,7 @@ version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ded41244b729663b1e574f1b4fb731469f69f79c17667b5d776b16cda0479449"
 dependencies = [
- "rand_core",
+ "rand_core 0.6.4",
  "subtle 2.6.1",
 ]
 
@@ -2615,6 +3095,16 @@ dependencies = [
  "scale-info",
 ]
 
+[[package]]
+name = "finito"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2384245d85162258a14b43567a9ee3598f5ae746a1581fb5d3d2cb780f0dbf95"
+dependencies = [
+ "futures-timer",
+ "pin-project",
+]
+
 [[package]]
 name = "fixed-hash"
 version = "0.8.0"
@@ -2622,7 +3112,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "835c052cb0c08c1acf6ffd71c022172e18723949c8282f2b9f27efbc51e64534"
 dependencies = [
  "byteorder",
- "rand",
+ "rand 0.8.5",
  "rustc-hex",
  "static_assertions",
 ]
@@ -2682,8 +3172,8 @@ checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
 
 [[package]]
 name = "fork-tree"
-version = "13.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "13.0.1"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "parity-scale-codec",
 ]
@@ -2704,16 +3194,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8835f84f38484cc86f110a805655697908257fb9a7af005234060891557198e9"
 dependencies = [
  "nonempty",
- "thiserror",
+ "thiserror 1.0.64",
 ]
 
 [[package]]
 name = "fp-account"
 version = "1.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=cd6bca14a3#cd6bca14a366cc7cb1c3b1b1d7bc8213667e4126"
+source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
 dependencies = [
  "hex",
- "impl-serde",
+ "impl-serde 0.5.0",
  "libsecp256k1",
  "log",
  "parity-scale-codec",
@@ -2722,14 +3212,14 @@ dependencies = [
  "sp-core",
  "sp-io",
  "sp-runtime",
- "sp-runtime-interface 28.0.0",
+ "sp-runtime-interface 29.0.0",
  "staging-xcm",
 ]
 
 [[package]]
 name = "fp-consensus"
 version = "2.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=cd6bca14a3#cd6bca14a366cc7cb1c3b1b1d7bc8213667e4126"
+source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
 dependencies = [
  "ethereum",
  "parity-scale-codec",
@@ -2740,10 +3230,10 @@ dependencies = [
 [[package]]
 name = "fp-ethereum"
 version = "1.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=cd6bca14a3#cd6bca14a366cc7cb1c3b1b1d7bc8213667e4126"
+source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
 dependencies = [
  "ethereum",
- "ethereum-types",
+ "ethereum-types 0.15.1",
  "fp-evm",
  "frame-support",
  "parity-scale-codec",
@@ -2752,8 +3242,9 @@ dependencies = [
 [[package]]
 name = "fp-evm"
 version = "3.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=cd6bca14a3#cd6bca14a366cc7cb1c3b1b1d7bc8213667e4126"
+source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
 dependencies = [
+ "environmental",
  "evm",
  "frame-support",
  "num_enum",
@@ -2767,10 +3258,10 @@ dependencies = [
 [[package]]
 name = "fp-rpc"
 version = "3.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=cd6bca14a3#cd6bca14a366cc7cb1c3b1b1d7bc8213667e4126"
+source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
 dependencies = [
  "ethereum",
- "ethereum-types",
+ "ethereum-types 0.15.1",
  "fp-evm",
  "parity-scale-codec",
  "scale-info",
@@ -2783,7 +3274,7 @@ dependencies = [
 [[package]]
 name = "fp-self-contained"
 version = "1.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=cd6bca14a3#cd6bca14a366cc7cb1c3b1b1d7bc8213667e4126"
+source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
 dependencies = [
  "frame-support",
  "parity-scale-codec",
@@ -2795,7 +3286,7 @@ dependencies = [
 [[package]]
 name = "fp-storage"
 version = "2.0.0"
-source = "git+https://github.com/opentensor/frontier?rev=cd6bca14a3#cd6bca14a366cc7cb1c3b1b1d7bc8213667e4126"
+source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
 dependencies = [
  "parity-scale-codec",
  "serde",
@@ -2809,8 +3300,8 @@ checksum = "6c2141d6d6c8512188a7891b4b01590a45f6dac67afb4f255c4124dbb86d4eaa"
 
 [[package]]
 name = "frame-benchmarking"
-version = "38.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "39.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "frame-support",
  "frame-support-procedural",
@@ -2826,32 +3317,36 @@ dependencies = [
  "sp-core",
  "sp-io",
  "sp-runtime",
- "sp-runtime-interface 28.0.0",
- "sp-storage 21.0.0",
+ "sp-runtime-interface 29.0.0",
+ "sp-storage 22.0.0",
  "static_assertions",
 ]
 
 [[package]]
 name = "frame-benchmarking-cli"
-version = "43.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "46.1.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "Inflector",
  "array-bytes",
  "chrono",
  "clap",
  "comfy-table",
+ "cumulus-client-parachain-inherent",
+ "cumulus-primitives-proof-size-hostfunction",
  "frame-benchmarking",
  "frame-support",
  "frame-system",
  "gethostname",
  "handlebars",
+ "hex",
  "itertools 0.11.0",
- "lazy_static",
  "linked-hash-map",
  "log",
  "parity-scale-codec",
- "rand",
+ "polkadot-parachain-primitives",
+ "polkadot-primitives",
+ "rand 0.8.5",
  "rand_pcg",
  "sc-block-builder",
  "sc-chain-spec",
@@ -2859,32 +3354,40 @@ dependencies = [
  "sc-client-api",
  "sc-client-db",
  "sc-executor",
+ "sc-executor-common",
  "sc-service",
  "sc-sysinfo",
  "serde",
  "serde_json",
  "sp-api",
+ "sp-block-builder",
  "sp-blockchain",
  "sp-core",
+ "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
  "sp-database",
- "sp-externalities 0.29.0",
+ "sp-externalities 0.30.0",
  "sp-genesis-builder",
  "sp-inherents",
  "sp-io",
  "sp-keystore",
  "sp-runtime",
  "sp-state-machine",
- "sp-storage 21.0.0",
+ "sp-storage 22.0.0",
+ "sp-timestamp",
+ "sp-transaction-pool",
  "sp-trie",
+ "sp-version",
  "sp-wasm-interface 21.0.1",
- "thiserror",
+ "subxt",
+ "subxt-signer",
+ "thiserror 1.0.64",
  "thousands",
 ]
 
 [[package]]
 name = "frame-executive"
-version = "38.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "39.1.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "aquamarine",
  "frame-support",
@@ -2899,6 +3402,17 @@ dependencies = [
  "sp-tracing 17.0.1",
 ]
 
+[[package]]
+name = "frame-metadata"
+version = "15.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "878babb0b136e731cc77ec2fd883ff02745ff21e6fb662729953d44923df009c"
+dependencies = [
+ "cfg-if",
+ "parity-scale-codec",
+ "scale-info",
+]
+
 [[package]]
 name = "frame-metadata"
 version = "16.0.0"
@@ -2911,12 +3425,25 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "frame-metadata"
+version = "18.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "daaf440c68eb2c3d88e5760fe8c7af3f9fee9181fab6c2f2c4e7cc48dcc40bb8"
+dependencies = [
+ "cfg-if",
+ "parity-scale-codec",
+ "scale-info",
+ "serde",
+]
+
 [[package]]
 name = "frame-metadata-hash-extension"
-version = "0.6.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.7.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "array-bytes",
+ "const-hex",
  "docify",
  "frame-support",
  "frame-system",
@@ -2928,15 +3455,16 @@ dependencies = [
 
 [[package]]
 name = "frame-support"
-version = "38.2.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "39.1.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "aquamarine",
  "array-bytes",
+ "binary-merkle-tree",
  "bitflags 1.3.2",
  "docify",
  "environmental",
- "frame-metadata",
+ "frame-metadata 18.0.0",
  "frame-support-procedural",
  "impl-trait-for-tuples",
  "k256",
@@ -2952,7 +3480,7 @@ dependencies = [
  "sp-arithmetic",
  "sp-core",
  "sp-crypto-hashing-proc-macro",
- "sp-debug-derive 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7)",
+ "sp-debug-derive 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
  "sp-genesis-builder",
  "sp-inherents",
  "sp-io",
@@ -2960,8 +3488,9 @@ dependencies = [
  "sp-runtime",
  "sp-staking",
  "sp-state-machine",
- "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7)",
+ "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
  "sp-tracing 17.0.1",
+ "sp-trie",
  "sp-weights",
  "static_assertions",
  "tt-call",
@@ -2969,22 +3498,22 @@ dependencies = [
 
 [[package]]
 name = "frame-support-procedural"
-version = "30.0.6"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "31.1.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "Inflector",
  "cfg-expr",
  "derive-syn-parse",
  "docify",
  "expander",
- "frame-support-procedural-tools 13.0.0",
+ "frame-support-procedural-tools 13.0.1",
  "itertools 0.11.0",
  "macro_magic",
  "proc-macro-warning 1.0.2",
  "proc-macro2",
  "quote",
- "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7)",
- "syn 2.0.90",
+ "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -2997,19 +3526,19 @@ dependencies = [
  "proc-macro-crate 3.2.0",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
 name = "frame-support-procedural-tools"
-version = "13.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "13.0.1"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "frame-support-procedural-tools-derive 12.0.0",
  "proc-macro-crate 3.2.0",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -3020,23 +3549,23 @@ checksum = "68672b9ec6fe72d259d3879dc212c5e42e977588cdac830c76f54d9f492aeb58"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
 name = "frame-support-procedural-tools-derive"
 version = "12.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
 name = "frame-system"
-version = "38.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "39.1.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "cfg-if",
  "docify",
@@ -3048,15 +3577,15 @@ dependencies = [
  "sp-core",
  "sp-io",
  "sp-runtime",
- "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7)",
+ "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
  "sp-version",
  "sp-weights",
 ]
 
 [[package]]
 name = "frame-system-benchmarking"
-version = "38.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "39.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "frame-benchmarking",
  "frame-support",
@@ -3069,8 +3598,8 @@ dependencies = [
 
 [[package]]
 name = "frame-system-rpc-runtime-api"
-version = "34.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "35.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "docify",
  "parity-scale-codec",
@@ -3079,8 +3608,8 @@ dependencies = [
 
 [[package]]
 name = "frame-try-runtime"
-version = "0.44.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.45.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "frame-support",
  "parity-scale-codec",
@@ -3189,7 +3718,10 @@ version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "52527eb5074e35e9339c6b4e8d12600c7128b68fb25dcb9fa9dec18f7c25f3a5"
 dependencies = [
+ "fastrand",
  "futures-core",
+ "futures-io",
+ "parking",
  "pin-project-lite",
 ]
 
@@ -3201,7 +3733,7 @@ checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -3297,7 +3829,19 @@ checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7"
 dependencies = [
  "cfg-if",
  "libc",
- "wasi",
+ "wasi 0.11.0+wasi-snapshot-preview1",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26145e563e54f2cadc477553f1ec5ee650b00862f0a58bcd12cbdc5f0ea2d2f4"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi",
+ "wasi 0.14.2+wasi-0.2.4",
 ]
 
 [[package]]
@@ -3306,8 +3850,8 @@ version = "0.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6ea1015b5a70616b688dc230cfe50c8af89d972cb132d5a622814d29773b10b9"
 dependencies = [
- "rand",
- "rand_core",
+ "rand 0.8.5",
+ "rand_core 0.6.4",
 ]
 
 [[package]]
@@ -3368,7 +3912,7 @@ dependencies = [
  "parking_lot 0.12.3",
  "portable-atomic",
  "quanta",
- "rand",
+ "rand 0.8.5",
  "smallvec",
  "spinning_top",
 ]
@@ -3380,7 +3924,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63"
 dependencies = [
  "ff",
- "rand_core",
+ "rand_core 0.6.4",
  "subtle 2.6.1",
 ]
 
@@ -3396,7 +3940,7 @@ dependencies = [
  "futures-sink",
  "futures-util",
  "http 0.2.12",
- "indexmap 2.6.0",
+ "indexmap 2.9.0",
  "slab",
  "tokio",
  "tokio-util",
@@ -3415,7 +3959,7 @@ dependencies = [
  "futures-core",
  "futures-sink",
  "http 1.1.0",
- "indexmap 2.6.0",
+ "indexmap 2.9.0",
  "slab",
  "tokio",
  "tokio-util",
@@ -3439,7 +3983,7 @@ dependencies = [
  "pest_derive",
  "serde",
  "serde_json",
- "thiserror",
+ "thiserror 1.0.64",
 ]
 
 [[package]]
@@ -3483,6 +4027,7 @@ checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
 dependencies = [
  "ahash 0.8.11",
  "allocator-api2",
+ "serde",
 ]
 
 [[package]]
@@ -3560,19 +4105,64 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6fe2267d4ed49bc07b63801559be28c718ea06c4738b7a03c94df7386d2cde46"
 
 [[package]]
-name = "hkdf"
-version = "0.12.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b5f8eb2ad728638ea2c7d47a21db23b7b58a72ed6a38256b8a1849f15fbbdf7"
-dependencies = [
- "hmac 0.12.1",
-]
-
-[[package]]
-name = "hmac"
-version = "0.8.1"
+name = "hickory-proto"
+version = "0.24.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "126888268dcc288495a26bf004b38c5fdbb31682f992c84ceb046a1f0fe38840"
+checksum = "92652067c9ce6f66ce53cc38d1169daa36e6e7eb7dd3b63b5103bd9d97117248"
+dependencies = [
+ "async-trait",
+ "cfg-if",
+ "data-encoding",
+ "enum-as-inner 0.6.1",
+ "futures-channel",
+ "futures-io",
+ "futures-util",
+ "idna 1.0.3",
+ "ipnet",
+ "once_cell",
+ "rand 0.8.5",
+ "thiserror 1.0.64",
+ "tinyvec",
+ "tokio",
+ "tracing",
+ "url",
+]
+
+[[package]]
+name = "hickory-resolver"
+version = "0.24.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cbb117a1ca520e111743ab2f6688eddee69db4e0ea242545a604dce8a66fd22e"
+dependencies = [
+ "cfg-if",
+ "futures-util",
+ "hickory-proto",
+ "ipconfig",
+ "lru-cache",
+ "once_cell",
+ "parking_lot 0.12.3",
+ "rand 0.8.5",
+ "resolv-conf",
+ "smallvec",
+ "thiserror 1.0.64",
+ "tokio",
+ "tracing",
+]
+
+[[package]]
+name = "hkdf"
+version = "0.12.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b5f8eb2ad728638ea2c7d47a21db23b7b58a72ed6a38256b8a1849f15fbbdf7"
+dependencies = [
+ "hmac 0.12.1",
+]
+
+[[package]]
+name = "hmac"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "126888268dcc288495a26bf004b38c5fdbb31682f992c84ceb046a1f0fe38840"
 dependencies = [
  "crypto-mac 0.8.0",
  "digest 0.9.0",
@@ -3598,15 +4188,6 @@ dependencies = [
  "hmac 0.8.1",
 ]
 
-[[package]]
-name = "home"
-version = "0.5.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3d1354bf6b7235cb4a0576c2619fd4ed18183f689b12b006a0ee7329eeff9a5"
-dependencies = [
- "windows-sys 0.52.0",
-]
-
 [[package]]
 name = "hostname"
 version = "0.3.1"
@@ -3709,7 +4290,7 @@ dependencies = [
  "httpdate",
  "itoa",
  "pin-project-lite",
- "socket2 0.5.7",
+ "socket2 0.4.10",
  "tokio",
  "tower-service",
  "tracing",
@@ -3734,6 +4315,7 @@ dependencies = [
  "pin-project-lite",
  "smallvec",
  "tokio",
+ "want",
 ]
 
 [[package]]
@@ -3747,9 +4329,27 @@ dependencies = [
  "hyper 0.14.30",
  "log",
  "rustls 0.21.12",
- "rustls-native-certs",
+ "rustls-native-certs 0.6.3",
+ "tokio",
+ "tokio-rustls 0.24.1",
+]
+
+[[package]]
+name = "hyper-rustls"
+version = "0.27.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03a01595e11bdcec50946522c32dde3fc6914743000a68b93000965f2f02406d"
+dependencies = [
+ "http 1.1.0",
+ "hyper 1.5.0",
+ "hyper-util",
+ "log",
+ "rustls 0.23.27",
+ "rustls-native-certs 0.8.1",
+ "rustls-pki-types",
  "tokio",
- "tokio-rustls",
+ "tokio-rustls 0.26.2",
+ "tower-service",
 ]
 
 [[package]]
@@ -3759,13 +4359,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "df2dcfbe0677734ab2f3ffa7fa7bfd4706bfdc1ef393f2ee30184aed67e631b4"
 dependencies = [
  "bytes",
+ "futures-channel",
  "futures-util",
  "http 1.1.0",
  "http-body 1.0.1",
  "hyper 1.5.0",
  "pin-project-lite",
+ "socket2 0.5.9",
  "tokio",
  "tower-service",
+ "tracing",
 ]
 
 [[package]]
@@ -3791,6 +4394,92 @@ dependencies = [
  "cc",
 ]
 
+[[package]]
+name = "icu_collections"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "200072f5d0e3614556f94a9930d5dc3e0662a652823904c3a75dc3b0af7fee47"
+dependencies = [
+ "displaydoc",
+ "potential_utf",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locale_core"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cde2700ccaed3872079a65fb1a78f6c0a36c91570f28755dda67bc8f7d9f00a"
+dependencies = [
+ "displaydoc",
+ "litemap",
+ "tinystr",
+ "writeable",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "436880e8e18df4d7bbc06d58432329d6458cc84531f7ac5f024e93deadb37979"
+dependencies = [
+ "displaydoc",
+ "icu_collections",
+ "icu_normalizer_data",
+ "icu_properties",
+ "icu_provider",
+ "smallvec",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer_data"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00210d6893afc98edb752b664b8890f0ef174c8adbb8d0be9710fa66fbbf72d3"
+
+[[package]]
+name = "icu_properties"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "016c619c1eeb94efb86809b015c58f479963de65bdb6253345c1a1276f22e32b"
+dependencies = [
+ "displaydoc",
+ "icu_collections",
+ "icu_locale_core",
+ "icu_properties_data",
+ "icu_provider",
+ "potential_utf",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_properties_data"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "298459143998310acd25ffe6810ed544932242d3f07083eee1084d83a71bd632"
+
+[[package]]
+name = "icu_provider"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03c80da27b5f4187909049ee2d72f276f0d9f99a42c306bd0131ecfe04d8e5af"
+dependencies = [
+ "displaydoc",
+ "icu_locale_core",
+ "stable_deref_trait",
+ "tinystr",
+ "writeable",
+ "yoke",
+ "zerofrom",
+ "zerotrie",
+ "zerovec",
+]
+
 [[package]]
 name = "ident_case"
 version = "1.0.1"
@@ -3820,12 +4509,23 @@ dependencies = [
 
 [[package]]
 name = "idna"
-version = "0.5.0"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "634d9b1461af396cad843f47fdba5597a4f9e6ddd4bfb6ff5d85028c25cb12f6"
+checksum = "686f825264d630750a544639377bae737628043f20d38bbc029e8f29ea968a7e"
 dependencies = [
- "unicode-bidi",
- "unicode-normalization",
+ "idna_adapter",
+ "smallvec",
+ "utf8_iter",
+]
+
+[[package]]
+name = "idna_adapter"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344"
+dependencies = [
+ "icu_normalizer",
+ "icu_properties",
 ]
 
 [[package]]
@@ -3845,7 +4545,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d6b0422c86d7ce0e97169cc42e04ae643caf278874a7a3c87b8150a220dc7e1e"
 dependencies = [
  "async-io",
- "core-foundation",
+ "core-foundation 0.9.4",
  "fnv",
  "futures",
  "if-addrs",
@@ -3870,7 +4570,7 @@ dependencies = [
  "http 0.2.12",
  "hyper 0.14.30",
  "log",
- "rand",
+ "rand 0.8.5",
  "tokio",
  "url",
  "xmltree",
@@ -3885,13 +4585,42 @@ dependencies = [
  "parity-scale-codec",
 ]
 
+[[package]]
+name = "impl-codec"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d40b9d5e17727407e55028eafc22b2dc68781786e6d7eb8a21103f5058e3a14"
+dependencies = [
+ "parity-scale-codec",
+]
+
+[[package]]
+name = "impl-num-traits"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "803d15461ab0dcc56706adf266158acbc44ccf719bf7d0af30705f58b90a4b8c"
+dependencies = [
+ "integer-sqrt",
+ "num-traits",
+ "uint 0.10.0",
+]
+
 [[package]]
 name = "impl-rlp"
 version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f28220f89297a075ddc7245cd538076ee98b01f2a9c23a53a4f1105d5a322808"
 dependencies = [
- "rlp",
+ "rlp 0.5.2",
+]
+
+[[package]]
+name = "impl-rlp"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "54ed8ad1f3877f7e775b8cbf30ed1bd3209a95401817f19a0eb4402d13f8cf90"
+dependencies = [
+ "rlp 0.6.1",
 ]
 
 [[package]]
@@ -3903,15 +4632,24 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "impl-serde"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a143eada6a1ec4aefa5049037a26a6d597bfd64f8c026d07b77133e02b7dd0b"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "impl-trait-for-tuples"
-version = "0.2.2"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "11d7a9f6330b71fea57921c9b61c47ee6e84f72d394754eff6163ae67e7395eb"
+checksum = "a0eb5a3343abf848c0984fe4604b2b105da9539376e24fc0a3b0007411ae4fd9"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -3946,14 +4684,20 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "2.6.0"
+version = "2.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "707907fe3c25f5424cce2cb7e1cbcafee6bdbe735ca90ef77c29e84591e5b9da"
+checksum = "cea70ddb795996207ad57735b50c5982d8844f38ba9ee5f1aedcfb708a2aa11e"
 dependencies = [
  "equivalent",
  "hashbrown 0.15.2",
 ]
 
+[[package]]
+name = "indexmap-nostd"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e04e2fd2b8188ea827b32ef11de88377086d690286ab35747ef7f9bf3ccb590"
+
 [[package]]
 name = "inout"
 version = "0.1.3"
@@ -4004,7 +4748,7 @@ version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b58db92f96b720de98181bbbe63c831e87005ab460c1bf306eb2622b4707997f"
 dependencies = [
- "socket2 0.5.7",
+ "socket2 0.5.9",
  "widestring",
  "windows-sys 0.48.0",
  "winreg",
@@ -4066,6 +4810,26 @@ version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
 
+[[package]]
+name = "jni"
+version = "0.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6df18c2e3db7e453d3c6ac5b3e9d5182664d28788126d39b91f2d1e22b017ec"
+dependencies = [
+ "cesu8",
+ "combine",
+ "jni-sys",
+ "log",
+ "thiserror 1.0.64",
+ "walkdir",
+]
+
+[[package]]
+name = "jni-sys"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8eaf4bc02d17cbdd7ff4c7438cafcdf7fb9a4613313ad11b4f8fefe7d3fa0130"
+
 [[package]]
 name = "jobserver"
 version = "0.1.32"
@@ -4084,20 +4848,132 @@ dependencies = [
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "jsonrpsee"
+version = "0.22.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfdb12a2381ea5b2e68c3469ec604a007b367778cdb14d09612c8069ebd616ad"
+dependencies = [
+ "jsonrpsee-client-transport 0.22.5",
+ "jsonrpsee-core 0.22.5",
+ "jsonrpsee-http-client",
+ "jsonrpsee-types 0.22.5",
+]
+
+[[package]]
+name = "jsonrpsee"
+version = "0.23.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62b089779ad7f80768693755a031cc14a7766aba707cbe886674e3f79e9b7e47"
+dependencies = [
+ "jsonrpsee-core 0.23.2",
+ "jsonrpsee-types 0.23.2",
+ "jsonrpsee-ws-client",
+]
+
 [[package]]
 name = "jsonrpsee"
 version = "0.24.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c5c71d8c1a731cc4227c2f698d377e7848ca12c8a48866fc5e6951c43a4db843"
 dependencies = [
- "jsonrpsee-core",
+ "jsonrpsee-core 0.24.7",
  "jsonrpsee-proc-macros",
  "jsonrpsee-server",
- "jsonrpsee-types",
+ "jsonrpsee-types 0.24.7",
  "tokio",
  "tracing",
 ]
 
+[[package]]
+name = "jsonrpsee-client-transport"
+version = "0.22.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4978087a58c3ab02efc5b07c5e5e2803024536106fd5506f558db172c889b3aa"
+dependencies = [
+ "futures-util",
+ "http 0.2.12",
+ "jsonrpsee-core 0.22.5",
+ "pin-project",
+ "rustls-native-certs 0.7.3",
+ "rustls-pki-types",
+ "soketto 0.7.1",
+ "thiserror 1.0.64",
+ "tokio",
+ "tokio-rustls 0.25.0",
+ "tokio-util",
+ "tracing",
+ "url",
+]
+
+[[package]]
+name = "jsonrpsee-client-transport"
+version = "0.23.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08163edd8bcc466c33d79e10f695cdc98c00d1e6ddfb95cec41b6b0279dd5432"
+dependencies = [
+ "base64 0.22.1",
+ "futures-util",
+ "http 1.1.0",
+ "jsonrpsee-core 0.23.2",
+ "pin-project",
+ "rustls 0.23.27",
+ "rustls-pki-types",
+ "rustls-platform-verifier",
+ "soketto 0.8.0",
+ "thiserror 1.0.64",
+ "tokio",
+ "tokio-rustls 0.26.2",
+ "tokio-util",
+ "tracing",
+ "url",
+]
+
+[[package]]
+name = "jsonrpsee-core"
+version = "0.22.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4b257e1ec385e07b0255dde0b933f948b5c8b8c28d42afda9587c3a967b896d"
+dependencies = [
+ "anyhow",
+ "async-trait",
+ "beef",
+ "futures-timer",
+ "futures-util",
+ "hyper 0.14.30",
+ "jsonrpsee-types 0.22.5",
+ "pin-project",
+ "rustc-hash 1.1.0",
+ "serde",
+ "serde_json",
+ "thiserror 1.0.64",
+ "tokio",
+ "tokio-stream",
+ "tracing",
+]
+
+[[package]]
+name = "jsonrpsee-core"
+version = "0.23.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "79712302e737d23ca0daa178e752c9334846b08321d439fd89af9a384f8c830b"
+dependencies = [
+ "anyhow",
+ "async-trait",
+ "beef",
+ "futures-timer",
+ "futures-util",
+ "jsonrpsee-types 0.23.2",
+ "pin-project",
+ "rustc-hash 1.1.0",
+ "serde",
+ "serde_json",
+ "thiserror 1.0.64",
+ "tokio",
+ "tokio-stream",
+ "tracing",
+]
+
 [[package]]
 name = "jsonrpsee-core"
 version = "0.24.7"
@@ -4110,17 +4986,37 @@ dependencies = [
  "http 1.1.0",
  "http-body 1.0.1",
  "http-body-util",
- "jsonrpsee-types",
+ "jsonrpsee-types 0.24.7",
  "parking_lot 0.12.3",
- "rand",
+ "rand 0.8.5",
  "rustc-hash 2.0.0",
  "serde",
  "serde_json",
- "thiserror",
+ "thiserror 1.0.64",
  "tokio",
  "tracing",
 ]
 
+[[package]]
+name = "jsonrpsee-http-client"
+version = "0.22.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ccf93fc4a0bfe05d851d37d7c32b7f370fe94336b52a2f0efc5f1981895c2e5"
+dependencies = [
+ "async-trait",
+ "hyper 0.14.30",
+ "hyper-rustls 0.24.2",
+ "jsonrpsee-core 0.22.5",
+ "jsonrpsee-types 0.22.5",
+ "serde",
+ "serde_json",
+ "thiserror 1.0.64",
+ "tokio",
+ "tower",
+ "tracing",
+ "url",
+]
+
 [[package]]
 name = "jsonrpsee-proc-macros"
 version = "0.24.7"
@@ -4131,7 +5027,7 @@ dependencies = [
  "proc-macro-crate 3.2.0",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -4146,14 +5042,14 @@ dependencies = [
  "http-body-util",
  "hyper 1.5.0",
  "hyper-util",
- "jsonrpsee-core",
- "jsonrpsee-types",
+ "jsonrpsee-core 0.24.7",
+ "jsonrpsee-types 0.24.7",
  "pin-project",
  "route-recognizer",
  "serde",
  "serde_json",
- "soketto",
- "thiserror",
+ "soketto 0.8.0",
+ "thiserror 1.0.64",
  "tokio",
  "tokio-stream",
  "tokio-util",
@@ -4161,6 +5057,32 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "jsonrpsee-types"
+version = "0.22.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "150d6168405890a7a3231a3c74843f58b8959471f6df76078db2619ddee1d07d"
+dependencies = [
+ "anyhow",
+ "beef",
+ "serde",
+ "serde_json",
+ "thiserror 1.0.64",
+]
+
+[[package]]
+name = "jsonrpsee-types"
+version = "0.23.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9c465fbe385238e861fdc4d1c85e04ada6c1fd246161d26385c1b311724d2af"
+dependencies = [
+ "beef",
+ "http 1.1.0",
+ "serde",
+ "serde_json",
+ "thiserror 1.0.64",
+]
+
 [[package]]
 name = "jsonrpsee-types"
 version = "0.24.7"
@@ -4170,7 +5092,20 @@ dependencies = [
  "http 1.1.0",
  "serde",
  "serde_json",
- "thiserror",
+ "thiserror 1.0.64",
+]
+
+[[package]]
+name = "jsonrpsee-ws-client"
+version = "0.23.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c28759775f5cb2f1ea9667672d3fe2b0e701d1f4b7b67954e60afe7fd058b5e"
+dependencies = [
+ "http 1.1.0",
+ "jsonrpsee-client-transport 0.23.2",
+ "jsonrpsee-core 0.23.2",
+ "jsonrpsee-types 0.23.2",
+ "url",
 ]
 
 [[package]]
@@ -4196,6 +5131,16 @@ dependencies = [
  "cpufeatures",
 ]
 
+[[package]]
+name = "keccak-hash"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b286e6b663fb926e1eeb68528e69cb70ed46c6d65871a21b2215ae8154c6d3c"
+dependencies = [
+ "primitive-types 0.12.2",
+ "tiny-keccak",
+]
+
 [[package]]
 name = "keystream"
 version = "1.0.0"
@@ -4279,7 +5224,7 @@ dependencies = [
  "either",
  "futures",
  "futures-timer",
- "getrandom",
+ "getrandom 0.2.15",
  "instant",
  "libp2p-allow-block-list",
  "libp2p-connection-limits",
@@ -4303,7 +5248,7 @@ dependencies = [
  "multiaddr 0.18.2",
  "pin-project",
  "rw-stream-sink",
- "thiserror",
+ "thiserror 1.0.64",
 ]
 
 [[package]]
@@ -4350,10 +5295,10 @@ dependencies = [
  "parking_lot 0.12.3",
  "pin-project",
  "quick-protobuf",
- "rand",
+ "rand 0.8.5",
  "rw-stream-sink",
  "smallvec",
- "thiserror",
+ "thiserror 1.0.64",
  "unsigned-varint 0.7.2",
  "void",
 ]
@@ -4393,7 +5338,7 @@ dependencies = [
  "quick-protobuf",
  "quick-protobuf-codec",
  "smallvec",
- "thiserror",
+ "thiserror 1.0.64",
  "void",
 ]
 
@@ -4403,14 +5348,14 @@ version = "0.2.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "55cca1eb2bc1fd29f099f3daaab7effd01e1a54b7c577d0ed082521034d912e8"
 dependencies = [
- "bs58 0.5.1",
+ "bs58",
  "ed25519-dalek",
  "hkdf",
  "multihash 0.19.2",
  "quick-protobuf",
- "rand",
+ "rand 0.8.5",
  "sha2 0.10.8",
- "thiserror",
+ "thiserror 1.0.64",
  "tracing",
  "zeroize",
 ]
@@ -4421,7 +5366,7 @@ version = "0.44.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "16ea178dabba6dde6ffc260a8e0452ccdc8f79becf544946692fff9d412fc29d"
 dependencies = [
- "arrayvec",
+ "arrayvec 0.7.6",
  "asynchronous-codec",
  "bytes",
  "either",
@@ -4435,11 +5380,11 @@ dependencies = [
  "log",
  "quick-protobuf",
  "quick-protobuf-codec",
- "rand",
+ "rand 0.8.5",
  "sha2 0.10.8",
  "smallvec",
- "thiserror",
- "uint",
+ "thiserror 1.0.64",
+ "uint 0.9.5",
  "unsigned-varint 0.7.2",
  "void",
 ]
@@ -4457,9 +5402,9 @@ dependencies = [
  "libp2p-identity",
  "libp2p-swarm",
  "log",
- "rand",
+ "rand 0.8.5",
  "smallvec",
- "socket2 0.5.7",
+ "socket2 0.5.9",
  "tokio",
  "trust-dns-proto 0.22.0",
  "void",
@@ -4498,11 +5443,11 @@ dependencies = [
  "multihash 0.19.2",
  "once_cell",
  "quick-protobuf",
- "rand",
+ "rand 0.8.5",
  "sha2 0.10.8",
  "snow",
  "static_assertions",
- "thiserror",
+ "thiserror 1.0.64",
  "x25519-dalek",
  "zeroize",
 ]
@@ -4521,7 +5466,7 @@ dependencies = [
  "libp2p-identity",
  "libp2p-swarm",
  "log",
- "rand",
+ "rand 0.8.5",
  "void",
 ]
 
@@ -4540,12 +5485,12 @@ dependencies = [
  "libp2p-tls",
  "log",
  "parking_lot 0.12.3",
- "quinn 0.10.2",
- "rand",
+ "quinn",
+ "rand 0.8.5",
  "ring 0.16.20",
  "rustls 0.21.12",
- "socket2 0.5.7",
- "thiserror",
+ "socket2 0.5.9",
+ "thiserror 1.0.64",
  "tokio",
 ]
 
@@ -4562,7 +5507,7 @@ dependencies = [
  "libp2p-identity",
  "libp2p-swarm",
  "log",
- "rand",
+ "rand 0.8.5",
  "smallvec",
  "void",
 ]
@@ -4584,7 +5529,7 @@ dependencies = [
  "log",
  "multistream-select",
  "once_cell",
- "rand",
+ "rand 0.8.5",
  "smallvec",
  "tokio",
  "void",
@@ -4600,7 +5545,7 @@ dependencies = [
  "proc-macro-warning 0.4.2",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -4616,7 +5561,7 @@ dependencies = [
  "libp2p-core",
  "libp2p-identity",
  "log",
- "socket2 0.5.7",
+ "socket2 0.5.9",
  "tokio",
 ]
 
@@ -4633,8 +5578,8 @@ dependencies = [
  "rcgen",
  "ring 0.16.20",
  "rustls 0.21.12",
- "rustls-webpki",
- "thiserror",
+ "rustls-webpki 0.101.7",
+ "thiserror 1.0.64",
  "x509-parser 0.15.1",
  "yasna",
 ]
@@ -4684,10 +5629,10 @@ dependencies = [
  "parking_lot 0.12.3",
  "pin-project-lite",
  "rw-stream-sink",
- "soketto",
- "thiserror",
+ "soketto 0.8.0",
+ "thiserror 1.0.64",
  "url",
- "webpki-roots",
+ "webpki-roots 0.25.4",
 ]
 
 [[package]]
@@ -4699,8 +5644,8 @@ dependencies = [
  "futures",
  "libp2p-core",
  "log",
- "thiserror",
- "yamux",
+ "thiserror 1.0.64",
+ "yamux 0.12.1",
 ]
 
 [[package]]
@@ -4742,7 +5687,7 @@ dependencies = [
  "libsecp256k1-core",
  "libsecp256k1-gen-ecmult",
  "libsecp256k1-gen-genmult",
- "rand",
+ "rand 0.8.5",
  "serde",
  "sha2 0.9.9",
  "typenum 1.17.0",
@@ -4856,57 +5801,55 @@ dependencies = [
  "keystream",
 ]
 
+[[package]]
+name = "litemap"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "241eaef5fd12c88705a01fc1066c48c4b36e0dd4377dcdc7ec3942cea7a69956"
+
 [[package]]
 name = "litep2p"
-version = "0.6.2"
+version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0f46c51c205264b834ceed95c8b195026e700494bc3991aaba3b4ea9e20626d9"
+checksum = "d71056c23c896bb0e18113b2d2f1989be95135e6bdeedb0b757422ee21a073eb"
 dependencies = [
  "async-trait",
- "bs58 0.4.0",
+ "bs58",
  "bytes",
- "cid 0.10.1",
+ "cid 0.11.1",
  "ed25519-dalek",
  "futures",
  "futures-timer",
- "hex-literal",
- "indexmap 2.6.0",
+ "hickory-resolver",
+ "indexmap 2.9.0",
  "libc",
- "mockall 0.12.1",
+ "mockall 0.13.1",
  "multiaddr 0.17.1",
  "multihash 0.17.0",
  "network-interface",
- "nohash-hasher",
  "parking_lot 0.12.3",
  "pin-project",
- "prost 0.12.6",
- "prost-build 0.11.9",
- "quinn 0.9.4",
- "rand",
- "rcgen",
- "ring 0.16.20",
- "rustls 0.20.9",
+ "prost 0.13.5",
+ "prost-build",
+ "rand 0.8.5",
  "serde",
  "sha2 0.10.8",
  "simple-dns",
  "smallvec",
  "snow",
- "socket2 0.5.7",
- "static_assertions",
- "str0m",
- "thiserror",
+ "socket2 0.5.9",
+ "thiserror 2.0.12",
  "tokio",
  "tokio-stream",
  "tokio-tungstenite",
  "tokio-util",
  "tracing",
- "trust-dns-resolver",
- "uint",
+ "uint 0.10.0",
  "unsigned-varint 0.8.0",
  "url",
- "webpki",
  "x25519-dalek",
- "x509-parser 0.16.0",
+ "x509-parser 0.17.0",
+ "yamux 0.13.5",
  "yasna",
  "zeroize",
 ]
@@ -4991,7 +5934,7 @@ dependencies = [
  "macro_magic_core",
  "macro_magic_macros",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -5005,7 +5948,7 @@ dependencies = [
  "macro_magic_core_macros",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -5016,7 +5959,7 @@ checksum = "b02abfe41815b5bd98dbd4260173db2c116dda171dc0fe7838cb206333b83308"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -5027,7 +5970,7 @@ checksum = "73ea28ee64b88876bf45277ed9a5817c1817df061a74f2b988971a12570e5869"
 dependencies = [
  "macro_magic_core",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -5114,13 +6057,13 @@ dependencies = [
 
 [[package]]
 name = "merkleized-metadata"
-version = "0.1.0"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f313fcff1d2a4bcaa2deeaa00bf7530d77d5f7bd0467a117dde2e29a75a7a17a"
+checksum = "38c592efaf1b3250df14c8f3c2d952233f0302bb81d3586db2f303666c1cd607"
 dependencies = [
  "array-bytes",
  "blake3",
- "frame-metadata",
+ "frame-metadata 18.0.0",
  "parity-scale-codec",
  "scale-decode",
  "scale-info",
@@ -5134,7 +6077,7 @@ checksum = "58c38e2799fc0978b65dfff8023ec7843e2330bb462f19198840b34b6582397d"
 dependencies = [
  "byteorder",
  "keccak",
- "rand_core",
+ "rand_core 0.6.4",
  "zeroize",
 ]
 
@@ -5161,7 +6104,7 @@ checksum = "80e04d1dcff3aae0704555fe5fee3bcfaf3d1fdf8a7e521d5b9d2b42acb52cec"
 dependencies = [
  "hermit-abi 0.3.9",
  "libc",
- "wasi",
+ "wasi 0.11.0+wasi-snapshot-preview1",
  "windows-sys 0.52.0",
 ]
 
@@ -5172,7 +6115,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "daa3eb39495d8e2e2947a1d862852c90cc6a4a8845f8b41c8829cb9fcc047f4a"
 dependencies = [
  "arrayref",
- "arrayvec",
+ "arrayvec 0.7.6",
  "bitflags 1.3.2",
  "blake2 0.10.6",
  "c2-chacha",
@@ -5182,11 +6125,11 @@ dependencies = [
  "lioness",
  "log",
  "parking_lot 0.12.3",
- "rand",
- "rand_chacha",
+ "rand 0.8.5",
+ "rand_chacha 0.3.1",
  "rand_distr",
  "subtle 2.6.1",
- "thiserror",
+ "thiserror 1.0.64",
  "zeroize",
 ]
 
@@ -5207,15 +6150,14 @@ dependencies = [
 
 [[package]]
 name = "mockall"
-version = "0.12.1"
+version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43766c2b5203b10de348ffe19f7e54564b64f3d6018ff7648d1e2d6d3a0f0a48"
+checksum = "39a6bfcc6c8c7eed5ee98b9c3e33adc726054389233e201c95dab2d41a3839d2"
 dependencies = [
  "cfg-if",
  "downcast",
  "fragile",
- "lazy_static",
- "mockall_derive 0.12.1",
+ "mockall_derive 0.13.1",
  "predicates 3.1.2",
  "predicates-tree",
 ]
@@ -5234,14 +6176,14 @@ dependencies = [
 
 [[package]]
 name = "mockall_derive"
-version = "0.12.1"
+version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af7cbce79ec385a1d4f54baa90a76401eb15d9cab93685f62e7e9f942aa00ae2"
+checksum = "25ca3004c2efe9011bd4e461bd8256445052b9615405b4f7ea43fc8ca5c20898"
 dependencies = [
  "cfg-if",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -5287,34 +6229,17 @@ name = "multibase"
 version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9b3539ec3c1f04ac9748a260728e855f261b4977f5c3406612c884564f329404"
-dependencies = [
- "base-x",
- "data-encoding",
- "data-encoding-macro",
-]
-
-[[package]]
-name = "multihash"
-version = "0.17.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "835d6ff01d610179fbce3de1694d007e500bf33a7f29689838941d6bf783ae40"
-dependencies = [
- "blake2b_simd",
- "blake2s_simd",
- "blake3",
- "core2",
- "digest 0.10.7",
- "multihash-derive",
- "sha2 0.10.8",
- "sha3",
- "unsigned-varint 0.7.2",
+dependencies = [
+ "base-x",
+ "data-encoding",
+ "data-encoding-macro",
 ]
 
 [[package]]
 name = "multihash"
-version = "0.18.1"
+version = "0.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cfd8a792c1694c6da4f68db0a9d707c72bd260994da179e6030a5dcee00bb815"
+checksum = "835d6ff01d610179fbce3de1694d007e500bf33a7f29689838941d6bf783ae40"
 dependencies = [
  "blake2b_simd",
  "blake2s_simd",
@@ -5395,7 +6320,7 @@ checksum = "254a5372af8fc138e36684761d3c0cdb758a4410e938babcff1c860ce14ddbfc"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -5404,9 +6329,15 @@ version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7bddcd3bf5144b6392de80e04c347cd7fab2508f6df16a85fc496ecd5cec39bc"
 dependencies = [
- "rand",
+ "rand 0.8.5",
 ]
 
+[[package]]
+name = "nanorand"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a51313c5820b0b02bd422f4b44776fbf47961755c74ce64afc73bfad10226c3"
+
 [[package]]
 name = "native-tls"
 version = "0.2.12"
@@ -5419,7 +6350,7 @@ dependencies = [
  "openssl-probe",
  "openssl-sys",
  "schannel",
- "security-framework",
+ "security-framework 2.11.1",
  "security-framework-sys",
  "tempfile",
 ]
@@ -5472,7 +6403,7 @@ dependencies = [
  "anyhow",
  "byteorder",
  "paste",
- "thiserror",
+ "thiserror 1.0.64",
 ]
 
 [[package]]
@@ -5486,7 +6417,7 @@ dependencies = [
  "log",
  "netlink-packet-core",
  "netlink-sys",
- "thiserror",
+ "thiserror 1.0.64",
  "tokio",
 ]
 
@@ -5505,13 +6436,13 @@ dependencies = [
 
 [[package]]
 name = "network-interface"
-version = "1.1.4"
+version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4a43439bf756eed340bdf8feba761e2d50c7d47175d87545cd5cbe4a137c4d1"
+checksum = "c3329f515506e4a2de3aa6e07027a6758e22e0f0e8eaf64fa47261cec2282602"
 dependencies = [
  "cc",
  "libc",
- "thiserror",
+ "thiserror 1.0.64",
  "winapi",
 ]
 
@@ -5532,6 +6463,12 @@ version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b93853da6d84c2e3c7d730d6473e8817692dd89be387eb01b94d7f108ecb5b8c"
 
+[[package]]
+name = "no-std-net"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43794a0ace135be66a25d3ae77d41b91615fb68ae937f904090203e81f755b65"
+
 [[package]]
 name = "node-subtensor"
 version = "4.0.0-dev"
@@ -5555,7 +6492,7 @@ dependencies = [
  "frame-system-rpc-runtime-api",
  "futures",
  "hex",
- "jsonrpsee",
+ "jsonrpsee 0.24.7",
  "memmap2 0.9.5",
  "node-subtensor-runtime",
  "num-traits",
@@ -5596,7 +6533,7 @@ dependencies = [
  "sp-consensus-aura",
  "sp-consensus-grandpa",
  "sp-core",
- "sp-crypto-ec-utils 0.14.0",
+ "sp-crypto-ec-utils 0.15.0",
  "sp-inherents",
  "sp-io",
  "sp-keyring",
@@ -5612,7 +6549,7 @@ dependencies = [
  "subtensor-custom-rpc",
  "subtensor-custom-rpc-runtime-api",
  "subtensor-runtime-common",
- "thiserror",
+ "thiserror 1.0.64",
 ]
 
 [[package]]
@@ -5626,14 +6563,14 @@ dependencies = [
  "fp-self-contained",
  "frame-benchmarking",
  "frame-executive",
- "frame-metadata",
+ "frame-metadata 16.0.0",
  "frame-metadata-hash-extension",
  "frame-support",
  "frame-system",
  "frame-system-benchmarking",
  "frame-system-rpc-runtime-api",
  "frame-try-runtime",
- "getrandom",
+ "getrandom 0.2.15",
  "hex",
  "log",
  "pallet-admin-utils",
@@ -5668,7 +6605,7 @@ dependencies = [
  "pallet-utility 38.0.0",
  "parity-scale-codec",
  "precompile-utils",
- "rand_chacha",
+ "rand_chacha 0.3.1",
  "scale-info",
  "serde_json",
  "sha2 0.10.8",
@@ -5683,8 +6620,8 @@ dependencies = [
  "sp-offchain",
  "sp-runtime",
  "sp-session",
- "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7)",
- "sp-storage 21.0.0",
+ "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-storage 22.0.0",
  "sp-tracing 17.0.1",
  "sp-transaction-pool",
  "sp-version",
@@ -5697,6 +6634,12 @@ dependencies = [
  "w3f-bls",
 ]
 
+[[package]]
+name = "nodrop"
+version = "0.1.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72ef4a56884ca558e5ddb05a1d1e7e1bfd9a68d9ed024c21704cc98872dae1bb"
+
 [[package]]
 name = "nohash-hasher"
 version = "0.2.0"
@@ -5786,7 +6729,7 @@ version = "0.4.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a652d9771a63711fd3c3deb670acfbe5c30a4072e664d7a3bf5a9e1056ac72c3"
 dependencies = [
- "arrayvec",
+ "arrayvec 0.7.6",
  "itoa",
 ]
 
@@ -5859,7 +6802,7 @@ dependencies = [
  "proc-macro-crate 3.2.0",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -5903,11 +6846,11 @@ dependencies = [
 
 [[package]]
 name = "oid-registry"
-version = "0.7.1"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8d8034d9489cdaf79228eb9f6a3b8d7bb32ba00d6645ebd48eef4077ceb5bd9"
+checksum = "12f40cff3dde1b6087cc5d5f5d4d65712f34016a03ed60e9c08dcc392736b5b7"
 dependencies = [
- "asn1-rs 0.6.2",
+ "asn1-rs 0.7.1",
 ]
 
 [[package]]
@@ -5954,7 +6897,7 @@ checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -5963,15 +6906,6 @@ version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf"
 
-[[package]]
-name = "openssl-src"
-version = "300.4.0+3.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a709e02f2b4aca747929cca5ed248880847c650233cf8b8cdc48f40aaf4898a6"
-dependencies = [
- "cc",
-]
-
 [[package]]
 name = "openssl-sys"
 version = "0.9.107"
@@ -5980,7 +6914,6 @@ checksum = "8288979acd84749c744a9014b4382d42b8f7b2592847b5afb2ed29e5d16ede07"
 dependencies = [
  "cc",
  "libc",
- "openssl-src",
  "pkg-config",
  "vcpkg",
 ]
@@ -5991,6 +6924,39 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
 
+[[package]]
+name = "orchestra"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41f6bbacc8c189a3f2e45e0fd0436e5d97f194db888e721bdbc3973e7dbed4c2"
+dependencies = [
+ "async-trait",
+ "dyn-clonable",
+ "futures",
+ "futures-timer",
+ "orchestra-proc-macro",
+ "pin-project",
+ "prioritized-metered-channel",
+ "thiserror 1.0.64",
+ "tracing",
+]
+
+[[package]]
+name = "orchestra-proc-macro"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7b1d40dd8f367db3c65bec8d3dd47d4a604ee8874480738f93191bddab4e0e0"
+dependencies = [
+ "expander",
+ "indexmap 2.9.0",
+ "itertools 0.11.0",
+ "petgraph",
+ "proc-macro-crate 3.2.0",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
 [[package]]
 name = "overload"
 version = "0.1.1"
@@ -6018,7 +6984,7 @@ dependencies = [
  "sp-core",
  "sp-io",
  "sp-runtime",
- "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7)",
+ "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
  "sp-tracing 17.0.1",
  "sp-weights",
  "substrate-fixed",
@@ -6027,8 +6993,8 @@ dependencies = [
 
 [[package]]
 name = "pallet-aura"
-version = "37.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "38.1.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "frame-support",
  "frame-system",
@@ -6043,8 +7009,8 @@ dependencies = [
 
 [[package]]
 name = "pallet-authorship"
-version = "38.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "39.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "frame-support",
  "frame-system",
@@ -6056,8 +7022,8 @@ dependencies = [
 
 [[package]]
 name = "pallet-balances"
-version = "39.0.1"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "40.1.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "docify",
  "frame-benchmarking",
@@ -6072,7 +7038,7 @@ dependencies = [
 [[package]]
 name = "pallet-base-fee"
 version = "1.0.0"
-source = "git+https://github.com/opentensor/frontier?rev=cd6bca14a3#cd6bca14a366cc7cb1c3b1b1d7bc8213667e4126"
+source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
 dependencies = [
  "fp-evm",
  "frame-support",
@@ -6096,7 +7062,7 @@ dependencies = [
  "sp-core",
  "sp-io",
  "sp-runtime",
- "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7)",
+ "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
  "subtensor-macros",
 ]
 
@@ -6115,13 +7081,13 @@ dependencies = [
  "pallet-drand",
  "pallet-subtensor",
  "parity-scale-codec",
- "rand_chacha",
+ "rand_chacha 0.3.1",
  "scale-info",
  "sha2 0.10.8",
  "sp-core",
  "sp-io",
  "sp-runtime",
- "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7)",
+ "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
  "subtensor-macros",
  "tle",
  "w3f-bls",
@@ -6142,7 +7108,7 @@ dependencies = [
  "sp-core",
  "sp-io",
  "sp-runtime",
- "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7)",
+ "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
  "subtensor-macros",
 ]
 
@@ -6182,10 +7148,10 @@ dependencies = [
 [[package]]
 name = "pallet-ethereum"
 version = "4.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=cd6bca14a3#cd6bca14a366cc7cb1c3b1b1d7bc8213667e4126"
+source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
 dependencies = [
  "ethereum",
- "ethereum-types",
+ "ethereum-types 0.15.1",
  "evm",
  "fp-consensus",
  "fp-ethereum",
@@ -6199,12 +7165,13 @@ dependencies = [
  "scale-info",
  "sp-io",
  "sp-runtime",
+ "sp-version",
 ]
 
 [[package]]
 name = "pallet-evm"
 version = "6.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=cd6bca14a3#cd6bca14a366cc7cb1c3b1b1d7bc8213667e4126"
+source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
 dependencies = [
  "environmental",
  "evm",
@@ -6227,7 +7194,7 @@ dependencies = [
 [[package]]
 name = "pallet-evm-chain-id"
 version = "1.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=cd6bca14a3#cd6bca14a366cc7cb1c3b1b1d7bc8213667e4126"
+source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
 dependencies = [
  "frame-support",
  "frame-system",
@@ -6238,7 +7205,7 @@ dependencies = [
 [[package]]
 name = "pallet-evm-precompile-modexp"
 version = "2.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=cd6bca14a3#cd6bca14a366cc7cb1c3b1b1d7bc8213667e4126"
+source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
 dependencies = [
  "fp-evm",
  "num",
@@ -6247,7 +7214,7 @@ dependencies = [
 [[package]]
 name = "pallet-evm-precompile-sha3fips"
 version = "2.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=cd6bca14a3#cd6bca14a366cc7cb1c3b1b1d7bc8213667e4126"
+source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
 dependencies = [
  "fp-evm",
  "tiny-keccak",
@@ -6256,7 +7223,7 @@ dependencies = [
 [[package]]
 name = "pallet-evm-precompile-simple"
 version = "2.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=cd6bca14a3#cd6bca14a366cc7cb1c3b1b1d7bc8213667e4126"
+source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
 dependencies = [
  "fp-evm",
  "ripemd",
@@ -6265,8 +7232,8 @@ dependencies = [
 
 [[package]]
 name = "pallet-grandpa"
-version = "38.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "39.1.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "frame-benchmarking",
  "frame-support",
@@ -6288,7 +7255,7 @@ dependencies = [
 [[package]]
 name = "pallet-hotfix-sufficients"
 version = "1.0.0"
-source = "git+https://github.com/opentensor/frontier?rev=cd6bca14a3#cd6bca14a366cc7cb1c3b1b1d7bc8213667e4126"
+source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
 dependencies = [
  "frame-benchmarking",
  "frame-support",
@@ -6302,8 +7269,8 @@ dependencies = [
 
 [[package]]
 name = "pallet-insecure-randomness-collective-flip"
-version = "26.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "27.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "frame-support",
  "frame-system",
@@ -6315,8 +7282,8 @@ dependencies = [
 
 [[package]]
 name = "pallet-membership"
-version = "38.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "39.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "frame-benchmarking",
  "frame-support",
@@ -6331,23 +7298,19 @@ dependencies = [
 
 [[package]]
 name = "pallet-multisig"
-version = "38.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "39.1.1"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
- "frame-benchmarking",
- "frame-support",
- "frame-system",
  "log",
  "parity-scale-codec",
+ "polkadot-sdk-frame",
  "scale-info",
- "sp-io",
- "sp-runtime",
 ]
 
 [[package]]
 name = "pallet-preimage"
-version = "38.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "39.1.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "frame-benchmarking",
  "frame-support",
@@ -6379,16 +7342,12 @@ dependencies = [
 
 [[package]]
 name = "pallet-proxy"
-version = "38.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "39.1.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
- "frame-benchmarking",
- "frame-support",
- "frame-system",
  "parity-scale-codec",
+ "polkadot-sdk-frame",
  "scale-info",
- "sp-io",
- "sp-runtime",
 ]
 
 [[package]]
@@ -6404,14 +7363,14 @@ dependencies = [
  "sp-core",
  "sp-io",
  "sp-runtime",
- "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7)",
+ "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
  "subtensor-macros",
 ]
 
 [[package]]
 name = "pallet-root-testing"
-version = "14.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "15.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "frame-support",
  "frame-system",
@@ -6424,16 +7383,16 @@ dependencies = [
 
 [[package]]
 name = "pallet-safe-mode"
-version = "19.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "20.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "docify",
  "frame-benchmarking",
  "frame-support",
  "frame-system",
  "pallet-balances",
- "pallet-proxy 38.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7)",
- "pallet-utility 38.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7)",
+ "pallet-proxy 39.1.0",
+ "pallet-utility 39.1.0",
  "parity-scale-codec",
  "scale-info",
  "sp-arithmetic",
@@ -6442,8 +7401,8 @@ dependencies = [
 
 [[package]]
 name = "pallet-scheduler"
-version = "39.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "40.1.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "docify",
  "frame-benchmarking",
@@ -6459,8 +7418,8 @@ dependencies = [
 
 [[package]]
 name = "pallet-session"
-version = "38.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "39.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "frame-support",
  "frame-system",
@@ -6504,8 +7463,8 @@ dependencies = [
  "pallet-utility 38.0.0",
  "parity-scale-codec",
  "parity-util-mem",
- "rand",
- "rand_chacha",
+ "rand 0.8.5",
+ "rand_chacha 0.3.1",
  "safe-math",
  "scale-info",
  "serde",
@@ -6518,7 +7477,7 @@ dependencies = [
  "sp-core",
  "sp-io",
  "sp-runtime",
- "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7)",
+ "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
  "sp-tracing 17.0.1",
  "sp-version",
  "substrate-fixed",
@@ -6529,8 +7488,8 @@ dependencies = [
 
 [[package]]
 name = "pallet-sudo"
-version = "38.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "39.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "docify",
  "frame-benchmarking",
@@ -6544,8 +7503,8 @@ dependencies = [
 
 [[package]]
 name = "pallet-timestamp"
-version = "37.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "38.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "docify",
  "frame-benchmarking",
@@ -6557,15 +7516,16 @@ dependencies = [
  "sp-inherents",
  "sp-io",
  "sp-runtime",
- "sp-storage 21.0.0",
+ "sp-storage 22.0.0",
  "sp-timestamp",
 ]
 
 [[package]]
 name = "pallet-transaction-payment"
-version = "38.0.2"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "39.1.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
+ "frame-benchmarking",
  "frame-support",
  "frame-system",
  "parity-scale-codec",
@@ -6578,10 +7538,10 @@ dependencies = [
 
 [[package]]
 name = "pallet-transaction-payment-rpc"
-version = "41.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "42.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
- "jsonrpsee",
+ "jsonrpsee 0.24.7",
  "pallet-transaction-payment-rpc-runtime-api",
  "parity-scale-codec",
  "sp-api",
@@ -6594,8 +7554,8 @@ dependencies = [
 
 [[package]]
 name = "pallet-transaction-payment-rpc-runtime-api"
-version = "38.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "39.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "pallet-transaction-payment",
  "parity-scale-codec",
@@ -6625,8 +7585,8 @@ dependencies = [
 
 [[package]]
 name = "pallet-utility"
-version = "38.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "39.1.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "frame-benchmarking",
  "frame-support",
@@ -6645,8 +7605,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4e69bf016dc406eff7d53a7d3f7cf1c2e72c82b9088aac1118591e36dd2cd3e9"
 dependencies = [
  "bitcoin_hashes",
- "rand",
- "rand_core",
+ "rand 0.8.5",
+ "rand_core 0.6.4",
  "serde",
  "unicode-normalization",
 ]
@@ -6666,37 +7626,39 @@ dependencies = [
  "lz4",
  "memmap2 0.5.10",
  "parking_lot 0.12.3",
- "rand",
- "siphasher",
+ "rand 0.8.5",
+ "siphasher 0.3.11",
  "snap",
  "winapi",
 ]
 
 [[package]]
 name = "parity-scale-codec"
-version = "3.6.12"
+version = "3.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "306800abfa29c7f16596b5970a588435e3d5b3149683d00c12b699cc19f895ee"
+checksum = "799781ae679d79a948e13d4824a40970bfa500058d245760dd857301059810fa"
 dependencies = [
- "arrayvec",
+ "arrayvec 0.7.6",
  "bitvec",
  "byte-slice-cast",
  "bytes",
+ "const_format",
  "impl-trait-for-tuples",
  "parity-scale-codec-derive",
+ "rustversion",
  "serde",
 ]
 
 [[package]]
 name = "parity-scale-codec-derive"
-version = "3.6.12"
+version = "3.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d830939c76d294956402033aee57a6da7b438f2294eb94864c37b0569053a42c"
+checksum = "34b4653168b563151153c9e4c08ebed57fb8262bebfa79711552fa983c623e7a"
 dependencies = [
  "proc-macro-crate 3.2.0",
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -6706,13 +7668,13 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0d32c34f4f5ca7f9196001c0aba5a1f9a5a12382c8944b8b0f90233282d1e8f8"
 dependencies = [
  "cfg-if",
- "ethereum-types",
+ "ethereum-types 0.14.1",
  "hashbrown 0.12.3",
  "impl-trait-for-tuples",
  "lru 0.8.1",
  "parity-util-mem-derive",
  "parking_lot 0.12.3",
- "primitive-types",
+ "primitive-types 0.12.2",
  "smallvec",
  "winapi",
 ]
@@ -6801,7 +7763,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "346f04948ba92c43e8469c1ee6736c7563d71012b17d40745260fe106aac2166"
 dependencies = [
  "base64ct",
- "rand_core",
+ "rand_core 0.6.4",
  "subtle 2.6.1",
 ]
 
@@ -6849,7 +7811,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fdbef9d1d47087a895abd220ed25eb4ad973a5e26f6a4367b038c25e28dfc2d9"
 dependencies = [
  "memchr",
- "thiserror",
+ "thiserror 1.0.64",
  "ucd-trie",
 ]
 
@@ -6873,7 +7835,7 @@ dependencies = [
  "pest_meta",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -6894,27 +7856,27 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b4c5cc86750666a3ed20bdaf5ca2a0344f9c67674cae0515bec2da16fbaa47db"
 dependencies = [
  "fixedbitset",
- "indexmap 2.6.0",
+ "indexmap 2.9.0",
 ]
 
 [[package]]
 name = "pin-project"
-version = "1.1.5"
+version = "1.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6bf43b791c5b9e34c3d182969b4abb522f9343702850a2e57f460d00d09b4b3"
+checksum = "677f1add503faace112b9f1373e43e9e054bfdd22ff1a63c1bc485eaec6a6a8a"
 dependencies = [
  "pin-project-internal",
 ]
 
 [[package]]
 name = "pin-project-internal"
-version = "1.1.5"
+version = "1.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f38a4412a78282e09a2cf38d195ea5420d15ba0602cb375210efbc877243965"
+checksum = "6e918e4ff8c4549eb882f14b3a4bc8c8bc93de829416eacf579f1207a8fbf861"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -6930,21 +7892,253 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
 
 [[package]]
-name = "pkcs8"
-version = "0.10.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
+name = "piper"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96c8c490f422ef9a4efd2cb5b42b76c8613d7e7dfc1caf667b8a3350a5acc066"
+dependencies = [
+ "atomic-waker",
+ "fastrand",
+ "futures-io",
+]
+
+[[package]]
+name = "pkcs8"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
+dependencies = [
+ "der",
+ "spki",
+]
+
+[[package]]
+name = "pkg-config"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "953ec861398dccce10c670dfeaf3ec4911ca479e9c02154b3a215178c5f566f2"
+
+[[package]]
+name = "polkadot-core-primitives"
+version = "16.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+dependencies = [
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-runtime",
+]
+
+[[package]]
+name = "polkadot-node-metrics"
+version = "21.1.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+dependencies = [
+ "bs58",
+ "futures",
+ "futures-timer",
+ "log",
+ "parity-scale-codec",
+ "polkadot-primitives",
+ "prioritized-metered-channel",
+ "sc-cli",
+ "sc-service",
+ "sc-tracing",
+ "substrate-prometheus-endpoint",
+ "tracing-gum",
+]
+
+[[package]]
+name = "polkadot-node-network-protocol"
+version = "21.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+dependencies = [
+ "async-channel 1.9.0",
+ "async-trait",
+ "bitvec",
+ "derive_more 0.99.18",
+ "fatality",
+ "futures",
+ "hex",
+ "parity-scale-codec",
+ "polkadot-node-primitives",
+ "polkadot-primitives",
+ "rand 0.8.5",
+ "sc-authority-discovery",
+ "sc-network",
+ "sc-network-types",
+ "sp-runtime",
+ "strum 0.26.3",
+ "thiserror 1.0.64",
+ "tracing-gum",
+]
+
+[[package]]
+name = "polkadot-node-primitives"
+version = "17.0.1"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+dependencies = [
+ "bitvec",
+ "bounded-vec",
+ "futures",
+ "futures-timer",
+ "parity-scale-codec",
+ "polkadot-parachain-primitives",
+ "polkadot-primitives",
+ "sc-keystore",
+ "schnorrkel",
+ "serde",
+ "sp-application-crypto",
+ "sp-consensus-babe",
+ "sp-consensus-slots",
+ "sp-core",
+ "sp-keystore",
+ "sp-maybe-compressed-blob",
+ "sp-runtime",
+ "thiserror 1.0.64",
+ "zstd 0.12.4",
+]
+
+[[package]]
+name = "polkadot-node-subsystem-types"
+version = "21.0.1"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+dependencies = [
+ "async-trait",
+ "bitvec",
+ "derive_more 0.99.18",
+ "fatality",
+ "futures",
+ "orchestra",
+ "polkadot-node-network-protocol",
+ "polkadot-node-primitives",
+ "polkadot-primitives",
+ "polkadot-statement-table",
+ "sc-client-api",
+ "sc-network",
+ "sc-network-types",
+ "sc-transaction-pool-api",
+ "smallvec",
+ "sp-api",
+ "sp-authority-discovery",
+ "sp-blockchain",
+ "sp-consensus-babe",
+ "sp-runtime",
+ "substrate-prometheus-endpoint",
+ "thiserror 1.0.64",
+]
+
+[[package]]
+name = "polkadot-overseer"
+version = "21.1.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+dependencies = [
+ "async-trait",
+ "futures",
+ "futures-timer",
+ "orchestra",
+ "parking_lot 0.12.3",
+ "polkadot-node-metrics",
+ "polkadot-node-network-protocol",
+ "polkadot-node-primitives",
+ "polkadot-node-subsystem-types",
+ "polkadot-primitives",
+ "sc-client-api",
+ "sp-api",
+ "sp-core",
+ "tikv-jemalloc-ctl",
+ "tracing-gum",
+]
+
+[[package]]
+name = "polkadot-parachain-primitives"
+version = "15.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+dependencies = [
+ "bounded-collections",
+ "derive_more 0.99.18",
+ "parity-scale-codec",
+ "polkadot-core-primitives",
+ "scale-info",
+ "serde",
+ "sp-core",
+ "sp-runtime",
+ "sp-weights",
+]
+
+[[package]]
+name = "polkadot-primitives"
+version = "17.1.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+dependencies = [
+ "bitvec",
+ "hex-literal",
+ "log",
+ "parity-scale-codec",
+ "polkadot-core-primitives",
+ "polkadot-parachain-primitives",
+ "scale-info",
+ "serde",
+ "sp-api",
+ "sp-application-crypto",
+ "sp-arithmetic",
+ "sp-authority-discovery",
+ "sp-consensus-slots",
+ "sp-core",
+ "sp-inherents",
+ "sp-io",
+ "sp-keystore",
+ "sp-runtime",
+ "sp-staking",
+ "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "thiserror 1.0.64",
+]
+
+[[package]]
+name = "polkadot-sdk-frame"
+version = "0.8.1"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+dependencies = [
+ "docify",
+ "frame-benchmarking",
+ "frame-executive",
+ "frame-support",
+ "frame-system",
+ "frame-system-benchmarking",
+ "frame-system-rpc-runtime-api",
+ "frame-try-runtime",
+ "log",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-api",
+ "sp-arithmetic",
+ "sp-block-builder",
+ "sp-consensus-aura",
+ "sp-consensus-grandpa",
+ "sp-core",
+ "sp-genesis-builder",
+ "sp-inherents",
+ "sp-io",
+ "sp-keyring",
+ "sp-offchain",
+ "sp-runtime",
+ "sp-session",
+ "sp-storage 22.0.0",
+ "sp-transaction-pool",
+ "sp-version",
+]
+
+[[package]]
+name = "polkadot-statement-table"
+version = "17.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
- "der",
- "spki",
+ "parity-scale-codec",
+ "polkadot-primitives",
+ "sp-core",
+ "tracing-gum",
 ]
 
-[[package]]
-name = "pkg-config"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "953ec861398dccce10c670dfeaf3ec4911ca479e9c02154b3a215178c5f566f2"
-
 [[package]]
 name = "polkavm"
 version = "0.9.3"
@@ -6994,7 +8188,7 @@ dependencies = [
  "polkavm-common",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -7004,7 +8198,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8ba81f7b5faac81e528eb6158a6f3c9e0bb1008e0ffa19653bc8dea925ecb429"
 dependencies = [
  "polkavm-derive-impl",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -7072,6 +8266,15 @@ version = "1.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cc9c68a3f6da06753e9335d63e27f6b9754dd1920d941135b7ea8224f141adb2"
 
+[[package]]
+name = "potential_utf"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5a7c30837279ca13e7c867e9e40053bc68740f988cb07f7ca6df43cc734b585"
+dependencies = [
+ "zerovec",
+]
+
 [[package]]
 name = "powerfmt"
 version = "0.2.0"
@@ -7090,7 +8293,7 @@ dependencies = [
 [[package]]
 name = "precompile-utils"
 version = "0.1.0"
-source = "git+https://github.com/opentensor/frontier?rev=cd6bca14a3#cd6bca14a366cc7cb1c3b1b1d7bc8213667e4126"
+source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
 dependencies = [
  "environmental",
  "evm",
@@ -7114,15 +8317,15 @@ dependencies = [
 [[package]]
 name = "precompile-utils-macro"
 version = "0.1.0"
-source = "git+https://github.com/opentensor/frontier?rev=cd6bca14a3#cd6bca14a366cc7cb1c3b1b1d7bc8213667e4126"
+source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
 dependencies = [
  "case",
  "num_enum",
- "prettyplease 0.2.22",
+ "prettyplease",
  "proc-macro2",
  "quote",
- "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7)",
- "syn 1.0.109",
+ "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -7167,36 +8370,57 @@ dependencies = [
 
 [[package]]
 name = "prettyplease"
-version = "0.1.25"
+version = "0.2.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c8646e95016a7a6c4adea95bafa8a16baab64b583356217f2c85db4a39d9a86"
+checksum = "664ec5419c51e34154eec046ebcba56312d5a2fc3b09a06da188e1ad21afadf6"
 dependencies = [
  "proc-macro2",
- "syn 1.0.109",
+ "syn 2.0.101",
 ]
 
 [[package]]
-name = "prettyplease"
-version = "0.2.22"
+name = "primitive-types"
+version = "0.12.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "479cf940fbbb3426c32c5d5176f62ad57549a0bb84773423ba8be9d089f5faba"
+checksum = "0b34d9fd68ae0b74a41b21c03c2f62847aa0ffea044eee893b4c140b37e244e2"
 dependencies = [
- "proc-macro2",
- "syn 2.0.90",
+ "fixed-hash",
+ "impl-codec 0.6.0",
+ "impl-rlp 0.3.0",
+ "impl-serde 0.4.0",
+ "scale-info",
+ "uint 0.9.5",
 ]
 
 [[package]]
 name = "primitive-types"
-version = "0.12.2"
+version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b34d9fd68ae0b74a41b21c03c2f62847aa0ffea044eee893b4c140b37e244e2"
+checksum = "d15600a7d856470b7d278b3fe0e311fe28c2526348549f8ef2ff7db3299c87f5"
 dependencies = [
  "fixed-hash",
- "impl-codec",
- "impl-rlp",
- "impl-serde",
+ "impl-codec 0.7.1",
+ "impl-num-traits",
+ "impl-rlp 0.4.0",
+ "impl-serde 0.5.0",
  "scale-info",
- "uint",
+ "uint 0.10.0",
+]
+
+[[package]]
+name = "prioritized-metered-channel"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a172e6cc603231f2cf004232eabcecccc0da53ba576ab286ef7baa0cfc7927ad"
+dependencies = [
+ "coarsetime",
+ "crossbeam-queue",
+ "derive_more 0.99.18",
+ "futures",
+ "futures-timer",
+ "nanorand",
+ "thiserror 1.0.64",
+ "tracing",
 ]
 
 [[package]]
@@ -7205,7 +8429,7 @@ version = "1.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e17d47ce914bf4de440332250b0edd23ce48c005f59fab39d3335866b114f11a"
 dependencies = [
- "thiserror",
+ "thiserror 1.0.64",
  "toml 0.5.11",
 ]
 
@@ -7250,7 +8474,7 @@ checksum = "3d1eaa7fa0aa1929ffdf7eeb6eac234dde6268914a14ad44d23521ab6a9b258e"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -7261,14 +8485,14 @@ checksum = "834da187cfe638ae8abb0203f0b33e5ccdb02a28e7199f2f47b3e2754f50edca"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.92"
+version = "1.0.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37d3544b3f2748c54e147655edb5025752e2303145b5aefb3c3ea2c78b973bb0"
+checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778"
 dependencies = [
  "unicode-ident",
 ]
@@ -7289,7 +8513,7 @@ dependencies = [
  "quote",
  "regex",
  "sp-crypto-hashing 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -7303,7 +8527,7 @@ dependencies = [
  "lazy_static",
  "memchr",
  "parking_lot 0.12.3",
- "thiserror",
+ "thiserror 1.0.64",
 ]
 
 [[package]]
@@ -7326,17 +8550,23 @@ checksum = "440f724eba9f6996b75d63681b0a92b06947f1457076d503a4d2e2c8f56442b8"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
-name = "prost"
-version = "0.11.9"
+name = "proptest"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b82eaa1d779e9a4bc1c3217db8ffbeabaae1dca241bf70183242128d48681cd"
+checksum = "14cae93065090804185d3b75f0bf93b8eeda30c7a9b4a33d3bdb3988d6229e50"
 dependencies = [
- "bytes",
- "prost-derive 0.11.9",
+ "bitflags 2.6.0",
+ "lazy_static",
+ "num-traits",
+ "rand 0.8.5",
+ "rand_chacha 0.3.1",
+ "rand_xorshift",
+ "regex-syntax 0.8.5",
+ "unarray",
 ]
 
 [[package]]
@@ -7350,90 +8580,68 @@ dependencies = [
 ]
 
 [[package]]
-name = "prost-build"
-version = "0.11.9"
+name = "prost"
+version = "0.13.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "119533552c9a7ffacc21e099c24a0ac8bb19c2a2a3f363de84cd9b844feab270"
+checksum = "2796faa41db3ec313a31f7624d9286acf277b52de526150b7e69f3debf891ee5"
 dependencies = [
  "bytes",
- "heck 0.4.1",
- "itertools 0.10.5",
- "lazy_static",
- "log",
- "multimap",
- "petgraph",
- "prettyplease 0.1.25",
- "prost 0.11.9",
- "prost-types 0.11.9",
- "regex",
- "syn 1.0.109",
- "tempfile",
- "which",
+ "prost-derive 0.13.5",
 ]
 
 [[package]]
 name = "prost-build"
-version = "0.12.6"
+version = "0.13.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22505a5c94da8e3b7c2996394d1c933236c4d743e81a410bcca4e6989fc066a4"
+checksum = "be769465445e8c1474e9c5dac2018218498557af32d9ed057325ec9a41ae81bf"
 dependencies = [
- "bytes",
  "heck 0.5.0",
  "itertools 0.12.1",
  "log",
  "multimap",
  "once_cell",
  "petgraph",
- "prettyplease 0.2.22",
- "prost 0.12.6",
- "prost-types 0.12.6",
+ "prettyplease",
+ "prost 0.13.5",
+ "prost-types",
  "regex",
- "syn 2.0.90",
+ "syn 2.0.101",
  "tempfile",
 ]
 
 [[package]]
 name = "prost-derive"
-version = "0.11.9"
+version = "0.12.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5d2d8d10f3c6ded6da8b05b5fb3b8a5082514344d56c9f871412d29b4e075b4"
+checksum = "81bddcdb20abf9501610992b6759a4c888aef7d1a7247ef75e2404275ac24af1"
 dependencies = [
  "anyhow",
- "itertools 0.10.5",
+ "itertools 0.12.1",
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.101",
 ]
 
 [[package]]
 name = "prost-derive"
-version = "0.12.6"
+version = "0.13.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81bddcdb20abf9501610992b6759a4c888aef7d1a7247ef75e2404275ac24af1"
+checksum = "8a56d757972c98b346a9b766e3f02746cde6dd1cd1d1d563472929fdd74bec4d"
 dependencies = [
  "anyhow",
  "itertools 0.12.1",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
-]
-
-[[package]]
-name = "prost-types"
-version = "0.11.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "213622a1460818959ac1181aaeb2dc9c7f63df720db7d788b3e24eacd1983e13"
-dependencies = [
- "prost 0.11.9",
+ "syn 2.0.101",
 ]
 
 [[package]]
 name = "prost-types"
-version = "0.12.6"
+version = "0.13.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9091c90b0a32608e984ff2fa4091273cbdd755d54935c51d520887f4a1dbd5b0"
+checksum = "52c2c1bf36ddb1a1c396b3601a3cec27c2462e45f07c386894ec3ccf5332bd16"
 dependencies = [
- "prost 0.12.6",
+ "prost 0.13.5",
 ]
 
 [[package]]
@@ -7455,7 +8663,7 @@ dependencies = [
  "libc",
  "once_cell",
  "raw-cpuid",
- "wasi",
+ "wasi 0.11.0+wasi-snapshot-preview1",
  "web-sys",
  "winapi",
 ]
@@ -7484,28 +8692,10 @@ dependencies = [
  "asynchronous-codec",
  "bytes",
  "quick-protobuf",
- "thiserror",
+ "thiserror 1.0.64",
  "unsigned-varint 0.7.2",
 ]
 
-[[package]]
-name = "quinn"
-version = "0.9.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e8b432585672228923edbbf64b8b12c14e1112f62e88737655b4a083dbcd78e"
-dependencies = [
- "bytes",
- "pin-project-lite",
- "quinn-proto 0.9.6",
- "quinn-udp 0.3.2",
- "rustc-hash 1.1.0",
- "rustls 0.20.9",
- "thiserror",
- "tokio",
- "tracing",
- "webpki",
-]
-
 [[package]]
 name = "quinn"
 version = "0.10.2"
@@ -7515,33 +8705,15 @@ dependencies = [
  "bytes",
  "futures-io",
  "pin-project-lite",
- "quinn-proto 0.10.6",
- "quinn-udp 0.4.1",
+ "quinn-proto",
+ "quinn-udp",
  "rustc-hash 1.1.0",
  "rustls 0.21.12",
- "thiserror",
+ "thiserror 1.0.64",
  "tokio",
  "tracing",
 ]
 
-[[package]]
-name = "quinn-proto"
-version = "0.9.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94b0b33c13a79f669c85defaf4c275dc86a0c0372807d0ca3d78e0bb87274863"
-dependencies = [
- "bytes",
- "rand",
- "ring 0.16.20",
- "rustc-hash 1.1.0",
- "rustls 0.20.9",
- "slab",
- "thiserror",
- "tinyvec",
- "tracing",
- "webpki",
-]
-
 [[package]]
 name = "quinn-proto"
 version = "0.10.6"
@@ -7549,29 +8721,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "141bf7dfde2fbc246bfd3fe12f2455aa24b0fbd9af535d8c86c7bd1381ff2b1a"
 dependencies = [
  "bytes",
- "rand",
+ "rand 0.8.5",
  "ring 0.16.20",
  "rustc-hash 1.1.0",
  "rustls 0.21.12",
  "slab",
- "thiserror",
+ "thiserror 1.0.64",
  "tinyvec",
  "tracing",
 ]
 
-[[package]]
-name = "quinn-udp"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "641538578b21f5e5c8ea733b736895576d0fe329bb883b937db6f4d163dbaaf4"
-dependencies = [
- "libc",
- "quinn-proto 0.9.6",
- "socket2 0.4.10",
- "tracing",
- "windows-sys 0.42.0",
-]
-
 [[package]]
 name = "quinn-udp"
 version = "0.4.1"
@@ -7580,20 +8739,26 @@ checksum = "055b4e778e8feb9f93c4e439f71dc2156ef13360b432b799e179a8c4cdf0b1d7"
 dependencies = [
  "bytes",
  "libc",
- "socket2 0.5.7",
+ "socket2 0.5.9",
  "tracing",
  "windows-sys 0.48.0",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.37"
+version = "1.0.40"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
+checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d"
 dependencies = [
  "proc-macro2",
 ]
 
+[[package]]
+name = "r-efi"
+version = "5.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "74765f6d916ee2faa39bc8e68e4f3ed8949b48cccdac59983d287a7cb71ce9c5"
+
 [[package]]
 name = "radium"
 version = "0.7.0"
@@ -7607,8 +8772,18 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
 dependencies = [
  "libc",
- "rand_chacha",
- "rand_core",
+ "rand_chacha 0.3.1",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9fbfd9d094a40bf3ae768db9361049ace4c0e04a4fd6b359518bd7b73a73dd97"
+dependencies = [
+ "rand_chacha 0.9.0",
+ "rand_core 0.9.3",
 ]
 
 [[package]]
@@ -7618,7 +8793,17 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
 dependencies = [
  "ppv-lite86",
- "rand_core",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.9.3",
 ]
 
 [[package]]
@@ -7627,7 +8812,16 @@ version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
 dependencies = [
- "getrandom",
+ "getrandom 0.2.15",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38"
+dependencies = [
+ "getrandom 0.3.3",
 ]
 
 [[package]]
@@ -7637,7 +8831,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32cb0b9bc82b0a0876c2dd994a7e7a2683d3e7390ca40e6886785ef0c7e3ee31"
 dependencies = [
  "num-traits",
- "rand",
+ "rand 0.8.5",
 ]
 
 [[package]]
@@ -7646,7 +8840,16 @@ version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "59cad018caf63deb318e5a4586d99a24424a364f40f1e5778c29aca23f4fc73e"
 dependencies = [
- "rand_core",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand_xorshift"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d25bf25ec5ae4a3f1b92f929810509a2f53d7dca2f50b794ff57e3face536c8f"
+dependencies = [
+ "rand_core 0.6.4",
 ]
 
 [[package]]
@@ -7696,6 +8899,22 @@ dependencies = [
  "yasna",
 ]
 
+[[package]]
+name = "reconnecting-jsonrpsee-ws-client"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06fa4f17e09edfc3131636082faaec633c7baa269396b4004040bc6c52f49f65"
+dependencies = [
+ "cfg_aliases 0.2.1",
+ "finito",
+ "futures",
+ "jsonrpsee 0.23.2",
+ "serde_json",
+ "thiserror 1.0.64",
+ "tokio",
+ "tracing",
+]
+
 [[package]]
 name = "redox_syscall"
 version = "0.2.16"
@@ -7720,9 +8939,9 @@ version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ba009ff324d1fc1b900bd1fdb31564febe58a8ccc8a6fdbb93b543d33b13ca43"
 dependencies = [
- "getrandom",
+ "getrandom 0.2.15",
  "libredox",
- "thiserror",
+ "thiserror 1.0.64",
 ]
 
 [[package]]
@@ -7742,7 +8961,7 @@ checksum = "bcc303e793d3734489387d205e9b186fac9c6cfacedd98cbb2e8a5943595f3e6"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -7857,7 +9076,7 @@ checksum = "70ac5d832aa16abd7d1def883a8545280c20a60f523a370aa3a9617c2b8550ee"
 dependencies = [
  "cc",
  "cfg-if",
- "getrandom",
+ "getrandom 0.2.15",
  "libc",
  "untrusted 0.9.0",
  "windows-sys 0.52.0",
@@ -7877,6 +9096,16 @@ name = "rlp"
 version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bb919243f34364b6bd2fc10ef797edbfa75f33c252e7998527479c6d6b47e1ec"
+dependencies = [
+ "bytes",
+ "rustc-hex",
+]
+
+[[package]]
+name = "rlp"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa24e92bb2a83198bb76d661a71df9f7076b8c420b8696e4d3d97d50d94479e3"
 dependencies = [
  "bytes",
  "rlp-derive",
@@ -7885,13 +9114,13 @@ dependencies = [
 
 [[package]]
 name = "rlp-derive"
-version = "0.1.0"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e33d7b2abe0c340d8797fe2907d3f20d3b5ea5908683618bfe80df7f621f672a"
+checksum = "652db34deaaa57929e10ca18e5454a32cb0efc351ae80d320334bbf907b908b3"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -7932,7 +9161,7 @@ dependencies = [
  "netlink-packet-route",
  "netlink-proto",
  "nix",
- "thiserror",
+ "thiserror 1.0.64",
  "tokio",
 ]
 
@@ -8026,25 +9255,43 @@ dependencies = [
 
 [[package]]
 name = "rustls"
-version = "0.20.9"
+version = "0.21.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b80e3dec595989ea8510028f30c408a4630db12c9cbb8de34203b89d6577e99"
+checksum = "3f56a14d1f48b391359b22f731fd4bd7e43c97f3c50eee276f3aa09c94784d3e"
 dependencies = [
- "ring 0.16.20",
+ "log",
+ "ring 0.17.13",
+ "rustls-webpki 0.101.7",
  "sct",
- "webpki",
 ]
 
 [[package]]
 name = "rustls"
-version = "0.21.12"
+version = "0.22.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f56a14d1f48b391359b22f731fd4bd7e43c97f3c50eee276f3aa09c94784d3e"
+checksum = "bf4ef73721ac7bcd79b2b315da7779d8fc09718c6b3d2d1b2d94850eb8c18432"
 dependencies = [
  "log",
  "ring 0.17.13",
- "rustls-webpki",
- "sct",
+ "rustls-pki-types",
+ "rustls-webpki 0.102.8",
+ "subtle 2.6.1",
+ "zeroize",
+]
+
+[[package]]
+name = "rustls"
+version = "0.23.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "730944ca083c1c233a75c09f199e973ca499344a2b7ba9e755c457e86fb4a321"
+dependencies = [
+ "log",
+ "once_cell",
+ "ring 0.17.13",
+ "rustls-pki-types",
+ "rustls-webpki 0.103.3",
+ "subtle 2.6.1",
+ "zeroize",
 ]
 
 [[package]]
@@ -8054,27 +9301,119 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a9aace74cb666635c918e9c12bc0d348266037aa8eb599b5cba565709a8dff00"
 dependencies = [
  "openssl-probe",
- "rustls-pemfile",
+ "rustls-pemfile 1.0.4",
+ "schannel",
+ "security-framework 2.11.1",
+]
+
+[[package]]
+name = "rustls-native-certs"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5bfb394eeed242e909609f56089eecfe5fda225042e8b171791b9c95f5931e5"
+dependencies = [
+ "openssl-probe",
+ "rustls-pemfile 2.2.0",
+ "rustls-pki-types",
+ "schannel",
+ "security-framework 2.11.1",
+]
+
+[[package]]
+name = "rustls-native-certs"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fcff2dd52b58a8d98a70243663a0d234c4e2b79235637849d15913394a247d3"
+dependencies = [
+ "openssl-probe",
+ "rustls-pki-types",
  "schannel",
- "security-framework",
+ "security-framework 3.2.0",
 ]
 
 [[package]]
 name = "rustls-pemfile"
 version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c74cae0a4cf6ccbbf5f359f08efdf8ee7e1dc532573bf0db71968cb56b1448c"
+checksum = "1c74cae0a4cf6ccbbf5f359f08efdf8ee7e1dc532573bf0db71968cb56b1448c"
+dependencies = [
+ "base64 0.21.7",
+]
+
+[[package]]
+name = "rustls-pemfile"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dce314e5fee3f39953d46bb63bb8a46d40c2f8fb7cc5a3b6cab2bde9721d6e50"
+dependencies = [
+ "rustls-pki-types",
+]
+
+[[package]]
+name = "rustls-pki-types"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "229a4a4c221013e7e1f1a043678c5cc39fe5171437c88fb47151a21e6f5b5c79"
+dependencies = [
+ "zeroize",
+]
+
+[[package]]
+name = "rustls-platform-verifier"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "afbb878bdfdf63a336a5e63561b1835e7a8c91524f51621db870169eac84b490"
+dependencies = [
+ "core-foundation 0.9.4",
+ "core-foundation-sys",
+ "jni",
+ "log",
+ "once_cell",
+ "rustls 0.23.27",
+ "rustls-native-certs 0.7.3",
+ "rustls-platform-verifier-android",
+ "rustls-webpki 0.102.8",
+ "security-framework 2.11.1",
+ "security-framework-sys",
+ "webpki-roots 0.26.11",
+ "winapi",
+]
+
+[[package]]
+name = "rustls-platform-verifier-android"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f87165f0995f63a9fbeea62b64d10b4d9d8e78ec6d7d51fb2125fda7bb36788f"
+
+[[package]]
+name = "rustls-webpki"
+version = "0.101.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b6275d1ee7a1cd780b64aca7726599a1dbc893b1e64144529e55c3c2f745765"
+dependencies = [
+ "ring 0.17.13",
+ "untrusted 0.9.0",
+]
+
+[[package]]
+name = "rustls-webpki"
+version = "0.102.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "64ca1bc8749bd4cf37b5ce386cc146580777b4e8572c7b97baf22c83f444bee9"
 dependencies = [
- "base64 0.21.7",
+ "ring 0.17.13",
+ "rustls-pki-types",
+ "untrusted 0.9.0",
 ]
 
 [[package]]
 name = "rustls-webpki"
-version = "0.101.7"
+version = "0.103.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b6275d1ee7a1cd780b64aca7726599a1dbc893b1e64144529e55c3c2f745765"
+checksum = "e4a72fe2bcf7a6ac6fd7d0b9e5cb68aeb7d4c0a0271730218b3e92d43b4eb435"
 dependencies = [
  "ring 0.17.13",
+ "rustls-pki-types",
  "untrusted 0.9.0",
 ]
 
@@ -8084,6 +9423,17 @@ version = "1.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "955d28af4278de8121b7ebeb796b6a45735dc01436d898801014aced2773a3d6"
 
+[[package]]
+name = "ruzstd"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "58c4eb8a81997cf040a091d1f7e1938aeab6749d3a0dfa73af43cdc32393483d"
+dependencies = [
+ "byteorder",
+ "derive_more 0.99.18",
+ "twox-hash",
+]
+
 [[package]]
 name = "rw-stream-sink"
 version = "0.4.0"
@@ -8106,7 +9456,7 @@ name = "safe-math"
 version = "0.1.0"
 dependencies = [
  "num-traits",
- "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7)",
+ "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
  "substrate-fixed",
 ]
 
@@ -8139,19 +9489,49 @@ dependencies = [
 
 [[package]]
 name = "sc-allocator"
-version = "29.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "30.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "log",
  "sp-core",
  "sp-wasm-interface 21.0.1",
- "thiserror",
+ "thiserror 1.0.64",
+]
+
+[[package]]
+name = "sc-authority-discovery"
+version = "0.48.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+dependencies = [
+ "async-trait",
+ "futures",
+ "futures-timer",
+ "ip_network",
+ "libp2p",
+ "linked_hash_set",
+ "log",
+ "multihash 0.19.2",
+ "parity-scale-codec",
+ "prost 0.12.6",
+ "prost-build",
+ "rand 0.8.5",
+ "sc-client-api",
+ "sc-network",
+ "sc-network-types",
+ "sp-api",
+ "sp-authority-discovery",
+ "sp-blockchain",
+ "sp-core",
+ "sp-keystore",
+ "sp-runtime",
+ "substrate-prometheus-endpoint",
+ "thiserror 1.0.64",
 ]
 
 [[package]]
 name = "sc-basic-authorship"
-version = "0.45.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.48.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "futures",
  "futures-timer",
@@ -8172,8 +9552,8 @@ dependencies = [
 
 [[package]]
 name = "sc-block-builder"
-version = "0.42.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.43.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "parity-scale-codec",
  "sp-api",
@@ -8187,8 +9567,8 @@ dependencies = [
 
 [[package]]
 name = "sc-chain-spec"
-version = "38.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "41.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "array-bytes",
  "docify",
@@ -8204,7 +9584,7 @@ dependencies = [
  "serde_json",
  "sp-blockchain",
  "sp-core",
- "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7)",
+ "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
  "sp-genesis-builder",
  "sp-io",
  "sp-runtime",
@@ -8215,18 +9595,18 @@ dependencies = [
 [[package]]
 name = "sc-chain-spec-derive"
 version = "12.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "proc-macro-crate 3.2.0",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
 name = "sc-cli"
-version = "0.47.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.50.1"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "array-bytes",
  "chrono",
@@ -8239,7 +9619,7 @@ dependencies = [
  "names",
  "parity-bip39",
  "parity-scale-codec",
- "rand",
+ "rand 0.8.5",
  "regex",
  "rpassword",
  "sc-client-api",
@@ -8250,6 +9630,7 @@ dependencies = [
  "sc-service",
  "sc-telemetry",
  "sc-tracing",
+ "sc-transaction-pool",
  "sc-utils",
  "serde",
  "serde_json",
@@ -8260,14 +9641,14 @@ dependencies = [
  "sp-panic-handler",
  "sp-runtime",
  "sp-version",
- "thiserror",
+ "thiserror 1.0.64",
  "tokio",
 ]
 
 [[package]]
 name = "sc-client-api"
-version = "37.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "38.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "fnv",
  "futures",
@@ -8282,19 +9663,19 @@ dependencies = [
  "sp-consensus",
  "sp-core",
  "sp-database",
- "sp-externalities 0.29.0",
+ "sp-externalities 0.30.0",
  "sp-runtime",
  "sp-state-machine",
  "sp-statement-store",
- "sp-storage 21.0.0",
+ "sp-storage 22.0.0",
  "sp-trie",
  "substrate-prometheus-endpoint",
 ]
 
 [[package]]
 name = "sc-client-db"
-version = "0.44.1"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.45.1"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "hash-db",
  "kvdb",
@@ -8319,8 +9700,8 @@ dependencies = [
 
 [[package]]
 name = "sc-consensus"
-version = "0.44.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.47.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "async-trait",
  "futures",
@@ -8338,13 +9719,13 @@ dependencies = [
  "sp-runtime",
  "sp-state-machine",
  "substrate-prometheus-endpoint",
- "thiserror",
+ "thiserror 1.0.64",
 ]
 
 [[package]]
 name = "sc-consensus-aura"
-version = "0.45.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.48.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "async-trait",
  "futures",
@@ -8367,13 +9748,13 @@ dependencies = [
  "sp-keystore",
  "sp-runtime",
  "substrate-prometheus-endpoint",
- "thiserror",
+ "thiserror 1.0.64",
 ]
 
 [[package]]
 name = "sc-consensus-babe"
-version = "0.45.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.48.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "async-trait",
  "fork-tree",
@@ -8398,18 +9779,18 @@ dependencies = [
  "sp-consensus-babe",
  "sp-consensus-slots",
  "sp-core",
- "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7)",
+ "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
  "sp-inherents",
  "sp-keystore",
  "sp-runtime",
  "substrate-prometheus-endpoint",
- "thiserror",
+ "thiserror 1.0.64",
 ]
 
 [[package]]
 name = "sc-consensus-epochs"
-version = "0.44.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.47.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "fork-tree",
  "parity-scale-codec",
@@ -8421,8 +9802,8 @@ dependencies = [
 
 [[package]]
 name = "sc-consensus-grandpa"
-version = "0.30.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.33.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "ahash 0.8.11",
  "array-bytes",
@@ -8435,7 +9816,7 @@ dependencies = [
  "log",
  "parity-scale-codec",
  "parking_lot 0.12.3",
- "rand",
+ "rand 0.8.5",
  "sc-block-builder",
  "sc-chain-spec",
  "sc-client-api",
@@ -8456,21 +9837,21 @@ dependencies = [
  "sp-consensus",
  "sp-consensus-grandpa",
  "sp-core",
- "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7)",
+ "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
  "sp-keystore",
  "sp-runtime",
  "substrate-prometheus-endpoint",
- "thiserror",
+ "thiserror 1.0.64",
 ]
 
 [[package]]
 name = "sc-consensus-grandpa-rpc"
-version = "0.30.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.33.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "finality-grandpa",
  "futures",
- "jsonrpsee",
+ "jsonrpsee 0.24.7",
  "log",
  "parity-scale-codec",
  "sc-client-api",
@@ -8480,19 +9861,19 @@ dependencies = [
  "sp-blockchain",
  "sp-core",
  "sp-runtime",
- "thiserror",
+ "thiserror 1.0.64",
 ]
 
 [[package]]
 name = "sc-consensus-manual-seal"
-version = "0.46.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.49.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "assert_matches",
  "async-trait",
  "futures",
  "futures-timer",
- "jsonrpsee",
+ "jsonrpsee 0.24.7",
  "log",
  "parity-scale-codec",
  "sc-client-api",
@@ -8515,13 +9896,13 @@ dependencies = [
  "sp-runtime",
  "sp-timestamp",
  "substrate-prometheus-endpoint",
- "thiserror",
+ "thiserror 1.0.64",
 ]
 
 [[package]]
 name = "sc-consensus-slots"
-version = "0.44.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.47.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "async-trait",
  "futures",
@@ -8543,8 +9924,8 @@ dependencies = [
 
 [[package]]
 name = "sc-executor"
-version = "0.40.1"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.41.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "parity-scale-codec",
  "parking_lot 0.12.3",
@@ -8554,10 +9935,10 @@ dependencies = [
  "schnellru",
  "sp-api",
  "sp-core",
- "sp-externalities 0.29.0",
+ "sp-externalities 0.30.0",
  "sp-io",
  "sp-panic-handler",
- "sp-runtime-interface 28.0.0",
+ "sp-runtime-interface 29.0.0",
  "sp-trie",
  "sp-version",
  "sp-wasm-interface 21.0.1",
@@ -8566,21 +9947,21 @@ dependencies = [
 
 [[package]]
 name = "sc-executor-common"
-version = "0.35.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.36.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "polkavm",
  "sc-allocator",
  "sp-maybe-compressed-blob",
  "sp-wasm-interface 21.0.1",
- "thiserror",
+ "thiserror 1.0.64",
  "wasm-instrument",
 ]
 
 [[package]]
 name = "sc-executor-polkavm"
-version = "0.32.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.33.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "log",
  "polkavm",
@@ -8590,8 +9971,8 @@ dependencies = [
 
 [[package]]
 name = "sc-executor-wasmtime"
-version = "0.35.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.36.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "anyhow",
  "cfg-if",
@@ -8601,15 +9982,15 @@ dependencies = [
  "rustix 0.36.17",
  "sc-allocator",
  "sc-executor-common",
- "sp-runtime-interface 28.0.0",
+ "sp-runtime-interface 29.0.0",
  "sp-wasm-interface 21.0.1",
  "wasmtime",
 ]
 
 [[package]]
 name = "sc-informant"
-version = "0.44.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.47.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "console",
  "futures",
@@ -8625,8 +10006,8 @@ dependencies = [
 
 [[package]]
 name = "sc-keystore"
-version = "33.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "34.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "array-bytes",
  "parking_lot 0.12.3",
@@ -8634,16 +10015,16 @@ dependencies = [
  "sp-application-crypto",
  "sp-core",
  "sp-keystore",
- "thiserror",
+ "thiserror 1.0.64",
 ]
 
 [[package]]
 name = "sc-mixnet"
-version = "0.15.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.18.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "array-bytes",
- "arrayvec",
+ "arrayvec 0.7.6",
  "blake2 0.10.6",
  "bytes",
  "futures",
@@ -8663,16 +10044,16 @@ dependencies = [
  "sp-keystore",
  "sp-mixnet",
  "sp-runtime",
- "thiserror",
+ "thiserror 1.0.64",
 ]
 
 [[package]]
 name = "sc-network"
-version = "0.45.6"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.48.3"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "array-bytes",
- "async-channel",
+ "async-channel 1.9.0",
  "async-trait",
  "asynchronous-codec",
  "bytes",
@@ -8693,8 +10074,8 @@ dependencies = [
  "partial_sort",
  "pin-project",
  "prost 0.12.6",
- "prost-build 0.12.6",
- "rand",
+ "prost-build",
+ "rand 0.8.5",
  "sc-client-api",
  "sc-network-common",
  "sc-network-types",
@@ -8708,7 +10089,7 @@ dependencies = [
  "sp-core",
  "sp-runtime",
  "substrate-prometheus-endpoint",
- "thiserror",
+ "thiserror 1.0.64",
  "tokio",
  "tokio-stream",
  "unsigned-varint 0.7.2",
@@ -8719,15 +10100,15 @@ dependencies = [
 
 [[package]]
 name = "sc-network-common"
-version = "0.44.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.47.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "async-trait",
  "bitflags 1.3.2",
  "futures",
  "libp2p-identity",
  "parity-scale-codec",
- "prost-build 0.12.6",
+ "prost-build",
  "sc-consensus",
  "sc-network-types",
  "sp-consensus",
@@ -8737,8 +10118,8 @@ dependencies = [
 
 [[package]]
 name = "sc-network-gossip"
-version = "0.45.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.48.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "ahash 0.8.11",
  "futures",
@@ -8756,42 +10137,41 @@ dependencies = [
 
 [[package]]
 name = "sc-network-light"
-version = "0.44.1"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.47.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "array-bytes",
- "async-channel",
+ "async-channel 1.9.0",
  "futures",
  "log",
  "parity-scale-codec",
  "prost 0.12.6",
- "prost-build 0.12.6",
+ "prost-build",
  "sc-client-api",
  "sc-network",
  "sc-network-types",
  "sp-blockchain",
  "sp-core",
  "sp-runtime",
- "thiserror",
+ "thiserror 1.0.64",
 ]
 
 [[package]]
 name = "sc-network-sync"
-version = "0.44.1"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.47.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "array-bytes",
- "async-channel",
+ "async-channel 1.9.0",
  "async-trait",
  "fork-tree",
  "futures",
  "futures-timer",
- "libp2p",
  "log",
  "mockall 0.11.4",
  "parity-scale-codec",
  "prost 0.12.6",
- "prost-build 0.12.6",
+ "prost-build",
  "sc-client-api",
  "sc-consensus",
  "sc-network",
@@ -8807,15 +10187,15 @@ dependencies = [
  "sp-core",
  "sp-runtime",
  "substrate-prometheus-endpoint",
- "thiserror",
+ "thiserror 1.0.64",
  "tokio",
  "tokio-stream",
 ]
 
 [[package]]
 name = "sc-network-transactions"
-version = "0.44.1"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.47.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "array-bytes",
  "futures",
@@ -8833,39 +10213,42 @@ dependencies = [
 
 [[package]]
 name = "sc-network-types"
-version = "0.12.1"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.15.2"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
- "bs58 0.5.1",
+ "bs58",
  "ed25519-dalek",
  "libp2p-identity",
  "litep2p",
  "log",
  "multiaddr 0.18.2",
  "multihash 0.19.2",
- "rand",
- "thiserror",
+ "rand 0.8.5",
+ "thiserror 1.0.64",
  "zeroize",
 ]
 
 [[package]]
 name = "sc-offchain"
-version = "40.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "43.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "array-bytes",
  "bytes",
  "fnv",
  "futures",
  "futures-timer",
- "hyper 0.14.30",
- "hyper-rustls",
+ "http-body-util",
+ "hyper 1.5.0",
+ "hyper-rustls 0.27.6",
+ "hyper-util",
  "log",
  "num_cpus",
  "once_cell",
  "parity-scale-codec",
  "parking_lot 0.12.3",
- "rand",
+ "rand 0.8.5",
+ "rustls 0.23.27",
  "sc-client-api",
  "sc-network",
  "sc-network-common",
@@ -8874,7 +10257,7 @@ dependencies = [
  "sc-utils",
  "sp-api",
  "sp-core",
- "sp-externalities 0.29.0",
+ "sp-externalities 0.30.0",
  "sp-keystore",
  "sp-offchain",
  "sp-runtime",
@@ -8885,7 +10268,7 @@ dependencies = [
 [[package]]
 name = "sc-proposer-metrics"
 version = "0.18.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "log",
  "substrate-prometheus-endpoint",
@@ -8893,11 +10276,11 @@ dependencies = [
 
 [[package]]
 name = "sc-rpc"
-version = "40.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "43.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "futures",
- "jsonrpsee",
+ "jsonrpsee 0.24.7",
  "log",
  "parity-scale-codec",
  "parking_lot 0.12.3",
@@ -8925,10 +10308,10 @@ dependencies = [
 
 [[package]]
 name = "sc-rpc-api"
-version = "0.44.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.47.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
- "jsonrpsee",
+ "jsonrpsee 0.24.7",
  "parity-scale-codec",
  "sc-chain-spec",
  "sc-mixnet",
@@ -8940,13 +10323,13 @@ dependencies = [
  "sp-rpc",
  "sp-runtime",
  "sp-version",
- "thiserror",
+ "thiserror 1.0.64",
 ]
 
 [[package]]
 name = "sc-rpc-server"
-version = "17.1.2"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "20.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "dyn-clone",
  "forwarded-header-value",
@@ -8956,7 +10339,7 @@ dependencies = [
  "http-body-util",
  "hyper 1.5.0",
  "ip_network",
- "jsonrpsee",
+ "jsonrpsee 0.24.7",
  "log",
  "sc-rpc-api",
  "serde",
@@ -8969,23 +10352,23 @@ dependencies = [
 
 [[package]]
 name = "sc-rpc-spec-v2"
-version = "0.45.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.48.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "array-bytes",
  "futures",
  "futures-util",
  "hex",
- "jsonrpsee",
+ "itertools 0.11.0",
+ "jsonrpsee 0.24.7",
  "log",
  "parity-scale-codec",
  "parking_lot 0.12.3",
- "rand",
+ "rand 0.8.5",
  "sc-chain-spec",
  "sc-client-api",
  "sc-rpc",
  "sc-transaction-pool-api",
- "sc-utils",
  "schnellru",
  "serde",
  "sp-api",
@@ -8994,27 +10377,27 @@ dependencies = [
  "sp-rpc",
  "sp-runtime",
  "sp-version",
- "thiserror",
+ "thiserror 1.0.64",
  "tokio",
  "tokio-stream",
 ]
 
 [[package]]
 name = "sc-service"
-version = "0.46.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.49.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "async-trait",
  "directories",
  "exit-future",
  "futures",
  "futures-timer",
- "jsonrpsee",
+ "jsonrpsee 0.24.7",
  "log",
  "parity-scale-codec",
  "parking_lot 0.12.3",
  "pin-project",
- "rand",
+ "rand 0.8.5",
  "sc-chain-spec",
  "sc-client-api",
  "sc-client-db",
@@ -9044,12 +10427,12 @@ dependencies = [
  "sp-blockchain",
  "sp-consensus",
  "sp-core",
- "sp-externalities 0.29.0",
+ "sp-externalities 0.30.0",
  "sp-keystore",
  "sp-runtime",
  "sp-session",
  "sp-state-machine",
- "sp-storage 21.0.0",
+ "sp-storage 22.0.0",
  "sp-transaction-pool",
  "sp-transaction-storage-proof",
  "sp-trie",
@@ -9057,7 +10440,7 @@ dependencies = [
  "static_init",
  "substrate-prometheus-endpoint",
  "tempfile",
- "thiserror",
+ "thiserror 1.0.64",
  "tokio",
  "tracing",
  "tracing-futures",
@@ -9065,8 +10448,8 @@ dependencies = [
 
 [[package]]
 name = "sc-state-db"
-version = "0.36.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.37.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "log",
  "parity-scale-codec",
@@ -9076,29 +10459,29 @@ dependencies = [
 
 [[package]]
 name = "sc-sysinfo"
-version = "38.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "41.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
- "derive_more",
+ "derive_more 0.99.18",
  "futures",
  "libc",
  "log",
- "rand",
+ "rand 0.8.5",
  "rand_pcg",
  "regex",
  "sc-telemetry",
  "serde",
  "serde_json",
  "sp-core",
- "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7)",
+ "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
  "sp-io",
- "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7)",
+ "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
 ]
 
 [[package]]
 name = "sc-telemetry"
-version = "25.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "28.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "chrono",
  "futures",
@@ -9106,24 +10489,23 @@ dependencies = [
  "log",
  "parking_lot 0.12.3",
  "pin-project",
- "rand",
+ "rand 0.8.5",
  "sc-network",
  "sc-utils",
  "serde",
  "serde_json",
- "thiserror",
+ "thiserror 1.0.64",
  "wasm-timer",
 ]
 
 [[package]]
 name = "sc-tracing"
-version = "37.0.1"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "38.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "chrono",
  "console",
  "is-terminal",
- "lazy_static",
  "libc",
  "log",
  "parity-scale-codec",
@@ -9138,7 +10520,7 @@ dependencies = [
  "sp-rpc",
  "sp-runtime",
  "sp-tracing 17.0.1",
- "thiserror",
+ "thiserror 1.0.64",
  "tracing",
  "tracing-log",
  "tracing-subscriber 0.3.18",
@@ -9147,22 +10529,24 @@ dependencies = [
 [[package]]
 name = "sc-tracing-proc-macro"
 version = "11.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "proc-macro-crate 3.2.0",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
 name = "sc-transaction-pool"
-version = "37.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "38.1.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "async-trait",
  "futures",
  "futures-timer",
+ "indexmap 2.9.0",
+ "itertools 0.11.0",
  "linked-hash-map",
  "log",
  "parity-scale-codec",
@@ -9174,18 +10558,20 @@ dependencies = [
  "sp-api",
  "sp-blockchain",
  "sp-core",
- "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7)",
+ "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
  "sp-runtime",
  "sp-tracing 17.0.1",
  "sp-transaction-pool",
  "substrate-prometheus-endpoint",
- "thiserror",
+ "thiserror 1.0.64",
+ "tokio",
+ "tokio-stream",
 ]
 
 [[package]]
 name = "sc-transaction-pool-api"
-version = "37.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "38.1.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "async-trait",
  "futures",
@@ -9195,18 +10581,17 @@ dependencies = [
  "sp-blockchain",
  "sp-core",
  "sp-runtime",
- "thiserror",
+ "thiserror 1.0.64",
 ]
 
 [[package]]
 name = "sc-utils"
-version = "17.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "18.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
- "async-channel",
+ "async-channel 1.9.0",
  "futures",
  "futures-timer",
- "lazy_static",
  "log",
  "parking_lot 0.12.3",
  "prometheus",
@@ -9220,7 +10605,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e57b1e7f6b65ed1f04e79a85a57d755ad56d76fdf1e9bddcc9ae14f71fcdcf54"
 dependencies = [
  "parity-scale-codec",
+ "scale-info",
  "scale-type-resolver",
+ "serde",
 ]
 
 [[package]]
@@ -9229,22 +10616,64 @@ version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e98f3262c250d90e700bb802eb704e1f841e03331c2eb815e46516c4edbf5b27"
 dependencies = [
- "derive_more",
+ "derive_more 0.99.18",
+ "parity-scale-codec",
+ "primitive-types 0.12.2",
+ "scale-bits",
+ "scale-decode-derive",
+ "scale-type-resolver",
+ "smallvec",
+]
+
+[[package]]
+name = "scale-decode-derive"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9bb22f574168103cdd3133b19281639ca65ad985e24612728f727339dcaf4021"
+dependencies = [
+ "darling 0.14.4",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "scale-encode"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "528464e6ae6c8f98e2b79633bf79ef939552e795e316579dab09c61670d56602"
+dependencies = [
+ "derive_more 0.99.18",
  "parity-scale-codec",
+ "primitive-types 0.12.2",
  "scale-bits",
+ "scale-encode-derive",
  "scale-type-resolver",
  "smallvec",
 ]
 
+[[package]]
+name = "scale-encode-derive"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef2618f123c88da9cd8853b69d766068f1eddc7692146d7dfe9b89e25ce2efd"
+dependencies = [
+ "darling 0.20.10",
+ "proc-macro-crate 3.2.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.101",
+]
+
 [[package]]
 name = "scale-info"
-version = "2.11.3"
+version = "2.11.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eca070c12893629e2cc820a9761bedf6ce1dcddc9852984d1dc734b8bd9bd024"
+checksum = "346a3b32eba2640d17a9cb5927056b08f3de90f65b72fe09402c2ad07d684d0b"
 dependencies = [
  "bitvec",
  "cfg-if",
- "derive_more",
+ "derive_more 1.0.0",
  "parity-scale-codec",
  "scale-info-derive",
  "serde",
@@ -9252,14 +10681,14 @@ dependencies = [
 
 [[package]]
 name = "scale-info-derive"
-version = "2.11.3"
+version = "2.11.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2d35494501194174bda522a32605929eefc9ecf7e0a326c26db1fdd85881eb62"
+checksum = "c6630024bf739e2179b91fb424b28898baf819414262c5d376677dbff1fe7ebf"
 dependencies = [
  "proc-macro-crate 3.2.0",
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -9267,6 +10696,44 @@ name = "scale-type-resolver"
 version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f0cded6518aa0bd6c1be2b88ac81bf7044992f0f154bfbabd5ad34f43512abcb"
+dependencies = [
+ "scale-info",
+ "smallvec",
+]
+
+[[package]]
+name = "scale-typegen"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "498d1aecf2ea61325d4511787c115791639c0fd21ef4f8e11e49dd09eff2bbac"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "scale-info",
+ "syn 2.0.101",
+ "thiserror 1.0.64",
+]
+
+[[package]]
+name = "scale-value"
+version = "0.16.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8cd6ab090d823e75cfdb258aad5fe92e13f2af7d04b43a55d607d25fcc38c811"
+dependencies = [
+ "base58",
+ "blake2 0.10.6",
+ "derive_more 0.99.18",
+ "either",
+ "frame-metadata 15.1.0",
+ "parity-scale-codec",
+ "scale-bits",
+ "scale-decode",
+ "scale-encode",
+ "scale-info",
+ "scale-type-resolver",
+ "serde",
+ "yap",
+]
 
 [[package]]
 name = "schannel"
@@ -9279,9 +10746,9 @@ dependencies = [
 
 [[package]]
 name = "schnellru"
-version = "0.2.3"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c9a8ef13a93c54d20580de1e5c413e624e53121d42fc7e2c11d10ef7f8b02367"
+checksum = "356285bbf17bea63d9e52e96bd18f039672ac92b55b8cb997d6162a2a37d1649"
 dependencies = [
  "ahash 0.8.11",
  "cfg-if",
@@ -9296,11 +10763,11 @@ checksum = "8de18f6d8ba0aad7045f5feae07ec29899c1112584a38509a84ad7b04451eaa0"
 dependencies = [
  "aead",
  "arrayref",
- "arrayvec",
+ "arrayvec 0.7.6",
  "curve25519-dalek",
  "getrandom_or_panic",
  "merlin",
- "rand_core",
+ "rand_core 0.6.4",
  "serde_bytes",
  "sha2 0.10.8",
  "subtle 2.6.1",
@@ -9329,21 +10796,6 @@ dependencies = [
  "untrusted 0.9.0",
 ]
 
-[[package]]
-name = "sctp-proto"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6220f78bb44c15f326b0596113305f6101097a18755d53727a575c97e09fb24"
-dependencies = [
- "bytes",
- "crc",
- "fxhash",
- "log",
- "rand",
- "slab",
- "thiserror",
-]
-
 [[package]]
 name = "sec1"
 version = "0.7.3"
@@ -9359,13 +10811,31 @@ dependencies = [
  "zeroize",
 ]
 
+[[package]]
+name = "secp256k1"
+version = "0.27.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "25996b82292a7a57ed3508f052cfff8640d38d32018784acd714758b43da9c8f"
+dependencies = [
+ "secp256k1-sys 0.8.1",
+]
+
 [[package]]
 name = "secp256k1"
 version = "0.28.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d24b59d129cdadea20aea4fb2352fa053712e5d713eee47d700cd4b2bc002f10"
 dependencies = [
- "secp256k1-sys",
+ "secp256k1-sys 0.9.2",
+]
+
+[[package]]
+name = "secp256k1-sys"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70a129b9e9efbfb223753b9163c4ab3b13cff7fd9c7f010fbac25ab4099fa07e"
+dependencies = [
+ "cc",
 ]
 
 [[package]]
@@ -9393,7 +10863,21 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02"
 dependencies = [
  "bitflags 2.6.0",
- "core-foundation",
+ "core-foundation 0.9.4",
+ "core-foundation-sys",
+ "libc",
+ "num-bigint",
+ "security-framework-sys",
+]
+
+[[package]]
+name = "security-framework"
+version = "3.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "271720403f46ca04f7ba6f55d438f8bd878d6b8ca0a1046e8228c4145bcbb316"
+dependencies = [
+ "bitflags 2.6.0",
+ "core-foundation 0.10.0",
  "core-foundation-sys",
  "libc",
  "security-framework-sys",
@@ -9401,9 +10885,9 @@ dependencies = [
 
 [[package]]
 name = "security-framework-sys"
-version = "2.12.0"
+version = "2.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ea4a292869320c0272d7bc55a5a6aafaff59b4f63404a003887b679a2e05b4b6"
+checksum = "49db231d56a190491cb4aeda9527f1ad45345af50b0851622a7adb8c03b01c32"
 dependencies = [
  "core-foundation-sys",
  "libc",
@@ -9450,9 +10934,9 @@ checksum = "cd0b0ec5f1c1ca621c432a25813d8d60c88abe6d3e08a3eb9cf37d97a0fe3d73"
 
 [[package]]
 name = "serde"
-version = "1.0.216"
+version = "1.0.219"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b9781016e935a97e8beecf0c933758c97a5520d32930e460142b4cd80c6338e"
+checksum = "5f0e2c6ed6606019b4e29e69dbaba95b11854410e5347d525002456dbbb786b6"
 dependencies = [
  "serde_derive",
 ]
@@ -9487,20 +10971,20 @@ dependencies = [
 
 [[package]]
 name = "serde_derive"
-version = "1.0.216"
+version = "1.0.219"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46f859dbbf73865c6627ed570e78961cd3ac92407a2d117204c49232485da55e"
+checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
 name = "serde_json"
-version = "1.0.128"
+version = "1.0.140"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ff5456707a1de34e7e37f2a6fd3d3f808c318259cbd01ab6377795054b483d8"
+checksum = "20068b6e96dc6c9bd23e01df8827e6c7e1f2fddd43c21810382803c136b99373"
 dependencies = [
  "itoa",
  "memchr",
@@ -9551,10 +11035,10 @@ version = "2.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "881b6f881b17d13214e5d494c939ebab463d01264ce1811e9d4ac3a882e7695f"
 dependencies = [
- "darling",
+ "darling 0.20.10",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -9569,14 +11053,15 @@ dependencies = [
 
 [[package]]
 name = "sha-1"
-version = "0.10.1"
+version = "0.9.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f5058ada175748e33390e40e872bd0fe59a19f265d0158daa551c5a88a76009c"
+checksum = "99cd6713db3cf16b6c84e06321e049a9b9f699826e16096d23bbcc44d15d51a6"
 dependencies = [
+ "block-buffer 0.9.0",
  "cfg-if",
  "cpufeatures",
- "digest 0.10.7",
- "sha1-asm",
+ "digest 0.9.0",
+ "opaque-debug 0.3.1",
 ]
 
 [[package]]
@@ -9590,15 +11075,6 @@ dependencies = [
  "digest 0.10.7",
 ]
 
-[[package]]
-name = "sha1-asm"
-version = "0.5.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "286acebaf8b67c1130aedffad26f594eff0c1292389158135327d2e23aed582b"
-dependencies = [
- "cc",
-]
-
 [[package]]
 name = "sha2"
 version = "0.9.9"
@@ -9647,7 +11123,7 @@ name = "share-pool"
 version = "0.1.0"
 dependencies = [
  "safe-math",
- "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7)",
+ "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
  "substrate-fixed",
 ]
 
@@ -9673,7 +11149,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
 dependencies = [
  "digest 0.10.7",
- "rand_core",
+ "rand_core 0.6.4",
 ]
 
 [[package]]
@@ -9691,9 +11167,9 @@ dependencies = [
 
 [[package]]
 name = "simple-dns"
-version = "0.5.7"
+version = "0.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cae9a3fcdadafb6d97f4c0e007e4247b114ee0f119f650c3cbf3a8b3a1479694"
+checksum = "dee851d0e5e7af3721faea1843e8015e820a234f81fda3dea9247e15bac9a86a"
 dependencies = [
  "bitflags 2.6.0",
 ]
@@ -9710,26 +11186,140 @@ version = "0.3.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "38b58827f4464d87d377d175e90bf58eb00fd8716ff0a62f80356b5e61555d0d"
 
+[[package]]
+name = "siphasher"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56199f7ddabf13fe5074ce809e7d3f42b42ae711800501b5b16ea82ad029c39d"
+
 [[package]]
 name = "slab"
 version = "0.4.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67"
+checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "slice-group-by"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "826167069c09b99d56f31e9ae5c99049e932a98c9dc2dac47645b08dbbf76ba7"
+
+[[package]]
+name = "smallvec"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8917285742e9f3e1683f0a9c4e6b57960b7314d0b08d30d1ecd426713ee2eee9"
+
+[[package]]
+name = "smol"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a33bd3e260892199c3ccfc487c88b2da2265080acb316cd920da72fdfd7c599f"
 dependencies = [
- "autocfg",
+ "async-channel 2.3.1",
+ "async-executor",
+ "async-fs",
+ "async-io",
+ "async-lock",
+ "async-net",
+ "async-process",
+ "blocking",
+ "futures-lite",
 ]
 
 [[package]]
-name = "slice-group-by"
-version = "0.3.1"
+name = "smoldot"
+version = "0.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "826167069c09b99d56f31e9ae5c99049e932a98c9dc2dac47645b08dbbf76ba7"
+checksum = "e6d1eaa97d77be4d026a1e7ffad1bb3b78448763b357ea6f8188d3e6f736a9b9"
+dependencies = [
+ "arrayvec 0.7.6",
+ "async-lock",
+ "atomic-take",
+ "base64 0.21.7",
+ "bip39",
+ "blake2-rfc",
+ "bs58",
+ "chacha20",
+ "crossbeam-queue",
+ "derive_more 0.99.18",
+ "ed25519-zebra",
+ "either",
+ "event-listener 4.0.3",
+ "fnv",
+ "futures-lite",
+ "futures-util",
+ "hashbrown 0.14.5",
+ "hex",
+ "hmac 0.12.1",
+ "itertools 0.12.1",
+ "libm",
+ "libsecp256k1",
+ "merlin",
+ "no-std-net",
+ "nom",
+ "num-bigint",
+ "num-rational",
+ "num-traits",
+ "pbkdf2",
+ "pin-project",
+ "poly1305",
+ "rand 0.8.5",
+ "rand_chacha 0.3.1",
+ "ruzstd",
+ "schnorrkel",
+ "serde",
+ "serde_json",
+ "sha2 0.10.8",
+ "sha3",
+ "siphasher 1.0.1",
+ "slab",
+ "smallvec",
+ "soketto 0.7.1",
+ "twox-hash",
+ "wasmi",
+ "x25519-dalek",
+ "zeroize",
+]
 
 [[package]]
-name = "smallvec"
-version = "1.13.2"
+name = "smoldot-light"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
+checksum = "5496f2d116b7019a526b1039ec2247dd172b8670633b1a64a614c9ea12c9d8c7"
+dependencies = [
+ "async-channel 2.3.1",
+ "async-lock",
+ "base64 0.21.7",
+ "blake2-rfc",
+ "derive_more 0.99.18",
+ "either",
+ "event-listener 4.0.3",
+ "fnv",
+ "futures-channel",
+ "futures-lite",
+ "futures-util",
+ "hashbrown 0.14.5",
+ "hex",
+ "itertools 0.12.1",
+ "log",
+ "lru 0.12.5",
+ "no-std-net",
+ "parking_lot 0.12.3",
+ "pin-project",
+ "rand 0.8.5",
+ "rand_chacha 0.3.1",
+ "serde",
+ "serde_json",
+ "siphasher 1.0.1",
+ "slab",
+ "smol",
+ "smoldot",
+ "zeroize",
+]
 
 [[package]]
 name = "snap"
@@ -9747,7 +11337,7 @@ dependencies = [
  "blake2 0.10.6",
  "chacha20poly1305",
  "curve25519-dalek",
- "rand_core",
+ "rand_core 0.6.4",
  "ring 0.17.13",
  "rustc_version 0.4.1",
  "sha2 0.10.8",
@@ -9766,14 +11356,29 @@ dependencies = [
 
 [[package]]
 name = "socket2"
-version = "0.5.7"
+version = "0.5.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce305eb0b4296696835b71df73eb912e0f1ffd2556a501fcede6e0c50349191c"
+checksum = "4f5fd57c80058a56cf5c777ab8a126398ece8e442983605d280a44ce79d0edef"
 dependencies = [
  "libc",
  "windows-sys 0.52.0",
 ]
 
+[[package]]
+name = "soketto"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d1c5305e39e09653383c2c7244f2f78b3bcae37cf50c64cb4789c9f5096ec2"
+dependencies = [
+ "base64 0.13.1",
+ "bytes",
+ "futures",
+ "httparse",
+ "log",
+ "rand 0.8.5",
+ "sha-1",
+]
+
 [[package]]
 name = "soketto"
 version = "0.8.0"
@@ -9786,14 +11391,14 @@ dependencies = [
  "http 1.1.0",
  "httparse",
  "log",
- "rand",
+ "rand 0.8.5",
  "sha1",
 ]
 
 [[package]]
 name = "sp-api"
-version = "34.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "35.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "docify",
  "hash-db",
@@ -9802,20 +11407,20 @@ dependencies = [
  "scale-info",
  "sp-api-proc-macro",
  "sp-core",
- "sp-externalities 0.29.0",
+ "sp-externalities 0.30.0",
  "sp-metadata-ir",
  "sp-runtime",
- "sp-runtime-interface 28.0.0",
+ "sp-runtime-interface 29.0.0",
  "sp-state-machine",
  "sp-trie",
  "sp-version",
- "thiserror",
+ "thiserror 1.0.64",
 ]
 
 [[package]]
 name = "sp-api-proc-macro"
-version = "20.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "21.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "Inflector",
  "blake2 0.10.6",
@@ -9823,13 +11428,13 @@ dependencies = [
  "proc-macro-crate 3.2.0",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
 name = "sp-application-crypto"
-version = "38.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "39.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "parity-scale-codec",
  "scale-info",
@@ -9841,7 +11446,7 @@ dependencies = [
 [[package]]
 name = "sp-arithmetic"
 version = "26.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "docify",
  "integer-sqrt",
@@ -9861,10 +11466,22 @@ dependencies = [
  "sp-crypto-ec-utils 0.10.0",
 ]
 
+[[package]]
+name = "sp-authority-discovery"
+version = "35.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+dependencies = [
+ "parity-scale-codec",
+ "scale-info",
+ "sp-api",
+ "sp-application-crypto",
+ "sp-runtime",
+]
+
 [[package]]
 name = "sp-block-builder"
-version = "34.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "35.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "sp-api",
  "sp-inherents",
@@ -9873,8 +11490,8 @@ dependencies = [
 
 [[package]]
 name = "sp-blockchain"
-version = "37.0.1"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "38.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "futures",
  "parity-scale-codec",
@@ -9886,14 +11503,14 @@ dependencies = [
  "sp-database",
  "sp-runtime",
  "sp-state-machine",
- "thiserror",
+ "thiserror 1.0.64",
  "tracing",
 ]
 
 [[package]]
 name = "sp-consensus"
-version = "0.40.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.41.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "async-trait",
  "futures",
@@ -9902,13 +11519,13 @@ dependencies = [
  "sp-inherents",
  "sp-runtime",
  "sp-state-machine",
- "thiserror",
+ "thiserror 1.0.64",
 ]
 
 [[package]]
 name = "sp-consensus-aura"
-version = "0.40.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.41.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "async-trait",
  "parity-scale-codec",
@@ -9923,8 +11540,8 @@ dependencies = [
 
 [[package]]
 name = "sp-consensus-babe"
-version = "0.40.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.41.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "async-trait",
  "parity-scale-codec",
@@ -9941,8 +11558,8 @@ dependencies = [
 
 [[package]]
 name = "sp-consensus-grandpa"
-version = "21.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "22.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "finality-grandpa",
  "log",
@@ -9958,8 +11575,8 @@ dependencies = [
 
 [[package]]
 name = "sp-consensus-slots"
-version = "0.40.1"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.41.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "parity-scale-codec",
  "scale-info",
@@ -9969,20 +11586,20 @@ dependencies = [
 
 [[package]]
 name = "sp-core"
-version = "34.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "35.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "array-bytes",
  "bitflags 1.3.2",
  "blake2 0.10.6",
  "bounded-collections",
- "bs58 0.5.1",
+ "bs58",
  "dyn-clonable",
  "ed25519-zebra",
  "futures",
  "hash-db",
  "hash256-std-hasher",
- "impl-serde",
+ "impl-serde 0.5.0",
  "itertools 0.11.0",
  "k256",
  "libsecp256k1",
@@ -9992,22 +11609,22 @@ dependencies = [
  "parity-scale-codec",
  "parking_lot 0.12.3",
  "paste",
- "primitive-types",
- "rand",
+ "primitive-types 0.13.1",
+ "rand 0.8.5",
  "scale-info",
  "schnorrkel",
- "secp256k1",
+ "secp256k1 0.28.2",
  "secrecy",
  "serde",
- "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7)",
- "sp-debug-derive 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7)",
- "sp-externalities 0.29.0",
- "sp-runtime-interface 28.0.0",
- "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7)",
- "sp-storage 21.0.0",
+ "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-debug-derive 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-externalities 0.30.0",
+ "sp-runtime-interface 29.0.0",
+ "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-storage 22.0.0",
  "ss58-registry",
  "substrate-bip39",
- "thiserror",
+ "thiserror 1.0.64",
  "tracing",
  "w3f-bls",
  "zeroize",
@@ -10035,8 +11652,8 @@ dependencies = [
 
 [[package]]
 name = "sp-crypto-ec-utils"
-version = "0.14.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.15.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "ark-bls12-377",
  "ark-bls12-377-ext",
@@ -10050,7 +11667,7 @@ dependencies = [
  "ark-ed-on-bls12-381-bandersnatch",
  "ark-ed-on-bls12-381-bandersnatch-ext",
  "ark-scale 0.0.12",
- "sp-runtime-interface 28.0.0",
+ "sp-runtime-interface 29.0.0",
 ]
 
 [[package]]
@@ -10070,7 +11687,7 @@ dependencies = [
 [[package]]
 name = "sp-crypto-hashing"
 version = "0.1.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "blake2b_simd",
  "byteorder",
@@ -10083,17 +11700,17 @@ dependencies = [
 [[package]]
 name = "sp-crypto-hashing-proc-macro"
 version = "0.1.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "quote",
- "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7)",
- "syn 2.0.90",
+ "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "syn 2.0.101",
 ]
 
 [[package]]
 name = "sp-database"
 version = "10.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "kvdb",
  "parking_lot 0.12.3",
@@ -10102,11 +11719,11 @@ dependencies = [
 [[package]]
 name = "sp-debug-derive"
 version = "14.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -10116,7 +11733,7 @@ source = "git+https://github.com/paritytech/polkadot-sdk#8614dc0e055d06de4a3774a
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -10131,18 +11748,18 @@ dependencies = [
 
 [[package]]
 name = "sp-externalities"
-version = "0.29.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.30.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "environmental",
  "parity-scale-codec",
- "sp-storage 21.0.0",
+ "sp-storage 22.0.0",
 ]
 
 [[package]]
 name = "sp-genesis-builder"
-version = "0.15.1"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.16.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "parity-scale-codec",
  "scale-info",
@@ -10153,21 +11770,21 @@ dependencies = [
 
 [[package]]
 name = "sp-inherents"
-version = "34.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "35.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "async-trait",
  "impl-trait-for-tuples",
  "parity-scale-codec",
  "scale-info",
  "sp-runtime",
- "thiserror",
+ "thiserror 1.0.64",
 ]
 
 [[package]]
 name = "sp-io"
-version = "38.0.2"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "39.0.1"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "bytes",
  "docify",
@@ -10177,12 +11794,12 @@ dependencies = [
  "parity-scale-codec",
  "polkavm-derive",
  "rustversion",
- "secp256k1",
+ "secp256k1 0.28.2",
  "sp-core",
- "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7)",
- "sp-externalities 0.29.0",
+ "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-externalities 0.30.0",
  "sp-keystore",
- "sp-runtime-interface 28.0.0",
+ "sp-runtime-interface 29.0.0",
  "sp-state-machine",
  "sp-tracing 17.0.1",
  "sp-trie",
@@ -10192,8 +11809,8 @@ dependencies = [
 
 [[package]]
 name = "sp-keyring"
-version = "39.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "40.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "sp-core",
  "sp-runtime",
@@ -10202,38 +11819,38 @@ dependencies = [
 
 [[package]]
 name = "sp-keystore"
-version = "0.40.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.41.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "parity-scale-codec",
  "parking_lot 0.12.3",
  "sp-core",
- "sp-externalities 0.29.0",
+ "sp-externalities 0.30.0",
 ]
 
 [[package]]
 name = "sp-maybe-compressed-blob"
 version = "11.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
- "thiserror",
+ "thiserror 1.0.64",
  "zstd 0.12.4",
 ]
 
 [[package]]
 name = "sp-metadata-ir"
-version = "0.7.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.8.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
- "frame-metadata",
+ "frame-metadata 18.0.0",
  "parity-scale-codec",
  "scale-info",
 ]
 
 [[package]]
 name = "sp-mixnet"
-version = "0.12.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.13.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "parity-scale-codec",
  "scale-info",
@@ -10243,8 +11860,8 @@ dependencies = [
 
 [[package]]
 name = "sp-offchain"
-version = "34.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "35.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "sp-api",
  "sp-core",
@@ -10253,18 +11870,17 @@ dependencies = [
 
 [[package]]
 name = "sp-panic-handler"
-version = "13.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "13.0.1"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "backtrace",
- "lazy_static",
  "regex",
 ]
 
 [[package]]
 name = "sp-rpc"
-version = "32.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "33.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "rustc-hash 1.1.0",
  "serde",
@@ -10273,9 +11889,10 @@ dependencies = [
 
 [[package]]
 name = "sp-runtime"
-version = "39.0.5"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "40.1.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
+ "binary-merkle-tree",
  "docify",
  "either",
  "hash256-std-hasher",
@@ -10284,7 +11901,7 @@ dependencies = [
  "num-traits",
  "parity-scale-codec",
  "paste",
- "rand",
+ "rand 0.8.5",
  "scale-info",
  "serde",
  "simple-mermaid",
@@ -10292,9 +11909,11 @@ dependencies = [
  "sp-arithmetic",
  "sp-core",
  "sp-io",
- "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7)",
+ "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-trie",
  "sp-weights",
  "tracing",
+ "tuplex",
 ]
 
 [[package]]
@@ -10306,7 +11925,7 @@ dependencies = [
  "impl-trait-for-tuples",
  "parity-scale-codec",
  "polkavm-derive",
- "primitive-types",
+ "primitive-types 0.12.2",
  "sp-externalities 0.25.0",
  "sp-runtime-interface-proc-macro 17.0.0",
  "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk)",
@@ -10318,18 +11937,18 @@ dependencies = [
 
 [[package]]
 name = "sp-runtime-interface"
-version = "28.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "29.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "bytes",
  "impl-trait-for-tuples",
  "parity-scale-codec",
  "polkavm-derive",
- "primitive-types",
- "sp-externalities 0.29.0",
+ "primitive-types 0.13.1",
+ "sp-externalities 0.30.0",
  "sp-runtime-interface-proc-macro 18.0.0",
- "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7)",
- "sp-storage 21.0.0",
+ "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-storage 22.0.0",
  "sp-tracing 17.0.1",
  "sp-wasm-interface 21.0.1",
  "static_assertions",
@@ -10345,26 +11964,26 @@ dependencies = [
  "proc-macro-crate 3.2.0",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
 name = "sp-runtime-interface-proc-macro"
 version = "18.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "Inflector",
  "expander",
  "proc-macro-crate 3.2.0",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
 name = "sp-session"
-version = "36.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "37.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "parity-scale-codec",
  "scale-info",
@@ -10377,8 +11996,8 @@ dependencies = [
 
 [[package]]
 name = "sp-staking"
-version = "36.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "37.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "impl-trait-for-tuples",
  "parity-scale-codec",
@@ -10390,52 +12009,52 @@ dependencies = [
 
 [[package]]
 name = "sp-state-machine"
-version = "0.43.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.44.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "hash-db",
  "log",
  "parity-scale-codec",
  "parking_lot 0.12.3",
- "rand",
+ "rand 0.8.5",
  "smallvec",
  "sp-core",
- "sp-externalities 0.29.0",
+ "sp-externalities 0.30.0",
  "sp-panic-handler",
  "sp-trie",
- "thiserror",
+ "thiserror 1.0.64",
  "tracing",
  "trie-db",
 ]
 
 [[package]]
 name = "sp-statement-store"
-version = "18.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "19.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "aes-gcm",
  "curve25519-dalek",
  "ed25519-dalek",
  "hkdf",
  "parity-scale-codec",
- "rand",
+ "rand 0.8.5",
  "scale-info",
  "sha2 0.10.8",
  "sp-api",
  "sp-application-crypto",
  "sp-core",
- "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7)",
- "sp-externalities 0.29.0",
+ "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-externalities 0.30.0",
  "sp-runtime",
- "sp-runtime-interface 28.0.0",
- "thiserror",
+ "sp-runtime-interface 29.0.0",
+ "thiserror 1.0.64",
  "x25519-dalek",
 ]
 
 [[package]]
 name = "sp-std"
 version = "14.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 
 [[package]]
 name = "sp-std"
@@ -10447,7 +12066,7 @@ name = "sp-storage"
 version = "19.0.0"
 source = "git+https://github.com/paritytech/polkadot-sdk#8614dc0e055d06de4a3774ac1da0a422b33f34e2"
 dependencies = [
- "impl-serde",
+ "impl-serde 0.4.0",
  "parity-scale-codec",
  "ref-cast",
  "serde",
@@ -10456,26 +12075,26 @@ dependencies = [
 
 [[package]]
 name = "sp-storage"
-version = "21.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "22.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
- "impl-serde",
+ "impl-serde 0.5.0",
  "parity-scale-codec",
  "ref-cast",
  "serde",
- "sp-debug-derive 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7)",
+ "sp-debug-derive 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
 ]
 
 [[package]]
 name = "sp-timestamp"
-version = "34.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "35.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "async-trait",
  "parity-scale-codec",
  "sp-inherents",
  "sp-runtime",
- "thiserror",
+ "thiserror 1.0.64",
 ]
 
 [[package]]
@@ -10492,7 +12111,7 @@ dependencies = [
 [[package]]
 name = "sp-tracing"
 version = "17.0.1"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "parity-scale-codec",
  "tracing",
@@ -10502,8 +12121,8 @@ dependencies = [
 
 [[package]]
 name = "sp-transaction-pool"
-version = "34.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "35.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "sp-api",
  "sp-runtime",
@@ -10511,8 +12130,8 @@ dependencies = [
 
 [[package]]
 name = "sp-transaction-storage-proof"
-version = "34.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "35.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "async-trait",
  "parity-scale-codec",
@@ -10525,22 +12144,21 @@ dependencies = [
 
 [[package]]
 name = "sp-trie"
-version = "37.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "38.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "ahash 0.8.11",
  "hash-db",
- "lazy_static",
  "memory-db",
  "nohash-hasher",
  "parity-scale-codec",
  "parking_lot 0.12.3",
- "rand",
+ "rand 0.8.5",
  "scale-info",
  "schnellru",
  "sp-core",
- "sp-externalities 0.29.0",
- "thiserror",
+ "sp-externalities 0.30.0",
+ "thiserror 1.0.64",
  "tracing",
  "trie-db",
  "trie-root",
@@ -10548,30 +12166,31 @@ dependencies = [
 
 [[package]]
 name = "sp-version"
-version = "37.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "38.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
- "impl-serde",
+ "impl-serde 0.5.0",
  "parity-scale-codec",
  "parity-wasm",
  "scale-info",
  "serde",
  "sp-crypto-hashing-proc-macro",
  "sp-runtime",
- "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7)",
+ "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
  "sp-version-proc-macro",
- "thiserror",
+ "thiserror 1.0.64",
 ]
 
 [[package]]
 name = "sp-version-proc-macro"
-version = "14.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "15.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "parity-scale-codec",
+ "proc-macro-warning 1.0.2",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -10588,7 +12207,7 @@ dependencies = [
 [[package]]
 name = "sp-wasm-interface"
 version = "21.0.1"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "anyhow",
  "impl-trait-for-tuples",
@@ -10600,7 +12219,7 @@ dependencies = [
 [[package]]
 name = "sp-weights"
 version = "31.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "bounded-collections",
  "parity-scale-codec",
@@ -10608,7 +12227,7 @@ dependencies = [
  "serde",
  "smallvec",
  "sp-arithmetic",
- "sp-debug-derive 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7)",
+ "sp-debug-derive 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
 ]
 
 [[package]]
@@ -10687,7 +12306,7 @@ dependencies = [
  "hashbrown 0.14.5",
  "hashlink 0.9.1",
  "hex",
- "indexmap 2.6.0",
+ "indexmap 2.9.0",
  "log",
  "memchr",
  "native-tls",
@@ -10698,7 +12317,7 @@ dependencies = [
  "sha2 0.10.8",
  "smallvec",
  "sqlformat",
- "thiserror",
+ "thiserror 1.0.64",
  "tokio",
  "tokio-stream",
  "tracing",
@@ -10715,7 +12334,7 @@ dependencies = [
  "quote",
  "sqlx-core",
  "sqlx-macros-core",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -10736,7 +12355,7 @@ dependencies = [
  "sha2 0.10.8",
  "sqlx-core",
  "sqlx-sqlite",
- "syn 2.0.90",
+ "syn 2.0.101",
  "tempfile",
  "tokio",
  "url",
@@ -10788,13 +12407,15 @@ checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
 
 [[package]]
 name = "staging-xcm"
-version = "14.2.2"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "15.0.3"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "array-bytes",
  "bounded-collections",
  "derivative",
  "environmental",
+ "frame-support",
+ "hex-literal",
  "impl-trait-for-tuples",
  "log",
  "parity-scale-codec",
@@ -10818,7 +12439,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8a2a1c578e98c1c16fc3b8ec1328f7659a500737d7a0c6d625e73e830ff9c1f6"
 dependencies = [
  "bitflags 1.3.2",
- "cfg_aliases",
+ "cfg_aliases 0.1.1",
  "libc",
  "parking_lot 0.11.2",
  "parking_lot_core 0.8.6",
@@ -10832,7 +12453,7 @@ version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "70a2595fc3aa78f2d0e45dd425b22282dd863273761cc77780914b2cf3003acf"
 dependencies = [
- "cfg_aliases",
+ "cfg_aliases 0.1.1",
  "memchr",
  "proc-macro2",
  "quote",
@@ -10840,24 +12461,10 @@ dependencies = [
 ]
 
 [[package]]
-name = "str0m"
-version = "0.5.1"
+name = "strsim"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6706347e49b13373f7ddfafad47df7583ed52083d6fc8a594eb2c80497ef959d"
-dependencies = [
- "combine",
- "crc",
- "fastrand",
- "hmac 0.12.1",
- "once_cell",
- "openssl",
- "openssl-sys",
- "sctp-proto",
- "serde",
- "sha-1",
- "thiserror",
- "tracing",
-]
+checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
 
 [[package]]
 name = "strsim"
@@ -10903,13 +12510,13 @@ dependencies = [
  "proc-macro2",
  "quote",
  "rustversion",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
 name = "substrate-bip39"
 version = "0.6.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "hmac 0.12.1",
  "pbkdf2",
@@ -10921,7 +12528,7 @@ dependencies = [
 [[package]]
 name = "substrate-build-script-utils"
 version = "11.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 
 [[package]]
 name = "substrate-fixed"
@@ -10936,13 +12543,13 @@ dependencies = [
 
 [[package]]
 name = "substrate-frame-rpc-system"
-version = "39.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "42.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "docify",
  "frame-system-rpc-runtime-api",
  "futures",
- "jsonrpsee",
+ "jsonrpsee 0.24.7",
  "log",
  "parity-scale-codec",
  "sc-rpc-api",
@@ -10956,35 +12563,36 @@ dependencies = [
 
 [[package]]
 name = "substrate-prometheus-endpoint"
-version = "0.17.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "0.17.1"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "http-body-util",
  "hyper 1.5.0",
  "hyper-util",
  "log",
  "prometheus",
- "thiserror",
+ "thiserror 1.0.64",
  "tokio",
 ]
 
 [[package]]
 name = "substrate-wasm-builder"
-version = "24.0.2"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "25.0.1"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "array-bytes",
  "build-helper",
  "cargo_metadata",
  "console",
  "filetime",
- "frame-metadata",
+ "frame-metadata 18.0.0",
  "jobserver",
  "merkleized-metadata",
  "parity-scale-codec",
  "parity-wasm",
  "polkavm-linker",
  "sc-executor",
+ "shlex",
  "sp-core",
  "sp-io",
  "sp-maybe-compressed-blob",
@@ -11007,7 +12615,7 @@ dependencies = [
  "quote",
  "rayon",
  "subtensor-linting",
- "syn 2.0.90",
+ "syn 2.0.101",
  "walkdir",
 ]
 
@@ -11015,7 +12623,7 @@ dependencies = [
 name = "subtensor-custom-rpc"
 version = "0.0.2"
 dependencies = [
- "jsonrpsee",
+ "jsonrpsee 0.24.7",
  "pallet-subtensor",
  "parity-scale-codec",
  "serde",
@@ -11045,7 +12653,7 @@ dependencies = [
  "proc-macro2",
  "procedural-fork",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -11055,7 +12663,7 @@ dependencies = [
  "ahash 0.8.11",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -11078,7 +12686,7 @@ dependencies = [
  "precompile-utils",
  "sp-core",
  "sp-runtime",
- "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7)",
+ "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
  "subtensor-runtime-common",
 ]
 
@@ -11104,16 +12712,169 @@ dependencies = [
 ]
 
 [[package]]
-name = "subtle"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2d67a5a62ba6e01cb2192ff309324cb4875d0c451d55fe2319433abe7a05a8ee"
-
-[[package]]
-name = "subtle"
-version = "2.6.1"
+name = "subtle"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d67a5a62ba6e01cb2192ff309324cb4875d0c451d55fe2319433abe7a05a8ee"
+
+[[package]]
+name = "subtle"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
+
+[[package]]
+name = "subxt"
+version = "0.37.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a160cba1edbf3ec4fbbeaea3f1a185f70448116a6bccc8276bb39adb3b3053bd"
+dependencies = [
+ "async-trait",
+ "derive-where",
+ "either",
+ "frame-metadata 16.0.0",
+ "futures",
+ "hex",
+ "impl-serde 0.4.0",
+ "instant",
+ "jsonrpsee 0.22.5",
+ "parity-scale-codec",
+ "primitive-types 0.12.2",
+ "reconnecting-jsonrpsee-ws-client",
+ "scale-bits",
+ "scale-decode",
+ "scale-encode",
+ "scale-info",
+ "scale-value",
+ "serde",
+ "serde_json",
+ "sp-crypto-hashing 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "subxt-core",
+ "subxt-lightclient",
+ "subxt-macro",
+ "subxt-metadata",
+ "thiserror 1.0.64",
+ "tokio-util",
+ "tracing",
+ "url",
+]
+
+[[package]]
+name = "subxt-codegen"
+version = "0.37.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d703dca0905cc5272d7cc27a4ac5f37dcaae7671acc7fef0200057cc8c317786"
+dependencies = [
+ "frame-metadata 16.0.0",
+ "heck 0.5.0",
+ "hex",
+ "jsonrpsee 0.22.5",
+ "parity-scale-codec",
+ "proc-macro2",
+ "quote",
+ "scale-info",
+ "scale-typegen",
+ "subxt-metadata",
+ "syn 2.0.101",
+ "thiserror 1.0.64",
+ "tokio",
+]
+
+[[package]]
+name = "subxt-core"
+version = "0.37.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3af3b36405538a36b424d229dc908d1396ceb0994c90825ce928709eac1a159a"
+dependencies = [
+ "base58",
+ "blake2 0.10.6",
+ "derive-where",
+ "frame-metadata 16.0.0",
+ "hashbrown 0.14.5",
+ "hex",
+ "impl-serde 0.4.0",
+ "parity-scale-codec",
+ "primitive-types 0.12.2",
+ "scale-bits",
+ "scale-decode",
+ "scale-encode",
+ "scale-info",
+ "scale-value",
+ "serde",
+ "serde_json",
+ "sp-crypto-hashing 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "subxt-metadata",
+ "tracing",
+]
+
+[[package]]
+name = "subxt-lightclient"
+version = "0.37.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d9406fbdb9548c110803cb8afa750f8b911d51eefdf95474b11319591d225d9"
+dependencies = [
+ "futures",
+ "futures-util",
+ "serde",
+ "serde_json",
+ "smoldot-light",
+ "thiserror 1.0.64",
+ "tokio",
+ "tokio-stream",
+ "tracing",
+]
+
+[[package]]
+name = "subxt-macro"
+version = "0.37.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c195f803d70687e409aba9be6c87115b5da8952cd83c4d13f2e043239818fcd"
+dependencies = [
+ "darling 0.20.10",
+ "parity-scale-codec",
+ "proc-macro-error",
+ "quote",
+ "scale-typegen",
+ "subxt-codegen",
+ "syn 2.0.101",
+]
+
+[[package]]
+name = "subxt-metadata"
+version = "0.37.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "738be5890fdeff899bbffff4d9c0f244fe2a952fb861301b937e3aa40ebb55da"
+dependencies = [
+ "frame-metadata 16.0.0",
+ "hashbrown 0.14.5",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-crypto-hashing 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "subxt-signer"
+version = "0.37.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
+checksum = "f49888ae6ae90fe01b471193528eea5bd4ed52d8eecd2d13f4a2333b87388850"
+dependencies = [
+ "bip32",
+ "bip39",
+ "cfg-if",
+ "hex",
+ "hmac 0.12.1",
+ "keccak-hash",
+ "parity-scale-codec",
+ "pbkdf2",
+ "regex",
+ "schnorrkel",
+ "secp256k1 0.28.2",
+ "secrecy",
+ "sha2 0.10.8",
+ "sp-crypto-hashing 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "subxt-core",
+ "zeroize",
+]
 
 [[package]]
 name = "syn"
@@ -11128,9 +12889,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.90"
+version = "2.0.101"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "919d3b74a5dd0ccd15aeb8f93e7006bd9e14c295087c9896a110f490752bcf31"
+checksum = "8ce2b7fc941b3a24138a0a7cf8e858bfc6a992e7978a068a5c760deb0ed43caf"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -11157,7 +12918,7 @@ checksum = "c8af7666ab7b6390ab78131fb5b0fce11d6b7a6951602017c35fa82800708971"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -11167,7 +12928,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ba3a3adc5c275d719af8cb4272ea1c4a6d668a777f37e115f6d11ddbc1c8e0e7"
 dependencies = [
  "bitflags 1.3.2",
- "core-foundation",
+ "core-foundation 0.9.4",
  "system-configuration-sys",
 ]
 
@@ -11237,7 +12998,16 @@ version = "1.0.64"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d50af8abc119fb8bb6dbabcfa89656f46f84aa0ac7688088608076ad2b459a84"
 dependencies = [
- "thiserror-impl",
+ "thiserror-impl 1.0.64",
+]
+
+[[package]]
+name = "thiserror"
+version = "2.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "567b8a2dae586314f7be2a752ec7474332959c6460e02bde30d702a66d488708"
+dependencies = [
+ "thiserror-impl 2.0.12",
 ]
 
 [[package]]
@@ -11248,7 +13018,18 @@ checksum = "08904e7672f5eb876eaaf87e0ce17857500934f4981c4a0ab2b4aa98baac7fc3"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "2.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f7cf42b4507d8ea322120659672cf1b9dbb93f8f2d4ecfd6e51350ff5b17a1d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -11276,6 +13057,17 @@ dependencies = [
  "num_cpus",
 ]
 
+[[package]]
+name = "tikv-jemalloc-ctl"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "619bfed27d807b54f7f776b9430d4f8060e66ee138a28632ca898584d462c31c"
+dependencies = [
+ "libc",
+ "paste",
+ "tikv-jemalloc-sys",
+]
+
 [[package]]
 name = "tikv-jemalloc-sys"
 version = "0.5.4+5.3.0-patched"
@@ -11326,6 +13118,16 @@ dependencies = [
  "crunchy",
 ]
 
+[[package]]
+name = "tinystr"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d4f6d1145dcb577acf783d4e601bc1d76a13337bb54e6233add580b07344c8b"
+dependencies = [
+ "displaydoc",
+ "zerovec",
+]
+
 [[package]]
 name = "tinyvec"
 version = "1.8.0"
@@ -11358,8 +13160,8 @@ dependencies = [
  "chacha20poly1305",
  "generic-array 0.14.7",
  "parity-scale-codec",
- "rand_chacha",
- "rand_core",
+ "rand_chacha 0.3.1",
+ "rand_core 0.6.4",
  "scale-info",
  "serde",
  "serde_cbor",
@@ -11382,7 +13184,7 @@ dependencies = [
  "parking_lot 0.12.3",
  "pin-project-lite",
  "signal-hook-registry",
- "socket2 0.5.7",
+ "socket2 0.5.9",
  "tokio-macros",
  "windows-sys 0.52.0",
 ]
@@ -11395,7 +13197,7 @@ checksum = "6e06d43f1345a3bcd39f6a56dbb7dcab2ba47e68e8ac134855e7e2bdbaf8cab8"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -11408,6 +13210,27 @@ dependencies = [
  "tokio",
 ]
 
+[[package]]
+name = "tokio-rustls"
+version = "0.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "775e0c0f0adb3a2f22a00c4745d728b479985fc15ee7ca6a2608388c5569860f"
+dependencies = [
+ "rustls 0.22.4",
+ "rustls-pki-types",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-rustls"
+version = "0.26.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e727b36a1a0e8b74c376ac2211e40c2c8af09fb4013c60d910495810f008e9b"
+dependencies = [
+ "rustls 0.23.27",
+ "tokio",
+]
+
 [[package]]
 name = "tokio-stream"
 version = "0.1.16"
@@ -11422,24 +13245,25 @@ dependencies = [
 
 [[package]]
 name = "tokio-tungstenite"
-version = "0.20.1"
+version = "0.26.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "212d5dcb2a1ce06d81107c3d0ffa3121fe974b73f068c8282cb1c32328113b6c"
+checksum = "7a9daff607c6d2bf6c16fd681ccb7eecc83e4e2cdc1ca067ffaadfca5de7f084"
 dependencies = [
  "futures-util",
  "log",
- "rustls 0.21.12",
- "rustls-native-certs",
+ "rustls 0.23.27",
+ "rustls-native-certs 0.8.1",
+ "rustls-pki-types",
  "tokio",
- "tokio-rustls",
+ "tokio-rustls 0.26.2",
  "tungstenite",
 ]
 
 [[package]]
 name = "tokio-util"
-version = "0.7.12"
+version = "0.7.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61e7c3654c13bcd040d4a03abee2c75b1d14a37b423cf5a813ceae1cc903ec6a"
+checksum = "66a539a9ad6d5d281510d5bd368c973d636c02dbf8a67300bfb6b950696ad7df"
 dependencies = [
  "bytes",
  "futures-core",
@@ -11485,7 +13309,7 @@ version = "0.22.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4ae48d6208a266e853d946088ed816055e556cc6028c5e8e2b84d9fa5dd7c7f5"
 dependencies = [
- "indexmap 2.6.0",
+ "indexmap 2.9.0",
  "serde",
  "serde_spanned",
  "toml_datetime",
@@ -11555,7 +13379,7 @@ checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -11578,6 +13402,29 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "tracing-gum"
+version = "17.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+dependencies = [
+ "coarsetime",
+ "polkadot-primitives",
+ "tracing",
+ "tracing-gum-proc-macro",
+]
+
+[[package]]
+name = "tracing-gum-proc-macro"
+version = "5.0.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+dependencies = [
+ "expander",
+ "proc-macro-crate 3.2.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.101",
+]
+
 [[package]]
 name = "tracing-log"
 version = "0.2.0"
@@ -11655,10 +13502,10 @@ dependencies = [
  "idna 0.2.3",
  "ipnet",
  "lazy_static",
- "rand",
+ "rand 0.8.5",
  "smallvec",
  "socket2 0.4.10",
- "thiserror",
+ "thiserror 1.0.64",
  "tinyvec",
  "tokio",
  "tracing",
@@ -11681,9 +13528,9 @@ dependencies = [
  "idna 0.4.0",
  "ipnet",
  "once_cell",
- "rand",
+ "rand 0.8.5",
  "smallvec",
- "thiserror",
+ "thiserror 1.0.64",
  "tinyvec",
  "tokio",
  "tracing",
@@ -11702,10 +13549,10 @@ dependencies = [
  "lru-cache",
  "once_cell",
  "parking_lot 0.12.3",
- "rand",
+ "rand 0.8.5",
  "resolv-conf",
  "smallvec",
- "thiserror",
+ "thiserror 1.0.64",
  "tokio",
  "tracing",
  "trust-dns-proto 0.23.2",
@@ -11725,24 +13572,30 @@ checksum = "f4f195fd851901624eee5a58c4bb2b4f06399148fcd0ed336e6f1cb60a9881df"
 
 [[package]]
 name = "tungstenite"
-version = "0.20.1"
+version = "0.26.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e3dac10fd62eaf6617d3a904ae222845979aec67c615d1c842b4002c7666fb9"
+checksum = "4793cb5e56680ecbb1d843515b23b6de9a75eb04b66643e256a396d43be33c13"
 dependencies = [
- "byteorder",
  "bytes",
  "data-encoding",
- "http 0.2.12",
+ "http 1.1.0",
  "httparse",
  "log",
- "rand",
- "rustls 0.21.12",
+ "rand 0.9.1",
+ "rustls 0.23.27",
+ "rustls-pki-types",
  "sha1",
- "thiserror",
+ "thiserror 2.0.12",
  "url",
  "utf-8",
 ]
 
+[[package]]
+name = "tuplex"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "676ac81d5454c4dcf37955d34fa8626ede3490f744b86ca14a7b90168d2a08aa"
+
 [[package]]
 name = "twox-hash"
 version = "1.6.3"
@@ -11751,7 +13604,7 @@ checksum = "97fee6b57c6a41524a810daee9286c02d7752c4253064d0b05472833a438f675"
 dependencies = [
  "cfg-if",
  "digest 0.10.7",
- "rand",
+ "rand 0.8.5",
  "static_assertions",
 ]
 
@@ -11788,6 +13641,24 @@ dependencies = [
  "static_assertions",
 ]
 
+[[package]]
+name = "uint"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "909988d098b2f738727b161a106cfc7cab00c539c2687a8836f8e565976fb53e"
+dependencies = [
+ "byteorder",
+ "crunchy",
+ "hex",
+ "static_assertions",
+]
+
+[[package]]
+name = "unarray"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eaea85b334db583fe3274d12b4cd1880032beab409c0d774be044d4480ab9a94"
+
 [[package]]
 name = "unicode-bidi"
 version = "0.3.17"
@@ -11873,12 +13744,12 @@ checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
 
 [[package]]
 name = "url"
-version = "2.5.2"
+version = "2.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22784dbdf76fdde8af1aeda5622b546b422b6fc585325248a2bf9f5e41e94d6c"
+checksum = "32f8b686cadd1473f4bd0117a5d28d36b1ade384ea9b5069a1c40aefed7fda60"
 dependencies = [
  "form_urlencoded",
- "idna 0.5.0",
+ "idna 1.0.3",
  "percent-encoding",
 ]
 
@@ -11888,6 +13759,12 @@ version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9"
 
+[[package]]
+name = "utf8_iter"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
+
 [[package]]
 name = "utf8parse"
 version = "0.2.2"
@@ -11933,12 +13810,12 @@ dependencies = [
  "arrayref",
  "constcat",
  "digest 0.10.7",
- "rand",
- "rand_chacha",
- "rand_core",
+ "rand 0.8.5",
+ "rand_chacha 0.3.1",
+ "rand_core 0.6.4",
  "sha2 0.10.8",
  "sha3",
- "thiserror",
+ "thiserror 1.0.64",
  "zeroize",
 ]
 
@@ -11967,6 +13844,24 @@ version = "0.11.0+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
+[[package]]
+name = "wasi"
+version = "0.14.2+wasi-0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9683f9a5a998d873c0d21fcbe3c083009670149a8fab228644b8bd36b2c48cb3"
+dependencies = [
+ "wit-bindgen-rt",
+]
+
+[[package]]
+name = "wasix"
+version = "0.12.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1fbb4ef9bbca0c1170e0b00dd28abc9e3b68669821600cad1caaed606583c6d"
+dependencies = [
+ "wasi 0.11.0+wasi-snapshot-preview1",
+]
+
 [[package]]
 name = "wasm-bindgen"
 version = "0.2.93"
@@ -11989,7 +13884,7 @@ dependencies = [
  "once_cell",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
  "wasm-bindgen-shared",
 ]
 
@@ -12023,7 +13918,7 @@ checksum = "afc340c74d9005395cf9dd098506f7f44e38f2b4a21c6aaacf9a105ea5e1e836"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
  "wasm-bindgen-backend",
  "wasm-bindgen-shared",
 ]
@@ -12054,7 +13949,7 @@ dependencies = [
  "strum 0.24.1",
  "strum_macros 0.24.3",
  "tempfile",
- "thiserror",
+ "thiserror 1.0.64",
  "wasm-opt-cxx-sys",
  "wasm-opt-sys",
 ]
@@ -12098,6 +13993,37 @@ dependencies = [
  "web-sys",
 ]
 
+[[package]]
+name = "wasmi"
+version = "0.31.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77a8281d1d660cdf54c76a3efa9ddd0c270cada1383a995db3ccb43d166456c7"
+dependencies = [
+ "smallvec",
+ "spin 0.9.8",
+ "wasmi_arena",
+ "wasmi_core",
+ "wasmparser-nostd",
+]
+
+[[package]]
+name = "wasmi_arena"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "104a7f73be44570cac297b3035d76b169d6599637631cf37a1703326a0727073"
+
+[[package]]
+name = "wasmi_core"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dcf1a7db34bff95b85c261002720c00c3a6168256dcb93041d3fa2054d19856a"
+dependencies = [
+ "downcast-rs",
+ "libm",
+ "num-traits",
+ "paste",
+]
+
 [[package]]
 name = "wasmparser"
 version = "0.102.0"
@@ -12108,6 +14034,15 @@ dependencies = [
  "url",
 ]
 
+[[package]]
+name = "wasmparser-nostd"
+version = "0.100.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d5a015fe95f3504a94bb1462c717aae75253e39b9dd6c3fb1062c934535c64aa"
+dependencies = [
+ "indexmap-nostd",
+]
+
 [[package]]
 name = "wasmtime"
 version = "8.0.1"
@@ -12181,7 +14116,7 @@ dependencies = [
  "log",
  "object 0.30.4",
  "target-lexicon",
- "thiserror",
+ "thiserror 1.0.64",
  "wasmparser",
  "wasmtime-cranelift-shared",
  "wasmtime-environ",
@@ -12216,7 +14151,7 @@ dependencies = [
  "object 0.30.4",
  "serde",
  "target-lexicon",
- "thiserror",
+ "thiserror 1.0.64",
  "wasmparser",
  "wasmtime-types",
 ]
@@ -12283,7 +14218,7 @@ dependencies = [
  "memfd",
  "memoffset",
  "paste",
- "rand",
+ "rand 0.8.5",
  "rustix 0.36.17",
  "wasmtime-asm-macros",
  "wasmtime-environ",
@@ -12299,7 +14234,7 @@ checksum = "a4f6fffd2a1011887d57f07654dd112791e872e3ff4a2e626aee8059ee17f06f"
 dependencies = [
  "cranelift-entity",
  "serde",
- "thiserror",
+ "thiserror 1.0.64",
  "wasmparser",
 ]
 
@@ -12314,13 +14249,13 @@ dependencies = [
 ]
 
 [[package]]
-name = "webpki"
-version = "0.22.4"
+name = "web-time"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed63aea5ce73d0ff405984102c42de94fc55a6b75765d621c65262469b3c9b53"
+checksum = "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb"
 dependencies = [
- "ring 0.17.13",
- "untrusted 0.9.0",
+ "js-sys",
+ "wasm-bindgen",
 ]
 
 [[package]]
@@ -12330,15 +14265,21 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5f20c57d8d7db6d3b86154206ae5d8fba62dd39573114de97c2cb0578251f8e1"
 
 [[package]]
-name = "which"
-version = "4.4.2"
+name = "webpki-roots"
+version = "0.26.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87ba24419a2078cd2b0f2ede2691b6c66d8e47836da3b6db8265ebad47afbfc7"
+checksum = "521bc38abb08001b01866da9f51eb7c5d647a19260e00054a8c7fd5f9e57f7a9"
 dependencies = [
- "either",
- "home",
- "once_cell",
- "rustix 0.38.37",
+ "webpki-roots 1.0.0",
+]
+
+[[package]]
+name = "webpki-roots"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2853738d1cc4f2da3a225c18ec6c3721abb31961096e9dbf5ab35fa88b19cfdb"
+dependencies = [
+ "rustls-pki-types",
 ]
 
 [[package]]
@@ -12416,21 +14357,6 @@ dependencies = [
  "windows-targets 0.52.6",
 ]
 
-[[package]]
-name = "windows-sys"
-version = "0.42.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a3e1820f08b8513f676f7ab6c1f99ff312fb97b553d30ff4dd86f9f15728aa7"
-dependencies = [
- "windows_aarch64_gnullvm 0.42.2",
- "windows_aarch64_msvc 0.42.2",
- "windows_i686_gnu 0.42.2",
- "windows_i686_msvc 0.42.2",
- "windows_x86_64_gnu 0.42.2",
- "windows_x86_64_gnullvm 0.42.2",
- "windows_x86_64_msvc 0.42.2",
-]
-
 [[package]]
 name = "windows-sys"
 version = "0.45.0"
@@ -12664,6 +14590,21 @@ dependencies = [
  "windows-sys 0.48.0",
 ]
 
+[[package]]
+name = "wit-bindgen-rt"
+version = "0.39.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f42320e61fe2cfd34354ecb597f86f413484a798ba44a8ca1165c58d42da6c1"
+dependencies = [
+ "bitflags 2.6.0",
+]
+
+[[package]]
+name = "writeable"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea2f10b9bb0928dfb1b42b65e1f9e36f7f54dbdf08457afefb38afcdec4fa2bb"
+
 [[package]]
 name = "wyz"
 version = "0.5.1"
@@ -12680,7 +14621,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c7e468321c81fb07fa7f4c636c3972b9100f0346e5b6a9f2bd0603a52f7ed277"
 dependencies = [
  "curve25519-dalek",
- "rand_core",
+ "rand_core 0.6.4",
  "serde",
  "zeroize",
 ]
@@ -12698,36 +14639,36 @@ dependencies = [
  "nom",
  "oid-registry 0.6.1",
  "rusticata-macros",
- "thiserror",
+ "thiserror 1.0.64",
  "time",
 ]
 
 [[package]]
 name = "x509-parser"
-version = "0.16.0"
+version = "0.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fcbc162f30700d6f3f82a24bf7cc62ffe7caea42c0b2cba8bf7f3ae50cf51f69"
+checksum = "4569f339c0c402346d4a75a9e39cf8dad310e287eef1ff56d4c68e5067f53460"
 dependencies = [
- "asn1-rs 0.6.2",
+ "asn1-rs 0.7.1",
  "data-encoding",
- "der-parser 9.0.0",
+ "der-parser 10.0.0",
  "lazy_static",
  "nom",
- "oid-registry 0.7.1",
+ "oid-registry 0.8.1",
  "rusticata-macros",
- "thiserror",
+ "thiserror 2.0.12",
  "time",
 ]
 
 [[package]]
 name = "xcm-procedural"
-version = "10.1.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7#0c9644766f02c872f51e5b72adf1051189fe9126"
+version = "11.0.1"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
 dependencies = [
  "Inflector",
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -12756,10 +14697,32 @@ dependencies = [
  "nohash-hasher",
  "parking_lot 0.12.3",
  "pin-project",
- "rand",
+ "rand 0.8.5",
+ "static_assertions",
+]
+
+[[package]]
+name = "yamux"
+version = "0.13.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3da1acad1c2dc53f0dde419115a38bd8221d8c3e47ae9aeceaf453266d29307e"
+dependencies = [
+ "futures",
+ "log",
+ "nohash-hasher",
+ "parking_lot 0.12.3",
+ "pin-project",
+ "rand 0.9.1",
  "static_assertions",
+ "web-time",
 ]
 
+[[package]]
+name = "yap"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff4524214bc4629eba08d78ceb1d6507070cc0bcbbed23af74e19e6e924a24cf"
+
 [[package]]
 name = "yasna"
 version = "0.5.2"
@@ -12769,6 +14732,30 @@ dependencies = [
  "time",
 ]
 
+[[package]]
+name = "yoke"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f41bb01b8226ef4bfd589436a297c53d118f65921786300e427be8d487695cc"
+dependencies = [
+ "serde",
+ "stable_deref_trait",
+ "yoke-derive",
+ "zerofrom",
+]
+
+[[package]]
+name = "yoke-derive"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38da3c9736e16c5d3c8c597a9aaa5d1fa565d0532ae05e27c24aa62fb32c0ab6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.101",
+ "synstructure 0.13.1",
+]
+
 [[package]]
 name = "zerocopy"
 version = "0.7.35"
@@ -12787,7 +14774,28 @@ checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
+]
+
+[[package]]
+name = "zerofrom"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5"
+dependencies = [
+ "zerofrom-derive",
+]
+
+[[package]]
+name = "zerofrom-derive"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.101",
+ "synstructure 0.13.1",
 ]
 
 [[package]]
@@ -12807,7 +14815,40 @@ checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.90",
+ "syn 2.0.101",
+]
+
+[[package]]
+name = "zerotrie"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36f0bbd478583f79edad978b407914f61b2972f5af6fa089686016be8f9af595"
+dependencies = [
+ "displaydoc",
+ "yoke",
+ "zerofrom",
+]
+
+[[package]]
+name = "zerovec"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a05eb080e015ba39cc9e23bbe5e7fb04d5fb040350f99f34e338d5fdd294428"
+dependencies = [
+ "yoke",
+ "zerofrom",
+ "zerovec-derive",
+]
+
+[[package]]
+name = "zerovec-derive"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b96237efa0c878c64bd89c436f661be4e46b2f3eff1ebb976f7ef2321d2f58f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.101",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index 548bc5af63..51228c94a6 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -57,7 +57,7 @@ node-subtensor-runtime = { default-features = false, path = "runtime" }
 async-trait = "0.1"
 cargo-husky = { version = "1", default-features = false }
 clap = "4.5.4"
-codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = [
+codec = { package = "parity-scale-codec", version = "3.7.5", default-features = false, features = [
 	"derive",
 ] }
 ed25519-dalek = { version = "2.1.0", default-features = false, features = [
@@ -100,128 +100,128 @@ approx = "0.5"
 
 subtensor-macros = { path = "support/macros" }
 
-frame-benchmarking = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
-frame-benchmarking-cli = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7" }
-frame-executive = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
-frame-metadata-hash-extension = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
-frame-support = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
-frame-system = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
-frame-system-benchmarking = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
-frame-system-rpc-runtime-api = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
-frame-try-runtime = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
+frame-benchmarking = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+frame-benchmarking-cli = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
+frame-executive = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+frame-metadata-hash-extension = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+frame-support = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+frame-system = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+frame-system-benchmarking = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+frame-system-rpc-runtime-api = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+frame-try-runtime = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
 
-pallet-aura = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
-pallet-balances = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
-pallet-grandpa = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
-pallet-insecure-randomness-collective-flip = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
-pallet-membership = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
-pallet-multisig = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
-pallet-preimage = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
+pallet-aura = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+pallet-balances = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+pallet-grandpa = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+pallet-insecure-randomness-collective-flip = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+pallet-membership = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+pallet-multisig = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+pallet-preimage = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
 pallet-proxy = { path = "pallets/proxy", default-features = false }
-pallet-safe-mode = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
-pallet-scheduler = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
-pallet-sudo = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
-pallet-timestamp = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
-pallet-transaction-payment = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
-pallet-transaction-payment-rpc = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7" }
-pallet-transaction-payment-rpc-runtime-api = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
+pallet-safe-mode = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+pallet-scheduler = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+pallet-sudo = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+pallet-timestamp = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+pallet-transaction-payment = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+pallet-transaction-payment-rpc = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
+pallet-transaction-payment-rpc-runtime-api = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
 pallet-utility = { path = "pallets/utility", default-features = false }
-pallet-root-testing = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
+pallet-root-testing = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
 
-sc-basic-authorship = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7" }
-sc-cli = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7" }
-sc-client-api = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7" }
-sc-consensus = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7" }
-sc-consensus-aura = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7" }
-sc-consensus-grandpa = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7" }
-sc-consensus-grandpa-rpc = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7" }
-sc-chain-spec-derive = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7" }
-sc-chain-spec = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7" }
-sc-consensus-slots = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7" }
-sc-executor = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7" }
-sc-keystore = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7" }
-sc-network = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7" }
-sc-offchain = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7" }
-sc-rpc = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7" }
-sc-rpc-api = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7" }
-sc-service = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7" }
-sc-telemetry = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7" }
-sc-transaction-pool = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7" }
-sc-transaction-pool-api = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7" }
+sc-basic-authorship = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
+sc-cli = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
+sc-client-api = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
+sc-consensus = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
+sc-consensus-aura = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
+sc-consensus-grandpa = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
+sc-consensus-grandpa-rpc = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
+sc-chain-spec-derive = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
+sc-chain-spec = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
+sc-consensus-slots = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
+sc-executor = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
+sc-keystore = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
+sc-network = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
+sc-offchain = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
+sc-rpc = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
+sc-rpc-api = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
+sc-service = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
+sc-telemetry = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
+sc-transaction-pool = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
+sc-transaction-pool-api = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
 
-sp-api = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
-sp-block-builder = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
-sp-blockchain = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
-sp-consensus = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7" }
-sp-consensus-aura = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
-sp-consensus-grandpa = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
-sp-genesis-builder = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
-sp-core = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
-sp-inherents = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
-sp-io = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
-sp-keyring = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
-sp-offchain = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
-sp-rpc = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
-sp-runtime = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
-sp-session = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
-sp-std = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
-sp-storage = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
-sp-timestamp = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7" }
-sp-tracing = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
-sp-transaction-pool = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
-sp-version = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
-sp-weights = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
+sp-api = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+sp-block-builder = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+sp-blockchain = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+sp-consensus = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
+sp-consensus-aura = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+sp-consensus-grandpa = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+sp-genesis-builder = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+sp-core = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+sp-inherents = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+sp-io = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+sp-keyring = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+sp-offchain = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+sp-rpc = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+sp-runtime = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+sp-session = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+sp-std = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+sp-storage = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+sp-timestamp = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
+sp-tracing = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+sp-transaction-pool = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+sp-version = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+sp-weights = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
 
-substrate-build-script-utils = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7" }
+substrate-build-script-utils = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
 substrate-fixed = { git = "https://github.com/opentensor/substrate-fixed.git", tag = "v0.5.9" }
-substrate-frame-rpc-system = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7" }
-substrate-wasm-builder = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7" }
+substrate-frame-rpc-system = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
+substrate-wasm-builder = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
 
-sc-consensus-manual-seal = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
-sc-network-sync = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
-substrate-prometheus-endpoint = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
+sc-consensus-manual-seal = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+sc-network-sync = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+substrate-prometheus-endpoint = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
 
 # Frontier
-fp-evm = { git = "https://github.com/opentensor/frontier", rev = "cd6bca14a3", default-features = false }
-fp-rpc = { git = "https://github.com/opentensor/frontier", rev = "cd6bca14a3", default-features = false }
-fp-self-contained = { git = "https://github.com/opentensor/frontier", rev = "cd6bca14a3", default-features = false, features = [
+fp-evm = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
+fp-rpc = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
+fp-self-contained = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false, features = [
 	"serde",
 ] }
-fp-account = { git = "https://github.com/opentensor/frontier", rev = "cd6bca14a3", default-features = false }
-fc-storage = { git = "https://github.com/opentensor/frontier", rev = "cd6bca14a3", default-features = false }
-fc-db = { git = "https://github.com/opentensor/frontier", rev = "cd6bca14a3", default-features = false }
-fc-consensus = { git = "https://github.com/opentensor/frontier", rev = "cd6bca14a3", default-features = false }
-fp-consensus = { git = "https://github.com/opentensor/frontier", rev = "cd6bca14a3", default-features = false }
-fp-dynamic-fee = { git = "https://github.com/opentensor/frontier", rev = "cd6bca14a3", default-features = false }
-fc-api = { git = "https://github.com/opentensor/frontier", rev = "cd6bca14a3", default-features = false }
-fc-rpc = { git = "https://github.com/opentensor/frontier", rev = "cd6bca14a3", default-features = false, features = [
+fp-account = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
+fc-storage = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
+fc-db = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
+fc-consensus = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
+fp-consensus = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
+fp-dynamic-fee = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
+fc-api = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
+fc-rpc = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false, features = [
 	"rpc-binary-search-estimate",
 ] }
-fc-rpc-core = { git = "https://github.com/opentensor/frontier", rev = "cd6bca14a3", default-features = false }
-fc-aura = { git = "https://github.com/opentensor/frontier", rev = "cd6bca14a3", default-features = false }
-fc-mapping-sync = { git = "https://github.com/opentensor/frontier", rev = "cd6bca14a3", default-features = false }
-precompile-utils = { git = "https://github.com/opentensor/frontier", rev = "cd6bca14a3", default-features = false }
+fc-rpc-core = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
+fc-aura = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
+fc-mapping-sync = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
+precompile-utils = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
 
 # Frontier FRAME
-pallet-base-fee = { git = "https://github.com/opentensor/frontier", rev = "cd6bca14a3", default-features = false }
-pallet-dynamic-fee = { git = "https://github.com/opentensor/frontier", rev = "cd6bca14a3", default-features = false }
-pallet-ethereum = { git = "https://github.com/opentensor/frontier", rev = "cd6bca14a3", default-features = false }
-pallet-evm = { git = "https://github.com/opentensor/frontier", rev = "cd6bca14a3", default-features = false }
-pallet-evm-chain-id = { git = "https://github.com/opentensor/frontier", rev = "cd6bca14a3", default-features = false }
-pallet-evm-precompile-modexp = { git = "https://github.com/opentensor/frontier", rev = "cd6bca14a3", default-features = false }
-pallet-evm-precompile-sha3fips = { git = "https://github.com/opentensor/frontier", rev = "cd6bca14a3", default-features = false }
-pallet-evm-precompile-simple = { git = "https://github.com/opentensor/frontier", rev = "cd6bca14a3", default-features = false }
-pallet-hotfix-sufficients = { git = "https://github.com/opentensor/frontier", rev = "cd6bca14a3", default-features = false }
+pallet-base-fee = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
+pallet-dynamic-fee = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
+pallet-ethereum = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
+pallet-evm = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
+pallet-evm-chain-id = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
+pallet-evm-precompile-modexp = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
+pallet-evm-precompile-sha3fips = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
+pallet-evm-precompile-simple = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
+pallet-hotfix-sufficients = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
 
 #DRAND
 pallet-drand = { path = "pallets/drand", default-features = false }
-sp-crypto-ec-utils = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", features = [
+sp-crypto-ec-utils = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", features = [
 	"bls12-381",
 ] }
 getrandom = { version = "0.2.15", features = [
 	"custom",
 ], default-features = false }
-sp-keystore = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2409-7", default-features = false }
+sp-keystore = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
 w3f-bls = { version = "=0.1.3", default-features = false }
 ark-crypto-primitives = { version = "0.4.0", default-features = false, features = [
 	"r1cs",

From cf8bc0f1048a7bd425ff0bbd05151f17bd754a31 Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Fri, 30 May 2025 16:08:50 +0200
Subject: [PATCH 212/418] fix ambiguous types

---
 pallets/admin-utils/src/lib.rs | 138 ++++++++++++++++-----------------
 pallets/commitments/src/lib.rs |  11 ++-
 2 files changed, 76 insertions(+), 73 deletions(-)

diff --git a/pallets/admin-utils/src/lib.rs b/pallets/admin-utils/src/lib.rs
index 2b41539816..de18289409 100644
--- a/pallets/admin-utils/src/lib.rs
+++ b/pallets/admin-utils/src/lib.rs
@@ -140,8 +140,8 @@ pub mod pallet {
         /// The extrinsic will call the Aura pallet to change the authorities.
         #[pallet::call_index(0)]
         #[pallet::weight(Weight::from_parts(6_265_000, 0)
-        .saturating_add(T::DbWeight::get().reads(1_u64))
-        .saturating_add(T::DbWeight::get().writes(2_u64)))]
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(1_u64))
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(2_u64)))]
         pub fn swap_authorities(
             origin: OriginFor<T>,
             new_authorities: BoundedVec<<T as Config>::AuthorityId, T::MaxAuthorities>,
@@ -161,8 +161,8 @@ pub mod pallet {
         /// The extrinsic will call the Subtensor pallet to set the default take.
         #[pallet::call_index(1)]
         #[pallet::weight(Weight::from_parts(6_942_000, 0)
-        .saturating_add(T::DbWeight::get().reads(0_u64))
-        .saturating_add(T::DbWeight::get().writes(1_u64)))]
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(0_u64))
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_default_take(origin: OriginFor<T>, default_take: u16) -> DispatchResult {
             ensure_root(origin)?;
             pallet_subtensor::Pallet::<T>::set_max_delegate_take(default_take);
@@ -187,8 +187,8 @@ pub mod pallet {
         /// The extrinsic will call the Subtensor pallet to set the serving rate limit.
         #[pallet::call_index(3)]
         #[pallet::weight(Weight::from_parts(7_815_000, 0)
-        .saturating_add(T::DbWeight::get().reads(0_u64))
-        .saturating_add(T::DbWeight::get().writes(1_u64)))]
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(0_u64))
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_serving_rate_limit(
             origin: OriginFor<T>,
             netuid: u16,
@@ -209,8 +209,8 @@ pub mod pallet {
         /// The extrinsic will call the Subtensor pallet to set the minimum difficulty.
         #[pallet::call_index(4)]
         #[pallet::weight(Weight::from_parts(19_780_000, 0)
-        .saturating_add(T::DbWeight::get().reads(1_u64))
-        .saturating_add(T::DbWeight::get().writes(1_u64)))]
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(1_u64))
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_min_difficulty(
             origin: OriginFor<T>,
             netuid: u16,
@@ -236,8 +236,8 @@ pub mod pallet {
         /// The extrinsic will call the Subtensor pallet to set the maximum difficulty.
         #[pallet::call_index(5)]
         #[pallet::weight(Weight::from_parts(20_050_000, 0)
-        .saturating_add(T::DbWeight::get().reads(1_u64))
-        .saturating_add(T::DbWeight::get().writes(1_u64)))]
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(1_u64))
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_max_difficulty(
             origin: OriginFor<T>,
             netuid: u16,
@@ -263,8 +263,8 @@ pub mod pallet {
         /// The extrinsic will call the Subtensor pallet to set the weights version key.
         #[pallet::call_index(6)]
         #[pallet::weight(Weight::from_parts(19_990_000, 0)
-        .saturating_add(T::DbWeight::get().reads(1_u64))
-        .saturating_add(T::DbWeight::get().writes(1_u64)))]
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(1_u64))
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_weights_version_key(
             origin: OriginFor<T>,
             netuid: u16,
@@ -313,8 +313,8 @@ pub mod pallet {
         /// The extrinsic will call the Subtensor pallet to set the weights set rate limit.
         #[pallet::call_index(7)]
         #[pallet::weight(Weight::from_parts(20_050_000, 0)
-        .saturating_add(T::DbWeight::get().reads(1_u64))
-        .saturating_add(T::DbWeight::get().writes(1_u64)))]
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(1_u64))
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_weights_set_rate_limit(
             origin: OriginFor<T>,
             netuid: u16,
@@ -343,8 +343,8 @@ pub mod pallet {
         /// The extrinsic will call the Subtensor pallet to set the adjustment interval.
         #[pallet::call_index(8)]
         #[pallet::weight(Weight::from_parts(20_010_000, 0)
-        .saturating_add(T::DbWeight::get().reads(1_u64))
-        .saturating_add(T::DbWeight::get().writes(1_u64)))]
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(1_u64))
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_adjustment_interval(
             origin: OriginFor<T>,
             netuid: u16,
@@ -371,8 +371,8 @@ pub mod pallet {
         #[pallet::call_index(9)]
         #[pallet::weight((
             Weight::from_parts(14_000_000, 0)
-                .saturating_add(T::DbWeight::get().writes(1))
-                .saturating_add(T::DbWeight::get().reads(1)),
+                .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1))
+                .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(1)),
             DispatchClass::Operational,
             Pays::No
         ))]
@@ -400,8 +400,8 @@ pub mod pallet {
         /// The extrinsic will call the Subtensor pallet to set the adjustment beta.
         #[pallet::call_index(12)]
         #[pallet::weight(Weight::from_parts(19_240_000, 0)
-        .saturating_add(T::DbWeight::get().reads(1_u64))
-        .saturating_add(T::DbWeight::get().writes(1_u64)))]
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(1_u64))
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_max_weight_limit(
             origin: OriginFor<T>,
             netuid: u16,
@@ -427,8 +427,8 @@ pub mod pallet {
         /// The extrinsic will call the Subtensor pallet to set the immunity period.
         #[pallet::call_index(13)]
         #[pallet::weight(Weight::from_parts(19_380_000, 0)
-        .saturating_add(T::DbWeight::get().reads(1_u64))
-        .saturating_add(T::DbWeight::get().writes(1_u64)))]
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(1_u64))
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_immunity_period(
             origin: OriginFor<T>,
             netuid: u16,
@@ -454,8 +454,8 @@ pub mod pallet {
         /// The extrinsic will call the Subtensor pallet to set the minimum allowed weights.
         #[pallet::call_index(14)]
         #[pallet::weight(Weight::from_parts(19_770_000, 0)
-        .saturating_add(T::DbWeight::get().reads(1_u64))
-        .saturating_add(T::DbWeight::get().writes(1_u64)))]
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(1_u64))
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_min_allowed_weights(
             origin: OriginFor<T>,
             netuid: u16,
@@ -481,8 +481,8 @@ pub mod pallet {
         /// The extrinsic will call the Subtensor pallet to set the maximum allowed UIDs for a subnet.
         #[pallet::call_index(15)]
         #[pallet::weight(Weight::from_parts(23_820_000, 0)
-        .saturating_add(T::DbWeight::get().reads(2_u64))
-        .saturating_add(T::DbWeight::get().writes(1_u64)))]
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(2_u64))
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_max_allowed_uids(
             origin: OriginFor<T>,
             netuid: u16,
@@ -511,8 +511,8 @@ pub mod pallet {
         /// The extrinsic will call the Subtensor pallet to set the kappa.
         #[pallet::call_index(16)]
         #[pallet::weight(Weight::from_parts(19_590_000, 0)
-        .saturating_add(T::DbWeight::get().reads(1_u64))
-        .saturating_add(T::DbWeight::get().writes(1_u64)))]
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(1_u64))
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_kappa(origin: OriginFor<T>, netuid: u16, kappa: u16) -> DispatchResult {
             pallet_subtensor::Pallet::<T>::ensure_subnet_owner_or_root(origin, netuid)?;
 
@@ -530,8 +530,8 @@ pub mod pallet {
         /// The extrinsic will call the Subtensor pallet to set the rho.
         #[pallet::call_index(17)]
         #[pallet::weight(Weight::from_parts(16_420_000, 0)
-        .saturating_add(T::DbWeight::get().reads(1_u64))
-        .saturating_add(T::DbWeight::get().writes(1_u64)))]
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(1_u64))
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_rho(origin: OriginFor<T>, netuid: u16, rho: u16) -> DispatchResult {
             pallet_subtensor::Pallet::<T>::ensure_subnet_owner_or_root(origin, netuid)?;
 
@@ -549,8 +549,8 @@ pub mod pallet {
         /// The extrinsic will call the Subtensor pallet to set the activity cutoff.
         #[pallet::call_index(18)]
         #[pallet::weight(Weight::from_parts(22_600_000, 0)
-        .saturating_add(T::DbWeight::get().reads(2_u64))
-        .saturating_add(T::DbWeight::get().writes(1_u64)))]
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(2_u64))
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_activity_cutoff(
             origin: OriginFor<T>,
             netuid: u16,
@@ -583,8 +583,8 @@ pub mod pallet {
         #[pallet::call_index(19)]
         #[pallet::weight((
 			Weight::from_parts(8_696_000, 0)
-                .saturating_add(T::DbWeight::get().reads(0))
-				.saturating_add(T::DbWeight::get().writes(1)),
+                .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(0))
+				.saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1)),
 			DispatchClass::Operational,
 			Pays::No
 		))]
@@ -612,7 +612,7 @@ pub mod pallet {
         #[pallet::call_index(20)]
         #[pallet::weight((
 			Weight::from_parts(14_000_000, 0)
-				.saturating_add(T::DbWeight::get().writes(1)),
+				.saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1)),
 			DispatchClass::Operational,
 			Pays::No
 		))]
@@ -639,8 +639,8 @@ pub mod pallet {
         /// The extrinsic will call the Subtensor pallet to set the target registrations per interval.
         #[pallet::call_index(21)]
         #[pallet::weight(Weight::from_parts(19_830_000, 0)
-        .saturating_add(T::DbWeight::get().reads(1_u64))
-        .saturating_add(T::DbWeight::get().writes(1_u64)))]
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(1_u64))
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_target_registrations_per_interval(
             origin: OriginFor<T>,
             netuid: u16,
@@ -669,8 +669,8 @@ pub mod pallet {
         /// The extrinsic will call the Subtensor pallet to set the minimum burn.
         #[pallet::call_index(22)]
         #[pallet::weight(Weight::from_parts(19_840_000, 0)
-        .saturating_add(T::DbWeight::get().reads(1_u64))
-        .saturating_add(T::DbWeight::get().writes(1_u64)))]
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(1_u64))
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_min_burn(
             origin: OriginFor<T>,
             netuid: u16,
@@ -696,8 +696,8 @@ pub mod pallet {
         /// The extrinsic will call the Subtensor pallet to set the maximum burn.
         #[pallet::call_index(23)]
         #[pallet::weight(Weight::from_parts(19_740_000, 0)
-        .saturating_add(T::DbWeight::get().reads(1_u64))
-        .saturating_add(T::DbWeight::get().writes(1_u64)))]
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(1_u64))
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_max_burn(
             origin: OriginFor<T>,
             netuid: u16,
@@ -723,8 +723,8 @@ pub mod pallet {
         /// The extrinsic will call the Subtensor pallet to set the difficulty.
         #[pallet::call_index(24)]
         #[pallet::weight(Weight::from_parts(20_280_000, 0)
-        .saturating_add(T::DbWeight::get().reads(1_u64))
-        .saturating_add(T::DbWeight::get().writes(1_u64)))]
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(1_u64))
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_difficulty(
             origin: OriginFor<T>,
             netuid: u16,
@@ -749,8 +749,8 @@ pub mod pallet {
         /// The extrinsic will call the Subtensor pallet to set the maximum allowed validators.
         #[pallet::call_index(25)]
         #[pallet::weight(Weight::from_parts(25_210_000, 0)
-        .saturating_add(T::DbWeight::get().reads(2_u64))
-        .saturating_add(T::DbWeight::get().writes(1_u64)))]
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(2_u64))
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_max_allowed_validators(
             origin: OriginFor<T>,
             netuid: u16,
@@ -784,8 +784,8 @@ pub mod pallet {
         /// The extrinsic will call the Subtensor pallet to set the bonds moving average.
         #[pallet::call_index(26)]
         #[pallet::weight(Weight::from_parts(20_270_000, 0)
-        .saturating_add(T::DbWeight::get().reads(1_u64))
-        .saturating_add(T::DbWeight::get().writes(1_u64)))]
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(1_u64))
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_bonds_moving_average(
             origin: OriginFor<T>,
             netuid: u16,
@@ -818,8 +818,8 @@ pub mod pallet {
         /// The extrinsic will call the Subtensor pallet to set the bonds penalty.
         #[pallet::call_index(60)]
         #[pallet::weight(Weight::from_parts(20_030_000, 0)
-        .saturating_add(T::DbWeight::get().reads(1_u64))
-        .saturating_add(T::DbWeight::get().writes(1_u64)))]
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(1_u64))
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_bonds_penalty(
             origin: OriginFor<T>,
             netuid: u16,
@@ -845,8 +845,8 @@ pub mod pallet {
         /// The extrinsic will call the Subtensor pallet to set the maximum registrations per block.
         #[pallet::call_index(27)]
         #[pallet::weight(Weight::from_parts(19_680_000, 0)
-        .saturating_add(T::DbWeight::get().reads(1_u64))
-        .saturating_add(T::DbWeight::get().writes(1_u64)))]
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(1_u64))
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_max_registrations_per_block(
             origin: OriginFor<T>,
             netuid: u16,
@@ -876,7 +876,7 @@ pub mod pallet {
         #[pallet::call_index(28)]
         #[pallet::weight((
 			Weight::from_parts(14_000_000, 0)
-				.saturating_add(T::DbWeight::get().writes(1)),
+				.saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1)),
 			DispatchClass::Operational,
 			Pays::No
 		))]
@@ -899,7 +899,7 @@ pub mod pallet {
         #[pallet::call_index(29)]
         #[pallet::weight((
 			Weight::from_parts(14_000_000, 0)
-				.saturating_add(T::DbWeight::get().writes(1)),
+				.saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1)),
 			DispatchClass::Operational,
 			Pays::No
 		))]
@@ -918,8 +918,8 @@ pub mod pallet {
         /// The extrinsic will call the Subtensor pallet to set the tempo.
         #[pallet::call_index(30)]
         #[pallet::weight(Weight::from_parts(19_900_000, 0)
-        .saturating_add(T::DbWeight::get().reads(1_u64))
-        .saturating_add(T::DbWeight::get().writes(1_u64)))]
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(1_u64))
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_tempo(origin: OriginFor<T>, netuid: u16, tempo: u16) -> DispatchResult {
             ensure_root(origin)?;
             ensure!(
@@ -953,7 +953,7 @@ pub mod pallet {
         #[pallet::call_index(35)]
         #[pallet::weight((
 			Weight::from_parts(14_000_000, 0)
-				.saturating_add(T::DbWeight::get().writes(1)),
+				.saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1)),
 			DispatchClass::Operational,
 			Pays::No
 		))]
@@ -976,7 +976,7 @@ pub mod pallet {
         #[pallet::call_index(36)]
         #[pallet::weight((
 			Weight::from_parts(14_000_000, 0)
-				.saturating_add(T::DbWeight::get().writes(1)),
+				.saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1)),
 			DispatchClass::Operational,
 			Pays::No
 		))]
@@ -999,7 +999,7 @@ pub mod pallet {
         #[pallet::call_index(37)]
         #[pallet::weight((
 			Weight::from_parts(14_000_000, 0)
-				.saturating_add(T::DbWeight::get().writes(1)),
+				.saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1)),
 			DispatchClass::Operational,
 			Pays::No
 		))]
@@ -1014,7 +1014,7 @@ pub mod pallet {
         #[pallet::call_index(38)]
         #[pallet::weight((
 			Weight::from_parts(14_000_000, 0)
-				.saturating_add(T::DbWeight::get().writes(1)),
+				.saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1)),
 			DispatchClass::Operational,
 			Pays::No
 		))]
@@ -1138,8 +1138,8 @@ pub mod pallet {
         /// The extrinsic will call the Subtensor pallet to set the value.
         #[pallet::call_index(49)]
         #[pallet::weight(Weight::from_parts(19_480_000, 0)
-        .saturating_add(T::DbWeight::get().reads(1_u64))
-        .saturating_add(T::DbWeight::get().writes(1_u64)))]
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(1_u64))
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_commit_reveal_weights_enabled(
             origin: OriginFor<T>,
             netuid: u16,
@@ -1339,8 +1339,8 @@ pub mod pallet {
         /// Weight is handled by the `#[pallet::weight]` attribute.
         #[pallet::call_index(57)]
         #[pallet::weight(Weight::from_parts(20_490_000, 0)
-        .saturating_add(T::DbWeight::get().reads(1_u64))
-        .saturating_add(T::DbWeight::get().writes(1_u64)))]
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(1_u64))
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_commit_reveal_weights_interval(
             origin: OriginFor<T>,
             netuid: u16,
@@ -1375,8 +1375,8 @@ pub mod pallet {
         /// Weight is handled by the `#[pallet::weight]` attribute.
         #[pallet::call_index(58)]
         #[pallet::weight(Weight::from_parts(27_199_000, 0)
-        .saturating_add(T::DbWeight::get().reads(1_u64))
-        .saturating_add(T::DbWeight::get().writes(1_u64)))]
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(1_u64))
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_evm_chain_id(origin: OriginFor<T>, chain_id: u64) -> DispatchResult {
             // Ensure the call is made by the root account
             ensure_root(origin)?;
@@ -1402,8 +1402,8 @@ pub mod pallet {
         /// is already pending.
         #[pallet::call_index(59)]
         #[pallet::weight(Weight::from_parts(11_550_000, 0)
-        .saturating_add(T::DbWeight::get().reads(1_u64))
-        .saturating_add(T::DbWeight::get().writes(1_u64)))]
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(1_u64))
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1_u64)))]
         pub fn schedule_grandpa_change(
             origin: OriginFor<T>,
             // grandpa ID is always the same type, so we don't need to parametrize it via `Config`
@@ -1503,7 +1503,7 @@ pub mod pallet {
         pub fn sudo_set_subnet_owner_hotkey(
             origin: OriginFor<T>,
             netuid: u16,
-            hotkey: T::AccountId,
+            hotkey: <T as frame_system::Config>::AccountId,
         ) -> DispatchResult {
             pallet_subtensor::Pallet::<T>::ensure_subnet_owner(origin.clone(), netuid)?;
             pallet_subtensor::Pallet::<T>::set_subnet_owner_hotkey(netuid, &hotkey);
@@ -1637,7 +1637,7 @@ pub mod pallet {
         pub fn sudo_set_sn_owner_hotkey(
             origin: OriginFor<T>,
             netuid: u16,
-            hotkey: T::AccountId,
+            hotkey: <T as frame_system::Config>::AccountId,
         ) -> DispatchResult {
             pallet_subtensor::Pallet::<T>::do_set_sn_owner_hotkey(origin, netuid, &hotkey)
         }
diff --git a/pallets/commitments/src/lib.rs b/pallets/commitments/src/lib.rs
index 5b1ff7f3a8..8331e76991 100644
--- a/pallets/commitments/src/lib.rs
+++ b/pallets/commitments/src/lib.rs
@@ -411,7 +411,8 @@ pub struct CommitmentsSignedExtension<T: Config + Send + Sync + TypeInfo>(pub Ph
 
 impl<T: Config + Send + Sync + TypeInfo> Default for CommitmentsSignedExtension<T>
 where
-    T::RuntimeCall: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,
+    <T as frame_system::Config>::RuntimeCall:
+        Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,
     <T as frame_system::Config>::RuntimeCall: IsSubType<Call<T>>,
 {
     fn default() -> Self {
@@ -421,7 +422,8 @@ where
 
 impl<T: Config + Send + Sync + TypeInfo> CommitmentsSignedExtension<T>
 where
-    T::RuntimeCall: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,
+    <T as frame_system::Config>::RuntimeCall:
+        Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,
     <T as frame_system::Config>::RuntimeCall: IsSubType<Call<T>>,
 {
     pub fn new() -> Self {
@@ -443,13 +445,14 @@ impl<T: Config + Send + Sync + TypeInfo> sp_std::fmt::Debug for CommitmentsSigne
 
 impl<T: Config + Send + Sync + TypeInfo> SignedExtension for CommitmentsSignedExtension<T>
 where
-    T::RuntimeCall: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,
+    <T as frame_system::Config>::RuntimeCall:
+        Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,
     <T as frame_system::Config>::RuntimeCall: IsSubType<Call<T>>,
 {
     const IDENTIFIER: &'static str = "CommitmentsSignedExtension";
 
     type AccountId = T::AccountId;
-    type Call = T::RuntimeCall;
+    type Call = <T as frame_system::Config>::RuntimeCall;
     type AdditionalSigned = ();
     type Pre = (CallType, u64, Self::AccountId);
 

From 631d0981cc03cb862927248fc8be689d62e1fe02 Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Fri, 30 May 2025 16:09:25 +0200
Subject: [PATCH 213/418] fix dispatch_info.weight to .call_weight

---
 pallets/collective/src/lib.rs |  6 ++---
 pallets/crowdloan/src/lib.rs  |  2 +-
 pallets/proxy/src/lib.rs      |  4 ++--
 pallets/utility/src/lib.rs    |  6 ++---
 pallets/utility/src/tests.rs  | 42 +++++++++++++++++------------------
 precompiles/src/extensions.rs | 12 +++++-----
 6 files changed, 36 insertions(+), 36 deletions(-)

diff --git a/pallets/collective/src/lib.rs b/pallets/collective/src/lib.rs
index 03d84b063e..baea090307 100644
--- a/pallets/collective/src/lib.rs
+++ b/pallets/collective/src/lib.rs
@@ -475,7 +475,7 @@ pub mod pallet {
 			T::WeightInfo::execute(
 				*length_bound, // B
 				T::MaxMembers::get(), // M
-			).saturating_add(proposal.get_dispatch_info().weight), // P
+			).saturating_add(proposal.get_dispatch_info().call_weight), // P
 			DispatchClass::Operational
 		))]
         pub fn execute(
@@ -934,7 +934,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
             Error::<T, I>::ProposalLengthBoundLessThanProposalLength
         );
         let proposal = ProposalOf::<T, I>::get(hash).ok_or(Error::<T, I>::ProposalNotExists)?;
-        let proposal_weight = proposal.get_dispatch_info().weight;
+        let proposal_weight = proposal.get_dispatch_info().call_weight;
         ensure!(
             proposal_weight.all_lte(weight_bound),
             Error::<T, I>::ProposalWeightLessThanDispatchCallWeight
@@ -964,7 +964,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
     ) -> (Weight, u32) {
         Self::deposit_event(Event::Approved { proposal_hash });
 
-        let dispatch_weight = proposal.get_dispatch_info().weight;
+        let dispatch_weight = proposal.get_dispatch_info().call_weight;
         let origin = RawOrigin::Members(yes_votes, seats).into();
         let result = proposal.dispatch(origin);
         Self::deposit_event(Event::Executed {
diff --git a/pallets/crowdloan/src/lib.rs b/pallets/crowdloan/src/lib.rs
index 1d4ed4e263..f068a9e2b0 100644
--- a/pallets/crowdloan/src/lib.rs
+++ b/pallets/crowdloan/src/lib.rs
@@ -309,7 +309,7 @@ pub mod pallet {
         #[pallet::weight({
 			let di = call.as_ref().map(|c| c.get_dispatch_info());
 			let inner_call_weight = match di {
-				Some(di) => di.weight,
+				Some(di) => di.call_weight,
 				None => Weight::zero(),
 			};
 			let base_weight = T::WeightInfo::create();
diff --git a/pallets/proxy/src/lib.rs b/pallets/proxy/src/lib.rs
index 3f45951190..3ae6b6f8cb 100644
--- a/pallets/proxy/src/lib.rs
+++ b/pallets/proxy/src/lib.rs
@@ -197,7 +197,7 @@ pub mod pallet {
         #[pallet::weight({
 			let di = call.get_dispatch_info();
 			let inner_call_weight = match di.pays_fee {
-				Pays::Yes => di.weight,
+				Pays::Yes => di.call_weight,
 				Pays::No => Weight::zero(),
 			};
 			let base_weight = T::WeightInfo::proxy(T::MaxProxies::get())
@@ -503,7 +503,7 @@ pub mod pallet {
 			(T::WeightInfo::proxy_announced(T::MaxPending::get(), T::MaxProxies::get())
 				 // AccountData for inner call origin accountdata.
 				.saturating_add(T::DbWeight::get().reads_writes(1, 1))
-				.saturating_add(di.weight),
+				.saturating_add(di.call_weight),
 			di.class)
 		})]
         pub fn proxy_announced(
diff --git a/pallets/utility/src/lib.rs b/pallets/utility/src/lib.rs
index 2677f744b6..35f11cbc53 100644
--- a/pallets/utility/src/lib.rs
+++ b/pallets/utility/src/lib.rs
@@ -260,7 +260,7 @@ pub mod pallet {
 				T::WeightInfo::as_derivative()
 					// AccountData for inner call origin accountdata.
 					.saturating_add(T::DbWeight::get().reads_writes(1, 1))
-					.saturating_add(dispatch_info.weight),
+					.saturating_add(dispatch_info.call_weight),
 				dispatch_info.class,
 			)
 		})]
@@ -368,7 +368,7 @@ pub mod pallet {
 			let dispatch_info = call.get_dispatch_info();
 			(
 				T::WeightInfo::dispatch_as()
-					.saturating_add(dispatch_info.weight),
+					.saturating_add(dispatch_info.call_weight),
 				dispatch_info.class,
 			)
 		})]
@@ -484,7 +484,7 @@ pub mod pallet {
                 |(total_weight, dispatch_class), di| {
                     (
                         if di.pays_fee == Pays::Yes {
-                            total_weight.saturating_add(di.weight)
+                            total_weight.saturating_add(di.call_weight)
                         } else {
                             total_weight
                         },
diff --git a/pallets/utility/src/tests.rs b/pallets/utility/src/tests.rs
index 34ed8d323e..d02e2e0faa 100644
--- a/pallets/utility/src/tests.rs
+++ b/pallets/utility/src/tests.rs
@@ -327,7 +327,7 @@ fn as_derivative_handles_weight_refund() {
         let info = call.get_dispatch_info();
         let result = call.dispatch(RuntimeOrigin::signed(1));
         assert_ok!(result);
-        assert_eq!(extract_actual_weight(&result, &info), info.weight);
+        assert_eq!(extract_actual_weight(&result, &info), info.call_weight);
 
         // Refund weight when ok
         let inner_call = call_foobar(false, start_weight, Some(end_weight));
@@ -339,7 +339,7 @@ fn as_derivative_handles_weight_refund() {
         let result = call.dispatch(RuntimeOrigin::signed(1));
         assert_ok!(result);
         // Diff is refunded
-        assert_eq!(extract_actual_weight(&result, &info), info.weight - diff);
+        assert_eq!(extract_actual_weight(&result, &info), info.call_weight - diff);
 
         // Full weight when err
         let inner_call = call_foobar(true, start_weight, None);
@@ -354,7 +354,7 @@ fn as_derivative_handles_weight_refund() {
             DispatchErrorWithPostInfo {
                 post_info: PostDispatchInfo {
                     // No weight is refunded
-                    actual_weight: Some(info.weight),
+                    actual_weight: Some(info.call_weight),
                     pays_fee: Pays::Yes,
                 },
                 error: DispatchError::Other("The cake is a lie."),
@@ -374,7 +374,7 @@ fn as_derivative_handles_weight_refund() {
             DispatchErrorWithPostInfo {
                 post_info: PostDispatchInfo {
                     // Diff is refunded
-                    actual_weight: Some(info.weight - diff),
+                    actual_weight: Some(info.call_weight - diff),
                     pays_fee: Pays::Yes,
                 },
                 error: DispatchError::Other("The cake is a lie."),
@@ -489,14 +489,14 @@ fn batch_weight_calculation_doesnt_overflow() {
         let big_call = RuntimeCall::RootTesting(RootTestingCall::fill_block {
             ratio: Perbill::from_percent(50),
         });
-        assert_eq!(big_call.get_dispatch_info().weight, Weight::MAX / 2);
+        assert_eq!(big_call.get_dispatch_info().call_weight, Weight::MAX / 2);
 
         // 3 * 50% saturates to 100%
         let batch_call = RuntimeCall::Utility(crate::Call::batch {
             calls: vec![big_call.clone(), big_call.clone(), big_call.clone()],
         });
 
-        assert_eq!(batch_call.get_dispatch_info().weight, Weight::MAX);
+        assert_eq!(batch_call.get_dispatch_info().call_weight, Weight::MAX);
     });
 }
 
@@ -515,7 +515,7 @@ fn batch_handles_weight_refund() {
         let info = call.get_dispatch_info();
         let result = call.dispatch(RuntimeOrigin::signed(1));
         assert_ok!(result);
-        assert_eq!(extract_actual_weight(&result, &info), info.weight);
+        assert_eq!(extract_actual_weight(&result, &info), info.call_weight);
 
         // Refund weight when ok
         let inner_call = call_foobar(false, start_weight, Some(end_weight));
@@ -527,7 +527,7 @@ fn batch_handles_weight_refund() {
         // Diff is refunded
         assert_eq!(
             extract_actual_weight(&result, &info),
-            info.weight - diff * batch_len
+            info.call_weight - diff * batch_len
         );
 
         // Full weight when err
@@ -546,7 +546,7 @@ fn batch_handles_weight_refund() {
             .into(),
         );
         // No weight is refunded
-        assert_eq!(extract_actual_weight(&result, &info), info.weight);
+        assert_eq!(extract_actual_weight(&result, &info), info.call_weight);
 
         // Refund weight when err
         let good_call = call_foobar(false, start_weight, Some(end_weight));
@@ -566,7 +566,7 @@ fn batch_handles_weight_refund() {
         );
         assert_eq!(
             extract_actual_weight(&result, &info),
-            info.weight - diff * batch_len
+            info.call_weight - diff * batch_len
         );
 
         // Partial batch completion
@@ -626,7 +626,7 @@ fn batch_all_revert() {
             DispatchErrorWithPostInfo {
                 post_info: PostDispatchInfo {
                     actual_weight: Some(
-                        <Test as Config>::WeightInfo::batch_all(2) + info.weight * 2
+                        <Test as Config>::WeightInfo::batch_all(2) + info.call_weight * 2
                     ),
                     pays_fee: Pays::Yes
                 },
@@ -653,7 +653,7 @@ fn batch_all_handles_weight_refund() {
         let info = call.get_dispatch_info();
         let result = call.dispatch(RuntimeOrigin::signed(1));
         assert_ok!(result);
-        assert_eq!(extract_actual_weight(&result, &info), info.weight);
+        assert_eq!(extract_actual_weight(&result, &info), info.call_weight);
 
         // Refund weight when ok
         let inner_call = call_foobar(false, start_weight, Some(end_weight));
@@ -665,7 +665,7 @@ fn batch_all_handles_weight_refund() {
         // Diff is refunded
         assert_eq!(
             extract_actual_weight(&result, &info),
-            info.weight - diff * batch_len
+            info.call_weight - diff * batch_len
         );
 
         // Full weight when err
@@ -677,7 +677,7 @@ fn batch_all_handles_weight_refund() {
         let result = call.dispatch(RuntimeOrigin::signed(1));
         assert_err_ignore_postinfo!(result, "The cake is a lie.");
         // No weight is refunded
-        assert_eq!(extract_actual_weight(&result, &info), info.weight);
+        assert_eq!(extract_actual_weight(&result, &info), info.call_weight);
 
         // Refund weight when err
         let good_call = call_foobar(false, start_weight, Some(end_weight));
@@ -690,7 +690,7 @@ fn batch_all_handles_weight_refund() {
         assert_err_ignore_postinfo!(result, "The cake is a lie.");
         assert_eq!(
             extract_actual_weight(&result, &info),
-            info.weight - diff * batch_len
+            info.call_weight - diff * batch_len
         );
 
         // Partial batch completion
@@ -729,7 +729,7 @@ fn batch_all_does_not_nest() {
             Utility::batch_all(RuntimeOrigin::signed(1), vec![batch_all.clone()]),
             DispatchErrorWithPostInfo {
                 post_info: PostDispatchInfo {
-                    actual_weight: Some(<Test as Config>::WeightInfo::batch_all(1) + info.weight),
+                    actual_weight: Some(<Test as Config>::WeightInfo::batch_all(1) + info.call_weight),
                     pays_fee: Pays::Yes
                 },
                 error: frame_system::Error::<Test>::CallFiltered.into(),
@@ -868,7 +868,7 @@ fn batch_all_doesnt_work_with_inherents() {
             batch_all.dispatch(RuntimeOrigin::signed(1)),
             DispatchErrorWithPostInfo {
                 post_info: PostDispatchInfo {
-                    actual_weight: Some(info.weight),
+                    actual_weight: Some(info.call_weight),
                     pays_fee: Pays::Yes
                 },
                 error: frame_system::Error::<Test>::CallFiltered.into(),
@@ -886,7 +886,7 @@ fn batch_works_with_council_origin() {
             )],
         });
         let proposal_len: u32 = proposal.using_encoded(|p| p.len() as u32);
-        let proposal_weight = proposal.get_dispatch_info().weight;
+        let proposal_weight = proposal.get_dispatch_info().call_weight;
         let hash = BlakeTwo256::hash_of(&proposal);
 
         assert_ok!(Council::propose(
@@ -926,7 +926,7 @@ fn force_batch_works_with_council_origin() {
             )],
         });
         let proposal_len: u32 = proposal.using_encoded(|p| p.len() as u32);
-        let proposal_weight = proposal.get_dispatch_info().weight;
+        let proposal_weight = proposal.get_dispatch_info().call_weight;
         let hash = BlakeTwo256::hash_of(&proposal);
 
         assert_ok!(Council::propose(
@@ -977,7 +977,7 @@ fn with_weight_works() {
         ));
         // Weight before is max.
         assert_eq!(
-            upgrade_code_call.get_dispatch_info().weight,
+            upgrade_code_call.get_dispatch_info().call_weight,
             <Test as frame_system::Config>::SystemWeightInfo::set_code()
         );
         assert_eq!(
@@ -991,7 +991,7 @@ fn with_weight_works() {
         };
         // Weight after is set by Root.
         assert_eq!(
-            with_weight_call.get_dispatch_info().weight,
+            with_weight_call.get_dispatch_info().call_weight,
             Weight::from_parts(123, 456)
         );
         assert_eq!(
diff --git a/precompiles/src/extensions.rs b/precompiles/src/extensions.rs
index 1c90922c57..ffa8da5778 100644
--- a/precompiles/src/extensions.rs
+++ b/precompiles/src/extensions.rs
@@ -56,7 +56,7 @@ pub(crate) trait PrecompileHandleExt: PrecompileHandle {
         if let Some(gas) = target_gas {
             let valid_weight =
                 <R as pallet_evm::Config>::GasWeightMapping::gas_to_weight(gas, false).ref_time();
-            if info.weight.ref_time() > valid_weight {
+            if info.call_weight.ref_time() > valid_weight {
                 return Err(PrecompileFailure::Error {
                     exit_status: ExitError::OutOfGas,
                 });
@@ -64,27 +64,27 @@ pub(crate) trait PrecompileHandleExt: PrecompileHandle {
         }
 
         self.record_external_cost(
-            Some(info.weight.ref_time()),
-            Some(info.weight.proof_size()),
+            Some(info.call_weight.ref_time()),
+            Some(info.call_weight.proof_size()),
             None,
         )?;
 
         match call.dispatch(R::RuntimeOrigin::from(origin)) {
             Ok(post_info) => {
                 if post_info.pays_fee(&info) == Pays::Yes {
-                    let actual_weight = post_info.actual_weight.unwrap_or(info.weight);
+                    let actual_weight = post_info.actual_weight.unwrap_or(info.call_weight);
                     let cost =
                         <R as pallet_evm::Config>::GasWeightMapping::weight_to_gas(actual_weight);
                     self.record_cost(cost)?;
 
                     self.refund_external_cost(
                         Some(
-                            info.weight
+                            info.call_weight
                                 .ref_time()
                                 .saturating_sub(actual_weight.ref_time()),
                         ),
                         Some(
-                            info.weight
+                            info.call_weight
                                 .proof_size()
                                 .saturating_sub(actual_weight.proof_size()),
                         ),

From aedad2e8e8b863ba6fde515824bb599fbcebcc7e Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Fri, 30 May 2025 16:10:01 +0200
Subject: [PATCH 214/418] refactor imports and fix hash conversion in subnet
 registration

---
 pallets/subtensor/src/migrations/migrate_rao.rs | 3 +--
 pallets/subtensor/src/subnets/registration.rs   | 2 +-
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/pallets/subtensor/src/migrations/migrate_rao.rs b/pallets/subtensor/src/migrations/migrate_rao.rs
index 975ab55c11..be27ba8e2e 100644
--- a/pallets/subtensor/src/migrations/migrate_rao.rs
+++ b/pallets/subtensor/src/migrations/migrate_rao.rs
@@ -1,8 +1,7 @@
-use alloc::string::String;
+use alloc::{format, string::String};
 
 use frame_support::IterableStorageMap;
 use frame_support::{traits::Get, weights::Weight};
-use sp_runtime::format;
 
 use super::*;
 
diff --git a/pallets/subtensor/src/subnets/registration.rs b/pallets/subtensor/src/subnets/registration.rs
index 5c698c1b33..9e772d865a 100644
--- a/pallets/subtensor/src/subnets/registration.rs
+++ b/pallets/subtensor/src/subnets/registration.rs
@@ -481,7 +481,7 @@ impl<T: Config> Pallet<T> {
     /// was too high.
     pub fn hash_meets_difficulty(hash: &H256, difficulty: U256) -> bool {
         let bytes: &[u8] = hash.as_bytes();
-        let num_hash: U256 = U256::from(bytes);
+        let num_hash: U256 = U256::from_little_endian(bytes);
         let (value, overflowed) = num_hash.overflowing_mul(difficulty);
 
         log::trace!(

From 8c3cc774ac87c2a4adf678b31ed8af6f51d9cc39 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Fri, 30 May 2025 16:27:35 +0200
Subject: [PATCH 215/418] Add rollback test

---
 pallets/swap/src/pallet/impls.rs | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index e850d3b924..6ff3847fc4 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -2643,4 +2643,18 @@ mod tests {
             });
         });
     }
+
+    #[test]
+    fn test_rollback_works() {
+        new_test_ext().execute_with(|| {
+            let netuid = NetUid::from(1);
+
+            assert_eq!(
+                Pallet::<Test>::do_swap(netuid, OrderType::Buy, 1_000_000, u64::MAX.into(), true)
+                    .unwrap(),
+                Pallet::<Test>::do_swap(netuid, OrderType::Buy, 1_000_000, u64::MAX.into(), false)
+                    .unwrap()
+            );
+        })
+    }
 }

From 71445a79ccf1a67afdb6b07d75dcbd8d14ce4640 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Fri, 30 May 2025 12:01:41 -0400
Subject: [PATCH 216/418] Remove swap_inner side effects

---
 pallets/swap/src/pallet/impls.rs | 62 ++++++++++++++++----------------
 1 file changed, 30 insertions(+), 32 deletions(-)

diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 6ff3847fc4..0abe19090f 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -326,18 +326,31 @@ impl<T: Config> Pallet<T> {
         should_rollback: bool,
     ) -> Result<SwapResult, DispatchError> {
         transactional::with_transaction(|| {
-            let result = Self::swap_inner(
-                netuid,
-                order_type,
-                amount,
-                sqrt_price_limit,
-                should_rollback,
-            )
-            .map_err(Into::into);
+            // Read alpha and tao reserves before transaction
+            let tao_reserve = T::SubnetInfo::tao_reserve(netuid.into());
+            let alpha_reserve = T::SubnetInfo::alpha_reserve(netuid.into());
+
+            let mut result =
+                Self::swap_inner(netuid, order_type, amount, sqrt_price_limit).map_err(Into::into);
 
             if should_rollback || result.is_err() {
+                // Simulation only
                 TransactionOutcome::Rollback(result)
             } else {
+                // Should persist changes
+
+                // Check if reserves are overused
+                if let Ok(ref swap_result) = result {
+                    let checked_reserve = match order_type {
+                        OrderType::Buy => alpha_reserve,
+                        OrderType::Sell => tao_reserve,
+                    };
+
+                    if checked_reserve < swap_result.amount_paid_out {
+                        result = Err(Error::<T>::InsufficientLiquidity.into());
+                    }
+                }
+
                 TransactionOutcome::Commit(result)
             }
         })
@@ -348,7 +361,6 @@ impl<T: Config> Pallet<T> {
         order_type: OrderType,
         amount: u64,
         sqrt_price_limit: SqrtPrice,
-        simulate: bool,
     ) -> Result<SwapResult, Error<T>> {
         ensure!(
             T::SubnetInfo::tao_reserve(netuid.into()) >= T::MinimumReserve::get().get()
@@ -396,29 +408,15 @@ impl<T: Config> Pallet<T> {
 
         let tao_reserve = T::SubnetInfo::tao_reserve(netuid.into());
         let alpha_reserve = T::SubnetInfo::alpha_reserve(netuid.into());
-        let (new_tao_reserve, new_alpha_reserve) = if !simulate {
-            let checked_reserve = match order_type {
-                OrderType::Buy => alpha_reserve,
-                OrderType::Sell => tao_reserve,
-            };
-
-            ensure!(
-                checked_reserve >= amount_paid_out,
-                Error::<T>::InsufficientLiquidity
-            );
-
-            match order_type {
-                OrderType::Buy => (
-                    tao_reserve.saturating_add(in_acc),
-                    alpha_reserve.saturating_sub(amount_paid_out),
-                ),
-                OrderType::Sell => (
-                    tao_reserve.saturating_sub(amount_paid_out),
-                    alpha_reserve.saturating_add(in_acc),
-                ),
-            }
-        } else {
-            (tao_reserve, alpha_reserve)
+        let (new_tao_reserve, new_alpha_reserve) = match order_type {
+            OrderType::Buy => (
+                tao_reserve.saturating_add(in_acc),
+                alpha_reserve.saturating_sub(amount_paid_out),
+            ),
+            OrderType::Sell => (
+                tao_reserve.saturating_sub(amount_paid_out),
+                alpha_reserve.saturating_add(in_acc),
+            ),
         };
 
         Ok(SwapResult {

From 6101662196249d45800e69409cee8a3a93dbafbe Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Fri, 30 May 2025 12:44:14 -0400
Subject: [PATCH 217/418] Rename do_swap should_rollback parameter to simulate
 and fix docs

---
 pallets/swap/src/pallet/impls.rs | 29 ++++++++++++++++++++++-------
 1 file changed, 22 insertions(+), 7 deletions(-)

diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 0abe19090f..90285b1f4a 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -311,19 +311,34 @@ impl<T: Config> Pallet<T> {
         Ok(())
     }
 
-    /// Perform a swap
+    /// Executes a token swap on the specified subnet.
     ///
-    /// Returns a tuple (amount_paid_out, refund), where amount_paid_out is the resulting paid out
-    /// amount and refund is any unswapped amount returned to the caller
+    /// # Parameters
+    /// - `netuid`: The identifier of the subnet on which the swap is performed.
+    /// - `order_type`: The type of the swap (e.g., Buy or Sell).
+    /// - `amount`: The amount of tokens to swap.
+    /// - `sqrt_price_limit`: A price limit (expressed as a square root) to bound the swap.
+    /// - `simulate`: If `true`, the function runs in simulation mode and does not persist any changes.
     ///
-    /// The function can be used without writing into the storage by setting `should_rollback` to
-    /// `true`.
+    /// # Returns
+    /// Returns a [`Result`] with a [`SwapResult`] on success, or a [`DispatchError`] on failure.
+    /// 
+    /// The [`SwapResult`] contains:
+    /// - `amount_paid_out`: The amount of tokens received from the swap.
+    /// - `refund`: Any unswapped portion of the input amount, refunded to the caller.
+    ///
+    /// # Simulation Mode
+    /// When `simulate` is set to `true`, the function:
+    /// 1. Executes all logic without persisting any state changes (i.e., performs a dry run).
+    /// 2. Skips reserve checks — it may return an `amount_paid_out` greater than the available reserve.
+    ///
+    /// Use simulation mode to preview the outcome of a swap without modifying the blockchain state.
     pub fn do_swap(
         netuid: NetUid,
         order_type: OrderType,
         amount: u64,
         sqrt_price_limit: SqrtPrice,
-        should_rollback: bool,
+        simulate: bool,
     ) -> Result<SwapResult, DispatchError> {
         transactional::with_transaction(|| {
             // Read alpha and tao reserves before transaction
@@ -333,7 +348,7 @@ impl<T: Config> Pallet<T> {
             let mut result =
                 Self::swap_inner(netuid, order_type, amount, sqrt_price_limit).map_err(Into::into);
 
-            if should_rollback || result.is_err() {
+            if simulate || result.is_err() {
                 // Simulation only
                 TransactionOutcome::Rollback(result)
             } else {

From 36270c346c8d3db7f89a11cc7be9bfc2cdb908c6 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Fri, 30 May 2025 20:18:40 +0200
Subject: [PATCH 218/418] Fix benchmarks

---
 pallets/subtensor/src/benchmarks.rs | 42 +++++++++++++++++++++++++----
 scripts/benchmark_action.sh         |  1 +
 2 files changed, 38 insertions(+), 5 deletions(-)

diff --git a/pallets/subtensor/src/benchmarks.rs b/pallets/subtensor/src/benchmarks.rs
index a7cd03e652..ecadec3b4e 100644
--- a/pallets/subtensor/src/benchmarks.rs
+++ b/pallets/subtensor/src/benchmarks.rs
@@ -874,7 +874,7 @@ mod pallet_benchmarks {
 
         let amount = 900_000_000_000;
         let limit: u64 = 6_000_000_000;
-        let amount_to_be_staked = 440_000_000_000;
+        let amount_to_be_staked = 44_000_000_000;
         Subtensor::<T>::add_balance_to_coldkey_account(&coldkey.clone(), amount);
 
         let tao_reserve = 150_000_000_000_u64;
@@ -1478,11 +1478,43 @@ mod pallet_benchmarks {
 
     #[benchmark]
     fn unstake_all_alpha() {
-        let coldkey: T::AccountId = whitelisted_caller();
-        let hotkey: T::AccountId = account("A", 0, 15);
-        Subtensor::<T>::create_account_if_non_existent(&coldkey, &hotkey);
+        let netuid: u16 = 1;
+        let tempo: u16 = 1;
+        let seed: u32 = 1;
+
+        Subtensor::<T>::init_new_network(netuid, tempo);
+        Subtensor::<T>::set_network_registration_allowed(netuid, true);
+        SubtokenEnabled::<T>::insert(netuid, true);
+
+        Subtensor::<T>::set_max_allowed_uids(netuid, 4096);
+        assert_eq!(Subtensor::<T>::get_max_allowed_uids(netuid), 4096);
+
+        let coldkey: T::AccountId = account("Test", 0, seed);
+        let hotkey: T::AccountId = account("Alice", 0, seed);
+        Subtensor::<T>::set_burn(netuid, 1);
+
+        SubnetTAO::<T>::insert(netuid, 150_000_000_000);
+        SubnetAlphaIn::<T>::insert(netuid, 100_000_000_000);
+
+        Subtensor::<T>::add_balance_to_coldkey_account(&coldkey.clone(), 1000000u32.into());
+
+        assert_ok!(Subtensor::<T>::do_burned_registration(
+            RawOrigin::Signed(coldkey.clone()).into(),
+            netuid,
+            hotkey.clone()
+        ));
+
+        let staked_amt = 100_000_000_000;
+        Subtensor::<T>::add_balance_to_coldkey_account(&coldkey.clone(), staked_amt);
+
+        assert_ok!(Subtensor::<T>::add_stake(
+            RawOrigin::Signed(coldkey.clone()).into(),
+            hotkey.clone(),
+            netuid,
+            staked_amt
+        ));
 
         #[extrinsic_call]
-        _(RawOrigin::Signed(coldkey.clone()), hotkey.clone());
+        _(RawOrigin::Signed(coldkey), hotkey);
     }
 }
diff --git a/scripts/benchmark_action.sh b/scripts/benchmark_action.sh
index 34043957de..e3259c69d0 100755
--- a/scripts/benchmark_action.sh
+++ b/scripts/benchmark_action.sh
@@ -10,6 +10,7 @@ declare -A DISPATCH_PATHS=(
   [admin_utils]="../pallets/admin-utils/src/lib.rs"
   [commitments]="../pallets/commitments/src/lib.rs"
   [drand]="../pallets/drand/src/lib.rs"
+  [swap]="../pallets/swap/src/pallet/mod.rs"
 )
 
 # Max allowed drift (%)

From 253d8073f6f52a4b102b6c87c33bcf30bd68ecbf Mon Sep 17 00:00:00 2001
From: Cameron Fairchild <cameron@opentensor.ai>
Date: Fri, 30 May 2025 13:35:53 -0500
Subject: [PATCH 219/418] impl

---
 pallets/subtensor/src/lib.rs                 | 2 +-
 pallets/subtensor/src/staking/stake_utils.rs | 6 ++++++
 runtime/src/lib.rs                           | 2 +-
 3 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/pallets/subtensor/src/lib.rs b/pallets/subtensor/src/lib.rs
index f4f511e74a..5a6decd597 100644
--- a/pallets/subtensor/src/lib.rs
+++ b/pallets/subtensor/src/lib.rs
@@ -1785,7 +1785,7 @@ pub mod pallet {
         }
 
         /// Ensure subtoken enalbed
-        pub fn ensure_subtoken_enabled(subnet: u16) -> DispatchResult {
+        pub fn ensure_subtoken_enabled(subnet: u16) -> Result<(), Error<T>> {
             ensure!(
                 SubtokenEnabled::<T>::get(subnet),
                 Error::<T>::SubtokenDisabled
diff --git a/pallets/subtensor/src/staking/stake_utils.rs b/pallets/subtensor/src/staking/stake_utils.rs
index 058622177e..2f9704a6b9 100644
--- a/pallets/subtensor/src/staking/stake_utils.rs
+++ b/pallets/subtensor/src/staking/stake_utils.rs
@@ -911,6 +911,9 @@ impl<T: Config> Pallet<T> {
         // Ensure that the subnet exists.
         ensure!(Self::if_subnet_exist(netuid), Error::<T>::SubnetNotExists);
 
+        // Ensure that the subnet is enabled.
+        Self::ensure_subtoken_enabled(netuid)?;
+
         // Get the minimum balance (and amount) that satisfies the transaction
         let min_amount = DefaultMinStake::<T>::get().saturating_add(DefaultStakingFee::<T>::get());
 
@@ -964,6 +967,9 @@ impl<T: Config> Pallet<T> {
         // Ensure that the subnet exists.
         ensure!(Self::if_subnet_exist(netuid), Error::<T>::SubnetNotExists);
 
+        // Ensure that the subnet is enabled.
+        Self::ensure_subtoken_enabled(netuid)?;
+
         // Ensure that the stake amount to be removed is above the minimum in tao equivalent.
         if let Some(tao_equivalent) = Self::sim_swap_alpha_for_tao(netuid, alpha_unstaked) {
             ensure!(
diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index 0b64ee3cde..9bf932b298 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -209,7 +209,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
     //   `spec_version`, and `authoring_version` are the same between Wasm and native.
     // This value is set to 100 to notify Polkadot-JS App (https://polkadot.js.org/apps) to use
     //   the compatible custom types.
-    spec_version: 273,
+    spec_version: 274,
     impl_version: 1,
     apis: RUNTIME_API_VERSIONS,
     transaction_version: 1,

From e43afcd6fdacb15f4925f2c850a4caa7e0d093fa Mon Sep 17 00:00:00 2001
From: Cameron Fairchild <cameron@opentensor.ai>
Date: Fri, 30 May 2025 13:35:58 -0500
Subject: [PATCH 220/418] tests

---
 pallets/subtensor/src/tests/subnet.rs | 42 +++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)

diff --git a/pallets/subtensor/src/tests/subnet.rs b/pallets/subtensor/src/tests/subnet.rs
index ec737f8601..8a09b881e1 100644
--- a/pallets/subtensor/src/tests/subnet.rs
+++ b/pallets/subtensor/src/tests/subnet.rs
@@ -251,6 +251,8 @@ fn test_subtoken_enable_reject_trading_before_enable() {
         let hotkey_account_2_id: U256 = U256::from(3);
         let amount = DefaultMinStake::<Test>::get() * 10;
 
+        let limit_price = 1000; // not important
+
         add_network_disable_subtoken(netuid, 10, 0);
         add_network_disable_subtoken(netuid2, 10, 0);
 
@@ -273,6 +275,46 @@ fn test_subtoken_enable_reject_trading_before_enable() {
             Error::<Test>::SubtokenDisabled
         );
 
+        assert_noop!(
+            SubtensorModule::add_stake_limit(
+                RuntimeOrigin::signed(coldkey_account_id),
+                hotkey_account_id,
+                netuid,
+                amount,
+                limit_price,
+                false
+            ),
+            Error::<Test>::SubtokenDisabled
+        );
+
+        assert_noop!(
+            SubtensorModule::unstake_all(
+                RuntimeOrigin::signed(coldkey_account_id),
+                hotkey_account_id
+            ),
+            Error::<Test>::SubtokenDisabled
+        );
+
+        assert_noop!(
+            SubtensorModule::unstake_all_alpha(
+                RuntimeOrigin::signed(coldkey_account_id),
+                hotkey_account_id
+            ),
+            Error::<Test>::SubtokenDisabled
+        );
+
+        assert_noop!(
+            SubtensorModule::remove_stake_limit(
+                RuntimeOrigin::signed(coldkey_account_id),
+                hotkey_account_id,
+                netuid,
+                amount,
+                limit_price,
+                false
+            ),
+            Error::<Test>::SubtokenDisabled
+        );
+
         assert_noop!(
             SubtensorModule::remove_stake(
                 RuntimeOrigin::signed(coldkey_account_id),

From ec7303fe4d3bc14f2940f7dee74d79103440d9ab Mon Sep 17 00:00:00 2001
From: Cameron Fairchild <cameron@opentensor.ai>
Date: Fri, 30 May 2025 13:38:56 -0500
Subject: [PATCH 221/418] update comment

---
 pallets/subtensor/src/macros/dispatches.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/pallets/subtensor/src/macros/dispatches.rs b/pallets/subtensor/src/macros/dispatches.rs
index 650fb50451..5c71c64179 100644
--- a/pallets/subtensor/src/macros/dispatches.rs
+++ b/pallets/subtensor/src/macros/dispatches.rs
@@ -551,11 +551,11 @@ mod dispatches {
             Self::do_increase_take(origin, hotkey, take)
         }
 
-        /// --- Adds stake to a hotkey. The call is made from the
-        /// coldkey account linked in the hotkey.
-        /// Only the associated coldkey is allowed to make staking and
-        /// unstaking requests. This protects the neuron against
-        /// attacks on its hotkey running in production code.
+        /// --- Adds stake to a hotkey. The call is made from a coldkey account.
+        /// This delegates stake to the hotkey.
+        ///
+        /// Note: the coldkey account may own the hotkey, in which case they are
+        /// delegating to themselves.
         ///
         /// # Args:
         ///  * 'origin': (<T as frame_system::Config>Origin):

From 5ab33bd30ad5753e530fba06fa3699a3ace06538 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Fri, 30 May 2025 14:41:50 -0400
Subject: [PATCH 222/418] Fix modify_position (was burning collected fees)

---
 pallets/swap/src/pallet/impls.rs |  2 +-
 pallets/swap/src/pallet/mod.rs   | 26 +++++++++++++-------------
 2 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 90285b1f4a..a5f489b96e 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -322,7 +322,7 @@ impl<T: Config> Pallet<T> {
     ///
     /// # Returns
     /// Returns a [`Result`] with a [`SwapResult`] on success, or a [`DispatchError`] on failure.
-    /// 
+    ///
     /// The [`SwapResult`] contains:
     /// - `amount_paid_out`: The amount of tokens received from the swap.
     /// - `refund`: Any unswapped portion of the input amount, refunded to the caller.
diff --git a/pallets/swap/src/pallet/mod.rs b/pallets/swap/src/pallet/mod.rs
index f506174101..10bce8f34d 100644
--- a/pallets/swap/src/pallet/mod.rs
+++ b/pallets/swap/src/pallet/mod.rs
@@ -451,8 +451,8 @@ mod pallet {
 
                 // Emit an event
                 Self::deposit_event(Event::LiquidityAdded {
-                    coldkey,
-                    hotkey,
+                    coldkey: coldkey.clone(),
+                    hotkey: hotkey.clone(),
                     netuid,
                     position_id,
                     liquidity: liquidity_delta as u64,
@@ -461,20 +461,12 @@ mod pallet {
                 });
             } else {
                 // Credit the returned tao and alpha to the account
-                T::BalanceOps::increase_balance(
-                    &coldkey,
-                    result.tao.saturating_add(result.fee_tao),
-                );
-                T::BalanceOps::increase_stake(
-                    &coldkey,
-                    &hotkey,
-                    netuid,
-                    result.alpha.saturating_add(result.fee_alpha),
-                )?;
+                T::BalanceOps::increase_balance(&coldkey, result.tao);
+                T::BalanceOps::increase_stake(&coldkey, &hotkey, netuid, result.alpha)?;
 
                 // Emit an event
                 Self::deposit_event(Event::LiquidityRemoved {
-                    coldkey,
+                    coldkey: coldkey.clone(),
                     netuid: netuid.into(),
                     position_id,
                     tao: result.tao,
@@ -484,6 +476,14 @@ mod pallet {
                 });
             }
 
+            // Credit accrued fees to user account (no matter if liquidity is added or removed)
+            if result.fee_tao > 0 {
+                T::BalanceOps::increase_balance(&coldkey, result.fee_tao);
+            }
+            if result.fee_alpha > 0 {
+                T::BalanceOps::increase_stake(&coldkey, &hotkey.clone(), netuid, result.fee_alpha)?;
+            }
+
             Ok(())
         }
     }

From 423b3ce8e240c9749ed573a4fdaa2f1233fc89af Mon Sep 17 00:00:00 2001
From: Cameron Fairchild <cameron@opentensor.ai>
Date: Fri, 30 May 2025 13:51:55 -0500
Subject: [PATCH 223/418] fix tests

---
 pallets/subtensor/src/tests/subnet.rs | 47 ++++++++++++++++++++++++---
 1 file changed, 42 insertions(+), 5 deletions(-)

diff --git a/pallets/subtensor/src/tests/subnet.rs b/pallets/subtensor/src/tests/subnet.rs
index 8a09b881e1..fdcaa00222 100644
--- a/pallets/subtensor/src/tests/subnet.rs
+++ b/pallets/subtensor/src/tests/subnet.rs
@@ -251,11 +251,20 @@ fn test_subtoken_enable_reject_trading_before_enable() {
         let hotkey_account_2_id: U256 = U256::from(3);
         let amount = DefaultMinStake::<Test>::get() * 10;
 
-        let limit_price = 1000; // not important
+        let stake_bal = 10_000_000_000; // 10 Alpha
+
+        let limit_price = 1_000_000_000; // not important
 
         add_network_disable_subtoken(netuid, 10, 0);
         add_network_disable_subtoken(netuid2, 10, 0);
 
+        assert!(!SubtokenEnabled::<Test>::get(netuid));
+        assert!(!SubtokenEnabled::<Test>::get(netuid2));
+
+        // Set liq high enough to not trigger other errors
+        SubnetTAO::<Test>::set(netuid, 20_000_000_000);
+        SubnetAlphaIn::<Test>::set(netuid, 20_000_000_000);
+
         // Register so staking *could* work
         register_ok_neuron(netuid, hotkey_account_id, coldkey_account_id, 0);
         register_ok_neuron(netuid2, hotkey_account_id, coldkey_account_id, 100);
@@ -264,6 +273,14 @@ fn test_subtoken_enable_reject_trading_before_enable() {
 
         SubtensorModule::add_balance_to_coldkey_account(&coldkey_account_id, 10_000);
 
+        // Give some stake
+        SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
+            &hotkey_account_id,
+            &coldkey_account_id,
+            netuid,
+            stake_bal,
+        );
+
         // all trading extrinsic should be rejected.
         assert_noop!(
             SubtensorModule::add_stake(
@@ -287,20 +304,40 @@ fn test_subtoken_enable_reject_trading_before_enable() {
             Error::<Test>::SubtokenDisabled
         );
 
-        assert_noop!(
+        // For unstake_all and unstake_all_alpha, the result is Ok, but the
+        // operation is not performed.
+        assert_ok!(
             SubtensorModule::unstake_all(
                 RuntimeOrigin::signed(coldkey_account_id),
                 hotkey_account_id
             ),
-            Error::<Test>::SubtokenDisabled
+            ()
+        );
+        // Check that the stake is still the same
+        assert_eq!(
+            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+                &hotkey_account_id,
+                &coldkey_account_id,
+                netuid
+            ),
+            stake_bal
         );
 
-        assert_noop!(
+        assert_ok!(
             SubtensorModule::unstake_all_alpha(
                 RuntimeOrigin::signed(coldkey_account_id),
                 hotkey_account_id
             ),
-            Error::<Test>::SubtokenDisabled
+            ()
+        );
+        // Check that the stake is still the same
+        assert_eq!(
+            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+                &hotkey_account_id,
+                &coldkey_account_id,
+                netuid
+            ),
+            stake_bal
         );
 
         assert_noop!(

From 4868e3b2da2a4ff2a5bf25cc773f8d185ba5c0a5 Mon Sep 17 00:00:00 2001
From: Tanyu <tanyu@tensorplex.ai>
Date: Sat, 31 May 2025 01:24:23 +0800
Subject: [PATCH 224/418] Add sr25519 precompiled pallet

---
 evm-tests/src/config.ts                       |  16 +++
 .../test/sr25519.precompile.verify.test.ts    | 122 ++++++++++++++++++
 precompiles/src/lib.rs                        |   8 +-
 precompiles/src/solidity/sr25519Verify.abi    |  14 ++
 precompiles/src/solidity/sr25519Verify.sol    |  17 +++
 precompiles/src/sr25519.rs                    |  74 +++++++++++
 6 files changed, 250 insertions(+), 1 deletion(-)
 create mode 100644 evm-tests/test/sr25519.precompile.verify.test.ts
 create mode 100644 precompiles/src/solidity/sr25519Verify.abi
 create mode 100644 precompiles/src/solidity/sr25519Verify.sol
 create mode 100644 precompiles/src/sr25519.rs

diff --git a/evm-tests/src/config.ts b/evm-tests/src/config.ts
index 7fb40e67cb..1d12e3d584 100644
--- a/evm-tests/src/config.ts
+++ b/evm-tests/src/config.ts
@@ -20,6 +20,22 @@ export const IEd25519VerifyABI = [
     },
 ];
 
+export const ISr25519VERIFY_ADDRESS = "0x0000000000000000000000000000000000000403";
+export const ISr25519VerifyABI = [
+    {
+        inputs: [
+            { internalType: "bytes32", name: "message", type: "bytes32" },
+            { internalType: "bytes32", name: "publicKey", type: "bytes32" },
+            { internalType: "bytes32", name: "r", type: "bytes32" },
+            { internalType: "bytes32", name: "s", type: "bytes32" },
+        ],
+        name: "verify",
+        outputs: [{ internalType: "bool", name: "", type: "bool" }],
+        stateMutability: "pure",
+        type: "function",
+    },
+];
+
 export const IBALANCETRANSFER_ADDRESS = "0x0000000000000000000000000000000000000800";
 export const IBalanceTransferABI = [
     {
diff --git a/evm-tests/test/sr25519.precompile.verify.test.ts b/evm-tests/test/sr25519.precompile.verify.test.ts
new file mode 100644
index 0000000000..a24bd82bc7
--- /dev/null
+++ b/evm-tests/test/sr25519.precompile.verify.test.ts
@@ -0,0 +1,122 @@
+import { ISr25519VERIFY_ADDRESS, ISr25519VerifyABI, ETH_LOCAL_URL } from '../src/config'
+import { getPublicClient } from "../src/utils";
+import { toHex, toBytes, keccak256, PublicClient } from 'viem'
+import { Keyring } from "@polkadot/keyring";
+import * as assert from "assert";
+
+describe("Verfication of sr25519 signature", () => {
+    // init eth part
+    let ethClient: PublicClient;
+
+    before(async () => {
+        ethClient = await getPublicClient(ETH_LOCAL_URL);
+    });
+
+    it("Verification of sr25519 works", async () => {
+        const keyring = new Keyring({ type: "sr25519" });
+        const alice = keyring.addFromUri("//Alice");
+
+        // Use this example: https://github.com/gztensor/evm-demo/blob/main/docs/sr25519verify-precompile.md
+        // const keyring = new Keyring({ type: "sr25519" });
+        // const myAccount = keyring.addFromUri("//Alice");
+
+        //////////////////////////////////////////////////////////////////////
+        // Generate a signature
+
+        // Your message to sign
+        const message = "Sign this message";
+        const messageU8a = new TextEncoder().encode(message);
+        const messageHex = toHex(messageU8a); // Convert message to hex string
+        const messageHash = keccak256(messageHex); // Hash the message to fit into bytes32
+        console.log(`messageHash = ${messageHash}`);
+        const hashedMessageBytes = toBytes(messageHash);
+        console.log(`hashedMessageBytes = ${hashedMessageBytes}`);
+
+        // Sign the message
+        const signature = await alice.sign(hashedMessageBytes);
+        console.log(`Signature: ${toHex(signature)}`);
+
+        // Verify the signature locally
+        const isValid = alice.verify(
+            hashedMessageBytes,
+            signature,
+            alice.publicKey
+        );
+        console.log(`Is the signature valid? ${isValid}`);
+
+        //////////////////////////////////////////////////////////////////////
+        // Verify the signature using the precompile contract
+
+        const publicKeyBytes = toHex(alice.publicKey);
+        console.log(`publicKeyBytes = ${publicKeyBytes}`);
+
+        // Split signture into Commitment (R) and response (s)
+        let r = signature.slice(0, 32); // Commitment, a.k.a. "r" - first 32 bytes
+        let s = signature.slice(32, 64); // Response, a.k.a. "s" - second 32 bytes
+        let rBytes = toHex(r);
+        let sBytes = toHex(s);
+
+        const isPrecompileValid = await ethClient.readContract({
+            address: ISr25519VERIFY_ADDRESS,
+            abi: ISr25519VerifyABI,
+            functionName: "verify",
+            args: [messageHash,
+                publicKeyBytes,
+                rBytes,
+                sBytes]
+
+        });
+
+        console.log(
+            `Is the signature valid according to the smart contract? ${isPrecompileValid}`
+        );
+        assert.equal(isPrecompileValid, true)
+
+        //////////////////////////////////////////////////////////////////////
+        // Verify the signature for bad data using the precompile contract
+
+        let brokenHashedMessageBytes = hashedMessageBytes;
+        brokenHashedMessageBytes[0] = (brokenHashedMessageBytes[0] + 1) % 0xff;
+        const brokenMessageHash = toHex(brokenHashedMessageBytes);
+        console.log(`brokenMessageHash = ${brokenMessageHash}`);
+
+        const isPrecompileValidBadData = await ethClient.readContract({
+            address: ISr25519VERIFY_ADDRESS,
+            abi: ISr25519VerifyABI,
+            functionName: "verify",
+            args: [brokenMessageHash,
+                publicKeyBytes,
+                rBytes,
+                sBytes]
+
+        });
+
+        console.log(
+            `Is the signature valid according to the smart contract for broken data? ${isPrecompileValidBadData}`
+        );
+        assert.equal(isPrecompileValidBadData, false)
+
+        //////////////////////////////////////////////////////////////////////
+        // Verify the bad signature for good data using the precompile contract
+
+        let brokenR = r;
+        brokenR[0] = (brokenR[0] + 1) % 0xff;
+        rBytes = toHex(r);
+        const isPrecompileValidBadSignature = await ethClient.readContract({
+            address: ISr25519VERIFY_ADDRESS,
+            abi: ISr25519VerifyABI,
+            functionName: "verify",
+            args: [messageHash,
+                publicKeyBytes,
+                rBytes,
+                sBytes]
+
+        });
+
+        console.log(
+            `Is the signature valid according to the smart contract for broken signature? ${isPrecompileValidBadSignature}`
+        );
+        assert.equal(isPrecompileValidBadSignature, false)
+
+    });
+});
\ No newline at end of file
diff --git a/precompiles/src/lib.rs b/precompiles/src/lib.rs
index 89902ec9ee..9c9578e927 100644
--- a/precompiles/src/lib.rs
+++ b/precompiles/src/lib.rs
@@ -28,6 +28,7 @@ use crate::ed25519::*;
 use crate::extensions::*;
 use crate::metagraph::*;
 use crate::neuron::*;
+use crate::sr25519::*;
 use crate::staking::*;
 use crate::storage_query::*;
 use crate::subnet::*;
@@ -38,6 +39,7 @@ mod ed25519;
 mod extensions;
 mod metagraph;
 mod neuron;
+mod sr25519;
 mod staking;
 mod storage_query;
 mod subnet;
@@ -91,7 +93,7 @@ where
         Self(Default::default())
     }
 
-    pub fn used_addresses() -> [H160; 17] {
+    pub fn used_addresses() -> [H160; 18] {
         [
             hash(1),
             hash(2),
@@ -102,6 +104,7 @@ where
             hash(1024),
             hash(1025),
             hash(Ed25519Verify::<R::AccountId>::INDEX),
+            hash(Sr25519Verify::<R::AccountId>::INDEX),
             hash(BalanceTransferPrecompile::<R>::INDEX),
             hash(StakingPrecompile::<R>::INDEX),
             hash(SubnetPrecompile::<R>::INDEX),
@@ -150,6 +153,9 @@ where
             a if a == hash(Ed25519Verify::<R::AccountId>::INDEX) => {
                 Some(Ed25519Verify::<R::AccountId>::execute(handle))
             }
+            a if a == hash(Sr25519Verify::<R::AccountId>::INDEX) => {
+                Some(Sr25519Verify::<R::AccountId>::execute(handle))
+            }
             // Subtensor specific precompiles :
             a if a == hash(BalanceTransferPrecompile::<R>::INDEX) => {
                 BalanceTransferPrecompile::<R>::try_execute::<R>(
diff --git a/precompiles/src/solidity/sr25519Verify.abi b/precompiles/src/solidity/sr25519Verify.abi
new file mode 100644
index 0000000000..05d75ae6cc
--- /dev/null
+++ b/precompiles/src/solidity/sr25519Verify.abi
@@ -0,0 +1,14 @@
+[
+    {
+        "inputs": [
+            { "internalType": "bytes32", "name": "message", "type": "bytes32" },
+            { "internalType": "bytes32", "name": "publicKey", "type": "bytes32" },
+            { "internalType": "bytes32", "name": "r", "type": "bytes32" },
+            { "internalType": "bytes32", "name": "s", "type": "bytes32" }
+        ],
+        "name": "verify",
+        "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
+        "stateMutability": "pure",
+        "type": "function"
+    }
+]
\ No newline at end of file
diff --git a/precompiles/src/solidity/sr25519Verify.sol b/precompiles/src/solidity/sr25519Verify.sol
new file mode 100644
index 0000000000..1c6cbff45a
--- /dev/null
+++ b/precompiles/src/solidity/sr25519Verify.sol
@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity ^0.8.0;
+
+address constant ISR25519VERIFY_ADDRESS = 0x0000000000000000000000000000000000000403;
+
+interface ISR25519Verify {
+    /**
+     * @dev Verifies SR25519 signature using provided message and public key.
+     *
+     * @param message The 32-byte signature payload message.
+     * @param publicKey 32-byte public key matching to private key used to sign the message.
+     * @param r The SR25519 signature commitment (first 32 bytes).
+     * @param s The SR25519 signature response (second 32 bytes).
+     * @return bool Returns true if the signature is valid for the given message and public key, false otherwise.
+     */
+    function verify(bytes32 message, bytes32 publicKey, bytes32 r, bytes32 s) external pure returns (bool);
+}
diff --git a/precompiles/src/sr25519.rs b/precompiles/src/sr25519.rs
new file mode 100644
index 0000000000..0e57bb297b
--- /dev/null
+++ b/precompiles/src/sr25519.rs
@@ -0,0 +1,74 @@
+extern crate alloc;
+
+use alloc::vec::Vec;
+use core::marker::PhantomData;
+use sp_core::sr25519;
+use sp_runtime::traits::Verify;
+
+use fp_evm::{ExitError, ExitSucceed, LinearCostPrecompile, PrecompileFailure};
+
+use crate::PrecompileExt;
+
+pub(crate) struct Sr25519Verify<A>(PhantomData<A>);
+
+impl<A> PrecompileExt<A> for Sr25519Verify<A>
+where
+    A: From<[u8; 32]>,
+{
+    const INDEX: u64 = 1027;
+}
+
+impl<A> LinearCostPrecompile for Sr25519Verify<A>
+where
+    A: From<[u8; 32]>,
+{
+    const BASE: u64 = 15;
+    const WORD: u64 = 3;
+
+    fn execute(input: &[u8], _: u64) -> Result<(ExitSucceed, Vec<u8>), PrecompileFailure> {
+        if input.len() < 132 {
+            return Err(PrecompileFailure::Error {
+                exit_status: ExitError::Other("input must contain 128 bytes".into()),
+            });
+        };
+
+        let mut buf = [0u8; 32];
+
+        let msg = parse_slice(input, 4, 36)?;
+        let pk = sr25519::Public::try_from(parse_slice(input, 36, 68)?).map_err(|_| {
+            PrecompileFailure::Error {
+                exit_status: ExitError::Other("Public key recover failed".into()),
+            }
+        })?;
+        let sig = sr25519::Signature::try_from(parse_slice(input, 68, 132)?).map_err(|_| {
+            PrecompileFailure::Error {
+                exit_status: ExitError::Other("Signature recover failed".into()),
+            }
+        })?;
+
+        let valid = sig.verify(msg, &pk);
+        if valid {
+            buf[31] = 1u8;
+        }
+
+        Ok((ExitSucceed::Returned, buf.to_vec()))
+    }
+}
+
+/// Takes a slice from bytes with PrecompileFailure as Error
+fn parse_slice(data: &[u8], from: usize, to: usize) -> Result<&[u8], PrecompileFailure> {
+    let maybe_slice = data.get(from..to);
+    if let Some(slice) = maybe_slice {
+        Ok(slice)
+    } else {
+        log::error!(
+            "fail to get slice from data, {:?}, from {}, to {}",
+            &data,
+            from,
+            to
+        );
+        Err(PrecompileFailure::Error {
+            exit_status: ExitError::InvalidRange,
+        })
+    }
+}

From 07d9ca2e0cdc4806531c588123b0b1b999ec1331 Mon Sep 17 00:00:00 2001
From: Tanyu <tanyu@tensorplex.ai>
Date: Mon, 2 Jun 2025 16:23:33 +0800
Subject: [PATCH 225/418] Move parse_slice to lib.rs and remove comments from
 test file

---
 .../test/sr25519.precompile.verify.test.ts    |  4 ----
 precompiles/src/ed25519.rs                    | 20 +---------------
 precompiles/src/lib.rs                        | 23 +++++++++++++++++++
 precompiles/src/sr25519.rs                    | 20 +---------------
 4 files changed, 25 insertions(+), 42 deletions(-)

diff --git a/evm-tests/test/sr25519.precompile.verify.test.ts b/evm-tests/test/sr25519.precompile.verify.test.ts
index a24bd82bc7..234638f195 100644
--- a/evm-tests/test/sr25519.precompile.verify.test.ts
+++ b/evm-tests/test/sr25519.precompile.verify.test.ts
@@ -16,10 +16,6 @@ describe("Verfication of sr25519 signature", () => {
         const keyring = new Keyring({ type: "sr25519" });
         const alice = keyring.addFromUri("//Alice");
 
-        // Use this example: https://github.com/gztensor/evm-demo/blob/main/docs/sr25519verify-precompile.md
-        // const keyring = new Keyring({ type: "sr25519" });
-        // const myAccount = keyring.addFromUri("//Alice");
-
         //////////////////////////////////////////////////////////////////////
         // Generate a signature
 
diff --git a/precompiles/src/ed25519.rs b/precompiles/src/ed25519.rs
index ae23a70e78..5e186f344f 100644
--- a/precompiles/src/ed25519.rs
+++ b/precompiles/src/ed25519.rs
@@ -6,7 +6,7 @@ use core::marker::PhantomData;
 use ed25519_dalek::{Signature, Verifier, VerifyingKey};
 use fp_evm::{ExitError, ExitSucceed, LinearCostPrecompile, PrecompileFailure};
 
-use crate::PrecompileExt;
+use crate::{PrecompileExt, parse_slice};
 
 pub(crate) struct Ed25519Verify<A>(PhantomData<A>);
 
@@ -52,21 +52,3 @@ where
         Ok((ExitSucceed::Returned, buf.to_vec()))
     }
 }
-
-/// Takes a slice from bytes with PrecompileFailure as Error
-fn parse_slice(data: &[u8], from: usize, to: usize) -> Result<&[u8], PrecompileFailure> {
-    let maybe_slice = data.get(from..to);
-    if let Some(slice) = maybe_slice {
-        Ok(slice)
-    } else {
-        log::error!(
-            "fail to get slice from data, {:?}, from {}, to {}",
-            &data,
-            from,
-            to
-        );
-        Err(PrecompileFailure::Error {
-            exit_status: ExitError::InvalidRange,
-        })
-    }
-}
diff --git a/precompiles/src/lib.rs b/precompiles/src/lib.rs
index 9c9578e927..354bee838d 100644
--- a/precompiles/src/lib.rs
+++ b/precompiles/src/lib.rs
@@ -4,6 +4,7 @@ extern crate alloc;
 
 use core::marker::PhantomData;
 
+use fp_evm::{ExitError, PrecompileFailure};
 use frame_support::{
     dispatch::{GetDispatchInfo, PostDispatchInfo},
     pallet_prelude::Decode,
@@ -199,3 +200,25 @@ where
 fn hash(a: u64) -> H160 {
     H160::from_low_u64_be(a)
 }
+
+/*
+ *
+ * This is used to parse a slice from bytes with PrecompileFailure as Error
+ *
+ */
+fn parse_slice(data: &[u8], from: usize, to: usize) -> Result<&[u8], PrecompileFailure> {
+    let maybe_slice = data.get(from..to);
+    if let Some(slice) = maybe_slice {
+        Ok(slice)
+    } else {
+        log::error!(
+            "fail to get slice from data, {:?}, from {}, to {}",
+            &data,
+            from,
+            to
+        );
+        Err(PrecompileFailure::Error {
+            exit_status: ExitError::InvalidRange,
+        })
+    }
+}
diff --git a/precompiles/src/sr25519.rs b/precompiles/src/sr25519.rs
index 0e57bb297b..c81443dc19 100644
--- a/precompiles/src/sr25519.rs
+++ b/precompiles/src/sr25519.rs
@@ -7,7 +7,7 @@ use sp_runtime::traits::Verify;
 
 use fp_evm::{ExitError, ExitSucceed, LinearCostPrecompile, PrecompileFailure};
 
-use crate::PrecompileExt;
+use crate::{PrecompileExt, parse_slice};
 
 pub(crate) struct Sr25519Verify<A>(PhantomData<A>);
 
@@ -54,21 +54,3 @@ where
         Ok((ExitSucceed::Returned, buf.to_vec()))
     }
 }
-
-/// Takes a slice from bytes with PrecompileFailure as Error
-fn parse_slice(data: &[u8], from: usize, to: usize) -> Result<&[u8], PrecompileFailure> {
-    let maybe_slice = data.get(from..to);
-    if let Some(slice) = maybe_slice {
-        Ok(slice)
-    } else {
-        log::error!(
-            "fail to get slice from data, {:?}, from {}, to {}",
-            &data,
-            from,
-            to
-        );
-        Err(PrecompileFailure::Error {
-            exit_status: ExitError::InvalidRange,
-        })
-    }
-}

From 41fdb3d45c0a47ef953257bfb5bf23f92ae37e0d Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Mon, 2 Jun 2025 15:41:39 +0200
Subject: [PATCH 226/418] Move pallet tests into a separate file

---
 Cargo.toml                       |    7 +-
 pallets/swap/src/pallet/impls.rs | 1530 +----------------------------
 pallets/swap/src/pallet/mod.rs   |   78 +-
 pallets/swap/src/pallet/tests.rs | 1570 ++++++++++++++++++++++++++++++
 4 files changed, 1578 insertions(+), 1607 deletions(-)
 create mode 100644 pallets/swap/src/pallet/tests.rs

diff --git a/Cargo.toml b/Cargo.toml
index 188af2b890..89b185b7ca 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -37,14 +37,13 @@ resolver = "2"
 edition = "2024"
 
 [workspace.lints.clippy]
-indexing-slicing = "deny"
 arithmetic-side-effects = "deny"
-type_complexity = "allow"
-unwrap-used = "deny"
+indexing-slicing = "deny"
 manual_inspect = "allow"
 result_large_err = "allow"
+type_complexity = "allow"
+unwrap-used = "deny"
 useless_conversion = "allow"     # until polkadot is patched
-result_large_err = "allow"
 
 [workspace.dependencies]
 node-subtensor-runtime = { default-features = false, path = "runtime" }
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index a5f489b96e..4a16db553a 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -267,7 +267,7 @@ impl<T: Config> Pallet<T> {
     }
 
     // initializes V3 swap for a subnet if needed
-    fn maybe_initialize_v3(netuid: NetUid) -> Result<(), Error<T>> {
+    pub(super) fn maybe_initialize_v3(netuid: NetUid) -> Result<(), Error<T>> {
         if SwapV3Initialized::<T>::get(netuid) {
             return Ok(());
         }
@@ -547,7 +547,7 @@ impl<T: Config> Pallet<T> {
     ///
     /// This is the core method of uniswap V3 that tells how much output token is given for an
     /// amount of input token within one price tick.
-    fn convert_deltas(netuid: NetUid, order_type: OrderType, delta_in: u64) -> u64 {
+    pub(super) fn convert_deltas(netuid: NetUid, order_type: OrderType, delta_in: u64) -> u64 {
         // Skip conversion if delta_in is zero
         if delta_in == 0 {
             return 0;
@@ -1054,7 +1054,7 @@ impl<T: Config> Pallet<T> {
     ///
     /// # Returns
     /// The number of positions that the account has in the specified subnet
-    fn count_positions(netuid: NetUid, account_id: &T::AccountId) -> usize {
+    pub(super) fn count_positions(netuid: NetUid, account_id: &T::AccountId) -> usize {
         Positions::<T>::iter_prefix_values((netuid, account_id.clone())).count()
     }
 
@@ -1147,1527 +1147,3 @@ pub enum SwapStepAction {
     Crossing,
     Stop,
 }
-
-// cargo test --package pallet-subtensor-swap --lib -- pallet::impls::tests --show-output
-#[allow(clippy::unwrap_used)]
-#[allow(clippy::indexing_slicing)]
-#[allow(clippy::arithmetic_side_effects)]
-#[cfg(test)]
-mod tests {
-    use approx::assert_abs_diff_eq;
-    use frame_support::{assert_err, assert_noop, assert_ok};
-    use sp_arithmetic::helpers_128bit;
-
-    use super::*;
-    use crate::{mock::*, pallet::*};
-
-    // this function is used to convert price (NON-SQRT price!) to TickIndex. it's only utility for
-    // testing, all the implementation logic is based on sqrt prices
-    fn price_to_tick(price: f64) -> TickIndex {
-        let price_sqrt: SqrtPrice = SqrtPrice::from_num(price.sqrt());
-        // Handle potential errors in the conversion
-        match TickIndex::try_from_sqrt_price(price_sqrt) {
-            Ok(mut tick) => {
-                // Ensure the tick is within bounds
-                if tick > TickIndex::MAX {
-                    tick = TickIndex::MAX;
-                } else if tick < TickIndex::MIN {
-                    tick = TickIndex::MIN;
-                }
-                tick
-            }
-            // Default to a reasonable value when conversion fails
-            Err(_) => {
-                if price > 1.0 {
-                    TickIndex::MAX
-                } else {
-                    TickIndex::MIN
-                }
-            }
-        }
-    }
-
-    fn get_ticked_prices_around_current_price() -> (f64, f64) {
-        // Get current price, ticks around it, and prices on the tick edges for test cases
-        let netuid = NetUid::from(1);
-        assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
-        let current_price_sqrt = AlphaSqrtPrice::<Test>::get(netuid);
-        let tick_index_for_current_price_low =
-            TickIndex::try_from_sqrt_price(current_price_sqrt).unwrap();
-        let tick_index_for_current_price_high = tick_index_for_current_price_low
-            .next()
-            .unwrap()
-            .next()
-            .unwrap();
-
-        // Low and high prices that match to a lower and higher tick that doesn't contain the current price
-        let current_price_low_sqrt =
-            TickIndex::try_to_sqrt_price(&tick_index_for_current_price_low)
-                .unwrap()
-                .to_num::<f64>();
-        let current_price_high_sqrt =
-            TickIndex::try_to_sqrt_price(&tick_index_for_current_price_high)
-                .unwrap()
-                .to_num::<f64>();
-        let current_price_low = current_price_low_sqrt * current_price_low_sqrt;
-        let current_price_high = current_price_high_sqrt * current_price_high_sqrt;
-
-        (current_price_low, current_price_high)
-    }
-
-    // this function is used to convert tick index NON-SQRT (!) price. it's only utility for
-    // testing, all the implementation logic is based on sqrt prices
-    fn tick_to_price(tick: TickIndex) -> f64 {
-        // Handle errors gracefully
-        match tick.try_to_sqrt_price() {
-            Ok(price_sqrt) => (price_sqrt * price_sqrt).to_num::<f64>(),
-            Err(_) => {
-                // Return a sensible default based on whether the tick is above or below the valid range
-                if tick > TickIndex::MAX {
-                    tick_to_price(TickIndex::MAX) // Use the max valid tick price
-                } else {
-                    tick_to_price(TickIndex::MIN) // Use the min valid tick price
-                }
-            }
-        }
-    }
-
-    #[test]
-    fn test_swap_initialization() {
-        new_test_ext().execute_with(|| {
-            let netuid = NetUid::from(1);
-
-            // Get reserves from the mock provider
-            let tao = MockLiquidityProvider::tao_reserve(netuid.into());
-            let alpha = MockLiquidityProvider::alpha_reserve(netuid.into());
-
-            assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
-
-            assert!(SwapV3Initialized::<Test>::get(netuid));
-
-            // Verify current price is set
-            let sqrt_price = AlphaSqrtPrice::<Test>::get(netuid);
-            let expected_sqrt_price = U64F64::from_num(0.5_f64);
-            assert_abs_diff_eq!(
-                sqrt_price.to_num::<f64>(),
-                expected_sqrt_price.to_num::<f64>(),
-                epsilon = 0.000000001
-            );
-
-            // Verify that current tick is set
-            let current_tick = CurrentTick::<Test>::get(netuid);
-            let expected_current_tick = TickIndex::from_sqrt_price_bounded(expected_sqrt_price);
-            assert_eq!(current_tick, expected_current_tick);
-
-            // Calculate expected liquidity
-            let expected_liquidity =
-                helpers_128bit::sqrt((tao as u128).saturating_mul(alpha as u128)) as u64;
-
-            // Get the protocol account
-            let protocol_account_id = Pallet::<Test>::protocol_account_id();
-
-            // Verify position created for protocol account
-            let positions = Positions::<Test>::iter_prefix_values((netuid, protocol_account_id))
-                .collect::<Vec<_>>();
-            assert_eq!(positions.len(), 1);
-
-            let position = &positions[0];
-            assert_eq!(position.liquidity, expected_liquidity);
-            assert_eq!(position.tick_low, TickIndex::MIN);
-            assert_eq!(position.tick_high, TickIndex::MAX);
-            assert_eq!(position.fees_tao, 0);
-            assert_eq!(position.fees_alpha, 0);
-
-            // Verify ticks were created
-            let tick_low = Ticks::<Test>::get(netuid, TickIndex::MIN).unwrap();
-            let tick_high = Ticks::<Test>::get(netuid, TickIndex::MAX).unwrap();
-
-            // Check liquidity values
-            assert_eq!(tick_low.liquidity_net, expected_liquidity as i128);
-            assert_eq!(tick_low.liquidity_gross, expected_liquidity);
-            assert_eq!(tick_high.liquidity_net, -(expected_liquidity as i128));
-            assert_eq!(tick_high.liquidity_gross, expected_liquidity);
-
-            // Verify current liquidity is set
-            assert_eq!(CurrentLiquidity::<Test>::get(netuid), expected_liquidity);
-        });
-    }
-
-    // Test adding liquidity on top of the existing protocol liquidity
-    #[test]
-    fn test_add_liquidity_basic() {
-        new_test_ext().execute_with(|| {
-            let min_price = tick_to_price(TickIndex::MIN);
-            let max_price = tick_to_price(TickIndex::MAX);
-            let max_tick = price_to_tick(max_price);
-            let current_price = 0.25;
-            assert_eq!(max_tick, TickIndex::MAX);
-
-            let (current_price_low, current_price_high) = get_ticked_prices_around_current_price();
-
-            // As a user add liquidity with all possible corner cases
-            //   - Initial price is 0.25
-            //   - liquidity is expressed in RAO units
-            // Test case is (price_low, price_high, liquidity, tao, alpha)
-            [
-                // Repeat the protocol liquidity at maximum range: Expect all the same values
-                (
-                    min_price,
-                    max_price,
-                    2_000_000_000_u64,
-                    1_000_000_000_u64,
-                    4_000_000_000_u64,
-                ),
-                // Repeat the protocol liquidity at current to max range: Expect the same alpha
-                (
-                    current_price_high,
-                    max_price,
-                    2_000_000_000_u64,
-                    0,
-                    4_000_000_000,
-                ),
-                // Repeat the protocol liquidity at min to current range: Expect all the same tao
-                (
-                    min_price,
-                    current_price_low,
-                    2_000_000_000_u64,
-                    1_000_000_000,
-                    0,
-                ),
-                // Half to double price - just some sane wothdraw amounts
-                (0.125, 0.5, 2_000_000_000_u64, 293_000_000, 1_171_000_000),
-                // Both below price - tao is non-zero, alpha is zero
-                (0.12, 0.13, 2_000_000_000_u64, 28_270_000, 0),
-                // Both above price - tao is zero, alpha is non-zero
-                (0.3, 0.4, 2_000_000_000_u64, 0, 489_200_000),
-            ]
-            .into_iter()
-            .enumerate()
-            .map(|(n, v)| (NetUid::from(n as u16 + 1), v.0, v.1, v.2, v.3, v.4))
-            .for_each(
-                |(netuid, price_low, price_high, liquidity, expected_tao, expected_alpha)| {
-                    assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
-
-                    // Calculate ticks (assuming tick math is tested separately)
-                    let tick_low = price_to_tick(price_low);
-                    let tick_high = price_to_tick(price_high);
-
-                    // Get tick infos and liquidity before adding (to account for protocol liquidity)
-                    let tick_low_info_before =
-                        Ticks::<Test>::get(netuid, tick_low).unwrap_or_default();
-                    let tick_high_info_before =
-                        Ticks::<Test>::get(netuid, tick_high).unwrap_or_default();
-                    let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
-
-                    // Add liquidity
-                    let (position_id, tao, alpha) = Pallet::<Test>::do_add_liquidity(
-                        netuid,
-                        &OK_COLDKEY_ACCOUNT_ID,
-                        &OK_HOTKEY_ACCOUNT_ID,
-                        tick_low,
-                        tick_high,
-                        liquidity,
-                    )
-                    .unwrap();
-
-                    assert_abs_diff_eq!(tao, expected_tao, epsilon = tao / 1000);
-                    assert_abs_diff_eq!(alpha, expected_alpha, epsilon = alpha / 1000);
-
-                    // Check that low and high ticks appear in the state and are properly updated
-                    let tick_low_info = Ticks::<Test>::get(netuid, tick_low).unwrap();
-                    let tick_high_info = Ticks::<Test>::get(netuid, tick_high).unwrap();
-                    let expected_liquidity_net_low = liquidity as i128;
-                    let expected_liquidity_gross_low = liquidity;
-                    let expected_liquidity_net_high = -(liquidity as i128);
-                    let expected_liquidity_gross_high = liquidity;
-
-                    assert_eq!(
-                        tick_low_info.liquidity_net - tick_low_info_before.liquidity_net,
-                        expected_liquidity_net_low,
-                    );
-                    assert_eq!(
-                        tick_low_info.liquidity_gross - tick_low_info_before.liquidity_gross,
-                        expected_liquidity_gross_low,
-                    );
-                    assert_eq!(
-                        tick_high_info.liquidity_net - tick_high_info_before.liquidity_net,
-                        expected_liquidity_net_high,
-                    );
-                    assert_eq!(
-                        tick_high_info.liquidity_gross - tick_high_info_before.liquidity_gross,
-                        expected_liquidity_gross_high,
-                    );
-
-                    // Liquidity position at correct ticks
-                    assert_eq!(
-                        Pallet::<Test>::count_positions(netuid, &OK_COLDKEY_ACCOUNT_ID),
-                        1
-                    );
-
-                    let position =
-                        Positions::<Test>::get((netuid, OK_COLDKEY_ACCOUNT_ID, position_id))
-                            .unwrap();
-                    assert_eq!(position.liquidity, liquidity);
-                    assert_eq!(position.tick_low, tick_low);
-                    assert_eq!(position.tick_high, tick_high);
-                    assert_eq!(position.fees_alpha, 0);
-                    assert_eq!(position.fees_tao, 0);
-
-                    // Current liquidity is updated only when price range includes the current price
-                    let expected_liquidity =
-                        if (price_high >= current_price) && (price_low <= current_price) {
-                            liquidity_before + liquidity
-                        } else {
-                            liquidity_before
-                        };
-
-                    assert_eq!(CurrentLiquidity::<Test>::get(netuid), expected_liquidity)
-                },
-            );
-        });
-    }
-
-    #[test]
-    fn test_add_liquidity_out_of_bounds() {
-        new_test_ext().execute_with(|| {
-            [
-                // For our tests, we'll construct TickIndex values that are intentionally
-                // outside the valid range for testing purposes only
-                (
-                    TickIndex::new_unchecked(TickIndex::MIN.get() - 1),
-                    TickIndex::MAX,
-                    1_000_000_000_u64,
-                ),
-                (
-                    TickIndex::MIN,
-                    TickIndex::new_unchecked(TickIndex::MAX.get() + 1),
-                    1_000_000_000_u64,
-                ),
-                (
-                    TickIndex::new_unchecked(TickIndex::MIN.get() - 1),
-                    TickIndex::new_unchecked(TickIndex::MAX.get() + 1),
-                    1_000_000_000_u64,
-                ),
-                (
-                    TickIndex::new_unchecked(TickIndex::MIN.get() - 100),
-                    TickIndex::new_unchecked(TickIndex::MAX.get() + 100),
-                    1_000_000_000_u64,
-                ),
-            ]
-            .into_iter()
-            .enumerate()
-            .map(|(n, v)| (NetUid::from(n as u16), v.0, v.1, v.2))
-            .for_each(|(netuid, tick_low, tick_high, liquidity)| {
-                assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
-
-                // Add liquidity
-                assert_err!(
-                    Swap::do_add_liquidity(
-                        netuid,
-                        &OK_COLDKEY_ACCOUNT_ID,
-                        &OK_HOTKEY_ACCOUNT_ID,
-                        tick_low,
-                        tick_high,
-                        liquidity
-                    ),
-                    Error::<Test>::InvalidTickRange,
-                );
-            });
-        });
-    }
-
-    #[test]
-    fn test_add_liquidity_over_balance() {
-        new_test_ext().execute_with(|| {
-            let coldkey_account_id = 2;
-            let hotkey_account_id = 3;
-
-            [
-                // Lower than price (not enough alpha)
-                (0.1, 0.2, 100_000_000_000_u64),
-                // Higher than price (not enough tao)
-                (0.3, 0.4, 100_000_000_000_u64),
-                // Around the price (not enough both)
-                (0.1, 0.4, 100_000_000_000_u64),
-            ]
-            .into_iter()
-            .enumerate()
-            .map(|(n, v)| (NetUid::from(n as u16), v.0, v.1, v.2))
-            .for_each(|(netuid, price_low, price_high, liquidity)| {
-                // Calculate ticks
-                let tick_low = price_to_tick(price_low);
-                let tick_high = price_to_tick(price_high);
-
-                assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
-
-                // Add liquidity
-                assert_err!(
-                    Pallet::<Test>::do_add_liquidity(
-                        netuid,
-                        &coldkey_account_id,
-                        &hotkey_account_id,
-                        tick_low,
-                        tick_high,
-                        liquidity
-                    ),
-                    Error::<Test>::InsufficientBalance,
-                );
-            });
-        });
-    }
-
-    // cargo test --package pallet-subtensor-swap --lib -- pallet::impls::tests::test_remove_liquidity_basic --exact --show-output
-    #[test]
-    fn test_remove_liquidity_basic() {
-        new_test_ext().execute_with(|| {
-            let min_price = tick_to_price(TickIndex::MIN);
-            let max_price = tick_to_price(TickIndex::MAX);
-            let max_tick = price_to_tick(max_price);
-            assert_eq!(max_tick, TickIndex::MAX);
-
-            let (current_price_low, current_price_high) = get_ticked_prices_around_current_price();
-
-            // As a user add liquidity with all possible corner cases
-            //   - Initial price is 0.25
-            //   - liquidity is expressed in RAO units
-            // Test case is (price_low, price_high, liquidity, tao, alpha)
-            [
-                // Repeat the protocol liquidity at maximum range: Expect all the same values
-                (
-                    min_price,
-                    max_price,
-                    2_000_000_000_u64,
-                    1_000_000_000_u64,
-                    4_000_000_000_u64,
-                ),
-                // Repeat the protocol liquidity at current to max range: Expect the same alpha
-                (
-                    current_price_high,
-                    max_price,
-                    2_000_000_000_u64,
-                    0,
-                    4_000_000_000,
-                ),
-                // Repeat the protocol liquidity at min to current range: Expect all the same tao
-                (
-                    min_price,
-                    current_price_low,
-                    2_000_000_000_u64,
-                    1_000_000_000,
-                    0,
-                ),
-                // Half to double price - just some sane wothdraw amounts
-                (0.125, 0.5, 2_000_000_000_u64, 293_000_000, 1_171_000_000),
-                // Both below price - tao is non-zero, alpha is zero
-                (0.12, 0.13, 2_000_000_000_u64, 28_270_000, 0),
-                // Both above price - tao is zero, alpha is non-zero
-                (0.3, 0.4, 2_000_000_000_u64, 0, 489_200_000),
-            ]
-            .into_iter()
-            .enumerate()
-            .map(|(n, v)| (NetUid::from(n as u16), v.0, v.1, v.2, v.3, v.4))
-            .for_each(|(netuid, price_low, price_high, liquidity, tao, alpha)| {
-                // Calculate ticks (assuming tick math is tested separately)
-                let tick_low = price_to_tick(price_low);
-                let tick_high = price_to_tick(price_high);
-
-                assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
-                let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
-
-                // Add liquidity
-                let (position_id, _, _) = Pallet::<Test>::do_add_liquidity(
-                    netuid,
-                    &OK_COLDKEY_ACCOUNT_ID,
-                    &OK_HOTKEY_ACCOUNT_ID,
-                    tick_low,
-                    tick_high,
-                    liquidity,
-                )
-                .unwrap();
-
-                // Remove liquidity
-                let remove_result = Pallet::<Test>::do_remove_liquidity(
-                    netuid,
-                    &OK_COLDKEY_ACCOUNT_ID,
-                    position_id,
-                )
-                .unwrap();
-                assert_abs_diff_eq!(remove_result.tao, tao, epsilon = tao / 1000);
-                assert_abs_diff_eq!(remove_result.alpha, alpha, epsilon = alpha / 1000);
-                assert_eq!(remove_result.fee_tao, 0);
-                assert_eq!(remove_result.fee_alpha, 0);
-
-                // Liquidity position is removed
-                assert_eq!(
-                    Pallet::<Test>::count_positions(netuid, &OK_COLDKEY_ACCOUNT_ID),
-                    0
-                );
-                assert!(
-                    Positions::<Test>::get((netuid, OK_COLDKEY_ACCOUNT_ID, position_id)).is_none()
-                );
-
-                // Current liquidity is updated (back where it was)
-                assert_eq!(CurrentLiquidity::<Test>::get(netuid), liquidity_before);
-            });
-        });
-    }
-
-    #[test]
-    fn test_remove_liquidity_nonexisting_position() {
-        new_test_ext().execute_with(|| {
-            let min_price = tick_to_price(TickIndex::MIN);
-            let max_price = tick_to_price(TickIndex::MAX);
-            let max_tick = price_to_tick(max_price);
-            assert_eq!(max_tick.get(), TickIndex::MAX.get());
-
-            let liquidity = 2_000_000_000_u64;
-            let netuid = NetUid::from(1);
-
-            // Calculate ticks (assuming tick math is tested separately)
-            let tick_low = price_to_tick(min_price);
-            let tick_high = price_to_tick(max_price);
-
-            // Setup swap
-            assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
-
-            // Add liquidity
-            assert_ok!(Pallet::<Test>::do_add_liquidity(
-                netuid,
-                &OK_COLDKEY_ACCOUNT_ID,
-                &OK_HOTKEY_ACCOUNT_ID,
-                tick_low,
-                tick_high,
-                liquidity,
-            ));
-
-            assert!(Pallet::<Test>::count_positions(netuid, &OK_COLDKEY_ACCOUNT_ID) > 0);
-
-            // Remove liquidity
-            assert_err!(
-                Pallet::<Test>::do_remove_liquidity(
-                    netuid,
-                    &OK_COLDKEY_ACCOUNT_ID,
-                    PositionId::new::<Test>()
-                ),
-                Error::<Test>::LiquidityNotFound,
-            );
-        });
-    }
-
-    #[test]
-    fn test_modify_position_basic() {
-        new_test_ext().execute_with(|| {
-            let max_price = tick_to_price(TickIndex::MAX);
-            let max_tick = price_to_tick(max_price);
-            let limit_price = 1000.0_f64;
-            assert_eq!(max_tick, TickIndex::MAX);
-            let (_current_price_low, current_price_high) = get_ticked_prices_around_current_price();
-
-            // As a user add liquidity with all possible corner cases
-            //   - Initial price is 0.25
-            //   - liquidity is expressed in RAO units
-            // Test case is (price_low, price_high, liquidity, tao, alpha)
-            [
-                // Repeat the protocol liquidity at current to max range: Expect the same alpha
-                (
-                    current_price_high,
-                    max_price,
-                    2_000_000_000_u64,
-                    4_000_000_000,
-                ),
-            ]
-            .into_iter()
-            .enumerate()
-            .map(|(n, v)| (NetUid::from(n as u16), v.0, v.1, v.2, v.3))
-            .for_each(|(netuid, price_low, price_high, liquidity, alpha)| {
-                // Calculate ticks (assuming tick math is tested separately)
-                let tick_low = price_to_tick(price_low);
-                let tick_high = price_to_tick(price_high);
-
-                assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
-
-                // Add liquidity
-                let (position_id, _, _) = Pallet::<Test>::do_add_liquidity(
-                    netuid,
-                    &OK_COLDKEY_ACCOUNT_ID,
-                    &OK_HOTKEY_ACCOUNT_ID,
-                    tick_low,
-                    tick_high,
-                    liquidity,
-                )
-                .unwrap();
-
-                // Swap to create fees on the position
-                let sqrt_limit_price = SqrtPrice::from_num((limit_price).sqrt());
-                Pallet::<Test>::do_swap(
-                    netuid,
-                    OrderType::Buy,
-                    liquidity / 10,
-                    sqrt_limit_price,
-                    false,
-                )
-                .unwrap();
-
-                // Modify liquidity (also causes claiming of fees)
-                let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
-                let modify_result = Pallet::<Test>::do_modify_position(
-                    netuid,
-                    &OK_COLDKEY_ACCOUNT_ID,
-                    &OK_HOTKEY_ACCOUNT_ID,
-                    position_id,
-                    -((liquidity / 10) as i64),
-                )
-                .unwrap();
-                assert_abs_diff_eq!(modify_result.alpha, alpha / 10, epsilon = alpha / 1000);
-                assert!(modify_result.fee_tao > 0);
-                assert_eq!(modify_result.fee_alpha, 0);
-
-                // Liquidity position is reduced
-                assert_eq!(
-                    Pallet::<Test>::count_positions(netuid, &OK_COLDKEY_ACCOUNT_ID),
-                    1
-                );
-
-                // Current liquidity is reduced with modify_position
-                assert!(CurrentLiquidity::<Test>::get(netuid) < liquidity_before);
-
-                // Position liquidity is reduced
-                let position =
-                    Positions::<Test>::get((netuid, OK_COLDKEY_ACCOUNT_ID, position_id)).unwrap();
-                assert_eq!(position.liquidity, liquidity * 9 / 10);
-                assert_eq!(position.tick_low, tick_low);
-                assert_eq!(position.tick_high, tick_high);
-
-                // Modify liquidity again (ensure fees aren't double-collected)
-                let modify_result = Pallet::<Test>::do_modify_position(
-                    netuid,
-                    &OK_COLDKEY_ACCOUNT_ID,
-                    &OK_HOTKEY_ACCOUNT_ID,
-                    position_id,
-                    -((liquidity / 100) as i64),
-                )
-                .unwrap();
-
-                assert_abs_diff_eq!(modify_result.alpha, alpha / 100, epsilon = alpha / 1000);
-                assert_eq!(modify_result.fee_tao, 0);
-                assert_eq!(modify_result.fee_alpha, 0);
-            });
-        });
-    }
-
-    // cargo test --package pallet-subtensor-swap --lib -- pallet::impls::tests::test_swap_basic --exact --show-output
-    #[test]
-    fn test_swap_basic() {
-        new_test_ext().execute_with(|| {
-            // Current price is 0.25
-            // Test case is (order_type, liquidity, limit_price, output_amount)
-            [
-                (OrderType::Buy, 1_000u64, 1000.0_f64, 3990_u64),
-                (OrderType::Sell, 1_000u64, 0.0001_f64, 250_u64),
-                (OrderType::Buy, 500_000_000, 1000.0, 2_000_000_000),
-            ]
-            .into_iter()
-            .enumerate()
-            .map(|(n, v)| (NetUid::from(n as u16), v.0, v.1, v.2, v.3))
-            .for_each(
-                |(netuid, order_type, liquidity, limit_price, output_amount)| {
-                    // Consumed liquidity ticks
-                    let tick_low = TickIndex::MIN;
-                    let tick_high = TickIndex::MAX;
-
-                    // Setup swap
-                    assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
-
-                    // Get tick infos before the swap
-                    let tick_low_info_before =
-                        Ticks::<Test>::get(netuid, tick_low).unwrap_or_default();
-                    let tick_high_info_before =
-                        Ticks::<Test>::get(netuid, tick_high).unwrap_or_default();
-                    let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
-
-                    // Get current price
-                    let sqrt_current_price = AlphaSqrtPrice::<Test>::get(netuid);
-                    let current_price = (sqrt_current_price * sqrt_current_price).to_num::<f64>();
-
-                    // Swap
-                    let sqrt_limit_price = SqrtPrice::from_num((limit_price).sqrt());
-                    let swap_result = Pallet::<Test>::do_swap(
-                        netuid,
-                        order_type,
-                        liquidity,
-                        sqrt_limit_price,
-                        false,
-                    )
-                    .unwrap();
-                    assert_abs_diff_eq!(
-                        swap_result.amount_paid_out,
-                        output_amount,
-                        epsilon = output_amount / 100
-                    );
-
-                    let (tao_expected, alpha_expected) = match order_type {
-                        OrderType::Buy => (
-                            MockLiquidityProvider::tao_reserve(netuid.into()) + liquidity,
-                            MockLiquidityProvider::alpha_reserve(netuid.into()) - output_amount,
-                        ),
-                        OrderType::Sell => (
-                            MockLiquidityProvider::tao_reserve(netuid.into()) + output_amount,
-                            MockLiquidityProvider::alpha_reserve(netuid.into()) - liquidity,
-                        ),
-                    };
-
-                    assert_abs_diff_eq!(
-                        swap_result.new_alpha_reserve,
-                        alpha_expected,
-                        epsilon = alpha_expected / 100
-                    );
-                    assert_abs_diff_eq!(
-                        swap_result.new_tao_reserve,
-                        tao_expected,
-                        epsilon = tao_expected / 100
-                    );
-
-                    // Check that low and high ticks' fees were updated properly, and liquidity values were not updated
-                    let tick_low_info = Ticks::<Test>::get(netuid, tick_low).unwrap();
-                    let tick_high_info = Ticks::<Test>::get(netuid, tick_high).unwrap();
-                    let expected_liquidity_net_low = tick_low_info_before.liquidity_net;
-                    let expected_liquidity_gross_low = tick_low_info_before.liquidity_gross;
-                    let expected_liquidity_net_high = tick_high_info_before.liquidity_net;
-                    let expected_liquidity_gross_high = tick_high_info_before.liquidity_gross;
-                    assert_eq!(tick_low_info.liquidity_net, expected_liquidity_net_low,);
-                    assert_eq!(tick_low_info.liquidity_gross, expected_liquidity_gross_low,);
-                    assert_eq!(tick_high_info.liquidity_net, expected_liquidity_net_high,);
-                    assert_eq!(
-                        tick_high_info.liquidity_gross,
-                        expected_liquidity_gross_high,
-                    );
-
-                    // Expected fee amount
-                    let fee_rate = FeeRate::<Test>::get(netuid) as f64 / u16::MAX as f64;
-                    let expected_fee = (liquidity as f64 * fee_rate) as u64;
-
-                    // Global fees should be updated
-                    let actual_global_fee = ((match order_type {
-                        OrderType::Buy => FeeGlobalTao::<Test>::get(netuid),
-                        OrderType::Sell => FeeGlobalAlpha::<Test>::get(netuid),
-                    })
-                    .to_num::<f64>()
-                        * (liquidity_before as f64))
-                        as u64;
-
-                    assert!((swap_result.fee_paid as i64 - expected_fee as i64).abs() <= 1);
-                    assert!((actual_global_fee as i64 - expected_fee as i64).abs() <= 1);
-
-                    // Tick fees should be updated
-
-                    // Liquidity position should not be updated
-                    let protocol_id = Pallet::<Test>::protocol_account_id();
-                    let positions = Positions::<Test>::iter_prefix_values((netuid, protocol_id))
-                        .collect::<Vec<_>>();
-                    let position = positions.first().unwrap();
-
-                    assert_eq!(
-                        position.liquidity,
-                        helpers_128bit::sqrt(
-                            MockLiquidityProvider::tao_reserve(netuid.into()) as u128
-                                * MockLiquidityProvider::alpha_reserve(netuid.into()) as u128
-                        ) as u64
-                    );
-                    assert_eq!(position.tick_low, tick_low);
-                    assert_eq!(position.tick_high, tick_high);
-                    assert_eq!(position.fees_alpha, 0);
-                    assert_eq!(position.fees_tao, 0);
-
-                    // Current liquidity is not updated
-                    assert_eq!(CurrentLiquidity::<Test>::get(netuid), liquidity_before);
-
-                    // Assert that price movement is in correct direction
-                    let sqrt_current_price_after = AlphaSqrtPrice::<Test>::get(netuid);
-                    let current_price_after =
-                        (sqrt_current_price_after * sqrt_current_price_after).to_num::<f64>();
-                    match order_type {
-                        OrderType::Buy => assert!(current_price_after > current_price),
-                        OrderType::Sell => assert!(current_price_after < current_price),
-                    }
-
-                    // Assert that current tick is updated
-                    let current_tick = CurrentTick::<Test>::get(netuid);
-                    let expected_current_tick =
-                        TickIndex::from_sqrt_price_bounded(sqrt_current_price_after);
-                    assert_eq!(current_tick, expected_current_tick);
-                },
-            );
-        });
-    }
-
-    // In this test the swap starts and ends within one (large liquidity) position
-    // SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor-swap --lib -- pallet::impls::tests::test_swap_single_position --exact --show-output --nocapture
-    #[test]
-    fn test_swap_single_position() {
-        let min_price = tick_to_price(TickIndex::MIN);
-        let max_price = tick_to_price(TickIndex::MAX);
-        let max_tick = price_to_tick(max_price);
-        let current_price = 0.25;
-        let netuid = NetUid(1);
-        assert_eq!(max_tick, TickIndex::MAX);
-
-        let mut current_price_low = 0_f64;
-        let mut current_price_high = 0_f64;
-        new_test_ext().execute_with(|| {
-            let (low, high) = get_ticked_prices_around_current_price();
-            current_price_low = low;
-            current_price_high = high;
-        });
-
-        // Current price is 0.25
-        // The test case is based on the current price and position prices are defined as a price
-        // offset from the current price
-        // Outer part of test case is Position: (price_low_offset, price_high_offset, liquidity)
-        [
-            // Very localized position at the current price
-            (-0.1, 0.1, 500_000_000_000_u64),
-            // Repeat the protocol liquidity at maximum range
-            (
-                min_price - current_price,
-                max_price - current_price,
-                2_000_000_000_u64,
-            ),
-            // Repeat the protocol liquidity at current to max range
-            (
-                current_price_high - current_price,
-                max_price - current_price,
-                2_000_000_000_u64,
-            ),
-            // Repeat the protocol liquidity at min to current range
-            (
-                min_price - current_price,
-                current_price_low - current_price,
-                2_000_000_000_u64,
-            ),
-            // Half to double price
-            (-0.125, 0.25, 2_000_000_000_u64),
-            // A few other price ranges and liquidity volumes
-            (-0.1, 0.1, 2_000_000_000_u64),
-            (-0.1, 0.1, 10_000_000_000_u64),
-            (-0.1, 0.1, 100_000_000_000_u64),
-            (-0.01, 0.01, 100_000_000_000_u64),
-            (-0.001, 0.001, 100_000_000_000_u64),
-        ]
-        .into_iter()
-        .for_each(
-            |(price_low_offset, price_high_offset, position_liquidity)| {
-                // Inner part of test case is Order: (order_type, order_liquidity, limit_price)
-                // order_liquidity is represented as a fraction of position_liquidity
-                [
-                    // (OrderType::Buy, 0.0001, 1000.0_f64),
-                    // (OrderType::Sell, 0.0001, 0.0001_f64),
-                    // (OrderType::Buy, 0.001, 1000.0_f64),
-                    // (OrderType::Sell, 0.001, 0.0001_f64),
-                    // (OrderType::Buy, 0.01, 1000.0_f64),
-                    // (OrderType::Sell, 0.01, 0.0001_f64),
-                    (OrderType::Buy, 0.1, 1000.0_f64),
-                    (OrderType::Sell, 0.1, 0.0001),
-                    // (OrderType::Buy, 0.2, 1000.0_f64),
-                    // (OrderType::Sell, 0.2, 0.0001),
-                    // (OrderType::Buy, 0.5, 1000.0),
-                    // (OrderType::Sell, 0.5, 0.0001),
-                    // (OrderType::Buy, 0.9999, 1000.0),
-                    // (OrderType::Sell, 0.9999, 0.0001),
-                    // (OrderType::Buy, 1.0, 1000.0),
-                    // (OrderType::Sell, 1.0, 0.0001),
-                ]
-                .into_iter()
-                .for_each(|(order_type, order_liquidity_fraction, limit_price)| {
-                    new_test_ext().execute_with(|| {
-                        //////////////////////////////////////////////
-                        // Initialize pool and add the user position
-                        assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
-                        let tao_reserve = MockLiquidityProvider::tao_reserve(netuid.into());
-                        let alpha_reserve = MockLiquidityProvider::alpha_reserve(netuid.into());
-                        let protocol_liquidity = (tao_reserve as f64 * alpha_reserve as f64).sqrt();
-
-                        // Add liquidity
-                        let sqrt_current_price = AlphaSqrtPrice::<Test>::get(netuid);
-                        let current_price =
-                            (sqrt_current_price * sqrt_current_price).to_num::<f64>();
-
-                        let price_low = price_low_offset + current_price;
-                        let price_high = price_high_offset + current_price;
-                        let tick_low = price_to_tick(price_low);
-                        let tick_high = price_to_tick(price_high);
-                        let (_position_id, _tao, _alpha) = Pallet::<Test>::do_add_liquidity(
-                            netuid,
-                            &OK_COLDKEY_ACCOUNT_ID,
-                            &OK_HOTKEY_ACCOUNT_ID,
-                            tick_low,
-                            tick_high,
-                            position_liquidity,
-                        )
-                        .unwrap();
-
-                        // Liquidity position at correct ticks
-                        assert_eq!(
-                            Pallet::<Test>::count_positions(netuid, &OK_COLDKEY_ACCOUNT_ID),
-                            1
-                        );
-
-                        // Get tick infos before the swap
-                        let tick_low_info_before =
-                            Ticks::<Test>::get(netuid, tick_low).unwrap_or_default();
-                        let tick_high_info_before =
-                            Ticks::<Test>::get(netuid, tick_high).unwrap_or_default();
-                        let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
-                        assert_abs_diff_eq!(
-                            liquidity_before as f64,
-                            protocol_liquidity + position_liquidity as f64,
-                            epsilon = liquidity_before as f64 / 1000.
-                        );
-
-                        //////////////////////////////////////////////
-                        // Swap
-
-                        // Calculate the expected output amount for the cornercase of one step
-                        let order_liquidity = order_liquidity_fraction * position_liquidity as f64;
-
-                        let output_amount = match order_type {
-                            OrderType::Buy => {
-                                let denom = sqrt_current_price.to_num::<f64>()
-                                    * (sqrt_current_price.to_num::<f64>()
-                                        * liquidity_before as f64
-                                        + order_liquidity);
-                                let per_order_liq = liquidity_before as f64 / denom;
-                                per_order_liq * order_liquidity
-                            }
-                            OrderType::Sell => {
-                                let denom = liquidity_before as f64
-                                    / sqrt_current_price.to_num::<f64>()
-                                    + order_liquidity;
-                                let per_order_liq = sqrt_current_price.to_num::<f64>()
-                                    * liquidity_before as f64
-                                    / denom;
-                                per_order_liq * order_liquidity
-                            }
-                        };
-
-                        // Do the swap
-                        let sqrt_limit_price = SqrtPrice::from_num((limit_price).sqrt());
-                        let swap_result = Pallet::<Test>::do_swap(
-                            netuid,
-                            order_type,
-                            order_liquidity as u64,
-                            sqrt_limit_price,
-                            false,
-                        )
-                        .unwrap();
-                        assert_abs_diff_eq!(
-                            swap_result.amount_paid_out as f64,
-                            output_amount,
-                            epsilon = output_amount / 10.
-                        );
-
-                        if order_liquidity_fraction <= 0.001 {
-                            let tao_reserve_f64 = tao_reserve as f64;
-                            let alpha_reserve_f64 = alpha_reserve as f64;
-                            let (tao_expected, alpha_expected) = match order_type {
-                                OrderType::Buy => (
-                                    tao_reserve_f64 + order_liquidity,
-                                    alpha_reserve_f64 - output_amount,
-                                ),
-                                OrderType::Sell => (
-                                    tao_reserve_f64 - output_amount,
-                                    alpha_reserve_f64 + order_liquidity,
-                                ),
-                            };
-                            assert_abs_diff_eq!(
-                                swap_result.new_alpha_reserve as f64,
-                                alpha_expected,
-                                epsilon = alpha_expected / 10.0
-                            );
-                            assert_abs_diff_eq!(
-                                swap_result.new_tao_reserve as f64,
-                                tao_expected,
-                                epsilon = tao_expected / 10.0
-                            );
-                        }
-
-                        // Assert that price movement is in correct direction
-                        let sqrt_current_price_after = AlphaSqrtPrice::<Test>::get(netuid);
-                        let current_price_after =
-                            (sqrt_current_price_after * sqrt_current_price_after).to_num::<f64>();
-                        match order_type {
-                            OrderType::Buy => assert!(current_price_after > current_price),
-                            OrderType::Sell => assert!(current_price_after < current_price),
-                        }
-
-                        // Assert that for small amounts price stays within the user position
-                        if (order_liquidity_fraction <= 0.001)
-                            && (price_low_offset > 0.0001)
-                            && (price_high_offset > 0.0001)
-                        {
-                            assert!(current_price_after <= price_high);
-                            assert!(current_price_after >= price_low);
-                        }
-
-                        // Check that low and high ticks' fees were updated properly
-                        let tick_low_info = Ticks::<Test>::get(netuid, tick_low).unwrap();
-                        let tick_high_info = Ticks::<Test>::get(netuid, tick_high).unwrap();
-                        let expected_liquidity_net_low = tick_low_info_before.liquidity_net;
-                        let expected_liquidity_gross_low = tick_low_info_before.liquidity_gross;
-                        let expected_liquidity_net_high = tick_high_info_before.liquidity_net;
-                        let expected_liquidity_gross_high = tick_high_info_before.liquidity_gross;
-                        assert_eq!(tick_low_info.liquidity_net, expected_liquidity_net_low,);
-                        assert_eq!(tick_low_info.liquidity_gross, expected_liquidity_gross_low,);
-                        assert_eq!(tick_high_info.liquidity_net, expected_liquidity_net_high,);
-                        assert_eq!(
-                            tick_high_info.liquidity_gross,
-                            expected_liquidity_gross_high,
-                        );
-
-                        // Expected fee amount
-                        let fee_rate = FeeRate::<Test>::get(netuid) as f64 / u16::MAX as f64;
-                        let expected_fee =
-                            (order_liquidity - order_liquidity / (1.0 + fee_rate)) as u64;
-
-                        // Global fees should be updated
-                        let actual_global_fee = ((match order_type {
-                            OrderType::Buy => FeeGlobalTao::<Test>::get(netuid),
-                            OrderType::Sell => FeeGlobalAlpha::<Test>::get(netuid),
-                        })
-                        .to_num::<f64>()
-                            * (liquidity_before as f64))
-                            as u64;
-
-                        assert_abs_diff_eq!(
-                            swap_result.fee_paid,
-                            expected_fee,
-                            epsilon = expected_fee / 10
-                        );
-                        assert_abs_diff_eq!(
-                            actual_global_fee,
-                            expected_fee,
-                            epsilon = expected_fee / 10
-                        );
-
-                        // Tick fees should be updated
-
-                        // Liquidity position should not be updated
-                        let positions =
-                            Positions::<Test>::iter_prefix_values((netuid, OK_COLDKEY_ACCOUNT_ID))
-                                .collect::<Vec<_>>();
-                        let position = positions.first().unwrap();
-
-                        assert_eq!(position.liquidity, position_liquidity,);
-                        assert_eq!(position.tick_low, tick_low);
-                        assert_eq!(position.tick_high, tick_high);
-                        assert_eq!(position.fees_alpha, 0);
-                        assert_eq!(position.fees_tao, 0);
-                    });
-                });
-            },
-        );
-    }
-
-    // This test is a sanity check for swap and multiple positions
-    // SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor-swap --lib -- pallet::impls::tests::test_swap_multiple_positions --exact --show-output --nocapture
-    #[test]
-    fn test_swap_multiple_positions() {
-        new_test_ext().execute_with(|| {
-            let min_price = tick_to_price(TickIndex::MIN);
-            let max_price = tick_to_price(TickIndex::MAX);
-            let max_tick = price_to_tick(max_price);
-            let netuid = NetUid(1);
-            assert_eq!(max_tick, TickIndex::MAX);
-
-            //////////////////////////////////////////////
-            // Initialize pool and add the user position
-            assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
-
-            // Add liquidity
-            let sqrt_current_price = AlphaSqrtPrice::<Test>::get(netuid);
-            let current_price = (sqrt_current_price * sqrt_current_price).to_num::<f64>();
-
-            // Current price is 0.25
-            // All positions below are placed at once
-            [
-                // Very localized position at the current price
-                (-0.1, 0.1, 500_000_000_000_u64),
-                // Repeat the protocol liquidity at maximum range
-                (
-                    min_price - current_price,
-                    max_price - current_price,
-                    2_000_000_000_u64,
-                ),
-                // Repeat the protocol liquidity at current to max range
-                (0.0, max_price - current_price, 2_000_000_000_u64),
-                // Repeat the protocol liquidity at min to current range
-                (min_price - current_price, 0.0, 2_000_000_000_u64),
-                // Half to double price
-                (-0.125, 0.25, 2_000_000_000_u64),
-                // A few other price ranges and liquidity volumes
-                (-0.1, 0.1, 2_000_000_000_u64),
-                (-0.1, 0.1, 10_000_000_000_u64),
-                (-0.1, 0.1, 100_000_000_000_u64),
-                (-0.01, 0.01, 100_000_000_000_u64),
-                (-0.001, 0.001, 100_000_000_000_u64),
-                // A few (overlapping) positions up the range
-                (0.01, 0.02, 100_000_000_000_u64),
-                (0.02, 0.03, 100_000_000_000_u64),
-                (0.03, 0.04, 100_000_000_000_u64),
-                (0.03, 0.05, 100_000_000_000_u64),
-                // A few (overlapping) positions down the range
-                (-0.02, -0.01, 100_000_000_000_u64),
-                (-0.03, -0.02, 100_000_000_000_u64),
-                (-0.04, -0.03, 100_000_000_000_u64),
-                (-0.05, -0.03, 100_000_000_000_u64),
-            ]
-            .into_iter()
-            .for_each(
-                |(price_low_offset, price_high_offset, position_liquidity)| {
-                    let price_low = price_low_offset + current_price;
-                    let price_high = price_high_offset + current_price;
-                    let tick_low = price_to_tick(price_low);
-                    let tick_high = price_to_tick(price_high);
-                    let (_position_id, _tao, _alpha) = Pallet::<Test>::do_add_liquidity(
-                        netuid,
-                        &OK_COLDKEY_ACCOUNT_ID,
-                        &OK_HOTKEY_ACCOUNT_ID,
-                        tick_low,
-                        tick_high,
-                        position_liquidity,
-                    )
-                    .unwrap();
-                },
-            );
-
-            // All these orders are executed without swap reset
-            [
-                (OrderType::Buy, 100_000_u64, 1000.0_f64),
-                (OrderType::Sell, 100_000, 0.0001_f64),
-                (OrderType::Buy, 1_000_000, 1000.0_f64),
-                (OrderType::Sell, 1_000_000, 0.0001_f64),
-                (OrderType::Buy, 10_000_000, 1000.0_f64),
-                (OrderType::Sell, 10_000_000, 0.0001_f64),
-                (OrderType::Buy, 100_000_000, 1000.0),
-                (OrderType::Sell, 100_000_000, 0.0001),
-                (OrderType::Buy, 200_000_000, 1000.0_f64),
-                (OrderType::Sell, 200_000_000, 0.0001),
-                (OrderType::Buy, 500_000_000, 1000.0),
-                (OrderType::Sell, 500_000_000, 0.0001),
-                (OrderType::Buy, 1_000_000_000, 1000.0),
-                (OrderType::Sell, 1_000_000_000, 0.0001),
-                (OrderType::Buy, 10_000_000_000, 1000.0),
-                (OrderType::Sell, 10_000_000_000, 0.0001),
-            ]
-            .into_iter()
-            .for_each(|(order_type, order_liquidity, limit_price)| {
-                //////////////////////////////////////////////
-                // Swap
-                let sqrt_current_price = AlphaSqrtPrice::<Test>::get(netuid);
-                let current_price = (sqrt_current_price * sqrt_current_price).to_num::<f64>();
-                let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
-
-                let output_amount = match order_type {
-                    OrderType::Buy => {
-                        let denom = sqrt_current_price.to_num::<f64>()
-                            * (sqrt_current_price.to_num::<f64>() * liquidity_before as f64
-                                + order_liquidity as f64);
-                        let per_order_liq = liquidity_before as f64 / denom;
-                        per_order_liq * order_liquidity as f64
-                    }
-                    OrderType::Sell => {
-                        let denom = liquidity_before as f64 / sqrt_current_price.to_num::<f64>()
-                            + order_liquidity as f64;
-                        let per_order_liq =
-                            sqrt_current_price.to_num::<f64>() * liquidity_before as f64 / denom;
-                        per_order_liq * order_liquidity as f64
-                    }
-                };
-
-                // Do the swap
-                let sqrt_limit_price = SqrtPrice::from_num((limit_price).sqrt());
-                let swap_result = Pallet::<Test>::do_swap(
-                    netuid,
-                    order_type,
-                    order_liquidity,
-                    sqrt_limit_price,
-                    false,
-                )
-                .unwrap();
-                assert_abs_diff_eq!(
-                    swap_result.amount_paid_out as f64,
-                    output_amount,
-                    epsilon = output_amount / 10.
-                );
-
-                let tao_reserve = MockLiquidityProvider::tao_reserve(netuid.into());
-                let alpha_reserve = MockLiquidityProvider::alpha_reserve(netuid.into());
-                let output_amount = output_amount as u64;
-
-                assert!(output_amount > 0);
-
-                if alpha_reserve > order_liquidity && tao_reserve > order_liquidity {
-                    let (tao_expected, alpha_expected) = match order_type {
-                        OrderType::Buy => {
-                            (tao_reserve + order_liquidity, alpha_reserve - output_amount)
-                        }
-                        OrderType::Sell => {
-                            (tao_reserve - output_amount, alpha_reserve + order_liquidity)
-                        }
-                    };
-                    assert_abs_diff_eq!(
-                        swap_result.new_alpha_reserve,
-                        alpha_expected,
-                        epsilon = alpha_expected / 100
-                    );
-                    assert_abs_diff_eq!(
-                        swap_result.new_tao_reserve,
-                        tao_expected,
-                        epsilon = tao_expected / 100
-                    );
-                }
-
-                // Assert that price movement is in correct direction
-                let sqrt_current_price_after = AlphaSqrtPrice::<Test>::get(netuid);
-                let current_price_after =
-                    (sqrt_current_price_after * sqrt_current_price_after).to_num::<f64>();
-                match order_type {
-                    OrderType::Buy => assert!(current_price_after > current_price),
-                    OrderType::Sell => assert!(current_price_after < current_price),
-                }
-            });
-
-            // Current price shouldn't be much different from the original
-            let sqrt_current_price_after = AlphaSqrtPrice::<Test>::get(netuid);
-            let current_price_after =
-                (sqrt_current_price_after * sqrt_current_price_after).to_num::<f64>();
-            assert_abs_diff_eq!(
-                current_price,
-                current_price_after,
-                epsilon = current_price / 10.
-            )
-        });
-    }
-
-    // cargo test --package pallet-subtensor-swap --lib -- pallet::impls::tests::test_swap_precision_edge_case --exact --show-output
-    #[test]
-    fn test_swap_precision_edge_case() {
-        new_test_ext().execute_with(|| {
-            let netuid = NetUid::from(123); // 123 is netuid with low edge case liquidity
-            let order_type = OrderType::Sell;
-            let liquidity = 1_000_000_000_000_000_000;
-            let tick_low = TickIndex::MIN;
-
-            let sqrt_limit_price: SqrtPrice = tick_low.try_to_sqrt_price().unwrap();
-
-            // Setup swap
-            assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
-
-            // Swap
-            let swap_result =
-                Pallet::<Test>::do_swap(netuid, order_type, liquidity, sqrt_limit_price, true)
-                    .unwrap();
-
-            assert!(swap_result.amount_paid_out > 0);
-        });
-    }
-
-    // cargo test --package pallet-subtensor-swap --lib -- pallet::impls::tests::test_price_tick_price_roundtrip --exact --show-output
-    #[test]
-    fn test_price_tick_price_roundtrip() {
-        new_test_ext().execute_with(|| {
-            let netuid = NetUid::from(1);
-
-            // Setup swap
-            assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
-
-            let current_price = SqrtPrice::from_num(0.500_000_512_192_122_7);
-            let tick = TickIndex::try_from_sqrt_price(current_price).unwrap();
-
-            let round_trip_price = TickIndex::try_to_sqrt_price(&tick).unwrap();
-            assert!(round_trip_price <= current_price);
-
-            let roundtrip_tick = TickIndex::try_from_sqrt_price(round_trip_price).unwrap();
-            assert!(tick == roundtrip_tick);
-        });
-    }
-
-    #[test]
-    fn test_convert_deltas() {
-        new_test_ext().execute_with(|| {
-            let netuid = NetUid::from(1);
-            assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
-
-            for (sqrt_price, delta_in, expected_buy, expected_sell) in [
-                (SqrtPrice::from_num(1.5), 1, 0, 2),
-                (SqrtPrice::from_num(1.5), 10000, 4444, 22500),
-                (SqrtPrice::from_num(1.5), 1000000, 444444, 2250000),
-                (
-                    SqrtPrice::from_num(1.5),
-                    u64::MAX,
-                    2000000000000,
-                    3000000000000,
-                ),
-                (
-                    TickIndex::MIN.as_sqrt_price_bounded(),
-                    1,
-                    18406523739291577836,
-                    465,
-                ),
-                (TickIndex::MIN.as_sqrt_price_bounded(), 10000, u64::MAX, 465),
-                (
-                    TickIndex::MIN.as_sqrt_price_bounded(),
-                    1000000,
-                    u64::MAX,
-                    465,
-                ),
-                (
-                    TickIndex::MIN.as_sqrt_price_bounded(),
-                    u64::MAX,
-                    u64::MAX,
-                    464,
-                ),
-                (
-                    TickIndex::MAX.as_sqrt_price_bounded(),
-                    1,
-                    0,
-                    18406523745214495085,
-                ),
-                (TickIndex::MAX.as_sqrt_price_bounded(), 10000, 0, u64::MAX),
-                (TickIndex::MAX.as_sqrt_price_bounded(), 1000000, 0, u64::MAX),
-                (
-                    TickIndex::MAX.as_sqrt_price_bounded(),
-                    u64::MAX,
-                    2000000000000,
-                    u64::MAX,
-                ),
-            ] {
-                {
-                    AlphaSqrtPrice::<Test>::insert(netuid, sqrt_price);
-
-                    assert_abs_diff_eq!(
-                        Pallet::<Test>::convert_deltas(netuid, OrderType::Sell, delta_in),
-                        expected_sell,
-                        epsilon = 2
-                    );
-                    assert_abs_diff_eq!(
-                        Pallet::<Test>::convert_deltas(netuid, OrderType::Buy, delta_in),
-                        expected_buy,
-                        epsilon = 2
-                    );
-                }
-            }
-        });
-    }
-
-    #[test]
-    fn test_user_liquidity_disabled() {
-        new_test_ext().execute_with(|| {
-            // Use a netuid above 100 since our mock enables liquidity for 0-100
-            let netuid = NetUid::from(101);
-            let tick_low = TickIndex::new_unchecked(-1000);
-            let tick_high = TickIndex::new_unchecked(1000);
-            let position_id = 1;
-            let liquidity = 1_000_000_000;
-            let liquidity_delta = 500_000_000;
-
-            assert!(!EnabledUserLiquidity::<Test>::get(netuid));
-
-            assert_noop!(
-                Swap::do_add_liquidity(
-                    netuid,
-                    &OK_COLDKEY_ACCOUNT_ID,
-                    &OK_HOTKEY_ACCOUNT_ID,
-                    tick_low,
-                    tick_high,
-                    liquidity
-                ),
-                Error::<Test>::UserLiquidityDisabled
-            );
-
-            assert_noop!(
-                Swap::do_remove_liquidity(netuid, &OK_COLDKEY_ACCOUNT_ID, position_id.into()),
-                Error::<Test>::UserLiquidityDisabled
-            );
-
-            assert_noop!(
-                Swap::modify_position(
-                    RuntimeOrigin::signed(OK_COLDKEY_ACCOUNT_ID),
-                    OK_HOTKEY_ACCOUNT_ID,
-                    netuid.into(),
-                    position_id,
-                    liquidity_delta
-                ),
-                Error::<Test>::UserLiquidityDisabled
-            );
-
-            assert_ok!(Swap::set_enabled_user_liquidity(
-                RuntimeOrigin::root(),
-                netuid.into()
-            ));
-
-            let position_id = Swap::do_add_liquidity(
-                netuid,
-                &OK_COLDKEY_ACCOUNT_ID,
-                &OK_HOTKEY_ACCOUNT_ID,
-                tick_low,
-                tick_high,
-                liquidity,
-            )
-            .unwrap()
-            .0;
-
-            assert_ok!(Swap::do_modify_position(
-                netuid.into(),
-                &OK_COLDKEY_ACCOUNT_ID,
-                &OK_HOTKEY_ACCOUNT_ID,
-                position_id,
-                liquidity_delta,
-            ));
-
-            assert_ok!(Swap::do_remove_liquidity(
-                netuid.into(),
-                &OK_COLDKEY_ACCOUNT_ID,
-                position_id,
-            ));
-        });
-    }
-
-    /// Test correctness of swap fees:
-    ///   1. Fees are distribued to (concentrated) liquidity providers
-    ///
-    #[test]
-    fn test_swap_fee_correctness() {
-        new_test_ext().execute_with(|| {
-            let min_price = tick_to_price(TickIndex::MIN);
-            let max_price = tick_to_price(TickIndex::MAX);
-            let netuid = NetUid::from(1);
-
-            // Provide very spread liquidity at the range from min to max that matches protocol liquidity
-            let liquidity = 2_000_000_000_000_u64; // 1x of protocol liquidity
-
-            assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
-
-            // Calculate ticks
-            let tick_low = price_to_tick(min_price);
-            let tick_high = price_to_tick(max_price);
-
-            // Add user liquidity
-            let (position_id, _tao, _alpha) = Pallet::<Test>::do_add_liquidity(
-                netuid,
-                &OK_COLDKEY_ACCOUNT_ID,
-                &OK_HOTKEY_ACCOUNT_ID,
-                tick_low,
-                tick_high,
-                liquidity,
-            )
-            .unwrap();
-
-            // Swap buy and swap sell
-            Pallet::<Test>::do_swap(
-                netuid,
-                OrderType::Buy,
-                liquidity / 10,
-                u64::MAX.into(),
-                false,
-            )
-            .unwrap();
-            Pallet::<Test>::do_swap(netuid, OrderType::Sell, liquidity / 10, 0_u64.into(), false)
-                .unwrap();
-
-            // Get user position
-            let mut position =
-                Positions::<Test>::get((netuid, OK_COLDKEY_ACCOUNT_ID, position_id)).unwrap();
-            assert_eq!(position.liquidity, liquidity);
-            assert_eq!(position.tick_low, tick_low);
-            assert_eq!(position.tick_high, tick_high);
-
-            // Check that 50% of fees were credited to the position
-            let fee_rate = FeeRate::<Test>::get(NetUid::from(netuid)) as f64 / u16::MAX as f64;
-            let (actual_fee_tao, actual_fee_alpha) = position.collect_fees::<Test>();
-            let expected_fee = (fee_rate * (liquidity / 10) as f64 * 0.5) as u64;
-
-            assert_abs_diff_eq!(actual_fee_tao, expected_fee, epsilon = 1,);
-            assert_abs_diff_eq!(actual_fee_alpha, expected_fee, epsilon = 1,);
-        });
-    }
-
-    #[test]
-    fn test_current_liquidity_updates() {
-        let netuid = NetUid::from(1);
-        let liquidity = 1_000_000_000;
-
-        // Get current price
-        let (current_price, current_price_low, current_price_high) =
-            new_test_ext().execute_with(|| {
-                assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
-                let sqrt_current_price = AlphaSqrtPrice::<Test>::get(netuid);
-                let current_price = (sqrt_current_price * sqrt_current_price).to_num::<f64>();
-                let (current_price_low, current_price_high) =
-                    get_ticked_prices_around_current_price();
-                (current_price, current_price_low, current_price_high)
-            });
-
-        // Test case: (price_low, price_high, expect_to_update)
-        [
-            // Current price is out of position range (lower), no current lq update
-            (current_price * 2., current_price * 3., false),
-            // Current price is out of position range (higher), no current lq update
-            (current_price / 3., current_price / 2., false),
-            // Current price is just below position range, no current lq update
-            (current_price_high, current_price * 3., false),
-            // Position lower edge is just below the current price, current lq updates
-            (current_price_low, current_price * 3., true),
-            // Current price is exactly at lower edge of position range, current lq updates
-            (current_price, current_price * 3., true),
-            // Current price is exactly at higher edge of position range, no current lq update
-            (current_price / 2., current_price, false),
-        ]
-        .into_iter()
-        .for_each(|(price_low, price_high, expect_to_update)| {
-            new_test_ext().execute_with(|| {
-                assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
-
-                // Calculate ticks (assuming tick math is tested separately)
-                let tick_low = price_to_tick(price_low);
-                let tick_high = price_to_tick(price_high);
-                let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
-
-                // Add liquidity
-                assert_ok!(Pallet::<Test>::do_add_liquidity(
-                    netuid,
-                    &OK_COLDKEY_ACCOUNT_ID,
-                    &OK_HOTKEY_ACCOUNT_ID,
-                    tick_low,
-                    tick_high,
-                    liquidity,
-                ));
-
-                // Current liquidity is updated only when price range includes the current price
-                let expected_liquidity =
-                    if (price_high > current_price) && (price_low <= current_price) {
-                        assert!(expect_to_update);
-                        liquidity_before + liquidity
-                    } else {
-                        assert!(!expect_to_update);
-                        liquidity_before
-                    };
-
-                assert_eq!(CurrentLiquidity::<Test>::get(netuid), expected_liquidity)
-            });
-        });
-    }
-
-    #[test]
-    fn test_rollback_works() {
-        new_test_ext().execute_with(|| {
-            let netuid = NetUid::from(1);
-
-            assert_eq!(
-                Pallet::<Test>::do_swap(netuid, OrderType::Buy, 1_000_000, u64::MAX.into(), true)
-                    .unwrap(),
-                Pallet::<Test>::do_swap(netuid, OrderType::Buy, 1_000_000, u64::MAX.into(), false)
-                    .unwrap()
-            );
-        })
-    }
-}
diff --git a/pallets/swap/src/pallet/mod.rs b/pallets/swap/src/pallet/mod.rs
index 10bce8f34d..f59049aae6 100644
--- a/pallets/swap/src/pallet/mod.rs
+++ b/pallets/swap/src/pallet/mod.rs
@@ -15,6 +15,8 @@ use crate::{
 pub use pallet::*;
 
 mod impls;
+#[cfg(test)]
+mod tests;
 
 #[allow(clippy::module_inception)]
 #[frame_support::pallet]
@@ -488,79 +490,3 @@ mod pallet {
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use frame_support::{assert_noop, assert_ok};
-    use sp_runtime::DispatchError;
-
-    use crate::{
-        NetUid,
-        mock::*,
-        pallet::{EnabledUserLiquidity, Error, FeeRate},
-    };
-
-    #[test]
-    fn test_set_fee_rate() {
-        new_test_ext().execute_with(|| {
-            let netuid = 1u16;
-            let fee_rate = 500; // 0.76% fee
-
-            assert_noop!(
-                Swap::set_fee_rate(RuntimeOrigin::signed(666), netuid.into(), fee_rate),
-                DispatchError::BadOrigin
-            );
-
-            assert_ok!(Swap::set_fee_rate(RuntimeOrigin::root(), netuid, fee_rate));
-
-            // Check that fee rate was set correctly
-            assert_eq!(FeeRate::<Test>::get(NetUid::from(netuid)), fee_rate);
-
-            let fee_rate = fee_rate * 2;
-            assert_ok!(Swap::set_fee_rate(
-                RuntimeOrigin::signed(1),
-                netuid,
-                fee_rate
-            ));
-            assert_eq!(FeeRate::<Test>::get(NetUid::from(netuid)), fee_rate);
-
-            // Verify fee rate validation - should fail if too high
-            let too_high_fee = MaxFeeRate::get() + 1;
-            assert_noop!(
-                Swap::set_fee_rate(RuntimeOrigin::root(), netuid, too_high_fee),
-                Error::<Test>::FeeRateTooHigh
-            );
-        });
-    }
-
-    #[test]
-    fn test_set_enabled_user_liquidity() {
-        new_test_ext().execute_with(|| {
-            let netuid = NetUid::from(101);
-
-            assert!(!EnabledUserLiquidity::<Test>::get(netuid));
-
-            assert_ok!(Swap::set_enabled_user_liquidity(
-                RuntimeOrigin::root(),
-                netuid.into()
-            ));
-
-            assert!(EnabledUserLiquidity::<Test>::get(netuid));
-
-            assert_noop!(
-                Swap::set_enabled_user_liquidity(RuntimeOrigin::signed(666), netuid.into()),
-                DispatchError::BadOrigin
-            );
-
-            assert_ok!(Swap::set_enabled_user_liquidity(
-                RuntimeOrigin::signed(1),
-                netuid.into()
-            ));
-
-            assert_noop!(
-                Swap::set_enabled_user_liquidity(RuntimeOrigin::root(), NON_EXISTENT_NETUID),
-                Error::<Test>::SubNetworkDoesNotExist
-            );
-        });
-    }
-}
diff --git a/pallets/swap/src/pallet/tests.rs b/pallets/swap/src/pallet/tests.rs
new file mode 100644
index 0000000000..3cad98329e
--- /dev/null
+++ b/pallets/swap/src/pallet/tests.rs
@@ -0,0 +1,1570 @@
+#![allow(clippy::unwrap_used)]
+#![allow(clippy::indexing_slicing)]
+#![allow(clippy::arithmetic_side_effects)]
+
+use approx::assert_abs_diff_eq;
+use frame_support::{assert_err, assert_noop, assert_ok};
+use sp_arithmetic::helpers_128bit;
+use sp_runtime::DispatchError;
+
+use super::*;
+use crate::{NetUid, OrderType, SqrtPrice, mock::*};
+
+// this function is used to convert price (NON-SQRT price!) to TickIndex. it's only utility for
+// testing, all the implementation logic is based on sqrt prices
+fn price_to_tick(price: f64) -> TickIndex {
+    let price_sqrt: SqrtPrice = SqrtPrice::from_num(price.sqrt());
+    // Handle potential errors in the conversion
+    match TickIndex::try_from_sqrt_price(price_sqrt) {
+        Ok(mut tick) => {
+            // Ensure the tick is within bounds
+            if tick > TickIndex::MAX {
+                tick = TickIndex::MAX;
+            } else if tick < TickIndex::MIN {
+                tick = TickIndex::MIN;
+            }
+            tick
+        }
+        // Default to a reasonable value when conversion fails
+        Err(_) => {
+            if price > 1.0 {
+                TickIndex::MAX
+            } else {
+                TickIndex::MIN
+            }
+        }
+    }
+}
+
+fn get_ticked_prices_around_current_price() -> (f64, f64) {
+    // Get current price, ticks around it, and prices on the tick edges for test cases
+    let netuid = NetUid::from(1);
+    assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
+    let current_price_sqrt = AlphaSqrtPrice::<Test>::get(netuid);
+    let tick_index_for_current_price_low =
+        TickIndex::try_from_sqrt_price(current_price_sqrt).unwrap();
+    let tick_index_for_current_price_high = tick_index_for_current_price_low
+        .next()
+        .unwrap()
+        .next()
+        .unwrap();
+
+    // Low and high prices that match to a lower and higher tick that doesn't contain the current
+    // price
+    let current_price_low_sqrt = TickIndex::try_to_sqrt_price(&tick_index_for_current_price_low)
+        .unwrap()
+        .to_num::<f64>();
+    let current_price_high_sqrt = TickIndex::try_to_sqrt_price(&tick_index_for_current_price_high)
+        .unwrap()
+        .to_num::<f64>();
+    let current_price_low = current_price_low_sqrt * current_price_low_sqrt;
+    let current_price_high = current_price_high_sqrt * current_price_high_sqrt;
+
+    (current_price_low, current_price_high)
+}
+
+// this function is used to convert tick index NON-SQRT (!) price. it's only utility for
+// testing, all the implementation logic is based on sqrt prices
+fn tick_to_price(tick: TickIndex) -> f64 {
+    // Handle errors gracefully
+    match tick.try_to_sqrt_price() {
+        Ok(price_sqrt) => (price_sqrt * price_sqrt).to_num::<f64>(),
+        Err(_) => {
+            // Return a sensible default based on whether the tick is above or below the valid range
+            if tick > TickIndex::MAX {
+                tick_to_price(TickIndex::MAX) // Use the max valid tick price
+            } else {
+                tick_to_price(TickIndex::MIN) // Use the min valid tick price
+            }
+        }
+    }
+}
+
+mod dispatchables {
+    use super::*;
+
+    #[test]
+    fn test_set_fee_rate() {
+        new_test_ext().execute_with(|| {
+            let netuid = 1u16;
+            let fee_rate = 500; // 0.76% fee
+
+            assert_noop!(
+                Swap::set_fee_rate(RuntimeOrigin::signed(666), netuid.into(), fee_rate),
+                DispatchError::BadOrigin
+            );
+
+            assert_ok!(Swap::set_fee_rate(RuntimeOrigin::root(), netuid, fee_rate));
+
+            // Check that fee rate was set correctly
+            assert_eq!(FeeRate::<Test>::get(NetUid::from(netuid)), fee_rate);
+
+            let fee_rate = fee_rate * 2;
+            assert_ok!(Swap::set_fee_rate(
+                RuntimeOrigin::signed(1),
+                netuid,
+                fee_rate
+            ));
+            assert_eq!(FeeRate::<Test>::get(NetUid::from(netuid)), fee_rate);
+
+            // Verify fee rate validation - should fail if too high
+            let too_high_fee = MaxFeeRate::get() + 1;
+            assert_noop!(
+                Swap::set_fee_rate(RuntimeOrigin::root(), netuid, too_high_fee),
+                Error::<Test>::FeeRateTooHigh
+            );
+        });
+    }
+
+    #[test]
+    fn test_set_enabled_user_liquidity() {
+        new_test_ext().execute_with(|| {
+            let netuid = NetUid::from(101);
+
+            assert!(!EnabledUserLiquidity::<Test>::get(netuid));
+
+            assert_ok!(Swap::set_enabled_user_liquidity(
+                RuntimeOrigin::root(),
+                netuid.into()
+            ));
+
+            assert!(EnabledUserLiquidity::<Test>::get(netuid));
+
+            assert_noop!(
+                Swap::set_enabled_user_liquidity(RuntimeOrigin::signed(666), netuid.into()),
+                DispatchError::BadOrigin
+            );
+
+            assert_ok!(Swap::set_enabled_user_liquidity(
+                RuntimeOrigin::signed(1),
+                netuid.into()
+            ));
+
+            assert_noop!(
+                Swap::set_enabled_user_liquidity(RuntimeOrigin::root(), NON_EXISTENT_NETUID),
+                Error::<Test>::SubNetworkDoesNotExist
+            );
+        });
+    }
+}
+
+#[test]
+fn test_swap_initialization() {
+    new_test_ext().execute_with(|| {
+        let netuid = NetUid::from(1);
+
+        // Get reserves from the mock provider
+        let tao = MockLiquidityProvider::tao_reserve(netuid.into());
+        let alpha = MockLiquidityProvider::alpha_reserve(netuid.into());
+
+        assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
+
+        assert!(SwapV3Initialized::<Test>::get(netuid));
+
+        // Verify current price is set
+        let sqrt_price = AlphaSqrtPrice::<Test>::get(netuid);
+        let expected_sqrt_price = U64F64::from_num(0.5_f64);
+        assert_abs_diff_eq!(
+            sqrt_price.to_num::<f64>(),
+            expected_sqrt_price.to_num::<f64>(),
+            epsilon = 0.000000001
+        );
+
+        // Verify that current tick is set
+        let current_tick = CurrentTick::<Test>::get(netuid);
+        let expected_current_tick = TickIndex::from_sqrt_price_bounded(expected_sqrt_price);
+        assert_eq!(current_tick, expected_current_tick);
+
+        // Calculate expected liquidity
+        let expected_liquidity =
+            helpers_128bit::sqrt((tao as u128).saturating_mul(alpha as u128)) as u64;
+
+        // Get the protocol account
+        let protocol_account_id = Pallet::<Test>::protocol_account_id();
+
+        // Verify position created for protocol account
+        let positions = Positions::<Test>::iter_prefix_values((netuid, protocol_account_id))
+            .collect::<Vec<_>>();
+        assert_eq!(positions.len(), 1);
+
+        let position = &positions[0];
+        assert_eq!(position.liquidity, expected_liquidity);
+        assert_eq!(position.tick_low, TickIndex::MIN);
+        assert_eq!(position.tick_high, TickIndex::MAX);
+        assert_eq!(position.fees_tao, 0);
+        assert_eq!(position.fees_alpha, 0);
+
+        // Verify ticks were created
+        let tick_low = Ticks::<Test>::get(netuid, TickIndex::MIN).unwrap();
+        let tick_high = Ticks::<Test>::get(netuid, TickIndex::MAX).unwrap();
+
+        // Check liquidity values
+        assert_eq!(tick_low.liquidity_net, expected_liquidity as i128);
+        assert_eq!(tick_low.liquidity_gross, expected_liquidity);
+        assert_eq!(tick_high.liquidity_net, -(expected_liquidity as i128));
+        assert_eq!(tick_high.liquidity_gross, expected_liquidity);
+
+        // Verify current liquidity is set
+        assert_eq!(CurrentLiquidity::<Test>::get(netuid), expected_liquidity);
+    });
+}
+
+// Test adding liquidity on top of the existing protocol liquidity
+#[test]
+fn test_add_liquidity_basic() {
+    new_test_ext().execute_with(|| {
+        let min_price = tick_to_price(TickIndex::MIN);
+        let max_price = tick_to_price(TickIndex::MAX);
+        let max_tick = price_to_tick(max_price);
+        let current_price = 0.25;
+        assert_eq!(max_tick, TickIndex::MAX);
+
+        let (current_price_low, current_price_high) = get_ticked_prices_around_current_price();
+
+        // As a user add liquidity with all possible corner cases
+        //   - Initial price is 0.25
+        //   - liquidity is expressed in RAO units
+        // Test case is (price_low, price_high, liquidity, tao, alpha)
+        [
+            // Repeat the protocol liquidity at maximum range: Expect all the same values
+            (
+                min_price,
+                max_price,
+                2_000_000_000_u64,
+                1_000_000_000_u64,
+                4_000_000_000_u64,
+            ),
+            // Repeat the protocol liquidity at current to max range: Expect the same alpha
+            (
+                current_price_high,
+                max_price,
+                2_000_000_000_u64,
+                0,
+                4_000_000_000,
+            ),
+            // Repeat the protocol liquidity at min to current range: Expect all the same tao
+            (
+                min_price,
+                current_price_low,
+                2_000_000_000_u64,
+                1_000_000_000,
+                0,
+            ),
+            // Half to double price - just some sane wothdraw amounts
+            (0.125, 0.5, 2_000_000_000_u64, 293_000_000, 1_171_000_000),
+            // Both below price - tao is non-zero, alpha is zero
+            (0.12, 0.13, 2_000_000_000_u64, 28_270_000, 0),
+            // Both above price - tao is zero, alpha is non-zero
+            (0.3, 0.4, 2_000_000_000_u64, 0, 489_200_000),
+        ]
+        .into_iter()
+        .enumerate()
+        .map(|(n, v)| (NetUid::from(n as u16 + 1), v.0, v.1, v.2, v.3, v.4))
+        .for_each(
+            |(netuid, price_low, price_high, liquidity, expected_tao, expected_alpha)| {
+                assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
+
+                // Calculate ticks (assuming tick math is tested separately)
+                let tick_low = price_to_tick(price_low);
+                let tick_high = price_to_tick(price_high);
+
+                // Get tick infos and liquidity before adding (to account for protocol liquidity)
+                let tick_low_info_before = Ticks::<Test>::get(netuid, tick_low).unwrap_or_default();
+                let tick_high_info_before =
+                    Ticks::<Test>::get(netuid, tick_high).unwrap_or_default();
+                let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
+
+                // Add liquidity
+                let (position_id, tao, alpha) = Pallet::<Test>::do_add_liquidity(
+                    netuid,
+                    &OK_COLDKEY_ACCOUNT_ID,
+                    &OK_HOTKEY_ACCOUNT_ID,
+                    tick_low,
+                    tick_high,
+                    liquidity,
+                )
+                .unwrap();
+
+                assert_abs_diff_eq!(tao, expected_tao, epsilon = tao / 1000);
+                assert_abs_diff_eq!(alpha, expected_alpha, epsilon = alpha / 1000);
+
+                // Check that low and high ticks appear in the state and are properly updated
+                let tick_low_info = Ticks::<Test>::get(netuid, tick_low).unwrap();
+                let tick_high_info = Ticks::<Test>::get(netuid, tick_high).unwrap();
+                let expected_liquidity_net_low = liquidity as i128;
+                let expected_liquidity_gross_low = liquidity;
+                let expected_liquidity_net_high = -(liquidity as i128);
+                let expected_liquidity_gross_high = liquidity;
+
+                assert_eq!(
+                    tick_low_info.liquidity_net - tick_low_info_before.liquidity_net,
+                    expected_liquidity_net_low,
+                );
+                assert_eq!(
+                    tick_low_info.liquidity_gross - tick_low_info_before.liquidity_gross,
+                    expected_liquidity_gross_low,
+                );
+                assert_eq!(
+                    tick_high_info.liquidity_net - tick_high_info_before.liquidity_net,
+                    expected_liquidity_net_high,
+                );
+                assert_eq!(
+                    tick_high_info.liquidity_gross - tick_high_info_before.liquidity_gross,
+                    expected_liquidity_gross_high,
+                );
+
+                // Liquidity position at correct ticks
+                assert_eq!(
+                    Pallet::<Test>::count_positions(netuid, &OK_COLDKEY_ACCOUNT_ID),
+                    1
+                );
+
+                let position =
+                    Positions::<Test>::get((netuid, OK_COLDKEY_ACCOUNT_ID, position_id)).unwrap();
+                assert_eq!(position.liquidity, liquidity);
+                assert_eq!(position.tick_low, tick_low);
+                assert_eq!(position.tick_high, tick_high);
+                assert_eq!(position.fees_alpha, 0);
+                assert_eq!(position.fees_tao, 0);
+
+                // Current liquidity is updated only when price range includes the current price
+                let expected_liquidity =
+                    if (price_high >= current_price) && (price_low <= current_price) {
+                        liquidity_before + liquidity
+                    } else {
+                        liquidity_before
+                    };
+
+                assert_eq!(CurrentLiquidity::<Test>::get(netuid), expected_liquidity)
+            },
+        );
+    });
+}
+
+#[test]
+fn test_add_liquidity_out_of_bounds() {
+    new_test_ext().execute_with(|| {
+        [
+            // For our tests, we'll construct TickIndex values that are intentionally
+            // outside the valid range for testing purposes only
+            (
+                TickIndex::new_unchecked(TickIndex::MIN.get() - 1),
+                TickIndex::MAX,
+                1_000_000_000_u64,
+            ),
+            (
+                TickIndex::MIN,
+                TickIndex::new_unchecked(TickIndex::MAX.get() + 1),
+                1_000_000_000_u64,
+            ),
+            (
+                TickIndex::new_unchecked(TickIndex::MIN.get() - 1),
+                TickIndex::new_unchecked(TickIndex::MAX.get() + 1),
+                1_000_000_000_u64,
+            ),
+            (
+                TickIndex::new_unchecked(TickIndex::MIN.get() - 100),
+                TickIndex::new_unchecked(TickIndex::MAX.get() + 100),
+                1_000_000_000_u64,
+            ),
+        ]
+        .into_iter()
+        .enumerate()
+        .map(|(n, v)| (NetUid::from(n as u16), v.0, v.1, v.2))
+        .for_each(|(netuid, tick_low, tick_high, liquidity)| {
+            assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
+
+            // Add liquidity
+            assert_err!(
+                Swap::do_add_liquidity(
+                    netuid,
+                    &OK_COLDKEY_ACCOUNT_ID,
+                    &OK_HOTKEY_ACCOUNT_ID,
+                    tick_low,
+                    tick_high,
+                    liquidity
+                ),
+                Error::<Test>::InvalidTickRange,
+            );
+        });
+    });
+}
+
+#[test]
+fn test_add_liquidity_over_balance() {
+    new_test_ext().execute_with(|| {
+        let coldkey_account_id = 2;
+        let hotkey_account_id = 3;
+
+        [
+            // Lower than price (not enough alpha)
+            (0.1, 0.2, 100_000_000_000_u64),
+            // Higher than price (not enough tao)
+            (0.3, 0.4, 100_000_000_000_u64),
+            // Around the price (not enough both)
+            (0.1, 0.4, 100_000_000_000_u64),
+        ]
+        .into_iter()
+        .enumerate()
+        .map(|(n, v)| (NetUid::from(n as u16), v.0, v.1, v.2))
+        .for_each(|(netuid, price_low, price_high, liquidity)| {
+            // Calculate ticks
+            let tick_low = price_to_tick(price_low);
+            let tick_high = price_to_tick(price_high);
+
+            assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
+
+            // Add liquidity
+            assert_err!(
+                Pallet::<Test>::do_add_liquidity(
+                    netuid,
+                    &coldkey_account_id,
+                    &hotkey_account_id,
+                    tick_low,
+                    tick_high,
+                    liquidity
+                ),
+                Error::<Test>::InsufficientBalance,
+            );
+        });
+    });
+}
+
+// cargo test --package pallet-subtensor-swap --lib -- pallet::impls::tests::test_remove_liquidity_basic --exact --show-output
+#[test]
+fn test_remove_liquidity_basic() {
+    new_test_ext().execute_with(|| {
+        let min_price = tick_to_price(TickIndex::MIN);
+        let max_price = tick_to_price(TickIndex::MAX);
+        let max_tick = price_to_tick(max_price);
+        assert_eq!(max_tick, TickIndex::MAX);
+
+        let (current_price_low, current_price_high) = get_ticked_prices_around_current_price();
+
+        // As a user add liquidity with all possible corner cases
+        //   - Initial price is 0.25
+        //   - liquidity is expressed in RAO units
+        // Test case is (price_low, price_high, liquidity, tao, alpha)
+        [
+            // Repeat the protocol liquidity at maximum range: Expect all the same values
+            (
+                min_price,
+                max_price,
+                2_000_000_000_u64,
+                1_000_000_000_u64,
+                4_000_000_000_u64,
+            ),
+            // Repeat the protocol liquidity at current to max range: Expect the same alpha
+            (
+                current_price_high,
+                max_price,
+                2_000_000_000_u64,
+                0,
+                4_000_000_000,
+            ),
+            // Repeat the protocol liquidity at min to current range: Expect all the same tao
+            (
+                min_price,
+                current_price_low,
+                2_000_000_000_u64,
+                1_000_000_000,
+                0,
+            ),
+            // Half to double price - just some sane wothdraw amounts
+            (0.125, 0.5, 2_000_000_000_u64, 293_000_000, 1_171_000_000),
+            // Both below price - tao is non-zero, alpha is zero
+            (0.12, 0.13, 2_000_000_000_u64, 28_270_000, 0),
+            // Both above price - tao is zero, alpha is non-zero
+            (0.3, 0.4, 2_000_000_000_u64, 0, 489_200_000),
+        ]
+        .into_iter()
+        .enumerate()
+        .map(|(n, v)| (NetUid::from(n as u16), v.0, v.1, v.2, v.3, v.4))
+        .for_each(|(netuid, price_low, price_high, liquidity, tao, alpha)| {
+            // Calculate ticks (assuming tick math is tested separately)
+            let tick_low = price_to_tick(price_low);
+            let tick_high = price_to_tick(price_high);
+
+            assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
+            let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
+
+            // Add liquidity
+            let (position_id, _, _) = Pallet::<Test>::do_add_liquidity(
+                netuid,
+                &OK_COLDKEY_ACCOUNT_ID,
+                &OK_HOTKEY_ACCOUNT_ID,
+                tick_low,
+                tick_high,
+                liquidity,
+            )
+            .unwrap();
+
+            // Remove liquidity
+            let remove_result =
+                Pallet::<Test>::do_remove_liquidity(netuid, &OK_COLDKEY_ACCOUNT_ID, position_id)
+                    .unwrap();
+            assert_abs_diff_eq!(remove_result.tao, tao, epsilon = tao / 1000);
+            assert_abs_diff_eq!(remove_result.alpha, alpha, epsilon = alpha / 1000);
+            assert_eq!(remove_result.fee_tao, 0);
+            assert_eq!(remove_result.fee_alpha, 0);
+
+            // Liquidity position is removed
+            assert_eq!(
+                Pallet::<Test>::count_positions(netuid, &OK_COLDKEY_ACCOUNT_ID),
+                0
+            );
+            assert!(Positions::<Test>::get((netuid, OK_COLDKEY_ACCOUNT_ID, position_id)).is_none());
+
+            // Current liquidity is updated (back where it was)
+            assert_eq!(CurrentLiquidity::<Test>::get(netuid), liquidity_before);
+        });
+    });
+}
+
+#[test]
+fn test_remove_liquidity_nonexisting_position() {
+    new_test_ext().execute_with(|| {
+        let min_price = tick_to_price(TickIndex::MIN);
+        let max_price = tick_to_price(TickIndex::MAX);
+        let max_tick = price_to_tick(max_price);
+        assert_eq!(max_tick.get(), TickIndex::MAX.get());
+
+        let liquidity = 2_000_000_000_u64;
+        let netuid = NetUid::from(1);
+
+        // Calculate ticks (assuming tick math is tested separately)
+        let tick_low = price_to_tick(min_price);
+        let tick_high = price_to_tick(max_price);
+
+        // Setup swap
+        assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
+
+        // Add liquidity
+        assert_ok!(Pallet::<Test>::do_add_liquidity(
+            netuid,
+            &OK_COLDKEY_ACCOUNT_ID,
+            &OK_HOTKEY_ACCOUNT_ID,
+            tick_low,
+            tick_high,
+            liquidity,
+        ));
+
+        assert!(Pallet::<Test>::count_positions(netuid, &OK_COLDKEY_ACCOUNT_ID) > 0);
+
+        // Remove liquidity
+        assert_err!(
+            Pallet::<Test>::do_remove_liquidity(
+                netuid,
+                &OK_COLDKEY_ACCOUNT_ID,
+                PositionId::new::<Test>()
+            ),
+            Error::<Test>::LiquidityNotFound,
+        );
+    });
+}
+
+#[test]
+fn test_modify_position_basic() {
+    new_test_ext().execute_with(|| {
+        let max_price = tick_to_price(TickIndex::MAX);
+        let max_tick = price_to_tick(max_price);
+        let limit_price = 1000.0_f64;
+        assert_eq!(max_tick, TickIndex::MAX);
+        let (_current_price_low, current_price_high) = get_ticked_prices_around_current_price();
+
+        // As a user add liquidity with all possible corner cases
+        //   - Initial price is 0.25
+        //   - liquidity is expressed in RAO units
+        // Test case is (price_low, price_high, liquidity, tao, alpha)
+        [
+            // Repeat the protocol liquidity at current to max range: Expect the same alpha
+            (
+                current_price_high,
+                max_price,
+                2_000_000_000_u64,
+                4_000_000_000,
+            ),
+        ]
+        .into_iter()
+        .enumerate()
+        .map(|(n, v)| (NetUid::from(n as u16), v.0, v.1, v.2, v.3))
+        .for_each(|(netuid, price_low, price_high, liquidity, alpha)| {
+            // Calculate ticks (assuming tick math is tested separately)
+            let tick_low = price_to_tick(price_low);
+            let tick_high = price_to_tick(price_high);
+
+            assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
+
+            // Add liquidity
+            let (position_id, _, _) = Pallet::<Test>::do_add_liquidity(
+                netuid,
+                &OK_COLDKEY_ACCOUNT_ID,
+                &OK_HOTKEY_ACCOUNT_ID,
+                tick_low,
+                tick_high,
+                liquidity,
+            )
+            .unwrap();
+
+            // Swap to create fees on the position
+            let sqrt_limit_price = SqrtPrice::from_num((limit_price).sqrt());
+            Pallet::<Test>::do_swap(
+                netuid,
+                OrderType::Buy,
+                liquidity / 10,
+                sqrt_limit_price,
+                false,
+            )
+            .unwrap();
+
+            // Modify liquidity (also causes claiming of fees)
+            let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
+            let modify_result = Pallet::<Test>::do_modify_position(
+                netuid,
+                &OK_COLDKEY_ACCOUNT_ID,
+                &OK_HOTKEY_ACCOUNT_ID,
+                position_id,
+                -((liquidity / 10) as i64),
+            )
+            .unwrap();
+            assert_abs_diff_eq!(modify_result.alpha, alpha / 10, epsilon = alpha / 1000);
+            assert!(modify_result.fee_tao > 0);
+            assert_eq!(modify_result.fee_alpha, 0);
+
+            // Liquidity position is reduced
+            assert_eq!(
+                Pallet::<Test>::count_positions(netuid, &OK_COLDKEY_ACCOUNT_ID),
+                1
+            );
+
+            // Current liquidity is reduced with modify_position
+            assert!(CurrentLiquidity::<Test>::get(netuid) < liquidity_before);
+
+            // Position liquidity is reduced
+            let position =
+                Positions::<Test>::get((netuid, OK_COLDKEY_ACCOUNT_ID, position_id)).unwrap();
+            assert_eq!(position.liquidity, liquidity * 9 / 10);
+            assert_eq!(position.tick_low, tick_low);
+            assert_eq!(position.tick_high, tick_high);
+
+            // Modify liquidity again (ensure fees aren't double-collected)
+            let modify_result = Pallet::<Test>::do_modify_position(
+                netuid,
+                &OK_COLDKEY_ACCOUNT_ID,
+                &OK_HOTKEY_ACCOUNT_ID,
+                position_id,
+                -((liquidity / 100) as i64),
+            )
+            .unwrap();
+
+            assert_abs_diff_eq!(modify_result.alpha, alpha / 100, epsilon = alpha / 1000);
+            assert_eq!(modify_result.fee_tao, 0);
+            assert_eq!(modify_result.fee_alpha, 0);
+        });
+    });
+}
+
+// cargo test --package pallet-subtensor-swap --lib -- pallet::impls::tests::test_swap_basic --exact --show-output
+#[test]
+fn test_swap_basic() {
+    new_test_ext().execute_with(|| {
+        // Current price is 0.25
+        // Test case is (order_type, liquidity, limit_price, output_amount)
+        [
+            (OrderType::Buy, 1_000u64, 1000.0_f64, 3990_u64),
+            (OrderType::Sell, 1_000u64, 0.0001_f64, 250_u64),
+            (OrderType::Buy, 500_000_000, 1000.0, 2_000_000_000),
+        ]
+        .into_iter()
+        .enumerate()
+        .map(|(n, v)| (NetUid::from(n as u16), v.0, v.1, v.2, v.3))
+        .for_each(
+            |(netuid, order_type, liquidity, limit_price, output_amount)| {
+                // Consumed liquidity ticks
+                let tick_low = TickIndex::MIN;
+                let tick_high = TickIndex::MAX;
+
+                // Setup swap
+                assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
+
+                // Get tick infos before the swap
+                let tick_low_info_before = Ticks::<Test>::get(netuid, tick_low).unwrap_or_default();
+                let tick_high_info_before =
+                    Ticks::<Test>::get(netuid, tick_high).unwrap_or_default();
+                let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
+
+                // Get current price
+                let sqrt_current_price = AlphaSqrtPrice::<Test>::get(netuid);
+                let current_price = (sqrt_current_price * sqrt_current_price).to_num::<f64>();
+
+                // Swap
+                let sqrt_limit_price = SqrtPrice::from_num((limit_price).sqrt());
+                let swap_result =
+                    Pallet::<Test>::do_swap(netuid, order_type, liquidity, sqrt_limit_price, false)
+                        .unwrap();
+                assert_abs_diff_eq!(
+                    swap_result.amount_paid_out,
+                    output_amount,
+                    epsilon = output_amount / 100
+                );
+
+                let (tao_expected, alpha_expected) = match order_type {
+                    OrderType::Buy => (
+                        MockLiquidityProvider::tao_reserve(netuid.into()) + liquidity,
+                        MockLiquidityProvider::alpha_reserve(netuid.into()) - output_amount,
+                    ),
+                    OrderType::Sell => (
+                        MockLiquidityProvider::tao_reserve(netuid.into()) + output_amount,
+                        MockLiquidityProvider::alpha_reserve(netuid.into()) - liquidity,
+                    ),
+                };
+
+                assert_abs_diff_eq!(
+                    swap_result.new_alpha_reserve,
+                    alpha_expected,
+                    epsilon = alpha_expected / 100
+                );
+                assert_abs_diff_eq!(
+                    swap_result.new_tao_reserve,
+                    tao_expected,
+                    epsilon = tao_expected / 100
+                );
+
+                // Check that low and high ticks' fees were updated properly, and liquidity values were not updated
+                let tick_low_info = Ticks::<Test>::get(netuid, tick_low).unwrap();
+                let tick_high_info = Ticks::<Test>::get(netuid, tick_high).unwrap();
+                let expected_liquidity_net_low = tick_low_info_before.liquidity_net;
+                let expected_liquidity_gross_low = tick_low_info_before.liquidity_gross;
+                let expected_liquidity_net_high = tick_high_info_before.liquidity_net;
+                let expected_liquidity_gross_high = tick_high_info_before.liquidity_gross;
+                assert_eq!(tick_low_info.liquidity_net, expected_liquidity_net_low,);
+                assert_eq!(tick_low_info.liquidity_gross, expected_liquidity_gross_low,);
+                assert_eq!(tick_high_info.liquidity_net, expected_liquidity_net_high,);
+                assert_eq!(
+                    tick_high_info.liquidity_gross,
+                    expected_liquidity_gross_high,
+                );
+
+                // Expected fee amount
+                let fee_rate = FeeRate::<Test>::get(netuid) as f64 / u16::MAX as f64;
+                let expected_fee = (liquidity as f64 * fee_rate) as u64;
+
+                // Global fees should be updated
+                let actual_global_fee = ((match order_type {
+                    OrderType::Buy => FeeGlobalTao::<Test>::get(netuid),
+                    OrderType::Sell => FeeGlobalAlpha::<Test>::get(netuid),
+                })
+                .to_num::<f64>()
+                    * (liquidity_before as f64)) as u64;
+
+                assert!((swap_result.fee_paid as i64 - expected_fee as i64).abs() <= 1);
+                assert!((actual_global_fee as i64 - expected_fee as i64).abs() <= 1);
+
+                // Tick fees should be updated
+
+                // Liquidity position should not be updated
+                let protocol_id = Pallet::<Test>::protocol_account_id();
+                let positions = Positions::<Test>::iter_prefix_values((netuid, protocol_id))
+                    .collect::<Vec<_>>();
+                let position = positions.first().unwrap();
+
+                assert_eq!(
+                    position.liquidity,
+                    helpers_128bit::sqrt(
+                        MockLiquidityProvider::tao_reserve(netuid.into()) as u128
+                            * MockLiquidityProvider::alpha_reserve(netuid.into()) as u128
+                    ) as u64
+                );
+                assert_eq!(position.tick_low, tick_low);
+                assert_eq!(position.tick_high, tick_high);
+                assert_eq!(position.fees_alpha, 0);
+                assert_eq!(position.fees_tao, 0);
+
+                // Current liquidity is not updated
+                assert_eq!(CurrentLiquidity::<Test>::get(netuid), liquidity_before);
+
+                // Assert that price movement is in correct direction
+                let sqrt_current_price_after = AlphaSqrtPrice::<Test>::get(netuid);
+                let current_price_after =
+                    (sqrt_current_price_after * sqrt_current_price_after).to_num::<f64>();
+                match order_type {
+                    OrderType::Buy => assert!(current_price_after > current_price),
+                    OrderType::Sell => assert!(current_price_after < current_price),
+                }
+
+                // Assert that current tick is updated
+                let current_tick = CurrentTick::<Test>::get(netuid);
+                let expected_current_tick =
+                    TickIndex::from_sqrt_price_bounded(sqrt_current_price_after);
+                assert_eq!(current_tick, expected_current_tick);
+            },
+        );
+    });
+}
+
+// In this test the swap starts and ends within one (large liquidity) position
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor-swap --lib -- pallet::impls::tests::test_swap_single_position --exact --show-output --nocapture
+#[test]
+fn test_swap_single_position() {
+    let min_price = tick_to_price(TickIndex::MIN);
+    let max_price = tick_to_price(TickIndex::MAX);
+    let max_tick = price_to_tick(max_price);
+    let current_price = 0.25;
+    let netuid = NetUid(1);
+    assert_eq!(max_tick, TickIndex::MAX);
+
+    let mut current_price_low = 0_f64;
+    let mut current_price_high = 0_f64;
+    new_test_ext().execute_with(|| {
+        let (low, high) = get_ticked_prices_around_current_price();
+        current_price_low = low;
+        current_price_high = high;
+    });
+
+    // Current price is 0.25
+    // The test case is based on the current price and position prices are defined as a price
+    // offset from the current price
+    // Outer part of test case is Position: (price_low_offset, price_high_offset, liquidity)
+    [
+        // Very localized position at the current price
+        (-0.1, 0.1, 500_000_000_000_u64),
+        // Repeat the protocol liquidity at maximum range
+        (
+            min_price - current_price,
+            max_price - current_price,
+            2_000_000_000_u64,
+        ),
+        // Repeat the protocol liquidity at current to max range
+        (
+            current_price_high - current_price,
+            max_price - current_price,
+            2_000_000_000_u64,
+        ),
+        // Repeat the protocol liquidity at min to current range
+        (
+            min_price - current_price,
+            current_price_low - current_price,
+            2_000_000_000_u64,
+        ),
+        // Half to double price
+        (-0.125, 0.25, 2_000_000_000_u64),
+        // A few other price ranges and liquidity volumes
+        (-0.1, 0.1, 2_000_000_000_u64),
+        (-0.1, 0.1, 10_000_000_000_u64),
+        (-0.1, 0.1, 100_000_000_000_u64),
+        (-0.01, 0.01, 100_000_000_000_u64),
+        (-0.001, 0.001, 100_000_000_000_u64),
+    ]
+    .into_iter()
+    .for_each(
+        |(price_low_offset, price_high_offset, position_liquidity)| {
+            // Inner part of test case is Order: (order_type, order_liquidity, limit_price)
+            // order_liquidity is represented as a fraction of position_liquidity
+            [
+                // (OrderType::Buy, 0.0001, 1000.0_f64),
+                // (OrderType::Sell, 0.0001, 0.0001_f64),
+                // (OrderType::Buy, 0.001, 1000.0_f64),
+                // (OrderType::Sell, 0.001, 0.0001_f64),
+                // (OrderType::Buy, 0.01, 1000.0_f64),
+                // (OrderType::Sell, 0.01, 0.0001_f64),
+                (OrderType::Buy, 0.1, 1000.0_f64),
+                (OrderType::Sell, 0.1, 0.0001),
+                // (OrderType::Buy, 0.2, 1000.0_f64),
+                // (OrderType::Sell, 0.2, 0.0001),
+                // (OrderType::Buy, 0.5, 1000.0),
+                // (OrderType::Sell, 0.5, 0.0001),
+                // (OrderType::Buy, 0.9999, 1000.0),
+                // (OrderType::Sell, 0.9999, 0.0001),
+                // (OrderType::Buy, 1.0, 1000.0),
+                // (OrderType::Sell, 1.0, 0.0001),
+            ]
+            .into_iter()
+            .for_each(|(order_type, order_liquidity_fraction, limit_price)| {
+                new_test_ext().execute_with(|| {
+                    //////////////////////////////////////////////
+                    // Initialize pool and add the user position
+                    assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
+                    let tao_reserve = MockLiquidityProvider::tao_reserve(netuid.into());
+                    let alpha_reserve = MockLiquidityProvider::alpha_reserve(netuid.into());
+                    let protocol_liquidity = (tao_reserve as f64 * alpha_reserve as f64).sqrt();
+
+                    // Add liquidity
+                    let sqrt_current_price = AlphaSqrtPrice::<Test>::get(netuid);
+                    let current_price = (sqrt_current_price * sqrt_current_price).to_num::<f64>();
+
+                    let price_low = price_low_offset + current_price;
+                    let price_high = price_high_offset + current_price;
+                    let tick_low = price_to_tick(price_low);
+                    let tick_high = price_to_tick(price_high);
+                    let (_position_id, _tao, _alpha) = Pallet::<Test>::do_add_liquidity(
+                        netuid,
+                        &OK_COLDKEY_ACCOUNT_ID,
+                        &OK_HOTKEY_ACCOUNT_ID,
+                        tick_low,
+                        tick_high,
+                        position_liquidity,
+                    )
+                    .unwrap();
+
+                    // Liquidity position at correct ticks
+                    assert_eq!(
+                        Pallet::<Test>::count_positions(netuid, &OK_COLDKEY_ACCOUNT_ID),
+                        1
+                    );
+
+                    // Get tick infos before the swap
+                    let tick_low_info_before =
+                        Ticks::<Test>::get(netuid, tick_low).unwrap_or_default();
+                    let tick_high_info_before =
+                        Ticks::<Test>::get(netuid, tick_high).unwrap_or_default();
+                    let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
+                    assert_abs_diff_eq!(
+                        liquidity_before as f64,
+                        protocol_liquidity + position_liquidity as f64,
+                        epsilon = liquidity_before as f64 / 1000.
+                    );
+
+                    //////////////////////////////////////////////
+                    // Swap
+
+                    // Calculate the expected output amount for the cornercase of one step
+                    let order_liquidity = order_liquidity_fraction * position_liquidity as f64;
+
+                    let output_amount = match order_type {
+                        OrderType::Buy => {
+                            let denom = sqrt_current_price.to_num::<f64>()
+                                * (sqrt_current_price.to_num::<f64>() * liquidity_before as f64
+                                    + order_liquidity);
+                            let per_order_liq = liquidity_before as f64 / denom;
+                            per_order_liq * order_liquidity
+                        }
+                        OrderType::Sell => {
+                            let denom = liquidity_before as f64
+                                / sqrt_current_price.to_num::<f64>()
+                                + order_liquidity;
+                            let per_order_liq = sqrt_current_price.to_num::<f64>()
+                                * liquidity_before as f64
+                                / denom;
+                            per_order_liq * order_liquidity
+                        }
+                    };
+
+                    // Do the swap
+                    let sqrt_limit_price = SqrtPrice::from_num((limit_price).sqrt());
+                    let swap_result = Pallet::<Test>::do_swap(
+                        netuid,
+                        order_type,
+                        order_liquidity as u64,
+                        sqrt_limit_price,
+                        false,
+                    )
+                    .unwrap();
+                    assert_abs_diff_eq!(
+                        swap_result.amount_paid_out as f64,
+                        output_amount,
+                        epsilon = output_amount / 10.
+                    );
+
+                    if order_liquidity_fraction <= 0.001 {
+                        let tao_reserve_f64 = tao_reserve as f64;
+                        let alpha_reserve_f64 = alpha_reserve as f64;
+                        let (tao_expected, alpha_expected) = match order_type {
+                            OrderType::Buy => (
+                                tao_reserve_f64 + order_liquidity,
+                                alpha_reserve_f64 - output_amount,
+                            ),
+                            OrderType::Sell => (
+                                tao_reserve_f64 - output_amount,
+                                alpha_reserve_f64 + order_liquidity,
+                            ),
+                        };
+                        assert_abs_diff_eq!(
+                            swap_result.new_alpha_reserve as f64,
+                            alpha_expected,
+                            epsilon = alpha_expected / 10.0
+                        );
+                        assert_abs_diff_eq!(
+                            swap_result.new_tao_reserve as f64,
+                            tao_expected,
+                            epsilon = tao_expected / 10.0
+                        );
+                    }
+
+                    // Assert that price movement is in correct direction
+                    let sqrt_current_price_after = AlphaSqrtPrice::<Test>::get(netuid);
+                    let current_price_after =
+                        (sqrt_current_price_after * sqrt_current_price_after).to_num::<f64>();
+                    match order_type {
+                        OrderType::Buy => assert!(current_price_after > current_price),
+                        OrderType::Sell => assert!(current_price_after < current_price),
+                    }
+
+                    // Assert that for small amounts price stays within the user position
+                    if (order_liquidity_fraction <= 0.001)
+                        && (price_low_offset > 0.0001)
+                        && (price_high_offset > 0.0001)
+                    {
+                        assert!(current_price_after <= price_high);
+                        assert!(current_price_after >= price_low);
+                    }
+
+                    // Check that low and high ticks' fees were updated properly
+                    let tick_low_info = Ticks::<Test>::get(netuid, tick_low).unwrap();
+                    let tick_high_info = Ticks::<Test>::get(netuid, tick_high).unwrap();
+                    let expected_liquidity_net_low = tick_low_info_before.liquidity_net;
+                    let expected_liquidity_gross_low = tick_low_info_before.liquidity_gross;
+                    let expected_liquidity_net_high = tick_high_info_before.liquidity_net;
+                    let expected_liquidity_gross_high = tick_high_info_before.liquidity_gross;
+                    assert_eq!(tick_low_info.liquidity_net, expected_liquidity_net_low,);
+                    assert_eq!(tick_low_info.liquidity_gross, expected_liquidity_gross_low,);
+                    assert_eq!(tick_high_info.liquidity_net, expected_liquidity_net_high,);
+                    assert_eq!(
+                        tick_high_info.liquidity_gross,
+                        expected_liquidity_gross_high,
+                    );
+
+                    // Expected fee amount
+                    let fee_rate = FeeRate::<Test>::get(netuid) as f64 / u16::MAX as f64;
+                    let expected_fee =
+                        (order_liquidity - order_liquidity / (1.0 + fee_rate)) as u64;
+
+                    // Global fees should be updated
+                    let actual_global_fee = ((match order_type {
+                        OrderType::Buy => FeeGlobalTao::<Test>::get(netuid),
+                        OrderType::Sell => FeeGlobalAlpha::<Test>::get(netuid),
+                    })
+                    .to_num::<f64>()
+                        * (liquidity_before as f64))
+                        as u64;
+
+                    assert_abs_diff_eq!(
+                        swap_result.fee_paid,
+                        expected_fee,
+                        epsilon = expected_fee / 10
+                    );
+                    assert_abs_diff_eq!(
+                        actual_global_fee,
+                        expected_fee,
+                        epsilon = expected_fee / 10
+                    );
+
+                    // Tick fees should be updated
+
+                    // Liquidity position should not be updated
+                    let positions =
+                        Positions::<Test>::iter_prefix_values((netuid, OK_COLDKEY_ACCOUNT_ID))
+                            .collect::<Vec<_>>();
+                    let position = positions.first().unwrap();
+
+                    assert_eq!(position.liquidity, position_liquidity,);
+                    assert_eq!(position.tick_low, tick_low);
+                    assert_eq!(position.tick_high, tick_high);
+                    assert_eq!(position.fees_alpha, 0);
+                    assert_eq!(position.fees_tao, 0);
+                });
+            });
+        },
+    );
+}
+
+// This test is a sanity check for swap and multiple positions
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor-swap --lib -- pallet::impls::tests::test_swap_multiple_positions --exact --show-output --nocapture
+#[test]
+fn test_swap_multiple_positions() {
+    new_test_ext().execute_with(|| {
+        let min_price = tick_to_price(TickIndex::MIN);
+        let max_price = tick_to_price(TickIndex::MAX);
+        let max_tick = price_to_tick(max_price);
+        let netuid = NetUid(1);
+        assert_eq!(max_tick, TickIndex::MAX);
+
+        //////////////////////////////////////////////
+        // Initialize pool and add the user position
+        assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
+
+        // Add liquidity
+        let sqrt_current_price = AlphaSqrtPrice::<Test>::get(netuid);
+        let current_price = (sqrt_current_price * sqrt_current_price).to_num::<f64>();
+
+        // Current price is 0.25
+        // All positions below are placed at once
+        [
+            // Very localized position at the current price
+            (-0.1, 0.1, 500_000_000_000_u64),
+            // Repeat the protocol liquidity at maximum range
+            (
+                min_price - current_price,
+                max_price - current_price,
+                2_000_000_000_u64,
+            ),
+            // Repeat the protocol liquidity at current to max range
+            (0.0, max_price - current_price, 2_000_000_000_u64),
+            // Repeat the protocol liquidity at min to current range
+            (min_price - current_price, 0.0, 2_000_000_000_u64),
+            // Half to double price
+            (-0.125, 0.25, 2_000_000_000_u64),
+            // A few other price ranges and liquidity volumes
+            (-0.1, 0.1, 2_000_000_000_u64),
+            (-0.1, 0.1, 10_000_000_000_u64),
+            (-0.1, 0.1, 100_000_000_000_u64),
+            (-0.01, 0.01, 100_000_000_000_u64),
+            (-0.001, 0.001, 100_000_000_000_u64),
+            // A few (overlapping) positions up the range
+            (0.01, 0.02, 100_000_000_000_u64),
+            (0.02, 0.03, 100_000_000_000_u64),
+            (0.03, 0.04, 100_000_000_000_u64),
+            (0.03, 0.05, 100_000_000_000_u64),
+            // A few (overlapping) positions down the range
+            (-0.02, -0.01, 100_000_000_000_u64),
+            (-0.03, -0.02, 100_000_000_000_u64),
+            (-0.04, -0.03, 100_000_000_000_u64),
+            (-0.05, -0.03, 100_000_000_000_u64),
+        ]
+        .into_iter()
+        .for_each(
+            |(price_low_offset, price_high_offset, position_liquidity)| {
+                let price_low = price_low_offset + current_price;
+                let price_high = price_high_offset + current_price;
+                let tick_low = price_to_tick(price_low);
+                let tick_high = price_to_tick(price_high);
+                let (_position_id, _tao, _alpha) = Pallet::<Test>::do_add_liquidity(
+                    netuid,
+                    &OK_COLDKEY_ACCOUNT_ID,
+                    &OK_HOTKEY_ACCOUNT_ID,
+                    tick_low,
+                    tick_high,
+                    position_liquidity,
+                )
+                .unwrap();
+            },
+        );
+
+        // All these orders are executed without swap reset
+        [
+            (OrderType::Buy, 100_000_u64, 1000.0_f64),
+            (OrderType::Sell, 100_000, 0.0001_f64),
+            (OrderType::Buy, 1_000_000, 1000.0_f64),
+            (OrderType::Sell, 1_000_000, 0.0001_f64),
+            (OrderType::Buy, 10_000_000, 1000.0_f64),
+            (OrderType::Sell, 10_000_000, 0.0001_f64),
+            (OrderType::Buy, 100_000_000, 1000.0),
+            (OrderType::Sell, 100_000_000, 0.0001),
+            (OrderType::Buy, 200_000_000, 1000.0_f64),
+            (OrderType::Sell, 200_000_000, 0.0001),
+            (OrderType::Buy, 500_000_000, 1000.0),
+            (OrderType::Sell, 500_000_000, 0.0001),
+            (OrderType::Buy, 1_000_000_000, 1000.0),
+            (OrderType::Sell, 1_000_000_000, 0.0001),
+            (OrderType::Buy, 10_000_000_000, 1000.0),
+            (OrderType::Sell, 10_000_000_000, 0.0001),
+        ]
+        .into_iter()
+        .for_each(|(order_type, order_liquidity, limit_price)| {
+            //////////////////////////////////////////////
+            // Swap
+            let sqrt_current_price = AlphaSqrtPrice::<Test>::get(netuid);
+            let current_price = (sqrt_current_price * sqrt_current_price).to_num::<f64>();
+            let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
+
+            let output_amount = match order_type {
+                OrderType::Buy => {
+                    let denom = sqrt_current_price.to_num::<f64>()
+                        * (sqrt_current_price.to_num::<f64>() * liquidity_before as f64
+                            + order_liquidity as f64);
+                    let per_order_liq = liquidity_before as f64 / denom;
+                    per_order_liq * order_liquidity as f64
+                }
+                OrderType::Sell => {
+                    let denom = liquidity_before as f64 / sqrt_current_price.to_num::<f64>()
+                        + order_liquidity as f64;
+                    let per_order_liq =
+                        sqrt_current_price.to_num::<f64>() * liquidity_before as f64 / denom;
+                    per_order_liq * order_liquidity as f64
+                }
+            };
+
+            // Do the swap
+            let sqrt_limit_price = SqrtPrice::from_num((limit_price).sqrt());
+            let swap_result = Pallet::<Test>::do_swap(
+                netuid,
+                order_type,
+                order_liquidity,
+                sqrt_limit_price,
+                false,
+            )
+            .unwrap();
+            assert_abs_diff_eq!(
+                swap_result.amount_paid_out as f64,
+                output_amount,
+                epsilon = output_amount / 10.
+            );
+
+            let tao_reserve = MockLiquidityProvider::tao_reserve(netuid.into());
+            let alpha_reserve = MockLiquidityProvider::alpha_reserve(netuid.into());
+            let output_amount = output_amount as u64;
+
+            assert!(output_amount > 0);
+
+            if alpha_reserve > order_liquidity && tao_reserve > order_liquidity {
+                let (tao_expected, alpha_expected) = match order_type {
+                    OrderType::Buy => {
+                        (tao_reserve + order_liquidity, alpha_reserve - output_amount)
+                    }
+                    OrderType::Sell => {
+                        (tao_reserve - output_amount, alpha_reserve + order_liquidity)
+                    }
+                };
+                assert_abs_diff_eq!(
+                    swap_result.new_alpha_reserve,
+                    alpha_expected,
+                    epsilon = alpha_expected / 100
+                );
+                assert_abs_diff_eq!(
+                    swap_result.new_tao_reserve,
+                    tao_expected,
+                    epsilon = tao_expected / 100
+                );
+            }
+
+            // Assert that price movement is in correct direction
+            let sqrt_current_price_after = AlphaSqrtPrice::<Test>::get(netuid);
+            let current_price_after =
+                (sqrt_current_price_after * sqrt_current_price_after).to_num::<f64>();
+            match order_type {
+                OrderType::Buy => assert!(current_price_after > current_price),
+                OrderType::Sell => assert!(current_price_after < current_price),
+            }
+        });
+
+        // Current price shouldn't be much different from the original
+        let sqrt_current_price_after = AlphaSqrtPrice::<Test>::get(netuid);
+        let current_price_after =
+            (sqrt_current_price_after * sqrt_current_price_after).to_num::<f64>();
+        assert_abs_diff_eq!(
+            current_price,
+            current_price_after,
+            epsilon = current_price / 10.
+        )
+    });
+}
+
+// cargo test --package pallet-subtensor-swap --lib -- pallet::impls::tests::test_swap_precision_edge_case --exact --show-output
+#[test]
+fn test_swap_precision_edge_case() {
+    new_test_ext().execute_with(|| {
+        let netuid = NetUid::from(123); // 123 is netuid with low edge case liquidity
+        let order_type = OrderType::Sell;
+        let liquidity = 1_000_000_000_000_000_000;
+        let tick_low = TickIndex::MIN;
+
+        let sqrt_limit_price: SqrtPrice = tick_low.try_to_sqrt_price().unwrap();
+
+        // Setup swap
+        assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
+
+        // Swap
+        let swap_result =
+            Pallet::<Test>::do_swap(netuid, order_type, liquidity, sqrt_limit_price, true).unwrap();
+
+        assert!(swap_result.amount_paid_out > 0);
+    });
+}
+
+// cargo test --package pallet-subtensor-swap --lib -- pallet::impls::tests::test_price_tick_price_roundtrip --exact --show-output
+#[test]
+fn test_price_tick_price_roundtrip() {
+    new_test_ext().execute_with(|| {
+        let netuid = NetUid::from(1);
+
+        // Setup swap
+        assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
+
+        let current_price = SqrtPrice::from_num(0.500_000_512_192_122_7);
+        let tick = TickIndex::try_from_sqrt_price(current_price).unwrap();
+
+        let round_trip_price = TickIndex::try_to_sqrt_price(&tick).unwrap();
+        assert!(round_trip_price <= current_price);
+
+        let roundtrip_tick = TickIndex::try_from_sqrt_price(round_trip_price).unwrap();
+        assert!(tick == roundtrip_tick);
+    });
+}
+
+#[test]
+fn test_convert_deltas() {
+    new_test_ext().execute_with(|| {
+        let netuid = NetUid::from(1);
+        assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
+
+        for (sqrt_price, delta_in, expected_buy, expected_sell) in [
+            (SqrtPrice::from_num(1.5), 1, 0, 2),
+            (SqrtPrice::from_num(1.5), 10000, 4444, 22500),
+            (SqrtPrice::from_num(1.5), 1000000, 444444, 2250000),
+            (
+                SqrtPrice::from_num(1.5),
+                u64::MAX,
+                2000000000000,
+                3000000000000,
+            ),
+            (
+                TickIndex::MIN.as_sqrt_price_bounded(),
+                1,
+                18406523739291577836,
+                465,
+            ),
+            (TickIndex::MIN.as_sqrt_price_bounded(), 10000, u64::MAX, 465),
+            (
+                TickIndex::MIN.as_sqrt_price_bounded(),
+                1000000,
+                u64::MAX,
+                465,
+            ),
+            (
+                TickIndex::MIN.as_sqrt_price_bounded(),
+                u64::MAX,
+                u64::MAX,
+                464,
+            ),
+            (
+                TickIndex::MAX.as_sqrt_price_bounded(),
+                1,
+                0,
+                18406523745214495085,
+            ),
+            (TickIndex::MAX.as_sqrt_price_bounded(), 10000, 0, u64::MAX),
+            (TickIndex::MAX.as_sqrt_price_bounded(), 1000000, 0, u64::MAX),
+            (
+                TickIndex::MAX.as_sqrt_price_bounded(),
+                u64::MAX,
+                2000000000000,
+                u64::MAX,
+            ),
+        ] {
+            {
+                AlphaSqrtPrice::<Test>::insert(netuid, sqrt_price);
+
+                assert_abs_diff_eq!(
+                    Pallet::<Test>::convert_deltas(netuid, OrderType::Sell, delta_in),
+                    expected_sell,
+                    epsilon = 2
+                );
+                assert_abs_diff_eq!(
+                    Pallet::<Test>::convert_deltas(netuid, OrderType::Buy, delta_in),
+                    expected_buy,
+                    epsilon = 2
+                );
+            }
+        }
+    });
+}
+
+#[test]
+fn test_user_liquidity_disabled() {
+    new_test_ext().execute_with(|| {
+        // Use a netuid above 100 since our mock enables liquidity for 0-100
+        let netuid = NetUid::from(101);
+        let tick_low = TickIndex::new_unchecked(-1000);
+        let tick_high = TickIndex::new_unchecked(1000);
+        let position_id = 1;
+        let liquidity = 1_000_000_000;
+        let liquidity_delta = 500_000_000;
+
+        assert!(!EnabledUserLiquidity::<Test>::get(netuid));
+
+        assert_noop!(
+            Swap::do_add_liquidity(
+                netuid,
+                &OK_COLDKEY_ACCOUNT_ID,
+                &OK_HOTKEY_ACCOUNT_ID,
+                tick_low,
+                tick_high,
+                liquidity
+            ),
+            Error::<Test>::UserLiquidityDisabled
+        );
+
+        assert_noop!(
+            Swap::do_remove_liquidity(netuid, &OK_COLDKEY_ACCOUNT_ID, position_id.into()),
+            Error::<Test>::UserLiquidityDisabled
+        );
+
+        assert_noop!(
+            Swap::modify_position(
+                RuntimeOrigin::signed(OK_COLDKEY_ACCOUNT_ID),
+                OK_HOTKEY_ACCOUNT_ID,
+                netuid.into(),
+                position_id,
+                liquidity_delta
+            ),
+            Error::<Test>::UserLiquidityDisabled
+        );
+
+        assert_ok!(Swap::set_enabled_user_liquidity(
+            RuntimeOrigin::root(),
+            netuid.into()
+        ));
+
+        let position_id = Swap::do_add_liquidity(
+            netuid,
+            &OK_COLDKEY_ACCOUNT_ID,
+            &OK_HOTKEY_ACCOUNT_ID,
+            tick_low,
+            tick_high,
+            liquidity,
+        )
+        .unwrap()
+        .0;
+
+        assert_ok!(Swap::do_modify_position(
+            netuid.into(),
+            &OK_COLDKEY_ACCOUNT_ID,
+            &OK_HOTKEY_ACCOUNT_ID,
+            position_id,
+            liquidity_delta,
+        ));
+
+        assert_ok!(Swap::do_remove_liquidity(
+            netuid.into(),
+            &OK_COLDKEY_ACCOUNT_ID,
+            position_id,
+        ));
+    });
+}
+
+/// Test correctness of swap fees:
+///   1. Fees are distribued to (concentrated) liquidity providers
+///
+#[test]
+fn test_swap_fee_correctness() {
+    new_test_ext().execute_with(|| {
+        let min_price = tick_to_price(TickIndex::MIN);
+        let max_price = tick_to_price(TickIndex::MAX);
+        let netuid = NetUid::from(1);
+
+        // Provide very spread liquidity at the range from min to max that matches protocol liquidity
+        let liquidity = 2_000_000_000_000_u64; // 1x of protocol liquidity
+
+        assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
+
+        // Calculate ticks
+        let tick_low = price_to_tick(min_price);
+        let tick_high = price_to_tick(max_price);
+
+        // Add user liquidity
+        let (position_id, _tao, _alpha) = Pallet::<Test>::do_add_liquidity(
+            netuid,
+            &OK_COLDKEY_ACCOUNT_ID,
+            &OK_HOTKEY_ACCOUNT_ID,
+            tick_low,
+            tick_high,
+            liquidity,
+        )
+        .unwrap();
+
+        // Swap buy and swap sell
+        Pallet::<Test>::do_swap(
+            netuid,
+            OrderType::Buy,
+            liquidity / 10,
+            u64::MAX.into(),
+            false,
+        )
+        .unwrap();
+        Pallet::<Test>::do_swap(netuid, OrderType::Sell, liquidity / 10, 0_u64.into(), false)
+            .unwrap();
+
+        // Get user position
+        let mut position =
+            Positions::<Test>::get((netuid, OK_COLDKEY_ACCOUNT_ID, position_id)).unwrap();
+        assert_eq!(position.liquidity, liquidity);
+        assert_eq!(position.tick_low, tick_low);
+        assert_eq!(position.tick_high, tick_high);
+
+        // Check that 50% of fees were credited to the position
+        let fee_rate = FeeRate::<Test>::get(NetUid::from(netuid)) as f64 / u16::MAX as f64;
+        let (actual_fee_tao, actual_fee_alpha) = position.collect_fees::<Test>();
+        let expected_fee = (fee_rate * (liquidity / 10) as f64 * 0.5) as u64;
+
+        assert_abs_diff_eq!(actual_fee_tao, expected_fee, epsilon = 1,);
+        assert_abs_diff_eq!(actual_fee_alpha, expected_fee, epsilon = 1,);
+    });
+}
+
+#[test]
+fn test_current_liquidity_updates() {
+    let netuid = NetUid::from(1);
+    let liquidity = 1_000_000_000;
+
+    // Get current price
+    let (current_price, current_price_low, current_price_high) =
+        new_test_ext().execute_with(|| {
+            assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
+            let sqrt_current_price = AlphaSqrtPrice::<Test>::get(netuid);
+            let current_price = (sqrt_current_price * sqrt_current_price).to_num::<f64>();
+            let (current_price_low, current_price_high) = get_ticked_prices_around_current_price();
+            (current_price, current_price_low, current_price_high)
+        });
+
+    // Test case: (price_low, price_high, expect_to_update)
+    [
+        // Current price is out of position range (lower), no current lq update
+        (current_price * 2., current_price * 3., false),
+        // Current price is out of position range (higher), no current lq update
+        (current_price / 3., current_price / 2., false),
+        // Current price is just below position range, no current lq update
+        (current_price_high, current_price * 3., false),
+        // Position lower edge is just below the current price, current lq updates
+        (current_price_low, current_price * 3., true),
+        // Current price is exactly at lower edge of position range, current lq updates
+        (current_price, current_price * 3., true),
+        // Current price is exactly at higher edge of position range, no current lq update
+        (current_price / 2., current_price, false),
+    ]
+    .into_iter()
+    .for_each(|(price_low, price_high, expect_to_update)| {
+        new_test_ext().execute_with(|| {
+            assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
+
+            // Calculate ticks (assuming tick math is tested separately)
+            let tick_low = price_to_tick(price_low);
+            let tick_high = price_to_tick(price_high);
+            let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
+
+            // Add liquidity
+            assert_ok!(Pallet::<Test>::do_add_liquidity(
+                netuid,
+                &OK_COLDKEY_ACCOUNT_ID,
+                &OK_HOTKEY_ACCOUNT_ID,
+                tick_low,
+                tick_high,
+                liquidity,
+            ));
+
+            // Current liquidity is updated only when price range includes the current price
+            let expected_liquidity = if (price_high > current_price) && (price_low <= current_price)
+            {
+                assert!(expect_to_update);
+                liquidity_before + liquidity
+            } else {
+                assert!(!expect_to_update);
+                liquidity_before
+            };
+
+            assert_eq!(CurrentLiquidity::<Test>::get(netuid), expected_liquidity)
+        });
+    });
+}
+
+#[test]
+fn test_rollback_works() {
+    new_test_ext().execute_with(|| {
+        let netuid = NetUid::from(1);
+
+        assert_eq!(
+            Pallet::<Test>::do_swap(netuid, OrderType::Buy, 1_000_000, u64::MAX.into(), true)
+                .unwrap(),
+            Pallet::<Test>::do_swap(netuid, OrderType::Buy, 1_000_000, u64::MAX.into(), false)
+                .unwrap()
+        );
+    })
+}

From a494d15ca044b21057b61adc36481167ae61ede8 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Mon, 2 Jun 2025 16:31:23 +0200
Subject: [PATCH 227/418] Move generic in Position to type

---
 pallets/swap/src/benchmarking.rs |  4 ++++
 pallets/swap/src/pallet/impls.rs |  7 ++++---
 pallets/swap/src/pallet/mod.rs   |  4 ++--
 pallets/swap/src/pallet/tests.rs |  2 +-
 pallets/swap/src/position.rs     | 35 ++++++++++++++++----------------
 5 files changed, 29 insertions(+), 23 deletions(-)

diff --git a/pallets/swap/src/benchmarking.rs b/pallets/swap/src/benchmarking.rs
index 117a2dd86f..566294010b 100644
--- a/pallets/swap/src/benchmarking.rs
+++ b/pallets/swap/src/benchmarking.rs
@@ -2,6 +2,8 @@
 #![allow(clippy::unwrap_used)]
 #![allow(clippy::multiple_bound_locations)]
 
+use core::marker::PhantomData;
+
 use frame_benchmarking::v2::*;
 use frame_support::traits::Get;
 use frame_system::RawOrigin;
@@ -80,6 +82,7 @@ mod benchmarks {
                 liquidity: 1000,
                 fees_tao: U64F64::from_num(0),
                 fees_alpha: U64F64::from_num(0),
+                _phantom: PhantomData,
             },
         );
 
@@ -112,6 +115,7 @@ mod benchmarks {
                 liquidity: 10000,
                 fees_tao: U64F64::from_num(0),
                 fees_alpha: U64F64::from_num(0),
+                _phantom: PhantomData,
             },
         );
 
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 4a16db553a..cfa35ae9ed 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -751,7 +751,7 @@ impl<T: Config> Pallet<T> {
         tick_low: TickIndex,
         tick_high: TickIndex,
         liquidity: u64,
-    ) -> Result<(Position, u64, u64), Error<T>> {
+    ) -> Result<(Position<T>, u64, u64), Error<T>> {
         ensure!(
             Self::count_positions(netuid, coldkey_account_id) <= T::MaxPositions::get() as usize,
             Error::<T>::MaxPositionsExceeded
@@ -777,6 +777,7 @@ impl<T: Config> Pallet<T> {
             liquidity,
             fees_tao: U64F64::saturating_from_num(0),
             fees_alpha: U64F64::saturating_from_num(0),
+            _phantom: PhantomData,
         };
 
         let current_price = AlphaSqrtPrice::<T>::get(netuid);
@@ -806,7 +807,7 @@ impl<T: Config> Pallet<T> {
         };
 
         // Collect fees and get tao and alpha amounts
-        let (fee_tao, fee_alpha) = position.collect_fees::<T>();
+        let (fee_tao, fee_alpha) = position.collect_fees();
         let current_price = AlphaSqrtPrice::<T>::get(netuid);
         let (tao, alpha) = position.to_token_amounts(current_price)?;
 
@@ -912,7 +913,7 @@ impl<T: Config> Pallet<T> {
         }
 
         // Collect fees
-        let (fee_tao, fee_alpha) = position.collect_fees::<T>();
+        let (fee_tao, fee_alpha) = position.collect_fees();
 
         // If delta brings the position liquidity below MinimumLiquidity, eliminate position and withdraw full amounts
         if (liquidity_delta < 0)
diff --git a/pallets/swap/src/pallet/mod.rs b/pallets/swap/src/pallet/mod.rs
index f59049aae6..b51a887803 100644
--- a/pallets/swap/src/pallet/mod.rs
+++ b/pallets/swap/src/pallet/mod.rs
@@ -119,13 +119,13 @@ mod pallet {
             NMapKey<Twox64Concat, T::AccountId>, // Account ID
             NMapKey<Twox64Concat, PositionId>,   // Position ID
         ),
-        Position,
+        Position<T>,
         OptionQuery,
     >;
 
     /// Position ID counter.
     #[pallet::storage]
-    pub type NextPositionId<T> = StorageValue<_, u128, ValueQuery>;
+    pub type LastPositionId<T> = StorageValue<_, u128, ValueQuery>;
 
     /// Tick index bitmap words storage
     #[pallet::storage]
diff --git a/pallets/swap/src/pallet/tests.rs b/pallets/swap/src/pallet/tests.rs
index 3cad98329e..6e0bc002f2 100644
--- a/pallets/swap/src/pallet/tests.rs
+++ b/pallets/swap/src/pallet/tests.rs
@@ -1482,7 +1482,7 @@ fn test_swap_fee_correctness() {
 
         // Check that 50% of fees were credited to the position
         let fee_rate = FeeRate::<Test>::get(NetUid::from(netuid)) as f64 / u16::MAX as f64;
-        let (actual_fee_tao, actual_fee_alpha) = position.collect_fees::<Test>();
+        let (actual_fee_tao, actual_fee_alpha) = position.collect_fees();
         let expected_fee = (fee_rate * (liquidity / 10) as f64 * 0.5) as u64;
 
         assert_abs_diff_eq!(actual_fee_tao, expected_fee, epsilon = 1,);
diff --git a/pallets/swap/src/position.rs b/pallets/swap/src/position.rs
index 8f1ef69d4d..1ab233a322 100644
--- a/pallets/swap/src/position.rs
+++ b/pallets/swap/src/position.rs
@@ -1,10 +1,12 @@
+use core::marker::PhantomData;
+
 use codec::{Decode, Encode, MaxEncodedLen};
 use frame_support::pallet_prelude::*;
 use safe_math::*;
 use substrate_fixed::types::U64F64;
 use subtensor_macros::freeze_struct;
 
-use crate::pallet::{Config, Error, FeeGlobalAlpha, FeeGlobalTao, NextPositionId};
+use crate::pallet::{Config, Error, FeeGlobalAlpha, FeeGlobalTao, LastPositionId};
 use crate::tick::TickIndex;
 use crate::{NetUid, SqrtPrice};
 
@@ -18,9 +20,10 @@ use crate::{NetUid, SqrtPrice};
 /// liquidity - position liquidity
 /// fees_tao - fees accrued by the position in quote currency (TAO)
 /// fees_alpha - fees accrued by the position in base currency (Alpha)
-#[freeze_struct("1a4924d76eb084f1")]
+#[freeze_struct("1b4be598fdbdca93")]
 #[derive(Clone, Encode, Decode, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen, Default)]
-pub struct Position {
+#[scale_info(skip_type_params(T))]
+pub struct Position<T: Config> {
     pub id: PositionId,
     pub netuid: NetUid,
     pub tick_low: TickIndex,
@@ -28,9 +31,10 @@ pub struct Position {
     pub liquidity: u64,
     pub fees_tao: U64F64,
     pub fees_alpha: U64F64,
+    pub _phantom: PhantomData<T>,
 }
 
-impl Position {
+impl<T: Config> Position<T> {
     /// Converts position to token amounts
     ///
     /// returns tuple of (TAO, Alpha)
@@ -46,21 +50,18 @@ impl Position {
     ///         tao = L * (self.sqrt_price_curr - sqrt_pa)
     ///         alpha = L * (1 / self.sqrt_price_curr - 1 / sqrt_pb)
     ///
-    pub fn to_token_amounts<T: Config>(
-        &self,
-        sqrt_price_curr: SqrtPrice,
-    ) -> Result<(u64, u64), Error<T>> {
+    pub fn to_token_amounts(&self, sqrt_price_curr: SqrtPrice) -> Result<(u64, u64), Error<T>> {
         let one = U64F64::saturating_from_num(1);
 
-        let sqrt_pa: SqrtPrice = self
+        let sqrt_pa = self
             .tick_low
             .try_to_sqrt_price()
             .map_err(|_| Error::<T>::InvalidTickRange)?;
-        let sqrt_pb: SqrtPrice = self
+        let sqrt_pb = self
             .tick_high
             .try_to_sqrt_price()
             .map_err(|_| Error::<T>::InvalidTickRange)?;
-        let liquidity_fixed: U64F64 = U64F64::saturating_from_num(self.liquidity);
+        let liquidity_fixed = U64F64::saturating_from_num(self.liquidity);
 
         Ok(if sqrt_price_curr < sqrt_pa {
             (
@@ -93,9 +94,9 @@ impl Position {
 
     /// Collect fees for a position
     /// Updates the position
-    pub fn collect_fees<T: Config>(&mut self) -> (u64, u64) {
-        let fee_tao_agg = self.fees_in_range::<T>(true);
-        let fee_alpha_agg = self.fees_in_range::<T>(false);
+    pub fn collect_fees(&mut self) -> (u64, u64) {
+        let fee_tao_agg = self.fees_in_range(true);
+        let fee_alpha_agg = self.fees_in_range(false);
 
         let mut fee_tao = fee_tao_agg.saturating_sub(self.fees_tao);
         let mut fee_alpha = fee_alpha_agg.saturating_sub(self.fees_alpha);
@@ -116,7 +117,7 @@ impl Position {
     /// Get fees in a position's range
     ///
     /// If quote flag is true, Tao is returned, otherwise alpha.
-    fn fees_in_range<T: Config>(&self, quote: bool) -> U64F64 {
+    fn fees_in_range(&self, quote: bool) -> U64F64 {
         if quote {
             FeeGlobalTao::<T>::get(self.netuid)
         } else {
@@ -136,8 +137,8 @@ pub struct PositionId(u128);
 impl PositionId {
     /// Create a new position ID
     pub fn new<T: Config>() -> Self {
-        let new = NextPositionId::<T>::get().saturating_add(1);
-        NextPositionId::<T>::put(new);
+        let new = LastPositionId::<T>::get().saturating_add(1);
+        LastPositionId::<T>::put(new);
 
         Self(new)
     }

From 36edb0dd45802a67b98e4d16f400573de3847da4 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Mon, 2 Jun 2025 16:56:00 +0200
Subject: [PATCH 228/418] Associate ActiveTickIndexManager generic with type
 instead of methods

---
 pallets/swap/src/pallet/impls.rs |  17 +--
 pallets/swap/src/tick.rs         | 190 +++++++++++++++----------------
 2 files changed, 104 insertions(+), 103 deletions(-)

diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index cfa35ae9ed..51eea61034 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -476,7 +476,7 @@ impl<T: Config> Pallet<T> {
         (match order_type {
             OrderType::Buy => {
                 let higher_tick =
-                    ActiveTickIndexManager::find_closest_higher::<T>(netuid, current_price_tick)
+                    ActiveTickIndexManager::<T>::find_closest_higher(netuid, current_price_tick)
                         .unwrap_or(TickIndex::MAX);
                 if higher_tick < TickIndex::MAX {
                     higher_tick.saturating_add(1)
@@ -486,11 +486,11 @@ impl<T: Config> Pallet<T> {
             }
             OrderType::Sell => {
                 let mut lower_tick =
-                    ActiveTickIndexManager::find_closest_lower::<T>(netuid, current_price_tick)
+                    ActiveTickIndexManager::<T>::find_closest_lower(netuid, current_price_tick)
                         .unwrap_or(TickIndex::MIN);
 
                 if current_price == roundtrip_current_price {
-                    lower_tick = ActiveTickIndexManager::find_closest_lower::<T>(
+                    lower_tick = ActiveTickIndexManager::<T>::find_closest_lower(
                         netuid,
                         lower_tick.prev().unwrap_or(TickIndex::MIN),
                     )
@@ -653,12 +653,12 @@ impl<T: Config> Pallet<T> {
     }
 
     pub fn find_closest_lower_active_tick(netuid: NetUid, index: TickIndex) -> Option<Tick> {
-        ActiveTickIndexManager::find_closest_lower::<T>(netuid, index)
+        ActiveTickIndexManager::<T>::find_closest_lower(netuid, index)
             .and_then(|ti| Ticks::<T>::get(netuid, ti))
     }
 
     pub fn find_closest_higher_active_tick(netuid: NetUid, index: TickIndex) -> Option<Tick> {
-        ActiveTickIndexManager::find_closest_higher::<T>(netuid, index)
+        ActiveTickIndexManager::<T>::find_closest_higher(netuid, index)
             .and_then(|ti| Ticks::<T>::get(netuid, ti))
     }
 
@@ -915,7 +915,8 @@ impl<T: Config> Pallet<T> {
         // Collect fees
         let (fee_tao, fee_alpha) = position.collect_fees();
 
-        // If delta brings the position liquidity below MinimumLiquidity, eliminate position and withdraw full amounts
+        // If delta brings the position liquidity below MinimumLiquidity, eliminate position and
+        // withdraw full amounts
         if (liquidity_delta < 0)
             && (position.liquidity.saturating_sub(delta_liquidity_abs) < T::MinimumLiquidity::get())
         {
@@ -980,7 +981,7 @@ impl<T: Config> Pallet<T> {
         });
 
         // Update active ticks
-        ActiveTickIndexManager::insert::<T>(netuid, tick_index);
+        ActiveTickIndexManager::<T>::insert(netuid, tick_index);
     }
 
     /// Remove liquidity at tick index.
@@ -1007,7 +1008,7 @@ impl<T: Config> Pallet<T> {
                     *maybe_tick = None;
 
                     // Update active ticks: Final liquidity is zero, remove this tick from active.
-                    ActiveTickIndexManager::remove::<T>(netuid, tick_index);
+                    ActiveTickIndexManager::<T>::remove(netuid, tick_index);
                 }
             }
         });
diff --git a/pallets/swap/src/tick.rs b/pallets/swap/src/tick.rs
index 52bb2c1a3d..5dce895113 100644
--- a/pallets/swap/src/tick.rs
+++ b/pallets/swap/src/tick.rs
@@ -209,7 +209,7 @@ impl TickIndex {
     pub fn fees_above<T: Config>(&self, netuid: NetUid, quote: bool) -> U64F64 {
         let current_tick = Self::current_bounded::<T>(netuid);
 
-        let Some(tick_index) = ActiveTickIndexManager::find_closest_lower::<T>(netuid, *self)
+        let Some(tick_index) = ActiveTickIndexManager::<T>::find_closest_lower(netuid, *self)
         else {
             return U64F64::from_num(0);
         };
@@ -232,7 +232,7 @@ impl TickIndex {
     pub fn fees_below<T: Config>(&self, netuid: NetUid, quote: bool) -> U64F64 {
         let current_tick = Self::current_bounded::<T>(netuid);
 
-        let Some(tick_index) = ActiveTickIndexManager::find_closest_lower::<T>(netuid, *self)
+        let Some(tick_index) = ActiveTickIndexManager::<T>::find_closest_lower(netuid, *self)
         else {
             return U64F64::saturating_from_num(0);
         };
@@ -473,10 +473,10 @@ impl TickIndex {
     }
 }
 
-pub struct ActiveTickIndexManager;
+pub struct ActiveTickIndexManager<T: Config>(PhantomData<T>);
 
-impl ActiveTickIndexManager {
-    pub fn insert<T: Config>(netuid: NetUid, index: TickIndex) {
+impl<T: Config> ActiveTickIndexManager<T> {
+    pub fn insert(netuid: NetUid, index: TickIndex) {
         // Check the range
         if (index < TickIndex::MIN) || (index > TickIndex::MAX) {
             return;
@@ -530,7 +530,7 @@ impl ActiveTickIndexManager {
         );
     }
 
-    pub fn remove<T: Config>(netuid: NetUid, index: TickIndex) {
+    pub fn remove(netuid: NetUid, index: TickIndex) {
         // Check the range
         if (index < TickIndex::MIN) || (index > TickIndex::MAX) {
             return;
@@ -588,15 +588,15 @@ impl ActiveTickIndexManager {
         }
     }
 
-    pub fn find_closest_lower<T: Config>(netuid: NetUid, index: TickIndex) -> Option<TickIndex> {
-        Self::find_closest::<T>(netuid, index, true)
+    pub fn find_closest_lower(netuid: NetUid, index: TickIndex) -> Option<TickIndex> {
+        Self::find_closest(netuid, index, true)
     }
 
-    pub fn find_closest_higher<T: Config>(netuid: NetUid, index: TickIndex) -> Option<TickIndex> {
-        Self::find_closest::<T>(netuid, index, false)
+    pub fn find_closest_higher(netuid: NetUid, index: TickIndex) -> Option<TickIndex> {
+        Self::find_closest(netuid, index, false)
     }
 
-    fn find_closest<T: Config>(netuid: NetUid, index: TickIndex, lower: bool) -> Option<TickIndex> {
+    fn find_closest(netuid: NetUid, index: TickIndex, lower: bool) -> Option<TickIndex> {
         // Check the range
         if (index < TickIndex::MIN) || (index > TickIndex::MAX) {
             return None;
@@ -1570,20 +1570,20 @@ mod tests {
             new_test_ext().execute_with(|| {
                 let netuid = NetUid::from(1);
 
-                ActiveTickIndexManager::insert::<Test>(netuid, TickIndex::MIN);
+                ActiveTickIndexManager::<Test>::insert(netuid, TickIndex::MIN);
 
                 assert_eq!(
-                    ActiveTickIndexManager::find_closest_lower::<Test>(netuid, TickIndex::MIN)
+                    ActiveTickIndexManager::<Test>::find_closest_lower(netuid, TickIndex::MIN)
                         .unwrap(),
                     TickIndex::MIN
                 );
                 assert_eq!(
-                    ActiveTickIndexManager::find_closest_lower::<Test>(netuid, TickIndex::MAX)
+                    ActiveTickIndexManager::<Test>::find_closest_lower(netuid, TickIndex::MAX)
                         .unwrap(),
                     TickIndex::MIN
                 );
                 assert_eq!(
-                    ActiveTickIndexManager::find_closest_lower::<Test>(
+                    ActiveTickIndexManager::<Test>::find_closest_lower(
                         netuid,
                         TickIndex::MAX.saturating_div(2)
                     )
@@ -1591,7 +1591,7 @@ mod tests {
                     TickIndex::MIN
                 );
                 assert_eq!(
-                    ActiveTickIndexManager::find_closest_lower::<Test>(
+                    ActiveTickIndexManager::<Test>::find_closest_lower(
                         netuid,
                         TickIndex::MAX.prev().unwrap()
                     )
@@ -1599,7 +1599,7 @@ mod tests {
                     TickIndex::MIN
                 );
                 assert_eq!(
-                    ActiveTickIndexManager::find_closest_lower::<Test>(
+                    ActiveTickIndexManager::<Test>::find_closest_lower(
                         netuid,
                         TickIndex::MIN.next().unwrap()
                     )
@@ -1608,50 +1608,50 @@ mod tests {
                 );
 
                 assert_eq!(
-                    ActiveTickIndexManager::find_closest_higher::<Test>(netuid, TickIndex::MIN)
+                    ActiveTickIndexManager::<Test>::find_closest_higher(netuid, TickIndex::MIN)
                         .unwrap(),
                     TickIndex::MIN
                 );
                 assert!(
-                    ActiveTickIndexManager::find_closest_higher::<Test>(netuid, TickIndex::MAX)
+                    ActiveTickIndexManager::<Test>::find_closest_higher(netuid, TickIndex::MAX)
                         .is_none()
                 );
                 assert!(
-                    ActiveTickIndexManager::find_closest_higher::<Test>(
+                    ActiveTickIndexManager::<Test>::find_closest_higher(
                         netuid,
                         TickIndex::MAX.saturating_div(2)
                     )
                     .is_none()
                 );
                 assert!(
-                    ActiveTickIndexManager::find_closest_higher::<Test>(
+                    ActiveTickIndexManager::<Test>::find_closest_higher(
                         netuid,
                         TickIndex::MAX.prev().unwrap()
                     )
                     .is_none()
                 );
                 assert!(
-                    ActiveTickIndexManager::find_closest_higher::<Test>(
+                    ActiveTickIndexManager::<Test>::find_closest_higher(
                         netuid,
                         TickIndex::MIN.next().unwrap()
                     )
                     .is_none()
                 );
 
-                ActiveTickIndexManager::insert::<Test>(netuid, TickIndex::MAX);
+                ActiveTickIndexManager::<Test>::insert(netuid, TickIndex::MAX);
 
                 assert_eq!(
-                    ActiveTickIndexManager::find_closest_lower::<Test>(netuid, TickIndex::MIN)
+                    ActiveTickIndexManager::<Test>::find_closest_lower(netuid, TickIndex::MIN)
                         .unwrap(),
                     TickIndex::MIN
                 );
                 assert_eq!(
-                    ActiveTickIndexManager::find_closest_lower::<Test>(netuid, TickIndex::MAX)
+                    ActiveTickIndexManager::<Test>::find_closest_lower(netuid, TickIndex::MAX)
                         .unwrap(),
                     TickIndex::MAX
                 );
                 assert_eq!(
-                    ActiveTickIndexManager::find_closest_lower::<Test>(
+                    ActiveTickIndexManager::<Test>::find_closest_lower(
                         netuid,
                         TickIndex::MAX.saturating_div(2)
                     )
@@ -1659,7 +1659,7 @@ mod tests {
                     TickIndex::MIN
                 );
                 assert_eq!(
-                    ActiveTickIndexManager::find_closest_lower::<Test>(
+                    ActiveTickIndexManager::<Test>::find_closest_lower(
                         netuid,
                         TickIndex::MAX.prev().unwrap()
                     )
@@ -1667,7 +1667,7 @@ mod tests {
                     TickIndex::MIN
                 );
                 assert_eq!(
-                    ActiveTickIndexManager::find_closest_lower::<Test>(
+                    ActiveTickIndexManager::<Test>::find_closest_lower(
                         netuid,
                         TickIndex::MIN.next().unwrap()
                     )
@@ -1683,15 +1683,15 @@ mod tests {
                 let active_index = TickIndex::MIN.saturating_add(10);
                 let netuid = NetUid::from(1);
 
-                ActiveTickIndexManager::insert::<Test>(netuid, active_index);
+                ActiveTickIndexManager::<Test>::insert(netuid, active_index);
 
                 assert_eq!(
-                    ActiveTickIndexManager::find_closest_lower::<Test>(netuid, active_index)
+                    ActiveTickIndexManager::<Test>::find_closest_lower(netuid, active_index)
                         .unwrap(),
                     active_index
                 );
                 assert_eq!(
-                    ActiveTickIndexManager::find_closest_lower::<Test>(
+                    ActiveTickIndexManager::<Test>::find_closest_lower(
                         netuid,
                         TickIndex::MIN.saturating_add(11)
                     )
@@ -1699,7 +1699,7 @@ mod tests {
                     active_index
                 );
                 assert_eq!(
-                    ActiveTickIndexManager::find_closest_lower::<Test>(
+                    ActiveTickIndexManager::<Test>::find_closest_lower(
                         netuid,
                         TickIndex::MIN.saturating_add(12)
                     )
@@ -1707,11 +1707,11 @@ mod tests {
                     active_index
                 );
                 assert_eq!(
-                    ActiveTickIndexManager::find_closest_lower::<Test>(netuid, TickIndex::MIN),
+                    ActiveTickIndexManager::<Test>::find_closest_lower(netuid, TickIndex::MIN),
                     None
                 );
                 assert_eq!(
-                    ActiveTickIndexManager::find_closest_lower::<Test>(
+                    ActiveTickIndexManager::<Test>::find_closest_lower(
                         netuid,
                         TickIndex::MIN.saturating_add(9)
                     ),
@@ -1719,31 +1719,31 @@ mod tests {
                 );
 
                 assert_eq!(
-                    ActiveTickIndexManager::find_closest_higher::<Test>(netuid, active_index)
+                    ActiveTickIndexManager::<Test>::find_closest_higher(netuid, active_index)
                         .unwrap(),
                     active_index
                 );
                 assert_eq!(
-                    ActiveTickIndexManager::find_closest_higher::<Test>(
+                    ActiveTickIndexManager::<Test>::find_closest_higher(
                         netuid,
                         TickIndex::MIN.saturating_add(11)
                     ),
                     None
                 );
                 assert_eq!(
-                    ActiveTickIndexManager::find_closest_higher::<Test>(
+                    ActiveTickIndexManager::<Test>::find_closest_higher(
                         netuid,
                         TickIndex::MIN.saturating_add(12)
                     ),
                     None
                 );
                 assert_eq!(
-                    ActiveTickIndexManager::find_closest_higher::<Test>(netuid, TickIndex::MIN)
+                    ActiveTickIndexManager::<Test>::find_closest_higher(netuid, TickIndex::MIN)
                         .unwrap(),
                     active_index
                 );
                 assert_eq!(
-                    ActiveTickIndexManager::find_closest_higher::<Test>(
+                    ActiveTickIndexManager::<Test>::find_closest_higher(
                         netuid,
                         TickIndex::MIN.saturating_add(9)
                     )
@@ -1759,7 +1759,7 @@ mod tests {
                 let netuid = NetUid::from(1);
 
                 (0..1000).for_each(|i| {
-                    ActiveTickIndexManager::insert::<Test>(
+                    ActiveTickIndexManager::<Test>::insert(
                         netuid,
                         TickIndex::MIN.saturating_add(i),
                     );
@@ -1768,12 +1768,12 @@ mod tests {
                 for i in 0..1000 {
                     let test_index = TickIndex::MIN.saturating_add(i);
                     assert_eq!(
-                        ActiveTickIndexManager::find_closest_lower::<Test>(netuid, test_index)
+                        ActiveTickIndexManager::<Test>::find_closest_lower(netuid, test_index)
                             .unwrap(),
                         test_index
                     );
                     assert_eq!(
-                        ActiveTickIndexManager::find_closest_higher::<Test>(netuid, test_index)
+                        ActiveTickIndexManager::<Test>::find_closest_higher(netuid, test_index)
                             .unwrap(),
                         test_index
                     );
@@ -1788,7 +1788,7 @@ mod tests {
                 let count = 1000;
 
                 for i in 0..=count {
-                    ActiveTickIndexManager::insert::<Test>(
+                    ActiveTickIndexManager::<Test>::insert(
                         netuid,
                         TickIndex::new_unchecked(i * 10),
                     );
@@ -1797,11 +1797,11 @@ mod tests {
                 for i in 1..count {
                     let tick = TickIndex::new_unchecked(i * 10);
                     assert_eq!(
-                        ActiveTickIndexManager::find_closest_lower::<Test>(netuid, tick).unwrap(),
+                        ActiveTickIndexManager::<Test>::find_closest_lower(netuid, tick).unwrap(),
                         tick
                     );
                     assert_eq!(
-                        ActiveTickIndexManager::find_closest_higher::<Test>(netuid, tick).unwrap(),
+                        ActiveTickIndexManager::<Test>::find_closest_higher(netuid, tick).unwrap(),
                         tick
                     );
                     for j in 1..=9 {
@@ -1810,17 +1810,17 @@ mod tests {
                         let prev_tick = TickIndex::new_unchecked((i - 1) * 10);
                         let next_tick = TickIndex::new_unchecked((i + 1) * 10);
                         assert_eq!(
-                            ActiveTickIndexManager::find_closest_lower::<Test>(netuid, before_tick)
+                            ActiveTickIndexManager::<Test>::find_closest_lower(netuid, before_tick)
                                 .unwrap(),
                             prev_tick
                         );
                         assert_eq!(
-                            ActiveTickIndexManager::find_closest_lower::<Test>(netuid, after_tick)
+                            ActiveTickIndexManager::<Test>::find_closest_lower(netuid, after_tick)
                                 .unwrap(),
                             tick
                         );
                         assert_eq!(
-                            ActiveTickIndexManager::find_closest_higher::<Test>(
+                            ActiveTickIndexManager::<Test>::find_closest_higher(
                                 netuid,
                                 before_tick
                             )
@@ -1828,7 +1828,7 @@ mod tests {
                             tick
                         );
                         assert_eq!(
-                            ActiveTickIndexManager::find_closest_higher::<Test>(netuid, after_tick)
+                            ActiveTickIndexManager::<Test>::find_closest_higher(netuid, after_tick)
                                 .unwrap(),
                             next_tick
                         );
@@ -1844,7 +1844,7 @@ mod tests {
                 let count = 1000;
 
                 for i in (0..=count).rev() {
-                    ActiveTickIndexManager::insert::<Test>(
+                    ActiveTickIndexManager::<Test>::insert(
                         netuid,
                         TickIndex::new_unchecked(i * 10),
                     );
@@ -1853,11 +1853,11 @@ mod tests {
                 for i in 1..count {
                     let tick = TickIndex::new_unchecked(i * 10);
                     assert_eq!(
-                        ActiveTickIndexManager::find_closest_lower::<Test>(netuid, tick).unwrap(),
+                        ActiveTickIndexManager::<Test>::find_closest_lower(netuid, tick).unwrap(),
                         tick
                     );
                     assert_eq!(
-                        ActiveTickIndexManager::find_closest_higher::<Test>(netuid, tick).unwrap(),
+                        ActiveTickIndexManager::<Test>::find_closest_higher(netuid, tick).unwrap(),
                         tick
                     );
                     for j in 1..=9 {
@@ -1867,17 +1867,17 @@ mod tests {
                         let next_tick = TickIndex::new_unchecked((i + 1) * 10);
 
                         assert_eq!(
-                            ActiveTickIndexManager::find_closest_lower::<Test>(netuid, before_tick)
+                            ActiveTickIndexManager::<Test>::find_closest_lower(netuid, before_tick)
                                 .unwrap(),
                             prev_tick
                         );
                         assert_eq!(
-                            ActiveTickIndexManager::find_closest_lower::<Test>(netuid, after_tick)
+                            ActiveTickIndexManager::<Test>::find_closest_lower(netuid, after_tick)
                                 .unwrap(),
                             tick
                         );
                         assert_eq!(
-                            ActiveTickIndexManager::find_closest_higher::<Test>(
+                            ActiveTickIndexManager::<Test>::find_closest_higher(
                                 netuid,
                                 before_tick
                             )
@@ -1885,7 +1885,7 @@ mod tests {
                             tick
                         );
                         assert_eq!(
-                            ActiveTickIndexManager::find_closest_higher::<Test>(netuid, after_tick)
+                            ActiveTickIndexManager::<Test>::find_closest_higher(netuid, after_tick)
                                 .unwrap(),
                             next_tick
                         );
@@ -1903,18 +1903,18 @@ mod tests {
                 for _ in 0..10 {
                     for i in 0..=count {
                         let tick = TickIndex::new_unchecked(i * 10);
-                        ActiveTickIndexManager::insert::<Test>(netuid, tick);
+                        ActiveTickIndexManager::<Test>::insert(netuid, tick);
                     }
 
                     for i in 1..count {
                         let tick = TickIndex::new_unchecked(i * 10);
                         assert_eq!(
-                            ActiveTickIndexManager::find_closest_lower::<Test>(netuid, tick)
+                            ActiveTickIndexManager::<Test>::find_closest_lower(netuid, tick)
                                 .unwrap(),
                             tick
                         );
                         assert_eq!(
-                            ActiveTickIndexManager::find_closest_higher::<Test>(netuid, tick)
+                            ActiveTickIndexManager::<Test>::find_closest_higher(netuid, tick)
                                 .unwrap(),
                             tick
                         );
@@ -1925,7 +1925,7 @@ mod tests {
                             let next_tick = TickIndex::new_unchecked((i + 1) * 10);
 
                             assert_eq!(
-                                ActiveTickIndexManager::find_closest_lower::<Test>(
+                                ActiveTickIndexManager::<Test>::find_closest_lower(
                                     netuid,
                                     before_tick
                                 )
@@ -1933,14 +1933,14 @@ mod tests {
                                 prev_tick
                             );
                             assert_eq!(
-                                ActiveTickIndexManager::find_closest_lower::<Test>(
+                                ActiveTickIndexManager::<Test>::find_closest_lower(
                                     netuid, after_tick
                                 )
                                 .unwrap(),
                                 tick
                             );
                             assert_eq!(
-                                ActiveTickIndexManager::find_closest_higher::<Test>(
+                                ActiveTickIndexManager::<Test>::find_closest_higher(
                                     netuid,
                                     before_tick
                                 )
@@ -1948,7 +1948,7 @@ mod tests {
                                 tick
                             );
                             assert_eq!(
-                                ActiveTickIndexManager::find_closest_higher::<Test>(
+                                ActiveTickIndexManager::<Test>::find_closest_higher(
                                     netuid, after_tick
                                 )
                                 .unwrap(),
@@ -1970,7 +1970,7 @@ mod tests {
 
                 for i in 0..=count {
                     let index = TickIndex::MIN.saturating_add(i * step);
-                    ActiveTickIndexManager::insert::<Test>(netuid, index);
+                    ActiveTickIndexManager::<Test>::insert(netuid, index);
                 }
                 for i in 1..count {
                     let index = TickIndex::MIN.saturating_add(i * step);
@@ -1979,49 +1979,49 @@ mod tests {
                     let next_minus_one = TickIndex::new_unchecked(index.get() + step - 1);
 
                     assert_eq!(
-                        ActiveTickIndexManager::find_closest_lower::<Test>(netuid, prev_index)
+                        ActiveTickIndexManager::<Test>::find_closest_lower(netuid, prev_index)
                             .unwrap(),
                         prev_index
                     );
                     assert_eq!(
-                        ActiveTickIndexManager::find_closest_lower::<Test>(netuid, index).unwrap(),
+                        ActiveTickIndexManager::<Test>::find_closest_lower(netuid, index).unwrap(),
                         index
                     );
                     assert_eq!(
-                        ActiveTickIndexManager::find_closest_lower::<Test>(netuid, next_minus_one)
+                        ActiveTickIndexManager::<Test>::find_closest_lower(netuid, next_minus_one)
                             .unwrap(),
                         index
                     );
 
                     let mid_next = TickIndex::new_unchecked(index.get() + step / 2);
                     assert_eq!(
-                        ActiveTickIndexManager::find_closest_lower::<Test>(netuid, mid_next)
+                        ActiveTickIndexManager::<Test>::find_closest_lower(netuid, mid_next)
                             .unwrap(),
                         index
                     );
 
                     assert_eq!(
-                        ActiveTickIndexManager::find_closest_higher::<Test>(netuid, index).unwrap(),
+                        ActiveTickIndexManager::<Test>::find_closest_higher(netuid, index).unwrap(),
                         index
                     );
 
                     let next_index = TickIndex::new_unchecked(index.get() + step);
                     assert_eq!(
-                        ActiveTickIndexManager::find_closest_higher::<Test>(netuid, next_index)
+                        ActiveTickIndexManager::<Test>::find_closest_higher(netuid, next_index)
                             .unwrap(),
                         next_index
                     );
 
                     let mid_next = TickIndex::new_unchecked(index.get() + step / 2);
                     assert_eq!(
-                        ActiveTickIndexManager::find_closest_higher::<Test>(netuid, mid_next)
+                        ActiveTickIndexManager::<Test>::find_closest_higher(netuid, mid_next)
                             .unwrap(),
                         next_index
                     );
 
                     let next_minus_1 = TickIndex::new_unchecked(index.get() + step - 1);
                     assert_eq!(
-                        ActiveTickIndexManager::find_closest_higher::<Test>(netuid, next_minus_1)
+                        ActiveTickIndexManager::<Test>::find_closest_higher(netuid, next_minus_1)
                             .unwrap(),
                         next_index
                     );
@@ -2030,7 +2030,7 @@ mod tests {
                         let after_index = TickIndex::new_unchecked(index.get() + j);
 
                         assert_eq!(
-                            ActiveTickIndexManager::find_closest_lower::<Test>(
+                            ActiveTickIndexManager::<Test>::find_closest_lower(
                                 netuid,
                                 before_index
                             )
@@ -2038,12 +2038,12 @@ mod tests {
                             prev_index
                         );
                         assert_eq!(
-                            ActiveTickIndexManager::find_closest_lower::<Test>(netuid, after_index)
+                            ActiveTickIndexManager::<Test>::find_closest_lower(netuid, after_index)
                                 .unwrap(),
                             index
                         );
                         assert_eq!(
-                            ActiveTickIndexManager::find_closest_higher::<Test>(
+                            ActiveTickIndexManager::<Test>::find_closest_higher(
                                 netuid,
                                 before_index
                             )
@@ -2051,7 +2051,7 @@ mod tests {
                             index
                         );
                         assert_eq!(
-                            ActiveTickIndexManager::find_closest_higher::<Test>(
+                            ActiveTickIndexManager::<Test>::find_closest_higher(
                                 netuid,
                                 after_index
                             )
@@ -2068,22 +2068,22 @@ mod tests {
             new_test_ext().execute_with(|| {
                 let netuid = NetUid::from(1);
 
-                ActiveTickIndexManager::insert::<Test>(netuid, TickIndex::MIN);
-                ActiveTickIndexManager::insert::<Test>(netuid, TickIndex::MAX);
-                ActiveTickIndexManager::remove::<Test>(netuid, TickIndex::MAX);
+                ActiveTickIndexManager::<Test>::insert(netuid, TickIndex::MIN);
+                ActiveTickIndexManager::<Test>::insert(netuid, TickIndex::MAX);
+                ActiveTickIndexManager::<Test>::remove(netuid, TickIndex::MAX);
 
                 assert_eq!(
-                    ActiveTickIndexManager::find_closest_lower::<Test>(netuid, TickIndex::MIN)
+                    ActiveTickIndexManager::<Test>::find_closest_lower(netuid, TickIndex::MIN)
                         .unwrap(),
                     TickIndex::MIN
                 );
                 assert_eq!(
-                    ActiveTickIndexManager::find_closest_lower::<Test>(netuid, TickIndex::MAX)
+                    ActiveTickIndexManager::<Test>::find_closest_lower(netuid, TickIndex::MAX)
                         .unwrap(),
                     TickIndex::MIN
                 );
                 assert_eq!(
-                    ActiveTickIndexManager::find_closest_lower::<Test>(
+                    ActiveTickIndexManager::<Test>::find_closest_lower(
                         netuid,
                         TickIndex::MAX.saturating_div(2)
                     )
@@ -2091,7 +2091,7 @@ mod tests {
                     TickIndex::MIN
                 );
                 assert_eq!(
-                    ActiveTickIndexManager::find_closest_lower::<Test>(
+                    ActiveTickIndexManager::<Test>::find_closest_lower(
                         netuid,
                         TickIndex::MAX.prev().unwrap()
                     )
@@ -2099,7 +2099,7 @@ mod tests {
                     TickIndex::MIN
                 );
                 assert_eq!(
-                    ActiveTickIndexManager::find_closest_lower::<Test>(
+                    ActiveTickIndexManager::<Test>::find_closest_lower(
                         netuid,
                         TickIndex::MIN.next().unwrap()
                     )
@@ -2108,30 +2108,30 @@ mod tests {
                 );
 
                 assert_eq!(
-                    ActiveTickIndexManager::find_closest_higher::<Test>(netuid, TickIndex::MIN)
+                    ActiveTickIndexManager::<Test>::find_closest_higher(netuid, TickIndex::MIN)
                         .unwrap(),
                     TickIndex::MIN
                 );
                 assert_eq!(
-                    ActiveTickIndexManager::find_closest_higher::<Test>(netuid, TickIndex::MAX),
+                    ActiveTickIndexManager::<Test>::find_closest_higher(netuid, TickIndex::MAX),
                     None
                 );
                 assert_eq!(
-                    ActiveTickIndexManager::find_closest_higher::<Test>(
+                    ActiveTickIndexManager::<Test>::find_closest_higher(
                         netuid,
                         TickIndex::MAX.saturating_div(2)
                     ),
                     None
                 );
                 assert_eq!(
-                    ActiveTickIndexManager::find_closest_higher::<Test>(
+                    ActiveTickIndexManager::<Test>::find_closest_higher(
                         netuid,
                         TickIndex::MAX.prev().unwrap()
                     ),
                     None
                 );
                 assert_eq!(
-                    ActiveTickIndexManager::find_closest_higher::<Test>(
+                    ActiveTickIndexManager::<Test>::find_closest_higher(
                         netuid,
                         TickIndex::MIN.next().unwrap()
                     ),
@@ -2152,14 +2152,14 @@ mod tests {
                 // Insert ticks
                 for i in 0..=count {
                     let index = TickIndex::MIN.saturating_add(i * step);
-                    ActiveTickIndexManager::insert::<Test>(netuid, index);
+                    ActiveTickIndexManager::<Test>::insert(netuid, index);
                 }
 
                 // Remove some ticks
                 for i in 1..count {
                     if i % remove_frequency == 0 {
                         let index = TickIndex::MIN.saturating_add(i * step);
-                        ActiveTickIndexManager::remove::<Test>(netuid, index);
+                        ActiveTickIndexManager::<Test>::remove(netuid, index);
                     }
                 }
 
@@ -2169,19 +2169,19 @@ mod tests {
 
                     if i % remove_frequency == 0 {
                         let lower =
-                            ActiveTickIndexManager::find_closest_lower::<Test>(netuid, index);
+                            ActiveTickIndexManager::<Test>::find_closest_lower(netuid, index);
                         let higher =
-                            ActiveTickIndexManager::find_closest_higher::<Test>(netuid, index);
+                            ActiveTickIndexManager::<Test>::find_closest_higher(netuid, index);
                         assert!(lower != Some(index));
                         assert!(higher != Some(index));
                     } else {
                         assert_eq!(
-                            ActiveTickIndexManager::find_closest_lower::<Test>(netuid, index)
+                            ActiveTickIndexManager::<Test>::find_closest_lower(netuid, index)
                                 .unwrap(),
                             index
                         );
                         assert_eq!(
-                            ActiveTickIndexManager::find_closest_higher::<Test>(netuid, index)
+                            ActiveTickIndexManager::<Test>::find_closest_higher(netuid, index)
                                 .unwrap(),
                             index
                         );

From 299d669a11190bb603567a235e5a681177fe9bbd Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Mon, 2 Jun 2025 14:38:55 -0400
Subject: [PATCH 229/418] Test for fee claiming in modify_position - in
 progress

---
 pallets/subtensor/src/tests/staking.rs | 114 ++++++++++++++++++++++++-
 pallets/swap/src/pallet/impls.rs       |   8 ++
 pallets/swap/src/pallet/mod.rs         |   2 +
 3 files changed, 123 insertions(+), 1 deletion(-)

diff --git a/pallets/subtensor/src/tests/staking.rs b/pallets/subtensor/src/tests/staking.rs
index 89d0286b0e..143f9adc47 100644
--- a/pallets/subtensor/src/tests/staking.rs
+++ b/pallets/subtensor/src/tests/staking.rs
@@ -6428,7 +6428,7 @@ fn test_swap_fees_tao_correctness() {
             netuid,
             user_alpha,
         ));
-        // Do not add fees because selling feels are in alpha
+        // Do not add fees because selling fees are in alpha
 
         // Check ending "total TAO"
         let owner_balance_after = SubtensorModule::get_coldkey_balance(&owner_coldkey);
@@ -6654,3 +6654,115 @@ fn test_default_min_stake_sufficiency() {
         assert!(current_price_after_stake > current_price_after_unstake);
     });
 }
+
+/// Test that modify_position always credits fees
+///
+#[test]
+fn test_update_position_fees() {
+    new_test_ext(1).execute_with(|| {
+        let owner_hotkey = U256::from(1);
+        let owner_coldkey = U256::from(2);
+        let coldkey = U256::from(4);
+        let amount = 1_000_000_000;
+
+        // add network
+        let netuid: u16 = add_dynamic_network(&owner_hotkey, &owner_coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&owner_coldkey, amount * 10);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, amount * 100);
+        let fee_rate = pallet_subtensor_swap::FeeRate::<Test>::get(NetUid::from(netuid)) as f64
+            / u16::MAX as f64;
+        pallet_subtensor_swap::EnabledUserLiquidity::<Test>::insert(NetUid::from(netuid), true);
+
+        // Forse-set alpha in and tao reserve to make price equal 0.25
+        let tao_reserve = U96F32::from_num(100_000_000_000_u64);
+        let alpha_in = U96F32::from_num(400_000_000_000_u64);
+        mock::setup_reserves(netuid, tao_reserve.to_num(), alpha_in.to_num());
+
+        // Get alpha for owner
+        assert_ok!(SubtensorModule::add_stake(
+            RuntimeOrigin::signed(owner_coldkey),
+            owner_hotkey,
+            netuid,
+            amount,
+        ));
+
+        // Add owner coldkey Alpha as concentrated liquidity
+        // between current price current price + 0.01
+        let current_price = <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid)
+            .to_num::<f64>()
+            + 0.0001;
+        let limit_price = current_price + 0.01;
+        let tick_low = price_to_tick(current_price);
+        let tick_high = price_to_tick(limit_price);
+        let liquidity = amount;
+
+        let (position_id, _, _) = <Test as pallet::Config>::SwapInterface::do_add_liquidity(
+            NetUid::from(netuid),
+            &owner_coldkey,
+            &owner_hotkey,
+            tick_low,
+            tick_high,
+            liquidity,
+        ).unwrap();
+
+        // Buy and then sell all alpha for user to hit owner liquidity
+        assert_ok!(SubtensorModule::add_stake(
+            RuntimeOrigin::signed(coldkey),
+            owner_hotkey,
+            netuid,
+            amount,
+        ));
+        let fees_tao = (fee_rate * amount as f64) as u64;
+
+        let user_alpha = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+            &owner_hotkey,
+            &coldkey,
+            netuid,
+        );
+        assert_ok!(SubtensorModule::remove_stake(
+            RuntimeOrigin::signed(coldkey),
+            owner_hotkey,
+            netuid,
+            user_alpha,
+        ));
+        let fees_alpha = (fee_rate * user_alpha as f64) as u64;
+
+        // Modify position - fees should be collected and paid to the owner
+        let owner_tao_before = SubtensorModule::get_coldkey_balance(&owner_coldkey);
+        let owner_alpha_before = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+            &owner_hotkey,
+            &owner_coldkey,
+            netuid,
+        );
+
+        // Make small modification - add liquidity
+        let delta = <tests::mock::Test as pallet_subtensor_swap::Config>::MinimumLiquidity::get();
+        assert_ok!(Swap::modify_position(
+            RuntimeOrigin::signed(owner_coldkey),
+            owner_hotkey,
+            netuid,
+            position_id.into(),
+            delta as i64,
+        ));
+
+        // Check ending owner TAO and alpha
+        let owner_tao_after_add = SubtensorModule::get_coldkey_balance(&owner_coldkey);
+        let owner_alpha_after_add = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+            &owner_hotkey,
+            &owner_coldkey,
+            netuid,
+        );
+
+        println!("owner_tao_before = {:?}", owner_tao_before);
+        println!("owner_alpha_before = {:?}", owner_alpha_before);
+        println!("owner_tao_after_add = {:?}", owner_tao_after_add);
+        println!("owner_alpha_after_add = {:?}", owner_alpha_after_add);
+        println!("fees_tao = {:?}", fees_tao);
+        println!("fees_alpha = {:?}", fees_alpha);
+        println!("delta = {:?}", delta);
+        delta
+
+        // // Total TAO does not change, leave some epsilon for rounding
+        // assert_abs_diff_eq!(total_tao_before, total_tao_after, epsilon = 2,);
+    });
+}
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 4a16db553a..bd3d2b1cb2 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -527,14 +527,20 @@ impl<T: Config> Pallet<T> {
         let fee_global_alpha = FeeGlobalAlpha::<T>::get(netuid);
         let fee_fixed = U64F64::saturating_from_num(fee);
 
+        println!("Adding fees. fee = {:?}", fee);
+
         match order_type {
             OrderType::Sell => {
+                println!("Alpha fees added: {:?}", fee_fixed.safe_div(liquidity_curr));
+
                 FeeGlobalAlpha::<T>::set(
                     netuid,
                     fee_global_alpha.saturating_add(fee_fixed.safe_div(liquidity_curr)),
                 );
             }
             OrderType::Buy => {
+                println!("TAO fees added: {:?}", fee_fixed.safe_div(liquidity_curr));
+
                 FeeGlobalTao::<T>::set(
                     netuid,
                     fee_global_tao.saturating_add(fee_fixed.safe_div(liquidity_curr)),
@@ -914,6 +920,8 @@ impl<T: Config> Pallet<T> {
         // Collect fees
         let (fee_tao, fee_alpha) = position.collect_fees::<T>();
 
+        println!("Fees collected: {:?}", (fee_tao, fee_alpha));
+
         // If delta brings the position liquidity below MinimumLiquidity, eliminate position and withdraw full amounts
         if (liquidity_delta < 0)
             && (position.liquidity.saturating_sub(delta_liquidity_abs) < T::MinimumLiquidity::get())
diff --git a/pallets/swap/src/pallet/mod.rs b/pallets/swap/src/pallet/mod.rs
index f59049aae6..47777f4d4b 100644
--- a/pallets/swap/src/pallet/mod.rs
+++ b/pallets/swap/src/pallet/mod.rs
@@ -439,6 +439,8 @@ mod pallet {
                 liquidity_delta,
             )?;
 
+            println!("modify result = {:?}", result);
+
             if liquidity_delta > 0 {
                 // Remove TAO and Alpha balances or fail transaction if they can't be removed exactly
                 let tao_provided = T::BalanceOps::decrease_balance(&coldkey, result.tao)?;

From 50cebaae33e10e0d089e4a9ae1704567f3574970 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Mon, 2 Jun 2025 18:33:51 -0400
Subject: [PATCH 230/418] Use integer tick index comparisons instead of price

---
 pallets/subtensor/src/tests/staking.rs |   8 +-
 pallets/swap/src/pallet/impls.rs       | 197 +++++++++++--------------
 pallets/swap/src/pallet/tests.rs       | 123 +++++++--------
 3 files changed, 146 insertions(+), 182 deletions(-)

diff --git a/pallets/subtensor/src/tests/staking.rs b/pallets/subtensor/src/tests/staking.rs
index 89d0286b0e..584ddff86e 100644
--- a/pallets/subtensor/src/tests/staking.rs
+++ b/pallets/subtensor/src/tests/staking.rs
@@ -4032,7 +4032,7 @@ fn test_max_amount_add_dynamic() {
                     <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid)
                         .to_num::<f64>(),
                     expected_price.to_num::<f64>(),
-                    epsilon = expected_price.to_num::<f64>() / 1_000_000_000_f64
+                    epsilon = expected_price.to_num::<f64>() / 1_000_f64
                 );
             }
 
@@ -4150,8 +4150,8 @@ fn test_max_amount_remove_dynamic() {
             (10_000_000_000, 10_000_000_000, 0, Ok(u64::MAX)),
             // Low bounds (numbers are empirical, it is only important that result
             // is sharply decreasing when limit price increases)
-            (1_000, 1_000, 0, Err(Error::<Test>::ZeroMaxStakeAmount)),
-            (1_001, 1_001, 0, Ok(4_307_770_117)),
+            (1_000, 1_000, 0, Ok(u64::MAX)),
+            (1_001, 1_001, 0, Ok(u64::MAX)),
             (1_001, 1_001, 1, Ok(31_715)),
             (1_001, 1_001, 2, Ok(22_426)),
             (1_001, 1_001, 1_001, Ok(1_000)),
@@ -4805,7 +4805,7 @@ fn test_add_stake_limit_ok() {
         assert_abs_diff_eq!(
             exp_price.to_num::<f64>(),
             current_price.to_num::<f64>(),
-            epsilon = 0.0001,
+            epsilon = 0.001,
         );
     });
 }
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 4a16db553a..0a0d444807 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -25,14 +25,19 @@ struct SwapStep<T: frame_system::Config> {
     // Input parameters
     netuid: NetUid,
     order_type: OrderType,
-    sqrt_price_limit: SqrtPrice,
 
     // Computed values
-    current_price: U64F64,
     current_liquidity: U64F64,
-    sqrt_price_edge: SqrtPrice,
     possible_delta_in: u64,
-    sqrt_price_target: SqrtPrice,
+
+    // Ticks and prices (current, limit, edge, target)
+    target_sqrt_price: SqrtPrice,
+    limit_sqrt_price: SqrtPrice,
+    current_sqrt_price: SqrtPrice,
+    edge_sqrt_price: SqrtPrice,
+    target_tick: TickIndex,
+    limit_tick: TickIndex,
+    edge_tick: TickIndex,
 
     // Result values
     action: SwapStepAction,
@@ -50,38 +55,43 @@ impl<T: Config> SwapStep<T> {
         netuid: NetUid,
         order_type: OrderType,
         amount_remaining: u64,
-        sqrt_price_limit: SqrtPrice,
+        limit_sqrt_price: SqrtPrice,
     ) -> Self {
-        let current_price = AlphaSqrtPrice::<T>::get(netuid);
-        let current_liquidity = Pallet::<T>::current_liquidity_safe(netuid);
-        let sqrt_price_edge = Pallet::<T>::sqrt_price_edge(netuid, current_price, order_type);
+        // Calculate prices and ticks
+        let current_tick = CurrentTick::<T>::get(netuid);
+        let current_sqrt_price = Pallet::<T>::current_price_sqrt(netuid);
+        let edge_tick = Pallet::<T>::tick_edge(netuid, current_tick, order_type);
+        let edge_sqrt_price = edge_tick.as_sqrt_price_bounded();
 
         let fee = Pallet::<T>::calculate_fee_amount(netuid, amount_remaining);
         let possible_delta_in = amount_remaining.saturating_sub(fee);
 
-        // println!("SwapStep::new order_type = {:?}", order_type);
-        // println!("SwapStep::new sqrt_price_limit = {:?}", sqrt_price_limit);
-
         // Target price and quantities
-        let sqrt_price_target = Pallet::<T>::sqrt_price_target(
+        let current_liquidity = Pallet::<T>::current_liquidity_safe(netuid);
+        let target_sqrt_price = Pallet::<T>::sqrt_price_target(
             order_type,
             current_liquidity,
-            current_price,
+            current_sqrt_price,
             possible_delta_in,
         );
+        let target_tick = TickIndex::from_sqrt_price_bounded(target_sqrt_price);
+        let limit_tick = TickIndex::from_sqrt_price_bounded(limit_sqrt_price);
 
         Self {
             netuid,
             order_type,
-            sqrt_price_limit,
-            current_price,
-            current_liquidity,
-            sqrt_price_edge,
+            target_sqrt_price,
+            limit_sqrt_price,
+            current_sqrt_price,
+            edge_sqrt_price,
+            target_tick,
+            limit_tick,
+            edge_tick,
             possible_delta_in,
-            sqrt_price_target,
+            current_liquidity,
             action: SwapStepAction::Stop,
             delta_in: 0,
-            final_price: sqrt_price_target,
+            final_price: target_sqrt_price,
             fee,
             _phantom: PhantomData,
         }
@@ -93,15 +103,15 @@ impl<T: Config> SwapStep<T> {
         self.process_swap()
     }
 
-    /// Returns True if price1 is closer to the current price than price2
+    /// Returns True if tick1 is closer to the current tick than tick2
     /// in terms of order direction.
-    ///    For buying:  price1 <= price2
-    ///    For selling: price1 >= price2
+    ///    For buying:  tick1 <= tick2
+    ///    For selling: tick1 >= tick2
     ///
-    fn price_is_closer(&self, price1: &SqrtPrice, price2: &SqrtPrice) -> bool {
+    fn tick_is_closer(&self, tick1: &TickIndex, tick2: &TickIndex) -> bool {
         match self.order_type {
-            OrderType::Buy => price1 <= price2,
-            OrderType::Sell => price1 >= price2,
+            OrderType::Buy => tick1 <= tick2,
+            OrderType::Sell => tick1 >= tick2,
         }
     }
 
@@ -111,31 +121,28 @@ impl<T: Config> SwapStep<T> {
 
         // Calculate the stopping price: The price at which we either reach the limit price,
         // exchange the full amount, or reach the edge price.
-        if self.price_is_closer(&self.sqrt_price_target, &self.sqrt_price_limit)
-            && self.price_is_closer(&self.sqrt_price_target, &self.sqrt_price_edge)
+        if self.tick_is_closer(&self.target_tick, &self.limit_tick)
+            && self.tick_is_closer(&self.target_tick, &self.edge_tick)
         {
             // Case 1. target_quantity is the lowest
             // The trade completely happens within one tick, no tick crossing happens.
             self.action = SwapStepAction::Stop;
-            self.final_price = self.sqrt_price_target;
+            self.final_price = self.target_sqrt_price;
             self.delta_in = self.possible_delta_in;
-            // println!("Case 1. Delta in = {:?}", self.delta_in);
-        } else if self.price_is_closer(&self.sqrt_price_limit, &self.sqrt_price_target)
-            && self.price_is_closer(&self.sqrt_price_limit, &self.sqrt_price_edge)
+        } else if self.tick_is_closer(&self.limit_tick, &self.target_tick)
+            && self.tick_is_closer(&self.limit_tick, &self.edge_tick)
         {
             // Case 2. lim_quantity is the lowest
             // The trade also completely happens within one tick, no tick crossing happens.
             self.action = SwapStepAction::Stop;
-            self.final_price = self.sqrt_price_limit;
+            self.final_price = self.limit_sqrt_price;
             self.delta_in = Self::delta_in(
                 self.order_type,
                 self.current_liquidity,
-                self.current_price,
-                self.sqrt_price_limit,
+                self.current_sqrt_price,
+                self.limit_sqrt_price,
             );
             recalculate_fee = true;
-            // println!("Case 2. Delta in = {:?}", self.delta_in);
-            // println!("Case 2. sqrt_price_limit = {:?}", self.sqrt_price_limit);
         } else {
             // Case 3. edge_quantity is the lowest
             // Tick crossing is likely
@@ -143,12 +150,11 @@ impl<T: Config> SwapStep<T> {
             self.delta_in = Self::delta_in(
                 self.order_type,
                 self.current_liquidity,
-                self.current_price,
-                self.sqrt_price_edge,
+                self.current_sqrt_price,
+                self.edge_sqrt_price,
             );
-            self.final_price = self.sqrt_price_edge;
+            self.final_price = self.edge_sqrt_price;
             recalculate_fee = true;
-            // println!("Case 3. Delta in = {:?}", self.delta_in);
         }
 
         // Because on step creation we calculate fee off the total amount, we might need to recalculate it
@@ -165,13 +171,12 @@ impl<T: Config> SwapStep<T> {
         // Now correct the action if we stopped exactly at the edge no matter what was the case above
         // Because order type buy moves the price up and tick semi-open interval doesn't include its right
         // point, we cross on buys and stop on sells.
-        let natural_reason_stop_price =
-            if self.price_is_closer(&self.sqrt_price_limit, &self.sqrt_price_target) {
-                self.sqrt_price_limit
-            } else {
-                self.sqrt_price_target
-            };
-        if natural_reason_stop_price == self.sqrt_price_edge {
+        let natural_reason_stop_tick = if self.tick_is_closer(&self.limit_tick, &self.target_tick) {
+            self.limit_tick
+        } else {
+            self.target_tick
+        };
+        if natural_reason_stop_tick == self.edge_tick {
             self.action = match self.order_type {
                 OrderType::Buy => SwapStepAction::Crossing,
                 OrderType::Sell => SwapStepAction::Stop,
@@ -181,9 +186,6 @@ impl<T: Config> SwapStep<T> {
 
     /// Process a single step of a swap
     fn process_swap(&self) -> Result<SwapStepResult, Error<T>> {
-        // println!("Executing swap step. order_type = {:?}", self.order_type);
-        // println!("Executing swap step. delta_in = {:?}", self.delta_in);
-
         // Hold the fees
         Pallet::<T>::add_fees(self.netuid, self.order_type, self.fee);
         let delta_out = Pallet::<T>::convert_deltas(self.netuid, self.order_type, self.delta_in);
@@ -229,7 +231,7 @@ impl<T: Config> SwapStep<T> {
     fn delta_in(
         order_type: OrderType,
         liquidity_curr: U64F64,
-        sqrt_price_curr: U64F64,
+        sqrt_price_curr: SqrtPrice,
         sqrt_price_target: SqrtPrice,
     ) -> u64 {
         let one = U64F64::saturating_from_num(1);
@@ -251,21 +253,28 @@ impl<T: Config> Pallet<T> {
     pub fn current_price(netuid: NetUid) -> U96F32 {
         match T::SubnetInfo::mechanism(netuid.into()) {
             1 => {
-                let sqrt_price = AlphaSqrtPrice::<T>::get(NetUid::from(netuid));
-                let tao_reserve = T::SubnetInfo::tao_reserve(netuid.into());
-                let alpha_reserve = T::SubnetInfo::alpha_reserve(netuid.into());
-
-                if sqrt_price == 0 && tao_reserve > 0 && alpha_reserve > 0 {
-                    U96F32::saturating_from_num(tao_reserve)
-                        .saturating_div(U96F32::saturating_from_num(alpha_reserve))
-                } else {
+                if SwapV3Initialized::<T>::get(netuid) {
+                    let sqrt_price = AlphaSqrtPrice::<T>::get(netuid);
                     U96F32::saturating_from_num(sqrt_price.saturating_mul(sqrt_price))
+                } else {
+                    let tao_reserve = T::SubnetInfo::tao_reserve(netuid.into());
+                    let alpha_reserve = T::SubnetInfo::alpha_reserve(netuid.into());
+                    if alpha_reserve > 0 {
+                        U96F32::saturating_from_num(tao_reserve)
+                            .saturating_div(U96F32::saturating_from_num(alpha_reserve))
+                    } else {
+                        U96F32::saturating_from_num(0)
+                    }
                 }
             }
             _ => U96F32::saturating_from_num(1),
         }
     }
 
+    pub fn current_price_sqrt(netuid: NetUid) -> SqrtPrice {
+        AlphaSqrtPrice::<T>::get(netuid)
+    }
+
     // initializes V3 swap for a subnet if needed
     pub(super) fn maybe_initialize_v3(netuid: NetUid) -> Result<(), Error<T>> {
         if SwapV3Initialized::<T>::get(netuid) {
@@ -443,40 +452,17 @@ impl<T: Config> Pallet<T> {
         })
     }
 
-    /// Get the square root price at the current tick edge for the given direction (order type) If
-    /// order type is Buy, then price edge is the high tick bound price, otherwise it is the low
-    /// tick bound price.
+    /// Get the tick at the current tick edge for the given direction (order type) If
+    /// order type is Buy, then edge tick is the high tick, otherwise it is the low
+    /// tick.
     ///
     /// If anything is wrong with tick math and it returns Err, we just abort the deal, i.e. return
     /// the edge that is impossible to execute
-    fn sqrt_price_edge(netuid: NetUid, current_price: U64F64, order_type: OrderType) -> SqrtPrice {
-        // Current price falls into a tick that may or may not be active. This tick represents
-        // the set of prices [tick_min_price, tick_max_price) (excluding the tick_max_price point).
-        //
-        // If this tick is active:
-        //    the lower edge (for sell order) is the tick_min_price,
-        //    the higher edge (for buy order) is the tick_max_price
-        //
-        // If this tick is not active:
-        //    the lower edge (for sell order) is the lower active tick low price
-        //    the higher edge (for buy order) is the higher active tick low price
-        //
-
-        let fallback_tick = match order_type {
-            OrderType::Buy => TickIndex::MIN,
-            OrderType::Sell => TickIndex::MAX,
-        };
-
-        let current_price_tick =
-            TickIndex::try_from_sqrt_price(current_price).unwrap_or(fallback_tick);
-        let roundtrip_current_price = current_price_tick
-            .try_to_sqrt_price()
-            .unwrap_or(SqrtPrice::from_num(0));
-
-        (match order_type {
+    fn tick_edge(netuid: NetUid, current_tick: TickIndex, order_type: OrderType) -> TickIndex {
+        match order_type {
             OrderType::Buy => {
                 let higher_tick =
-                    ActiveTickIndexManager::find_closest_higher::<T>(netuid, current_price_tick)
+                    ActiveTickIndexManager::find_closest_higher::<T>(netuid, current_tick)
                         .unwrap_or(TickIndex::MAX);
                 if higher_tick < TickIndex::MAX {
                     higher_tick.saturating_add(1)
@@ -486,21 +472,14 @@ impl<T: Config> Pallet<T> {
             }
             OrderType::Sell => {
                 let mut lower_tick =
-                    ActiveTickIndexManager::find_closest_lower::<T>(netuid, current_price_tick)
+                    ActiveTickIndexManager::find_closest_lower::<T>(netuid, current_tick)
                         .unwrap_or(TickIndex::MIN);
-
-                if current_price == roundtrip_current_price {
-                    lower_tick = ActiveTickIndexManager::find_closest_lower::<T>(
-                        netuid,
-                        lower_tick.prev().unwrap_or(TickIndex::MIN),
-                    )
-                    .unwrap_or(TickIndex::MIN);
+                if lower_tick == current_tick {
+                    lower_tick = lower_tick.prev().unwrap_or(TickIndex::MIN);
                 }
                 lower_tick
             }
-        })
-        .try_to_sqrt_price()
-        .unwrap_or(SqrtPrice::from_num(0))
+        }
     }
 
     /// Calculate fee amount
@@ -554,7 +533,7 @@ impl<T: Config> Pallet<T> {
         }
 
         let liquidity_curr = SqrtPrice::saturating_from_num(CurrentLiquidity::<T>::get(netuid));
-        let sqrt_price_curr = AlphaSqrtPrice::<T>::get(netuid);
+        let sqrt_price_curr = Pallet::<T>::current_price_sqrt(netuid);
         let delta_fixed = SqrtPrice::saturating_from_num(delta_in);
 
         // Calculate result based on order type with proper fixed-point math
@@ -597,7 +576,7 @@ impl<T: Config> Pallet<T> {
     fn sqrt_price_target(
         order_type: OrderType,
         liquidity_curr: U64F64,
-        sqrt_price_curr: U64F64,
+        sqrt_price_curr: SqrtPrice,
         delta_in: u64,
     ) -> SqrtPrice {
         let delta_fixed = U64F64::saturating_from_num(delta_in);
@@ -779,8 +758,8 @@ impl<T: Config> Pallet<T> {
             fees_alpha: U64F64::saturating_from_num(0),
         };
 
-        let current_price = AlphaSqrtPrice::<T>::get(netuid);
-        let (tao, alpha) = position.to_token_amounts(current_price)?;
+        let current_price_sqrt = Pallet::<T>::current_price_sqrt(netuid);
+        let (tao, alpha) = position.to_token_amounts(current_price_sqrt)?;
 
         SwapV3Initialized::<T>::set(netuid, true);
 
@@ -807,8 +786,8 @@ impl<T: Config> Pallet<T> {
 
         // Collect fees and get tao and alpha amounts
         let (fee_tao, fee_alpha) = position.collect_fees::<T>();
-        let current_price = AlphaSqrtPrice::<T>::get(netuid);
-        let (tao, alpha) = position.to_token_amounts(current_price)?;
+        let current_price_sqrt = Pallet::<T>::current_price_sqrt(netuid);
+        let (tao, alpha) = position.to_token_amounts(current_price_sqrt)?;
 
         // Update liquidity at position ticks
         Self::remove_liquidity_at_index(netuid, position.tick_low, position.liquidity, false);
@@ -859,7 +838,7 @@ impl<T: Config> Pallet<T> {
         let mut delta_liquidity_abs = liquidity_delta.unsigned_abs();
 
         // Determine the effective price for token calculations
-        let current_price = AlphaSqrtPrice::<T>::get(netuid);
+        let current_price_sqrt = Pallet::<T>::current_price_sqrt(netuid);
         let sqrt_pa: SqrtPrice = position
             .tick_low
             .try_to_sqrt_price()
@@ -868,9 +847,9 @@ impl<T: Config> Pallet<T> {
             .tick_high
             .try_to_sqrt_price()
             .map_err(|_| Error::<T>::InvalidTickRange)?;
-        let sqrt_price_box = if current_price < sqrt_pa {
+        let sqrt_price_box = if current_price_sqrt < sqrt_pa {
             sqrt_pa
-        } else if current_price > sqrt_pb {
+        } else if current_price_sqrt > sqrt_pb {
             sqrt_pb
         } else {
             // Update current liquidity if price is in range
@@ -880,7 +859,7 @@ impl<T: Config> Pallet<T> {
                 CurrentLiquidity::<T>::get(netuid).saturating_sub(delta_liquidity_abs)
             };
             CurrentLiquidity::<T>::set(netuid, new_liquidity_curr);
-            current_price
+            current_price_sqrt
         };
 
         // Calculate token amounts for the liquidity change
diff --git a/pallets/swap/src/pallet/tests.rs b/pallets/swap/src/pallet/tests.rs
index 3cad98329e..a52611af01 100644
--- a/pallets/swap/src/pallet/tests.rs
+++ b/pallets/swap/src/pallet/tests.rs
@@ -6,6 +6,7 @@ use approx::assert_abs_diff_eq;
 use frame_support::{assert_err, assert_noop, assert_ok};
 use sp_arithmetic::helpers_128bit;
 use sp_runtime::DispatchError;
+use substrate_fixed::types::U96F32;
 
 use super::*;
 use crate::{NetUid, OrderType, SqrtPrice, mock::*};
@@ -40,27 +41,20 @@ fn get_ticked_prices_around_current_price() -> (f64, f64) {
     // Get current price, ticks around it, and prices on the tick edges for test cases
     let netuid = NetUid::from(1);
     assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
-    let current_price_sqrt = AlphaSqrtPrice::<Test>::get(netuid);
-    let tick_index_for_current_price_low =
-        TickIndex::try_from_sqrt_price(current_price_sqrt).unwrap();
-    let tick_index_for_current_price_high = tick_index_for_current_price_low
-        .next()
-        .unwrap()
-        .next()
-        .unwrap();
-
-    // Low and high prices that match to a lower and higher tick that doesn't contain the current
-    // price
-    let current_price_low_sqrt = TickIndex::try_to_sqrt_price(&tick_index_for_current_price_low)
-        .unwrap()
-        .to_num::<f64>();
-    let current_price_high_sqrt = TickIndex::try_to_sqrt_price(&tick_index_for_current_price_high)
-        .unwrap()
-        .to_num::<f64>();
-    let current_price_low = current_price_low_sqrt * current_price_low_sqrt;
-    let current_price_high = current_price_high_sqrt * current_price_high_sqrt;
-
-    (current_price_low, current_price_high)
+    let current_tick = CurrentTick::<Test>::get(netuid);
+
+    // Low and high prices that match to a lower and higher tick that doesn't contain the current price
+    let current_price_low_sqrt = current_tick.as_sqrt_price_bounded();
+    let current_price_high_sqrt = current_tick.next().unwrap().as_sqrt_price_bounded();
+    let current_price_low =
+        U96F32::saturating_from_num(current_price_low_sqrt * current_price_low_sqrt);
+    let current_price_high =
+        U96F32::saturating_from_num(current_price_high_sqrt * current_price_high_sqrt);
+
+    (
+        current_price_low.to_num::<f64>(),
+        current_price_high.to_num::<f64>() + 0.000000001,
+    )
 }
 
 // this function is used to convert tick index NON-SQRT (!) price. it's only utility for
@@ -216,9 +210,10 @@ fn test_add_liquidity_basic() {
         let min_price = tick_to_price(TickIndex::MIN);
         let max_price = tick_to_price(TickIndex::MAX);
         let max_tick = price_to_tick(max_price);
-        let current_price = 0.25;
         assert_eq!(max_tick, TickIndex::MAX);
 
+        assert_ok!(Pallet::<Test>::maybe_initialize_v3(NetUid::from(1)));
+        let current_price = Pallet::<Test>::current_price(NetUid::from(1)).to_num::<f64>();
         let (current_price_low, current_price_high) = get_ticked_prices_around_current_price();
 
         // As a user add liquidity with all possible corner cases
@@ -329,7 +324,7 @@ fn test_add_liquidity_basic() {
 
                 // Current liquidity is updated only when price range includes the current price
                 let expected_liquidity =
-                    if (price_high >= current_price) && (price_low <= current_price) {
+                    if (price_high > current_price) && (price_low <= current_price) {
                         liquidity_before + liquidity
                     } else {
                         liquidity_before
@@ -370,7 +365,7 @@ fn test_add_liquidity_out_of_bounds() {
         ]
         .into_iter()
         .enumerate()
-        .map(|(n, v)| (NetUid::from(n as u16), v.0, v.1, v.2))
+        .map(|(n, v)| (NetUid::from(n as u16 + 1), v.0, v.1, v.2))
         .for_each(|(netuid, tick_low, tick_high, liquidity)| {
             assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
 
@@ -406,7 +401,7 @@ fn test_add_liquidity_over_balance() {
         ]
         .into_iter()
         .enumerate()
-        .map(|(n, v)| (NetUid::from(n as u16), v.0, v.1, v.2))
+        .map(|(n, v)| (NetUid::from(n as u16 + 1), v.0, v.1, v.2))
         .for_each(|(netuid, price_low, price_high, liquidity)| {
             // Calculate ticks
             let tick_low = price_to_tick(price_low);
@@ -479,7 +474,7 @@ fn test_remove_liquidity_basic() {
         ]
         .into_iter()
         .enumerate()
-        .map(|(n, v)| (NetUid::from(n as u16), v.0, v.1, v.2, v.3, v.4))
+        .map(|(n, v)| (NetUid::from(n as u16 + 1), v.0, v.1, v.2, v.3, v.4))
         .for_each(|(netuid, price_low, price_high, liquidity, tao, alpha)| {
             // Calculate ticks (assuming tick math is tested separately)
             let tick_low = price_to_tick(price_low);
@@ -587,7 +582,7 @@ fn test_modify_position_basic() {
         ]
         .into_iter()
         .enumerate()
-        .map(|(n, v)| (NetUid::from(n as u16), v.0, v.1, v.2, v.3))
+        .map(|(n, v)| (NetUid::from(n as u16 + 1), v.0, v.1, v.2, v.3))
         .for_each(|(netuid, price_low, price_high, liquidity, alpha)| {
             // Calculate ticks (assuming tick math is tested separately)
             let tick_low = price_to_tick(price_low);
@@ -677,7 +672,7 @@ fn test_swap_basic() {
         ]
         .into_iter()
         .enumerate()
-        .map(|(n, v)| (NetUid::from(n as u16), v.0, v.1, v.2, v.3))
+        .map(|(n, v)| (NetUid::from(n as u16 + 1), v.0, v.1, v.2, v.3))
         .for_each(
             |(netuid, order_type, liquidity, limit_price, output_amount)| {
                 // Consumed liquidity ticks
@@ -694,8 +689,7 @@ fn test_swap_basic() {
                 let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
 
                 // Get current price
-                let sqrt_current_price = AlphaSqrtPrice::<Test>::get(netuid);
-                let current_price = (sqrt_current_price * sqrt_current_price).to_num::<f64>();
+                let current_price = Pallet::<Test>::current_price(netuid);
 
                 // Swap
                 let sqrt_limit_price = SqrtPrice::from_num((limit_price).sqrt());
@@ -784,12 +778,11 @@ fn test_swap_basic() {
                 assert_eq!(CurrentLiquidity::<Test>::get(netuid), liquidity_before);
 
                 // Assert that price movement is in correct direction
-                let sqrt_current_price_after = AlphaSqrtPrice::<Test>::get(netuid);
-                let current_price_after =
-                    (sqrt_current_price_after * sqrt_current_price_after).to_num::<f64>();
+                let sqrt_current_price_after = Pallet::<Test>::current_price_sqrt(netuid);
+                let current_price_after = Pallet::<Test>::current_price(netuid);
                 match order_type {
-                    OrderType::Buy => assert!(current_price_after > current_price),
-                    OrderType::Sell => assert!(current_price_after < current_price),
+                    OrderType::Buy => assert!(current_price_after >= current_price),
+                    OrderType::Sell => assert!(current_price_after <= current_price),
                 }
 
                 // Assert that current tick is updated
@@ -809,16 +802,17 @@ fn test_swap_single_position() {
     let min_price = tick_to_price(TickIndex::MIN);
     let max_price = tick_to_price(TickIndex::MAX);
     let max_tick = price_to_tick(max_price);
-    let current_price = 0.25;
     let netuid = NetUid(1);
     assert_eq!(max_tick, TickIndex::MAX);
 
     let mut current_price_low = 0_f64;
     let mut current_price_high = 0_f64;
+    let mut current_price = 0_f64;
     new_test_ext().execute_with(|| {
         let (low, high) = get_ticked_prices_around_current_price();
         current_price_low = low;
         current_price_high = high;
+        current_price = Pallet::<Test>::current_price(netuid).to_num::<f64>();
     });
 
     // Current price is 0.25
@@ -861,22 +855,18 @@ fn test_swap_single_position() {
             // Inner part of test case is Order: (order_type, order_liquidity, limit_price)
             // order_liquidity is represented as a fraction of position_liquidity
             [
-                // (OrderType::Buy, 0.0001, 1000.0_f64),
-                // (OrderType::Sell, 0.0001, 0.0001_f64),
-                // (OrderType::Buy, 0.001, 1000.0_f64),
-                // (OrderType::Sell, 0.001, 0.0001_f64),
-                // (OrderType::Buy, 0.01, 1000.0_f64),
-                // (OrderType::Sell, 0.01, 0.0001_f64),
+                (OrderType::Buy, 0.0001, 1000.0_f64),
+                (OrderType::Sell, 0.0001, 0.0001_f64),
+                (OrderType::Buy, 0.001, 1000.0_f64),
+                (OrderType::Sell, 0.001, 0.0001_f64),
+                (OrderType::Buy, 0.01, 1000.0_f64),
+                (OrderType::Sell, 0.01, 0.0001_f64),
                 (OrderType::Buy, 0.1, 1000.0_f64),
                 (OrderType::Sell, 0.1, 0.0001),
-                // (OrderType::Buy, 0.2, 1000.0_f64),
-                // (OrderType::Sell, 0.2, 0.0001),
-                // (OrderType::Buy, 0.5, 1000.0),
-                // (OrderType::Sell, 0.5, 0.0001),
-                // (OrderType::Buy, 0.9999, 1000.0),
-                // (OrderType::Sell, 0.9999, 0.0001),
-                // (OrderType::Buy, 1.0, 1000.0),
-                // (OrderType::Sell, 1.0, 0.0001),
+                (OrderType::Buy, 0.2, 1000.0_f64),
+                (OrderType::Sell, 0.2, 0.0001),
+                (OrderType::Buy, 0.5, 1000.0),
+                (OrderType::Sell, 0.5, 0.0001),
             ]
             .into_iter()
             .for_each(|(order_type, order_liquidity_fraction, limit_price)| {
@@ -889,8 +879,9 @@ fn test_swap_single_position() {
                     let protocol_liquidity = (tao_reserve as f64 * alpha_reserve as f64).sqrt();
 
                     // Add liquidity
-                    let sqrt_current_price = AlphaSqrtPrice::<Test>::get(netuid);
-                    let current_price = (sqrt_current_price * sqrt_current_price).to_num::<f64>();
+                    let current_price = Pallet::<Test>::current_price(netuid).to_num::<f64>();
+                    let sqrt_current_price =
+                        Pallet::<Test>::current_price_sqrt(netuid).to_num::<f64>();
 
                     let price_low = price_low_offset + current_price;
                     let price_high = price_high_offset + current_price;
@@ -932,19 +923,16 @@ fn test_swap_single_position() {
 
                     let output_amount = match order_type {
                         OrderType::Buy => {
-                            let denom = sqrt_current_price.to_num::<f64>()
-                                * (sqrt_current_price.to_num::<f64>() * liquidity_before as f64
-                                    + order_liquidity);
+                            let denom = sqrt_current_price
+                                * (sqrt_current_price * liquidity_before as f64 + order_liquidity);
                             let per_order_liq = liquidity_before as f64 / denom;
                             per_order_liq * order_liquidity
                         }
                         OrderType::Sell => {
-                            let denom = liquidity_before as f64
-                                / sqrt_current_price.to_num::<f64>()
-                                + order_liquidity;
-                            let per_order_liq = sqrt_current_price.to_num::<f64>()
-                                * liquidity_before as f64
-                                / denom;
+                            let denom =
+                                liquidity_before as f64 / sqrt_current_price + order_liquidity;
+                            let per_order_liq =
+                                sqrt_current_price * liquidity_before as f64 / denom;
                             per_order_liq * order_liquidity
                         }
                     };
@@ -991,9 +979,7 @@ fn test_swap_single_position() {
                     }
 
                     // Assert that price movement is in correct direction
-                    let sqrt_current_price_after = AlphaSqrtPrice::<Test>::get(netuid);
-                    let current_price_after =
-                        (sqrt_current_price_after * sqrt_current_price_after).to_num::<f64>();
+                    let current_price_after = Pallet::<Test>::current_price(netuid);
                     match order_type {
                         OrderType::Buy => assert!(current_price_after > current_price),
                         OrderType::Sell => assert!(current_price_after < current_price),
@@ -1083,8 +1069,7 @@ fn test_swap_multiple_positions() {
         assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
 
         // Add liquidity
-        let sqrt_current_price = AlphaSqrtPrice::<Test>::get(netuid);
-        let current_price = (sqrt_current_price * sqrt_current_price).to_num::<f64>();
+        let current_price = Pallet::<Test>::current_price(netuid).to_num::<f64>();
 
         // Current price is 0.25
         // All positions below are placed at once
@@ -1162,7 +1147,7 @@ fn test_swap_multiple_positions() {
         .for_each(|(order_type, order_liquidity, limit_price)| {
             //////////////////////////////////////////////
             // Swap
-            let sqrt_current_price = AlphaSqrtPrice::<Test>::get(netuid);
+            let sqrt_current_price = Pallet::<Test>::current_price_sqrt(netuid);
             let current_price = (sqrt_current_price * sqrt_current_price).to_num::<f64>();
             let liquidity_before = CurrentLiquidity::<Test>::get(netuid);
 
@@ -1227,7 +1212,7 @@ fn test_swap_multiple_positions() {
             }
 
             // Assert that price movement is in correct direction
-            let sqrt_current_price_after = AlphaSqrtPrice::<Test>::get(netuid);
+            let sqrt_current_price_after = Pallet::<Test>::current_price_sqrt(netuid);
             let current_price_after =
                 (sqrt_current_price_after * sqrt_current_price_after).to_num::<f64>();
             match order_type {
@@ -1237,7 +1222,7 @@ fn test_swap_multiple_positions() {
         });
 
         // Current price shouldn't be much different from the original
-        let sqrt_current_price_after = AlphaSqrtPrice::<Test>::get(netuid);
+        let sqrt_current_price_after = Pallet::<Test>::current_price_sqrt(netuid);
         let current_price_after =
             (sqrt_current_price_after * sqrt_current_price_after).to_num::<f64>();
         assert_abs_diff_eq!(

From f404c9bb00610da2479041ef0f3d2138e26dd6c0 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Mon, 2 Jun 2025 18:50:05 -0400
Subject: [PATCH 231/418] Merge upstream

---
 pallets/swap/src/pallet/impls.rs | 15 +++++----------
 pallets/swap/src/pallet/tests.rs |  6 ++----
 2 files changed, 7 insertions(+), 14 deletions(-)

diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index c5107f1855..6a52cccd03 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -462,7 +462,7 @@ impl<T: Config> Pallet<T> {
         match order_type {
             OrderType::Buy => {
                 let higher_tick =
-                    ActiveTickIndexManager::find_closest_higher::<T>(netuid, current_price_tick)
+                    ActiveTickIndexManager::<T>::find_closest_higher(netuid, current_tick)
                         .unwrap_or(TickIndex::MAX);
                 if higher_tick < TickIndex::MAX {
                     higher_tick.saturating_add(1)
@@ -472,15 +472,10 @@ impl<T: Config> Pallet<T> {
             }
             OrderType::Sell => {
                 let mut lower_tick =
-                    ActiveTickIndexManager::find_closest_lower::<T>(netuid, current_price_tick)
+                    ActiveTickIndexManager::<T>::find_closest_lower(netuid, current_tick)
                         .unwrap_or(TickIndex::MIN);
-
-                if current_price == roundtrip_current_price {
-                    lower_tick = ActiveTickIndexManager::find_closest_lower::<T>(
-                        netuid,
-                        lower_tick.prev().unwrap_or(TickIndex::MIN),
-                    )
-                    .unwrap_or(TickIndex::MIN);
+                if lower_tick == current_tick {
+                    lower_tick = lower_tick.prev().unwrap_or(TickIndex::MIN);
                 }
                 lower_tick
             }
@@ -791,7 +786,7 @@ impl<T: Config> Pallet<T> {
         };
 
         // Collect fees and get tao and alpha amounts
-        let (fee_tao, fee_alpha) = position.collect_fees::<T>();
+        let (fee_tao, fee_alpha) = position.collect_fees();
         let current_price = AlphaSqrtPrice::<T>::get(netuid);
         let (tao, alpha) = position.to_token_amounts(current_price)?;
 
diff --git a/pallets/swap/src/pallet/tests.rs b/pallets/swap/src/pallet/tests.rs
index d9e59a2fe2..685dfc7be0 100644
--- a/pallets/swap/src/pallet/tests.rs
+++ b/pallets/swap/src/pallet/tests.rs
@@ -46,10 +46,8 @@ fn get_ticked_prices_around_current_price() -> (f64, f64) {
     // Low and high prices that match to a lower and higher tick that doesn't contain the current price
     let current_price_low_sqrt = current_tick.as_sqrt_price_bounded();
     let current_price_high_sqrt = current_tick.next().unwrap().as_sqrt_price_bounded();
-    let current_price_low =
-        U96F32::saturating_from_num(current_price_low_sqrt * current_price_low_sqrt);
-    let current_price_high =
-        U96F32::saturating_from_num(current_price_high_sqrt * current_price_high_sqrt);
+    let current_price_low = U96F32::from_num(current_price_low_sqrt * current_price_low_sqrt);
+    let current_price_high = U96F32::from_num(current_price_high_sqrt * current_price_high_sqrt);
 
     (
         current_price_low.to_num::<f64>(),

From 845a91e8455100cabeb75ab46d45e044a030ee51 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Mon, 2 Jun 2025 19:50:47 -0400
Subject: [PATCH 232/418] Handle the case when a sell swap starts on the edge

---
 pallets/swap/src/pallet/impls.rs | 86 +++++++++++++++++++++-----------
 pallets/swap/src/pallet/tests.rs |  2 +-
 2 files changed, 57 insertions(+), 31 deletions(-)

diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 6a52cccd03..878b758f57 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -25,6 +25,7 @@ struct SwapStep<T: frame_system::Config> {
     // Input parameters
     netuid: NetUid,
     order_type: OrderType,
+    first_step: bool,
 
     // Computed values
     current_liquidity: U64F64,
@@ -56,6 +57,7 @@ impl<T: Config> SwapStep<T> {
         order_type: OrderType,
         amount_remaining: u64,
         limit_sqrt_price: SqrtPrice,
+        first_step: bool,
     ) -> Self {
         // Calculate prices and ticks
         let current_tick = CurrentTick::<T>::get(netuid);
@@ -80,6 +82,7 @@ impl<T: Config> SwapStep<T> {
         Self {
             netuid,
             order_type,
+            first_step,
             target_sqrt_price,
             limit_sqrt_price,
             current_sqrt_price,
@@ -99,7 +102,7 @@ impl<T: Config> SwapStep<T> {
 
     /// Execute the swap step and return the result
     fn execute(&mut self) -> Result<SwapStepResult, Error<T>> {
-        self.determine_action();
+        self.determine_action()?;
         self.process_swap()
     }
 
@@ -116,9 +119,25 @@ impl<T: Config> SwapStep<T> {
     }
 
     /// Determine the appropriate action for this swap step
-    fn determine_action(&mut self) {
+    fn determine_action(&mut self) -> Result<(), Error<T>> {
         let mut recalculate_fee = false;
 
+        // For sell orders: If the current price matches the edge price, then cross the tick first,
+        // and then move the edge price to one active tick lower.
+        // Also, if this is the first swap step, cross the tick.
+        if (self.edge_sqrt_price == self.current_sqrt_price) && (self.order_type == OrderType::Sell)
+        {
+            if self.first_step {
+                self.cross_tick()?;
+            }
+            self.edge_tick = ActiveTickIndexManager::<T>::find_closest_lower(
+                self.netuid,
+                self.edge_tick.prev().unwrap_or(TickIndex::MIN),
+            )
+            .unwrap_or(TickIndex::MIN);
+            self.edge_sqrt_price = self.edge_tick.as_sqrt_price_bounded();
+        }
+
         // Calculate the stopping price: The price at which we either reach the limit price,
         // exchange the full amount, or reach the edge price.
         if self.tick_is_closer(&self.target_tick, &self.limit_tick)
@@ -182,6 +201,31 @@ impl<T: Config> SwapStep<T> {
                 OrderType::Sell => SwapStepAction::Stop,
             };
         }
+
+        Ok(())
+    }
+
+    fn cross_tick(&self) -> Result<(), Error<T>> {
+        // Get current tick
+        let current_tick_index = TickIndex::current_bounded::<T>(self.netuid);
+
+        let mut tick = match self.order_type {
+            OrderType::Sell => {
+                Pallet::<T>::find_closest_lower_active_tick(self.netuid, current_tick_index)
+            }
+            OrderType::Buy => {
+                Pallet::<T>::find_closest_higher_active_tick(self.netuid, current_tick_index)
+            }
+        }
+        .ok_or(Error::<T>::InsufficientLiquidity)?;
+
+        tick.fees_out_tao = FeeGlobalTao::<T>::get(self.netuid).saturating_sub(tick.fees_out_tao);
+        tick.fees_out_alpha =
+            FeeGlobalAlpha::<T>::get(self.netuid).saturating_sub(tick.fees_out_alpha);
+        Pallet::<T>::update_liquidity_at_crossing(self.netuid, self.order_type)?;
+        Ticks::<T>::insert(self.netuid, current_tick_index, tick);
+
+        Ok(())
     }
 
     /// Process a single step of a swap
@@ -190,26 +234,8 @@ impl<T: Config> SwapStep<T> {
         Pallet::<T>::add_fees(self.netuid, self.order_type, self.fee);
         let delta_out = Pallet::<T>::convert_deltas(self.netuid, self.order_type, self.delta_in);
 
-        // Get current tick
-        let current_tick_index = TickIndex::current_bounded::<T>(self.netuid);
-
         if self.action == SwapStepAction::Crossing {
-            let mut tick = match self.order_type {
-                OrderType::Sell => {
-                    Pallet::<T>::find_closest_lower_active_tick(self.netuid, current_tick_index)
-                }
-                OrderType::Buy => {
-                    Pallet::<T>::find_closest_higher_active_tick(self.netuid, current_tick_index)
-                }
-            }
-            .ok_or(Error::<T>::InsufficientLiquidity)?;
-
-            tick.fees_out_tao =
-                FeeGlobalTao::<T>::get(self.netuid).saturating_sub(tick.fees_out_tao);
-            tick.fees_out_alpha =
-                FeeGlobalAlpha::<T>::get(self.netuid).saturating_sub(tick.fees_out_alpha);
-            Pallet::<T>::update_liquidity_at_crossing(self.netuid, self.order_type)?;
-            Ticks::<T>::insert(self.netuid, current_tick_index, tick);
+            self.cross_tick()?;
         }
 
         // Update current price
@@ -403,8 +429,13 @@ impl<T: Config> Pallet<T> {
         // Swap one tick at a time until we reach one of the stop conditions
         while amount_remaining > 0 {
             // Create and execute a swap step
-            let mut swap_step =
-                SwapStep::<T>::new(netuid, order_type, amount_remaining, sqrt_price_limit);
+            let mut swap_step = SwapStep::<T>::new(
+                netuid,
+                order_type,
+                amount_remaining,
+                sqrt_price_limit,
+                iteration_counter == 0,
+            );
 
             let swap_result = swap_step.execute()?;
 
@@ -471,13 +502,8 @@ impl<T: Config> Pallet<T> {
                 }
             }
             OrderType::Sell => {
-                let mut lower_tick =
-                    ActiveTickIndexManager::<T>::find_closest_lower(netuid, current_tick)
-                        .unwrap_or(TickIndex::MIN);
-                if lower_tick == current_tick {
-                    lower_tick = lower_tick.prev().unwrap_or(TickIndex::MIN);
-                }
-                lower_tick
+                ActiveTickIndexManager::<T>::find_closest_lower(netuid, current_tick)
+                    .unwrap_or(TickIndex::MIN)
             }
         }
     }
diff --git a/pallets/swap/src/pallet/tests.rs b/pallets/swap/src/pallet/tests.rs
index 685dfc7be0..1083d8d6a9 100644
--- a/pallets/swap/src/pallet/tests.rs
+++ b/pallets/swap/src/pallet/tests.rs
@@ -794,7 +794,7 @@ fn test_swap_basic() {
 }
 
 // In this test the swap starts and ends within one (large liquidity) position
-// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor-swap --lib -- pallet::impls::tests::test_swap_single_position --exact --show-output --nocapture
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor-swap --lib -- pallet::tests::test_swap_single_position --exact --show-output
 #[test]
 fn test_swap_single_position() {
     let min_price = tick_to_price(TickIndex::MIN);

From 7c21126eae121c7bf188110c710d0d7010ee21aa Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Tue, 3 Jun 2025 16:51:59 +0200
Subject: [PATCH 233/418] Fix typing issues

---
 Cargo.lock                                    |  4 +
 common/Cargo.toml                             |  1 +
 common/src/lib.rs                             | 48 ++++++++++
 pallets/subtensor/Cargo.toml                  |  2 +
 .../subtensor/src/coinbase/block_emission.rs  |  2 +-
 .../subtensor/src/coinbase/run_coinbase.rs    |  2 +-
 pallets/subtensor/src/lib.rs                  | 45 +++++----
 pallets/subtensor/src/rpc_info/stake_info.rs  |  2 +-
 pallets/subtensor/src/staking/add_stake.rs    |  7 +-
 pallets/subtensor/src/staking/helpers.rs      | 11 ++-
 pallets/subtensor/src/staking/move_stake.rs   |  5 +-
 pallets/subtensor/src/staking/remove_stake.rs |  7 +-
 pallets/subtensor/src/staking/stake_utils.rs  | 23 +++--
 pallets/subtensor/src/tests/epoch.rs          |  4 +-
 pallets/subtensor/src/tests/mock.rs           |  4 +-
 pallets/subtensor/src/tests/move_stake.rs     | 13 +--
 pallets/subtensor/src/tests/senate.rs         |  6 +-
 pallets/subtensor/src/tests/staking.rs        | 93 +++++++++++--------
 pallets/subtensor/src/tests/staking2.rs       | 31 ++++---
 pallets/subtensor/src/tests/swap_coldkey.rs   |  3 +-
 pallets/subtensor/src/tests/weights.rs        |  3 +-
 pallets/swap-interface/Cargo.toml             |  2 +
 pallets/swap-interface/src/lib.rs             | 40 ++------
 pallets/swap/Cargo.toml                       |  4 +-
 pallets/swap/src/benchmarking.rs              | 12 ++-
 pallets/swap/src/lib.rs                       | 21 -----
 pallets/swap/src/mock.rs                      | 36 +++----
 pallets/swap/src/pallet/impls.rs              | 26 +++---
 pallets/swap/src/pallet/mod.rs                | 81 ++++++++--------
 pallets/swap/src/pallet/tests.rs              | 27 +++---
 pallets/swap/src/position.rs                  |  3 +-
 pallets/swap/src/tick.rs                      | 15 ++-
 32 files changed, 325 insertions(+), 258 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 77848ae978..0000ea577e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6916,6 +6916,7 @@ dependencies = [
  "sp-version",
  "substrate-fixed",
  "subtensor-macros",
+ "subtensor-runtime-common",
  "subtensor-swap-interface",
  "tle",
  "w3f-bls",
@@ -6942,6 +6943,7 @@ dependencies = [
  "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7)",
  "substrate-fixed",
  "subtensor-macros",
+ "subtensor-runtime-common",
  "subtensor-swap-interface",
 ]
 
@@ -11737,6 +11739,7 @@ dependencies = [
  "scale-info",
  "sp-core",
  "sp-runtime",
+ "subtensor-macros",
 ]
 
 [[package]]
@@ -11747,6 +11750,7 @@ dependencies = [
  "parity-scale-codec",
  "scale-info",
  "substrate-fixed",
+ "subtensor-runtime-common",
 ]
 
 [[package]]
diff --git a/common/Cargo.toml b/common/Cargo.toml
index d0b43cdc1b..ea7d65866b 100644
--- a/common/Cargo.toml
+++ b/common/Cargo.toml
@@ -16,6 +16,7 @@ frame-support = { workspace = true }
 scale-info = { workspace = true }
 sp-runtime = { workspace = true }
 sp-core = { workspace = true }
+subtensor-macros = { workspace = true }
 
 [lints]
 workspace = true
diff --git a/common/src/lib.rs b/common/src/lib.rs
index 75b18e3b14..0b691ce48e 100644
--- a/common/src/lib.rs
+++ b/common/src/lib.rs
@@ -1,12 +1,15 @@
 #![cfg_attr(not(feature = "std"), no_std)]
 
 use codec::{Decode, Encode, MaxEncodedLen};
+use frame_support::pallet_prelude::*;
 use scale_info::TypeInfo;
 use sp_runtime::{
     MultiSignature,
     traits::{IdentifyAccount, Verify},
 };
 
+use subtensor_macros::freeze_struct;
+
 /// Balance of an account.
 pub type Balance = u64;
 
@@ -31,6 +34,24 @@ pub type Nonce = u32;
 /// Transfers below SMALL_TRANSFER_LIMIT are considered small transfers
 pub const SMALL_TRANSFER_LIMIT: Balance = 500_000_000; // 0.5 TAO
 
+#[freeze_struct("2a62496e31bbcddc")]
+#[derive(
+    Clone, Copy, Decode, Default, Encode, Eq, MaxEncodedLen, PartialEq, RuntimeDebug, TypeInfo,
+)]
+pub struct NetUid(u16);
+
+impl From<NetUid> for u16 {
+    fn from(val: NetUid) -> Self {
+        val.0
+    }
+}
+
+impl From<u16> for NetUid {
+    fn from(value: u16) -> Self {
+        Self(value)
+    }
+}
+
 #[derive(
     Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Encode, Decode, Debug, MaxEncodedLen, TypeInfo,
 )]
@@ -59,6 +80,33 @@ impl Default for ProxyType {
     }
 }
 
+pub trait SubnetInfo<AccountId> {
+    fn tao_reserve(netuid: NetUid) -> u64;
+    fn alpha_reserve(netuid: NetUid) -> u64;
+    fn exists(netuid: NetUid) -> bool;
+    fn mechanism(netuid: NetUid) -> u16;
+    fn is_owner(account_id: &AccountId, netuid: NetUid) -> bool;
+}
+
+pub trait BalanceOps<AccountId> {
+    fn tao_balance(account_id: &AccountId) -> u64;
+    fn alpha_balance(netuid: NetUid, coldkey: &AccountId, hotkey: &AccountId) -> u64;
+    fn increase_balance(coldkey: &AccountId, tao: u64);
+    fn decrease_balance(coldkey: &AccountId, tao: u64) -> Result<u64, DispatchError>;
+    fn increase_stake(
+        coldkey: &AccountId,
+        hotkey: &AccountId,
+        netuid: NetUid,
+        alpha: u64,
+    ) -> Result<(), DispatchError>;
+    fn decrease_stake(
+        coldkey: &AccountId,
+        hotkey: &AccountId,
+        netuid: NetUid,
+        alpha: u64,
+    ) -> Result<u64, DispatchError>;
+}
+
 pub mod time {
     use super::*;
 
diff --git a/pallets/subtensor/Cargo.toml b/pallets/subtensor/Cargo.toml
index 0024991ee1..d5cbcea464 100644
--- a/pallets/subtensor/Cargo.toml
+++ b/pallets/subtensor/Cargo.toml
@@ -45,6 +45,7 @@ share-pool = { default-features = false, path = "../../primitives/share-pool" }
 safe-math = { default-features = false, path = "../../primitives/safe-math" }
 approx = { workspace = true }
 subtensor-swap-interface = { workspace = true }
+subtensor-runtime-common = { workspace = true }
 
 pallet-collective = { version = "4.0.0-dev", default-features = false, path = "../collective" }
 pallet-drand = { path = "../drand", default-features = false }
@@ -113,6 +114,7 @@ std = [
 	"sp-version/std",
 	"substrate-fixed/std",
 	"substrate-fixed/std",
+	"subtensor-runtime-common/std",
 	"subtensor-swap-interface/std",
 	"tle/std",
 	"w3f-bls/std",
diff --git a/pallets/subtensor/src/coinbase/block_emission.rs b/pallets/subtensor/src/coinbase/block_emission.rs
index d5bba2192f..974f9e9ab1 100644
--- a/pallets/subtensor/src/coinbase/block_emission.rs
+++ b/pallets/subtensor/src/coinbase/block_emission.rs
@@ -39,7 +39,7 @@ impl<T: Config> Pallet<T> {
         let float_alpha_block_emission: U96F32 = U96F32::saturating_from_num(alpha_block_emission);
 
         // Get alpha price for subnet.
-        let alpha_price = T::SwapInterface::current_alpha_price(netuid);
+        let alpha_price = T::SwapInterface::current_alpha_price(netuid.into());
         log::debug!("{:?} - alpha_price: {:?}", netuid, alpha_price);
 
         // Get initial alpha_in
diff --git a/pallets/subtensor/src/coinbase/run_coinbase.rs b/pallets/subtensor/src/coinbase/run_coinbase.rs
index 07725f07a1..764ffa2a21 100644
--- a/pallets/subtensor/src/coinbase/run_coinbase.rs
+++ b/pallets/subtensor/src/coinbase/run_coinbase.rs
@@ -70,7 +70,7 @@ impl<T: Config> Pallet<T> {
         // Only calculate for subnets that we are emitting to.
         for netuid_i in subnets_to_emit_to.iter() {
             // Get subnet price.
-            let price_i = T::SwapInterface::current_alpha_price(*netuid_i);
+            let price_i = T::SwapInterface::current_alpha_price((*netuid_i).into());
             log::debug!("price_i: {:?}", price_i);
             // Get subnet TAO.
             let moving_price_i: U96F32 = Self::get_moving_alpha_price(*netuid_i);
diff --git a/pallets/subtensor/src/lib.rs b/pallets/subtensor/src/lib.rs
index 4cce25dc70..762e87b957 100644
--- a/pallets/subtensor/src/lib.rs
+++ b/pallets/subtensor/src/lib.rs
@@ -28,6 +28,7 @@ use sp_runtime::{
     transaction_validity::{TransactionValidity, TransactionValidityError},
 };
 use sp_std::marker::PhantomData;
+use subtensor_runtime_common::NetUid;
 
 // ============================
 //	==== Benchmark Imports =====
@@ -2696,38 +2697,38 @@ impl<T, H, P> CollectiveInterface<T, H, P> for () {
 }
 
 impl<T: Config + pallet_balances::Config<Balance = u64>>
-    subtensor_swap_interface::SubnetInfo<T::AccountId> for Pallet<T>
+    subtensor_runtime_common::SubnetInfo<T::AccountId> for Pallet<T>
 {
-    fn tao_reserve(netuid: u16) -> u64 {
-        SubnetTAO::<T>::get(netuid)
+    fn tao_reserve(netuid: NetUid) -> u64 {
+        SubnetTAO::<T>::get(u16::from(netuid))
     }
 
-    fn alpha_reserve(netuid: u16) -> u64 {
-        SubnetAlphaIn::<T>::get(netuid)
+    fn alpha_reserve(netuid: NetUid) -> u64 {
+        SubnetAlphaIn::<T>::get(u16::from(netuid))
     }
 
-    fn exists(netuid: u16) -> bool {
-        Self::if_subnet_exist(netuid)
+    fn exists(netuid: NetUid) -> bool {
+        Self::if_subnet_exist(u16::from(netuid))
     }
 
-    fn mechanism(netuid: u16) -> u16 {
-        SubnetMechanism::<T>::get(netuid)
+    fn mechanism(netuid: NetUid) -> u16 {
+        SubnetMechanism::<T>::get(u16::from(netuid))
     }
 
-    fn is_owner(account_id: &T::AccountId, netuid: u16) -> bool {
-        SubnetOwner::<T>::get(netuid) == *account_id
+    fn is_owner(account_id: &T::AccountId, netuid: NetUid) -> bool {
+        SubnetOwner::<T>::get(u16::from(netuid)) == *account_id
     }
 }
 
 impl<T: Config + pallet_balances::Config<Balance = u64>>
-    subtensor_swap_interface::BalanceOps<T::AccountId> for Pallet<T>
+    subtensor_runtime_common::BalanceOps<T::AccountId> for Pallet<T>
 {
     fn tao_balance(account_id: &T::AccountId) -> u64 {
         pallet_balances::Pallet::<T>::free_balance(account_id)
     }
 
-    fn alpha_balance(netuid: u16, coldkey: &T::AccountId, hotkey: &T::AccountId) -> u64 {
-        Self::get_stake_for_hotkey_and_coldkey_on_subnet(hotkey, coldkey, netuid)
+    fn alpha_balance(netuid: NetUid, coldkey: &T::AccountId, hotkey: &T::AccountId) -> u64 {
+        Self::get_stake_for_hotkey_and_coldkey_on_subnet(hotkey, coldkey, netuid.into())
     }
 
     fn increase_balance(coldkey: &T::AccountId, tao: u64) {
@@ -2741,7 +2742,7 @@ impl<T: Config + pallet_balances::Config<Balance = u64>>
     fn increase_stake(
         coldkey: &T::AccountId,
         hotkey: &T::AccountId,
-        netuid: u16,
+        netuid: NetUid,
         alpha: u64,
     ) -> Result<(), DispatchError> {
         ensure!(
@@ -2749,7 +2750,12 @@ impl<T: Config + pallet_balances::Config<Balance = u64>>
             Error::<T>::HotKeyAccountNotExists
         );
 
-        Self::increase_stake_for_hotkey_and_coldkey_on_subnet(hotkey, coldkey, netuid, alpha);
+        Self::increase_stake_for_hotkey_and_coldkey_on_subnet(
+            hotkey,
+            coldkey,
+            netuid.into(),
+            alpha,
+        );
 
         Ok(())
     }
@@ -2757,7 +2763,7 @@ impl<T: Config + pallet_balances::Config<Balance = u64>>
     fn decrease_stake(
         coldkey: &T::AccountId,
         hotkey: &T::AccountId,
-        netuid: u16,
+        netuid: NetUid,
         alpha: u64,
     ) -> Result<u64, DispatchError> {
         ensure!(
@@ -2766,7 +2772,10 @@ impl<T: Config + pallet_balances::Config<Balance = u64>>
         );
 
         Ok(Self::decrease_stake_for_hotkey_and_coldkey_on_subnet(
-            hotkey, coldkey, netuid, alpha,
+            hotkey,
+            coldkey,
+            netuid.into(),
+            alpha,
         ))
     }
 }
diff --git a/pallets/subtensor/src/rpc_info/stake_info.rs b/pallets/subtensor/src/rpc_info/stake_info.rs
index 26877c2fe2..c237e3af39 100644
--- a/pallets/subtensor/src/rpc_info/stake_info.rs
+++ b/pallets/subtensor/src/rpc_info/stake_info.rs
@@ -124,6 +124,6 @@ impl<T: Config> Pallet<T> {
         amount: u64,
     ) -> u64 {
         let netuid = destination.or(origin).map(|v| v.1).unwrap_or_default();
-        T::SwapInterface::approx_fee_amount(netuid, amount)
+        T::SwapInterface::approx_fee_amount(netuid.into(), amount)
     }
 }
diff --git a/pallets/subtensor/src/staking/add_stake.rs b/pallets/subtensor/src/staking/add_stake.rs
index 243c7c3c36..9528537b23 100644
--- a/pallets/subtensor/src/staking/add_stake.rs
+++ b/pallets/subtensor/src/staking/add_stake.rs
@@ -335,9 +335,10 @@ impl<T: Config> Pallet<T> {
         }
 
         // Use reverting swap to estimate max limit amount
-        let result = T::SwapInterface::swap(netuid, OrderType::Buy, u64::MAX, limit_price, true)
-            .map(|r| r.amount_paid_in.saturating_add(r.fee_paid))
-            .map_err(|_| Error::ZeroMaxStakeAmount)?;
+        let result =
+            T::SwapInterface::swap(netuid.into(), OrderType::Buy, u64::MAX, limit_price, true)
+                .map(|r| r.amount_paid_in.saturating_add(r.fee_paid))
+                .map_err(|_| Error::ZeroMaxStakeAmount)?;
 
         if result != 0 {
             Ok(result)
diff --git a/pallets/subtensor/src/staking/helpers.rs b/pallets/subtensor/src/staking/helpers.rs
index edabf4d64c..9b0f0ec0ab 100644
--- a/pallets/subtensor/src/staking/helpers.rs
+++ b/pallets/subtensor/src/staking/helpers.rs
@@ -50,8 +50,9 @@ impl<T: Config> Pallet<T> {
                 let alpha = U96F32::saturating_from_num(Self::get_stake_for_hotkey_on_subnet(
                     hotkey, netuid,
                 ));
-                let alpha_price =
-                    U96F32::saturating_from_num(T::SwapInterface::current_alpha_price(netuid));
+                let alpha_price = U96F32::saturating_from_num(
+                    T::SwapInterface::current_alpha_price(netuid.into()),
+                );
                 alpha.saturating_mul(alpha_price)
             })
             .sum::<U96F32>()
@@ -70,10 +71,12 @@ impl<T: Config> Pallet<T> {
                         let alpha_stake = Self::get_stake_for_hotkey_and_coldkey_on_subnet(
                             hotkey, coldkey, netuid,
                         );
-                        T::SwapInterface::sim_swap(netuid, OrderType::Sell, alpha_stake)
+                        T::SwapInterface::sim_swap(netuid.into(), OrderType::Sell, alpha_stake)
                             .map(|r| {
                                 let fee: u64 = U96F32::saturating_from_num(r.fee_paid)
-                                    .saturating_mul(T::SwapInterface::current_alpha_price(netuid))
+                                    .saturating_mul(T::SwapInterface::current_alpha_price(
+                                        netuid.into(),
+                                    ))
                                     .saturating_to_num();
                                 r.amount_paid_out.saturating_add(fee)
                             })
diff --git a/pallets/subtensor/src/staking/move_stake.rs b/pallets/subtensor/src/staking/move_stake.rs
index 3a5efe8512..d491b837d3 100644
--- a/pallets/subtensor/src/staking/move_stake.rs
+++ b/pallets/subtensor/src/staking/move_stake.rs
@@ -464,8 +464,9 @@ impl<T: Config> Pallet<T> {
         let limit_price_float: U64F64 = U64F64::saturating_from_num(limit_price)
             .checked_div(U64F64::saturating_from_num(1_000_000_000))
             .unwrap_or(U64F64::saturating_from_num(0));
-        let current_price = T::SwapInterface::current_alpha_price(origin_netuid)
-            .safe_div(T::SwapInterface::current_alpha_price(destination_netuid));
+        let current_price = T::SwapInterface::current_alpha_price(origin_netuid.into()).safe_div(
+            T::SwapInterface::current_alpha_price(destination_netuid.into()),
+        );
         if limit_price_float > current_price {
             return Err(Error::ZeroMaxStakeAmount);
         }
diff --git a/pallets/subtensor/src/staking/remove_stake.rs b/pallets/subtensor/src/staking/remove_stake.rs
index bbd872c25f..d05f7dc001 100644
--- a/pallets/subtensor/src/staking/remove_stake.rs
+++ b/pallets/subtensor/src/staking/remove_stake.rs
@@ -615,9 +615,10 @@ impl<T: Config> Pallet<T> {
         }
 
         // Use reverting swap to estimate max limit amount
-        let result = T::SwapInterface::swap(netuid, OrderType::Sell, u64::MAX, limit_price, true)
-            .map(|r| r.amount_paid_in.saturating_add(r.fee_paid))
-            .map_err(|_| Error::ZeroMaxStakeAmount)?;
+        let result =
+            T::SwapInterface::swap(netuid.into(), OrderType::Sell, u64::MAX, limit_price, true)
+                .map(|r| r.amount_paid_in.saturating_add(r.fee_paid))
+                .map_err(|_| Error::ZeroMaxStakeAmount)?;
 
         if result != 0 {
             Ok(result)
diff --git a/pallets/subtensor/src/staking/stake_utils.rs b/pallets/subtensor/src/staking/stake_utils.rs
index d3447533db..6bb321796d 100644
--- a/pallets/subtensor/src/staking/stake_utils.rs
+++ b/pallets/subtensor/src/staking/stake_utils.rs
@@ -59,7 +59,8 @@ impl<T: Config> Pallet<T> {
         // We can use unsigned type here: U96F32
         let one_minus_alpha: U96F32 = U96F32::saturating_from_num(1.0).saturating_sub(alpha);
         let current_price: U96F32 = alpha.saturating_mul(
-            T::SwapInterface::current_alpha_price(netuid).min(U96F32::saturating_from_num(1.0)),
+            T::SwapInterface::current_alpha_price(netuid.into())
+                .min(U96F32::saturating_from_num(1.0)),
         );
         let current_moving: U96F32 =
             one_minus_alpha.saturating_mul(Self::get_moving_alpha_price(netuid));
@@ -618,7 +619,7 @@ impl<T: Config> Pallet<T> {
         let mechanism_id: u16 = SubnetMechanism::<T>::get(netuid);
         if mechanism_id == 1 {
             let swap_result =
-                T::SwapInterface::swap(netuid, OrderType::Buy, tao, price_limit, false)?;
+                T::SwapInterface::swap(netuid.into(), OrderType::Buy, tao, price_limit, false)?;
 
             // update Alpha reserves.
             SubnetAlphaIn::<T>::set(netuid, swap_result.new_alpha_reserve);
@@ -666,7 +667,7 @@ impl<T: Config> Pallet<T> {
         // Step 2: Swap alpha and attain tao
         if mechanism_id == 1 {
             let swap_result =
-                T::SwapInterface::swap(netuid, OrderType::Sell, alpha, price_limit, false)?;
+                T::SwapInterface::swap(netuid.into(), OrderType::Sell, alpha, price_limit, false)?;
 
             // Increase Alpha reserves.
             SubnetAlphaIn::<T>::set(netuid, swap_result.new_alpha_reserve);
@@ -852,9 +853,12 @@ impl<T: Config> Pallet<T> {
         // Get the minimum balance (and amount) that satisfies the transaction
         let min_amount = {
             let min_stake = DefaultMinStake::<T>::get();
-            let fee = T::SwapInterface::sim_swap(netuid, OrderType::Buy, min_stake)
+            let fee = T::SwapInterface::sim_swap(netuid.into(), OrderType::Buy, min_stake)
                 .map(|res| res.fee_paid)
-                .unwrap_or(T::SwapInterface::approx_fee_amount(netuid, min_stake));
+                .unwrap_or(T::SwapInterface::approx_fee_amount(
+                    netuid.into(),
+                    min_stake,
+                ));
             min_stake.saturating_add(fee)
         };
 
@@ -879,8 +883,9 @@ impl<T: Config> Pallet<T> {
             Error::<T>::HotKeyAccountNotExists
         );
 
-        let expected_alpha = T::SwapInterface::sim_swap(netuid, OrderType::Buy, stake_to_be_added)
-            .map_err(|_| Error::<T>::InsufficientLiquidity)?;
+        let expected_alpha =
+            T::SwapInterface::sim_swap(netuid.into(), OrderType::Buy, stake_to_be_added)
+                .map_err(|_| Error::<T>::InsufficientLiquidity)?;
 
         ensure!(
             expected_alpha.amount_paid_out > 0,
@@ -912,7 +917,7 @@ impl<T: Config> Pallet<T> {
         ensure!(Self::if_subnet_exist(netuid), Error::<T>::SubnetNotExists);
 
         // Ensure that the stake amount to be removed is above the minimum in tao equivalent.
-        match T::SwapInterface::sim_swap(netuid, OrderType::Sell, alpha_unstaked) {
+        match T::SwapInterface::sim_swap(netuid.into(), OrderType::Sell, alpha_unstaked) {
             Ok(res) => ensure!(
                 res.amount_paid_out > DefaultMinStake::<T>::get(),
                 Error::<T>::AmountTooLow
@@ -1044,7 +1049,7 @@ impl<T: Config> Pallet<T> {
 
         // Ensure that the stake amount to be removed is above the minimum in tao equivalent.
         let tao_equivalent =
-            T::SwapInterface::sim_swap(origin_netuid, OrderType::Sell, alpha_amount)
+            T::SwapInterface::sim_swap(origin_netuid.into(), OrderType::Sell, alpha_amount)
                 .map(|res| res.amount_paid_out)
                 .map_err(|_| Error::<T>::InsufficientLiquidity)?;
         ensure!(
diff --git a/pallets/subtensor/src/tests/epoch.rs b/pallets/subtensor/src/tests/epoch.rs
index 1a576869dd..f75f035623 100644
--- a/pallets/subtensor/src/tests/epoch.rs
+++ b/pallets/subtensor/src/tests/epoch.rs
@@ -1306,7 +1306,7 @@ fn test_set_alpha_disabled() {
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, 1_000_000_000_000_000);
         assert_ok!(SubtensorModule::root_register(signer.clone(), hotkey,));
         let fee = <Test as pallet::Config>::SwapInterface::approx_fee_amount(
-            netuid,
+            netuid.into(),
             DefaultMinStake::<Test>::get(),
         );
         assert_ok!(SubtensorModule::add_stake(
@@ -2259,7 +2259,7 @@ fn test_get_set_alpha() {
         SubtokenEnabled::<Test>::insert(netuid, true);
 
         let fee = <Test as pallet::Config>::SwapInterface::approx_fee_amount(
-            netuid,
+            netuid.into(),
             DefaultMinStake::<Test>::get(),
         );
 
diff --git a/pallets/subtensor/src/tests/mock.rs b/pallets/subtensor/src/tests/mock.rs
index e91a27e065..f8f820119e 100644
--- a/pallets/subtensor/src/tests/mock.rs
+++ b/pallets/subtensor/src/tests/mock.rs
@@ -914,7 +914,7 @@ pub(crate) fn swap_tao_to_alpha(netuid: u16, tao: u64) -> (u64, u64) {
         0 => (tao, 0),
         _ => {
             let result = <Test as pallet::Config>::SwapInterface::swap(
-                netuid,
+                netuid.into(),
                 OrderType::Buy,
                 tao,
                 <Test as pallet::Config>::SwapInterface::max_price(),
@@ -943,7 +943,7 @@ pub(crate) fn swap_alpha_to_tao(netuid: u16, alpha: u64) -> (u64, u64) {
             );
 
             let result = <Test as pallet::Config>::SwapInterface::swap(
-                netuid,
+                netuid.into(),
                 OrderType::Sell,
                 alpha,
                 <Test as pallet::Config>::SwapInterface::min_price(),
diff --git a/pallets/subtensor/src/tests/move_stake.rs b/pallets/subtensor/src/tests/move_stake.rs
index 2718f3f548..d90db884ee 100644
--- a/pallets/subtensor/src/tests/move_stake.rs
+++ b/pallets/subtensor/src/tests/move_stake.rs
@@ -30,7 +30,7 @@ fn test_do_move_success() {
         SubtensorModule::stake_into_subnet(
             &origin_hotkey,
             &coldkey,
-            netuid,
+            netuid.into(),
             stake_amount,
             <Test as Config>::SwapInterface::max_price(),
         )
@@ -128,7 +128,8 @@ fn test_do_move_different_subnets() {
             ),
             0
         );
-        let fee = <Test as Config>::SwapInterface::approx_fee_amount(destination_netuid, alpha);
+        let fee =
+            <Test as Config>::SwapInterface::approx_fee_amount(destination_netuid.into(), alpha);
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
                 &destination_hotkey,
@@ -358,7 +359,7 @@ fn test_do_move_all_stake() {
             ),
             0
         );
-        let fee = <Test as Config>::SwapInterface::approx_fee_amount(netuid, alpha);
+        let fee = <Test as Config>::SwapInterface::approx_fee_amount(netuid.into(), alpha);
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
                 &destination_hotkey,
@@ -420,7 +421,7 @@ fn test_do_move_half_stake() {
             alpha / 2,
             epsilon = alpha / 1000
         );
-        let fee = <Test as Config>::SwapInterface::approx_fee_amount(netuid, alpha);
+        let fee = <Test as Config>::SwapInterface::approx_fee_amount(netuid.into(), alpha);
         assert_abs_diff_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
                 &destination_hotkey,
@@ -1704,9 +1705,9 @@ fn test_swap_stake_limit_validate() {
 
         // Setup limit price so that it doesn't allow much slippage at all
         let limit_price =
-            ((<Test as pallet::Config>::SwapInterface::current_alpha_price(origin_netuid)
+            ((<Test as pallet::Config>::SwapInterface::current_alpha_price(origin_netuid.into())
                 / <Test as pallet::Config>::SwapInterface::current_alpha_price(
-                    destination_netuid,
+                    destination_netuid.into(),
                 ))
                 * U96F32::from_num(1_000_000_000))
             .to_num::<u64>()
diff --git a/pallets/subtensor/src/tests/senate.rs b/pallets/subtensor/src/tests/senate.rs
index a4bacc3dcc..7680b50500 100644
--- a/pallets/subtensor/src/tests/senate.rs
+++ b/pallets/subtensor/src/tests/senate.rs
@@ -723,8 +723,10 @@ fn test_adjust_senate_events() {
         let max_senate_size: u16 = SenateMaxMembers::get() as u16;
         let stake_threshold = {
             let default_stake = DefaultMinStake::<Test>::get();
-            let fee =
-                <Test as pallet::Config>::SwapInterface::approx_fee_amount(netuid, default_stake);
+            let fee = <Test as pallet::Config>::SwapInterface::approx_fee_amount(
+                netuid.into(),
+                default_stake,
+            );
             default_stake + fee
         };
 
diff --git a/pallets/subtensor/src/tests/staking.rs b/pallets/subtensor/src/tests/staking.rs
index 584ddff86e..08b0331a8d 100644
--- a/pallets/subtensor/src/tests/staking.rs
+++ b/pallets/subtensor/src/tests/staking.rs
@@ -6,11 +6,12 @@ use frame_support::dispatch::{DispatchClass, DispatchInfo, GetDispatchInfo, Pays
 use frame_support::sp_runtime::DispatchError;
 use frame_support::{assert_err, assert_noop, assert_ok, traits::Currency};
 use frame_system::RawOrigin;
-use pallet_subtensor_swap::{NetUid, tick::TickIndex};
+use pallet_subtensor_swap::tick::TickIndex;
 use safe_math::FixedExt;
 use sp_core::{Get, H256, U256};
 use substrate_fixed::traits::FromFixed;
 use substrate_fixed::types::{I96F32, I110F18, U64F64, U96F32};
+use subtensor_runtime_common::NetUid;
 use subtensor_swap_interface::{OrderType, SwapHandler};
 
 use super::mock;
@@ -79,7 +80,8 @@ fn test_add_stake_ok_no_emission() {
         ));
 
         let (tao_expected, _) = mock::swap_alpha_to_tao(netuid, alpha_staked);
-        let approx_fee = <Test as pallet::Config>::SwapInterface::approx_fee_amount(netuid, amount);
+        let approx_fee =
+            <Test as pallet::Config>::SwapInterface::approx_fee_amount(netuid.into(), amount);
 
         assert_abs_diff_eq!(
             SubtensorModule::get_total_stake_for_hotkey(&hotkey_account_id),
@@ -1586,7 +1588,7 @@ fn test_remove_stake_total_balance_no_change() {
 
         // Add subnet TAO for the equivalent amount added at price
         let amount_tao = U96F32::saturating_from_num(amount)
-            * <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid);
+            * <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid.into());
         SubnetTAO::<Test>::mutate(netuid, |v| *v += amount_tao.saturating_to_num::<u64>());
         TotalStake::<Test>::mutate(|v| *v += amount_tao.saturating_to_num::<u64>());
 
@@ -1598,7 +1600,7 @@ fn test_remove_stake_total_balance_no_change() {
             amount
         ));
 
-        let fee = <Test as Config>::SwapInterface::approx_fee_amount(netuid, amount);
+        let fee = <Test as Config>::SwapInterface::approx_fee_amount(netuid.into(), amount);
         assert_abs_diff_eq!(
             SubtensorModule::get_coldkey_balance(&coldkey_account_id),
             amount - fee,
@@ -3139,7 +3141,8 @@ fn test_get_alpha_share_stake_multiple_delegators() {
         );
 
         // Calculate expected total delegated stake
-        let fee = <Test as Config>::SwapInterface::approx_fee_amount(netuid, stake1 + stake2);
+        let fee =
+            <Test as Config>::SwapInterface::approx_fee_amount(netuid.into(), stake1 + stake2);
         let expected_total_stake = stake1 + stake2 - existential_deposit * 2 - fee;
         let actual_total_stake = SubtensorModule::get_alpha_share_pool(hotkey1, netuid)
             .get_value(&coldkey1)
@@ -3493,7 +3496,8 @@ fn test_stake_below_min_validate() {
         let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
         let amount_staked = {
             let defaulte_stake = DefaultMinStake::<Test>::get();
-            let fee = <Test as Config>::SwapInterface::approx_fee_amount(netuid, defaulte_stake);
+            let fee =
+                <Test as Config>::SwapInterface::approx_fee_amount(netuid.into(), defaulte_stake);
             let min_valid_stake = defaulte_stake + fee;
 
             min_valid_stake - 1
@@ -3527,7 +3531,8 @@ fn test_stake_below_min_validate() {
         // Increase the stake to be equal to the minimum, but leave the balance low
         let amount_staked = {
             let defaulte_stake = DefaultMinStake::<Test>::get();
-            let fee = <Test as Config>::SwapInterface::approx_fee_amount(netuid, defaulte_stake);
+            let fee =
+                <Test as Config>::SwapInterface::approx_fee_amount(netuid.into(), defaulte_stake);
 
             defaulte_stake + fee
         };
@@ -3578,7 +3583,8 @@ fn test_add_stake_limit_validate() {
         let alpha_in: U96F32 = U96F32::from_num(100_000_000_000_u64);
         SubnetTAO::<Test>::insert(netuid, tao_reserve.to_num::<u64>());
         SubnetAlphaIn::<Test>::insert(netuid, alpha_in.to_num::<u64>());
-        let current_price = <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid);
+        let current_price =
+            <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid.into());
         assert_eq!(current_price, U96F32::from_num(1.5));
 
         // Give it some $$$ in his coldkey balance
@@ -3642,7 +3648,8 @@ fn test_remove_stake_limit_validate() {
         let alpha_in: U96F32 = U96F32::from_num(100_000_000_000_u64);
         SubnetTAO::<Test>::insert(netuid, tao_reserve.to_num::<u64>());
         SubnetAlphaIn::<Test>::insert(netuid, alpha_in.to_num::<u64>());
-        let current_price = <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid);
+        let current_price =
+            <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid.into());
         assert_eq!(current_price, U96F32::from_num(1.5));
 
         // Setup limit price so that it doesn't drop by more than 10% from current price
@@ -4029,7 +4036,7 @@ fn test_max_amount_add_dynamic() {
             if alpha_in != 0 {
                 let expected_price = U96F32::from_num(tao_in) / U96F32::from_num(alpha_in);
                 assert_abs_diff_eq!(
-                    <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid)
+                    <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid.into())
                         .to_num::<f64>(),
                     expected_price.to_num::<f64>(),
                     epsilon = expected_price.to_num::<f64>() / 1_000_f64
@@ -4235,7 +4242,7 @@ fn test_max_amount_remove_dynamic() {
                 if alpha_in != 0 {
                     let expected_price = I96F32::from_num(tao_in) / I96F32::from_num(alpha_in);
                     assert_eq!(
-                        <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid),
+                        <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid.into()),
                         expected_price
                     );
                 }
@@ -4363,7 +4370,7 @@ fn test_max_amount_move_stable_dynamic() {
         SubnetTAO::<Test>::insert(dynamic_netuid, tao_reserve.to_num::<u64>());
         SubnetAlphaIn::<Test>::insert(dynamic_netuid, alpha_in.to_num::<u64>());
         let current_price =
-            <Test as pallet::Config>::SwapInterface::current_alpha_price(dynamic_netuid);
+            <Test as pallet::Config>::SwapInterface::current_alpha_price(dynamic_netuid.into());
         assert_eq!(current_price, U96F32::from_num(0.5));
 
         // The tests below just mimic the add_stake_limit tests for reverted price
@@ -4438,7 +4445,7 @@ fn test_max_amount_move_dynamic_stable() {
         SubnetTAO::<Test>::insert(dynamic_netuid, tao_reserve.to_num::<u64>());
         SubnetAlphaIn::<Test>::insert(dynamic_netuid, alpha_in.to_num::<u64>());
         let current_price =
-            <Test as pallet::Config>::SwapInterface::current_alpha_price(dynamic_netuid);
+            <Test as pallet::Config>::SwapInterface::current_alpha_price(dynamic_netuid.into());
         assert_eq!(current_price, U96F32::from_num(1.5));
 
         // The tests below just mimic the remove_stake_limit tests
@@ -4717,9 +4724,9 @@ fn test_max_amount_move_dynamic_dynamic() {
                         let expected_price = origin_price / dest_price;
                         assert_eq!(
                             <Test as pallet::Config>::SwapInterface::current_alpha_price(
-                                origin_netuid
+                                origin_netuid.into()
                             ) / <Test as pallet::Config>::SwapInterface::current_alpha_price(
-                                destination_netuid
+                                destination_netuid.into()
                             ),
                             expected_price
                         );
@@ -4755,7 +4762,8 @@ fn test_add_stake_limit_ok() {
         let tao_reserve = U96F32::from_num(150_000_000_000_u64);
         let alpha_in = U96F32::from_num(100_000_000_000_u64);
         mock::setup_reserves(netuid, tao_reserve.to_num(), alpha_in.to_num());
-        let current_price = <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid);
+        let current_price =
+            <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid.into());
         assert_eq!(current_price, U96F32::from_num(1.5));
 
         // Give it some $$$ in his coldkey balance
@@ -4790,7 +4798,7 @@ fn test_add_stake_limit_ok() {
 
         // Check that 450 TAO less fees balance still remains free on coldkey
         let fee = <tests::mock::Test as pallet::Config>::SwapInterface::approx_fee_amount(
-            netuid,
+            netuid.into(),
             amount / 2,
         ) as f64;
         assert_abs_diff_eq!(
@@ -4801,7 +4809,8 @@ fn test_add_stake_limit_ok() {
 
         // Check that price has updated to ~24 = (150+450) / (100 - 75)
         let exp_price = U96F32::from_num(24.0);
-        let current_price = <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid);
+        let current_price =
+            <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid.into());
         assert_abs_diff_eq!(
             exp_price.to_num::<f64>(),
             current_price.to_num::<f64>(),
@@ -4964,7 +4973,8 @@ fn test_add_stake_limit_fill_or_kill() {
         let alpha_in: U96F32 = U96F32::from_num(100_000_000_000_u64);
         SubnetTAO::<Test>::insert(netuid, tao_reserve.to_num::<u64>());
         SubnetAlphaIn::<Test>::insert(netuid, alpha_in.to_num::<u64>());
-        let current_price = <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid);
+        let current_price =
+            <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid.into());
         // FIXME it's failing because in the swap pallet, the alpha price is set only after an
         // initial swap
         assert_eq!(current_price, U96F32::from_num(1.5));
@@ -5070,7 +5080,8 @@ fn test_remove_stake_limit_ok() {
         );
 
         // Setup limit price to 99% of current price
-        let current_price = <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid);
+        let current_price =
+            <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid.into());
         let limit_price = (current_price.to_num::<f64>() * 990_000_000_f64) as u64;
 
         // Alpha unstaked - calculated using formula from delta_in()
@@ -5268,7 +5279,8 @@ fn test_remove_stake_limit_fill_or_kill() {
         let alpha_in: U96F32 = U96F32::from_num(100_000_000_000_u64);
         SubnetTAO::<Test>::insert(netuid, tao_reserve.to_num::<u64>());
         SubnetAlphaIn::<Test>::insert(netuid, alpha_in.to_num::<u64>());
-        let current_price = <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid);
+        let current_price =
+            <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid.into());
         assert_eq!(current_price, U96F32::from_num(1.5));
 
         // Setup limit price so that it doesn't drop by more than 10% from current price
@@ -5473,7 +5485,7 @@ fn test_add_stake_specific_stake_into_subnet_fail() {
 
         // Add stake as new hotkey
         let expected_alpha = <Test as Config>::SwapInterface::swap(
-            netuid,
+            netuid.into(),
             OrderType::Buy,
             tao_staked,
             <Test as Config>::SwapInterface::max_price(),
@@ -5599,7 +5611,7 @@ fn test_remove_99_9989_per_cent_stake_leaves_a_little() {
         ));
 
         // Check that all alpha was unstaked and 99% TAO balance was returned (less fees)
-        // let fee = <Test as Config>::SwapInterface::approx_fee_amount(netuid, (amount as f64 * 0.99) as u64);
+        // let fee = <Test as Config>::SwapInterface::approx_fee_amount(netuid.into(), (amount as f64 * 0.99) as u64);
         assert_abs_diff_eq!(
             SubtensorModule::get_coldkey_balance(&coldkey_account_id),
             (amount as f64 * 0.99) as u64 - fee,
@@ -5653,7 +5665,7 @@ fn test_move_stake_limit_partial() {
         SubnetTAO::<Test>::insert(destination_netuid, (tao_reserve * 100_000).to_num::<u64>());
         SubnetAlphaIn::<Test>::insert(destination_netuid, (alpha_in * 100_000).to_num::<u64>());
         let current_price =
-            <Test as pallet::Config>::SwapInterface::current_alpha_price(origin_netuid);
+            <Test as pallet::Config>::SwapInterface::current_alpha_price(origin_netuid.into());
         assert_eq!(current_price, U96F32::from_num(1.5));
 
         // The relative price between origin and destination subnets is 1.
@@ -5988,11 +6000,12 @@ fn test_stake_into_subnet_ok() {
         let alpha_in = U96F32::from_num(1_000_000_000_000_u64);
         mock::setup_reserves(netuid, tao_reserve.to_num(), alpha_in.to_num());
         let current_price =
-            <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid).to_num::<f64>();
+            <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid.into())
+                .to_num::<f64>();
 
         // Initialize swap v3
         assert_ok!(<tests::mock::Test as pallet::Config>::SwapInterface::swap(
-            netuid,
+            netuid.into(),
             OrderType::Buy,
             0,
             0,
@@ -6036,11 +6049,12 @@ fn test_stake_into_subnet_low_amount() {
         let alpha_in = U96F32::from_num(1_000_000_000_000_u64);
         mock::setup_reserves(netuid, tao_reserve.to_num(), alpha_in.to_num());
         let current_price =
-            <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid).to_num::<f64>();
+            <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid.into())
+                .to_num::<f64>();
 
         // Initialize swap v3
         assert_ok!(<tests::mock::Test as pallet::Config>::SwapInterface::swap(
-            netuid,
+            netuid.into(),
             OrderType::Buy,
             0,
             0,
@@ -6086,7 +6100,7 @@ fn test_unstake_from_subnet_low_amount() {
 
         // Initialize swap v3
         assert_ok!(<tests::mock::Test as pallet::Config>::SwapInterface::swap(
-            netuid,
+            netuid.into(),
             OrderType::Buy,
             0,
             0,
@@ -6140,7 +6154,7 @@ fn test_stake_into_subnet_prohibitive_limit() {
 
         // Initialize swap v3
         assert_ok!(<tests::mock::Test as pallet::Config>::SwapInterface::swap(
-            netuid,
+            netuid.into(),
             OrderType::Buy,
             0,
             0,
@@ -6195,7 +6209,7 @@ fn test_unstake_from_subnet_prohibitive_limit() {
 
         // Initialize swap v3
         assert_ok!(<tests::mock::Test as pallet::Config>::SwapInterface::swap(
-            netuid,
+            netuid.into(),
             OrderType::Buy,
             0,
             0,
@@ -6268,7 +6282,7 @@ fn test_unstake_full_amount() {
 
         // Initialize swap v3
         assert_ok!(<tests::mock::Test as pallet::Config>::SwapInterface::swap(
-            netuid,
+            netuid.into(),
             OrderType::Buy,
             0,
             0,
@@ -6389,16 +6403,17 @@ fn test_swap_fees_tao_correctness() {
 
         // Add owner coldkey Alpha as concentrated liquidity
         // between current price current price + 0.01
-        let current_price = <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid)
-            .to_num::<f64>()
-            + 0.0001;
+        let current_price =
+            <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid.into())
+                .to_num::<f64>()
+                + 0.0001;
         let limit_price = current_price + 0.01;
         let tick_low = price_to_tick(current_price);
         let tick_high = price_to_tick(limit_price);
         let liquidity = amount;
 
         assert_ok!(<Test as pallet::Config>::SwapInterface::do_add_liquidity(
-            NetUid::from(netuid),
+            netuid.into(),
             &owner_coldkey,
             &owner_hotkey,
             tick_low,
@@ -6620,7 +6635,7 @@ fn test_default_min_stake_sufficiency() {
         let alpha_in = U96F32::from_num(21_000_000_000_000_000_u64);
         mock::setup_reserves(netuid, tao_reserve.to_num(), alpha_in.to_num());
         let current_price_before =
-            <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid);
+            <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid.into());
 
         // Stake and unstake
         assert_ok!(SubtensorModule::add_stake(
@@ -6631,7 +6646,7 @@ fn test_default_min_stake_sufficiency() {
         ));
         let fee_stake = (fee_rate * amount as f64) as u64;
         let current_price_after_stake =
-            <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid);
+            <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid.into());
 
         let user_alpha = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
             &owner_hotkey,
@@ -6646,7 +6661,7 @@ fn test_default_min_stake_sufficiency() {
         ));
         let fee_unstake = (fee_rate * user_alpha as f64) as u64;
         let current_price_after_unstake =
-            <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid);
+            <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid.into());
 
         assert!(fee_stake > 0);
         assert!(fee_unstake > 0);
diff --git a/pallets/subtensor/src/tests/staking2.rs b/pallets/subtensor/src/tests/staking2.rs
index e5bc16dd0a..058ba7416a 100644
--- a/pallets/subtensor/src/tests/staking2.rs
+++ b/pallets/subtensor/src/tests/staking2.rs
@@ -673,7 +673,7 @@ fn test_stake_fee_api() {
             stake_amount,
         );
         let dynamic_fee_0 =
-            <Test as Config>::SwapInterface::approx_fee_amount(netuid0, stake_amount);
+            <Test as Config>::SwapInterface::approx_fee_amount(netuid0.into(), stake_amount);
         assert_eq!(stake_fee_0, dynamic_fee_0);
 
         // Test stake fee for remove on root
@@ -685,7 +685,7 @@ fn test_stake_fee_api() {
             stake_amount,
         );
         let dynamic_fee_1 =
-            <Test as Config>::SwapInterface::approx_fee_amount(root_netuid, stake_amount);
+            <Test as Config>::SwapInterface::approx_fee_amount(root_netuid.into(), stake_amount);
         assert_eq!(stake_fee_1, dynamic_fee_1);
 
         // Test stake fee for move from root to non-root
@@ -697,7 +697,7 @@ fn test_stake_fee_api() {
             stake_amount,
         );
         let dynamic_fee_2 =
-            <Test as Config>::SwapInterface::approx_fee_amount(netuid0, stake_amount);
+            <Test as Config>::SwapInterface::approx_fee_amount(netuid0.into(), stake_amount);
         assert_eq!(stake_fee_2, dynamic_fee_2);
 
         // Test stake fee for move between hotkeys on root
@@ -709,7 +709,7 @@ fn test_stake_fee_api() {
             stake_amount,
         );
         let dynamic_fee_3 =
-            <Test as Config>::SwapInterface::approx_fee_amount(root_netuid, stake_amount);
+            <Test as Config>::SwapInterface::approx_fee_amount(root_netuid.into(), stake_amount);
         assert_eq!(stake_fee_3, dynamic_fee_3);
 
         // Test stake fee for move between coldkeys on root
@@ -721,7 +721,7 @@ fn test_stake_fee_api() {
             stake_amount,
         );
         let dynamic_fee_4 =
-            <Test as Config>::SwapInterface::approx_fee_amount(root_netuid, stake_amount);
+            <Test as Config>::SwapInterface::approx_fee_amount(root_netuid.into(), stake_amount);
         assert_eq!(stake_fee_4, dynamic_fee_4);
 
         // Test stake fee for *swap* from non-root to root
@@ -733,7 +733,7 @@ fn test_stake_fee_api() {
             stake_amount,
         );
         let dynamic_fee_5 =
-            <Test as Config>::SwapInterface::approx_fee_amount(root_netuid, stake_amount);
+            <Test as Config>::SwapInterface::approx_fee_amount(root_netuid.into(), stake_amount);
         assert_eq!(stake_fee_5, dynamic_fee_5);
 
         // Test stake fee for move between hotkeys on non-root
@@ -745,7 +745,7 @@ fn test_stake_fee_api() {
             stake_amount,
         );
         let dynamic_fee_6 =
-            <Test as Config>::SwapInterface::approx_fee_amount(netuid0, stake_amount);
+            <Test as Config>::SwapInterface::approx_fee_amount(netuid0.into(), stake_amount);
         assert_eq!(stake_fee_6, dynamic_fee_6);
 
         // Test stake fee for move between coldkeys on non-root
@@ -757,7 +757,7 @@ fn test_stake_fee_api() {
             stake_amount,
         );
         let dynamic_fee_7 =
-            <Test as Config>::SwapInterface::approx_fee_amount(netuid0, stake_amount);
+            <Test as Config>::SwapInterface::approx_fee_amount(netuid0.into(), stake_amount);
         assert_eq!(stake_fee_7, dynamic_fee_7);
 
         // Test stake fee for *swap* from non-root to non-root
@@ -769,7 +769,7 @@ fn test_stake_fee_api() {
             stake_amount,
         );
         let dynamic_fee_8 =
-            <Test as Config>::SwapInterface::approx_fee_amount(netuid1, stake_amount);
+            <Test as Config>::SwapInterface::approx_fee_amount(netuid1.into(), stake_amount);
         assert_eq!(stake_fee_8, dynamic_fee_8);
     });
 }
@@ -813,29 +813,32 @@ fn test_stake_fee_calculation() {
         // Test stake fee for add_stake
 
         // Default for adding stake
-        let stake_fee = <Test as Config>::SwapInterface::approx_fee_amount(netuid0, stake_amount);
+        let stake_fee =
+            <Test as Config>::SwapInterface::approx_fee_amount(netuid0.into(), stake_amount);
         assert_eq!(stake_fee, default_fee);
 
         // Test stake fee for remove on root
         let stake_fee =
-            <Test as Config>::SwapInterface::approx_fee_amount(root_netuid, stake_amount); // Default for removing stake from root
+            <Test as Config>::SwapInterface::approx_fee_amount(root_netuid.into(), stake_amount); // Default for removing stake from root
         assert_eq!(stake_fee, default_fee);
 
         // Test stake fee for move from root to non-root
 
         // Default for moving stake from root to non-root
-        let stake_fee = <Test as Config>::SwapInterface::approx_fee_amount(netuid0, stake_amount);
+        let stake_fee =
+            <Test as Config>::SwapInterface::approx_fee_amount(netuid0.into(), stake_amount);
         assert_eq!(stake_fee, default_fee);
 
         // Test stake fee for move between hotkeys on root
         let stake_fee =
-            <Test as Config>::SwapInterface::approx_fee_amount(root_netuid, stake_amount); // Default for moving stake between hotkeys on root
+            <Test as Config>::SwapInterface::approx_fee_amount(root_netuid.into(), stake_amount); // Default for moving stake between hotkeys on root
         assert_eq!(stake_fee, default_fee);
 
         // Test stake fee for *swap* from non-root to non-root
 
         // Charged a dynamic fee
-        let stake_fee = <Test as Config>::SwapInterface::approx_fee_amount(netuid1, stake_amount);
+        let stake_fee =
+            <Test as Config>::SwapInterface::approx_fee_amount(netuid1.into(), stake_amount);
         assert_ne!(stake_fee, default_fee);
     });
 }
diff --git a/pallets/subtensor/src/tests/swap_coldkey.rs b/pallets/subtensor/src/tests/swap_coldkey.rs
index ddd9931613..8565bd2f00 100644
--- a/pallets/subtensor/src/tests/swap_coldkey.rs
+++ b/pallets/subtensor/src/tests/swap_coldkey.rs
@@ -12,7 +12,8 @@ use frame_system::{Config, RawOrigin};
 use sp_core::{Get, H256, U256};
 use sp_runtime::DispatchError;
 use substrate_fixed::types::U96F32;
-use subtensor_swap_interface::{OrderType, SubnetInfo, SwapHandler};
+use subtensor_runtime_common::SubnetInfo;
+use subtensor_swap_interface::{OrderType, SwapHandler};
 
 use super::mock;
 use super::mock::*;
diff --git a/pallets/subtensor/src/tests/weights.rs b/pallets/subtensor/src/tests/weights.rs
index 96dd950b64..e7403ce6f2 100644
--- a/pallets/subtensor/src/tests/weights.rs
+++ b/pallets/subtensor/src/tests/weights.rs
@@ -336,7 +336,8 @@ fn test_set_weights_validate() {
         );
 
         // Increase the stake and make it to be equal to the minimum threshold
-        let fee = <Test as pallet::Config>::SwapInterface::approx_fee_amount(netuid, min_stake);
+        let fee =
+            <Test as pallet::Config>::SwapInterface::approx_fee_amount(netuid.into(), min_stake);
         assert_ok!(SubtensorModule::do_add_stake(
             RuntimeOrigin::signed(hotkey),
             hotkey,
diff --git a/pallets/swap-interface/Cargo.toml b/pallets/swap-interface/Cargo.toml
index cdde4a78b2..5af146881c 100644
--- a/pallets/swap-interface/Cargo.toml
+++ b/pallets/swap-interface/Cargo.toml
@@ -8,6 +8,7 @@ codec = { workspace = true }
 frame-support = { workspace = true }
 scale-info = { workspace = true }
 substrate-fixed = { workspace = true }
+subtensor-runtime-common = { workspace = true }
 
 [lints]
 workspace = true
@@ -19,4 +20,5 @@ std = [
 	"frame-support/std",
 	"scale-info/std",
 	"substrate-fixed/std",
+	"subtensor-runtime-common/std",
 ]
diff --git a/pallets/swap-interface/src/lib.rs b/pallets/swap-interface/src/lib.rs
index 78d80a8e1b..6d2c080568 100644
--- a/pallets/swap-interface/src/lib.rs
+++ b/pallets/swap-interface/src/lib.rs
@@ -2,6 +2,7 @@
 
 use frame_support::pallet_prelude::*;
 use substrate_fixed::types::U96F32;
+use subtensor_runtime_common::NetUid;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum OrderType {
@@ -11,15 +12,19 @@ pub enum OrderType {
 
 pub trait SwapHandler<AccountId> {
     fn swap(
-        netuid: u16,
+        netuid: NetUid,
         order_t: OrderType,
         amount: u64,
         price_limit: u64,
         should_rollback: bool,
     ) -> Result<SwapResult, DispatchError>;
-    fn sim_swap(netuid: u16, order_t: OrderType, amount: u64) -> Result<SwapResult, DispatchError>;
-    fn approx_fee_amount(netuid: u16, amount: u64) -> u64;
-    fn current_alpha_price(netuid: u16) -> U96F32;
+    fn sim_swap(
+        netuid: NetUid,
+        order_t: OrderType,
+        amount: u64,
+    ) -> Result<SwapResult, DispatchError>;
+    fn approx_fee_amount(netuid: NetUid, amount: u64) -> u64;
+    fn current_alpha_price(netuid: NetUid) -> U96F32;
     fn max_price() -> u64;
     fn min_price() -> u64;
 }
@@ -41,30 +46,3 @@ pub struct UpdateLiquidityResult {
     pub fee_tao: u64,
     pub fee_alpha: u64,
 }
-
-pub trait SubnetInfo<AccountId> {
-    fn tao_reserve(netuid: u16) -> u64;
-    fn alpha_reserve(netuid: u16) -> u64;
-    fn exists(netuid: u16) -> bool;
-    fn mechanism(netuid: u16) -> u16;
-    fn is_owner(account_id: &AccountId, netuid: u16) -> bool;
-}
-
-pub trait BalanceOps<AccountId> {
-    fn tao_balance(account_id: &AccountId) -> u64;
-    fn alpha_balance(netuid: u16, coldkey: &AccountId, hotkey: &AccountId) -> u64;
-    fn increase_balance(coldkey: &AccountId, tao: u64);
-    fn decrease_balance(coldkey: &AccountId, tao: u64) -> Result<u64, DispatchError>;
-    fn increase_stake(
-        coldkey: &AccountId,
-        hotkey: &AccountId,
-        netuid: u16,
-        alpha: u64,
-    ) -> Result<(), DispatchError>;
-    fn decrease_stake(
-        coldkey: &AccountId,
-        hotkey: &AccountId,
-        netuid: u16,
-        alpha: u64,
-    ) -> Result<u64, DispatchError>;
-}
diff --git a/pallets/swap/Cargo.toml b/pallets/swap/Cargo.toml
index df7ee91686..9a455b1f85 100644
--- a/pallets/swap/Cargo.toml
+++ b/pallets/swap/Cargo.toml
@@ -21,8 +21,9 @@ sp-std = { workspace = true }
 substrate-fixed = { workspace = true }
 
 pallet-subtensor-swap-runtime-api = { workspace = true }
-subtensor-swap-interface = { workspace = true }
 subtensor-macros = { workspace = true }
+subtensor-runtime-common = {workspace = true}
+subtensor-swap-interface = { workspace = true }
 
 [lints]
 workspace = true
@@ -45,6 +46,7 @@ std = [
 	"sp-runtime/std",
 	"sp-std/std",
 	"substrate-fixed/std",
+	"subtensor-runtime-common/std",
 	"subtensor-swap-interface/std",
 ]
 runtime-benchmarks = [
diff --git a/pallets/swap/src/benchmarking.rs b/pallets/swap/src/benchmarking.rs
index 566294010b..838a5e7def 100644
--- a/pallets/swap/src/benchmarking.rs
+++ b/pallets/swap/src/benchmarking.rs
@@ -8,9 +8,9 @@ use frame_benchmarking::v2::*;
 use frame_support::traits::Get;
 use frame_system::RawOrigin;
 use substrate_fixed::types::U64F64;
+use subtensor_runtime_common::NetUid;
 
 use crate::{
-    NetUid,
     pallet::{
         AlphaSqrtPrice, Call, Config, CurrentLiquidity, CurrentTick, EnabledUserLiquidity, Pallet,
         Positions, SwapV3Initialized,
@@ -25,7 +25,7 @@ mod benchmarks {
 
     #[benchmark]
     fn set_fee_rate() {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let rate: u16 = 100; // Some arbitrary fee rate value
 
         #[extrinsic_call]
@@ -45,14 +45,16 @@ mod benchmarks {
 
         let caller: T::AccountId = whitelisted_caller();
         let hotkey: T::AccountId = account("hotkey", 0, 0);
+        let tick_low = TickIndex::new_unchecked(-1000);
+        let tick_high = TickIndex::new_unchecked(1000);
 
         #[extrinsic_call]
         add_liquidity(
             RawOrigin::Signed(caller),
             hotkey,
-            netuid.into(),
-            -10000,
-            10000,
+            netuid,
+            tick_low,
+            tick_high,
             1000,
         );
     }
diff --git a/pallets/swap/src/lib.rs b/pallets/swap/src/lib.rs
index 823ea7cd72..75961b73d1 100644
--- a/pallets/swap/src/lib.rs
+++ b/pallets/swap/src/lib.rs
@@ -1,9 +1,6 @@
 #![cfg_attr(not(feature = "std"), no_std)]
 
-use codec::{Decode, Encode, MaxEncodedLen};
-use frame_support::pallet_prelude::*;
 use substrate_fixed::types::U64F64;
-use subtensor_macros::freeze_struct;
 use subtensor_swap_interface::OrderType;
 
 pub mod pallet;
@@ -20,21 +17,3 @@ pub mod benchmarking;
 pub(crate) mod mock;
 
 type SqrtPrice = U64F64;
-
-#[freeze_struct("2a62496e31bbcddc")]
-#[derive(
-    Clone, Copy, Decode, Default, Encode, Eq, MaxEncodedLen, PartialEq, RuntimeDebug, TypeInfo,
-)]
-pub struct NetUid(u16);
-
-impl From<NetUid> for u16 {
-    fn from(val: NetUid) -> Self {
-        val.0
-    }
-}
-
-impl From<u16> for NetUid {
-    fn from(value: u16) -> Self {
-        Self(value)
-    }
-}
diff --git a/pallets/swap/src/mock.rs b/pallets/swap/src/mock.rs
index 9c9e9bc1ce..cb241d444e 100644
--- a/pallets/swap/src/mock.rs
+++ b/pallets/swap/src/mock.rs
@@ -14,9 +14,9 @@ use sp_runtime::{
     BuildStorage,
     traits::{BlakeTwo256, IdentityLookup},
 };
-use subtensor_swap_interface::{BalanceOps, SubnetInfo};
+use subtensor_runtime_common::{BalanceOps, NetUid, SubnetInfo};
 
-use crate::{NetUid, pallet::EnabledUserLiquidity};
+use crate::pallet::EnabledUserLiquidity;
 
 construct_runtime!(
     pub enum Test {
@@ -81,29 +81,29 @@ parameter_types! {
 pub struct MockLiquidityProvider;
 
 impl SubnetInfo<AccountId> for MockLiquidityProvider {
-    fn tao_reserve(netuid: u16) -> u64 {
-        match netuid {
-            123 => 10_000,
+    fn tao_reserve(netuid: NetUid) -> u64 {
+        match netuid.into() {
+            123u16 => 10_000,
             _ => 1_000_000_000_000,
         }
     }
 
-    fn alpha_reserve(netuid: u16) -> u64 {
-        match netuid {
-            123 => 10_000,
+    fn alpha_reserve(netuid: NetUid) -> u64 {
+        match netuid.into() {
+            123u16 => 10_000,
             _ => 4_000_000_000_000,
         }
     }
 
-    fn exists(netuid: u16) -> bool {
-        netuid != NON_EXISTENT_NETUID
+    fn exists(netuid: NetUid) -> bool {
+        netuid != NON_EXISTENT_NETUID.into()
     }
 
-    fn mechanism(netuid: u16) -> u16 {
-        if netuid == 0 { 0 } else { 1 }
+    fn mechanism(netuid: NetUid) -> u16 {
+        if netuid == NetUid::from(0) { 0 } else { 1 }
     }
 
-    fn is_owner(account_id: &AccountId, _netuid: u16) -> bool {
+    fn is_owner(account_id: &AccountId, _netuid: NetUid) -> bool {
         *account_id != NOT_SUBNET_OWNER
     }
 }
@@ -119,7 +119,11 @@ impl BalanceOps<AccountId> for MockBalanceOps {
         }
     }
 
-    fn alpha_balance(_: u16, coldkey_account_id: &AccountId, hotkey_account_id: &AccountId) -> u64 {
+    fn alpha_balance(
+        _: NetUid,
+        coldkey_account_id: &AccountId,
+        hotkey_account_id: &AccountId,
+    ) -> u64 {
         if (*coldkey_account_id == OK_COLDKEY_ACCOUNT_ID)
             && (*hotkey_account_id == OK_HOTKEY_ACCOUNT_ID)
         {
@@ -138,7 +142,7 @@ impl BalanceOps<AccountId> for MockBalanceOps {
     fn increase_stake(
         _coldkey: &AccountId,
         _hotkey: &AccountId,
-        _netuid: u16,
+        _netuid: NetUid,
         _alpha: u64,
     ) -> Result<(), DispatchError> {
         Ok(())
@@ -147,7 +151,7 @@ impl BalanceOps<AccountId> for MockBalanceOps {
     fn decrease_stake(
         _coldkey: &AccountId,
         _hotkey: &AccountId,
-        _netuid: u16,
+        _netuid: NetUid,
         alpha: u64,
     ) -> Result<u64, DispatchError> {
         Ok(alpha)
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 878b758f57..3580e78f68 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -7,13 +7,12 @@ use safe_math::*;
 use sp_arithmetic::helpers_128bit;
 use sp_runtime::traits::AccountIdConversion;
 use substrate_fixed::types::{U64F64, U96F32};
-use subtensor_swap_interface::{
-    BalanceOps, SubnetInfo, SwapHandler, SwapResult, UpdateLiquidityResult,
-};
+use subtensor_runtime_common::{BalanceOps, NetUid, SubnetInfo};
+use subtensor_swap_interface::{SwapHandler, SwapResult, UpdateLiquidityResult};
 
 use super::pallet::*;
 use crate::{
-    NetUid, OrderType, SqrtPrice,
+    OrderType, SqrtPrice,
     position::{Position, PositionId},
     tick::{ActiveTickIndexManager, Tick, TickIndex},
 };
@@ -902,11 +901,8 @@ impl<T: Config> Pallet<T> {
             // Check that user has enough balances
             ensure!(
                 T::BalanceOps::tao_balance(coldkey_account_id) >= tao
-                    && T::BalanceOps::alpha_balance(
-                        netuid.into(),
-                        coldkey_account_id,
-                        hotkey_account_id
-                    ) >= alpha,
+                    && T::BalanceOps::alpha_balance(netuid, coldkey_account_id, hotkey_account_id)
+                        >= alpha,
                 Error::<T>::InsufficientBalance
             );
         } else {
@@ -1076,7 +1072,7 @@ impl<T: Config> Pallet<T> {
 
 impl<T: Config> SwapHandler<T::AccountId> for Pallet<T> {
     fn swap(
-        netuid: u16,
+        netuid: NetUid,
         order_t: OrderType,
         amount: u64,
         price_limit: u64,
@@ -1097,7 +1093,11 @@ impl<T: Config> SwapHandler<T::AccountId> for Pallet<T> {
         .map_err(Into::into)
     }
 
-    fn sim_swap(netuid: u16, order_t: OrderType, amount: u64) -> Result<SwapResult, DispatchError> {
+    fn sim_swap(
+        netuid: NetUid,
+        order_t: OrderType,
+        amount: u64,
+    ) -> Result<SwapResult, DispatchError> {
         match T::SubnetInfo::mechanism(netuid) {
             1 => {
                 let price_limit = match order_t {
@@ -1117,11 +1117,11 @@ impl<T: Config> SwapHandler<T::AccountId> for Pallet<T> {
         }
     }
 
-    fn approx_fee_amount(netuid: u16, amount: u64) -> u64 {
+    fn approx_fee_amount(netuid: NetUid, amount: u64) -> u64 {
         Self::calculate_fee_amount(netuid.into(), amount)
     }
 
-    fn current_alpha_price(netuid: u16) -> U96F32 {
+    fn current_alpha_price(netuid: NetUid) -> U96F32 {
         Self::current_price(netuid.into())
     }
 
diff --git a/pallets/swap/src/pallet/mod.rs b/pallets/swap/src/pallet/mod.rs
index b51a887803..f9cb9f0f36 100644
--- a/pallets/swap/src/pallet/mod.rs
+++ b/pallets/swap/src/pallet/mod.rs
@@ -3,10 +3,9 @@ use core::num::NonZeroU64;
 use frame_support::{PalletId, pallet_prelude::*, traits::Get};
 use frame_system::pallet_prelude::*;
 use substrate_fixed::types::U64F64;
-use subtensor_swap_interface::{BalanceOps, SubnetInfo};
+use subtensor_runtime_common::{BalanceOps, NetUid, SubnetInfo};
 
 use crate::{
-    NetUid,
     position::{Position, PositionId},
     tick::{LayerLevel, Tick, TickIndex},
     weights::WeightInfo,
@@ -157,9 +156,9 @@ mod pallet {
             /// The hotkey account associated with the position
             hotkey: T::AccountId,
             /// The subnet identifier
-            netuid: u16,
+            netuid: NetUid,
             /// Unique identifier for the liquidity position
-            position_id: u128,
+            position_id: PositionId,
             /// The amount of liquidity added to the position
             liquidity: u64,
             /// The amount of TAO tokens committed to the position
@@ -173,9 +172,9 @@ mod pallet {
             /// The coldkey account that owns the position
             coldkey: T::AccountId,
             /// The subnet identifier
-            netuid: u16,
+            netuid: NetUid,
             /// Unique identifier for the liquidity position
-            position_id: u128,
+            position_id: PositionId,
             /// The amount of TAO tokens returned to the user
             tao: u64,
             /// The amount of Alpha tokens returned to the user
@@ -238,24 +237,21 @@ mod pallet {
         /// Only callable by the admin origin
         #[pallet::call_index(0)]
         #[pallet::weight(<T as pallet::Config>::WeightInfo::set_fee_rate())]
-        pub fn set_fee_rate(origin: OriginFor<T>, netuid: u16, rate: u16) -> DispatchResult {
+        pub fn set_fee_rate(origin: OriginFor<T>, netuid: NetUid, rate: u16) -> DispatchResult {
             if ensure_root(origin.clone()).is_err() {
                 let account_id: T::AccountId = ensure_signed(origin)?;
                 ensure!(
-                    T::SubnetInfo::is_owner(&account_id, netuid),
+                    T::SubnetInfo::is_owner(&account_id, netuid.into()),
                     DispatchError::BadOrigin
                 );
             }
 
             // Ensure that the subnet exists.
             ensure!(
-                T::SubnetInfo::exists(netuid),
+                T::SubnetInfo::exists(netuid.into()),
                 Error::<T>::SubNetworkDoesNotExist
             );
 
-            // using u16 for compatibility
-            let netuid = netuid.into();
-
             ensure!(rate <= T::MaxFeeRate::get(), Error::<T>::FeeRateTooHigh);
 
             FeeRate::<T>::insert(netuid, rate);
@@ -271,22 +267,20 @@ mod pallet {
         /// Only callable by the admin origin
         #[pallet::call_index(4)]
         #[pallet::weight(<T as pallet::Config>::WeightInfo::set_enabled_user_liquidity())]
-        pub fn set_enabled_user_liquidity(origin: OriginFor<T>, netuid: u16) -> DispatchResult {
+        pub fn set_enabled_user_liquidity(origin: OriginFor<T>, netuid: NetUid) -> DispatchResult {
             if ensure_root(origin.clone()).is_err() {
                 let account_id: T::AccountId = ensure_signed(origin)?;
                 ensure!(
-                    T::SubnetInfo::is_owner(&account_id, netuid),
+                    T::SubnetInfo::is_owner(&account_id, netuid.into()),
                     DispatchError::BadOrigin
                 );
             }
 
             ensure!(
-                T::SubnetInfo::exists(netuid),
+                T::SubnetInfo::exists(netuid.into()),
                 Error::<T>::SubNetworkDoesNotExist
             );
 
-            let netuid = netuid.into();
-
             EnabledUserLiquidity::<T>::insert(netuid, true);
 
             Self::deposit_event(Event::UserLiquidityEnabled { netuid });
@@ -309,21 +303,19 @@ mod pallet {
         pub fn add_liquidity(
             origin: OriginFor<T>,
             hotkey: T::AccountId,
-            netuid: u16,
-            tick_low: i32,
-            tick_high: i32,
+            netuid: NetUid,
+            tick_low: TickIndex,
+            tick_high: TickIndex,
             liquidity: u64,
         ) -> DispatchResult {
             let coldkey = ensure_signed(origin)?;
 
             // Ensure that the subnet exists.
             ensure!(
-                T::SubnetInfo::exists(netuid),
+                T::SubnetInfo::exists(netuid.into()),
                 Error::<T>::SubNetworkDoesNotExist
             );
 
-            let tick_low = TickIndex::new(tick_low).map_err(|_| Error::<T>::InvalidTickRange)?;
-            let tick_high = TickIndex::new(tick_high).map_err(|_| Error::<T>::InvalidTickRange)?;
             let (position_id, tao, alpha) = Self::do_add_liquidity(
                 netuid.into(),
                 &coldkey,
@@ -337,7 +329,8 @@ mod pallet {
             let tao_provided = T::BalanceOps::decrease_balance(&coldkey, tao)?;
             ensure!(tao_provided == tao, Error::<T>::InsufficientBalance);
 
-            let alpha_provided = T::BalanceOps::decrease_stake(&coldkey, &hotkey, netuid, alpha)?;
+            let alpha_provided =
+                T::BalanceOps::decrease_stake(&coldkey, &hotkey, netuid.into(), alpha)?;
             ensure!(alpha_provided == alpha, Error::<T>::InsufficientBalance);
 
             // Emit an event
@@ -345,7 +338,7 @@ mod pallet {
                 coldkey,
                 hotkey,
                 netuid,
-                position_id: position_id.into(),
+                position_id,
                 liquidity,
                 tao,
                 alpha,
@@ -367,26 +360,26 @@ mod pallet {
         pub fn remove_liquidity(
             origin: OriginFor<T>,
             hotkey: T::AccountId,
-            netuid: u16,
-            position_id: u128,
+            netuid: NetUid,
+            position_id: PositionId,
         ) -> DispatchResult {
             let coldkey = ensure_signed(origin)?;
 
             // Ensure that the subnet exists.
             ensure!(
-                T::SubnetInfo::exists(netuid),
+                T::SubnetInfo::exists(netuid.into()),
                 Error::<T>::SubNetworkDoesNotExist
             );
 
             // Remove liquidity
-            let result = Self::do_remove_liquidity(netuid.into(), &coldkey, position_id.into())?;
+            let result = Self::do_remove_liquidity(netuid, &coldkey, position_id)?;
 
             // Credit the returned tao and alpha to the account
             T::BalanceOps::increase_balance(&coldkey, result.tao.saturating_add(result.fee_tao));
             T::BalanceOps::increase_stake(
                 &coldkey,
                 &hotkey,
-                netuid,
+                netuid.into(),
                 result.alpha.saturating_add(result.fee_alpha),
             )?;
 
@@ -418,26 +411,21 @@ mod pallet {
         pub fn modify_position(
             origin: OriginFor<T>,
             hotkey: T::AccountId,
-            netuid: u16,
-            position_id: u128,
+            netuid: NetUid,
+            position_id: PositionId,
             liquidity_delta: i64,
         ) -> DispatchResult {
             let coldkey = ensure_signed(origin)?;
 
             // Ensure that the subnet exists.
             ensure!(
-                T::SubnetInfo::exists(netuid),
+                T::SubnetInfo::exists(netuid.into()),
                 Error::<T>::SubNetworkDoesNotExist
             );
 
             // Add or remove liquidity
-            let result = Self::do_modify_position(
-                netuid.into(),
-                &coldkey,
-                &hotkey,
-                position_id.into(),
-                liquidity_delta,
-            )?;
+            let result =
+                Self::do_modify_position(netuid, &coldkey, &hotkey, position_id, liquidity_delta)?;
 
             if liquidity_delta > 0 {
                 // Remove TAO and Alpha balances or fail transaction if they can't be removed exactly
@@ -445,7 +433,7 @@ mod pallet {
                 ensure!(tao_provided == result.tao, Error::<T>::InsufficientBalance);
 
                 let alpha_provided =
-                    T::BalanceOps::decrease_stake(&coldkey, &hotkey, netuid, result.alpha)?;
+                    T::BalanceOps::decrease_stake(&coldkey, &hotkey, netuid.into(), result.alpha)?;
                 ensure!(
                     alpha_provided == result.alpha,
                     Error::<T>::InsufficientBalance
@@ -464,12 +452,12 @@ mod pallet {
             } else {
                 // Credit the returned tao and alpha to the account
                 T::BalanceOps::increase_balance(&coldkey, result.tao);
-                T::BalanceOps::increase_stake(&coldkey, &hotkey, netuid, result.alpha)?;
+                T::BalanceOps::increase_stake(&coldkey, &hotkey, netuid.into(), result.alpha)?;
 
                 // Emit an event
                 Self::deposit_event(Event::LiquidityRemoved {
                     coldkey: coldkey.clone(),
-                    netuid: netuid.into(),
+                    netuid,
                     position_id,
                     tao: result.tao,
                     alpha: result.alpha,
@@ -483,7 +471,12 @@ mod pallet {
                 T::BalanceOps::increase_balance(&coldkey, result.fee_tao);
             }
             if result.fee_alpha > 0 {
-                T::BalanceOps::increase_stake(&coldkey, &hotkey.clone(), netuid, result.fee_alpha)?;
+                T::BalanceOps::increase_stake(
+                    &coldkey,
+                    &hotkey.clone(),
+                    netuid.into(),
+                    result.fee_alpha,
+                )?;
             }
 
             Ok(())
diff --git a/pallets/swap/src/pallet/tests.rs b/pallets/swap/src/pallet/tests.rs
index 1083d8d6a9..d20ada5c84 100644
--- a/pallets/swap/src/pallet/tests.rs
+++ b/pallets/swap/src/pallet/tests.rs
@@ -7,9 +7,10 @@ use frame_support::{assert_err, assert_noop, assert_ok};
 use sp_arithmetic::helpers_128bit;
 use sp_runtime::DispatchError;
 use substrate_fixed::types::U96F32;
+use subtensor_runtime_common::NetUid;
 
 use super::*;
-use crate::{NetUid, OrderType, SqrtPrice, mock::*};
+use crate::{OrderType, SqrtPrice, mock::*};
 
 // this function is used to convert price (NON-SQRT price!) to TickIndex. it's only utility for
 // testing, all the implementation logic is based on sqrt prices
@@ -78,18 +79,18 @@ mod dispatchables {
     #[test]
     fn test_set_fee_rate() {
         new_test_ext().execute_with(|| {
-            let netuid = 1u16;
+            let netuid = NetUid::from(1);
             let fee_rate = 500; // 0.76% fee
 
             assert_noop!(
-                Swap::set_fee_rate(RuntimeOrigin::signed(666), netuid.into(), fee_rate),
+                Swap::set_fee_rate(RuntimeOrigin::signed(666), netuid, fee_rate),
                 DispatchError::BadOrigin
             );
 
             assert_ok!(Swap::set_fee_rate(RuntimeOrigin::root(), netuid, fee_rate));
 
             // Check that fee rate was set correctly
-            assert_eq!(FeeRate::<Test>::get(NetUid::from(netuid)), fee_rate);
+            assert_eq!(FeeRate::<Test>::get(netuid), fee_rate);
 
             let fee_rate = fee_rate * 2;
             assert_ok!(Swap::set_fee_rate(
@@ -97,7 +98,7 @@ mod dispatchables {
                 netuid,
                 fee_rate
             ));
-            assert_eq!(FeeRate::<Test>::get(NetUid::from(netuid)), fee_rate);
+            assert_eq!(FeeRate::<Test>::get(netuid), fee_rate);
 
             // Verify fee rate validation - should fail if too high
             let too_high_fee = MaxFeeRate::get() + 1;
@@ -133,7 +134,7 @@ mod dispatchables {
             ));
 
             assert_noop!(
-                Swap::set_enabled_user_liquidity(RuntimeOrigin::root(), NON_EXISTENT_NETUID),
+                Swap::set_enabled_user_liquidity(RuntimeOrigin::root(), NON_EXISTENT_NETUID.into()),
                 Error::<Test>::SubNetworkDoesNotExist
             );
         });
@@ -800,7 +801,7 @@ fn test_swap_single_position() {
     let min_price = tick_to_price(TickIndex::MIN);
     let max_price = tick_to_price(TickIndex::MAX);
     let max_tick = price_to_tick(max_price);
-    let netuid = NetUid(1);
+    let netuid = NetUid::from(1);
     assert_eq!(max_tick, TickIndex::MAX);
 
     let mut current_price_low = 0_f64;
@@ -1059,7 +1060,7 @@ fn test_swap_multiple_positions() {
         let min_price = tick_to_price(TickIndex::MIN);
         let max_price = tick_to_price(TickIndex::MAX);
         let max_tick = price_to_tick(max_price);
-        let netuid = NetUid(1);
+        let netuid = NetUid::from(1);
         assert_eq!(max_tick, TickIndex::MAX);
 
         //////////////////////////////////////////////
@@ -1348,7 +1349,7 @@ fn test_user_liquidity_disabled() {
         let netuid = NetUid::from(101);
         let tick_low = TickIndex::new_unchecked(-1000);
         let tick_high = TickIndex::new_unchecked(1000);
-        let position_id = 1;
+        let position_id = PositionId::from(1);
         let liquidity = 1_000_000_000;
         let liquidity_delta = 500_000_000;
 
@@ -1367,7 +1368,7 @@ fn test_user_liquidity_disabled() {
         );
 
         assert_noop!(
-            Swap::do_remove_liquidity(netuid, &OK_COLDKEY_ACCOUNT_ID, position_id.into()),
+            Swap::do_remove_liquidity(netuid, &OK_COLDKEY_ACCOUNT_ID, position_id),
             Error::<Test>::UserLiquidityDisabled
         );
 
@@ -1375,7 +1376,7 @@ fn test_user_liquidity_disabled() {
             Swap::modify_position(
                 RuntimeOrigin::signed(OK_COLDKEY_ACCOUNT_ID),
                 OK_HOTKEY_ACCOUNT_ID,
-                netuid.into(),
+                netuid,
                 position_id,
                 liquidity_delta
             ),
@@ -1384,7 +1385,7 @@ fn test_user_liquidity_disabled() {
 
         assert_ok!(Swap::set_enabled_user_liquidity(
             RuntimeOrigin::root(),
-            netuid.into()
+            netuid
         ));
 
         let position_id = Swap::do_add_liquidity(
@@ -1407,7 +1408,7 @@ fn test_user_liquidity_disabled() {
         ));
 
         assert_ok!(Swap::do_remove_liquidity(
-            netuid.into(),
+            netuid,
             &OK_COLDKEY_ACCOUNT_ID,
             position_id,
         ));
diff --git a/pallets/swap/src/position.rs b/pallets/swap/src/position.rs
index 1ab233a322..a5abbb6a00 100644
--- a/pallets/swap/src/position.rs
+++ b/pallets/swap/src/position.rs
@@ -5,10 +5,11 @@ use frame_support::pallet_prelude::*;
 use safe_math::*;
 use substrate_fixed::types::U64F64;
 use subtensor_macros::freeze_struct;
+use subtensor_runtime_common::NetUid;
 
+use crate::SqrtPrice;
 use crate::pallet::{Config, Error, FeeGlobalAlpha, FeeGlobalTao, LastPositionId};
 use crate::tick::TickIndex;
-use crate::{NetUid, SqrtPrice};
 
 /// Position designates one liquidity position.
 ///
diff --git a/pallets/swap/src/tick.rs b/pallets/swap/src/tick.rs
index 5dce895113..e723dd6394 100644
--- a/pallets/swap/src/tick.rs
+++ b/pallets/swap/src/tick.rs
@@ -7,18 +7,19 @@ use core::hash::Hash;
 use core::ops::{Add, AddAssign, BitOr, Deref, Neg, Shl, Shr, Sub, SubAssign};
 
 use alloy_primitives::{I256, U256};
-use codec::{Decode, Encode, MaxEncodedLen};
+use codec::{Decode, Encode, Error as CodecError, Input, MaxEncodedLen};
 use frame_support::pallet_prelude::*;
 use safe_math::*;
 use sp_std::vec;
 use sp_std::vec::Vec;
 use substrate_fixed::types::U64F64;
 use subtensor_macros::freeze_struct;
+use subtensor_runtime_common::NetUid;
 
+use crate::SqrtPrice;
 use crate::pallet::{
     Config, CurrentTick, FeeGlobalAlpha, FeeGlobalTao, TickIndexBitmapWords, Ticks,
 };
-use crate::{NetUid, SqrtPrice};
 
 const U256_1: U256 = U256::from_limbs([1, 0, 0, 0]);
 const U256_2: U256 = U256::from_limbs([2, 0, 0, 0]);
@@ -94,14 +95,13 @@ impl Tick {
 }
 
 /// Struct representing a tick index
-#[freeze_struct("cdd46795662dcc43")]
+#[freeze_struct("31577b3ad1f55092")]
 #[derive(
     Debug,
     Default,
     Clone,
     Copy,
     Encode,
-    Decode,
     TypeInfo,
     MaxEncodedLen,
     PartialEq,
@@ -112,6 +112,13 @@ impl Tick {
 )]
 pub struct TickIndex(i32);
 
+impl Decode for TickIndex {
+    fn decode<I: Input>(input: &mut I) -> Result<Self, CodecError> {
+        let raw = i32::decode(input)?;
+        TickIndex::new(raw).map_err(|_| "TickIndex out of bounds".into())
+    }
+}
+
 impl Add<TickIndex> for TickIndex {
     type Output = Self;
 

From f384045e473e401092bc747349252dd0bf1df99e Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Tue, 3 Jun 2025 17:12:04 +0200
Subject: [PATCH 234/418] Add NetUid type to common

---
 Cargo.lock                   |  2 ++
 common/Cargo.toml            |  3 ++-
 common/src/lib.rs            | 28 ++++++++++++++++++++
 pallets/subtensor/Cargo.toml | 50 +++++++++++++++++++-----------------
 4 files changed, 59 insertions(+), 24 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 1ec256be62..e1d8f6dc06 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6535,6 +6535,7 @@ dependencies = [
  "sp-version",
  "substrate-fixed",
  "subtensor-macros",
+ "subtensor-runtime-common",
  "tle",
  "w3f-bls",
 ]
@@ -11105,6 +11106,7 @@ dependencies = [
  "scale-info",
  "sp-core",
  "sp-runtime",
+ "subtensor-macros",
 ]
 
 [[package]]
diff --git a/common/Cargo.toml b/common/Cargo.toml
index d0b43cdc1b..24fc9947df 100644
--- a/common/Cargo.toml
+++ b/common/Cargo.toml
@@ -14,8 +14,9 @@ targets = ["x86_64-unknown-linux-gnu"]
 codec = { workspace = true }
 frame-support = { workspace = true }
 scale-info = { workspace = true }
-sp-runtime = { workspace = true }
 sp-core = { workspace = true }
+sp-runtime = { workspace = true }
+subtensor-macros = { workspace = true }
 
 [lints]
 workspace = true
diff --git a/common/src/lib.rs b/common/src/lib.rs
index 75b18e3b14..ccfba79b9c 100644
--- a/common/src/lib.rs
+++ b/common/src/lib.rs
@@ -1,11 +1,13 @@
 #![cfg_attr(not(feature = "std"), no_std)]
 
 use codec::{Decode, Encode, MaxEncodedLen};
+use frame_support::pallet_prelude::*;
 use scale_info::TypeInfo;
 use sp_runtime::{
     MultiSignature,
     traits::{IdentifyAccount, Verify},
 };
+use subtensor_macros::freeze_struct;
 
 /// Balance of an account.
 pub type Balance = u64;
@@ -31,6 +33,32 @@ pub type Nonce = u32;
 /// Transfers below SMALL_TRANSFER_LIMIT are considered small transfers
 pub const SMALL_TRANSFER_LIMIT: Balance = 500_000_000; // 0.5 TAO
 
+#[freeze_struct("2a62496e31bbcddc")]
+#[derive(
+    Clone, Copy, Decode, Default, Encode, Eq, MaxEncodedLen, PartialEq, RuntimeDebug, TypeInfo,
+)]
+pub struct NetUid(u16);
+
+impl NetUid {
+    pub const ROOT: NetUid = NetUid(0);
+
+    pub fn is_root(&self) -> bool {
+        *self == Self::ROOT
+    }
+}
+
+impl From<NetUid> for u16 {
+    fn from(val: NetUid) -> Self {
+        val.0
+    }
+}
+
+impl From<u16> for NetUid {
+    fn from(value: u16) -> Self {
+        Self(value)
+    }
+}
+
 #[derive(
     Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Encode, Decode, Debug, MaxEncodedLen, TypeInfo,
 )]
diff --git a/pallets/subtensor/Cargo.toml b/pallets/subtensor/Cargo.toml
index ab17cf5bdc..cd9cf258c1 100644
--- a/pallets/subtensor/Cargo.toml
+++ b/pallets/subtensor/Cargo.toml
@@ -49,13 +49,16 @@ pallet-collective = { version = "4.0.0-dev", default-features = false, path = ".
 pallet-drand = { path = "../drand", default-features = false }
 pallet-membership = { workspace = true }
 hex-literal = { workspace = true }
-num-traits = { version = "0.2.19", default-features = false, features = ["libm"] }
+num-traits = { version = "0.2.19", default-features = false, features = [
+	"libm",
+] }
 tle = { workspace = true, default-features = false }
 ark-bls12-381 = { workspace = true, default-features = false }
 ark-serialize = { workspace = true, default-features = false }
 w3f-bls = { workspace = true, default-features = false }
 sha2 = { workspace = true }
 rand_chacha = { workspace = true }
+subtensor-runtime-common = { workspace = true }
 
 [dev-dependencies]
 pallet-balances = { workspace = true, features = ["std"] }
@@ -70,47 +73,48 @@ sp-std = { workspace = true }
 pallet-preimage = { workspace = true }
 
 [features]
-default = ["std"]
 std = [
+	"ark-bls12-381/std",
+	"ark-serialize/std",
 	"codec/std",
 	"frame-benchmarking/std",
 	"frame-support/std",
 	"frame-system/std",
-	"scale-info/std",
+	"hex/std",
+	"libsecp256k1/std",
+	"log/std",
+	"ndarray/std",
+	"num-traits/std",
+	"pallet-balances/std",
 	"pallet-collective/std",
+	"pallet-drand/std",
 	"pallet-membership/std",
-	"substrate-fixed/std",
-	"pallet-balances/std",
 	"pallet-preimage/std",
 	"pallet-scheduler/std",
 	"pallet-transaction-payment/std",
 	"pallet-utility/std",
+	"rand_chacha/std",
+	"safe-math/std",
+	"scale-info/std",
+	"serde/std",
+	"serde_bytes/std",
+	"serde_json/std",
+	"serde_with/std",
+	"sha2/std",
+	"share-pool/std",
 	"sp-core/std",
 	"sp-io/std",
 	"sp-runtime/std",
 	"sp-std/std",
 	"sp-tracing/std",
 	"sp-version/std",
-	"hex/std",
-	"libsecp256k1/std",
-	"log/std",
-	"ndarray/std",
-	"serde/std",
-	"serde_bytes/std",
-	"serde_with/std",
 	"substrate-fixed/std",
-	"num-traits/std",
-	"serde_json/std",
+	"substrate-fixed/std",
+	"subtensor-runtime-common/std",
 	"tle/std",
-	"pallet-drand/std",
-	"ark-bls12-381/std",
-	"ark-serialize/std",
 	"w3f-bls/std",
-	"rand_chacha/std",
-	"safe-math/std",
-	"sha2/std",
-	"share-pool/std"
 ]
+default = ["std"]
 runtime-benchmarks = [
 	"frame-benchmarking/runtime-benchmarks",
 	"frame-support/runtime-benchmarks",
@@ -122,7 +126,7 @@ runtime-benchmarks = [
 	"pallet-collective/runtime-benchmarks",
 	"pallet-preimage/runtime-benchmarks",
 	"pallet-scheduler/runtime-benchmarks",
-	"pallet-drand/runtime-benchmarks"
+	"pallet-drand/runtime-benchmarks",
 ]
 try-runtime = [
 	"frame-support/try-runtime",
@@ -135,7 +139,7 @@ try-runtime = [
 	"pallet-utility/try-runtime",
 	"sp-runtime/try-runtime",
 	"pallet-collective/try-runtime",
-	"pallet-drand/try-runtime"
+	"pallet-drand/try-runtime",
 ]
 pow-faucet = []
 fast-blocks = []

From a6ee1c96060f4fba900ad4c94b944f386c4fc2cb Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Tue, 3 Jun 2025 21:00:09 -0400
Subject: [PATCH 235/418] Add changes from Max and Dr. Nick

---
 pallets/swap/src/pallet/impls.rs | 184 +++++++++++++++++++------------
 pallets/swap/src/tick.rs         |   4 +
 2 files changed, 115 insertions(+), 73 deletions(-)

diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 878b758f57..80f31b3f1a 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -25,7 +25,6 @@ struct SwapStep<T: frame_system::Config> {
     // Input parameters
     netuid: NetUid,
     order_type: OrderType,
-    first_step: bool,
 
     // Computed values
     current_liquidity: U64F64,
@@ -57,7 +56,6 @@ impl<T: Config> SwapStep<T> {
         order_type: OrderType,
         amount_remaining: u64,
         limit_sqrt_price: SqrtPrice,
-        first_step: bool,
     ) -> Self {
         // Calculate prices and ticks
         let current_tick = CurrentTick::<T>::get(netuid);
@@ -82,7 +80,6 @@ impl<T: Config> SwapStep<T> {
         Self {
             netuid,
             order_type,
-            first_step,
             target_sqrt_price,
             limit_sqrt_price,
             current_sqrt_price,
@@ -102,7 +99,7 @@ impl<T: Config> SwapStep<T> {
 
     /// Execute the swap step and return the result
     fn execute(&mut self) -> Result<SwapStepResult, Error<T>> {
-        self.determine_action()?;
+        self.determine_action();
         self.process_swap()
     }
 
@@ -119,25 +116,9 @@ impl<T: Config> SwapStep<T> {
     }
 
     /// Determine the appropriate action for this swap step
-    fn determine_action(&mut self) -> Result<(), Error<T>> {
+    fn determine_action(&mut self) {
         let mut recalculate_fee = false;
 
-        // For sell orders: If the current price matches the edge price, then cross the tick first,
-        // and then move the edge price to one active tick lower.
-        // Also, if this is the first swap step, cross the tick.
-        if (self.edge_sqrt_price == self.current_sqrt_price) && (self.order_type == OrderType::Sell)
-        {
-            if self.first_step {
-                self.cross_tick()?;
-            }
-            self.edge_tick = ActiveTickIndexManager::<T>::find_closest_lower(
-                self.netuid,
-                self.edge_tick.prev().unwrap_or(TickIndex::MIN),
-            )
-            .unwrap_or(TickIndex::MIN);
-            self.edge_sqrt_price = self.edge_tick.as_sqrt_price_bounded();
-        }
-
         // Calculate the stopping price: The price at which we either reach the limit price,
         // exchange the full amount, or reach the edge price.
         if self.tick_is_closer(&self.target_tick, &self.limit_tick)
@@ -176,6 +157,28 @@ impl<T: Config> SwapStep<T> {
             recalculate_fee = true;
         }
 
+        // println!("\tAction           : {:?}", self.action);
+        // println!(
+        //     "\tCurrent Price    : {}",
+        //     self.current_sqrt_price * self.current_sqrt_price
+        // );
+        // println!(
+        //     "\tTarget Price     : {}",
+        //     self.target_sqrt_price * self.target_sqrt_price
+        // );
+        // println!(
+        //     "\tLimit Price      : {}",
+        //     self.limit_sqrt_price * self.limit_sqrt_price
+        // );
+        // println!(
+        //     "\tEdge Price       : {}",
+        //     self.edge_sqrt_price * self.edge_sqrt_price
+        // );
+        // println!(
+        //     "\t{}",
+        //     format!("Delta In         : {}", self.delta_in).yellow()
+        // );
+
         // Because on step creation we calculate fee off the total amount, we might need to recalculate it
         // in case if we hit the limit price or the edge price.
         if recalculate_fee {
@@ -201,31 +204,6 @@ impl<T: Config> SwapStep<T> {
                 OrderType::Sell => SwapStepAction::Stop,
             };
         }
-
-        Ok(())
-    }
-
-    fn cross_tick(&self) -> Result<(), Error<T>> {
-        // Get current tick
-        let current_tick_index = TickIndex::current_bounded::<T>(self.netuid);
-
-        let mut tick = match self.order_type {
-            OrderType::Sell => {
-                Pallet::<T>::find_closest_lower_active_tick(self.netuid, current_tick_index)
-            }
-            OrderType::Buy => {
-                Pallet::<T>::find_closest_higher_active_tick(self.netuid, current_tick_index)
-            }
-        }
-        .ok_or(Error::<T>::InsufficientLiquidity)?;
-
-        tick.fees_out_tao = FeeGlobalTao::<T>::get(self.netuid).saturating_sub(tick.fees_out_tao);
-        tick.fees_out_alpha =
-            FeeGlobalAlpha::<T>::get(self.netuid).saturating_sub(tick.fees_out_alpha);
-        Pallet::<T>::update_liquidity_at_crossing(self.netuid, self.order_type)?;
-        Ticks::<T>::insert(self.netuid, current_tick_index, tick);
-
-        Ok(())
     }
 
     /// Process a single step of a swap
@@ -233,9 +211,28 @@ impl<T: Config> SwapStep<T> {
         // Hold the fees
         Pallet::<T>::add_fees(self.netuid, self.order_type, self.fee);
         let delta_out = Pallet::<T>::convert_deltas(self.netuid, self.order_type, self.delta_in);
+        // println!("\t{}", format!("Delta Out        : {}", delta_out).green());
+
+        // Get current tick
+        let current_tick_index = TickIndex::current_bounded::<T>(self.netuid);
 
         if self.action == SwapStepAction::Crossing {
-            self.cross_tick()?;
+            let mut tick = match self.order_type {
+                OrderType::Sell => {
+                    Pallet::<T>::find_closest_lower_active_tick(self.netuid, current_tick_index)
+                }
+                OrderType::Buy => {
+                    Pallet::<T>::find_closest_higher_active_tick(self.netuid, current_tick_index)
+                }
+            }
+            .ok_or(Error::<T>::InsufficientLiquidity)?;
+
+            tick.fees_out_tao =
+                FeeGlobalTao::<T>::get(self.netuid).saturating_sub(tick.fees_out_tao);
+            tick.fees_out_alpha =
+                FeeGlobalAlpha::<T>::get(self.netuid).saturating_sub(tick.fees_out_alpha);
+            Pallet::<T>::update_liquidity_at_crossing(self.netuid, self.order_type)?;
+            Ticks::<T>::insert(self.netuid, current_tick_index, tick);
         }
 
         // Update current price
@@ -352,7 +349,7 @@ impl<T: Config> Pallet<T> {
     /// - `netuid`: The identifier of the subnet on which the swap is performed.
     /// - `order_type`: The type of the swap (e.g., Buy or Sell).
     /// - `amount`: The amount of tokens to swap.
-    /// - `sqrt_price_limit`: A price limit (expressed as a square root) to bound the swap.
+    /// - `limit_sqrt_price`: A price limit (expressed as a square root) to bound the swap.
     /// - `simulate`: If `true`, the function runs in simulation mode and does not persist any changes.
     ///
     /// # Returns
@@ -372,7 +369,7 @@ impl<T: Config> Pallet<T> {
         netuid: NetUid,
         order_type: OrderType,
         amount: u64,
-        sqrt_price_limit: SqrtPrice,
+        limit_sqrt_price: SqrtPrice,
         simulate: bool,
     ) -> Result<SwapResult, DispatchError> {
         transactional::with_transaction(|| {
@@ -381,7 +378,7 @@ impl<T: Config> Pallet<T> {
             let alpha_reserve = T::SubnetInfo::alpha_reserve(netuid.into());
 
             let mut result =
-                Self::swap_inner(netuid, order_type, amount, sqrt_price_limit).map_err(Into::into);
+                Self::swap_inner(netuid, order_type, amount, limit_sqrt_price).map_err(Into::into);
 
             if simulate || result.is_err() {
                 // Simulation only
@@ -410,7 +407,7 @@ impl<T: Config> Pallet<T> {
         netuid: NetUid,
         order_type: OrderType,
         amount: u64,
-        sqrt_price_limit: SqrtPrice,
+        limit_sqrt_price: SqrtPrice,
     ) -> Result<SwapResult, Error<T>> {
         ensure!(
             T::SubnetInfo::tao_reserve(netuid.into()) >= T::MinimumReserve::get().get()
@@ -426,16 +423,20 @@ impl<T: Config> Pallet<T> {
         let mut in_acc: u64 = 0;
         let mut fee_acc: u64 = 0;
 
+        // println!("======== Start Swap ========");
+        // println!("Amount Remaining: {}", amount_remaining);
+
         // Swap one tick at a time until we reach one of the stop conditions
         while amount_remaining > 0 {
+            // println!("\nIteration: {}", iteration_counter);
+            // println!(
+            //     "\tCurrent Liquidity: {}",
+            //     CurrentLiquidity::<T>::get(netuid)
+            // );
+
             // Create and execute a swap step
-            let mut swap_step = SwapStep::<T>::new(
-                netuid,
-                order_type,
-                amount_remaining,
-                sqrt_price_limit,
-                iteration_counter == 0,
-            );
+            let mut swap_step =
+                SwapStep::<T>::new(netuid, order_type, amount_remaining, limit_sqrt_price);
 
             let swap_result = swap_step.execute()?;
 
@@ -461,6 +462,9 @@ impl<T: Config> Pallet<T> {
             );
         }
 
+        // println!("\nAmount Paid Out: {}", amount_paid_out);
+        // println!("======== End Swap ========");
+
         let tao_reserve = T::SubnetInfo::tao_reserve(netuid.into());
         let alpha_reserve = T::SubnetInfo::alpha_reserve(netuid.into());
         let (new_tao_reserve, new_alpha_reserve) = match order_type {
@@ -491,19 +495,27 @@ impl<T: Config> Pallet<T> {
     /// the edge that is impossible to execute
     fn tick_edge(netuid: NetUid, current_tick: TickIndex, order_type: OrderType) -> TickIndex {
         match order_type {
-            OrderType::Buy => {
-                let higher_tick =
-                    ActiveTickIndexManager::<T>::find_closest_higher(netuid, current_tick)
-                        .unwrap_or(TickIndex::MAX);
-                if higher_tick < TickIndex::MAX {
-                    higher_tick.saturating_add(1)
-                } else {
-                    higher_tick
-                }
-            }
+            OrderType::Buy => ActiveTickIndexManager::<T>::find_closest_higher(
+                netuid,
+                current_tick.next().unwrap_or(TickIndex::MAX),
+            )
+            .unwrap_or(TickIndex::MAX),
             OrderType::Sell => {
-                ActiveTickIndexManager::<T>::find_closest_lower(netuid, current_tick)
+                let current_price = Pallet::<T>::current_price_sqrt(netuid);
+                let current_tick_price = current_tick.as_sqrt_price_bounded();
+                let is_active = ActiveTickIndexManager::<T>::tick_is_active(netuid, current_tick);
+
+                let lower_tick = if is_active && current_price > current_tick_price {
+                    ActiveTickIndexManager::<T>::find_closest_lower(netuid, current_tick)
+                        .unwrap_or(TickIndex::MIN)
+                } else {
+                    ActiveTickIndexManager::<T>::find_closest_lower(
+                        netuid,
+                        current_tick.prev().unwrap_or(TickIndex::MIN),
+                    )
                     .unwrap_or(TickIndex::MIN)
+                };
+                lower_tick
             }
         }
     }
@@ -635,8 +647,34 @@ impl<T: Config> Pallet<T> {
 
         // Find the appropriate tick based on order type
         let tick = match order_type {
-            OrderType::Sell => Self::find_closest_lower_active_tick(netuid, current_tick_index),
-            OrderType::Buy => Self::find_closest_higher_active_tick(netuid, current_tick_index),
+            OrderType::Sell => {
+                // Self::find_closest_lower_active_tick(netuid, current_tick_index)
+                let current_price = Pallet::<T>::current_price_sqrt(netuid);
+                let current_tick_price = current_tick_index.as_sqrt_price_bounded();
+                let is_active =
+                    ActiveTickIndexManager::<T>::tick_is_active(netuid, current_tick_index);
+
+                let lower_tick = if is_active && current_price > current_tick_price {
+                    ActiveTickIndexManager::<T>::find_closest_lower(netuid, current_tick_index)
+                        .unwrap_or(TickIndex::MIN)
+                } else {
+                    ActiveTickIndexManager::<T>::find_closest_lower(
+                        netuid,
+                        current_tick_index.prev().unwrap_or(TickIndex::MIN),
+                    )
+                    .unwrap_or(TickIndex::MIN)
+                };
+                Ticks::<T>::get(netuid, lower_tick)
+            }
+            OrderType::Buy => {
+                // Self::find_closest_higher_active_tick(netuid, current_tick_index),
+                let upper_tick = ActiveTickIndexManager::<T>::find_closest_higher(
+                    netuid,
+                    current_tick_index.next().unwrap_or(TickIndex::MAX),
+                )
+                .unwrap_or(TickIndex::MAX);
+                Ticks::<T>::get(netuid, upper_tick)
+            }
         }
         .ok_or(Error::<T>::InsufficientLiquidity)?;
 
@@ -1082,7 +1120,7 @@ impl<T: Config> SwapHandler<T::AccountId> for Pallet<T> {
         price_limit: u64,
         should_rollback: bool,
     ) -> Result<SwapResult, DispatchError> {
-        let sqrt_price_limit = SqrtPrice::saturating_from_num(price_limit)
+        let limit_sqrt_price = SqrtPrice::saturating_from_num(price_limit)
             .safe_div(SqrtPrice::saturating_from_num(1_000_000_000))
             .checked_sqrt(SqrtPrice::saturating_from_num(0.0000000001))
             .ok_or(Error::<T>::PriceLimitExceeded)?;
@@ -1091,7 +1129,7 @@ impl<T: Config> SwapHandler<T::AccountId> for Pallet<T> {
             NetUid::from(netuid),
             order_t,
             amount,
-            sqrt_price_limit,
+            limit_sqrt_price,
             should_rollback,
         )
         .map_err(Into::into)
diff --git a/pallets/swap/src/tick.rs b/pallets/swap/src/tick.rs
index 5dce895113..db33043ff1 100644
--- a/pallets/swap/src/tick.rs
+++ b/pallets/swap/src/tick.rs
@@ -693,6 +693,10 @@ impl<T: Config> ActiveTickIndexManager<T> {
         // Convert the result offset_index back to a tick index
         TickIndex::from_offset_index(result).ok()
     }
+
+    pub fn tick_is_active(netuid: NetUid, tick: TickIndex) -> bool {
+        Self::find_closest_lower(netuid, tick).unwrap_or(TickIndex::MAX) == tick
+    }
 }
 
 /// Represents the three layers in the Uniswap V3 bitmap structure

From 82c10e4e7a3f94c2d4002fe539ffcc4085c8cfe7 Mon Sep 17 00:00:00 2001
From: Ken Jon <kenjon@Kens-MacBook-Air.local>
Date: Wed, 4 Jun 2025 12:02:10 +0100
Subject: [PATCH 236/418] updated spec version to 275

---
 runtime/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index 73b99914fb..b5be536ac5 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -209,7 +209,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
     //   `spec_version`, and `authoring_version` are the same between Wasm and native.
     // This value is set to 100 to notify Polkadot-JS App (https://polkadot.js.org/apps) to use
     //   the compatible custom types.
-    spec_version: 274,
+    spec_version: 275,
     impl_version: 1,
     apis: RUNTIME_API_VERSIONS,
     transaction_version: 1,

From ff01f9e68ddac36f4deb89a66f5fc76829ad647c Mon Sep 17 00:00:00 2001
From: John Reed <87283488+JohnReedV@users.noreply.github.com>
Date: Wed, 4 Jun 2025 08:57:54 -0700
Subject: [PATCH 237/418] update weight values

---
 pallets/subtensor/src/macros/dispatches.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/pallets/subtensor/src/macros/dispatches.rs b/pallets/subtensor/src/macros/dispatches.rs
index 59777e2399..434291c45d 100644
--- a/pallets/subtensor/src/macros/dispatches.rs
+++ b/pallets/subtensor/src/macros/dispatches.rs
@@ -937,9 +937,9 @@ mod dispatches {
 
         /// The extrinsic for user to change its hotkey in subnet or all subnets.
         #[pallet::call_index(70)]
-        #[pallet::weight((Weight::from_parts(240_600_000, 0)
-        .saturating_add(T::DbWeight::get().reads(31))
-        .saturating_add(T::DbWeight::get().writes(23)), DispatchClass::Operational, Pays::No))]
+        #[pallet::weight((Weight::from_parts(285_900_000, 0)
+        .saturating_add(T::DbWeight::get().reads(47))
+        .saturating_add(T::DbWeight::get().writes(37)), DispatchClass::Operational, Pays::No))]
         pub fn swap_hotkey(
             origin: OriginFor<T>,
             hotkey: T::AccountId,

From c19138464045b321881d576eca6f5205fe8d52a8 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Tue, 3 Jun 2025 20:59:08 +0200
Subject: [PATCH 238/418] Replace u16 with NetUid for subnet id

---
 common/src/lib.rs                             |  49 +++-
 .../subtensor/src/coinbase/block_emission.rs  |   3 +-
 pallets/subtensor/src/coinbase/block_step.rs  |  11 +-
 pallets/subtensor/src/coinbase/root.rs        |  94 +++---
 .../subtensor/src/coinbase/run_coinbase.rs    |  60 ++--
 pallets/subtensor/src/epoch/run_epoch.rs      |  83 +++---
 pallets/subtensor/src/lib.rs                  | 272 ++++++++++--------
 pallets/subtensor/src/macros/dispatches.rs    |  76 ++---
 pallets/subtensor/src/macros/events.rs        | 152 +++++-----
 pallets/subtensor/src/macros/genesis.rs       |  26 +-
 .../migrations/migrate_create_root_network.rs |  24 +-
 .../migrations/migrate_delete_subnet_21.rs    |   5 +-
 .../src/migrations/migrate_delete_subnet_3.rs |   4 +-
 .../subtensor/src/migrations/migrate_rao.rs   |   8 +-
 ...migrate_set_first_emission_block_number.rs |   2 +-
 .../src/migrations/migrate_set_min_burn.rs    |   6 +-
 .../migrations/migrate_set_min_difficulty.rs  |   6 +-
 .../migrate_set_subtoken_enabled.rs           |   2 +-
 .../migrate_to_v1_separate_emission.rs        |   2 +-
 ...igrate_transfer_ownership_to_foundation.rs |   8 +-
 .../subtensor/src/rpc_info/delegate_info.rs   |  24 +-
 .../subtensor/src/rpc_info/dynamic_info.rs    |   9 +-
 pallets/subtensor/src/rpc_info/metagraph.rs   |  19 +-
 pallets/subtensor/src/rpc_info/neuron_info.rs |  27 +-
 pallets/subtensor/src/rpc_info/show_subnet.rs |   7 +-
 pallets/subtensor/src/rpc_info/stake_info.rs  |  24 +-
 pallets/subtensor/src/rpc_info/subnet_info.rs |  39 +--
 pallets/subtensor/src/staking/add_stake.rs    |  13 +-
 pallets/subtensor/src/staking/helpers.rs      |   3 +-
 pallets/subtensor/src/staking/move_stake.rs   |  43 ++-
 .../subtensor/src/staking/recycle_alpha.rs    |   9 +-
 pallets/subtensor/src/staking/remove_stake.rs |  21 +-
 pallets/subtensor/src/staking/set_children.rs |  15 +-
 pallets/subtensor/src/staking/stake_utils.rs  |  93 +++---
 pallets/subtensor/src/subnets/registration.rs |  15 +-
 pallets/subtensor/src/subnets/serving.rs      |  15 +-
 pallets/subtensor/src/subnets/subnet.rs       |  41 +--
 pallets/subtensor/src/subnets/symbols.rs      |   9 +-
 pallets/subtensor/src/subnets/uids.rs         |  41 +--
 pallets/subtensor/src/subnets/weights.rs      |  52 ++--
 pallets/subtensor/src/swap/swap_hotkey.rs     |   4 +-
 pallets/subtensor/src/utils/evm.rs            |   5 +-
 pallets/subtensor/src/utils/identity.rs       |   3 +-
 pallets/subtensor/src/utils/misc.rs           | 248 ++++++++--------
 pallets/subtensor/src/utils/rate_limiting.rs  |  14 +-
 45 files changed, 883 insertions(+), 803 deletions(-)

diff --git a/common/src/lib.rs b/common/src/lib.rs
index ccfba79b9c..ea624081a0 100644
--- a/common/src/lib.rs
+++ b/common/src/lib.rs
@@ -1,6 +1,7 @@
 #![cfg_attr(not(feature = "std"), no_std)]
+use core::fmt::{self, Display, Formatter};
 
-use codec::{Decode, Encode, MaxEncodedLen};
+use codec::{Compact, CompactAs, Decode, Encode, Error as CodecError, MaxEncodedLen};
 use frame_support::pallet_prelude::*;
 use scale_info::TypeInfo;
 use sp_runtime::{
@@ -33,18 +34,58 @@ pub type Nonce = u32;
 /// Transfers below SMALL_TRANSFER_LIMIT are considered small transfers
 pub const SMALL_TRANSFER_LIMIT: Balance = 500_000_000; // 0.5 TAO
 
-#[freeze_struct("2a62496e31bbcddc")]
+#[freeze_struct("45dfe0bb8f7886a9")]
+#[repr(transparent)]
 #[derive(
-    Clone, Copy, Decode, Default, Encode, Eq, MaxEncodedLen, PartialEq, RuntimeDebug, TypeInfo,
+    Clone,
+    Copy,
+    Decode,
+    Default,
+    Encode,
+    Eq,
+    MaxEncodedLen,
+    Ord,
+    PartialEq,
+    PartialOrd,
+    RuntimeDebug,
+    TypeInfo,
 )]
 pub struct NetUid(u16);
 
 impl NetUid {
-    pub const ROOT: NetUid = NetUid(0);
+    pub const ROOT: NetUid = Self(0);
 
     pub fn is_root(&self) -> bool {
         *self == Self::ROOT
     }
+
+    pub fn next(&self) -> NetUid {
+        Self(self.0.saturating_add(1))
+    }
+}
+
+impl Display for NetUid {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        Display::fmt(&self.0, f)
+    }
+}
+
+impl CompactAs for NetUid {
+    type As = u16;
+
+    fn encode_as(&self) -> &Self::As {
+        &self.0
+    }
+
+    fn decode_from(v: Self::As) -> Result<Self, CodecError> {
+        Ok(Self(v))
+    }
+}
+
+impl From<Compact<NetUid>> for NetUid {
+    fn from(c: Compact<NetUid>) -> Self {
+        c.0
+    }
 }
 
 impl From<NetUid> for u16 {
diff --git a/pallets/subtensor/src/coinbase/block_emission.rs b/pallets/subtensor/src/coinbase/block_emission.rs
index cd9d778b8a..f1c8478e22 100644
--- a/pallets/subtensor/src/coinbase/block_emission.rs
+++ b/pallets/subtensor/src/coinbase/block_emission.rs
@@ -5,6 +5,7 @@ use substrate_fixed::{
     transcendental::log2,
     types::{I96F32, U96F32},
 };
+use subtensor_runtime_common::NetUid;
 
 impl<T: Config> Pallet<T> {
     /// Calculates the dynamic TAO emission for a given subnet.
@@ -29,7 +30,7 @@ impl<T: Config> Pallet<T> {
     /// It also ensures that the total amount of alpha_in_emission + alpha_out_emission sum to 2 * alpha_block_emission
     /// It also ensures that 1 < alpha_out_emission < 2 * alpha_block_emission and 0 < alpha_in_emission < alpha_block_emission.
     pub fn get_dynamic_tao_emission(
-        netuid: u16,
+        netuid: NetUid,
         tao_emission: u64,
         alpha_block_emission: u64,
     ) -> (u64, u64, u64) {
diff --git a/pallets/subtensor/src/coinbase/block_step.rs b/pallets/subtensor/src/coinbase/block_step.rs
index a7e658e89a..d003a698e3 100644
--- a/pallets/subtensor/src/coinbase/block_step.rs
+++ b/pallets/subtensor/src/coinbase/block_step.rs
@@ -1,7 +1,7 @@
 use super::*;
-use frame_support::storage::IterableStorageMap;
 use safe_math::*;
 use substrate_fixed::types::{U96F32, U110F18};
+use subtensor_runtime_common::NetUid;
 
 impl<T: Config + pallet_drand::Config> Pallet<T> {
     /// Executes the necessary operations for each block.
@@ -23,8 +23,7 @@ impl<T: Config + pallet_drand::Config> Pallet<T> {
     }
 
     fn try_set_pending_children(block_number: u64) {
-        let subnets: Vec<u16> = Self::get_all_subnet_netuids();
-        for &netuid in subnets.iter() {
+        for netuid in Self::get_all_subnet_netuids() {
             if Self::should_run_epoch(netuid, block_number) {
                 // Set pending children on the epoch.
                 Self::do_set_pending_children(netuid);
@@ -38,7 +37,7 @@ impl<T: Config + pallet_drand::Config> Pallet<T> {
         log::debug!("adjust_registration_terms_for_networks");
 
         // --- 1. Iterate through each network.
-        for (netuid, _) in <NetworksAdded<T> as IterableStorageMap<u16, bool>>::iter() {
+        for (netuid, _) in NetworksAdded::<T>::iter() {
             // --- 2. Pull counters for network difficulty.
             let last_adjustment_block: u64 = Self::get_last_adjustment_block(netuid);
             let adjustment_interval: u16 = Self::get_adjustment_interval(netuid);
@@ -194,7 +193,7 @@ impl<T: Config + pallet_drand::Config> Pallet<T> {
     /// We use U110F18 to avoid any overflows on u64. Also min_difficulty and max_difficulty bound the range.
     ///
     pub fn upgraded_difficulty(
-        netuid: u16,
+        netuid: NetUid,
         current_difficulty: u64,
         registrations_this_interval: u16,
         target_registrations_per_interval: u16,
@@ -228,7 +227,7 @@ impl<T: Config + pallet_drand::Config> Pallet<T> {
     /// We use U110F18 to avoid any overflows on u64. Also min_burn and max_burn bound the range.
     ///
     pub fn upgraded_burn(
-        netuid: u16,
+        netuid: NetUid,
         current_burn: u64,
         registrations_this_interval: u16,
         target_registrations_per_interval: u16,
diff --git a/pallets/subtensor/src/coinbase/root.rs b/pallets/subtensor/src/coinbase/root.rs
index 1f3a91b339..32ead349a2 100644
--- a/pallets/subtensor/src/coinbase/root.rs
+++ b/pallets/subtensor/src/coinbase/root.rs
@@ -23,6 +23,7 @@ use safe_math::*;
 use sp_core::Get;
 use sp_std::vec;
 use substrate_fixed::types::I64F64;
+use subtensor_runtime_common::NetUid;
 
 impl<T: Config> Pallet<T> {
     /// Fetches the total count of root network validators
@@ -33,7 +34,7 @@ impl<T: Config> Pallet<T> {
     /// * 'u16': The total number of root network validators
     ///
     pub fn get_num_root_validators() -> u16 {
-        Self::get_subnetwork_n(Self::get_root_netuid())
+        Self::get_subnetwork_n(NetUid::ROOT)
     }
 
     /// Fetches the max validators count of root network.
@@ -44,7 +45,7 @@ impl<T: Config> Pallet<T> {
     /// * 'u16': The max validators count of root network.
     ///
     pub fn get_max_root_validators() -> u16 {
-        Self::get_max_allowed_uids(Self::get_root_netuid())
+        Self::get_max_allowed_uids(NetUid::ROOT)
     }
 
     /// Checks for any UIDs in the given list that are either equal to the root netuid or exceed the total number of subnets.
@@ -57,7 +58,7 @@ impl<T: Config> Pallet<T> {
     /// # Returns:
     /// * 'bool': 'true' if any of the UIDs are invalid, 'false' otherwise.
     ///
-    pub fn contains_invalid_root_uids(netuids: &[u16]) -> bool {
+    pub fn contains_invalid_root_uids(netuids: &[NetUid]) -> bool {
         for netuid in netuids {
             if !Self::if_subnet_exist(*netuid) {
                 log::debug!(
@@ -79,11 +80,11 @@ impl<T: Config> Pallet<T> {
     ///
     pub fn get_root_weights() -> Vec<Vec<I64F64>> {
         // --- 0. The number of validators on the root network.
-        let n: usize = Self::get_num_root_validators() as usize;
+        let n = Self::get_num_root_validators() as usize;
 
         // --- 1 The number of subnets to validate.
         log::debug!("subnet size before cast: {:?}", Self::get_num_subnets());
-        let k: usize = Self::get_num_subnets() as usize;
+        let k = Self::get_num_subnets() as usize;
         log::debug!("n: {:?} k: {:?}", n, k);
 
         // --- 2. Initialize a 2D vector with zeros to store the weights. The dimensions are determined
@@ -95,8 +96,8 @@ impl<T: Config> Pallet<T> {
 
         // --- 3. Iterate over stored weights and fill the matrix.
         for (uid_i, weights_i) in
-            <Weights<T> as IterableStorageDoubleMap<u16, u16, Vec<(u16, u16)>>>::iter_prefix(
-                Self::get_root_netuid(),
+            <Weights<T> as IterableStorageDoubleMap<NetUid, u16, Vec<(u16, u16)>>>::iter_prefix(
+                NetUid::ROOT,
             )
         {
             // --- 4. Iterate over each weight entry in `weights_i` to update the corresponding value in the
@@ -108,7 +109,7 @@ impl<T: Config> Pallet<T> {
                     if let Some((w, _)) = weight
                         .iter_mut()
                         .zip(&subnet_list)
-                        .find(|(_, subnet)| *subnet == netuid)
+                        .find(|(_, subnet)| *subnet == &NetUid::from(*netuid))
                     {
                         *w = I64F64::saturating_from_num(*weight_ij);
                     }
@@ -134,10 +135,9 @@ impl<T: Config> Pallet<T> {
     ///
     pub fn do_root_register(origin: T::RuntimeOrigin, hotkey: T::AccountId) -> DispatchResult {
         // --- 0. Get the unique identifier (UID) for the root network.
-        let root_netuid: u16 = Self::get_root_netuid();
         let current_block_number: u64 = Self::get_current_block_as_u64();
         ensure!(
-            Self::if_subnet_exist(root_netuid),
+            Self::if_subnet_exist(NetUid::ROOT),
             Error::<T>::RootNetworkDoesNotExist
         );
 
@@ -151,21 +151,21 @@ impl<T: Config> Pallet<T> {
 
         // --- 2. Ensure that the number of registrations in this block doesn't exceed the allowed limit.
         ensure!(
-            Self::get_registrations_this_block(root_netuid)
-                < Self::get_max_registrations_per_block(root_netuid),
+            Self::get_registrations_this_block(NetUid::ROOT)
+                < Self::get_max_registrations_per_block(NetUid::ROOT),
             Error::<T>::TooManyRegistrationsThisBlock
         );
 
         // --- 3. Ensure that the number of registrations in this interval doesn't exceed thrice the target limit.
         ensure!(
-            Self::get_registrations_this_interval(root_netuid)
-                < Self::get_target_registrations_per_interval(root_netuid).saturating_mul(3),
+            Self::get_registrations_this_interval(NetUid::ROOT)
+                < Self::get_target_registrations_per_interval(NetUid::ROOT).saturating_mul(3),
             Error::<T>::TooManyRegistrationsThisInterval
         );
 
         // --- 4. Check if the hotkey is already registered. If so, error out.
         ensure!(
-            !Uids::<T>::contains_key(root_netuid, &hotkey),
+            !Uids::<T>::contains_key(NetUid::ROOT, &hotkey),
             Error::<T>::HotKeyAlreadyRegisteredInSubNet
         );
 
@@ -185,7 +185,7 @@ impl<T: Config> Pallet<T> {
             subnetwork_uid = current_num_root_validators;
 
             // --- 12.1.2 Add the new account and make them a member of the Senate.
-            Self::append_neuron(root_netuid, &hotkey, current_block_number);
+            Self::append_neuron(NetUid::ROOT, &hotkey, current_block_number);
             log::debug!("add new neuron: {:?} on uid {:?}", hotkey, subnetwork_uid);
         } else {
             // --- 13.1.1 The network is full. Perform replacement.
@@ -194,12 +194,8 @@ impl<T: Config> Pallet<T> {
             let mut lowest_uid: u16 = 0;
 
             // Iterate over all keys in the root network to find the neuron with the lowest stake.
-            for (uid_i, hotkey_i) in
-                <Keys<T> as IterableStorageDoubleMap<u16, u16, T::AccountId>>::iter_prefix(
-                    root_netuid,
-                )
-            {
-                let stake_i: u64 = Self::get_stake_for_hotkey_on_subnet(&hotkey_i, 0);
+            for (uid_i, hotkey_i) in Keys::<T>::iter_prefix(NetUid::ROOT) {
+                let stake_i = Self::get_stake_for_hotkey_on_subnet(&hotkey_i, NetUid::ROOT);
                 if stake_i < lowest_stake {
                     lowest_stake = stake_i;
                     lowest_uid = uid_i;
@@ -207,17 +203,17 @@ impl<T: Config> Pallet<T> {
             }
             subnetwork_uid = lowest_uid;
             let replaced_hotkey: T::AccountId =
-                Self::get_hotkey_for_net_and_uid(root_netuid, subnetwork_uid)?;
+                Self::get_hotkey_for_net_and_uid(NetUid::ROOT, subnetwork_uid)?;
 
             // --- 13.1.2 The new account has a higher stake than the one being replaced.
             ensure!(
-                lowest_stake < Self::get_stake_for_hotkey_on_subnet(&hotkey, 0),
+                lowest_stake < Self::get_stake_for_hotkey_on_subnet(&hotkey, NetUid::ROOT),
                 Error::<T>::StakeTooLowForRoot
             );
 
             // --- 13.1.3 The new account has a higher stake than the one being replaced.
             // Replace the neuron account with new information.
-            Self::replace_neuron(root_netuid, lowest_uid, &hotkey, current_block_number);
+            Self::replace_neuron(NetUid::ROOT, lowest_uid, &hotkey, current_block_number);
 
             log::debug!(
                 "replace neuron: {:?} with {:?} on uid {:?}",
@@ -239,19 +235,23 @@ impl<T: Config> Pallet<T> {
         // --- 15. Update the registration counters for both the block and interval.
         #[allow(clippy::arithmetic_side_effects)]
         // note this RA + clippy false positive is a known substrate issue
-        RegistrationsThisInterval::<T>::mutate(root_netuid, |val| *val += 1);
+        RegistrationsThisInterval::<T>::mutate(NetUid::ROOT, |val| *val += 1);
         #[allow(clippy::arithmetic_side_effects)]
         // note this RA + clippy false positive is a known substrate issue
-        RegistrationsThisBlock::<T>::mutate(root_netuid, |val| *val += 1);
+        RegistrationsThisBlock::<T>::mutate(NetUid::ROOT, |val| *val += 1);
 
         // --- 16. Log and announce the successful registration.
         log::debug!(
             "RootRegistered(netuid:{:?} uid:{:?} hotkey:{:?})",
-            root_netuid,
+            NetUid::ROOT,
             subnetwork_uid,
             hotkey
         );
-        Self::deposit_event(Event::NeuronRegistered(root_netuid, subnetwork_uid, hotkey));
+        Self::deposit_event(Event::NeuronRegistered(
+            NetUid::ROOT,
+            subnetwork_uid,
+            hotkey,
+        ));
 
         // --- 17. Finish and return success.
         Ok(())
@@ -270,10 +270,8 @@ impl<T: Config> Pallet<T> {
     // * 'DispatchResult': A result type indicating success or failure of the registration.
     //
     pub fn do_adjust_senate(origin: T::RuntimeOrigin, hotkey: T::AccountId) -> DispatchResult {
-        // --- 0. Get the unique identifier (UID) for the root network.
-        let root_netuid: u16 = Self::get_root_netuid();
         ensure!(
-            Self::if_subnet_exist(root_netuid),
+            Self::if_subnet_exist(NetUid::ROOT),
             Error::<T>::RootNetworkDoesNotExist
         );
 
@@ -287,7 +285,7 @@ impl<T: Config> Pallet<T> {
 
         // --- 2. Check if the hotkey is already registered to the root network. If not, error out.
         ensure!(
-            Uids::<T>::contains_key(root_netuid, &hotkey),
+            Uids::<T>::contains_key(NetUid::ROOT, &hotkey),
             Error::<T>::HotKeyNotRegisteredInSubNet
         );
 
@@ -332,12 +330,9 @@ impl<T: Config> Pallet<T> {
     // * 'Result<Option<&T::AccountId>, Error<T>>': A result containing the replaced member, if any.
     //
     fn join_senate_if_eligible(hotkey: &T::AccountId) -> Result<Option<&T::AccountId>, Error<T>> {
-        // Get the root network UID.
-        let root_netuid: u16 = Self::get_root_netuid();
-
         // --- 1. Check the hotkey is registered in the root network.
         ensure!(
-            Uids::<T>::contains_key(root_netuid, hotkey),
+            Uids::<T>::contains_key(NetUid::ROOT, hotkey),
             Error::<T>::HotKeyNotRegisteredInSubNet
         );
 
@@ -348,7 +343,7 @@ impl<T: Config> Pallet<T> {
         );
 
         // --- 3. Grab the hotkey's stake.
-        let current_stake = Self::get_stake_for_hotkey_on_subnet(hotkey, Self::get_root_netuid());
+        let current_stake = Self::get_stake_for_hotkey_on_subnet(hotkey, NetUid::ROOT);
 
         // Add the hotkey to the Senate.
         // If we're full, we'll swap out the lowest stake member.
@@ -357,15 +352,14 @@ impl<T: Config> Pallet<T> {
         if (members.len() as u32) == T::SenateMembers::max_members() {
             let mut sorted_members = members.clone();
             sorted_members.sort_by(|a, b| {
-                let a_stake = Self::get_stake_for_hotkey_on_subnet(a, Self::get_root_netuid());
-                let b_stake = Self::get_stake_for_hotkey_on_subnet(b, Self::get_root_netuid());
+                let a_stake = Self::get_stake_for_hotkey_on_subnet(a, NetUid::ROOT);
+                let b_stake = Self::get_stake_for_hotkey_on_subnet(b, NetUid::ROOT);
 
                 b_stake.cmp(&a_stake)
             });
 
             if let Some(last) = sorted_members.last() {
-                let last_stake =
-                    Self::get_stake_for_hotkey_on_subnet(last, Self::get_root_netuid());
+                let last_stake = Self::get_stake_for_hotkey_on_subnet(last, NetUid::ROOT);
 
                 if last_stake < current_stake {
                     // Swap the member with the lowest stake.
@@ -440,7 +434,7 @@ impl<T: Config> Pallet<T> {
     /// * 'SubNetworkDoesNotExist': If the specified network does not exist.
     /// * 'NotSubnetOwner': If the caller does not own the specified subnet.
     ///
-    pub fn user_remove_network(coldkey: T::AccountId, netuid: u16) -> dispatch::DispatchResult {
+    pub fn user_remove_network(coldkey: T::AccountId, netuid: NetUid) -> dispatch::DispatchResult {
         // --- 1. Ensure this subnet exists.
         ensure!(
             Self::if_subnet_exist(netuid),
@@ -481,7 +475,7 @@ impl<T: Config> Pallet<T> {
     /// # Note:
     /// This function does not emit any events, nor does it raise any errors. It silently
     /// returns if any internal checks fail.
-    pub fn remove_network(netuid: u16) {
+    pub fn remove_network(netuid: NetUid) {
         // --- 1. Return balance to subnet owner.
         let owner_coldkey: T::AccountId = SubnetOwner::<T>::get(netuid);
         let reserved_amount: u64 = Self::get_subnet_locked_balance(netuid);
@@ -512,20 +506,20 @@ impl<T: Config> Pallet<T> {
 
         // --- 9. Iterate over stored weights and fill the matrix.
         for (uid_i, weights_i) in
-            <Weights<T> as IterableStorageDoubleMap<u16, u16, Vec<(u16, u16)>>>::iter_prefix(
-                Self::get_root_netuid(),
+            <Weights<T> as IterableStorageDoubleMap<NetUid, u16, Vec<(u16, u16)>>>::iter_prefix(
+                NetUid::ROOT,
             )
         {
             // Create a new vector to hold modified weights.
-            let mut modified_weights: Vec<(u16, u16)> = weights_i.clone();
+            let mut modified_weights = weights_i.clone();
             // Iterate over each weight entry to potentially update it.
             for (subnet_id, weight) in modified_weights.iter_mut() {
-                if subnet_id == &netuid {
+                if subnet_id == &u16::from(netuid) {
                     // If the condition matches, modify the weight
                     *weight = 0; // Set weight to 0 for the matching subnet_id.
                 }
             }
-            Weights::<T>::insert(Self::get_root_netuid(), uid_i, modified_weights);
+            Weights::<T>::insert(NetUid::ROOT, uid_i, modified_weights);
         }
 
         // --- 10. Remove various network-related parameters.
@@ -621,7 +615,7 @@ impl<T: Config> Pallet<T> {
         lock_cost
     }
 
-    pub fn get_network_registered_block(netuid: u16) -> u64 {
+    pub fn get_network_registered_block(netuid: NetUid) -> u64 {
         NetworkRegisteredAt::<T>::get(netuid)
     }
     pub fn get_network_immunity_period() -> u64 {
diff --git a/pallets/subtensor/src/coinbase/run_coinbase.rs b/pallets/subtensor/src/coinbase/run_coinbase.rs
index 00b0c2fa55..833f0e7c8f 100644
--- a/pallets/subtensor/src/coinbase/run_coinbase.rs
+++ b/pallets/subtensor/src/coinbase/run_coinbase.rs
@@ -2,6 +2,7 @@ use super::*;
 use alloc::collections::BTreeMap;
 use safe_math::*;
 use substrate_fixed::types::U96F32;
+use subtensor_runtime_common::NetUid;
 use tle::stream_ciphers::AESGCMStreamCipherProvider;
 use tle::tlock::tld;
 
@@ -38,13 +39,13 @@ impl<T: Config> Pallet<T> {
         log::debug!("Current block: {:?}", current_block);
 
         // --- 1. Get all netuids (filter out root)
-        let subnets: Vec<u16> = Self::get_all_subnet_netuids()
+        let subnets: Vec<NetUid> = Self::get_all_subnet_netuids()
             .into_iter()
-            .filter(|netuid| *netuid != 0)
+            .filter(|netuid| *netuid != NetUid::ROOT)
             .collect();
         log::debug!("All subnet netuids: {:?}", subnets);
         // Filter out subnets with no first emission block number.
-        let subnets_to_emit_to: Vec<u16> = subnets
+        let subnets_to_emit_to: Vec<NetUid> = subnets
             .clone()
             .into_iter()
             .filter(|netuid| FirstEmissionBlockNumber::<T>::get(*netuid).is_some())
@@ -52,7 +53,7 @@ impl<T: Config> Pallet<T> {
         log::debug!("Subnets to emit to: {:?}", subnets_to_emit_to);
 
         // --- 2. Get sum of tao reserves ( in a later version we will switch to prices. )
-        let mut total_moving_prices: U96F32 = U96F32::saturating_from_num(0.0);
+        let mut total_moving_prices = U96F32::saturating_from_num(0.0);
         // Only get price EMA for subnets that we emit to.
         for netuid_i in subnets_to_emit_to.iter() {
             // Get and update the moving price of each subnet adding the total together.
@@ -63,9 +64,9 @@ impl<T: Config> Pallet<T> {
 
         // --- 3. Get subnet terms (tao_in, alpha_in, and alpha_out)
         // Computation is described in detail in the dtao whitepaper.
-        let mut tao_in: BTreeMap<u16, U96F32> = BTreeMap::new();
-        let mut alpha_in: BTreeMap<u16, U96F32> = BTreeMap::new();
-        let mut alpha_out: BTreeMap<u16, U96F32> = BTreeMap::new();
+        let mut tao_in: BTreeMap<NetUid, U96F32> = BTreeMap::new();
+        let mut alpha_in: BTreeMap<NetUid, U96F32> = BTreeMap::new();
+        let mut alpha_out: BTreeMap<NetUid, U96F32> = BTreeMap::new();
         // Only calculate for subnets that we are emitting to.
         for netuid_i in subnets_to_emit_to.iter() {
             // Get subnet price.
@@ -143,7 +144,7 @@ impl<T: Config> Pallet<T> {
         // Remove owner cuts here so that we can properly seperate root dividends in the next step.
         // Owner cuts are accumulated and then fed to the drain at the end of this func.
         let cut_percent: U96F32 = Self::get_float_subnet_owner_cut();
-        let mut owner_cuts: BTreeMap<u16, U96F32> = BTreeMap::new();
+        let mut owner_cuts: BTreeMap<NetUid, U96F32> = BTreeMap::new();
         for netuid_i in subnets_to_emit_to.iter() {
             // Get alpha out.
             let alpha_out_i: U96F32 = *alpha_out.get(netuid_i).unwrap_or(&asfloat!(0));
@@ -168,7 +169,7 @@ impl<T: Config> Pallet<T> {
             let alpha_out_i: U96F32 = *alpha_out.get(netuid_i).unwrap_or(&asfloat!(0.0));
             log::debug!("alpha_out_i: {:?}", alpha_out_i);
             // Get total TAO on root.
-            let root_tao: U96F32 = asfloat!(SubnetTAO::<T>::get(0));
+            let root_tao: U96F32 = asfloat!(SubnetTAO::<T>::get(NetUid::ROOT));
             log::debug!("root_tao: {:?}", root_tao);
             // Get total ALPHA on subnet.
             let alpha_issuance: U96F32 = asfloat!(Self::get_alpha_issuance(*netuid_i));
@@ -263,7 +264,7 @@ impl<T: Config> Pallet<T> {
     }
 
     pub fn calculate_dividends_and_incentives(
-        netuid: u16,
+        netuid: NetUid,
         hotkey_emission: Vec<(T::AccountId, u64, u64)>,
     ) -> (BTreeMap<T::AccountId, u64>, BTreeMap<T::AccountId, U96F32>) {
         // Accumulate emission of dividends and incentive per hotkey.
@@ -394,7 +395,7 @@ impl<T: Config> Pallet<T> {
     }
 
     pub fn distribute_dividends_and_incentives(
-        netuid: u16,
+        netuid: NetUid,
         owner_cut: u64,
         incentives: BTreeMap<T::AccountId, u64>,
         alpha_dividends: BTreeMap<T::AccountId, U96F32>,
@@ -483,16 +484,12 @@ impl<T: Config> Pallet<T> {
             Self::increase_stake_for_hotkey_and_coldkey_on_subnet(
                 &hotkey,
                 &Owner::<T>::get(hotkey.clone()),
-                Self::get_root_netuid(),
+                NetUid::ROOT,
                 tou64!(tao_take),
             );
             // Give rest to nominators.
             log::debug!("hotkey: {:?} root_tao: {:?}", hotkey, root_tao);
-            Self::increase_stake_for_hotkey_on_subnet(
-                &hotkey,
-                Self::get_root_netuid(),
-                tou64!(root_tao),
-            );
+            Self::increase_stake_for_hotkey_on_subnet(&hotkey, NetUid::ROOT, tou64!(root_tao));
             // Record root dividends for this validator on this subnet.
             TaoDividendsPerSubnet::<T>::mutate(netuid, hotkey.clone(), |divs| {
                 *divs = divs.saturating_add(tou64!(root_tao));
@@ -501,7 +498,7 @@ impl<T: Config> Pallet<T> {
     }
 
     pub fn get_stake_map(
-        netuid: u16,
+        netuid: NetUid,
         hotkeys: Vec<&T::AccountId>,
     ) -> BTreeMap<T::AccountId, (u64, u64)> {
         let mut stake_map: BTreeMap<T::AccountId, (u64, u64)> = BTreeMap::new();
@@ -509,15 +506,14 @@ impl<T: Config> Pallet<T> {
             // Get hotkey ALPHA on subnet.
             let alpha_stake: u64 = Self::get_stake_for_hotkey_on_subnet(hotkey, netuid);
             // Get hotkey TAO on root.
-            let root_stake: u64 =
-                Self::get_stake_for_hotkey_on_subnet(hotkey, Self::get_root_netuid());
+            let root_stake: u64 = Self::get_stake_for_hotkey_on_subnet(hotkey, NetUid::ROOT);
             stake_map.insert(hotkey.clone(), (alpha_stake, root_stake));
         }
         stake_map
     }
 
     pub fn calculate_dividend_and_incentive_distribution(
-        netuid: u16,
+        netuid: NetUid,
         pending_tao: u64,
         pending_validator_alpha: u64,
         hotkey_emission: Vec<(T::AccountId, u64, u64)>,
@@ -547,7 +543,7 @@ impl<T: Config> Pallet<T> {
     }
 
     pub fn drain_pending_emission(
-        netuid: u16,
+        netuid: NetUid,
         pending_alpha: u64,
         pending_tao: u64,
         pending_swapped: u64,
@@ -610,7 +606,7 @@ impl<T: Config> Pallet<T> {
 
     /// Returns the self contribution of a hotkey on a subnet.
     /// This is the portion of the hotkey's stake that is provided by itself, and not delegated to other hotkeys.
-    pub fn get_self_contribution(hotkey: &T::AccountId, netuid: u16) -> u64 {
+    pub fn get_self_contribution(hotkey: &T::AccountId, netuid: NetUid) -> u64 {
         // Get all childkeys for this hotkey.
         let childkeys = Self::get_children(hotkey, netuid);
         let mut remaining_proportion: U96F32 = U96F32::saturating_from_num(1.0);
@@ -625,10 +621,8 @@ impl<T: Config> Pallet<T> {
         let tao_weight: U96F32 = Self::get_tao_weight();
 
         // Get the hotkey's stake including weight
-        let root_stake: U96F32 = U96F32::saturating_from_num(Self::get_stake_for_hotkey_on_subnet(
-            hotkey,
-            Self::get_root_netuid(),
-        ));
+        let root_stake: U96F32 =
+            U96F32::saturating_from_num(Self::get_stake_for_hotkey_on_subnet(hotkey, NetUid::ROOT));
         let alpha_stake: U96F32 =
             U96F32::saturating_from_num(Self::get_stake_for_hotkey_on_subnet(hotkey, netuid));
 
@@ -658,7 +652,7 @@ impl<T: Config> Pallet<T> {
     ///
     pub fn get_parent_child_dividends_distribution(
         hotkey: &T::AccountId,
-        netuid: u16,
+        netuid: NetUid,
         dividends: u64,
     ) -> Vec<(T::AccountId, u64)> {
         // hotkey dividends.
@@ -711,7 +705,7 @@ impl<T: Config> Pallet<T> {
 
             // Get the parent's root and subnet-specific (alpha) stakes
             let parent_root: U96F32 = U96F32::saturating_from_num(
-                Self::get_stake_for_hotkey_on_subnet(&parent, Self::get_root_netuid()),
+                Self::get_stake_for_hotkey_on_subnet(&parent, NetUid::ROOT),
             );
             let parent_alpha: U96F32 =
                 U96F32::saturating_from_num(Self::get_stake_for_hotkey_on_subnet(&parent, netuid));
@@ -813,7 +807,7 @@ impl<T: Config> Pallet<T> {
     ///
     /// # Returns
     /// * `bool` - True if the epoch should run, false otherwise.
-    pub fn should_run_epoch(netuid: u16, current_block: u64) -> bool {
+    pub fn should_run_epoch(netuid: NetUid, current_block: u64) -> bool {
         Self::blocks_until_next_epoch(netuid, Self::get_tempo(netuid), current_block) == 0
     }
 
@@ -828,11 +822,11 @@ impl<T: Config> Pallet<T> {
     ///   100      1              98
     /// Special case: tempo = 0, the network never runs.
     ///
-    pub fn blocks_until_next_epoch(netuid: u16, tempo: u16, block_number: u64) -> u64 {
+    pub fn blocks_until_next_epoch(netuid: NetUid, tempo: u16, block_number: u64) -> u64 {
         if tempo == 0 {
             return u64::MAX;
         }
-        let netuid_plus_one = (netuid as u64).saturating_add(1);
+        let netuid_plus_one = (u16::from(netuid) as u64).saturating_add(1);
         let tempo_plus_one = (tempo as u64).saturating_add(1);
         let adjusted_block = block_number.wrapping_add(netuid_plus_one);
         let remainder = adjusted_block.checked_rem(tempo_plus_one).unwrap_or(0);
@@ -840,7 +834,7 @@ impl<T: Config> Pallet<T> {
     }
 
     /// The `reveal_crv3_commits` function is run at the very beginning of epoch `n`,
-    pub fn reveal_crv3_commits(netuid: u16) -> dispatch::DispatchResult {
+    pub fn reveal_crv3_commits(netuid: NetUid) -> dispatch::DispatchResult {
         use ark_serialize::CanonicalDeserialize;
         use frame_support::traits::OriginTrait;
         use tle::curves::drand::TinyBLS381;
diff --git a/pallets/subtensor/src/epoch/run_epoch.rs b/pallets/subtensor/src/epoch/run_epoch.rs
index c550135123..715eb89f69 100644
--- a/pallets/subtensor/src/epoch/run_epoch.rs
+++ b/pallets/subtensor/src/epoch/run_epoch.rs
@@ -4,12 +4,13 @@ use frame_support::IterableStorageDoubleMap;
 use safe_math::*;
 use sp_std::vec;
 use substrate_fixed::types::{I32F32, I64F64, I96F32};
+use subtensor_runtime_common::NetUid;
 
 impl<T: Config> Pallet<T> {
     /// Calculates reward consensus and returns the emissions for uids/hotkeys in a given `netuid`.
     /// (Dense version used only for testing purposes.)
     #[allow(clippy::indexing_slicing)]
-    pub fn epoch_dense(netuid: u16, rao_emission: u64) -> Vec<(T::AccountId, u64, u64)> {
+    pub fn epoch_dense(netuid: NetUid, rao_emission: u64) -> Vec<(T::AccountId, u64, u64)> {
         // Get subnetwork size.
         let n: u16 = Self::get_subnetwork_n(netuid);
         log::trace!("n: {:?}", n);
@@ -75,7 +76,7 @@ impl<T: Config> Pallet<T> {
         // ===========
 
         let hotkeys: Vec<(u16, T::AccountId)> =
-            <Keys<T> as IterableStorageDoubleMap<u16, u16, T::AccountId>>::iter_prefix(netuid)
+            <Keys<T> as IterableStorageDoubleMap<NetUid, u16, T::AccountId>>::iter_prefix(netuid)
                 .collect();
         log::trace!("hotkeys: {:?}", &hotkeys);
 
@@ -438,7 +439,7 @@ impl<T: Config> Pallet<T> {
     ///     - Print debugging outputs.
     ///
     #[allow(clippy::indexing_slicing)]
-    pub fn epoch(netuid: u16, rao_emission: u64) -> Vec<(T::AccountId, u64, u64)> {
+    pub fn epoch(netuid: NetUid, rao_emission: u64) -> Vec<(T::AccountId, u64, u64)> {
         // Get subnetwork size.
         let n: u16 = Self::get_subnetwork_n(netuid);
         log::trace!("Number of Neurons in Network: {:?}", n);
@@ -482,7 +483,7 @@ impl<T: Config> Pallet<T> {
         // ===========
 
         let hotkeys: Vec<(u16, T::AccountId)> =
-            <Keys<T> as IterableStorageDoubleMap<u16, u16, T::AccountId>>::iter_prefix(netuid)
+            <Keys<T> as IterableStorageDoubleMap<NetUid, u16, T::AccountId>>::iter_prefix(netuid)
                 .collect();
         log::debug!("hotkeys: {:?}", &hotkeys);
 
@@ -879,19 +880,19 @@ impl<T: Config> Pallet<T> {
             .collect()
     }
 
-    pub fn get_float_rho(netuid: u16) -> I32F32 {
+    pub fn get_float_rho(netuid: NetUid) -> I32F32 {
         I32F32::saturating_from_num(Self::get_rho(netuid))
     }
-    pub fn get_float_kappa(netuid: u16) -> I32F32 {
+    pub fn get_float_kappa(netuid: NetUid) -> I32F32 {
         I32F32::saturating_from_num(Self::get_kappa(netuid))
             .safe_div(I32F32::saturating_from_num(u16::MAX))
     }
-    pub fn get_float_bonds_penalty(netuid: u16) -> I32F32 {
+    pub fn get_float_bonds_penalty(netuid: NetUid) -> I32F32 {
         I32F32::saturating_from_num(Self::get_bonds_penalty(netuid))
             .safe_div(I32F32::saturating_from_num(u16::MAX))
     }
 
-    pub fn get_block_at_registration(netuid: u16) -> Vec<u64> {
+    pub fn get_block_at_registration(netuid: NetUid) -> Vec<u64> {
         let n = Self::get_subnetwork_n(netuid);
         let block_at_registration: Vec<u64> = (0..n)
             .map(|neuron_uid| {
@@ -906,12 +907,14 @@ impl<T: Config> Pallet<T> {
     }
 
     /// Output unnormalized sparse weights, input weights are assumed to be row max-upscaled in u16.
-    pub fn get_weights_sparse(netuid: u16) -> Vec<Vec<(u16, I32F32)>> {
-        let n: usize = Self::get_subnetwork_n(netuid) as usize;
+    pub fn get_weights_sparse(netuid: NetUid) -> Vec<Vec<(u16, I32F32)>> {
+        let n = Self::get_subnetwork_n(netuid) as usize;
         let mut weights: Vec<Vec<(u16, I32F32)>> = vec![vec![]; n];
         for (uid_i, weights_i) in
-            <Weights<T> as IterableStorageDoubleMap<u16, u16, Vec<(u16, u16)>>>::iter_prefix(netuid)
-                .filter(|(uid_i, _)| *uid_i < n as u16)
+            <Weights<T> as IterableStorageDoubleMap<NetUid, u16, Vec<(u16, u16)>>>::iter_prefix(
+                netuid,
+            )
+            .filter(|(uid_i, _)| *uid_i < n as u16)
         {
             for (uid_j, weight_ij) in weights_i.iter().filter(|(uid_j, _)| *uid_j < n as u16) {
                 weights
@@ -924,12 +927,14 @@ impl<T: Config> Pallet<T> {
     }
 
     /// Output unnormalized weights in [n, n] matrix, input weights are assumed to be row max-upscaled in u16.
-    pub fn get_weights(netuid: u16) -> Vec<Vec<I32F32>> {
-        let n: usize = Self::get_subnetwork_n(netuid) as usize;
+    pub fn get_weights(netuid: NetUid) -> Vec<Vec<I32F32>> {
+        let n = Self::get_subnetwork_n(netuid) as usize;
         let mut weights: Vec<Vec<I32F32>> = vec![vec![I32F32::saturating_from_num(0.0); n]; n];
         for (uid_i, weights_vec) in
-            <Weights<T> as IterableStorageDoubleMap<u16, u16, Vec<(u16, u16)>>>::iter_prefix(netuid)
-                .filter(|(uid_i, _)| *uid_i < n as u16)
+            <Weights<T> as IterableStorageDoubleMap<NetUid, u16, Vec<(u16, u16)>>>::iter_prefix(
+                netuid,
+            )
+            .filter(|(uid_i, _)| *uid_i < n as u16)
         {
             for (uid_j, weight_ij) in weights_vec
                 .into_iter()
@@ -947,12 +952,14 @@ impl<T: Config> Pallet<T> {
     }
 
     /// Output unnormalized sparse bonds, input bonds are assumed to be column max-upscaled in u16.
-    pub fn get_bonds_sparse(netuid: u16) -> Vec<Vec<(u16, I32F32)>> {
-        let n: usize = Self::get_subnetwork_n(netuid) as usize;
+    pub fn get_bonds_sparse(netuid: NetUid) -> Vec<Vec<(u16, I32F32)>> {
+        let n = Self::get_subnetwork_n(netuid) as usize;
         let mut bonds: Vec<Vec<(u16, I32F32)>> = vec![vec![]; n];
         for (uid_i, bonds_vec) in
-            <Bonds<T> as IterableStorageDoubleMap<u16, u16, Vec<(u16, u16)>>>::iter_prefix(netuid)
-                .filter(|(uid_i, _)| *uid_i < n as u16)
+            <Bonds<T> as IterableStorageDoubleMap<NetUid, u16, Vec<(u16, u16)>>>::iter_prefix(
+                netuid,
+            )
+            .filter(|(uid_i, _)| *uid_i < n as u16)
         {
             for (uid_j, bonds_ij) in bonds_vec {
                 bonds
@@ -965,12 +972,14 @@ impl<T: Config> Pallet<T> {
     }
 
     /// Output unnormalized bonds in [n, n] matrix, input bonds are assumed to be column max-upscaled in u16.
-    pub fn get_bonds(netuid: u16) -> Vec<Vec<I32F32>> {
+    pub fn get_bonds(netuid: NetUid) -> Vec<Vec<I32F32>> {
         let n: usize = Self::get_subnetwork_n(netuid) as usize;
         let mut bonds: Vec<Vec<I32F32>> = vec![vec![I32F32::saturating_from_num(0.0); n]; n];
         for (uid_i, bonds_vec) in
-            <Bonds<T> as IterableStorageDoubleMap<u16, u16, Vec<(u16, u16)>>>::iter_prefix(netuid)
-                .filter(|(uid_i, _)| *uid_i < n as u16)
+            <Bonds<T> as IterableStorageDoubleMap<NetUid, u16, Vec<(u16, u16)>>>::iter_prefix(
+                netuid,
+            )
+            .filter(|(uid_i, _)| *uid_i < n as u16)
         {
             for (uid_j, bonds_ij) in bonds_vec.into_iter().filter(|(uid_j, _)| *uid_j < n as u16) {
                 *bonds
@@ -984,7 +993,7 @@ impl<T: Config> Pallet<T> {
         bonds
     }
 
-    pub fn get_bonds_fixed_proportion(netuid: u16) -> Vec<Vec<I32F32>> {
+    pub fn get_bonds_fixed_proportion(netuid: NetUid) -> Vec<Vec<I32F32>> {
         let mut bonds = Self::get_bonds(netuid);
         bonds.iter_mut().for_each(|bonds_row| {
             bonds_row
@@ -994,7 +1003,7 @@ impl<T: Config> Pallet<T> {
         bonds
     }
 
-    pub fn get_bonds_sparse_fixed_proportion(netuid: u16) -> Vec<Vec<(u16, I32F32)>> {
+    pub fn get_bonds_sparse_fixed_proportion(netuid: NetUid) -> Vec<Vec<(u16, I32F32)>> {
         let mut bonds = Self::get_bonds_sparse(netuid);
         bonds.iter_mut().for_each(|bonds_row| {
             bonds_row
@@ -1016,7 +1025,7 @@ impl<T: Config> Pallet<T> {
     pub fn compute_ema_bonds_normal_sparse(
         bonds_delta: &[Vec<(u16, I32F32)>],
         bonds: &[Vec<(u16, I32F32)>],
-        netuid: u16,
+        netuid: NetUid,
     ) -> Vec<Vec<(u16, I32F32)>> {
         // Retrieve the bonds moving average for the given network ID and scale it down.
         let bonds_moving_average: I64F64 =
@@ -1050,7 +1059,7 @@ impl<T: Config> Pallet<T> {
     pub fn compute_ema_bonds_normal(
         bonds_delta: &[Vec<I32F32>],
         bonds: &[Vec<I32F32>],
-        netuid: u16,
+        netuid: NetUid,
     ) -> Vec<Vec<I32F32>> {
         // Retrieve the bonds moving average for the given network ID and scale it down.
         let bonds_moving_average: I64F64 =
@@ -1084,7 +1093,7 @@ impl<T: Config> Pallet<T> {
     /// # Returns:
     /// A vector of EMA bonds.
     pub fn compute_bonds(
-        netuid: u16,
+        netuid: NetUid,
         weights: &[Vec<I32F32>], // weights_for_bonds
         bonds: &[Vec<I32F32>],
         consensus: &[I32F32],
@@ -1124,7 +1133,7 @@ impl<T: Config> Pallet<T> {
     /// # Returns:
     /// A vector of EMA bonds.
     pub fn compute_bonds_sparse(
-        netuid: u16,
+        netuid: NetUid,
         weights: &[Vec<(u16, I32F32)>],
         bonds: &[Vec<(u16, I32F32)>],
         consensus: &[I32F32],
@@ -1164,7 +1173,7 @@ impl<T: Config> Pallet<T> {
     /// # Returns:
     /// A matrix of alphas
     pub fn compute_liquid_alpha_values(
-        netuid: u16,
+        netuid: NetUid,
         weights: &[Vec<I32F32>], // current epoch weights
         bonds: &[Vec<I32F32>],   // previous epoch bonds
         consensus: &[I32F32],    // previous epoch consensus weights
@@ -1210,7 +1219,7 @@ impl<T: Config> Pallet<T> {
     /// # Returns:
     /// A dense matrix of alphas
     pub fn compute_liquid_alpha_values_sparse(
-        netuid: u16,
+        netuid: NetUid,
         weights: &[Vec<(u16, I32F32)>], // current epoch weights
         bonds: &[Vec<(u16, I32F32)>],   // previous epoch bonds
         consensus: &[I32F32],           // previous epoch consensus weights
@@ -1301,7 +1310,7 @@ impl<T: Config> Pallet<T> {
         clamp_value(alpha, alpha_low, alpha_high)
     }
 
-    pub fn compute_disabled_liquid_alpha(netuid: u16) -> I32F32 {
+    pub fn compute_disabled_liquid_alpha(netuid: NetUid) -> I32F32 {
         // Retrieve the bonds moving average for the given network ID and scale it down.
         let bonds_moving_average: I64F64 = I64F64::from_num(Self::get_bonds_moving_average(netuid))
             .saturating_div(I64F64::from_num(1_000_000));
@@ -1315,7 +1324,7 @@ impl<T: Config> Pallet<T> {
 
     pub fn do_set_alpha_values(
         origin: T::RuntimeOrigin,
-        netuid: u16,
+        netuid: NetUid,
         alpha_low: u16,
         alpha_high: u16,
     ) -> Result<(), DispatchError> {
@@ -1354,7 +1363,7 @@ impl<T: Config> Pallet<T> {
         Ok(())
     }
 
-    pub fn do_reset_bonds(netuid: u16, account_id: &T::AccountId) -> Result<(), DispatchError> {
+    pub fn do_reset_bonds(netuid: NetUid, account_id: &T::AccountId) -> Result<(), DispatchError> {
         // check bonds reset enabled for this subnet
         let bonds_reset_enabled: bool = Self::get_bonds_reset(netuid);
         if !bonds_reset_enabled {
@@ -1362,11 +1371,7 @@ impl<T: Config> Pallet<T> {
         }
 
         if let Ok(uid) = Self::get_uid_for_net_and_hotkey(netuid, account_id) {
-            for (i, bonds_vec) in
-                <Bonds<T> as IterableStorageDoubleMap<u16, u16, Vec<(u16, u16)>>>::iter_prefix(
-                    netuid,
-                )
-            {
+            for (i, bonds_vec) in Bonds::<T>::iter_prefix(netuid) {
                 Bonds::<T>::insert(
                     netuid,
                     i,
diff --git a/pallets/subtensor/src/lib.rs b/pallets/subtensor/src/lib.rs
index f4f511e74a..305c7a4c29 100644
--- a/pallets/subtensor/src/lib.rs
+++ b/pallets/subtensor/src/lib.rs
@@ -28,6 +28,7 @@ use sp_runtime::{
     transaction_validity::{TransactionValidity, TransactionValidityError},
 };
 use sp_std::marker::PhantomData;
+use subtensor_runtime_common::NetUid;
 
 // ============================
 //	==== Benchmark Imports =====
@@ -85,6 +86,7 @@ pub mod pallet {
     use sp_std::vec::Vec;
     use substrate_fixed::types::{I96F32, U64F64};
     use subtensor_macros::freeze_struct;
+    use subtensor_runtime_common::NetUid;
 
     #[cfg(not(feature = "std"))]
     use alloc::boxed::Box;
@@ -280,7 +282,7 @@ pub mod pallet {
             /// Coldkey account
             coldkey: AccountId,
             /// Subnet ID
-            netuid: u16,
+            netuid: NetUid,
             /// The amount of stake to be added to the hotkey staking account.
             stake_to_be_added: u64,
         },
@@ -291,7 +293,7 @@ pub mod pallet {
             /// Coldkey account
             coldkey: AccountId,
             /// Subnet ID
-            netuid: u16,
+            netuid: NetUid,
             /// Alpha value
             alpha_unstaked: u64,
         },
@@ -302,7 +304,7 @@ pub mod pallet {
             /// Hotkey account
             hotkey: AccountId,
             /// Subnet ID
-            netuid: u16,
+            netuid: NetUid,
             /// The amount of stake to be added to the hotkey staking account.
             stake_to_be_added: u64,
             /// The limit price expressed in units of RAO per one Alpha.
@@ -318,7 +320,7 @@ pub mod pallet {
             /// Hotkey account
             hotkey: AccountId,
             /// Subnet ID
-            netuid: u16,
+            netuid: NetUid,
             /// The amount of stake to be added to the hotkey staking account.
             alpha_unstaked: u64,
             /// The limit price
@@ -986,8 +988,8 @@ pub mod pallet {
         Blake2_128Concat,
         T::AccountId, // First key: hotkey
         Identity,
-        u16, // Second key: netuid
-        u16, // Value: take
+        NetUid, // Second key: netuid
+        u16,    // Value: take
         ValueQuery,
     >;
     #[pallet::storage]
@@ -995,7 +997,7 @@ pub mod pallet {
     pub type PendingChildKeys<T: Config> = StorageDoubleMap<
         _,
         Identity,
-        u16,
+        NetUid,
         Blake2_128Concat,
         T::AccountId,
         (Vec<(u64, T::AccountId)>, u64),
@@ -1009,7 +1011,7 @@ pub mod pallet {
         Blake2_128Concat,
         T::AccountId,
         Identity,
-        u16,
+        NetUid,
         Vec<(u64, T::AccountId)>,
         ValueQuery,
         DefaultAccountLinkage<T>,
@@ -1021,7 +1023,7 @@ pub mod pallet {
         Blake2_128Concat,
         T::AccountId,
         Identity,
-        u16,
+        NetUid,
         Vec<(u64, T::AccountId)>,
         ValueQuery,
         DefaultAccountLinkage<T>,
@@ -1030,7 +1032,7 @@ pub mod pallet {
     pub type AlphaDividendsPerSubnet<T: Config> = StorageDoubleMap<
         _,
         Identity,
-        u16,
+        NetUid,
         Blake2_128Concat,
         T::AccountId,
         u64,
@@ -1041,7 +1043,7 @@ pub mod pallet {
     pub type TaoDividendsPerSubnet<T: Config> = StorageDoubleMap<
         _,
         Identity,
-        u16,
+        NetUid,
         Blake2_128Concat,
         T::AccountId,
         u64,
@@ -1062,7 +1064,7 @@ pub mod pallet {
         Blake2_128Concat,
         T::AccountId,
         Identity,
-        u16,
+        NetUid,
         u64,
         ValueQuery,
         DefaultZeroU64<T>,
@@ -1088,28 +1090,28 @@ pub mod pallet {
     pub type SubnetMovingAlpha<T> = StorageValue<_, I96F32, ValueQuery, DefaultMovingAlpha<T>>;
     #[pallet::storage] // --- MAP ( netuid ) --> moving_price | The subnet moving price.
     pub type SubnetMovingPrice<T: Config> =
-        StorageMap<_, Identity, u16, I96F32, ValueQuery, DefaultMovingPrice<T>>;
+        StorageMap<_, Identity, NetUid, I96F32, ValueQuery, DefaultMovingPrice<T>>;
     #[pallet::storage] // --- MAP ( netuid ) --> total_volume | The total amount of TAO bought and sold since the start of the network.
     pub type SubnetVolume<T: Config> =
-        StorageMap<_, Identity, u16, u128, ValueQuery, DefaultZeroU128<T>>;
+        StorageMap<_, Identity, NetUid, u128, ValueQuery, DefaultZeroU128<T>>;
     #[pallet::storage] // --- MAP ( netuid ) --> tao_in_subnet | Returns the amount of TAO in the subnet.
     pub type SubnetTAO<T: Config> =
-        StorageMap<_, Identity, u16, u64, ValueQuery, DefaultZeroU64<T>>;
+        StorageMap<_, Identity, NetUid, u64, ValueQuery, DefaultZeroU64<T>>;
     #[pallet::storage] // --- MAP ( netuid ) --> alpha_in_emission | Returns the amount of alph in  emission into the pool per block.
     pub type SubnetAlphaInEmission<T: Config> =
-        StorageMap<_, Identity, u16, u64, ValueQuery, DefaultZeroU64<T>>;
+        StorageMap<_, Identity, NetUid, u64, ValueQuery, DefaultZeroU64<T>>;
     #[pallet::storage] // --- MAP ( netuid ) --> alpha_out_emission | Returns the amount of alpha out emission into the network per block.
     pub type SubnetAlphaOutEmission<T: Config> =
-        StorageMap<_, Identity, u16, u64, ValueQuery, DefaultZeroU64<T>>;
+        StorageMap<_, Identity, NetUid, u64, ValueQuery, DefaultZeroU64<T>>;
     #[pallet::storage] // --- MAP ( netuid ) --> tao_in_emission | Returns the amount of tao emitted into this subent on the last block.
     pub type SubnetTaoInEmission<T: Config> =
-        StorageMap<_, Identity, u16, u64, ValueQuery, DefaultZeroU64<T>>;
+        StorageMap<_, Identity, NetUid, u64, ValueQuery, DefaultZeroU64<T>>;
     #[pallet::storage] // --- MAP ( netuid ) --> alpha_supply_in_pool | Returns the amount of alpha in the pool.
     pub type SubnetAlphaIn<T: Config> =
-        StorageMap<_, Identity, u16, u64, ValueQuery, DefaultZeroU64<T>>;
+        StorageMap<_, Identity, NetUid, u64, ValueQuery, DefaultZeroU64<T>>;
     #[pallet::storage] // --- MAP ( netuid ) --> alpha_supply_in_subnet | Returns the amount of alpha in the subnet.
     pub type SubnetAlphaOut<T: Config> =
-        StorageMap<_, Identity, u16, u64, ValueQuery, DefaultZeroU64<T>>;
+        StorageMap<_, Identity, NetUid, u64, ValueQuery, DefaultZeroU64<T>>;
     #[pallet::storage] // --- MAP ( cold ) --> Vec<hot> | Maps coldkey to hotkeys that stake to it
     pub type StakingHotkeys<T: Config> =
         StorageMap<_, Blake2_128Concat, T::AccountId, Vec<T::AccountId>, ValueQuery>;
@@ -1133,7 +1135,7 @@ pub mod pallet {
         Blake2_128Concat,
         T::AccountId,
         Identity,
-        u16,
+        NetUid,
         u64,
         ValueQuery,
         DefaultZeroU64<T>,
@@ -1144,7 +1146,7 @@ pub mod pallet {
         Blake2_128Concat,
         T::AccountId,
         Identity,
-        u16,
+        NetUid,
         u64,
         ValueQuery,
         DefaultZeroU64<T>,
@@ -1156,7 +1158,7 @@ pub mod pallet {
         Blake2_128Concat,
         T::AccountId,
         Identity,
-        u16,
+        NetUid,
         U64F64,
         ValueQuery,
         DefaultSharePoolZero<T>,
@@ -1167,14 +1169,14 @@ pub mod pallet {
         (
             NMapKey<Blake2_128Concat, T::AccountId>, // hot
             NMapKey<Blake2_128Concat, T::AccountId>, // cold
-            NMapKey<Identity, u16>,                  // subnet
+            NMapKey<Identity, NetUid>,               // subnet
         ),
         U64F64, // Shares
         ValueQuery,
     >;
     #[pallet::storage] // --- MAP ( netuid ) --> token_symbol | Returns the token symbol for a subnet.
     pub type TokenSymbol<T: Config> =
-        StorageMap<_, Identity, u16, Vec<u8>, ValueQuery, DefaultUnicodeVecU8<T>>;
+        StorageMap<_, Identity, NetUid, Vec<u8>, ValueQuery, DefaultUnicodeVecU8<T>>;
 
     /// ============================
     /// ==== Global Parameters =====
@@ -1185,7 +1187,7 @@ pub mod pallet {
     #[pallet::storage]
     /// --- ITEM( global_max_registrations_per_block )
     pub type MaxRegistrationsPerBlock<T> =
-        StorageMap<_, Identity, u16, u16, ValueQuery, DefaultMaxRegistrationsPerBlock<T>>;
+        StorageMap<_, Identity, NetUid, u16, ValueQuery, DefaultMaxRegistrationsPerBlock<T>>;
     #[pallet::storage]
     /// --- ITEM( total_number_of_existing_networks )
     pub type TotalNetworks<T> = StorageValue<_, u16, ValueQuery>;
@@ -1235,40 +1237,42 @@ pub mod pallet {
     /// ============================
     #[pallet::storage] // --- MAP ( netuid ) --> transfer_toggle
     pub type TransferToggle<T: Config> =
-        StorageMap<_, Identity, u16, bool, ValueQuery, DefaultTrue<T>>;
+        StorageMap<_, Identity, NetUid, bool, ValueQuery, DefaultTrue<T>>;
     #[pallet::storage] // --- MAP ( netuid ) --> total_subnet_locked
     pub type SubnetLocked<T: Config> =
-        StorageMap<_, Identity, u16, u64, ValueQuery, DefaultZeroU64<T>>;
+        StorageMap<_, Identity, NetUid, u64, ValueQuery, DefaultZeroU64<T>>;
     #[pallet::storage] // --- MAP ( netuid ) --> largest_locked
     pub type LargestLocked<T: Config> =
-        StorageMap<_, Identity, u16, u64, ValueQuery, DefaultZeroU64<T>>;
+        StorageMap<_, Identity, NetUid, u64, ValueQuery, DefaultZeroU64<T>>;
 
     /// =================
     /// ==== Tempos =====
     /// =================
     #[pallet::storage] // --- MAP ( netuid ) --> tempo
-    pub type Tempo<T> = StorageMap<_, Identity, u16, u16, ValueQuery, DefaultTempo<T>>;
+    pub type Tempo<T> = StorageMap<_, Identity, NetUid, u16, ValueQuery, DefaultTempo<T>>;
 
     /// ============================
     /// ==== Subnet Parameters =====
     /// ============================
     /// --- MAP ( netuid ) --> block number of first emission
     #[pallet::storage]
-    pub type FirstEmissionBlockNumber<T: Config> = StorageMap<_, Identity, u16, u64, OptionQuery>;
+    pub type FirstEmissionBlockNumber<T: Config> =
+        StorageMap<_, Identity, NetUid, u64, OptionQuery>;
     /// --- MAP ( netuid ) --> subnet mechanism
     #[pallet::storage]
     pub type SubnetMechanism<T: Config> =
-        StorageMap<_, Identity, u16, u16, ValueQuery, DefaultZeroU16<T>>;
+        StorageMap<_, Identity, NetUid, u16, ValueQuery, DefaultZeroU16<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> subnetwork_n (Number of UIDs in the network).
-    pub type SubnetworkN<T: Config> = StorageMap<_, Identity, u16, u16, ValueQuery, DefaultN<T>>;
+    pub type SubnetworkN<T: Config> = StorageMap<_, Identity, NetUid, u16, ValueQuery, DefaultN<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> modality   TEXT: 0, IMAGE: 1, TENSOR: 2
-    pub type NetworkModality<T> = StorageMap<_, Identity, u16, u16, ValueQuery, DefaultModality<T>>;
+    pub type NetworkModality<T> =
+        StorageMap<_, Identity, NetUid, u16, ValueQuery, DefaultModality<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> network_is_added
     pub type NetworksAdded<T: Config> =
-        StorageMap<_, Identity, u16, bool, ValueQuery, DefaultNeworksAdded<T>>;
+        StorageMap<_, Identity, NetUid, bool, ValueQuery, DefaultNeworksAdded<T>>;
     #[pallet::storage]
     /// --- DMAP ( hotkey, netuid ) --> bool
     pub type IsNetworkMember<T: Config> = StorageDoubleMap<
@@ -1276,7 +1280,7 @@ pub mod pallet {
         Blake2_128Concat,
         T::AccountId,
         Identity,
-        u16,
+        NetUid,
         bool,
         ValueQuery,
         DefaultIsNetworkMember<T>,
@@ -1284,174 +1288,177 @@ pub mod pallet {
     #[pallet::storage]
     /// --- MAP ( netuid ) --> network_registration_allowed
     pub type NetworkRegistrationAllowed<T: Config> =
-        StorageMap<_, Identity, u16, bool, ValueQuery, DefaultRegistrationAllowed<T>>;
+        StorageMap<_, Identity, NetUid, bool, ValueQuery, DefaultRegistrationAllowed<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> network_pow_allowed
     pub type NetworkPowRegistrationAllowed<T: Config> =
-        StorageMap<_, Identity, u16, bool, ValueQuery, DefaultRegistrationAllowed<T>>;
+        StorageMap<_, Identity, NetUid, bool, ValueQuery, DefaultRegistrationAllowed<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> block_created
     pub type NetworkRegisteredAt<T: Config> =
-        StorageMap<_, Identity, u16, u64, ValueQuery, DefaultNetworkRegisteredAt<T>>;
+        StorageMap<_, Identity, NetUid, u64, ValueQuery, DefaultNetworkRegisteredAt<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> pending_emission
     pub type PendingEmission<T> =
-        StorageMap<_, Identity, u16, u64, ValueQuery, DefaultPendingEmission<T>>;
+        StorageMap<_, Identity, NetUid, u64, ValueQuery, DefaultPendingEmission<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> pending_root_emission
-    pub type PendingRootDivs<T> = StorageMap<_, Identity, u16, u64, ValueQuery, DefaultZeroU64<T>>;
+    pub type PendingRootDivs<T> =
+        StorageMap<_, Identity, NetUid, u64, ValueQuery, DefaultZeroU64<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> pending_alpha_swapped
     pub type PendingAlphaSwapped<T> =
-        StorageMap<_, Identity, u16, u64, ValueQuery, DefaultZeroU64<T>>;
+        StorageMap<_, Identity, NetUid, u64, ValueQuery, DefaultZeroU64<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> pending_owner_cut
-    pub type PendingOwnerCut<T> = StorageMap<_, Identity, u16, u64, ValueQuery, DefaultZeroU64<T>>;
+    pub type PendingOwnerCut<T> =
+        StorageMap<_, Identity, NetUid, u64, ValueQuery, DefaultZeroU64<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> blocks_since_last_step
     pub type BlocksSinceLastStep<T> =
-        StorageMap<_, Identity, u16, u64, ValueQuery, DefaultBlocksSinceLastStep<T>>;
+        StorageMap<_, Identity, NetUid, u64, ValueQuery, DefaultBlocksSinceLastStep<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> last_mechanism_step_block
     pub type LastMechansimStepBlock<T> =
-        StorageMap<_, Identity, u16, u64, ValueQuery, DefaultLastMechanismStepBlock<T>>;
+        StorageMap<_, Identity, NetUid, u64, ValueQuery, DefaultLastMechanismStepBlock<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> subnet_owner
     pub type SubnetOwner<T: Config> =
-        StorageMap<_, Identity, u16, T::AccountId, ValueQuery, DefaultSubnetOwner<T>>;
+        StorageMap<_, Identity, NetUid, T::AccountId, ValueQuery, DefaultSubnetOwner<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> subnet_owner_hotkey
     pub type SubnetOwnerHotkey<T: Config> =
-        StorageMap<_, Identity, u16, T::AccountId, ValueQuery, DefaultSubnetOwner<T>>;
+        StorageMap<_, Identity, NetUid, T::AccountId, ValueQuery, DefaultSubnetOwner<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> serving_rate_limit
     pub type ServingRateLimit<T> =
-        StorageMap<_, Identity, u16, u64, ValueQuery, DefaultServingRateLimit<T>>;
+        StorageMap<_, Identity, NetUid, u64, ValueQuery, DefaultServingRateLimit<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> Rho
-    pub type Rho<T> = StorageMap<_, Identity, u16, u16, ValueQuery, DefaultRho<T>>;
+    pub type Rho<T> = StorageMap<_, Identity, NetUid, u16, ValueQuery, DefaultRho<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> AlphaSigmoidSteepness
     pub type AlphaSigmoidSteepness<T> =
-        StorageMap<_, Identity, u16, u16, ValueQuery, DefaultAlphaSigmoidSteepness<T>>;
+        StorageMap<_, Identity, NetUid, u16, ValueQuery, DefaultAlphaSigmoidSteepness<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> Kappa
-    pub type Kappa<T> = StorageMap<_, Identity, u16, u16, ValueQuery, DefaultKappa<T>>;
+    pub type Kappa<T> = StorageMap<_, Identity, NetUid, u16, ValueQuery, DefaultKappa<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> registrations_this_interval
-    pub type RegistrationsThisInterval<T: Config> = StorageMap<_, Identity, u16, u16, ValueQuery>;
+    pub type RegistrationsThisInterval<T: Config> =
+        StorageMap<_, Identity, NetUid, u16, ValueQuery>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> pow_registrations_this_interval
     pub type POWRegistrationsThisInterval<T: Config> =
-        StorageMap<_, Identity, u16, u16, ValueQuery>;
+        StorageMap<_, Identity, NetUid, u16, ValueQuery>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> burn_registrations_this_interval
     pub type BurnRegistrationsThisInterval<T: Config> =
-        StorageMap<_, Identity, u16, u16, ValueQuery>;
+        StorageMap<_, Identity, NetUid, u16, ValueQuery>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> max_allowed_uids
     pub type MaxAllowedUids<T> =
-        StorageMap<_, Identity, u16, u16, ValueQuery, DefaultMaxAllowedUids<T>>;
+        StorageMap<_, Identity, NetUid, u16, ValueQuery, DefaultMaxAllowedUids<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> immunity_period
     pub type ImmunityPeriod<T> =
-        StorageMap<_, Identity, u16, u16, ValueQuery, DefaultImmunityPeriod<T>>;
+        StorageMap<_, Identity, NetUid, u16, ValueQuery, DefaultImmunityPeriod<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> activity_cutoff
     pub type ActivityCutoff<T> =
-        StorageMap<_, Identity, u16, u16, ValueQuery, DefaultActivityCutoff<T>>;
+        StorageMap<_, Identity, NetUid, u16, ValueQuery, DefaultActivityCutoff<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> max_weight_limit
     pub type MaxWeightsLimit<T> =
-        StorageMap<_, Identity, u16, u16, ValueQuery, DefaultMaxWeightsLimit<T>>;
+        StorageMap<_, Identity, NetUid, u16, ValueQuery, DefaultMaxWeightsLimit<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> weights_version_key
     pub type WeightsVersionKey<T> =
-        StorageMap<_, Identity, u16, u64, ValueQuery, DefaultWeightsVersionKey<T>>;
+        StorageMap<_, Identity, NetUid, u64, ValueQuery, DefaultWeightsVersionKey<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> min_allowed_weights
     pub type MinAllowedWeights<T> =
-        StorageMap<_, Identity, u16, u16, ValueQuery, DefaultMinAllowedWeights<T>>;
+        StorageMap<_, Identity, NetUid, u16, ValueQuery, DefaultMinAllowedWeights<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> max_allowed_validators
     pub type MaxAllowedValidators<T> =
-        StorageMap<_, Identity, u16, u16, ValueQuery, DefaultMaxAllowedValidators<T>>;
+        StorageMap<_, Identity, NetUid, u16, ValueQuery, DefaultMaxAllowedValidators<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> adjustment_interval
     pub type AdjustmentInterval<T> =
-        StorageMap<_, Identity, u16, u16, ValueQuery, DefaultAdjustmentInterval<T>>;
+        StorageMap<_, Identity, NetUid, u16, ValueQuery, DefaultAdjustmentInterval<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> bonds_moving_average
     pub type BondsMovingAverage<T> =
-        StorageMap<_, Identity, u16, u64, ValueQuery, DefaultBondsMovingAverage<T>>;
+        StorageMap<_, Identity, NetUid, u64, ValueQuery, DefaultBondsMovingAverage<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> bonds_penalty
     pub type BondsPenalty<T> =
-        StorageMap<_, Identity, u16, u16, ValueQuery, DefaultBondsPenalty<T>>;
+        StorageMap<_, Identity, NetUid, u16, ValueQuery, DefaultBondsPenalty<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> bonds_reset
     pub type BondsResetOn<T> =
-        StorageMap<_, Identity, u16, bool, ValueQuery, DefaultBondsResetOn<T>>;
+        StorageMap<_, Identity, NetUid, bool, ValueQuery, DefaultBondsResetOn<T>>;
     /// --- MAP ( netuid ) --> weights_set_rate_limit
     #[pallet::storage]
     pub type WeightsSetRateLimit<T> =
-        StorageMap<_, Identity, u16, u64, ValueQuery, DefaultWeightsSetRateLimit<T>>;
+        StorageMap<_, Identity, NetUid, u64, ValueQuery, DefaultWeightsSetRateLimit<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> validator_prune_len
     pub type ValidatorPruneLen<T> =
-        StorageMap<_, Identity, u16, u64, ValueQuery, DefaultValidatorPruneLen<T>>;
+        StorageMap<_, Identity, NetUid, u64, ValueQuery, DefaultValidatorPruneLen<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> scaling_law_power
     pub type ScalingLawPower<T> =
-        StorageMap<_, Identity, u16, u16, ValueQuery, DefaultScalingLawPower<T>>;
+        StorageMap<_, Identity, NetUid, u16, ValueQuery, DefaultScalingLawPower<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> target_registrations_this_interval
     pub type TargetRegistrationsPerInterval<T> =
-        StorageMap<_, Identity, u16, u16, ValueQuery, DefaultTargetRegistrationsPerInterval<T>>;
+        StorageMap<_, Identity, NetUid, u16, ValueQuery, DefaultTargetRegistrationsPerInterval<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> adjustment_alpha
     pub type AdjustmentAlpha<T: Config> =
-        StorageMap<_, Identity, u16, u64, ValueQuery, DefaultAdjustmentAlpha<T>>;
+        StorageMap<_, Identity, NetUid, u64, ValueQuery, DefaultAdjustmentAlpha<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> commit reveal v2 weights are enabled
     pub type CommitRevealWeightsEnabled<T> =
-        StorageMap<_, Identity, u16, bool, ValueQuery, DefaultCommitRevealWeightsEnabled<T>>;
+        StorageMap<_, Identity, NetUid, bool, ValueQuery, DefaultCommitRevealWeightsEnabled<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> Burn
-    pub type Burn<T> = StorageMap<_, Identity, u16, u64, ValueQuery, DefaultBurn<T>>;
+    pub type Burn<T> = StorageMap<_, Identity, NetUid, u64, ValueQuery, DefaultBurn<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> Difficulty
-    pub type Difficulty<T> = StorageMap<_, Identity, u16, u64, ValueQuery, DefaultDifficulty<T>>;
+    pub type Difficulty<T> = StorageMap<_, Identity, NetUid, u64, ValueQuery, DefaultDifficulty<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> MinBurn
-    pub type MinBurn<T> = StorageMap<_, Identity, u16, u64, ValueQuery, DefaultMinBurn<T>>;
+    pub type MinBurn<T> = StorageMap<_, Identity, NetUid, u64, ValueQuery, DefaultMinBurn<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> MaxBurn
-    pub type MaxBurn<T> = StorageMap<_, Identity, u16, u64, ValueQuery, DefaultMaxBurn<T>>;
+    pub type MaxBurn<T> = StorageMap<_, Identity, NetUid, u64, ValueQuery, DefaultMaxBurn<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> MinDifficulty
     pub type MinDifficulty<T> =
-        StorageMap<_, Identity, u16, u64, ValueQuery, DefaultMinDifficulty<T>>;
+        StorageMap<_, Identity, NetUid, u64, ValueQuery, DefaultMinDifficulty<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> MaxDifficulty
     pub type MaxDifficulty<T> =
-        StorageMap<_, Identity, u16, u64, ValueQuery, DefaultMaxDifficulty<T>>;
+        StorageMap<_, Identity, NetUid, u64, ValueQuery, DefaultMaxDifficulty<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) -->  Block at last adjustment.
     pub type LastAdjustmentBlock<T> =
-        StorageMap<_, Identity, u16, u64, ValueQuery, DefaultLastAdjustmentBlock<T>>;
+        StorageMap<_, Identity, NetUid, u64, ValueQuery, DefaultLastAdjustmentBlock<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> Registrations of this Block.
     pub type RegistrationsThisBlock<T> =
-        StorageMap<_, Identity, u16, u16, ValueQuery, DefaultRegistrationsThisBlock<T>>;
+        StorageMap<_, Identity, NetUid, u16, ValueQuery, DefaultRegistrationsThisBlock<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> Halving time of average moving price.
     pub type EMAPriceHalvingBlocks<T> =
-        StorageMap<_, Identity, u16, u64, ValueQuery, DefaultEMAPriceMovingBlocks<T>>;
+        StorageMap<_, Identity, NetUid, u64, ValueQuery, DefaultEMAPriceMovingBlocks<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> global_RAO_recycled_for_registration
     pub type RAORecycledForRegistration<T> =
-        StorageMap<_, Identity, u16, u64, ValueQuery, DefaultRAORecycledForRegistration<T>>;
+        StorageMap<_, Identity, NetUid, u64, ValueQuery, DefaultRAORecycledForRegistration<T>>;
     #[pallet::storage]
     /// --- ITEM ( tx_rate_limit )
     pub type TxRateLimit<T> = StorageValue<_, u64, ValueQuery, DefaultTxRateLimit<T>>;
@@ -1466,84 +1473,96 @@ pub mod pallet {
     #[pallet::storage]
     /// --- MAP ( netuid ) --> Whether or not Liquid Alpha is enabled
     pub type LiquidAlphaOn<T> =
-        StorageMap<_, Blake2_128Concat, u16, bool, ValueQuery, DefaultLiquidAlpha<T>>;
+        StorageMap<_, Blake2_128Concat, NetUid, bool, ValueQuery, DefaultLiquidAlpha<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> Whether or not Yuma3 is enabled
-    pub type Yuma3On<T> = StorageMap<_, Blake2_128Concat, u16, bool, ValueQuery, DefaultYuma3<T>>;
+    pub type Yuma3On<T> =
+        StorageMap<_, Blake2_128Concat, NetUid, bool, ValueQuery, DefaultYuma3<T>>;
     #[pallet::storage]
     ///  MAP ( netuid ) --> (alpha_low, alpha_high)
     pub type AlphaValues<T> =
-        StorageMap<_, Identity, u16, (u16, u16), ValueQuery, DefaultAlphaValues<T>>;
+        StorageMap<_, Identity, NetUid, (u16, u16), ValueQuery, DefaultAlphaValues<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> If subtoken trading enabled
-    pub type SubtokenEnabled<T> = StorageMap<_, Identity, u16, bool, ValueQuery, DefaultFalse<T>>;
+    pub type SubtokenEnabled<T> =
+        StorageMap<_, Identity, NetUid, bool, ValueQuery, DefaultFalse<T>>;
 
     /// =======================================
     /// ==== Subnetwork Consensus Storage  ====
     /// =======================================
     #[pallet::storage] // --- DMAP ( netuid ) --> stake_weight | weight for stake used in YC.
     pub(super) type StakeWeight<T: Config> =
-        StorageMap<_, Identity, u16, Vec<u16>, ValueQuery, EmptyU16Vec<T>>;
+        StorageMap<_, Identity, NetUid, Vec<u16>, ValueQuery, EmptyU16Vec<T>>;
     #[pallet::storage]
     /// --- DMAP ( netuid, hotkey ) --> uid
     pub type Uids<T: Config> =
-        StorageDoubleMap<_, Identity, u16, Blake2_128Concat, T::AccountId, u16, OptionQuery>;
+        StorageDoubleMap<_, Identity, NetUid, Blake2_128Concat, T::AccountId, u16, OptionQuery>;
     #[pallet::storage]
     /// --- DMAP ( netuid, uid ) --> hotkey
-    pub type Keys<T: Config> =
-        StorageDoubleMap<_, Identity, u16, Identity, u16, T::AccountId, ValueQuery, DefaultKey<T>>;
+    pub type Keys<T: Config> = StorageDoubleMap<
+        _,
+        Identity,
+        NetUid,
+        Identity,
+        u16,
+        T::AccountId,
+        ValueQuery,
+        DefaultKey<T>,
+    >;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> (hotkey, se, ve)
     pub type LoadedEmission<T: Config> =
-        StorageMap<_, Identity, u16, Vec<(T::AccountId, u64, u64)>, OptionQuery>;
+        StorageMap<_, Identity, NetUid, Vec<(T::AccountId, u64, u64)>, OptionQuery>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> active
     pub type Active<T: Config> =
-        StorageMap<_, Identity, u16, Vec<bool>, ValueQuery, EmptyBoolVec<T>>;
+        StorageMap<_, Identity, NetUid, Vec<bool>, ValueQuery, EmptyBoolVec<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> rank
-    pub type Rank<T: Config> = StorageMap<_, Identity, u16, Vec<u16>, ValueQuery, EmptyU16Vec<T>>;
+    pub type Rank<T: Config> =
+        StorageMap<_, Identity, NetUid, Vec<u16>, ValueQuery, EmptyU16Vec<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> trust
-    pub type Trust<T: Config> = StorageMap<_, Identity, u16, Vec<u16>, ValueQuery, EmptyU16Vec<T>>;
+    pub type Trust<T: Config> =
+        StorageMap<_, Identity, NetUid, Vec<u16>, ValueQuery, EmptyU16Vec<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> consensus
     pub type Consensus<T: Config> =
-        StorageMap<_, Identity, u16, Vec<u16>, ValueQuery, EmptyU16Vec<T>>;
+        StorageMap<_, Identity, NetUid, Vec<u16>, ValueQuery, EmptyU16Vec<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> incentive
     pub type Incentive<T: Config> =
-        StorageMap<_, Identity, u16, Vec<u16>, ValueQuery, EmptyU16Vec<T>>;
+        StorageMap<_, Identity, NetUid, Vec<u16>, ValueQuery, EmptyU16Vec<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> dividends
     pub type Dividends<T: Config> =
-        StorageMap<_, Identity, u16, Vec<u16>, ValueQuery, EmptyU16Vec<T>>;
+        StorageMap<_, Identity, NetUid, Vec<u16>, ValueQuery, EmptyU16Vec<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> emission
     pub type Emission<T: Config> =
-        StorageMap<_, Identity, u16, Vec<u64>, ValueQuery, EmptyU64Vec<T>>;
+        StorageMap<_, Identity, NetUid, Vec<u64>, ValueQuery, EmptyU64Vec<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> last_update
     pub type LastUpdate<T: Config> =
-        StorageMap<_, Identity, u16, Vec<u64>, ValueQuery, EmptyU64Vec<T>>;
+        StorageMap<_, Identity, NetUid, Vec<u64>, ValueQuery, EmptyU64Vec<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> validator_trust
     pub type ValidatorTrust<T: Config> =
-        StorageMap<_, Identity, u16, Vec<u16>, ValueQuery, EmptyU16Vec<T>>;
+        StorageMap<_, Identity, NetUid, Vec<u16>, ValueQuery, EmptyU16Vec<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> pruning_scores
     pub type PruningScores<T: Config> =
-        StorageMap<_, Identity, u16, Vec<u16>, ValueQuery, EmptyU16Vec<T>>;
+        StorageMap<_, Identity, NetUid, Vec<u16>, ValueQuery, EmptyU16Vec<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> validator_permit
     pub type ValidatorPermit<T: Config> =
-        StorageMap<_, Identity, u16, Vec<bool>, ValueQuery, EmptyBoolVec<T>>;
+        StorageMap<_, Identity, NetUid, Vec<bool>, ValueQuery, EmptyBoolVec<T>>;
     #[pallet::storage]
     /// --- DMAP ( netuid, uid ) --> weights
     pub type Weights<T: Config> = StorageDoubleMap<
         _,
         Identity,
-        u16,
+        NetUid,
         Identity,
         u16,
         Vec<(u16, u16)>,
@@ -1555,7 +1574,7 @@ pub mod pallet {
     pub type Bonds<T: Config> = StorageDoubleMap<
         _,
         Identity,
-        u16,
+        NetUid,
         Identity,
         u16,
         Vec<(u16, u16)>,
@@ -1567,7 +1586,7 @@ pub mod pallet {
     pub type BlockAtRegistration<T: Config> = StorageDoubleMap<
         _,
         Identity,
-        u16,
+        NetUid,
         Identity,
         u16,
         u64,
@@ -1576,14 +1595,21 @@ pub mod pallet {
     >;
     #[pallet::storage]
     /// --- MAP ( netuid, hotkey ) --> axon_info
-    pub type Axons<T: Config> =
-        StorageDoubleMap<_, Identity, u16, Blake2_128Concat, T::AccountId, AxonInfoOf, OptionQuery>;
+    pub type Axons<T: Config> = StorageDoubleMap<
+        _,
+        Identity,
+        NetUid,
+        Blake2_128Concat,
+        T::AccountId,
+        AxonInfoOf,
+        OptionQuery,
+    >;
     /// --- MAP ( netuid, hotkey ) --> certificate
     #[pallet::storage]
     pub type NeuronCertificates<T: Config> = StorageDoubleMap<
         _,
         Identity,
-        u16,
+        NetUid,
         Blake2_128Concat,
         T::AccountId,
         NeuronCertificateOf,
@@ -1594,7 +1620,7 @@ pub mod pallet {
     pub type Prometheus<T: Config> = StorageDoubleMap<
         _,
         Identity,
-        u16,
+        NetUid,
         Blake2_128Concat,
         T::AccountId,
         PrometheusInfoOf,
@@ -1610,11 +1636,11 @@ pub mod pallet {
 
     #[pallet::storage] // --- MAP ( netuid ) --> identity. (DEPRECATED for V2)
     pub type SubnetIdentities<T: Config> =
-        StorageMap<_, Blake2_128Concat, u16, SubnetIdentityOf, OptionQuery>;
+        StorageMap<_, Blake2_128Concat, NetUid, SubnetIdentityOf, OptionQuery>;
 
     #[pallet::storage] // --- MAP ( netuid ) --> identityV2
     pub type SubnetIdentitiesV2<T: Config> =
-        StorageMap<_, Blake2_128Concat, u16, SubnetIdentityOfV2, OptionQuery>;
+        StorageMap<_, Blake2_128Concat, NetUid, SubnetIdentityOfV2, OptionQuery>;
 
     /// =================================
     /// ==== Axon / Promo Endpoints =====
@@ -1624,7 +1650,7 @@ pub mod pallet {
         _,
         (
             NMapKey<Blake2_128Concat, T::AccountId>, // hot
-            NMapKey<Identity, u16>,                  // netuid
+            NMapKey<Identity, NetUid>,               // netuid
             NMapKey<Identity, u16>,                  // extrinsic enum.
         ),
         u64,
@@ -1650,7 +1676,7 @@ pub mod pallet {
     pub type WeightCommits<T: Config> = StorageDoubleMap<
         _,
         Twox64Concat,
-        u16,
+        NetUid,
         Twox64Concat,
         T::AccountId,
         VecDeque<(H256, u64, u64, u64)>,
@@ -1661,7 +1687,7 @@ pub mod pallet {
     pub type CRV3WeightCommits<T: Config> = StorageDoubleMap<
         _,
         Twox64Concat,
-        u16,
+        NetUid,
         Twox64Concat,
         u64,
         VecDeque<(
@@ -1674,7 +1700,7 @@ pub mod pallet {
     #[pallet::storage]
     /// --- Map (netuid) --> Number of epochs allowed for commit reveal periods
     pub type RevealPeriodEpochs<T: Config> =
-        StorageMap<_, Twox64Concat, u16, u64, ValueQuery, DefaultRevealPeriodEpochs<T>>;
+        StorageMap<_, Twox64Concat, NetUid, u64, ValueQuery, DefaultRevealPeriodEpochs<T>>;
 
     #[pallet::storage]
     /// --- Map (coldkey, hotkey) --> u64 the last block at which stake was added/removed.
@@ -1694,7 +1720,7 @@ pub mod pallet {
     #[pallet::storage]
     /// --- DMAP (netuid, uid) --> (H160, last_block_where_ownership_was_proven)
     pub type AssociatedEvmAddress<T: Config> =
-        StorageDoubleMap<_, Twox64Concat, u16, Twox64Concat, u16, (H160, u64), OptionQuery>;
+        StorageDoubleMap<_, Twox64Concat, NetUid, Twox64Concat, u16, (H160, u64), OptionQuery>;
 
     /// ==================
     /// ==== Genesis =====
@@ -1722,7 +1748,7 @@ pub mod pallet {
     // ---- Subtensor helper functions.
     impl<T: Config> Pallet<T> {
         /// Returns the transaction priority for setting weights.
-        pub fn get_priority_set_weights(hotkey: &T::AccountId, netuid: u16) -> u64 {
+        pub fn get_priority_set_weights(hotkey: &T::AccountId, netuid: NetUid) -> u64 {
             if let Ok(uid) = Self::get_uid_for_net_and_hotkey(netuid, hotkey) {
                 // TODO rethink this.
                 let _stake = Self::get_inherited_for_hotkey_on_subnet(hotkey, netuid);
@@ -1754,15 +1780,15 @@ pub mod pallet {
         }
 
         /// Is the caller allowed to set weights
-        pub fn check_weights_min_stake(hotkey: &T::AccountId, netuid: u16) -> bool {
+        pub fn check_weights_min_stake(hotkey: &T::AccountId, netuid: NetUid) -> bool {
             // Blacklist weights transactions for low stake peers.
             let (total_stake, _, _) = Self::get_stake_weights_for_hotkey_on_subnet(hotkey, netuid);
             total_stake >= Self::get_stake_threshold()
         }
 
         /// Helper function to check if register is allowed
-        pub fn checked_allowed_register(netuid: u16) -> bool {
-            if netuid == Self::get_root_netuid() {
+        pub fn checked_allowed_register(netuid: NetUid) -> bool {
+            if netuid.is_root() {
                 return false;
             }
             if !Self::if_subnet_exist(netuid) {
@@ -1785,7 +1811,7 @@ pub mod pallet {
         }
 
         /// Ensure subtoken enalbed
-        pub fn ensure_subtoken_enabled(subnet: u16) -> DispatchResult {
+        pub fn ensure_subtoken_enabled(subnet: NetUid) -> DispatchResult {
             ensure!(
                 SubtokenEnabled::<T>::get(subnet),
                 Error::<T>::SubtokenDisabled
@@ -1885,7 +1911,7 @@ where
         u64::MAX
     }
 
-    pub fn get_priority_set_weights(who: &T::AccountId, netuid: u16) -> u64 {
+    pub fn get_priority_set_weights(who: &T::AccountId, netuid: NetUid) -> u64 {
         Pallet::<T>::get_priority_set_weights(who, netuid)
     }
 
@@ -1897,7 +1923,7 @@ where
         Pallet::<T>::get_priority_staking(coldkey, hotkey, stake_amount)
     }
 
-    pub fn check_weights_min_stake(who: &T::AccountId, netuid: u16) -> bool {
+    pub fn check_weights_min_stake(who: &T::AccountId, netuid: NetUid) -> bool {
         Pallet::<T>::check_weights_min_stake(who, netuid)
     }
 
@@ -2712,5 +2738,5 @@ impl<T, H, P> CollectiveInterface<T, H, P> for () {
 #[derive(Encode, Decode, Clone, PartialEq, Eq, Debug, TypeInfo)]
 pub enum RateLimitKey {
     // The setting sn owner hotkey operation is rate limited per netuid
-    SetSNOwnerHotkey(u16),
+    SetSNOwnerHotkey(NetUid),
 }
diff --git a/pallets/subtensor/src/macros/dispatches.rs b/pallets/subtensor/src/macros/dispatches.rs
index 650fb50451..d7675a9f3d 100644
--- a/pallets/subtensor/src/macros/dispatches.rs
+++ b/pallets/subtensor/src/macros/dispatches.rs
@@ -82,7 +82,7 @@ mod dispatches {
         .saturating_add(T::DbWeight::get().writes(2)), DispatchClass::Normal, Pays::No))]
         pub fn set_weights(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             dests: Vec<u16>,
             weights: Vec<u16>,
             version_key: u64,
@@ -125,7 +125,7 @@ mod dispatches {
         .saturating_add(T::DbWeight::get().writes(2)), DispatchClass::Normal, Pays::No))]
         pub fn batch_set_weights(
             origin: OriginFor<T>,
-            netuids: Vec<Compact<u16>>,
+            netuids: Vec<Compact<NetUid>>,
             weights: Vec<Vec<(Compact<u16>, Compact<u16>)>>,
             version_keys: Vec<Compact<u64>>,
         ) -> DispatchResult {
@@ -157,7 +157,7 @@ mod dispatches {
 		.saturating_add(T::DbWeight::get().writes(2)), DispatchClass::Normal, Pays::No))]
         pub fn commit_weights(
             origin: T::RuntimeOrigin,
-            netuid: u16,
+            netuid: NetUid,
             commit_hash: H256,
         ) -> DispatchResult {
             Self::do_commit_weights(origin, netuid, commit_hash)
@@ -191,7 +191,7 @@ mod dispatches {
         .saturating_add(T::DbWeight::get().writes(2)), DispatchClass::Normal, Pays::No))]
         pub fn batch_commit_weights(
             origin: OriginFor<T>,
-            netuids: Vec<Compact<u16>>,
+            netuids: Vec<Compact<NetUid>>,
             commit_hashes: Vec<H256>,
         ) -> DispatchResult {
             Self::do_batch_commit_weights(origin, netuids, commit_hashes)
@@ -240,7 +240,7 @@ mod dispatches {
 		.saturating_add(T::DbWeight::get().writes(2)), DispatchClass::Normal, Pays::No))]
         pub fn reveal_weights(
             origin: T::RuntimeOrigin,
-            netuid: u16,
+            netuid: NetUid,
             uids: Vec<u16>,
             values: Vec<u16>,
             salt: Vec<u16>,
@@ -284,7 +284,7 @@ mod dispatches {
 		.saturating_add(T::DbWeight::get().writes(2)), DispatchClass::Normal, Pays::No))]
         pub fn commit_crv3_weights(
             origin: T::RuntimeOrigin,
-            netuid: u16,
+            netuid: NetUid,
             commit: BoundedVec<u8, ConstU32<MAX_CRV3_COMMIT_SIZE_BYTES>>,
             reveal_round: u64,
         ) -> DispatchResult {
@@ -336,7 +336,7 @@ mod dispatches {
 		.saturating_add(T::DbWeight::get().writes(2)), DispatchClass::Normal, Pays::No))]
         pub fn batch_reveal_weights(
             origin: T::RuntimeOrigin,
-            netuid: u16,
+            netuid: NetUid,
             uids_list: Vec<Vec<u16>>,
             values_list: Vec<Vec<u16>>,
             salts_list: Vec<Vec<u16>>,
@@ -418,7 +418,7 @@ mod dispatches {
 		.saturating_add(T::DbWeight::get().writes(0)), DispatchClass::Normal, Pays::No))]
         pub fn set_tao_weights(
             _origin: OriginFor<T>,
-            _netuid: u16,
+            _netuid: NetUid,
             _hotkey: T::AccountId,
             _dests: Vec<u16>,
             _weights: Vec<u16>,
@@ -591,7 +591,7 @@ mod dispatches {
         pub fn add_stake(
             origin: OriginFor<T>,
             hotkey: T::AccountId,
-            netuid: u16,
+            netuid: NetUid,
             amount_staked: u64,
         ) -> DispatchResult {
             Self::do_add_stake(origin, hotkey, netuid, amount_staked)
@@ -635,7 +635,7 @@ mod dispatches {
         pub fn remove_stake(
             origin: OriginFor<T>,
             hotkey: T::AccountId,
-            netuid: u16,
+            netuid: NetUid,
             amount_unstaked: u64,
         ) -> DispatchResult {
             Self::do_remove_stake(origin, hotkey, netuid, amount_unstaked)
@@ -698,7 +698,7 @@ mod dispatches {
 		.saturating_add(T::DbWeight::get().writes(1)), DispatchClass::Normal, Pays::No))]
         pub fn serve_axon(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             version: u32,
             ip: u128,
             port: u16,
@@ -782,7 +782,7 @@ mod dispatches {
 		.saturating_add(T::DbWeight::get().writes(1)), DispatchClass::Normal, Pays::No))]
         pub fn serve_axon_tls(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             version: u32,
             ip: u128,
             port: u16,
@@ -832,7 +832,7 @@ mod dispatches {
 		.saturating_add(T::DbWeight::get().writes(1)), DispatchClass::Normal, Pays::No))]
         pub fn serve_prometheus(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             version: u32,
             ip: u128,
             port: u16,
@@ -894,7 +894,7 @@ mod dispatches {
 		.saturating_add(T::DbWeight::get().writes(23)), DispatchClass::Normal, Pays::No))]
         pub fn register(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             block_number: u64,
             nonce: u64,
             work: Vec<u8>,
@@ -929,7 +929,7 @@ mod dispatches {
 		.saturating_add(T::DbWeight::get().writes(29)), DispatchClass::Normal, Pays::No))]
         pub fn burned_register(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             hotkey: T::AccountId,
         ) -> DispatchResult {
             Self::do_burned_registration(origin, netuid, hotkey)
@@ -1020,7 +1020,7 @@ mod dispatches {
         pub fn set_childkey_take(
             origin: OriginFor<T>,
             hotkey: T::AccountId,
-            netuid: u16,
+            netuid: NetUid,
             take: u16,
         ) -> DispatchResult {
             let coldkey = ensure_signed(origin)?;
@@ -1228,7 +1228,7 @@ mod dispatches {
         pub fn dissolve_network(
             origin: OriginFor<T>,
             coldkey: T::AccountId,
-            netuid: u16,
+            netuid: NetUid,
         ) -> DispatchResult {
             ensure_root(origin)?;
             Self::user_remove_network(coldkey, netuid)
@@ -1286,7 +1286,7 @@ mod dispatches {
         pub fn set_children(
             origin: T::RuntimeOrigin,
             hotkey: T::AccountId,
-            netuid: u16,
+            netuid: NetUid,
             children: Vec<(u64, T::AccountId)>,
         ) -> DispatchResultWithPostInfo {
             Self::do_schedule_children(origin, hotkey, netuid, children)?;
@@ -1406,7 +1406,7 @@ mod dispatches {
 		.saturating_add(T::DbWeight::get().writes(31)), DispatchClass::Operational, Pays::Yes))]
         pub fn schedule_dissolve_network(
             _origin: OriginFor<T>,
-            _netuid: u16,
+            _netuid: NetUid,
         ) -> DispatchResultWithPostInfo {
             Err(Error::<T>::CallDisabled.into())
 
@@ -1511,7 +1511,7 @@ mod dispatches {
 		.saturating_add(T::DbWeight::get().writes(1)), DispatchClass::Normal, Pays::Yes))]
         pub fn set_subnet_identity(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             subnet_name: Vec<u8>,
             github_repo: Vec<u8>,
             subnet_contact: Vec<u8>,
@@ -1641,8 +1641,8 @@ mod dispatches {
             origin: T::RuntimeOrigin,
             origin_hotkey: T::AccountId,
             destination_hotkey: T::AccountId,
-            origin_netuid: u16,
-            destination_netuid: u16,
+            origin_netuid: NetUid,
+            destination_netuid: NetUid,
             alpha_amount: u64,
         ) -> DispatchResult {
             Self::do_move_stake(
@@ -1684,8 +1684,8 @@ mod dispatches {
             origin: T::RuntimeOrigin,
             destination_coldkey: T::AccountId,
             hotkey: T::AccountId,
-            origin_netuid: u16,
-            destination_netuid: u16,
+            origin_netuid: NetUid,
+            destination_netuid: NetUid,
             alpha_amount: u64,
         ) -> DispatchResult {
             Self::do_transfer_stake(
@@ -1728,8 +1728,8 @@ mod dispatches {
         pub fn swap_stake(
             origin: T::RuntimeOrigin,
             hotkey: T::AccountId,
-            origin_netuid: u16,
-            destination_netuid: u16,
+            origin_netuid: NetUid,
+            destination_netuid: NetUid,
             alpha_amount: u64,
         ) -> DispatchResult {
             Self::do_swap_stake(
@@ -1790,7 +1790,7 @@ mod dispatches {
         pub fn add_stake_limit(
             origin: OriginFor<T>,
             hotkey: T::AccountId,
-            netuid: u16,
+            netuid: NetUid,
             amount_staked: u64,
             limit_price: u64,
             allow_partial: bool,
@@ -1854,7 +1854,7 @@ mod dispatches {
         pub fn remove_stake_limit(
             origin: OriginFor<T>,
             hotkey: T::AccountId,
-            netuid: u16,
+            netuid: NetUid,
             amount_unstaked: u64,
             limit_price: u64,
             allow_partial: bool,
@@ -1901,8 +1901,8 @@ mod dispatches {
         pub fn swap_stake_limit(
             origin: T::RuntimeOrigin,
             hotkey: T::AccountId,
-            origin_netuid: u16,
-            destination_netuid: u16,
+            origin_netuid: NetUid,
+            destination_netuid: NetUid,
             alpha_amount: u64,
             limit_price: u64,
             allow_partial: bool,
@@ -1957,7 +1957,7 @@ mod dispatches {
             DispatchClass::Operational,
             Pays::Yes
         ))]
-        pub fn start_call(origin: T::RuntimeOrigin, netuid: u16) -> DispatchResult {
+        pub fn start_call(origin: T::RuntimeOrigin, netuid: NetUid) -> DispatchResult {
             Self::do_start_call(origin, netuid)?;
             Ok(())
         }
@@ -1997,7 +1997,7 @@ mod dispatches {
         ))]
         pub fn associate_evm_key(
             origin: T::RuntimeOrigin,
-            netuid: u16,
+            netuid: NetUid,
             hotkey: T::AccountId,
             evm_key: H160,
             block_number: u64,
@@ -2026,7 +2026,7 @@ mod dispatches {
             origin: T::RuntimeOrigin,
             hotkey: T::AccountId,
             amount: u64,
-            netuid: u16,
+            netuid: NetUid,
         ) -> DispatchResult {
             Self::do_recycle_alpha(origin, hotkey, amount, netuid)
         }
@@ -2051,7 +2051,7 @@ mod dispatches {
             origin: T::RuntimeOrigin,
             hotkey: T::AccountId,
             amount: u64,
-            netuid: u16,
+            netuid: NetUid,
         ) -> DispatchResult {
             Self::do_burn_alpha(origin, hotkey, amount, netuid)
         }
@@ -2100,7 +2100,7 @@ mod dispatches {
         // pub fn add_stake_aggregate(
         //     origin: OriginFor<T>,
         //     hotkey: T::AccountId,
-        //     netuid: u16,
+        //     netuid: NetUid,
         //     amount_staked: u64,
         // ) -> DispatchResult {
         //     Self::do_add_stake_aggregate(origin, hotkey, netuid, amount_staked)
@@ -2150,7 +2150,7 @@ mod dispatches {
         // pub fn remove_stake_aggregate(
         //     origin: OriginFor<T>,
         //     hotkey: T::AccountId,
-        //     netuid: u16,
+        //     netuid: NetUid,
         //     amount_unstaked: u64,
         // ) -> DispatchResult {
         //     Self::do_remove_stake_aggregate(origin, hotkey, netuid, amount_unstaked)
@@ -2207,7 +2207,7 @@ mod dispatches {
         // pub fn add_stake_limit_aggregate(
         //     origin: OriginFor<T>,
         //     hotkey: T::AccountId,
-        //     netuid: u16,
+        //     netuid: Netuid,
         //     amount_staked: u64,
         //     limit_price: u64,
         //     allow_partial: bool,
@@ -2273,7 +2273,7 @@ mod dispatches {
         // pub fn remove_stake_limit_aggregate(
         //     origin: OriginFor<T>,
         //     hotkey: T::AccountId,
-        //     netuid: u16,
+        //     netuid: NetUid,
         //     amount_unstaked: u64,
         //     limit_price: u64,
         //     allow_partial: bool,
diff --git a/pallets/subtensor/src/macros/events.rs b/pallets/subtensor/src/macros/events.rs
index 9849a517ee..d7575174bd 100644
--- a/pallets/subtensor/src/macros/events.rs
+++ b/pallets/subtensor/src/macros/events.rs
@@ -10,29 +10,29 @@ mod events {
     #[pallet::generate_deposit(pub(super) fn deposit_event)]
     pub enum Event<T: Config> {
         /// a new network is added.
-        NetworkAdded(u16, u16),
+        NetworkAdded(NetUid, u16),
         /// a network is removed.
-        NetworkRemoved(u16),
+        NetworkRemoved(NetUid),
         /// stake has been transferred from the a coldkey account onto the hotkey staking account.
-        StakeAdded(T::AccountId, T::AccountId, u64, u64, u16, u64),
+        StakeAdded(T::AccountId, T::AccountId, u64, u64, NetUid, u64),
         /// stake has been removed from the hotkey staking account onto the coldkey account.
-        StakeRemoved(T::AccountId, T::AccountId, u64, u64, u16, u64),
+        StakeRemoved(T::AccountId, T::AccountId, u64, u64, NetUid, u64),
         /// stake has been transferred from the coldkey account onto the hotkey staking account (at the end of the block)
-        AggregatedStakeAdded(T::AccountId, T::AccountId, u16, u64),
+        AggregatedStakeAdded(T::AccountId, T::AccountId, NetUid, u64),
         /// adding aggregated stake has failed
-        FailedToAddAggregatedStake(T::AccountId, T::AccountId, u16, u64),
+        FailedToAddAggregatedStake(T::AccountId, T::AccountId, NetUid, u64),
         /// limited stake has been transferred from the coldkey account onto the hotkey staking account (at the end of the block)
-        AggregatedLimitedStakeAdded(T::AccountId, T::AccountId, u16, u64, u64, bool),
+        AggregatedLimitedStakeAdded(T::AccountId, T::AccountId, NetUid, u64, u64, bool),
         /// adding limited aggregated stake has failed
-        FailedToAddAggregatedLimitedStake(T::AccountId, T::AccountId, u16, u64, u64, bool),
+        FailedToAddAggregatedLimitedStake(T::AccountId, T::AccountId, NetUid, u64, u64, bool),
         /// stake has been removed from the hotkey staking account into the coldkey account (at the end of the block).
-        AggregatedStakeRemoved(T::AccountId, T::AccountId, u16, u64),
+        AggregatedStakeRemoved(T::AccountId, T::AccountId, NetUid, u64),
         /// removing aggregated stake has failed
-        FailedToRemoveAggregatedStake(T::AccountId, T::AccountId, u16, u64),
+        FailedToRemoveAggregatedStake(T::AccountId, T::AccountId, NetUid, u64),
         /// aggregated limited stake has been removed from the hotkey staking account into the coldkey account (at the end of the block).
-        AggregatedLimitedStakeRemoved(T::AccountId, T::AccountId, u16, u64, u64, bool),
+        AggregatedLimitedStakeRemoved(T::AccountId, T::AccountId, NetUid, u64, u64, bool),
         /// removing limited aggregated stake has failed
-        FailedToRemoveAggregatedLimitedStake(T::AccountId, T::AccountId, u16, u64, u64, bool),
+        FailedToRemoveAggregatedLimitedStake(T::AccountId, T::AccountId, NetUid, u64, u64, bool),
         ///  aggregated unstake_all operation has succeeded
         AggregatedUnstakeAllSucceeded(T::AccountId, T::AccountId),
         /// aggregated unstake_all operation has failed
@@ -42,75 +42,82 @@ mod events {
         /// aggregated unstake_all_alpha operation has failed
         AggregatedUnstakeAllAlphaFailed(T::AccountId, T::AccountId),
         /// stake has been moved from origin (hotkey, subnet ID) to destination (hotkey, subnet ID) of this amount (in TAO).
-        StakeMoved(T::AccountId, T::AccountId, u16, T::AccountId, u16, u64),
+        StakeMoved(
+            T::AccountId,
+            T::AccountId,
+            NetUid,
+            T::AccountId,
+            NetUid,
+            u64,
+        ),
         /// a caller successfully sets their weights on a subnetwork.
-        WeightsSet(u16, u16),
+        WeightsSet(NetUid, u16),
         /// a new neuron account has been registered to the chain.
-        NeuronRegistered(u16, u16, T::AccountId),
+        NeuronRegistered(NetUid, u16, T::AccountId),
         /// multiple uids have been concurrently registered.
         BulkNeuronsRegistered(u16, u16),
         /// FIXME: Not used yet
         BulkBalancesSet(u16, u16),
         /// max allowed uids has been set for a subnetwork.
-        MaxAllowedUidsSet(u16, u16),
+        MaxAllowedUidsSet(NetUid, u16),
         /// the max weight limit has been set for a subnetwork.
-        MaxWeightLimitSet(u16, u16),
+        MaxWeightLimitSet(NetUid, u16),
         /// the difficulty has been set for a subnet.
-        DifficultySet(u16, u64),
+        DifficultySet(NetUid, u64),
         /// the adjustment interval is set for a subnet.
-        AdjustmentIntervalSet(u16, u16),
+        AdjustmentIntervalSet(NetUid, u16),
         /// registration per interval is set for a subnet.
-        RegistrationPerIntervalSet(u16, u16),
+        RegistrationPerIntervalSet(NetUid, u16),
         /// we set max registrations per block.
-        MaxRegistrationsPerBlockSet(u16, u16),
+        MaxRegistrationsPerBlockSet(NetUid, u16),
         /// an activity cutoff is set for a subnet.
-        ActivityCutoffSet(u16, u16),
+        ActivityCutoffSet(NetUid, u16),
         /// Rho value is set.
-        RhoSet(u16, u16),
+        RhoSet(NetUid, u16),
         /// steepness of the sigmoid used to compute alpha values.
-        AlphaSigmoidSteepnessSet(u16, u16),
+        AlphaSigmoidSteepnessSet(NetUid, u16),
         /// Kappa is set for a subnet.
-        KappaSet(u16, u16),
+        KappaSet(NetUid, u16),
         /// minimum allowed weight is set for a subnet.
-        MinAllowedWeightSet(u16, u16),
+        MinAllowedWeightSet(NetUid, u16),
         /// the validator pruning length has been set.
-        ValidatorPruneLenSet(u16, u64),
+        ValidatorPruneLenSet(NetUid, u64),
         /// the scaling law power has been set for a subnet.
-        ScalingLawPowerSet(u16, u16),
+        ScalingLawPowerSet(NetUid, u16),
         /// weights set rate limit has been set for a subnet.
-        WeightsSetRateLimitSet(u16, u64),
+        WeightsSetRateLimitSet(NetUid, u64),
         /// immunity period is set for a subnet.
-        ImmunityPeriodSet(u16, u16),
+        ImmunityPeriodSet(NetUid, u16),
         /// bonds moving average is set for a subnet.
-        BondsMovingAverageSet(u16, u64),
+        BondsMovingAverageSet(NetUid, u64),
         /// bonds penalty is set for a subnet.
-        BondsPenaltySet(u16, u16),
+        BondsPenaltySet(NetUid, u16),
         /// bonds reset is set for a subnet.
-        BondsResetOnSet(u16, bool),
+        BondsResetOnSet(NetUid, bool),
         /// setting the max number of allowed validators on a subnet.
-        MaxAllowedValidatorsSet(u16, u16),
+        MaxAllowedValidatorsSet(NetUid, u16),
         /// the axon server information is added to the network.
-        AxonServed(u16, T::AccountId),
+        AxonServed(NetUid, T::AccountId),
         /// the prometheus server information is added to the network.
-        PrometheusServed(u16, T::AccountId),
+        PrometheusServed(NetUid, T::AccountId),
         /// a hotkey has become a delegate.
         DelegateAdded(T::AccountId, T::AccountId, u16),
         /// the default take is set.
         DefaultTakeSet(u16),
         /// weights version key is set for a network.
-        WeightsVersionKeySet(u16, u64),
+        WeightsVersionKeySet(NetUid, u64),
         /// setting min difficulty on a network.
-        MinDifficultySet(u16, u64),
+        MinDifficultySet(NetUid, u64),
         /// setting max difficulty on a network.
-        MaxDifficultySet(u16, u64),
+        MaxDifficultySet(NetUid, u64),
         /// setting the prometheus serving rate limit.
-        ServingRateLimitSet(u16, u64),
+        ServingRateLimitSet(NetUid, u64),
         /// setting burn on a network.
-        BurnSet(u16, u64),
+        BurnSet(NetUid, u64),
         /// setting max burn on a network.
-        MaxBurnSet(u16, u64),
+        MaxBurnSet(NetUid, u64),
         /// setting min burn on a network.
-        MinBurnSet(u16, u64),
+        MinBurnSet(NetUid, u64),
         /// setting the transaction rate limit.
         TxRateLimitSet(u64),
         /// setting the delegate take transaction rate limit.
@@ -126,19 +133,19 @@ mod events {
         /// a sudo call is done.
         Sudid(DispatchResult),
         /// registration is allowed/disallowed for a subnet.
-        RegistrationAllowed(u16, bool),
+        RegistrationAllowed(NetUid, bool),
         /// POW registration is allowed/disallowed for a subnet.
-        PowRegistrationAllowed(u16, bool),
+        PowRegistrationAllowed(NetUid, bool),
         /// setting tempo on a network
-        TempoSet(u16, u16),
+        TempoSet(NetUid, u16),
         /// setting the RAO recycled for registration.
-        RAORecycledForRegistrationSet(u16, u64),
+        RAORecycledForRegistrationSet(NetUid, u64),
         /// min stake is set for validators to set weights.
         StakeThresholdSet(u64),
         /// setting the minimum required stake amount for senate registration.
         SenateRequiredStakePercentSet(u64),
         /// setting the adjustment alpha on a subnet.
-        AdjustmentAlphaSet(u16, u64),
+        AdjustmentAlphaSet(NetUid, u64),
         /// the faucet it called on the test net.
         Faucet(T::AccountId, u64),
         /// the subnet owner cut is set.
@@ -214,9 +221,9 @@ mod events {
             coldkey: T::AccountId,
         },
         /// Setting of children of a hotkey have been scheduled
-        SetChildrenScheduled(T::AccountId, u16, u64, Vec<(u64, T::AccountId)>),
+        SetChildrenScheduled(T::AccountId, NetUid, u64, Vec<(u64, T::AccountId)>),
         /// The children of a hotkey have been set
-        SetChildren(T::AccountId, u16, Vec<(u64, T::AccountId)>),
+        SetChildren(T::AccountId, NetUid, Vec<(u64, T::AccountId)>),
         // /// The hotkey emission tempo has been set
         // HotkeyEmissionTempoSet(u64),
         // /// The network maximum stake has been set
@@ -224,15 +231,15 @@ mod events {
         /// The identity of a coldkey has been set
         ChainIdentitySet(T::AccountId),
         /// The identity of a subnet has been set
-        SubnetIdentitySet(u16),
+        SubnetIdentitySet(NetUid),
         /// The identity of a subnet has been removed
-        SubnetIdentityRemoved(u16),
+        SubnetIdentityRemoved(NetUid),
         /// A dissolve network extrinsic scheduled.
         DissolveNetworkScheduled {
             /// The account ID schedule the dissolve network extrisnic
             account: T::AccountId,
             /// network ID will be dissolved
-            netuid: u16,
+            netuid: NetUid,
             /// extrinsic execution block number
             execution_block: BlockNumberFor<T>,
         },
@@ -245,33 +252,33 @@ mod events {
         /// - **who**: The account ID of the user committing the weights.
         /// - **netuid**: The network identifier.
         /// - **commit_hash**: The hash representing the committed weights.
-        CRV3WeightsCommitted(T::AccountId, u16, H256),
+        CRV3WeightsCommitted(T::AccountId, NetUid, H256),
         /// Weights have been successfully committed.
         ///
         /// - **who**: The account ID of the user committing the weights.
         /// - **netuid**: The network identifier.
         /// - **commit_hash**: The hash representing the committed weights.
-        WeightsCommitted(T::AccountId, u16, H256),
+        WeightsCommitted(T::AccountId, NetUid, H256),
 
         /// Weights have been successfully revealed.
         ///
         /// - **who**: The account ID of the user revealing the weights.
         /// - **netuid**: The network identifier.
         /// - **commit_hash**: The hash of the revealed weights.
-        WeightsRevealed(T::AccountId, u16, H256),
+        WeightsRevealed(T::AccountId, NetUid, H256),
 
         /// Weights have been successfully batch revealed.
         ///
         /// - **who**: The account ID of the user revealing the weights.
         /// - **netuid**: The network identifier.
         /// - **revealed_hashes**: A vector of hashes representing each revealed weight set.
-        WeightsBatchRevealed(T::AccountId, u16, Vec<H256>),
+        WeightsBatchRevealed(T::AccountId, NetUid, Vec<H256>),
 
         /// A batch of weights (or commits) have been force-set.
         ///
         /// - **netuids**: The netuids these weights were successfully set/committed for.
         /// - **who**: The hotkey that set this batch.
-        BatchWeightsCompleted(Vec<Compact<u16>>, T::AccountId),
+        BatchWeightsCompleted(Vec<Compact<NetUid>>, T::AccountId),
 
         /// A batch extrinsic completed but with some errors.
         BatchCompletedWithErrors(),
@@ -284,48 +291,55 @@ mod events {
         /// Stake has been transferred from one coldkey to another on the same subnet.
         /// Parameters:
         /// (origin_coldkey, destination_coldkey, hotkey, origin_netuid, destination_netuid, amount)
-        StakeTransferred(T::AccountId, T::AccountId, T::AccountId, u16, u16, u64),
+        StakeTransferred(
+            T::AccountId,
+            T::AccountId,
+            T::AccountId,
+            NetUid,
+            NetUid,
+            u64,
+        ),
 
         /// Stake has been swapped from one subnet to another for the same coldkey-hotkey pair.
         ///
         /// Parameters:
         /// (coldkey, hotkey, origin_netuid, destination_netuid, amount)
-        StakeSwapped(T::AccountId, T::AccountId, u16, u16, u64),
+        StakeSwapped(T::AccountId, T::AccountId, NetUid, NetUid, u64),
 
         /// Event called when transfer is toggled on a subnet.
         ///
         /// Parameters:
         /// (netuid, bool)
-        TransferToggle(u16, bool),
+        TransferToggle(NetUid, bool),
 
         /// The owner hotkey for a subnet has been set.
         ///
         /// Parameters:
         /// (netuid, new_hotkey)
-        SubnetOwnerHotkeySet(u16, T::AccountId),
+        SubnetOwnerHotkeySet(NetUid, T::AccountId),
         /// FirstEmissionBlockNumber is set via start call extrinsic
         ///
         /// Parameters:
         /// netuid
         /// block number
-        FirstEmissionBlockNumberSet(u16, u64),
+        FirstEmissionBlockNumberSet(NetUid, u64),
 
         /// Alpha has been recycled, reducing AlphaOut on a subnet.
         ///
         /// Parameters:
         /// (coldkey, hotkey, amount, subnet_id)
-        AlphaRecycled(T::AccountId, T::AccountId, u64, u16),
+        AlphaRecycled(T::AccountId, T::AccountId, u64, NetUid),
 
         /// Alpha have been burned without reducing AlphaOut.
         ///
         /// Parameters:
         /// (coldkey, hotkey, amount, subnet_id)
-        AlphaBurned(T::AccountId, T::AccountId, u64, u16),
+        AlphaBurned(T::AccountId, T::AccountId, u64, NetUid),
 
         /// An EVM key has been associated with a hotkey.
         EvmKeyAssociated {
             /// The subnet that the hotkey belongs to.
-            netuid: u16,
+            netuid: NetUid,
             /// The hotkey associated with the EVM key.
             hotkey: T::AccountId,
             /// The EVM key being associated with the hotkey.
@@ -338,18 +352,18 @@ mod events {
         ///
         /// - **netuid**: The network identifier.
         /// - **who**: The account ID of the user revealing the weights.
-        CRV3WeightsRevealed(u16, T::AccountId),
+        CRV3WeightsRevealed(NetUid, T::AccountId),
 
         /// Commit-Reveal periods has been successfully set.
         ///
         /// - **netuid**: The network identifier.
         /// - **periods**: The number of epochs before the reveal.
-        CommitRevealPeriodsSet(u16, u64),
+        CommitRevealPeriodsSet(NetUid, u64),
 
         /// Commit-Reveal has been successfully toggled.
         ///
         /// - **netuid**: The network identifier.
         /// - **Enabled**: Is Commit-Reveal enabled.
-        CommitRevealEnabled(u16, bool),
+        CommitRevealEnabled(NetUid, bool),
     }
 }
diff --git a/pallets/subtensor/src/macros/genesis.rs b/pallets/subtensor/src/macros/genesis.rs
index f1288c5a63..7040c7fef6 100644
--- a/pallets/subtensor/src/macros/genesis.rs
+++ b/pallets/subtensor/src/macros/genesis.rs
@@ -11,41 +11,38 @@ mod genesis {
             // Set initial total issuance from balances
             TotalIssuance::<T>::put(self.balances_issuance);
 
-            // Get the root network uid.
-            let root_netuid: u16 = 0;
-
             // Set the root network as added.
-            NetworksAdded::<T>::insert(root_netuid, true);
+            NetworksAdded::<T>::insert(NetUid::ROOT, true);
 
             // Increment the number of total networks.
             TotalNetworks::<T>::mutate(|n| *n = n.saturating_add(1));
 
             // Set the number of validators to 1.
-            SubnetworkN::<T>::insert(root_netuid, 0);
+            SubnetworkN::<T>::insert(NetUid::ROOT, 0);
 
             // Set the maximum number to the number of senate members.
-            MaxAllowedUids::<T>::insert(root_netuid, 64u16);
+            MaxAllowedUids::<T>::insert(NetUid::ROOT, 64u16);
 
             // Set the maximum number to the number of validators to all members.
-            MaxAllowedValidators::<T>::insert(root_netuid, 64u16);
+            MaxAllowedValidators::<T>::insert(NetUid::ROOT, 64u16);
 
             // Set the min allowed weights to zero, no weights restrictions.
-            MinAllowedWeights::<T>::insert(root_netuid, 0);
+            MinAllowedWeights::<T>::insert(NetUid::ROOT, 0);
 
             // Set the max weight limit to infitiy, no weight restrictions.
-            MaxWeightsLimit::<T>::insert(root_netuid, u16::MAX);
+            MaxWeightsLimit::<T>::insert(NetUid::ROOT, u16::MAX);
 
             // Add default root tempo.
-            Tempo::<T>::insert(root_netuid, 100);
+            Tempo::<T>::insert(NetUid::ROOT, 100);
 
             // Set the root network as open.
-            NetworkRegistrationAllowed::<T>::insert(root_netuid, true);
+            NetworkRegistrationAllowed::<T>::insert(NetUid::ROOT, true);
 
             // Set target registrations for validators as 1 per block.
-            TargetRegistrationsPerInterval::<T>::insert(root_netuid, 1);
+            TargetRegistrationsPerInterval::<T>::insert(NetUid::ROOT, 1);
 
             for net in 1..2 {
-                let netuid: u16 = net as u16;
+                let netuid = NetUid::from(net);
                 let hotkey = DefaultAccount::<T>::get();
                 SubnetMechanism::<T>::insert(netuid, 1); // Make dynamic.
                 Owner::<T>::insert(hotkey.clone(), hotkey.clone());
@@ -83,8 +80,7 @@ mod genesis {
                 }
 
                 let block_number = Pallet::<T>::get_current_block_as_u64();
-                for next_uid_s in 0..1 {
-                    let next_uid: u16 = next_uid_s as u16;
+                for next_uid in 0u16..1 {
                     SubnetworkN::<T>::insert(netuid, next_uid.saturating_add(1));
                     Rank::<T>::mutate(netuid, |v| v.push(0));
                     Trust::<T>::mutate(netuid, |v| v.push(0));
diff --git a/pallets/subtensor/src/migrations/migrate_create_root_network.rs b/pallets/subtensor/src/migrations/migrate_create_root_network.rs
index c413d1f078..24e2251c38 100644
--- a/pallets/subtensor/src/migrations/migrate_create_root_network.rs
+++ b/pallets/subtensor/src/migrations/migrate_create_root_network.rs
@@ -6,6 +6,7 @@ use frame_support::{
     weights::Weight,
 };
 use sp_std::vec::Vec;
+use subtensor_runtime_common::NetUid;
 
 // TODO (camfairchild): TEST MIGRATION
 
@@ -39,47 +40,44 @@ pub mod deprecated_loaded_emission_format {
 /// let weight = migrate_create_root_network::<Runtime>();
 /// ```
 pub fn migrate_create_root_network<T: Config>() -> Weight {
-    // Define the root network UID
-    let root_netuid: u16 = 0;
-
     // Initialize weight counter
     let mut weight = T::DbWeight::get().reads(1);
 
     // Check if root network already exists
-    if NetworksAdded::<T>::get(root_netuid) {
+    if NetworksAdded::<T>::get(NetUid::ROOT) {
         // Return early if root network already exists
         return weight;
     }
 
     // Set the root network as added
-    NetworksAdded::<T>::insert(root_netuid, true);
+    NetworksAdded::<T>::insert(NetUid::ROOT, true);
 
     // Increment the total number of networks
     TotalNetworks::<T>::mutate(|n| *n = n.saturating_add(1));
 
     // Set the maximum number of UIDs to the number of senate members
-    MaxAllowedUids::<T>::insert(root_netuid, 64);
+    MaxAllowedUids::<T>::insert(NetUid::ROOT, 64);
 
     // Set the maximum number of validators to all members
-    MaxAllowedValidators::<T>::insert(root_netuid, 64);
+    MaxAllowedValidators::<T>::insert(NetUid::ROOT, 64);
 
     // Set the minimum allowed weights to zero (no weight restrictions)
-    MinAllowedWeights::<T>::insert(root_netuid, 0);
+    MinAllowedWeights::<T>::insert(NetUid::ROOT, 0);
 
     // Set the maximum weight limit to u16::MAX (no weight restrictions)
-    MaxWeightsLimit::<T>::insert(root_netuid, u16::MAX);
+    MaxWeightsLimit::<T>::insert(NetUid::ROOT, u16::MAX);
 
     // Set default root tempo
-    Tempo::<T>::insert(root_netuid, 100);
+    Tempo::<T>::insert(NetUid::ROOT, 100);
 
     // Set the root network as open for registration
-    NetworkRegistrationAllowed::<T>::insert(root_netuid, true);
+    NetworkRegistrationAllowed::<T>::insert(NetUid::ROOT, true);
 
     // Set target registrations for validators as 1 per block
-    TargetRegistrationsPerInterval::<T>::insert(root_netuid, 1);
+    TargetRegistrationsPerInterval::<T>::insert(NetUid::ROOT, 1);
 
     // TODO: Consider if WeightsSetRateLimit should be set
-    // WeightsSetRateLimit::<T>::insert(root_netuid, 7200);
+    // WeightsSetRateLimit::<T>::insert(NetUid::ROOT, 7200);
 
     // Accrue weight for database writes
     weight.saturating_accrue(T::DbWeight::get().writes(8));
diff --git a/pallets/subtensor/src/migrations/migrate_delete_subnet_21.rs b/pallets/subtensor/src/migrations/migrate_delete_subnet_21.rs
index d12a58ed37..068fcc35b3 100644
--- a/pallets/subtensor/src/migrations/migrate_delete_subnet_21.rs
+++ b/pallets/subtensor/src/migrations/migrate_delete_subnet_21.rs
@@ -7,6 +7,7 @@ use frame_support::{
 };
 use log::info;
 use sp_std::vec::Vec;
+use subtensor_runtime_common::NetUid;
 
 /// Constant for logging purposes
 const LOG_TARGET: &str = "migrate_delete_subnet_21";
@@ -50,10 +51,10 @@ pub fn migrate_delete_subnet_21<T: Config>() -> Weight {
     let onchain_version = Pallet::<T>::on_chain_storage_version();
 
     // Only runs if we haven't already updated version past above new_storage_version and subnet 21 exists.
-    if onchain_version < new_storage_version && Pallet::<T>::if_subnet_exist(21) {
+    if onchain_version < new_storage_version && Pallet::<T>::if_subnet_exist(NetUid::from(21)) {
         info!(target: LOG_TARGET, ">>> Removing subnet 21 {:?}", onchain_version);
 
-        let netuid = 21;
+        let netuid = NetUid::from(21);
 
         // We do this all manually as we don't want to call code related to giving subnet owner back their locked token cost.
         // Remove network count
diff --git a/pallets/subtensor/src/migrations/migrate_delete_subnet_3.rs b/pallets/subtensor/src/migrations/migrate_delete_subnet_3.rs
index 0e85c56554..fde7e09920 100644
--- a/pallets/subtensor/src/migrations/migrate_delete_subnet_3.rs
+++ b/pallets/subtensor/src/migrations/migrate_delete_subnet_3.rs
@@ -50,14 +50,14 @@ pub fn migrate_delete_subnet_3<T: Config>() -> Weight {
     let onchain_version = Pallet::<T>::on_chain_storage_version();
 
     // Only proceed if current version is less than the new version and subnet 3 exists
-    if onchain_version < new_storage_version && Pallet::<T>::if_subnet_exist(3) {
+    if onchain_version < new_storage_version && Pallet::<T>::if_subnet_exist(3.into()) {
         info!(
             target: LOG_TARGET,
             "Removing subnet 3. Current version: {:?}",
             onchain_version
         );
 
-        let netuid = 3;
+        let netuid = NetUid::from(3);
 
         // Remove network count
         SubnetworkN::<T>::remove(netuid);
diff --git a/pallets/subtensor/src/migrations/migrate_rao.rs b/pallets/subtensor/src/migrations/migrate_rao.rs
index 975ab55c11..f4cd87b356 100644
--- a/pallets/subtensor/src/migrations/migrate_rao.rs
+++ b/pallets/subtensor/src/migrations/migrate_rao.rs
@@ -25,7 +25,7 @@ pub fn migrate_rao<T: Config>() -> Weight {
         String::from_utf8_lossy(&migration_name)
     );
 
-    let netuids: Vec<u16> = <NetworksAdded<T> as IterableStorageMap<u16, bool>>::iter()
+    let netuids: Vec<NetUid> = <NetworksAdded<T> as IterableStorageMap<NetUid, bool>>::iter()
         .map(|(netuid, _)| netuid)
         .collect();
     weight = weight.saturating_add(T::DbWeight::get().reads_writes(netuids.len() as u64, 0));
@@ -62,12 +62,12 @@ pub fn migrate_rao<T: Config>() -> Weight {
     NetworkMinLockCost::<T>::set(1_000_000_000);
     // Set tao weight.
     TaoWeight::<T>::set(3_320_413_933_267_719_290);
-    for netuid in netuids.iter().clone() {
-        if *netuid == 0 {
+    for netuid in netuids.iter() {
+        if netuid.is_root() {
             // Give root a single RAO in pool to avoid any catestrophic division by zero.
             SubnetAlphaIn::<T>::insert(netuid, 1_000_000_000);
             SubnetMechanism::<T>::insert(netuid, 0); // Set to zero mechanism.
-            TokenSymbol::<T>::insert(netuid, Pallet::<T>::get_symbol_for_subnet(0));
+            TokenSymbol::<T>::insert(netuid, Pallet::<T>::get_symbol_for_subnet(NetUid::ROOT));
             continue;
         }
         let owner = SubnetOwner::<T>::get(netuid);
diff --git a/pallets/subtensor/src/migrations/migrate_set_first_emission_block_number.rs b/pallets/subtensor/src/migrations/migrate_set_first_emission_block_number.rs
index 04ad306218..2da7cef51a 100644
--- a/pallets/subtensor/src/migrations/migrate_set_first_emission_block_number.rs
+++ b/pallets/subtensor/src/migrations/migrate_set_first_emission_block_number.rs
@@ -26,7 +26,7 @@ pub fn migrate_set_first_emission_block_number<T: Config>() -> Weight {
     let netuids = Pallet::<T>::get_all_subnet_netuids();
     let current_block_number = Pallet::<T>::get_current_block_as_u64();
     for netuid in netuids.iter() {
-        if *netuid != 0 {
+        if !netuid.is_root() {
             FirstEmissionBlockNumber::<T>::insert(netuid, current_block_number);
         }
     }
diff --git a/pallets/subtensor/src/migrations/migrate_set_min_burn.rs b/pallets/subtensor/src/migrations/migrate_set_min_burn.rs
index a38badfbb1..8a74e1e51c 100644
--- a/pallets/subtensor/src/migrations/migrate_set_min_burn.rs
+++ b/pallets/subtensor/src/migrations/migrate_set_min_burn.rs
@@ -24,13 +24,13 @@ pub fn migrate_set_min_burn<T: Config>() -> Weight {
         String::from_utf8_lossy(&migration_name)
     );
 
-    let netuids: Vec<u16> = <NetworksAdded<T> as IterableStorageMap<u16, bool>>::iter()
+    let netuids: Vec<NetUid> = <NetworksAdded<T> as IterableStorageMap<NetUid, bool>>::iter()
         .map(|(netuid, _)| netuid)
         .collect();
     weight = weight.saturating_add(T::DbWeight::get().reads(netuids.len() as u64));
 
-    for netuid in netuids.iter().clone() {
-        if *netuid == 0 {
+    for netuid in netuids.iter() {
+        if netuid.is_root() {
             continue;
         }
         // Set min burn to the newest initial min burn
diff --git a/pallets/subtensor/src/migrations/migrate_set_min_difficulty.rs b/pallets/subtensor/src/migrations/migrate_set_min_difficulty.rs
index 6d859925ae..bdc6c993e2 100644
--- a/pallets/subtensor/src/migrations/migrate_set_min_difficulty.rs
+++ b/pallets/subtensor/src/migrations/migrate_set_min_difficulty.rs
@@ -24,13 +24,13 @@ pub fn migrate_set_min_difficulty<T: Config>() -> Weight {
         String::from_utf8_lossy(&migration_name)
     );
 
-    let netuids: Vec<u16> = <NetworksAdded<T> as IterableStorageMap<u16, bool>>::iter()
+    let netuids: Vec<NetUid> = <NetworksAdded<T> as IterableStorageMap<NetUid, bool>>::iter()
         .map(|(netuid, _)| netuid)
         .collect();
     weight = weight.saturating_add(T::DbWeight::get().reads(netuids.len() as u64));
 
-    for netuid in netuids.iter().clone() {
-        if *netuid == 0 {
+    for netuid in netuids.iter() {
+        if netuid.is_root() {
             continue;
         }
         // Set min difficulty to 10 million for all subnets
diff --git a/pallets/subtensor/src/migrations/migrate_set_subtoken_enabled.rs b/pallets/subtensor/src/migrations/migrate_set_subtoken_enabled.rs
index da4386c4b8..3b0d236f99 100644
--- a/pallets/subtensor/src/migrations/migrate_set_subtoken_enabled.rs
+++ b/pallets/subtensor/src/migrations/migrate_set_subtoken_enabled.rs
@@ -25,7 +25,7 @@ pub fn migrate_set_subtoken_enabled<T: Config>() -> Weight {
     // ------------------------------
     let netuids = Pallet::<T>::get_all_subnet_netuids();
     for netuid in netuids.iter() {
-        if *netuid != 0 {
+        if !netuid.is_root() {
             // set it as true if start call executed and value exists for first emission block number
             SubtokenEnabled::<T>::insert(
                 netuid,
diff --git a/pallets/subtensor/src/migrations/migrate_to_v1_separate_emission.rs b/pallets/subtensor/src/migrations/migrate_to_v1_separate_emission.rs
index 5d28337dcb..b97acaa4a3 100644
--- a/pallets/subtensor/src/migrations/migrate_to_v1_separate_emission.rs
+++ b/pallets/subtensor/src/migrations/migrate_to_v1_separate_emission.rs
@@ -72,7 +72,7 @@ pub fn migrate_to_v1_separate_emission<T: Config>() -> Weight {
 
         // Translate old storage values to new format
         LoadedEmission::<T>::translate::<Vec<(AccountIdOf<T>, u64)>, _>(
-            |netuid: u16,
+            |netuid: NetUid,
              netuid_emissions: Vec<(AccountIdOf<T>, u64)>|
              -> Option<Vec<(AccountIdOf<T>, u64, u64)>> {
                 info!(target: LOG_TARGET, "     Do migration of netuid: {:?}...", netuid);
diff --git a/pallets/subtensor/src/migrations/migrate_transfer_ownership_to_foundation.rs b/pallets/subtensor/src/migrations/migrate_transfer_ownership_to_foundation.rs
index 8d1bd437c6..10a93784bb 100644
--- a/pallets/subtensor/src/migrations/migrate_transfer_ownership_to_foundation.rs
+++ b/pallets/subtensor/src/migrations/migrate_transfer_ownership_to_foundation.rs
@@ -65,13 +65,13 @@ pub fn migrate_transfer_ownership_to_foundation<T: Config>(coldkey: [u8; 32]) ->
         weight.saturating_accrue(T::DbWeight::get().reads(1));
 
         // Transfer ownership of subnets 1 and 11 to the foundation
-        SubnetOwner::<T>::insert(1, coldkey_account.clone());
-        SubnetOwner::<T>::insert(11, coldkey_account);
+        SubnetOwner::<T>::insert(NetUid::from(1), coldkey_account.clone());
+        SubnetOwner::<T>::insert(NetUid::from(11), coldkey_account);
 
         // Set the registration time for subnet 1 to extend immunity period
-        NetworkRegisteredAt::<T>::insert(1, current_block.saturating_add(13 * 7200));
+        NetworkRegisteredAt::<T>::insert(NetUid::from(1), current_block.saturating_add(13 * 7200));
         // Set the registration time for subnet 11 to the current block
-        NetworkRegisteredAt::<T>::insert(11, current_block);
+        NetworkRegisteredAt::<T>::insert(NetUid::from(11), current_block);
 
         weight.saturating_accrue(T::DbWeight::get().writes(4));
 
diff --git a/pallets/subtensor/src/rpc_info/delegate_info.rs b/pallets/subtensor/src/rpc_info/delegate_info.rs
index f0a2447e4f..94e4034b66 100644
--- a/pallets/subtensor/src/rpc_info/delegate_info.rs
+++ b/pallets/subtensor/src/rpc_info/delegate_info.rs
@@ -6,16 +6,17 @@ use substrate_fixed::types::U64F64;
 extern crate alloc;
 use alloc::collections::BTreeMap;
 use codec::Compact;
+use subtensor_runtime_common::NetUid;
 
-#[freeze_struct("7cd21f57627d2d0d")]
+#[freeze_struct("1fafc4fcf28cba7a")]
 #[derive(Decode, Encode, PartialEq, Eq, Clone, Debug, TypeInfo)]
 pub struct DelegateInfo<AccountId: TypeInfo + Encode + Decode> {
     pub delegate_ss58: AccountId,
     pub take: Compact<u16>,
-    pub nominators: Vec<(AccountId, Vec<(Compact<u16>, Compact<u64>)>)>, // map of nominator_ss58 to netuid and stake amount
+    pub nominators: Vec<(AccountId, Vec<(Compact<NetUid>, Compact<u64>)>)>, // map of nominator_ss58 to netuid and stake amount
     pub owner_ss58: AccountId,
-    pub registrations: Vec<Compact<u16>>, // Vec of netuid this delegate is registered on
-    pub validator_permits: Vec<Compact<u16>>, // Vec of netuid this delegate has validator permit on
+    pub registrations: Vec<Compact<NetUid>>, // Vec of netuid this delegate is registered on
+    pub validator_permits: Vec<Compact<NetUid>>, // Vec of netuid this delegate has validator permit on
     pub return_per_1000: Compact<u64>, // Delegators current daily return per 1000 TAO staked minus take fee
     pub total_daily_return: Compact<u64>, // Delegators current daily return
 }
@@ -53,8 +54,9 @@ impl<T: Config> Pallet<T> {
         delegate: AccountIdOf<T>,
         skip_nominators: bool,
     ) -> DelegateInfo<T::AccountId> {
-        let mut nominators = Vec::<(T::AccountId, Vec<(Compact<u16>, Compact<u64>)>)>::new();
-        let mut nominator_map = BTreeMap::<T::AccountId, Vec<(Compact<u16>, Compact<u64>)>>::new();
+        let mut nominators = Vec::<(T::AccountId, Vec<(Compact<NetUid>, Compact<u64>)>)>::new();
+        let mut nominator_map =
+            BTreeMap::<T::AccountId, Vec<(Compact<NetUid>, Compact<u64>)>>::new();
 
         if !skip_nominators {
             let mut alpha_share_pools = vec![];
@@ -68,7 +70,7 @@ impl<T: Config> Pallet<T> {
                     continue;
                 }
 
-                if let Some(alpha_share_pool) = alpha_share_pools.get(netuid as usize) {
+                if let Some(alpha_share_pool) = alpha_share_pools.get(u16::from(netuid) as usize) {
                     let coldkey_stake = alpha_share_pool.get_value_from_shares(alpha_stake);
 
                     nominator_map
@@ -84,7 +86,7 @@ impl<T: Config> Pallet<T> {
         }
 
         let registrations = Self::get_registered_networks_for_hotkey(&delegate.clone());
-        let mut validator_permits = Vec::<Compact<u16>>::new();
+        let mut validator_permits = Vec::<Compact<NetUid>>::new();
         let mut emissions_per_day: U64F64 = U64F64::saturating_from_num(0);
 
         for netuid in registrations.iter() {
@@ -108,7 +110,7 @@ impl<T: Config> Pallet<T> {
         let take: Compact<u16> = <Delegates<T>>::get(delegate.clone()).into();
 
         let total_stake: U64F64 =
-            Self::get_stake_for_hotkey_on_subnet(&delegate.clone(), Self::get_root_netuid()).into();
+            Self::get_stake_for_hotkey_on_subnet(&delegate.clone(), NetUid::ROOT).into();
 
         let return_per_1000: U64F64 =
             Self::return_per_1000_tao(take, total_stake, emissions_per_day);
@@ -151,8 +153,8 @@ impl<T: Config> Pallet<T> {
     ///
     pub fn get_delegated(
         delegatee: T::AccountId,
-    ) -> Vec<(DelegateInfo<T::AccountId>, (Compact<u16>, Compact<u64>))> {
-        let mut delegates: Vec<(DelegateInfo<T::AccountId>, (Compact<u16>, Compact<u64>))> =
+    ) -> Vec<(DelegateInfo<T::AccountId>, (Compact<NetUid>, Compact<u64>))> {
+        let mut delegates: Vec<(DelegateInfo<T::AccountId>, (Compact<NetUid>, Compact<u64>))> =
             Vec::new();
         for delegate in <Delegates<T> as IterableStorageMap<T::AccountId, u16>>::iter_keys() {
             // Staked to this delegate, so add to list
diff --git a/pallets/subtensor/src/rpc_info/dynamic_info.rs b/pallets/subtensor/src/rpc_info/dynamic_info.rs
index b363931d9c..4e5400aba0 100644
--- a/pallets/subtensor/src/rpc_info/dynamic_info.rs
+++ b/pallets/subtensor/src/rpc_info/dynamic_info.rs
@@ -4,11 +4,12 @@ use codec::Compact;
 use frame_support::pallet_prelude::{Decode, Encode};
 use substrate_fixed::types::I96F32;
 use subtensor_macros::freeze_struct;
+use subtensor_runtime_common::NetUid;
 
-#[freeze_struct("7fbd2013e8262885")]
+#[freeze_struct("d813a7696ae616af")]
 #[derive(Decode, Encode, PartialEq, Eq, Clone, Debug, TypeInfo)]
 pub struct DynamicInfo<AccountId: TypeInfo + Encode + Decode> {
-    netuid: Compact<u16>,
+    netuid: Compact<NetUid>,
     owner_hotkey: AccountId,
     owner_coldkey: AccountId,
     subnet_name: Vec<Compact<u8>>,
@@ -32,7 +33,7 @@ pub struct DynamicInfo<AccountId: TypeInfo + Encode + Decode> {
 }
 
 impl<T: Config> Pallet<T> {
-    pub fn get_dynamic_info(netuid: u16) -> Option<DynamicInfo<T::AccountId>> {
+    pub fn get_dynamic_info(netuid: NetUid) -> Option<DynamicInfo<T::AccountId>> {
         if !Self::if_subnet_exist(netuid) {
             return None;
         }
@@ -70,7 +71,7 @@ impl<T: Config> Pallet<T> {
         })
     }
     pub fn get_all_dynamic_info() -> Vec<Option<DynamicInfo<T::AccountId>>> {
-        let netuids: Vec<u16> = Self::get_all_subnet_netuids();
+        let netuids = Self::get_all_subnet_netuids();
         let mut dynamic_info = Vec::<Option<DynamicInfo<T::AccountId>>>::new();
         for netuid in netuids.clone().iter() {
             dynamic_info.push(Self::get_dynamic_info(*netuid));
diff --git a/pallets/subtensor/src/rpc_info/metagraph.rs b/pallets/subtensor/src/rpc_info/metagraph.rs
index 04325fef4d..48455c4436 100644
--- a/pallets/subtensor/src/rpc_info/metagraph.rs
+++ b/pallets/subtensor/src/rpc_info/metagraph.rs
@@ -6,12 +6,13 @@ use frame_support::pallet_prelude::{Decode, Encode};
 use substrate_fixed::types::I64F64;
 use substrate_fixed::types::I96F32;
 use subtensor_macros::freeze_struct;
+use subtensor_runtime_common::NetUid;
 
-#[freeze_struct("cb3ff125c0c35c9e")]
+#[freeze_struct("ea9ff0b8daeaa5ed")]
 #[derive(Decode, Encode, PartialEq, Eq, Clone, Debug, TypeInfo)]
 pub struct Metagraph<AccountId: TypeInfo + Encode + Decode> {
     // Subnet index
-    netuid: Compact<u16>,
+    netuid: Compact<NetUid>,
 
     // Name and symbol
     name: Vec<Compact<u8>>,              // name
@@ -107,11 +108,11 @@ pub struct Metagraph<AccountId: TypeInfo + Encode + Decode> {
     alpha_dividends_per_hotkey: Vec<(AccountId, Compact<u64>)>, // List of dividend payout in alpha via subnet.
 }
 
-#[freeze_struct("182c7375fee9db7b")]
+#[freeze_struct("5f0b0167abaff1b9")]
 #[derive(Decode, Encode, PartialEq, Eq, Clone, Debug, TypeInfo)]
 pub struct SelectiveMetagraph<AccountId: TypeInfo + Encode + Decode + Clone> {
     // Subnet index
-    netuid: Compact<u16>,
+    netuid: Compact<NetUid>,
 
     // Name and symbol
     name: Option<Vec<Compact<u8>>>,              // name
@@ -373,7 +374,7 @@ where
 {
     fn default() -> Self {
         Self {
-            netuid: 0.into(),
+            netuid: NetUid::ROOT.into(),
             name: None,
             symbol: None,
             identity: None,
@@ -604,7 +605,7 @@ impl SelectiveMetagraphIndex {
     }
 }
 impl<T: Config> Pallet<T> {
-    pub fn get_metagraph(netuid: u16) -> Option<Metagraph<T::AccountId>> {
+    pub fn get_metagraph(netuid: NetUid) -> Option<Metagraph<T::AccountId>> {
         if !Self::if_subnet_exist(netuid) {
             return None;
         }
@@ -780,7 +781,7 @@ impl<T: Config> Pallet<T> {
         })
     }
     pub fn get_all_metagraphs() -> Vec<Option<Metagraph<T::AccountId>>> {
-        let netuids: Vec<u16> = Self::get_all_subnet_netuids();
+        let netuids = Self::get_all_subnet_netuids();
         let mut metagraphs = Vec::<Option<Metagraph<T::AccountId>>>::new();
         for netuid in netuids.clone().iter() {
             metagraphs.push(Self::get_metagraph(*netuid));
@@ -789,7 +790,7 @@ impl<T: Config> Pallet<T> {
     }
 
     pub fn get_selective_metagraph(
-        netuid: u16,
+        netuid: NetUid,
         metagraph_indexes: Vec<u16>,
     ) -> Option<SelectiveMetagraph<T::AccountId>> {
         if !Self::if_subnet_exist(netuid) {
@@ -805,7 +806,7 @@ impl<T: Config> Pallet<T> {
     }
 
     fn get_single_selective_metagraph(
-        netuid: u16,
+        netuid: NetUid,
         metagraph_index: u16,
     ) -> SelectiveMetagraph<T::AccountId> {
         match SelectiveMetagraphIndex::from_index(metagraph_index as usize) {
diff --git a/pallets/subtensor/src/rpc_info/neuron_info.rs b/pallets/subtensor/src/rpc_info/neuron_info.rs
index 4838b376f9..337b89212d 100644
--- a/pallets/subtensor/src/rpc_info/neuron_info.rs
+++ b/pallets/subtensor/src/rpc_info/neuron_info.rs
@@ -2,14 +2,15 @@ use super::*;
 use frame_support::pallet_prelude::{Decode, Encode};
 extern crate alloc;
 use codec::Compact;
+use subtensor_runtime_common::NetUid;
 
-#[freeze_struct("d6da7340b3350951")]
+#[freeze_struct("3bddc0abfa5445a6")]
 #[derive(Decode, Encode, PartialEq, Eq, Clone, Debug, TypeInfo)]
 pub struct NeuronInfo<AccountId: TypeInfo + Encode + Decode> {
     hotkey: AccountId,
     coldkey: AccountId,
     uid: Compact<u16>,
-    netuid: Compact<u16>,
+    netuid: Compact<NetUid>,
     active: bool,
     axon_info: AxonInfo,
     prometheus_info: PrometheusInfo,
@@ -28,13 +29,13 @@ pub struct NeuronInfo<AccountId: TypeInfo + Encode + Decode> {
     pruning_score: Compact<u16>,
 }
 
-#[freeze_struct("3e9eed057f379b3b")]
+#[freeze_struct("e2a6a95696a82c4f")]
 #[derive(Decode, Encode, PartialEq, Eq, Clone, Debug, TypeInfo)]
 pub struct NeuronInfoLite<AccountId: TypeInfo + Encode + Decode> {
     hotkey: AccountId,
     coldkey: AccountId,
     uid: Compact<u16>,
-    netuid: Compact<u16>,
+    netuid: Compact<NetUid>,
     active: bool,
     axon_info: AxonInfo,
     prometheus_info: PrometheusInfo,
@@ -53,7 +54,7 @@ pub struct NeuronInfoLite<AccountId: TypeInfo + Encode + Decode> {
 }
 
 impl<T: Config> Pallet<T> {
-    pub fn get_neurons(netuid: u16) -> Vec<NeuronInfo<T::AccountId>> {
+    pub fn get_neurons(netuid: NetUid) -> Vec<NeuronInfo<T::AccountId>> {
         if !Self::if_subnet_exist(netuid) {
             return Vec::new();
         }
@@ -71,7 +72,7 @@ impl<T: Config> Pallet<T> {
         neurons
     }
 
-    fn get_neuron_subnet_exists(netuid: u16, uid: u16) -> Option<NeuronInfo<T::AccountId>> {
+    fn get_neuron_subnet_exists(netuid: NetUid, uid: u16) -> Option<NeuronInfo<T::AccountId>> {
         let hotkey = match Self::get_hotkey_for_net_and_uid(netuid, uid) {
             Ok(h) => h,
             Err(_) => return None,
@@ -95,10 +96,10 @@ impl<T: Config> Pallet<T> {
         let last_update = Self::get_last_update_for_uid(netuid, uid);
         let validator_permit = Self::get_validator_permit_for_uid(netuid, uid);
 
-        let weights = <Weights<T>>::get(netuid, uid)
-            .iter()
+        let weights = Weights::<T>::get(netuid, uid)
+            .into_iter()
             .filter_map(|(i, w)| {
-                if *w > 0 {
+                if w > 0 {
                     Some((i.into(), w.into()))
                 } else {
                     None
@@ -146,7 +147,7 @@ impl<T: Config> Pallet<T> {
         Some(neuron)
     }
 
-    pub fn get_neuron(netuid: u16, uid: u16) -> Option<NeuronInfo<T::AccountId>> {
+    pub fn get_neuron(netuid: NetUid, uid: u16) -> Option<NeuronInfo<T::AccountId>> {
         if !Self::if_subnet_exist(netuid) {
             return None;
         }
@@ -155,7 +156,7 @@ impl<T: Config> Pallet<T> {
     }
 
     fn get_neuron_lite_subnet_exists(
-        netuid: u16,
+        netuid: NetUid,
         uid: u16,
     ) -> Option<NeuronInfoLite<T::AccountId>> {
         let hotkey = match Self::get_hotkey_for_net_and_uid(netuid, uid) {
@@ -210,7 +211,7 @@ impl<T: Config> Pallet<T> {
         Some(neuron)
     }
 
-    pub fn get_neurons_lite(netuid: u16) -> Vec<NeuronInfoLite<T::AccountId>> {
+    pub fn get_neurons_lite(netuid: NetUid) -> Vec<NeuronInfoLite<T::AccountId>> {
         if !Self::if_subnet_exist(netuid) {
             return Vec::new();
         }
@@ -228,7 +229,7 @@ impl<T: Config> Pallet<T> {
         neurons
     }
 
-    pub fn get_neuron_lite(netuid: u16, uid: u16) -> Option<NeuronInfoLite<T::AccountId>> {
+    pub fn get_neuron_lite(netuid: NetUid, uid: u16) -> Option<NeuronInfoLite<T::AccountId>> {
         if !Self::if_subnet_exist(netuid) {
             return None;
         }
diff --git a/pallets/subtensor/src/rpc_info/show_subnet.rs b/pallets/subtensor/src/rpc_info/show_subnet.rs
index 9b66439fa2..aa5b2f4d36 100644
--- a/pallets/subtensor/src/rpc_info/show_subnet.rs
+++ b/pallets/subtensor/src/rpc_info/show_subnet.rs
@@ -4,11 +4,12 @@ use crate::epoch::math::*;
 use codec::Compact;
 use frame_support::pallet_prelude::{Decode, Encode};
 use substrate_fixed::types::I64F64;
+use subtensor_runtime_common::NetUid;
 
-#[freeze_struct("7954f39fd0755b28")]
+#[freeze_struct("11f58860434dd863")]
 #[derive(Decode, Encode, PartialEq, Eq, Clone, Debug, TypeInfo)]
 pub struct SubnetState<AccountId: TypeInfo + Encode + Decode> {
-    netuid: Compact<u16>,
+    netuid: Compact<NetUid>,
     hotkeys: Vec<AccountId>,
     coldkeys: Vec<AccountId>,
     active: Vec<bool>,
@@ -79,7 +80,7 @@ impl<T: Config> Pallet<T> {
     ///
     /// * `Option<SubnetState<T::AccountId>>` - An optional `SubnetState` struct containing the collected data for the subnet.
     ///   Returns `None` if the subnet does not exist.
-    pub fn get_subnet_state(netuid: u16) -> Option<SubnetState<T::AccountId>> {
+    pub fn get_subnet_state(netuid: NetUid) -> Option<SubnetState<T::AccountId>> {
         if !Self::if_subnet_exist(netuid) {
             return None;
         }
diff --git a/pallets/subtensor/src/rpc_info/stake_info.rs b/pallets/subtensor/src/rpc_info/stake_info.rs
index 8a3888061f..56a0a066cb 100644
--- a/pallets/subtensor/src/rpc_info/stake_info.rs
+++ b/pallets/subtensor/src/rpc_info/stake_info.rs
@@ -3,13 +3,14 @@ use frame_support::pallet_prelude::{Decode, Encode};
 extern crate alloc;
 use codec::Compact;
 use substrate_fixed::types::U96F32;
+use subtensor_runtime_common::NetUid;
 
-#[freeze_struct("5cfb3c84c3af3116")]
+#[freeze_struct("56f5e9f33e5ec9da")]
 #[derive(Decode, Encode, PartialEq, Eq, Clone, Debug, TypeInfo)]
 pub struct StakeInfo<AccountId: TypeInfo + Encode + Decode> {
     hotkey: AccountId,
     coldkey: AccountId,
-    netuid: Compact<u16>,
+    netuid: Compact<NetUid>,
     stake: Compact<u64>,
     locked: Compact<u64>,
     emission: Compact<u64>,
@@ -25,7 +26,7 @@ impl<T: Config> Pallet<T> {
         if coldkeys.is_empty() {
             return Vec::new(); // No coldkeys to check
         }
-        let netuids: Vec<u16> = Self::get_all_subnet_netuids();
+        let netuids = Self::get_all_subnet_netuids();
         let mut stake_info: Vec<(T::AccountId, Vec<StakeInfo<T::AccountId>>)> = Vec::new();
         for coldkey_i in coldkeys.clone().iter() {
             // Get all hotkeys associated with this coldkey.
@@ -90,7 +91,7 @@ impl<T: Config> Pallet<T> {
     pub fn get_stake_info_for_hotkey_coldkey_netuid(
         hotkey_account: T::AccountId,
         coldkey_account: T::AccountId,
-        netuid: u16,
+        netuid: NetUid,
     ) -> Option<StakeInfo<T::AccountId>> {
         let alpha: u64 = Self::get_stake_for_hotkey_and_coldkey_on_subnet(
             &hotkey_account,
@@ -115,18 +116,17 @@ impl<T: Config> Pallet<T> {
     }
 
     pub fn get_stake_fee(
-        origin: Option<(T::AccountId, u16)>,
+        origin: Option<(T::AccountId, NetUid)>,
         origin_coldkey_account: T::AccountId,
-        destination: Option<(T::AccountId, u16)>,
+        destination: Option<(T::AccountId, NetUid)>,
         destination_coldkey_account: T::AccountId,
         amount: u64,
     ) -> u64 {
-        let origin_: Option<(&T::AccountId, u16)> =
-            if let Some((ref origin_hotkey, origin_netuid)) = origin {
-                Some((origin_hotkey, origin_netuid))
-            } else {
-                None
-            };
+        let origin_ = if let Some((ref origin_hotkey, origin_netuid)) = origin {
+            Some((origin_hotkey, origin_netuid))
+        } else {
+            None
+        };
 
         let destination_ = if let Some((ref destination_hotkey, destination_netuid)) = destination {
             Some((destination_hotkey, destination_netuid))
diff --git a/pallets/subtensor/src/rpc_info/subnet_info.rs b/pallets/subtensor/src/rpc_info/subnet_info.rs
index 6e9e722295..636b72899b 100644
--- a/pallets/subtensor/src/rpc_info/subnet_info.rs
+++ b/pallets/subtensor/src/rpc_info/subnet_info.rs
@@ -3,11 +3,12 @@ use frame_support::pallet_prelude::{Decode, Encode};
 use frame_support::storage::IterableStorageMap;
 extern crate alloc;
 use codec::Compact;
+use subtensor_runtime_common::NetUid;
 
-#[freeze_struct("1eee6f3911800c6b")]
+#[freeze_struct("dd2293544ffd8f2e")]
 #[derive(Decode, Encode, PartialEq, Eq, Clone, Debug, TypeInfo)]
 pub struct SubnetInfo<AccountId: TypeInfo + Encode + Decode> {
-    netuid: Compact<u16>,
+    netuid: Compact<NetUid>,
     rho: Compact<u16>,
     kappa: Compact<u16>,
     difficulty: Compact<u64>,
@@ -27,10 +28,10 @@ pub struct SubnetInfo<AccountId: TypeInfo + Encode + Decode> {
     owner: AccountId,
 }
 
-#[freeze_struct("a86ee623525247cc")]
+#[freeze_struct("42d9a1f1761c3b31")]
 #[derive(Decode, Encode, PartialEq, Eq, Clone, Debug, TypeInfo)]
 pub struct SubnetInfov2<AccountId: TypeInfo + Encode + Decode> {
-    netuid: Compact<u16>,
+    netuid: Compact<NetUid>,
     rho: Compact<u16>,
     kappa: Compact<u16>,
     difficulty: Compact<u64>,
@@ -84,7 +85,7 @@ pub struct SubnetHyperparams {
 }
 
 impl<T: Config> Pallet<T> {
-    pub fn get_subnet_info(netuid: u16) -> Option<SubnetInfo<T::AccountId>> {
+    pub fn get_subnet_info(netuid: NetUid) -> Option<SubnetInfo<T::AccountId>> {
         if !Self::if_subnet_exist(netuid) {
             return None;
         }
@@ -132,28 +133,28 @@ impl<T: Config> Pallet<T> {
     }
 
     pub fn get_subnets_info() -> Vec<Option<SubnetInfo<T::AccountId>>> {
-        let mut subnet_netuids = Vec::<u16>::new();
+        let mut subnet_netuids = Vec::<NetUid>::new();
         let mut max_netuid: u16 = 0;
-        for (netuid, added) in <NetworksAdded<T> as IterableStorageMap<u16, bool>>::iter() {
+        for (netuid, added) in <NetworksAdded<T> as IterableStorageMap<NetUid, bool>>::iter() {
             if added {
                 subnet_netuids.push(netuid);
-                if netuid > max_netuid {
-                    max_netuid = netuid;
+                if u16::from(netuid) > max_netuid {
+                    max_netuid = u16::from(netuid);
                 }
             }
         }
 
         let mut subnets_info = Vec::<Option<SubnetInfo<T::AccountId>>>::new();
         for netuid_ in 0..=max_netuid {
-            if subnet_netuids.contains(&netuid_) {
-                subnets_info.push(Self::get_subnet_info(netuid_));
+            if subnet_netuids.contains(&netuid_.into()) {
+                subnets_info.push(Self::get_subnet_info(netuid_.into()));
             }
         }
 
         subnets_info
     }
 
-    pub fn get_subnet_info_v2(netuid: u16) -> Option<SubnetInfov2<T::AccountId>> {
+    pub fn get_subnet_info_v2(netuid: NetUid) -> Option<SubnetInfov2<T::AccountId>> {
         if !Self::if_subnet_exist(netuid) {
             return None;
         }
@@ -204,28 +205,28 @@ impl<T: Config> Pallet<T> {
     }
 
     pub fn get_subnets_info_v2() -> Vec<Option<SubnetInfov2<T::AccountId>>> {
-        let mut subnet_netuids = Vec::<u16>::new();
+        let mut subnet_netuids = Vec::<NetUid>::new();
         let mut max_netuid: u16 = 0;
-        for (netuid, added) in <NetworksAdded<T> as IterableStorageMap<u16, bool>>::iter() {
+        for (netuid, added) in <NetworksAdded<T> as IterableStorageMap<NetUid, bool>>::iter() {
             if added {
                 subnet_netuids.push(netuid);
-                if netuid > max_netuid {
-                    max_netuid = netuid;
+                if u16::from(netuid) > max_netuid {
+                    max_netuid = u16::from(netuid);
                 }
             }
         }
 
         let mut subnets_info = Vec::<Option<SubnetInfov2<T::AccountId>>>::new();
         for netuid_ in 0..=max_netuid {
-            if subnet_netuids.contains(&netuid_) {
-                subnets_info.push(Self::get_subnet_info_v2(netuid_));
+            if subnet_netuids.contains(&netuid_.into()) {
+                subnets_info.push(Self::get_subnet_info_v2(netuid_.into()));
             }
         }
 
         subnets_info
     }
 
-    pub fn get_subnet_hyperparams(netuid: u16) -> Option<SubnetHyperparams> {
+    pub fn get_subnet_hyperparams(netuid: NetUid) -> Option<SubnetHyperparams> {
         if !Self::if_subnet_exist(netuid) {
             return None;
         }
diff --git a/pallets/subtensor/src/staking/add_stake.rs b/pallets/subtensor/src/staking/add_stake.rs
index 8886806cd9..291cf4ca4e 100644
--- a/pallets/subtensor/src/staking/add_stake.rs
+++ b/pallets/subtensor/src/staking/add_stake.rs
@@ -1,5 +1,6 @@
 use super::*;
 use substrate_fixed::types::I96F32;
+use subtensor_runtime_common::NetUid;
 
 impl<T: Config> Pallet<T> {
     /// ---- The implementation for the extrinsic add_stake: Adds stake to a hotkey account.
@@ -37,7 +38,7 @@ impl<T: Config> Pallet<T> {
     pub fn do_add_stake(
         origin: T::RuntimeOrigin,
         hotkey: T::AccountId,
-        netuid: u16,
+        netuid: NetUid,
         stake_to_be_added: u64,
     ) -> dispatch::DispatchResult {
         // 1. We check that the transaction is signed by the caller and retrieve the T::AccountId coldkey information.
@@ -116,7 +117,7 @@ impl<T: Config> Pallet<T> {
     pub fn do_add_stake_aggregate(
         origin: T::RuntimeOrigin,
         hotkey: T::AccountId,
-        netuid: u16,
+        netuid: NetUid,
         stake_to_be_added: u64,
     ) -> dispatch::DispatchResult {
         // We check that the transaction is signed by the caller and retrieve the T::AccountId coldkey information.
@@ -193,7 +194,7 @@ impl<T: Config> Pallet<T> {
     pub fn do_add_stake_limit_aggregate(
         origin: T::RuntimeOrigin,
         hotkey: T::AccountId,
-        netuid: u16,
+        netuid: NetUid,
         stake_to_be_added: u64,
         limit_price: u64,
         allow_partial: bool,
@@ -272,7 +273,7 @@ impl<T: Config> Pallet<T> {
     pub fn do_add_stake_limit(
         origin: T::RuntimeOrigin,
         hotkey: T::AccountId,
-        netuid: u16,
+        netuid: NetUid,
         stake_to_be_added: u64,
         limit_price: u64,
         allow_partial: bool,
@@ -329,11 +330,11 @@ impl<T: Config> Pallet<T> {
     }
 
     // Returns the maximum amount of RAO that can be executed with price limit
-    pub fn get_max_amount_add(netuid: u16, limit_price: u64) -> Result<u64, Error<T>> {
+    pub fn get_max_amount_add(netuid: NetUid, limit_price: u64) -> Result<u64, Error<T>> {
         // Corner case: root and stao
         // There's no slippage for root or stable subnets, so if limit price is 1e9 rao or
         // higher, then max_amount equals u64::MAX, otherwise it is 0.
-        if (netuid == Self::get_root_netuid()) || (SubnetMechanism::<T>::get(netuid)) == 0 {
+        if netuid.is_root() || SubnetMechanism::<T>::get(netuid) == 0 {
             if limit_price >= 1_000_000_000 {
                 return Ok(u64::MAX);
             } else {
diff --git a/pallets/subtensor/src/staking/helpers.rs b/pallets/subtensor/src/staking/helpers.rs
index 9ee04f36a8..aacc448952 100644
--- a/pallets/subtensor/src/staking/helpers.rs
+++ b/pallets/subtensor/src/staking/helpers.rs
@@ -1,6 +1,7 @@
 use super::*;
 use safe_math::*;
 use substrate_fixed::types::U96F32;
+use subtensor_runtime_common::NetUid;
 
 use frame_support::traits::{
     Imbalance,
@@ -165,7 +166,7 @@ impl<T: Config> Pallet<T> {
     pub fn clear_small_nomination_if_required(
         hotkey: &T::AccountId,
         coldkey: &T::AccountId,
-        netuid: u16,
+        netuid: NetUid,
     ) {
         // Verify if the account is a nominator account by checking ownership of the hotkey by the coldkey.
         if !Self::coldkey_owns_hotkey(coldkey, hotkey) {
diff --git a/pallets/subtensor/src/staking/move_stake.rs b/pallets/subtensor/src/staking/move_stake.rs
index ef576f3607..a32996321b 100644
--- a/pallets/subtensor/src/staking/move_stake.rs
+++ b/pallets/subtensor/src/staking/move_stake.rs
@@ -2,6 +2,7 @@ use super::*;
 use safe_math::*;
 use sp_core::Get;
 use substrate_fixed::types::{U64F64, U96F32};
+use subtensor_runtime_common::NetUid;
 
 impl<T: Config> Pallet<T> {
     /// Moves stake from one hotkey to another across subnets.
@@ -29,8 +30,8 @@ impl<T: Config> Pallet<T> {
         origin: T::RuntimeOrigin,
         origin_hotkey: T::AccountId,
         destination_hotkey: T::AccountId,
-        origin_netuid: u16,
-        destination_netuid: u16,
+        origin_netuid: NetUid,
+        destination_netuid: NetUid,
         alpha_amount: u64,
     ) -> dispatch::DispatchResult {
         // Check that the origin is signed by the origin_hotkey.
@@ -97,7 +98,7 @@ impl<T: Config> Pallet<T> {
     ///
     /// # Events
     /// Emits a `StakeTransferred` event upon successful completion of the transfer.
-    pub fn toggle_transfer(netuid: u16, toggle: bool) -> dispatch::DispatchResult {
+    pub fn toggle_transfer(netuid: NetUid, toggle: bool) -> dispatch::DispatchResult {
         TransferToggle::<T>::insert(netuid, toggle);
         log::debug!(
             "TransferToggle( netuid: {:?}, toggle: {:?} ) ",
@@ -111,8 +112,8 @@ impl<T: Config> Pallet<T> {
         origin: T::RuntimeOrigin,
         destination_coldkey: T::AccountId,
         hotkey: T::AccountId,
-        origin_netuid: u16,
-        destination_netuid: u16,
+        origin_netuid: NetUid,
+        destination_netuid: NetUid,
         alpha_amount: u64,
     ) -> dispatch::DispatchResult {
         // Ensure the extrinsic is signed by the origin_coldkey.
@@ -181,8 +182,8 @@ impl<T: Config> Pallet<T> {
     pub fn do_swap_stake(
         origin: T::RuntimeOrigin,
         hotkey: T::AccountId,
-        origin_netuid: u16,
-        destination_netuid: u16,
+        origin_netuid: NetUid,
+        destination_netuid: NetUid,
         alpha_amount: u64,
     ) -> dispatch::DispatchResult {
         // Ensure the extrinsic is signed by the coldkey.
@@ -251,8 +252,8 @@ impl<T: Config> Pallet<T> {
     pub fn do_swap_stake_limit(
         origin: T::RuntimeOrigin,
         hotkey: T::AccountId,
-        origin_netuid: u16,
-        destination_netuid: u16,
+        origin_netuid: NetUid,
+        destination_netuid: NetUid,
         alpha_amount: u64,
         limit_price: u64,
         allow_partial: bool,
@@ -302,8 +303,8 @@ impl<T: Config> Pallet<T> {
         destination_coldkey: &T::AccountId,
         origin_hotkey: &T::AccountId,
         destination_hotkey: &T::AccountId,
-        origin_netuid: u16,
-        destination_netuid: u16,
+        origin_netuid: NetUid,
+        destination_netuid: NetUid,
         alpha_amount: u64,
         maybe_limit_price: Option<u64>,
         maybe_allow_partial: Option<bool>,
@@ -398,8 +399,8 @@ impl<T: Config> Pallet<T> {
     /// In the corner case when SubnetTAO(2) == SubnetTAO(1), no slippage is going to occur.
     ///
     pub fn get_max_amount_move(
-        origin_netuid: u16,
-        destination_netuid: u16,
+        origin_netuid: NetUid,
+        destination_netuid: NetUid,
         limit_price: u64,
     ) -> Result<u64, Error<T>> {
         let tao: U64F64 = U64F64::saturating_from_num(1_000_000_000);
@@ -407,10 +408,8 @@ impl<T: Config> Pallet<T> {
         // Corner case: both subnet IDs are root or stao
         // There's no slippage for root or stable subnets, so slippage is always 0.
         // The price always stays at 1.0, return 0 if price is expected to raise.
-        if ((origin_netuid == Self::get_root_netuid())
-            || (SubnetMechanism::<T>::get(origin_netuid)) == 0)
-            && ((destination_netuid == Self::get_root_netuid())
-                || (SubnetMechanism::<T>::get(destination_netuid)) == 0)
+        if (origin_netuid.is_root() || SubnetMechanism::<T>::get(origin_netuid) == 0)
+            && (destination_netuid.is_root() || SubnetMechanism::<T>::get(destination_netuid) == 0)
         {
             if limit_price > tao.saturating_to_num::<u64>() {
                 return Err(Error::ZeroMaxStakeAmount);
@@ -421,9 +420,8 @@ impl<T: Config> Pallet<T> {
 
         // Corner case: Origin is root or stable, destination is dynamic
         // Same as adding stake with limit price
-        if ((origin_netuid == Self::get_root_netuid())
-            || (SubnetMechanism::<T>::get(origin_netuid)) == 0)
-            && ((SubnetMechanism::<T>::get(destination_netuid)) == 1)
+        if (origin_netuid.is_root() || SubnetMechanism::<T>::get(origin_netuid) == 0)
+            && (SubnetMechanism::<T>::get(destination_netuid) == 1)
         {
             if limit_price == 0 {
                 return Ok(u64::MAX);
@@ -439,9 +437,8 @@ impl<T: Config> Pallet<T> {
 
         // Corner case: Origin is dynamic, destination is root or stable
         // Same as removing stake with limit price
-        if ((destination_netuid == Self::get_root_netuid())
-            || (SubnetMechanism::<T>::get(destination_netuid)) == 0)
-            && ((SubnetMechanism::<T>::get(origin_netuid)) == 1)
+        if (destination_netuid.is_root() || SubnetMechanism::<T>::get(destination_netuid) == 0)
+            && (SubnetMechanism::<T>::get(origin_netuid) == 1)
         {
             return Self::get_max_amount_remove(origin_netuid, limit_price);
         }
diff --git a/pallets/subtensor/src/staking/recycle_alpha.rs b/pallets/subtensor/src/staking/recycle_alpha.rs
index ef3cea2b29..5bb9f2da1c 100644
--- a/pallets/subtensor/src/staking/recycle_alpha.rs
+++ b/pallets/subtensor/src/staking/recycle_alpha.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::{Error, system::ensure_signed};
+use subtensor_runtime_common::NetUid;
 
 impl<T: Config> Pallet<T> {
     /// Recycles alpha from a cold/hot key pair, reducing AlphaOut on a subnet
@@ -18,7 +19,7 @@ impl<T: Config> Pallet<T> {
         origin: T::RuntimeOrigin,
         hotkey: T::AccountId,
         amount: u64,
-        netuid: u16,
+        netuid: NetUid,
     ) -> DispatchResult {
         let coldkey: T::AccountId = ensure_signed(origin)?;
 
@@ -28,7 +29,7 @@ impl<T: Config> Pallet<T> {
         );
 
         ensure!(
-            netuid != Self::get_root_netuid(),
+            !netuid.is_root(),
             Error::<T>::CannotBurnOrRecycleOnRootSubnet
         );
 
@@ -87,7 +88,7 @@ impl<T: Config> Pallet<T> {
         origin: T::RuntimeOrigin,
         hotkey: T::AccountId,
         amount: u64,
-        netuid: u16,
+        netuid: NetUid,
     ) -> DispatchResult {
         let coldkey = ensure_signed(origin)?;
 
@@ -97,7 +98,7 @@ impl<T: Config> Pallet<T> {
         );
 
         ensure!(
-            netuid != Self::get_root_netuid(),
+            !netuid.is_root(),
             Error::<T>::CannotBurnOrRecycleOnRootSubnet
         );
 
diff --git a/pallets/subtensor/src/staking/remove_stake.rs b/pallets/subtensor/src/staking/remove_stake.rs
index 378ea8001b..8da82527f1 100644
--- a/pallets/subtensor/src/staking/remove_stake.rs
+++ b/pallets/subtensor/src/staking/remove_stake.rs
@@ -1,5 +1,6 @@
 use super::*;
 use substrate_fixed::types::U96F32;
+use subtensor_runtime_common::NetUid;
 
 impl<T: Config> Pallet<T> {
     /// ---- The implementation for the extrinsic remove_stake: Removes stake from a hotkey account and adds it onto a coldkey.
@@ -37,7 +38,7 @@ impl<T: Config> Pallet<T> {
     pub fn do_remove_stake(
         origin: T::RuntimeOrigin,
         hotkey: T::AccountId,
-        netuid: u16,
+        netuid: NetUid,
         alpha_unstaked: u64,
     ) -> dispatch::DispatchResult {
         // 1. We check the transaction is signed by the caller and retrieve the T::AccountId coldkey information.
@@ -125,7 +126,7 @@ impl<T: Config> Pallet<T> {
     pub fn do_remove_stake_aggregate(
         origin: T::RuntimeOrigin,
         hotkey: T::AccountId,
-        netuid: u16,
+        netuid: NetUid,
         alpha_unstaked: u64,
     ) -> dispatch::DispatchResult {
         // We check the transaction is signed by the caller and retrieve the T::AccountId coldkey information.
@@ -199,7 +200,7 @@ impl<T: Config> Pallet<T> {
         );
 
         // 3. Get all netuids.
-        let netuids: Vec<u16> = Self::get_all_subnet_netuids();
+        let netuids = Self::get_all_subnet_netuids();
         log::debug!("All subnet netuids: {:?}", netuids);
 
         // 4. Iterate through all subnets and remove stake.
@@ -326,7 +327,7 @@ impl<T: Config> Pallet<T> {
         );
 
         // 3. Get all netuids.
-        let netuids: Vec<u16> = Self::get_all_subnet_netuids();
+        let netuids = Self::get_all_subnet_netuids();
         log::debug!("All subnet netuids: {:?}", netuids);
 
         // 4. Iterate through all subnets and remove stake.
@@ -336,7 +337,7 @@ impl<T: Config> Pallet<T> {
                 continue;
             }
             // If not Root network.
-            if netuid != Self::get_root_netuid() {
+            if !netuid.is_root() {
                 // Ensure that the hotkey has enough stake to withdraw.
                 let alpha_unstaked =
                     Self::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid);
@@ -381,7 +382,7 @@ impl<T: Config> Pallet<T> {
         Self::stake_into_subnet(
             &hotkey,
             &coldkey,
-            Self::get_root_netuid(),
+            NetUid::ROOT,
             total_tao_unstaked,
             0, // no fee for restaking
         );
@@ -469,7 +470,7 @@ impl<T: Config> Pallet<T> {
     pub fn do_remove_stake_limit(
         origin: T::RuntimeOrigin,
         hotkey: T::AccountId,
-        netuid: u16,
+        netuid: NetUid,
         alpha_unstaked: u64,
         limit_price: u64,
         allow_partial: bool,
@@ -575,7 +576,7 @@ impl<T: Config> Pallet<T> {
     pub fn do_remove_stake_limit_aggregate(
         origin: T::RuntimeOrigin,
         hotkey: T::AccountId,
-        netuid: u16,
+        netuid: NetUid,
         alpha_unstaked: u64,
         limit_price: u64,
         allow_partial: bool,
@@ -614,11 +615,11 @@ impl<T: Config> Pallet<T> {
     }
 
     // Returns the maximum amount of RAO that can be executed with price limit
-    pub fn get_max_amount_remove(netuid: u16, limit_price: u64) -> Result<u64, Error<T>> {
+    pub fn get_max_amount_remove(netuid: NetUid, limit_price: u64) -> Result<u64, Error<T>> {
         // Corner case: root and stao
         // There's no slippage for root or stable subnets, so if limit price is 1e9 rao or
         // lower, then max_amount equals u64::MAX, otherwise it is 0.
-        if (netuid == Self::get_root_netuid()) || (SubnetMechanism::<T>::get(netuid)) == 0 {
+        if netuid.is_root() || SubnetMechanism::<T>::get(netuid) == 0 {
             if limit_price <= 1_000_000_000 {
                 return Ok(u64::MAX);
             } else {
diff --git a/pallets/subtensor/src/staking/set_children.rs b/pallets/subtensor/src/staking/set_children.rs
index 2d2ebaec47..dc2da75785 100644
--- a/pallets/subtensor/src/staking/set_children.rs
+++ b/pallets/subtensor/src/staking/set_children.rs
@@ -1,5 +1,6 @@
 use super::*;
 use sp_core::Get;
+use subtensor_runtime_common::NetUid;
 
 impl<T: Config> Pallet<T> {
     /// ---- The implementation for the extrinsic do_set_child_singular: Sets a single child.
@@ -36,7 +37,7 @@ impl<T: Config> Pallet<T> {
     pub fn do_schedule_children(
         origin: T::RuntimeOrigin,
         hotkey: T::AccountId,
-        netuid: u16,
+        netuid: NetUid,
         children: Vec<(u64, T::AccountId)>,
     ) -> DispatchResult {
         // Check that the caller has signed the transaction. (the coldkey of the pairing)
@@ -61,7 +62,7 @@ impl<T: Config> Pallet<T> {
 
         // Check that this delegation is not on the root network. Child hotkeys are not valid on root.
         ensure!(
-            netuid != Self::get_root_netuid(),
+            !netuid.is_root(),
             Error::<T>::RegistrationNotPermittedOnRootSubnet
         );
 
@@ -170,7 +171,7 @@ impl<T: Config> Pallet<T> {
     /// 1. **Old Children Cleanup**: Removes the hotkey from the parent list of its old children.
     /// 2. **New Children Assignment**: Assigns the new child to the hotkey and updates the parent list for the new child.
     ///
-    pub fn do_set_pending_children(netuid: u16) {
+    pub fn do_set_pending_children(netuid: NetUid) {
         let current_block = Self::get_current_block_as_u64();
 
         // Iterate over all pending children of this subnet and set as needed
@@ -251,7 +252,7 @@ impl<T: Config> Pallet<T> {
     /// ```
     /// let children = SubtensorModule::get_children(&hotkey, netuid);
      */
-    pub fn get_children(hotkey: &T::AccountId, netuid: u16) -> Vec<(u64, T::AccountId)> {
+    pub fn get_children(hotkey: &T::AccountId, netuid: NetUid) -> Vec<(u64, T::AccountId)> {
         ChildKeys::<T>::get(hotkey, netuid)
     }
 
@@ -268,7 +269,7 @@ impl<T: Config> Pallet<T> {
     /// ```
     /// let parents = SubtensorModule::get_parents(&child, netuid);
      */
-    pub fn get_parents(child: &T::AccountId, netuid: u16) -> Vec<(u64, T::AccountId)> {
+    pub fn get_parents(child: &T::AccountId, netuid: NetUid) -> Vec<(u64, T::AccountId)> {
         ParentKeys::<T>::get(child, netuid)
     }
 
@@ -302,7 +303,7 @@ impl<T: Config> Pallet<T> {
     pub fn do_set_childkey_take(
         coldkey: T::AccountId,
         hotkey: T::AccountId,
-        netuid: u16,
+        netuid: NetUid,
         take: u16,
     ) -> DispatchResult {
         // Ensure the coldkey owns the hotkey
@@ -373,7 +374,7 @@ impl<T: Config> Pallet<T> {
     /// * `u16`
     ///     - The childkey take value. This is a percentage represented as a value between 0
     ///       and 10000, where 10000 represents 100%.
-    pub fn get_childkey_take(hotkey: &T::AccountId, netuid: u16) -> u16 {
+    pub fn get_childkey_take(hotkey: &T::AccountId, netuid: NetUid) -> u16 {
         ChildkeyTake::<T>::get(hotkey, netuid)
     }
 }
diff --git a/pallets/subtensor/src/staking/stake_utils.rs b/pallets/subtensor/src/staking/stake_utils.rs
index 058622177e..6d48389d02 100644
--- a/pallets/subtensor/src/staking/stake_utils.rs
+++ b/pallets/subtensor/src/staking/stake_utils.rs
@@ -5,6 +5,7 @@ use share_pool::{SharePool, SharePoolDataOperations};
 //use sp_runtime::Saturating;
 use sp_std::ops::Neg;
 use substrate_fixed::types::{I64F64, I96F32, U64F64, U96F32, U110F18};
+use subtensor_runtime_common::NetUid;
 
 impl<T: Config> Pallet<T> {
     /// Retrieves the total alpha issuance for a given subnet.
@@ -17,7 +18,7 @@ impl<T: Config> Pallet<T> {
     ///
     /// # Returns
     /// * `u64` - The total alpha issuance for the specified subnet.
-    pub fn get_alpha_issuance(netuid: u16) -> u64 {
+    pub fn get_alpha_issuance(netuid: NetUid) -> u64 {
         SubnetAlphaIn::<T>::get(netuid).saturating_add(SubnetAlphaOut::<T>::get(netuid))
     }
 
@@ -32,8 +33,8 @@ impl<T: Config> Pallet<T> {
     ///
     /// # Returns
     /// * `I96F32` - The price of alpha for the specified subnet.
-    pub fn get_alpha_price(netuid: u16) -> U96F32 {
-        if netuid == Self::get_root_netuid() {
+    pub fn get_alpha_price(netuid: NetUid) -> U96F32 {
+        if netuid.is_root() {
             return U96F32::saturating_from_num(1.0); // Root.
         }
         if SubnetMechanism::<T>::get(netuid) == 0 {
@@ -47,9 +48,9 @@ impl<T: Config> Pallet<T> {
                 .unwrap_or(U96F32::saturating_from_num(0))
         }
     }
-    pub fn get_moving_alpha_price(netuid: u16) -> U96F32 {
+    pub fn get_moving_alpha_price(netuid: NetUid) -> U96F32 {
         let one = U96F32::saturating_from_num(1.0);
-        if netuid == Self::get_root_netuid() {
+        if netuid.is_root() {
             // Root.
             one
         } else if SubnetMechanism::<T>::get(netuid) == 0 {
@@ -60,7 +61,7 @@ impl<T: Config> Pallet<T> {
         }
     }
 
-    pub fn update_moving_price(netuid: u16) {
+    pub fn update_moving_price(netuid: NetUid) {
         let blocks_since_start_call = U96F32::saturating_from_num({
             // We expect FirstEmissionBlockNumber to be set earlier, and we take the block when
             // `start_call` was called (first block before FirstEmissionBlockNumber).
@@ -146,7 +147,7 @@ impl<T: Config> Pallet<T> {
     ///
     pub fn get_stake_weights_for_hotkey_on_subnet(
         hotkey: &T::AccountId,
-        netuid: u16,
+        netuid: NetUid,
     ) -> (I64F64, I64F64, I64F64) {
         // Retrieve the global tao weight.
         let tao_weight = I64F64::saturating_from_num(Self::get_tao_weight());
@@ -172,7 +173,9 @@ impl<T: Config> Pallet<T> {
 
     /// Calculates the weighted combination of alpha and global tao for hotkeys on a subnet.
     ///
-    pub fn get_stake_weights_for_network(netuid: u16) -> (Vec<I64F64>, Vec<I64F64>, Vec<I64F64>) {
+    pub fn get_stake_weights_for_network(
+        netuid: NetUid,
+    ) -> (Vec<I64F64>, Vec<I64F64>, Vec<I64F64>) {
         // Retrieve the global tao weight.
         let tao_weight: I64F64 = I64F64::saturating_from_num(Self::get_tao_weight());
         log::debug!("tao_weight: {:?}", tao_weight);
@@ -250,10 +253,9 @@ impl<T: Config> Pallet<T> {
     ///
     /// # Note
     /// This function uses saturating arithmetic to prevent overflows.
-    pub fn get_tao_inherited_for_hotkey_on_subnet(hotkey: &T::AccountId, netuid: u16) -> u64 {
-        let initial_tao: U96F32 = U96F32::saturating_from_num(
-            Self::get_stake_for_hotkey_on_subnet(hotkey, Self::get_root_netuid()),
-        );
+    pub fn get_tao_inherited_for_hotkey_on_subnet(hotkey: &T::AccountId, netuid: NetUid) -> u64 {
+        let initial_tao: U96F32 =
+            U96F32::saturating_from_num(Self::get_stake_for_hotkey_on_subnet(hotkey, NetUid::ROOT));
 
         // Initialize variables to track alpha allocated to children and inherited from parents.
         let mut tao_to_children: U96F32 = U96F32::saturating_from_num(0);
@@ -298,9 +300,10 @@ impl<T: Config> Pallet<T> {
         // Step 4: Calculate the total tao inherited from parents.
         for (proportion, parent) in parents {
             // Retrieve the parent's total stake on this subnet.
-            let parent_tao: U96F32 = U96F32::saturating_from_num(
-                Self::get_stake_for_hotkey_on_subnet(&parent, Self::get_root_netuid()),
-            );
+            let parent_tao = U96F32::saturating_from_num(Self::get_stake_for_hotkey_on_subnet(
+                &parent,
+                NetUid::ROOT,
+            ));
             log::trace!(
                 "Parent tao for parent {:?} on subnet {}: {:?}",
                 parent,
@@ -309,7 +312,7 @@ impl<T: Config> Pallet<T> {
             );
 
             // Convert the proportion to a normalized value between 0 and 1.
-            let normalized_proportion: U96F32 = U96F32::saturating_from_num(proportion)
+            let normalized_proportion = U96F32::saturating_from_num(proportion)
                 .safe_div(U96F32::saturating_from_num(u64::MAX));
             log::trace!(
                 "Normalized proportion from parent: {:?}",
@@ -344,7 +347,7 @@ impl<T: Config> Pallet<T> {
         finalized_tao.saturating_to_num::<u64>()
     }
 
-    pub fn get_inherited_for_hotkey_on_subnet(hotkey: &T::AccountId, netuid: u16) -> u64 {
+    pub fn get_inherited_for_hotkey_on_subnet(hotkey: &T::AccountId, netuid: NetUid) -> u64 {
         // Step 1: Retrieve the initial total stake (alpha) for the hotkey on the specified subnet.
         let initial_alpha: U96F32 =
             U96F32::saturating_from_num(Self::get_stake_for_hotkey_on_subnet(hotkey, netuid));
@@ -354,7 +357,7 @@ impl<T: Config> Pallet<T> {
             netuid,
             initial_alpha
         );
-        if netuid == 0 {
+        if netuid.is_root() {
             return initial_alpha.saturating_to_num::<u64>();
         }
 
@@ -469,7 +472,7 @@ impl<T: Config> Pallet<T> {
     pub fn has_enough_stake_on_subnet(
         hotkey: &T::AccountId,
         coldkey: &T::AccountId,
-        netuid: u16,
+        netuid: NetUid,
         decrement: u64,
     ) -> bool {
         // Retrieve the current stake for this hotkey-coldkey pair on the subnet
@@ -501,7 +504,7 @@ impl<T: Config> Pallet<T> {
     pub fn get_stake_for_hotkey_and_coldkey_on_subnet(
         hotkey: &T::AccountId,
         coldkey: &T::AccountId,
-        netuid: u16,
+        netuid: NetUid,
     ) -> u64 {
         let alpha_share_pool = Self::get_alpha_share_pool(hotkey.clone(), netuid);
         alpha_share_pool.try_get_value(coldkey).unwrap_or(0)
@@ -521,7 +524,7 @@ impl<T: Config> Pallet<T> {
     ///
     /// # Note
     /// This function returns the cumulative stake across all coldkeys associated with this hotkey on the subnet.
-    pub fn get_stake_for_hotkey_on_subnet(hotkey: &T::AccountId, netuid: u16) -> u64 {
+    pub fn get_stake_for_hotkey_on_subnet(hotkey: &T::AccountId, netuid: NetUid) -> u64 {
         // Retrieve and return the total alpha this hotkey owns on this subnet.
         // This value represents the sum of stakes from all coldkeys associated with this hotkey.
         TotalHotkeyAlpha::<T>::get(hotkey, netuid)
@@ -536,7 +539,7 @@ impl<T: Config> Pallet<T> {
     /// * `netuid` - The unique identifier of the subnet.
     /// * `amount` - The amount of alpha to be added.
     ///
-    pub fn increase_stake_for_hotkey_on_subnet(hotkey: &T::AccountId, netuid: u16, amount: u64) {
+    pub fn increase_stake_for_hotkey_on_subnet(hotkey: &T::AccountId, netuid: NetUid, amount: u64) {
         let mut alpha_share_pool = Self::get_alpha_share_pool(hotkey.clone(), netuid);
         alpha_share_pool.update_value_for_all(amount as i64);
     }
@@ -550,7 +553,7 @@ impl<T: Config> Pallet<T> {
     /// * `netuid` - The unique identifier of the subnet.
     /// * `amount` - The amount of alpha to be added.
     ///
-    pub fn decrease_stake_for_hotkey_on_subnet(hotkey: &T::AccountId, netuid: u16, amount: u64) {
+    pub fn decrease_stake_for_hotkey_on_subnet(hotkey: &T::AccountId, netuid: NetUid, amount: u64) {
         let mut alpha_share_pool = Self::get_alpha_share_pool(hotkey.clone(), netuid);
         alpha_share_pool.update_value_for_all((amount as i64).neg());
     }
@@ -568,7 +571,7 @@ impl<T: Config> Pallet<T> {
     pub fn increase_stake_for_hotkey_and_coldkey_on_subnet(
         hotkey: &T::AccountId,
         coldkey: &T::AccountId,
-        netuid: u16,
+        netuid: NetUid,
         amount: u64,
     ) -> u64 {
         if amount > 0 {
@@ -590,7 +593,7 @@ impl<T: Config> Pallet<T> {
 
     pub fn try_increase_stake_for_hotkey_and_coldkey_on_subnet(
         hotkey: &T::AccountId,
-        netuid: u16,
+        netuid: NetUid,
         amount: u64,
     ) -> bool {
         let mut alpha_share_pool = Self::get_alpha_share_pool(hotkey.clone(), netuid);
@@ -610,7 +613,7 @@ impl<T: Config> Pallet<T> {
     pub fn decrease_stake_for_hotkey_and_coldkey_on_subnet(
         hotkey: &T::AccountId,
         coldkey: &T::AccountId,
-        netuid: u16,
+        netuid: NetUid,
         amount: u64,
     ) -> u64 {
         let mut alpha_share_pool = Self::get_alpha_share_pool(hotkey.clone(), netuid);
@@ -636,7 +639,7 @@ impl<T: Config> Pallet<T> {
     /// If new alpha_reserve is about to drop below DefaultMinimumPoolLiquidity,
     /// then don't do it.
     ///
-    pub fn sim_swap_tao_for_alpha(netuid: u16, tao: u64) -> Option<u64> {
+    pub fn sim_swap_tao_for_alpha(netuid: NetUid, tao: u64) -> Option<u64> {
         // Step 1: Get the mechanism type for the subnet (0 for Stable, 1 for Dynamic)
         let mechanism_id: u16 = SubnetMechanism::<T>::get(netuid);
         // Step 2: Initialized vars.
@@ -675,7 +678,7 @@ impl<T: Config> Pallet<T> {
     /// If new tao_reserve is about to drop below DefaultMinimumPoolLiquidity,
     /// then don't do it.
     ///
-    pub fn sim_swap_alpha_for_tao(netuid: u16, alpha: u64) -> Option<u64> {
+    pub fn sim_swap_alpha_for_tao(netuid: NetUid, alpha: u64) -> Option<u64> {
         // Step 1: Get the mechanism type for the subnet (0 for Stable, 1 for Dynamic)
         let mechanism_id: u16 = SubnetMechanism::<T>::get(netuid);
         // Step 2: Swap alpha and attain tao
@@ -712,7 +715,7 @@ impl<T: Config> Pallet<T> {
     /// Swaps TAO for the alpha token on the subnet.
     ///
     /// Updates TaoIn, AlphaIn, and AlphaOut
-    pub fn swap_tao_for_alpha(netuid: u16, tao: u64) -> u64 {
+    pub fn swap_tao_for_alpha(netuid: NetUid, tao: u64) -> u64 {
         if let Some(alpha) = Self::sim_swap_tao_for_alpha(netuid, tao) {
             // Step 4. Decrease Alpha reserves.
             SubnetAlphaIn::<T>::mutate(netuid, |total| {
@@ -744,7 +747,7 @@ impl<T: Config> Pallet<T> {
     /// Swaps a subnet's Alpba token for TAO.
     ///
     /// Updates TaoIn, AlphaIn, and AlphaOut
-    pub fn swap_alpha_for_tao(netuid: u16, alpha: u64) -> u64 {
+    pub fn swap_alpha_for_tao(netuid: NetUid, alpha: u64) -> u64 {
         if let Some(tao) = Self::sim_swap_alpha_for_tao(netuid, alpha) {
             // Step 4: Increase Alpha reserves.
             SubnetAlphaIn::<T>::mutate(netuid, |total| {
@@ -779,7 +782,7 @@ impl<T: Config> Pallet<T> {
     pub fn unstake_from_subnet(
         hotkey: &T::AccountId,
         coldkey: &T::AccountId,
-        netuid: u16,
+        netuid: NetUid,
         alpha: u64,
         fee: u64,
     ) -> u64 {
@@ -838,7 +841,7 @@ impl<T: Config> Pallet<T> {
     pub(crate) fn stake_into_subnet(
         hotkey: &T::AccountId,
         coldkey: &T::AccountId,
-        netuid: u16,
+        netuid: NetUid,
         tao: u64,
         fee: u64,
     ) -> u64 {
@@ -892,7 +895,7 @@ impl<T: Config> Pallet<T> {
 
     pub fn get_alpha_share_pool(
         hotkey: <T as frame_system::Config>::AccountId,
-        netuid: u16,
+        netuid: NetUid,
     ) -> SharePool<AlphaShareKey<T>, HotkeyAlphaSharePoolDataOperations<T>> {
         let ops = HotkeyAlphaSharePoolDataOperations::new(hotkey, netuid);
         SharePool::<AlphaShareKey<T>, HotkeyAlphaSharePoolDataOperations<T>>::new(ops)
@@ -903,7 +906,7 @@ impl<T: Config> Pallet<T> {
     pub fn validate_add_stake(
         coldkey: &T::AccountId,
         hotkey: &T::AccountId,
-        netuid: u16,
+        netuid: NetUid,
         stake_to_be_added: u64,
         max_amount: u64,
         allow_partial: bool,
@@ -956,7 +959,7 @@ impl<T: Config> Pallet<T> {
     pub fn validate_remove_stake(
         coldkey: &T::AccountId,
         hotkey: &T::AccountId,
-        netuid: u16,
+        netuid: NetUid,
         alpha_unstaked: u64,
         max_amount: u64,
         allow_partial: bool,
@@ -1003,7 +1006,7 @@ impl<T: Config> Pallet<T> {
         only_alpha: bool,
     ) -> Result<(), Error<T>> {
         // Get all netuids (filter out root)
-        let subnets: Vec<u16> = Self::get_all_subnet_netuids();
+        let subnets = Self::get_all_subnet_netuids();
 
         // Ensure that the hotkey account exists this is only possible through registration.
         ensure!(
@@ -1013,7 +1016,7 @@ impl<T: Config> Pallet<T> {
 
         let mut unstaking_any = false;
         for netuid in subnets.iter() {
-            if only_alpha && (*netuid == Self::get_root_netuid()) {
+            if only_alpha && netuid.is_root() {
                 continue;
             }
 
@@ -1039,8 +1042,8 @@ impl<T: Config> Pallet<T> {
         destination_coldkey: &T::AccountId,
         origin_hotkey: &T::AccountId,
         destination_hotkey: &T::AccountId,
-        origin_netuid: u16,
-        destination_netuid: u16,
+        origin_netuid: NetUid,
+        destination_netuid: NetUid,
         alpha_amount: u64,
         max_amount: u64,
         maybe_allow_partial: Option<bool>,
@@ -1143,9 +1146,9 @@ impl<T: Config> Pallet<T> {
     }
 
     pub(crate) fn calculate_staking_fee(
-        origin: Option<(&T::AccountId, u16)>,
+        origin: Option<(&T::AccountId, NetUid)>,
         _origin_coldkey: &T::AccountId,
-        destination: Option<(&T::AccountId, u16)>,
+        destination: Option<(&T::AccountId, NetUid)>,
         _destination_coldkey: &T::AccountId,
         alpha_estimate: U96F32,
     ) -> u64 {
@@ -1160,9 +1163,7 @@ impl<T: Config> Pallet<T> {
                     }
                 }
 
-                if origin_netuid == Self::get_root_netuid()
-                    || SubnetMechanism::<T>::get(origin_netuid) == 0
-                {
+                if origin_netuid.is_root() || SubnetMechanism::<T>::get(origin_netuid) == 0 {
                     // If the origin netuid is root, or the subnet mechanism is 0, use the default fee
                     DefaultStakingFee::<T>::get()
                 } else {
@@ -1574,13 +1575,13 @@ impl<T: Config> Pallet<T> {
 
 #[derive(Debug)]
 pub struct HotkeyAlphaSharePoolDataOperations<T: frame_system::Config> {
-    netuid: u16,
+    netuid: NetUid,
     hotkey: <T as frame_system::Config>::AccountId,
     _marker: sp_std::marker::PhantomData<T>,
 }
 
 impl<T: Config> HotkeyAlphaSharePoolDataOperations<T> {
-    fn new(hotkey: <T as frame_system::Config>::AccountId, netuid: u16) -> Self {
+    fn new(hotkey: <T as frame_system::Config>::AccountId, netuid: NetUid) -> Self {
         HotkeyAlphaSharePoolDataOperations {
             netuid,
             hotkey,
diff --git a/pallets/subtensor/src/subnets/registration.rs b/pallets/subtensor/src/subnets/registration.rs
index 5c698c1b33..b01abec248 100644
--- a/pallets/subtensor/src/subnets/registration.rs
+++ b/pallets/subtensor/src/subnets/registration.rs
@@ -2,12 +2,13 @@ use super::*;
 use sp_core::{H256, U256};
 use sp_io::hashing::{keccak_256, sha2_256};
 use sp_runtime::Saturating;
+use subtensor_runtime_common::NetUid;
 use system::pallet_prelude::BlockNumberFor;
 
 const LOG_TARGET: &str = "runtime::subtensor::registration";
 
 impl<T: Config> Pallet<T> {
-    pub fn register_neuron(netuid: u16, hotkey: &T::AccountId) -> u16 {
+    pub fn register_neuron(netuid: NetUid, hotkey: &T::AccountId) -> u16 {
         // Init param
         let neuron_uid: u16;
         let block_number: u64 = Self::get_current_block_as_u64();
@@ -64,7 +65,7 @@ impl<T: Config> Pallet<T> {
     ///
     pub fn do_burned_registration(
         origin: T::RuntimeOrigin,
-        netuid: u16,
+        netuid: NetUid,
         hotkey: T::AccountId,
     ) -> DispatchResult {
         // --- 1. Check that the caller has signed the transaction. (the coldkey of the pairing)
@@ -78,7 +79,7 @@ impl<T: Config> Pallet<T> {
 
         // --- 2. Ensure the passed network is valid.
         ensure!(
-            netuid != Self::get_root_netuid(),
+            !netuid.is_root(),
             Error::<T>::RegistrationNotPermittedOnRootSubnet
         );
         ensure!(
@@ -213,7 +214,7 @@ impl<T: Config> Pallet<T> {
     ///
     pub fn do_registration(
         origin: T::RuntimeOrigin,
-        netuid: u16,
+        netuid: NetUid,
         block_number: u64,
         nonce: u64,
         work: Vec<u8>,
@@ -237,7 +238,7 @@ impl<T: Config> Pallet<T> {
 
         // --- 2. Ensure the passed network is valid.
         ensure!(
-            netuid != Self::get_root_netuid(),
+            !netuid.is_root(),
             Error::<T>::RegistrationNotPermittedOnRootSubnet
         );
         ensure!(
@@ -406,7 +407,7 @@ impl<T: Config> Pallet<T> {
     /// If all neurons are in immunity period, the neuron with the lowest pruning score is pruned. If there is a tie for
     /// the lowest pruning score, the immune neuron registered earliest is pruned.
     /// Ties for earliest registration are broken by the neuron with the lowest uid.
-    pub fn get_neuron_to_prune(netuid: u16) -> u16 {
+    pub fn get_neuron_to_prune(netuid: NetUid) -> u16 {
         let mut min_score: u16 = u16::MAX;
         let mut min_score_in_immunity: u16 = u16::MAX;
         let mut earliest_registration: u64 = u64::MAX;
@@ -584,7 +585,7 @@ impl<T: Config> Pallet<T> {
 
     /// Helper function for creating nonce and work.
     pub fn create_work_for_block_number(
-        netuid: u16,
+        netuid: NetUid,
         block_number: u64,
         start_nonce: u64,
         hotkey: &T::AccountId,
diff --git a/pallets/subtensor/src/subnets/serving.rs b/pallets/subtensor/src/subnets/serving.rs
index bee81bfae6..ae1c97cc7c 100644
--- a/pallets/subtensor/src/subnets/serving.rs
+++ b/pallets/subtensor/src/subnets/serving.rs
@@ -1,4 +1,5 @@
 use super::*;
+use subtensor_runtime_common::NetUid;
 
 impl<T: Config> Pallet<T> {
     /// ---- The implementation for the extrinsic serve_axon which sets the ip endpoint information for a uid on a network.
@@ -56,7 +57,7 @@ impl<T: Config> Pallet<T> {
     ///
     pub fn do_serve_axon(
         origin: T::RuntimeOrigin,
-        netuid: u16,
+        netuid: NetUid,
         version: u32,
         ip: u128,
         port: u16,
@@ -160,7 +161,7 @@ impl<T: Config> Pallet<T> {
     ///
     pub fn do_serve_prometheus(
         origin: T::RuntimeOrigin,
-        netuid: u16,
+        netuid: NetUid,
         version: u32,
         ip: u128,
         port: u16,
@@ -220,7 +221,7 @@ impl<T: Config> Pallet<T> {
     *********************************/
 
     pub fn axon_passes_rate_limit(
-        netuid: u16,
+        netuid: NetUid,
         prev_axon_info: &AxonInfoOf,
         current_block: u64,
     ) -> bool {
@@ -230,7 +231,7 @@ impl<T: Config> Pallet<T> {
     }
 
     pub fn prometheus_passes_rate_limit(
-        netuid: u16,
+        netuid: NetUid,
         prev_prometheus_info: &PrometheusInfoOf,
         current_block: u64,
     ) -> bool {
@@ -239,7 +240,7 @@ impl<T: Config> Pallet<T> {
         rate_limit == 0 || last_serve == 0 || current_block.saturating_sub(last_serve) >= rate_limit
     }
 
-    pub fn get_axon_info(netuid: u16, hotkey: &T::AccountId) -> AxonInfoOf {
+    pub fn get_axon_info(netuid: NetUid, hotkey: &T::AccountId) -> AxonInfoOf {
         if let Some(axons) = Axons::<T>::get(netuid, hotkey) {
             axons
         } else {
@@ -256,7 +257,7 @@ impl<T: Config> Pallet<T> {
         }
     }
 
-    pub fn get_prometheus_info(netuid: u16, hotkey: &T::AccountId) -> PrometheusInfoOf {
+    pub fn get_prometheus_info(netuid: NetUid, hotkey: &T::AccountId) -> PrometheusInfoOf {
         if let Some(prometheus) = Prometheus::<T>::get(netuid, hotkey) {
             prometheus
         } else {
@@ -319,7 +320,7 @@ impl<T: Config> Pallet<T> {
 
     pub fn validate_serve_axon(
         hotkey_id: &T::AccountId,
-        netuid: u16,
+        netuid: NetUid,
         version: u32,
         ip: u128,
         port: u16,
diff --git a/pallets/subtensor/src/subnets/subnet.rs b/pallets/subtensor/src/subnets/subnet.rs
index b122bfa049..ff9762353c 100644
--- a/pallets/subtensor/src/subnets/subnet.rs
+++ b/pallets/subtensor/src/subnets/subnet.rs
@@ -1,19 +1,8 @@
 use super::*;
-use frame_support::IterableStorageMap;
 use sp_core::Get;
+use subtensor_runtime_common::NetUid;
 
 impl<T: Config> Pallet<T> {
-    /// Retrieves the unique identifier (UID) for the root network.
-    ///
-    /// The root network is a special case and has a fixed UID of 0.
-    ///
-    /// # Returns:
-    /// * 'u16': The UID for the root network.
-    ///
-    pub fn get_root_netuid() -> u16 {
-        0
-    }
-
     /// Fetches the total count of subnets.
     ///
     /// This function retrieves the total number of subnets present on the chain.
@@ -32,7 +21,7 @@ impl<T: Config> Pallet<T> {
     /// # Returns:
     /// * 'bool': Whether the subnet exists.
     ///
-    pub fn if_subnet_exist(netuid: u16) -> bool {
+    pub fn if_subnet_exist(netuid: NetUid) -> bool {
         NetworksAdded::<T>::get(netuid)
     }
 
@@ -44,8 +33,8 @@ impl<T: Config> Pallet<T> {
     /// # Returns:
     /// * 'Vec<u16>': Netuids of all subnets.
     ///
-    pub fn get_all_subnet_netuids() -> Vec<u16> {
-        <NetworksAdded<T> as IterableStorageMap<u16, bool>>::iter()
+    pub fn get_all_subnet_netuids() -> Vec<NetUid> {
+        NetworksAdded::<T>::iter()
             .map(|(netuid, _)| netuid)
             .collect()
     }
@@ -61,7 +50,7 @@ impl<T: Config> Pallet<T> {
     /// # Returns:
     /// * 'u16': The subnet mechanism
     ///
-    pub fn get_subnet_mechanism(netuid: u16) -> u16 {
+    pub fn get_subnet_mechanism(netuid: NetUid) -> u16 {
         SubnetMechanism::<T>::get(netuid)
     }
 
@@ -72,14 +61,14 @@ impl<T: Config> Pallet<T> {
     ///
     /// # Returns
     /// * `u16` - The next available mechanism ID.
-    pub fn get_next_netuid() -> u16 {
-        let mut next_netuid = 1; // do not allow creation of root
-        let netuids: Vec<u16> = Self::get_all_subnet_netuids();
+    pub fn get_next_netuid() -> NetUid {
+        let mut next_netuid = NetUid::from(1); // do not allow creation of root
+        let netuids = Self::get_all_subnet_netuids();
         loop {
             if !netuids.contains(&next_netuid) {
                 break next_netuid;
             }
-            next_netuid = next_netuid.saturating_add(1);
+            next_netuid = next_netuid.next();
         }
     }
 
@@ -103,7 +92,7 @@ impl<T: Config> Pallet<T> {
     /// # Returns
     ///
     /// * `bool` - `true` if registrations are allowed for the subnet, `false` otherwise.
-    pub fn is_registration_allowed(netuid: u16) -> bool {
+    pub fn is_registration_allowed(netuid: NetUid) -> bool {
         Self::get_subnet_hyperparams(netuid)
             .map(|params| params.registration_allowed)
             .unwrap_or(false)
@@ -160,7 +149,7 @@ impl<T: Config> Pallet<T> {
         );
 
         // --- 5. Determine the netuid to register.
-        let netuid_to_register: u16 = Self::get_next_netuid();
+        let netuid_to_register = Self::get_next_netuid();
 
         // --- 6. Perform the lock operation.
         let actual_tao_lock_amount: u64 =
@@ -245,7 +234,7 @@ impl<T: Config> Pallet<T> {
     }
 
     /// Sets initial and custom parameters for a new network.
-    pub fn init_new_network(netuid: u16, tempo: u16) {
+    pub fn init_new_network(netuid: NetUid, tempo: u16) {
         // --- 1. Set network to 0 size.
         SubnetworkN::<T>::insert(netuid, 0);
 
@@ -340,7 +329,7 @@ impl<T: Config> Pallet<T> {
     /// # Returns
     ///
     /// * `DispatchResult`: A result indicating the success or failure of the operation.
-    pub fn do_start_call(origin: T::RuntimeOrigin, netuid: u16) -> DispatchResult {
+    pub fn do_start_call(origin: T::RuntimeOrigin, netuid: NetUid) -> DispatchResult {
         ensure!(
             Self::if_subnet_exist(netuid),
             Error::<T>::SubNetworkDoesNotExist
@@ -402,7 +391,7 @@ impl<T: Config> Pallet<T> {
     /// This function is rate-limited to one call per subnet per interval (e.g., one week).
     pub fn do_set_sn_owner_hotkey(
         origin: T::RuntimeOrigin,
-        netuid: u16,
+        netuid: NetUid,
         hotkey: &T::AccountId,
     ) -> DispatchResult {
         // Ensure the caller is either root or subnet owner.
@@ -437,7 +426,7 @@ impl<T: Config> Pallet<T> {
         Ok(())
     }
 
-    pub fn is_valid_subnet_for_emission(netuid: u16) -> bool {
+    pub fn is_valid_subnet_for_emission(netuid: NetUid) -> bool {
         FirstEmissionBlockNumber::<T>::get(netuid).is_some()
     }
 }
diff --git a/pallets/subtensor/src/subnets/symbols.rs b/pallets/subtensor/src/subnets/symbols.rs
index 1aae9c3a0c..b06d4807f5 100644
--- a/pallets/subtensor/src/subnets/symbols.rs
+++ b/pallets/subtensor/src/subnets/symbols.rs
@@ -1,8 +1,9 @@
 use super::*;
+use subtensor_runtime_common::NetUid;
 
 /// Returns the Unicode symbol as a Vec<u8> for a given netuid.
 impl<T: Config> Pallet<T> {
-    pub fn get_name_for_subnet(netuid: u16) -> Vec<u8> {
+    pub fn get_name_for_subnet(netuid: NetUid) -> Vec<u8> {
         SubnetIdentitiesV2::<T>::try_get(netuid)
             .and_then(|identity| {
                 if !identity.subnet_name.is_empty() {
@@ -12,7 +13,7 @@ impl<T: Config> Pallet<T> {
                 }
             })
             .unwrap_or_else(|_| {
-                match netuid {
+                match u16::from(netuid) {
                     0 => b"root".to_vec(),          // Τ (Upper case Tau)
                     1 => b"apex".to_vec(),          // α (Alpha)
                     2 => b"omron".to_vec(),         // β (Beta)
@@ -457,8 +458,8 @@ impl<T: Config> Pallet<T> {
             })
     }
 
-    pub fn get_symbol_for_subnet(netuid: u16) -> Vec<u8> {
-        match netuid {
+    pub fn get_symbol_for_subnet(netuid: NetUid) -> Vec<u8> {
+        match u16::from(netuid) {
             // Greek Alphabet (Lowercase)
             0 => b"\xCE\xA4".to_vec(),  // Τ (Upper case Tau)
             1 => b"\xCE\xB1".to_vec(),  // α (Alpha)
diff --git a/pallets/subtensor/src/subnets/uids.rs b/pallets/subtensor/src/subnets/uids.rs
index c97252677c..f9efd6999f 100644
--- a/pallets/subtensor/src/subnets/uids.rs
+++ b/pallets/subtensor/src/subnets/uids.rs
@@ -1,10 +1,11 @@
 use super::*;
 use frame_support::storage::IterableStorageDoubleMap;
 use sp_std::vec;
+use subtensor_runtime_common::NetUid;
 
 impl<T: Config> Pallet<T> {
     /// Returns the number of filled slots on a network.
-    pub fn get_subnetwork_n(netuid: u16) -> u16 {
+    pub fn get_subnetwork_n(netuid: NetUid) -> u16 {
         SubnetworkN::<T>::get(netuid)
     }
 
@@ -16,7 +17,7 @@ impl<T: Config> Pallet<T> {
     }
 
     /// Resets the trust, emission, consensus, incentive, dividends of the neuron to default
-    pub fn clear_neuron(netuid: u16, neuron_uid: u16) {
+    pub fn clear_neuron(netuid: NetUid, neuron_uid: u16) {
         let neuron_index: usize = neuron_uid.into();
         Emission::<T>::mutate(netuid, |v| Self::set_element_at(v, neuron_index, 0));
         Trust::<T>::mutate(netuid, |v| Self::set_element_at(v, neuron_index, 0));
@@ -28,7 +29,7 @@ impl<T: Config> Pallet<T> {
 
     /// Replace the neuron under this uid.
     pub fn replace_neuron(
-        netuid: u16,
+        netuid: NetUid,
         uid_to_replace: u16,
         new_hotkey: &T::AccountId,
         block_number: u64,
@@ -82,7 +83,7 @@ impl<T: Config> Pallet<T> {
     }
 
     /// Appends the uid to the network.
-    pub fn append_neuron(netuid: u16, new_hotkey: &T::AccountId, block_number: u64) {
+    pub fn append_neuron(netuid: NetUid, new_hotkey: &T::AccountId, block_number: u64) {
         // 1. Get the next uid. This is always equal to subnetwork_n.
         let next_uid: u16 = Self::get_subnetwork_n(netuid);
         log::debug!(
@@ -117,20 +118,20 @@ impl<T: Config> Pallet<T> {
 
     /// Returns true if the uid is set on the network.
     ///
-    pub fn is_uid_exist_on_network(netuid: u16, uid: u16) -> bool {
+    pub fn is_uid_exist_on_network(netuid: NetUid, uid: u16) -> bool {
         Keys::<T>::contains_key(netuid, uid)
     }
 
     /// Returns true if the hotkey holds a slot on the network.
     ///
-    pub fn is_hotkey_registered_on_network(netuid: u16, hotkey: &T::AccountId) -> bool {
+    pub fn is_hotkey_registered_on_network(netuid: NetUid, hotkey: &T::AccountId) -> bool {
         Uids::<T>::contains_key(netuid, hotkey)
     }
 
     /// Returs the hotkey under the network uid as a Result. Ok if the uid is taken.
     ///
     pub fn get_hotkey_for_net_and_uid(
-        netuid: u16,
+        netuid: NetUid,
         neuron_uid: u16,
     ) -> Result<T::AccountId, DispatchError> {
         Keys::<T>::try_get(netuid, neuron_uid)
@@ -140,7 +141,7 @@ impl<T: Config> Pallet<T> {
     /// Returns the uid of the hotkey in the network as a Result. Ok if the hotkey has a slot.
     ///
     pub fn get_uid_for_net_and_hotkey(
-        netuid: u16,
+        netuid: NetUid,
         hotkey: &T::AccountId,
     ) -> Result<u16, DispatchError> {
         Uids::<T>::try_get(netuid, hotkey)
@@ -149,7 +150,7 @@ impl<T: Config> Pallet<T> {
 
     /// Returns the stake of the uid on network or 0 if it doesnt exist.
     ///
-    pub fn get_stake_for_uid_and_subnetwork(netuid: u16, neuron_uid: u16) -> u64 {
+    pub fn get_stake_for_uid_and_subnetwork(netuid: NetUid, neuron_uid: u16) -> u64 {
         if let Ok(hotkey) = Self::get_hotkey_for_net_and_uid(netuid, neuron_uid) {
             Self::get_stake_for_hotkey_on_subnet(&hotkey, netuid)
         } else {
@@ -159,12 +160,13 @@ impl<T: Config> Pallet<T> {
 
     /// Return a list of all networks a hotkey is registered on.
     ///
-    pub fn get_registered_networks_for_hotkey(hotkey: &T::AccountId) -> Vec<u16> {
-        let mut all_networks: Vec<u16> = vec![];
-        for (network, is_registered) in
-            <IsNetworkMember<T> as IterableStorageDoubleMap<T::AccountId, u16, bool>>::iter_prefix(
-                hotkey,
-            )
+    pub fn get_registered_networks_for_hotkey(hotkey: &T::AccountId) -> Vec<NetUid> {
+        let mut all_networks: Vec<NetUid> = vec![];
+        for (network, is_registered) in <IsNetworkMember<T> as IterableStorageDoubleMap<
+            T::AccountId,
+            NetUid,
+            bool,
+        >>::iter_prefix(hotkey)
         {
             if is_registered {
                 all_networks.push(network)
@@ -176,10 +178,11 @@ impl<T: Config> Pallet<T> {
     /// Return true if a hotkey is registered on any network.
     ///
     pub fn is_hotkey_registered_on_any_network(hotkey: &T::AccountId) -> bool {
-        for (_, is_registered) in
-            <IsNetworkMember<T> as IterableStorageDoubleMap<T::AccountId, u16, bool>>::iter_prefix(
-                hotkey,
-            )
+        for (_, is_registered) in <IsNetworkMember<T> as IterableStorageDoubleMap<
+            T::AccountId,
+            NetUid,
+            bool,
+        >>::iter_prefix(hotkey)
         {
             if is_registered {
                 return true;
diff --git a/pallets/subtensor/src/subnets/weights.rs b/pallets/subtensor/src/subnets/weights.rs
index ec6c9949bc..427846938a 100644
--- a/pallets/subtensor/src/subnets/weights.rs
+++ b/pallets/subtensor/src/subnets/weights.rs
@@ -8,6 +8,7 @@ use sp_runtime::{
     traits::{BlakeTwo256, Hash},
 };
 use sp_std::{collections::vec_deque::VecDeque, vec};
+use subtensor_runtime_common::NetUid;
 
 impl<T: Config> Pallet<T> {
     /// ---- The implementation for committing weight hashes.
@@ -40,7 +41,7 @@ impl<T: Config> Pallet<T> {
     ///   - Emitted upon successfully storing the weight hash.
     pub fn do_commit_weights(
         origin: T::RuntimeOrigin,
-        netuid: u16,
+        netuid: NetUid,
         commit_hash: H256,
     ) -> DispatchResult {
         // 1. Verify the caller's signature (hotkey).
@@ -138,7 +139,7 @@ impl<T: Config> Pallet<T> {
     ///
     pub fn do_batch_commit_weights(
         origin: T::RuntimeOrigin,
-        netuids: Vec<Compact<u16>>,
+        netuids: Vec<Compact<NetUid>>,
         commit_hashes: Vec<H256>,
     ) -> dispatch::DispatchResult {
         // --- 1. Check the caller's signature. This is the hotkey of a registered account.
@@ -228,7 +229,7 @@ impl<T: Config> Pallet<T> {
     ///   - Emitted upon successfully storing the weight hash.
     pub fn do_commit_crv3_weights(
         origin: T::RuntimeOrigin,
-        netuid: u16,
+        netuid: NetUid,
         commit: BoundedVec<u8, ConstU32<MAX_CRV3_COMMIT_SIZE_BYTES>>,
         reveal_round: u64,
     ) -> DispatchResult {
@@ -338,7 +339,7 @@ impl<T: Config> Pallet<T> {
     ///   - The revealed hash does not match any committed hash.
     pub fn do_reveal_weights(
         origin: T::RuntimeOrigin,
-        netuid: u16,
+        netuid: NetUid,
         uids: Vec<u16>,
         values: Vec<u16>,
         salt: Vec<u16>,
@@ -479,7 +480,7 @@ impl<T: Config> Pallet<T> {
     ///   - The input vectors are of mismatched lengths.
     pub fn do_batch_reveal_weights(
         origin: T::RuntimeOrigin,
-        netuid: u16,
+        netuid: NetUid,
         uids_list: Vec<Vec<u16>>,
         values_list: Vec<Vec<u16>>,
         salts_list: Vec<Vec<u16>>,
@@ -675,7 +676,7 @@ impl<T: Config> Pallet<T> {
     ///
     pub fn do_set_weights(
         origin: T::RuntimeOrigin,
-        netuid: u16,
+        netuid: NetUid,
         uids: Vec<u16>,
         values: Vec<u16>,
         version_key: u64,
@@ -691,10 +692,7 @@ impl<T: Config> Pallet<T> {
         );
 
         // --- Check that the netuid is not the root network.
-        ensure!(
-            netuid != Self::get_root_netuid(),
-            Error::<T>::CanNotSetRootNetworkWeights
-        );
+        ensure!(!netuid.is_root(), Error::<T>::CanNotSetRootNetworkWeights);
 
         // --- 2. Check that the length of uid list and value list are equal for this network.
         ensure!(
@@ -829,7 +827,7 @@ impl<T: Config> Pallet<T> {
     ///
     pub fn do_batch_set_weights(
         origin: T::RuntimeOrigin,
-        netuids: Vec<Compact<u16>>,
+        netuids: Vec<Compact<NetUid>>,
         weights: Vec<Vec<(Compact<u16>, Compact<u16>)>>,
         version_keys: Vec<Compact<u64>>,
     ) -> dispatch::DispatchResult {
@@ -901,7 +899,7 @@ impl<T: Config> Pallet<T> {
 
     /// Returns true if version_key is up-to-date.
     ///
-    pub fn check_version_key(netuid: u16, version_key: u64) -> bool {
+    pub fn check_version_key(netuid: NetUid, version_key: u64) -> bool {
         let network_version_key: u64 = WeightsVersionKey::<T>::get(netuid);
         log::debug!(
             "check_version_key( network_version_key:{:?}, version_key:{:?} )",
@@ -913,7 +911,7 @@ impl<T: Config> Pallet<T> {
 
     /// Checks if the neuron has set weights within the weights_set_rate_limit.
     ///
-    pub fn check_rate_limit(netuid: u16, neuron_uid: u16, current_block: u64) -> bool {
+    pub fn check_rate_limit(netuid: NetUid, neuron_uid: u16, current_block: u64) -> bool {
         if Self::is_uid_exist_on_network(netuid, neuron_uid) {
             // --- 1. Ensure that the diff between current and last_set weights is greater than limit.
             let last_set_weights: u64 = Self::get_last_update_for_uid(netuid, neuron_uid);
@@ -928,7 +926,7 @@ impl<T: Config> Pallet<T> {
     }
 
     /// Checks for any invalid uids on this network.
-    pub fn contains_invalid_uids(netuid: u16, uids: &[u16]) -> bool {
+    pub fn contains_invalid_uids(netuid: NetUid, uids: &[u16]) -> bool {
         for uid in uids {
             if !Self::is_uid_exist_on_network(netuid, *uid) {
                 log::debug!(
@@ -960,7 +958,7 @@ impl<T: Config> Pallet<T> {
     }
 
     /// Returns True if setting self-weight or has validator permit.
-    pub fn check_validator_permit(netuid: u16, uid: u16, uids: &[u16], weights: &[u16]) -> bool {
+    pub fn check_validator_permit(netuid: NetUid, uid: u16, uids: &[u16], weights: &[u16]) -> bool {
         // Check self weight. Allowed to set single value for self weight.
         if Self::is_self_weight(uid, uids, weights) {
             return true;
@@ -970,7 +968,7 @@ impl<T: Config> Pallet<T> {
     }
 
     /// Returns True if the uids and weights are have a valid length for uid on network.
-    pub fn check_length(netuid: u16, uid: u16, uids: &[u16], weights: &[u16]) -> bool {
+    pub fn check_length(netuid: NetUid, uid: u16, uids: &[u16], weights: &[u16]) -> bool {
         let subnet_n: usize = Self::get_subnetwork_n(netuid) as usize;
         let min_allowed_length: usize = Self::get_min_allowed_weights(netuid) as usize;
         let min_allowed: usize = {
@@ -983,7 +981,7 @@ impl<T: Config> Pallet<T> {
 
         // Check self weight. Allowed to set single value for self weight.
         // Or check that this is the root netuid.
-        if netuid != Self::get_root_netuid() && Self::is_self_weight(uid, uids, weights) {
+        if !netuid.is_root() && Self::is_self_weight(uid, uids, weights) {
             return true;
         }
         // Check if number of weights exceeds min.
@@ -1008,7 +1006,7 @@ impl<T: Config> Pallet<T> {
     }
 
     /// Returns False if the weights exceed the max_weight_limit for this network.
-    pub fn max_weight_limited(netuid: u16, uid: u16, uids: &[u16], weights: &[u16]) -> bool {
+    pub fn max_weight_limited(netuid: NetUid, uid: u16, uids: &[u16], weights: &[u16]) -> bool {
         // Allow self weights to exceed max weight limit.
         if Self::is_self_weight(uid, uids, weights) {
             return true;
@@ -1039,13 +1037,13 @@ impl<T: Config> Pallet<T> {
     }
 
     /// Returns False is the number of uids exceeds the allowed number of uids for this network.
-    pub fn check_len_uids_within_allowed(netuid: u16, uids: &[u16]) -> bool {
+    pub fn check_len_uids_within_allowed(netuid: NetUid, uids: &[u16]) -> bool {
         let subnetwork_n: u16 = Self::get_subnetwork_n(netuid);
         // we should expect at most subnetwork_n uids.
         uids.len() <= subnetwork_n as usize
     }
 
-    pub fn is_reveal_block_range(netuid: u16, commit_block: u64) -> bool {
+    pub fn is_reveal_block_range(netuid: NetUid, commit_block: u64) -> bool {
         let current_block: u64 = Self::get_current_block_as_u64();
         let commit_epoch: u64 = Self::get_epoch_index(netuid, commit_block);
         let current_epoch: u64 = Self::get_epoch_index(netuid, current_block);
@@ -1055,16 +1053,16 @@ impl<T: Config> Pallet<T> {
         current_epoch == commit_epoch.saturating_add(reveal_period)
     }
 
-    pub fn get_epoch_index(netuid: u16, block_number: u64) -> u64 {
+    pub fn get_epoch_index(netuid: NetUid, block_number: u64) -> u64 {
         let tempo: u64 = Self::get_tempo(netuid) as u64;
         let tempo_plus_one: u64 = tempo.saturating_add(1);
-        let netuid_plus_one: u64 = (netuid as u64).saturating_add(1);
+        let netuid_plus_one: u64 = (u16::from(netuid) as u64).saturating_add(1);
         let block_with_offset: u64 = block_number.saturating_add(netuid_plus_one);
 
         block_with_offset.checked_div(tempo_plus_one).unwrap_or(0)
     }
 
-    pub fn is_commit_expired(netuid: u16, commit_block: u64) -> bool {
+    pub fn is_commit_expired(netuid: NetUid, commit_block: u64) -> bool {
         let current_block: u64 = Self::get_current_block_as_u64();
         let current_epoch: u64 = Self::get_epoch_index(netuid, current_block);
         let commit_epoch: u64 = Self::get_epoch_index(netuid, commit_block);
@@ -1073,11 +1071,11 @@ impl<T: Config> Pallet<T> {
         current_epoch > commit_epoch.saturating_add(reveal_period)
     }
 
-    pub fn get_reveal_blocks(netuid: u16, commit_block: u64) -> (u64, u64) {
+    pub fn get_reveal_blocks(netuid: NetUid, commit_block: u64) -> (u64, u64) {
         let reveal_period: u64 = Self::get_reveal_period(netuid);
         let tempo: u64 = Self::get_tempo(netuid) as u64;
         let tempo_plus_one: u64 = tempo.saturating_add(1);
-        let netuid_plus_one: u64 = (netuid as u64).saturating_add(1);
+        let netuid_plus_one: u64 = (u16::from(netuid) as u64).saturating_add(1);
 
         let commit_epoch: u64 = Self::get_epoch_index(netuid, commit_block);
         let reveal_epoch: u64 = commit_epoch.saturating_add(reveal_period);
@@ -1090,11 +1088,11 @@ impl<T: Config> Pallet<T> {
         (first_reveal_block, last_reveal_block)
     }
 
-    pub fn set_reveal_period(netuid: u16, reveal_period: u64) {
+    pub fn set_reveal_period(netuid: NetUid, reveal_period: u64) {
         RevealPeriodEpochs::<T>::insert(netuid, reveal_period);
         Self::deposit_event(Event::CommitRevealPeriodsSet(netuid, reveal_period));
     }
-    pub fn get_reveal_period(netuid: u16) -> u64 {
+    pub fn get_reveal_period(netuid: NetUid) -> u64 {
         RevealPeriodEpochs::<T>::get(netuid)
     }
 }
diff --git a/pallets/subtensor/src/swap/swap_hotkey.rs b/pallets/subtensor/src/swap/swap_hotkey.rs
index 54c7c01d8e..10676aafe6 100644
--- a/pallets/subtensor/src/swap/swap_hotkey.rs
+++ b/pallets/subtensor/src/swap/swap_hotkey.rs
@@ -227,7 +227,7 @@ impl<T: Config> Pallet<T> {
         // (DEPRECATED.)
 
         // 10. Swap all subnet specific info.
-        let all_netuids: Vec<u16> = Self::get_all_subnet_netuids();
+        let all_netuids = Self::get_all_subnet_netuids();
         all_netuids.iter().for_each(|netuid| {
             // 10.1 Remove the previous hotkey and insert the new hotkey from membership.
             // IsNetworkMember( hotkey, netuid ) -> bool -- is the hotkey a subnet member.
@@ -312,7 +312,7 @@ impl<T: Config> Pallet<T> {
 
         // 11. Swap Alpha
         // Alpha( hotkey, coldkey, netuid ) -> alpha
-        let old_alpha_values: Vec<((T::AccountId, u16), U64F64)> =
+        let old_alpha_values: Vec<((T::AccountId, NetUid), U64F64)> =
             Alpha::<T>::iter_prefix((old_hotkey,)).collect();
         // Clear the entire old prefix here.
         let _ = Alpha::<T>::clear_prefix((old_hotkey,), old_alpha_values.len() as u32, None);
diff --git a/pallets/subtensor/src/utils/evm.rs b/pallets/subtensor/src/utils/evm.rs
index 6877739f69..5d4f1ad493 100644
--- a/pallets/subtensor/src/utils/evm.rs
+++ b/pallets/subtensor/src/utils/evm.rs
@@ -5,6 +5,7 @@ use frame_support::ensure;
 use frame_system::ensure_signed;
 use sp_core::{H160, ecdsa::Signature, hashing::keccak_256};
 use sp_std::vec::Vec;
+use subtensor_runtime_common::NetUid;
 
 const MESSAGE_PREFIX: &str = "\x19Ethereum Signed Message:\n";
 
@@ -42,7 +43,7 @@ impl<T: Config> Pallet<T> {
     /// * `signature` - A signed message by the `evm_key` containing the `hotkey` and the hashed `block_number`.
     pub fn do_associate_evm_key(
         origin: T::RuntimeOrigin,
-        netuid: u16,
+        netuid: NetUid,
         hotkey: T::AccountId,
         evm_key: H160,
         block_number: u64,
@@ -91,7 +92,7 @@ impl<T: Config> Pallet<T> {
         Ok(())
     }
 
-    pub fn uid_lookup(netuid: u16, evm_key: H160, limit: u16) -> Vec<(u16, u64)> {
+    pub fn uid_lookup(netuid: NetUid, evm_key: H160, limit: u16) -> Vec<(u16, u64)> {
         let mut ret_val = AssociatedEvmAddress::<T>::iter_prefix(netuid)
             .take(limit as usize)
             .filter_map(|(uid, (stored_evm_key, block_associated))| {
diff --git a/pallets/subtensor/src/utils/identity.rs b/pallets/subtensor/src/utils/identity.rs
index c4b9fdc821..287c45a543 100644
--- a/pallets/subtensor/src/utils/identity.rs
+++ b/pallets/subtensor/src/utils/identity.rs
@@ -2,6 +2,7 @@ use super::*;
 use frame_support::ensure;
 use frame_system::ensure_signed;
 use sp_std::vec::Vec;
+use subtensor_runtime_common::NetUid;
 
 impl<T: Config> Pallet<T> {
     /// Sets the identity for a coldkey.
@@ -96,7 +97,7 @@ impl<T: Config> Pallet<T> {
     /// Returns `Ok(())` if the subnet identity is successfully set, otherwise returns an error.
     pub fn do_set_subnet_identity(
         origin: T::RuntimeOrigin,
-        netuid: u16,
+        netuid: NetUid,
         subnet_name: Vec<u8>,
         github_repo: Vec<u8>,
         subnet_contact: Vec<u8>,
diff --git a/pallets/subtensor/src/utils/misc.rs b/pallets/subtensor/src/utils/misc.rs
index 899fa83646..cf7c5f1a18 100644
--- a/pallets/subtensor/src/utils/misc.rs
+++ b/pallets/subtensor/src/utils/misc.rs
@@ -8,11 +8,12 @@ use sp_core::Get;
 use sp_core::U256;
 use sp_runtime::Saturating;
 use substrate_fixed::types::{I32F32, U96F32};
+use subtensor_runtime_common::NetUid;
 
 impl<T: Config> Pallet<T> {
     pub fn ensure_subnet_owner_or_root(
         o: T::RuntimeOrigin,
-        netuid: u16,
+        netuid: NetUid,
     ) -> Result<(), DispatchError> {
         let coldkey = ensure_signed_or_root(o);
         match coldkey {
@@ -23,7 +24,7 @@ impl<T: Config> Pallet<T> {
         }
     }
 
-    pub fn ensure_subnet_owner(o: T::RuntimeOrigin, netuid: u16) -> Result<(), DispatchError> {
+    pub fn ensure_subnet_owner(o: T::RuntimeOrigin, netuid: NetUid) -> Result<(), DispatchError> {
         let coldkey = ensure_signed(o);
         match coldkey {
             Ok(who) if SubnetOwner::<T>::get(netuid) == who => Ok(()),
@@ -35,30 +36,33 @@ impl<T: Config> Pallet<T> {
     // ========================
     // ==== Global Setters ====
     // ========================
-    pub fn set_tempo(netuid: u16, tempo: u16) {
+    pub fn set_tempo(netuid: NetUid, tempo: u16) {
         Tempo::<T>::insert(netuid, tempo);
         Self::deposit_event(Event::TempoSet(netuid, tempo));
     }
-    pub fn set_last_adjustment_block(netuid: u16, last_adjustment_block: u64) {
+    pub fn set_last_adjustment_block(netuid: NetUid, last_adjustment_block: u64) {
         LastAdjustmentBlock::<T>::insert(netuid, last_adjustment_block);
     }
-    pub fn set_blocks_since_last_step(netuid: u16, blocks_since_last_step: u64) {
+    pub fn set_blocks_since_last_step(netuid: NetUid, blocks_since_last_step: u64) {
         BlocksSinceLastStep::<T>::insert(netuid, blocks_since_last_step);
     }
-    pub fn set_registrations_this_block(netuid: u16, registrations_this_block: u16) {
+    pub fn set_registrations_this_block(netuid: NetUid, registrations_this_block: u16) {
         RegistrationsThisBlock::<T>::insert(netuid, registrations_this_block);
     }
-    pub fn set_last_mechanism_step_block(netuid: u16, last_mechanism_step_block: u64) {
+    pub fn set_last_mechanism_step_block(netuid: NetUid, last_mechanism_step_block: u64) {
         LastMechansimStepBlock::<T>::insert(netuid, last_mechanism_step_block);
     }
-    pub fn set_registrations_this_interval(netuid: u16, registrations_this_interval: u16) {
+    pub fn set_registrations_this_interval(netuid: NetUid, registrations_this_interval: u16) {
         RegistrationsThisInterval::<T>::insert(netuid, registrations_this_interval);
     }
-    pub fn set_pow_registrations_this_interval(netuid: u16, pow_registrations_this_interval: u16) {
+    pub fn set_pow_registrations_this_interval(
+        netuid: NetUid,
+        pow_registrations_this_interval: u16,
+    ) {
         POWRegistrationsThisInterval::<T>::insert(netuid, pow_registrations_this_interval);
     }
     pub fn set_burn_registrations_this_interval(
-        netuid: u16,
+        netuid: NetUid,
         burn_registrations_this_interval: u16,
     ) {
         BurnRegistrationsThisInterval::<T>::insert(netuid, burn_registrations_this_interval);
@@ -79,44 +83,44 @@ impl<T: Config> Pallet<T> {
     // ==============================
     // ==== YumaConsensus params ====
     // ==============================
-    pub fn get_rank(netuid: u16) -> Vec<u16> {
+    pub fn get_rank(netuid: NetUid) -> Vec<u16> {
         Rank::<T>::get(netuid)
     }
-    pub fn get_trust(netuid: u16) -> Vec<u16> {
+    pub fn get_trust(netuid: NetUid) -> Vec<u16> {
         Trust::<T>::get(netuid)
     }
-    pub fn get_active(netuid: u16) -> Vec<bool> {
+    pub fn get_active(netuid: NetUid) -> Vec<bool> {
         Active::<T>::get(netuid)
     }
-    pub fn get_emission(netuid: u16) -> Vec<u64> {
+    pub fn get_emission(netuid: NetUid) -> Vec<u64> {
         Emission::<T>::get(netuid)
     }
-    pub fn get_consensus(netuid: u16) -> Vec<u16> {
+    pub fn get_consensus(netuid: NetUid) -> Vec<u16> {
         Consensus::<T>::get(netuid)
     }
-    pub fn get_incentive(netuid: u16) -> Vec<u16> {
+    pub fn get_incentive(netuid: NetUid) -> Vec<u16> {
         Incentive::<T>::get(netuid)
     }
-    pub fn get_dividends(netuid: u16) -> Vec<u16> {
+    pub fn get_dividends(netuid: NetUid) -> Vec<u16> {
         Dividends::<T>::get(netuid)
     }
-    pub fn get_last_update(netuid: u16) -> Vec<u64> {
+    pub fn get_last_update(netuid: NetUid) -> Vec<u64> {
         LastUpdate::<T>::get(netuid)
     }
-    pub fn get_pruning_score(netuid: u16) -> Vec<u16> {
+    pub fn get_pruning_score(netuid: NetUid) -> Vec<u16> {
         PruningScores::<T>::get(netuid)
     }
-    pub fn get_validator_trust(netuid: u16) -> Vec<u16> {
+    pub fn get_validator_trust(netuid: NetUid) -> Vec<u16> {
         ValidatorTrust::<T>::get(netuid)
     }
-    pub fn get_validator_permit(netuid: u16) -> Vec<bool> {
+    pub fn get_validator_permit(netuid: NetUid) -> Vec<bool> {
         ValidatorPermit::<T>::get(netuid)
     }
 
     // ==================================
     // ==== YumaConsensus UID params ====
     // ==================================
-    pub fn set_last_update_for_uid(netuid: u16, uid: u16, last_update: u64) {
+    pub fn set_last_update_for_uid(netuid: NetUid, uid: u16, last_update: u64) {
         let mut updated_last_update_vec = Self::get_last_update(netuid);
         let Some(updated_last_update) = updated_last_update_vec.get_mut(uid as usize) else {
             return;
@@ -124,7 +128,7 @@ impl<T: Config> Pallet<T> {
         *updated_last_update = last_update;
         LastUpdate::<T>::insert(netuid, updated_last_update_vec);
     }
-    pub fn set_active_for_uid(netuid: u16, uid: u16, active: bool) {
+    pub fn set_active_for_uid(netuid: NetUid, uid: u16, active: bool) {
         let mut updated_active_vec = Self::get_active(netuid);
         let Some(updated_active) = updated_active_vec.get_mut(uid as usize) else {
             return;
@@ -132,7 +136,7 @@ impl<T: Config> Pallet<T> {
         *updated_active = active;
         Active::<T>::insert(netuid, updated_active_vec);
     }
-    pub fn set_pruning_score_for_uid(netuid: u16, uid: u16, pruning_score: u16) {
+    pub fn set_pruning_score_for_uid(netuid: NetUid, uid: u16, pruning_score: u16) {
         log::debug!("netuid = {:?}", netuid);
         log::debug!(
             "SubnetworkN::<T>::get( netuid ) = {:?}",
@@ -146,7 +150,7 @@ impl<T: Config> Pallet<T> {
             }
         });
     }
-    pub fn set_validator_permit_for_uid(netuid: u16, uid: u16, validator_permit: bool) {
+    pub fn set_validator_permit_for_uid(netuid: NetUid, uid: u16, validator_permit: bool) {
         let mut updated_validator_permits = Self::get_validator_permit(netuid);
         let Some(updated_validator_permit) = updated_validator_permits.get_mut(uid as usize) else {
             return;
@@ -159,47 +163,47 @@ impl<T: Config> Pallet<T> {
         Self::deposit_event(Event::StakeThresholdSet(min_stake));
     }
 
-    pub fn get_rank_for_uid(netuid: u16, uid: u16) -> u16 {
+    pub fn get_rank_for_uid(netuid: NetUid, uid: u16) -> u16 {
         let vec = Rank::<T>::get(netuid);
         vec.get(uid as usize).copied().unwrap_or(0)
     }
-    pub fn get_trust_for_uid(netuid: u16, uid: u16) -> u16 {
+    pub fn get_trust_for_uid(netuid: NetUid, uid: u16) -> u16 {
         let vec = Trust::<T>::get(netuid);
         vec.get(uid as usize).copied().unwrap_or(0)
     }
-    pub fn get_emission_for_uid(netuid: u16, uid: u16) -> u64 {
+    pub fn get_emission_for_uid(netuid: NetUid, uid: u16) -> u64 {
         let vec = Emission::<T>::get(netuid);
         vec.get(uid as usize).copied().unwrap_or(0)
     }
-    pub fn get_active_for_uid(netuid: u16, uid: u16) -> bool {
+    pub fn get_active_for_uid(netuid: NetUid, uid: u16) -> bool {
         let vec = Active::<T>::get(netuid);
         vec.get(uid as usize).copied().unwrap_or(false)
     }
-    pub fn get_consensus_for_uid(netuid: u16, uid: u16) -> u16 {
+    pub fn get_consensus_for_uid(netuid: NetUid, uid: u16) -> u16 {
         let vec = Consensus::<T>::get(netuid);
         vec.get(uid as usize).copied().unwrap_or(0)
     }
-    pub fn get_incentive_for_uid(netuid: u16, uid: u16) -> u16 {
+    pub fn get_incentive_for_uid(netuid: NetUid, uid: u16) -> u16 {
         let vec = Incentive::<T>::get(netuid);
         vec.get(uid as usize).copied().unwrap_or(0)
     }
-    pub fn get_dividends_for_uid(netuid: u16, uid: u16) -> u16 {
+    pub fn get_dividends_for_uid(netuid: NetUid, uid: u16) -> u16 {
         let vec = Dividends::<T>::get(netuid);
         vec.get(uid as usize).copied().unwrap_or(0)
     }
-    pub fn get_last_update_for_uid(netuid: u16, uid: u16) -> u64 {
+    pub fn get_last_update_for_uid(netuid: NetUid, uid: u16) -> u64 {
         let vec = LastUpdate::<T>::get(netuid);
         vec.get(uid as usize).copied().unwrap_or(0)
     }
-    pub fn get_pruning_score_for_uid(netuid: u16, uid: u16) -> u16 {
+    pub fn get_pruning_score_for_uid(netuid: NetUid, uid: u16) -> u16 {
         let vec = PruningScores::<T>::get(netuid);
         vec.get(uid as usize).copied().unwrap_or(u16::MAX)
     }
-    pub fn get_validator_trust_for_uid(netuid: u16, uid: u16) -> u16 {
+    pub fn get_validator_trust_for_uid(netuid: NetUid, uid: u16) -> u16 {
         let vec = ValidatorTrust::<T>::get(netuid);
         vec.get(uid as usize).copied().unwrap_or(0)
     }
-    pub fn get_validator_permit_for_uid(netuid: u16, uid: u16) -> bool {
+    pub fn get_validator_permit_for_uid(netuid: NetUid, uid: u16) -> bool {
         let vec = ValidatorPermit::<T>::get(netuid);
         vec.get(uid as usize).copied().unwrap_or(false)
     }
@@ -210,37 +214,37 @@ impl<T: Config> Pallet<T> {
     // ============================
     // ==== Subnetwork Getters ====
     // ============================
-    pub fn get_tempo(netuid: u16) -> u16 {
+    pub fn get_tempo(netuid: NetUid) -> u16 {
         Tempo::<T>::get(netuid)
     }
-    pub fn get_pending_emission(netuid: u16) -> u64 {
+    pub fn get_pending_emission(netuid: NetUid) -> u64 {
         PendingEmission::<T>::get(netuid)
     }
-    pub fn get_last_adjustment_block(netuid: u16) -> u64 {
+    pub fn get_last_adjustment_block(netuid: NetUid) -> u64 {
         LastAdjustmentBlock::<T>::get(netuid)
     }
-    pub fn get_blocks_since_last_step(netuid: u16) -> u64 {
+    pub fn get_blocks_since_last_step(netuid: NetUid) -> u64 {
         BlocksSinceLastStep::<T>::get(netuid)
     }
-    pub fn get_difficulty(netuid: u16) -> U256 {
+    pub fn get_difficulty(netuid: NetUid) -> U256 {
         U256::from(Self::get_difficulty_as_u64(netuid))
     }
-    pub fn get_registrations_this_block(netuid: u16) -> u16 {
+    pub fn get_registrations_this_block(netuid: NetUid) -> u16 {
         RegistrationsThisBlock::<T>::get(netuid)
     }
-    pub fn get_last_mechanism_step_block(netuid: u16) -> u64 {
+    pub fn get_last_mechanism_step_block(netuid: NetUid) -> u64 {
         LastMechansimStepBlock::<T>::get(netuid)
     }
-    pub fn get_registrations_this_interval(netuid: u16) -> u16 {
+    pub fn get_registrations_this_interval(netuid: NetUid) -> u16 {
         RegistrationsThisInterval::<T>::get(netuid)
     }
-    pub fn get_pow_registrations_this_interval(netuid: u16) -> u16 {
+    pub fn get_pow_registrations_this_interval(netuid: NetUid) -> u16 {
         POWRegistrationsThisInterval::<T>::get(netuid)
     }
-    pub fn get_burn_registrations_this_interval(netuid: u16) -> u16 {
+    pub fn get_burn_registrations_this_interval(netuid: NetUid) -> u16 {
         BurnRegistrationsThisInterval::<T>::get(netuid)
     }
-    pub fn get_neuron_block_at_registration(netuid: u16, neuron_uid: u16) -> u64 {
+    pub fn get_neuron_block_at_registration(netuid: NetUid, neuron_uid: u16) -> u64 {
         BlockAtRegistration::<T>::get(netuid, neuron_uid)
     }
 
@@ -273,10 +277,10 @@ impl<T: Config> Pallet<T> {
         TotalIssuance::<T>::put(TotalIssuance::<T>::get().saturating_add(amount));
     }
 
-    pub fn set_subnet_locked_balance(netuid: u16, amount: u64) {
+    pub fn set_subnet_locked_balance(netuid: NetUid, amount: u64) {
         SubnetLocked::<T>::insert(netuid, amount);
     }
-    pub fn get_subnet_locked_balance(netuid: u16) -> u64 {
+    pub fn get_subnet_locked_balance(netuid: NetUid) -> u64 {
         SubnetLocked::<T>::get(netuid)
     }
     pub fn get_total_subnet_locked() -> u64 {
@@ -352,42 +356,42 @@ impl<T: Config> Pallet<T> {
         MaxChildkeyTake::<T>::get()
     }
 
-    pub fn get_serving_rate_limit(netuid: u16) -> u64 {
+    pub fn get_serving_rate_limit(netuid: NetUid) -> u64 {
         ServingRateLimit::<T>::get(netuid)
     }
-    pub fn set_serving_rate_limit(netuid: u16, serving_rate_limit: u64) {
+    pub fn set_serving_rate_limit(netuid: NetUid, serving_rate_limit: u64) {
         ServingRateLimit::<T>::insert(netuid, serving_rate_limit);
         Self::deposit_event(Event::ServingRateLimitSet(netuid, serving_rate_limit));
     }
 
-    pub fn get_min_difficulty(netuid: u16) -> u64 {
+    pub fn get_min_difficulty(netuid: NetUid) -> u64 {
         MinDifficulty::<T>::get(netuid)
     }
-    pub fn set_min_difficulty(netuid: u16, min_difficulty: u64) {
+    pub fn set_min_difficulty(netuid: NetUid, min_difficulty: u64) {
         MinDifficulty::<T>::insert(netuid, min_difficulty);
         Self::deposit_event(Event::MinDifficultySet(netuid, min_difficulty));
     }
 
-    pub fn get_max_difficulty(netuid: u16) -> u64 {
+    pub fn get_max_difficulty(netuid: NetUid) -> u64 {
         MaxDifficulty::<T>::get(netuid)
     }
-    pub fn set_max_difficulty(netuid: u16, max_difficulty: u64) {
+    pub fn set_max_difficulty(netuid: NetUid, max_difficulty: u64) {
         MaxDifficulty::<T>::insert(netuid, max_difficulty);
         Self::deposit_event(Event::MaxDifficultySet(netuid, max_difficulty));
     }
 
-    pub fn get_weights_version_key(netuid: u16) -> u64 {
+    pub fn get_weights_version_key(netuid: NetUid) -> u64 {
         WeightsVersionKey::<T>::get(netuid)
     }
-    pub fn set_weights_version_key(netuid: u16, weights_version_key: u64) {
+    pub fn set_weights_version_key(netuid: NetUid, weights_version_key: u64) {
         WeightsVersionKey::<T>::insert(netuid, weights_version_key);
         Self::deposit_event(Event::WeightsVersionKeySet(netuid, weights_version_key));
     }
 
-    pub fn get_weights_set_rate_limit(netuid: u16) -> u64 {
+    pub fn get_weights_set_rate_limit(netuid: NetUid) -> u64 {
         WeightsSetRateLimit::<T>::get(netuid)
     }
-    pub fn set_weights_set_rate_limit(netuid: u16, weights_set_rate_limit: u64) {
+    pub fn set_weights_set_rate_limit(netuid: NetUid, weights_set_rate_limit: u64) {
         WeightsSetRateLimit::<T>::insert(netuid, weights_set_rate_limit);
         Self::deposit_event(Event::WeightsSetRateLimitSet(
             netuid,
@@ -395,126 +399,126 @@ impl<T: Config> Pallet<T> {
         ));
     }
 
-    pub fn get_adjustment_interval(netuid: u16) -> u16 {
+    pub fn get_adjustment_interval(netuid: NetUid) -> u16 {
         AdjustmentInterval::<T>::get(netuid)
     }
-    pub fn set_adjustment_interval(netuid: u16, adjustment_interval: u16) {
+    pub fn set_adjustment_interval(netuid: NetUid, adjustment_interval: u16) {
         AdjustmentInterval::<T>::insert(netuid, adjustment_interval);
         Self::deposit_event(Event::AdjustmentIntervalSet(netuid, adjustment_interval));
     }
 
-    pub fn get_adjustment_alpha(netuid: u16) -> u64 {
+    pub fn get_adjustment_alpha(netuid: NetUid) -> u64 {
         AdjustmentAlpha::<T>::get(netuid)
     }
-    pub fn set_adjustment_alpha(netuid: u16, adjustment_alpha: u64) {
+    pub fn set_adjustment_alpha(netuid: NetUid, adjustment_alpha: u64) {
         AdjustmentAlpha::<T>::insert(netuid, adjustment_alpha);
         Self::deposit_event(Event::AdjustmentAlphaSet(netuid, adjustment_alpha));
     }
 
-    pub fn set_validator_prune_len(netuid: u16, validator_prune_len: u64) {
+    pub fn set_validator_prune_len(netuid: NetUid, validator_prune_len: u64) {
         ValidatorPruneLen::<T>::insert(netuid, validator_prune_len);
         Self::deposit_event(Event::ValidatorPruneLenSet(netuid, validator_prune_len));
     }
 
-    pub fn get_scaling_law_power(netuid: u16) -> u16 {
+    pub fn get_scaling_law_power(netuid: NetUid) -> u16 {
         ScalingLawPower::<T>::get(netuid)
     }
-    pub fn set_scaling_law_power(netuid: u16, scaling_law_power: u16) {
+    pub fn set_scaling_law_power(netuid: NetUid, scaling_law_power: u16) {
         ScalingLawPower::<T>::insert(netuid, scaling_law_power);
         Self::deposit_event(Event::ScalingLawPowerSet(netuid, scaling_law_power));
     }
 
-    pub fn get_max_weight_limit(netuid: u16) -> u16 {
+    pub fn get_max_weight_limit(netuid: NetUid) -> u16 {
         MaxWeightsLimit::<T>::get(netuid)
     }
-    pub fn set_max_weight_limit(netuid: u16, max_weight_limit: u16) {
+    pub fn set_max_weight_limit(netuid: NetUid, max_weight_limit: u16) {
         MaxWeightsLimit::<T>::insert(netuid, max_weight_limit);
         Self::deposit_event(Event::MaxWeightLimitSet(netuid, max_weight_limit));
     }
 
-    pub fn get_immunity_period(netuid: u16) -> u16 {
+    pub fn get_immunity_period(netuid: NetUid) -> u16 {
         ImmunityPeriod::<T>::get(netuid)
     }
-    pub fn set_immunity_period(netuid: u16, immunity_period: u16) {
+    pub fn set_immunity_period(netuid: NetUid, immunity_period: u16) {
         ImmunityPeriod::<T>::insert(netuid, immunity_period);
         Self::deposit_event(Event::ImmunityPeriodSet(netuid, immunity_period));
     }
     /// Check if a neuron is in immunity based on the current block
-    pub fn get_neuron_is_immune(netuid: u16, uid: u16) -> bool {
+    pub fn get_neuron_is_immune(netuid: NetUid, uid: u16) -> bool {
         let registered_at = Self::get_neuron_block_at_registration(netuid, uid);
         let current_block = Self::get_current_block_as_u64();
         let immunity_period = Self::get_immunity_period(netuid);
         current_block.saturating_sub(registered_at) < u64::from(immunity_period)
     }
 
-    pub fn get_min_allowed_weights(netuid: u16) -> u16 {
+    pub fn get_min_allowed_weights(netuid: NetUid) -> u16 {
         MinAllowedWeights::<T>::get(netuid)
     }
-    pub fn set_min_allowed_weights(netuid: u16, min_allowed_weights: u16) {
+    pub fn set_min_allowed_weights(netuid: NetUid, min_allowed_weights: u16) {
         MinAllowedWeights::<T>::insert(netuid, min_allowed_weights);
         Self::deposit_event(Event::MinAllowedWeightSet(netuid, min_allowed_weights));
     }
 
-    pub fn get_max_allowed_uids(netuid: u16) -> u16 {
+    pub fn get_max_allowed_uids(netuid: NetUid) -> u16 {
         MaxAllowedUids::<T>::get(netuid)
     }
-    pub fn set_max_allowed_uids(netuid: u16, max_allowed: u16) {
+    pub fn set_max_allowed_uids(netuid: NetUid, max_allowed: u16) {
         MaxAllowedUids::<T>::insert(netuid, max_allowed);
         Self::deposit_event(Event::MaxAllowedUidsSet(netuid, max_allowed));
     }
 
-    pub fn get_kappa(netuid: u16) -> u16 {
+    pub fn get_kappa(netuid: NetUid) -> u16 {
         Kappa::<T>::get(netuid)
     }
-    pub fn set_kappa(netuid: u16, kappa: u16) {
+    pub fn set_kappa(netuid: NetUid, kappa: u16) {
         Kappa::<T>::insert(netuid, kappa);
         Self::deposit_event(Event::KappaSet(netuid, kappa));
     }
-    pub fn get_commit_reveal_weights_enabled(netuid: u16) -> bool {
+    pub fn get_commit_reveal_weights_enabled(netuid: NetUid) -> bool {
         CommitRevealWeightsEnabled::<T>::get(netuid)
     }
-    pub fn set_commit_reveal_weights_enabled(netuid: u16, enabled: bool) {
+    pub fn set_commit_reveal_weights_enabled(netuid: NetUid, enabled: bool) {
         CommitRevealWeightsEnabled::<T>::set(netuid, enabled);
         Self::deposit_event(Event::CommitRevealEnabled(netuid, enabled));
     }
 
-    pub fn get_rho(netuid: u16) -> u16 {
+    pub fn get_rho(netuid: NetUid) -> u16 {
         Rho::<T>::get(netuid)
     }
-    pub fn set_rho(netuid: u16, rho: u16) {
+    pub fn set_rho(netuid: NetUid, rho: u16) {
         Rho::<T>::insert(netuid, rho);
     }
 
-    pub fn get_activity_cutoff(netuid: u16) -> u16 {
+    pub fn get_activity_cutoff(netuid: NetUid) -> u16 {
         ActivityCutoff::<T>::get(netuid)
     }
-    pub fn set_activity_cutoff(netuid: u16, activity_cutoff: u16) {
+    pub fn set_activity_cutoff(netuid: NetUid, activity_cutoff: u16) {
         ActivityCutoff::<T>::insert(netuid, activity_cutoff);
         Self::deposit_event(Event::ActivityCutoffSet(netuid, activity_cutoff));
     }
 
     // Registration Toggle utils
-    pub fn get_network_registration_allowed(netuid: u16) -> bool {
+    pub fn get_network_registration_allowed(netuid: NetUid) -> bool {
         NetworkRegistrationAllowed::<T>::get(netuid)
     }
-    pub fn set_network_registration_allowed(netuid: u16, registration_allowed: bool) {
+    pub fn set_network_registration_allowed(netuid: NetUid, registration_allowed: bool) {
         NetworkRegistrationAllowed::<T>::insert(netuid, registration_allowed);
         Self::deposit_event(Event::RegistrationAllowed(netuid, registration_allowed));
     }
 
-    pub fn get_network_pow_registration_allowed(netuid: u16) -> bool {
+    pub fn get_network_pow_registration_allowed(netuid: NetUid) -> bool {
         NetworkPowRegistrationAllowed::<T>::get(netuid)
     }
-    pub fn set_network_pow_registration_allowed(netuid: u16, registration_allowed: bool) {
+    pub fn set_network_pow_registration_allowed(netuid: NetUid, registration_allowed: bool) {
         NetworkPowRegistrationAllowed::<T>::insert(netuid, registration_allowed);
         Self::deposit_event(Event::PowRegistrationAllowed(netuid, registration_allowed));
     }
 
-    pub fn get_target_registrations_per_interval(netuid: u16) -> u16 {
+    pub fn get_target_registrations_per_interval(netuid: NetUid) -> u16 {
         TargetRegistrationsPerInterval::<T>::get(netuid)
     }
     pub fn set_target_registrations_per_interval(
-        netuid: u16,
+        netuid: NetUid,
         target_registrations_per_interval: u16,
     ) {
         TargetRegistrationsPerInterval::<T>::insert(netuid, target_registrations_per_interval);
@@ -524,41 +528,41 @@ impl<T: Config> Pallet<T> {
         ));
     }
 
-    pub fn get_burn_as_u64(netuid: u16) -> u64 {
+    pub fn get_burn_as_u64(netuid: NetUid) -> u64 {
         Burn::<T>::get(netuid)
     }
-    pub fn set_burn(netuid: u16, burn: u64) {
+    pub fn set_burn(netuid: NetUid, burn: u64) {
         Burn::<T>::insert(netuid, burn);
     }
 
-    pub fn get_min_burn_as_u64(netuid: u16) -> u64 {
+    pub fn get_min_burn_as_u64(netuid: NetUid) -> u64 {
         MinBurn::<T>::get(netuid)
     }
-    pub fn set_min_burn(netuid: u16, min_burn: u64) {
+    pub fn set_min_burn(netuid: NetUid, min_burn: u64) {
         MinBurn::<T>::insert(netuid, min_burn);
         Self::deposit_event(Event::MinBurnSet(netuid, min_burn));
     }
 
-    pub fn get_max_burn_as_u64(netuid: u16) -> u64 {
+    pub fn get_max_burn_as_u64(netuid: NetUid) -> u64 {
         MaxBurn::<T>::get(netuid)
     }
-    pub fn set_max_burn(netuid: u16, max_burn: u64) {
+    pub fn set_max_burn(netuid: NetUid, max_burn: u64) {
         MaxBurn::<T>::insert(netuid, max_burn);
         Self::deposit_event(Event::MaxBurnSet(netuid, max_burn));
     }
 
-    pub fn get_difficulty_as_u64(netuid: u16) -> u64 {
+    pub fn get_difficulty_as_u64(netuid: NetUid) -> u64 {
         Difficulty::<T>::get(netuid)
     }
-    pub fn set_difficulty(netuid: u16, difficulty: u64) {
+    pub fn set_difficulty(netuid: NetUid, difficulty: u64) {
         Difficulty::<T>::insert(netuid, difficulty);
         Self::deposit_event(Event::DifficultySet(netuid, difficulty));
     }
 
-    pub fn get_max_allowed_validators(netuid: u16) -> u16 {
+    pub fn get_max_allowed_validators(netuid: NetUid) -> u16 {
         MaxAllowedValidators::<T>::get(netuid)
     }
-    pub fn set_max_allowed_validators(netuid: u16, max_allowed_validators: u16) {
+    pub fn set_max_allowed_validators(netuid: NetUid, max_allowed_validators: u16) {
         MaxAllowedValidators::<T>::insert(netuid, max_allowed_validators);
         Self::deposit_event(Event::MaxAllowedValidatorsSet(
             netuid,
@@ -566,34 +570,34 @@ impl<T: Config> Pallet<T> {
         ));
     }
 
-    pub fn get_bonds_moving_average(netuid: u16) -> u64 {
+    pub fn get_bonds_moving_average(netuid: NetUid) -> u64 {
         BondsMovingAverage::<T>::get(netuid)
     }
-    pub fn set_bonds_moving_average(netuid: u16, bonds_moving_average: u64) {
+    pub fn set_bonds_moving_average(netuid: NetUid, bonds_moving_average: u64) {
         BondsMovingAverage::<T>::insert(netuid, bonds_moving_average);
         Self::deposit_event(Event::BondsMovingAverageSet(netuid, bonds_moving_average));
     }
 
-    pub fn get_bonds_penalty(netuid: u16) -> u16 {
+    pub fn get_bonds_penalty(netuid: NetUid) -> u16 {
         BondsPenalty::<T>::get(netuid)
     }
-    pub fn set_bonds_penalty(netuid: u16, bonds_penalty: u16) {
+    pub fn set_bonds_penalty(netuid: NetUid, bonds_penalty: u16) {
         BondsPenalty::<T>::insert(netuid, bonds_penalty);
         Self::deposit_event(Event::BondsPenaltySet(netuid, bonds_penalty));
     }
 
-    pub fn get_bonds_reset(netuid: u16) -> bool {
+    pub fn get_bonds_reset(netuid: NetUid) -> bool {
         BondsResetOn::<T>::get(netuid)
     }
-    pub fn set_bonds_reset(netuid: u16, bonds_reset: bool) {
+    pub fn set_bonds_reset(netuid: NetUid, bonds_reset: bool) {
         BondsResetOn::<T>::insert(netuid, bonds_reset);
         Self::deposit_event(Event::BondsResetOnSet(netuid, bonds_reset));
     }
 
-    pub fn get_max_registrations_per_block(netuid: u16) -> u16 {
+    pub fn get_max_registrations_per_block(netuid: NetUid) -> u16 {
         MaxRegistrationsPerBlock::<T>::get(netuid)
     }
-    pub fn set_max_registrations_per_block(netuid: u16, max_registrations_per_block: u16) {
+    pub fn set_max_registrations_per_block(netuid: NetUid, max_registrations_per_block: u16) {
         MaxRegistrationsPerBlock::<T>::insert(netuid, max_registrations_per_block);
         Self::deposit_event(Event::MaxRegistrationsPerBlockSet(
             netuid,
@@ -601,7 +605,7 @@ impl<T: Config> Pallet<T> {
         ));
     }
 
-    pub fn get_subnet_owner(netuid: u16) -> T::AccountId {
+    pub fn get_subnet_owner(netuid: NetUid) -> T::AccountId {
         SubnetOwner::<T>::get(netuid)
     }
     pub fn get_subnet_owner_cut() -> u16 {
@@ -627,14 +631,14 @@ impl<T: Config> Pallet<T> {
         TotalIssuance::<T>::put(total_issuance);
     }
 
-    pub fn get_rao_recycled(netuid: u16) -> u64 {
+    pub fn get_rao_recycled(netuid: NetUid) -> u64 {
         RAORecycledForRegistration::<T>::get(netuid)
     }
-    pub fn set_rao_recycled(netuid: u16, rao_recycled: u64) {
+    pub fn set_rao_recycled(netuid: NetUid, rao_recycled: u64) {
         RAORecycledForRegistration::<T>::insert(netuid, rao_recycled);
         Self::deposit_event(Event::RAORecycledForRegistrationSet(netuid, rao_recycled));
     }
-    pub fn increase_rao_recycled(netuid: u16, inc_rao_recycled: u64) {
+    pub fn increase_rao_recycled(netuid: NetUid, inc_rao_recycled: u64) {
         let curr_rao_recycled = Self::get_rao_recycled(netuid);
         let rao_recycled = curr_rao_recycled.saturating_add(inc_rao_recycled);
         Self::set_rao_recycled(netuid, rao_recycled);
@@ -675,17 +679,17 @@ impl<T: Config> Pallet<T> {
         T::KeySwapCost::get()
     }
 
-    pub fn get_alpha_values(netuid: u16) -> (u16, u16) {
+    pub fn get_alpha_values(netuid: NetUid) -> (u16, u16) {
         AlphaValues::<T>::get(netuid)
     }
 
-    pub fn set_alpha_values_32(netuid: u16, low: I32F32, high: I32F32) {
+    pub fn set_alpha_values_32(netuid: NetUid, low: I32F32, high: I32F32) {
         let low = (low.saturating_mul(I32F32::saturating_from_num(u16::MAX))).to_num::<u16>();
         let high = (high.saturating_mul(I32F32::saturating_from_num(u16::MAX))).to_num::<u16>();
         AlphaValues::<T>::insert(netuid, (low, high));
     }
 
-    pub fn get_alpha_values_32(netuid: u16) -> (I32F32, I32F32) {
+    pub fn get_alpha_values_32(netuid: NetUid) -> (I32F32, I32F32) {
         let (alpha_low, alpha_high): (u16, u16) = AlphaValues::<T>::get(netuid);
         let converted_low =
             I32F32::saturating_from_num(alpha_low).safe_div(I32F32::saturating_from_num(u16::MAX));
@@ -695,27 +699,27 @@ impl<T: Config> Pallet<T> {
         (converted_low, converted_high)
     }
 
-    pub fn set_alpha_sigmoid_steepness(netuid: u16, steepness: u16) {
+    pub fn set_alpha_sigmoid_steepness(netuid: NetUid, steepness: u16) {
         AlphaSigmoidSteepness::<T>::insert(netuid, steepness);
     }
-    pub fn get_alpha_sigmoid_steepness(netuid: u16) -> I32F32 {
+    pub fn get_alpha_sigmoid_steepness(netuid: NetUid) -> I32F32 {
         let alpha = AlphaSigmoidSteepness::<T>::get(netuid);
         I32F32::saturating_from_num(alpha)
     }
 
-    pub fn set_liquid_alpha_enabled(netuid: u16, enabled: bool) {
+    pub fn set_liquid_alpha_enabled(netuid: NetUid, enabled: bool) {
         LiquidAlphaOn::<T>::set(netuid, enabled);
     }
 
-    pub fn get_liquid_alpha_enabled(netuid: u16) -> bool {
+    pub fn get_liquid_alpha_enabled(netuid: NetUid) -> bool {
         LiquidAlphaOn::<T>::get(netuid)
     }
 
-    pub fn set_yuma3_enabled(netuid: u16, enabled: bool) {
+    pub fn set_yuma3_enabled(netuid: NetUid, enabled: bool) {
         Yuma3On::<T>::set(netuid, enabled);
     }
 
-    pub fn get_yuma3_enabled(netuid: u16) -> bool {
+    pub fn get_yuma3_enabled(netuid: NetUid) -> bool {
         Yuma3On::<T>::get(netuid)
     }
 
@@ -760,13 +764,13 @@ impl<T: Config> Pallet<T> {
     ///
     /// * Update the SubnetOwnerHotkey storage.
     /// * Emits a SubnetOwnerHotkeySet event.
-    pub fn set_subnet_owner_hotkey(netuid: u16, hotkey: &T::AccountId) {
+    pub fn set_subnet_owner_hotkey(netuid: NetUid, hotkey: &T::AccountId) {
         SubnetOwnerHotkey::<T>::insert(netuid, hotkey.clone());
         Self::deposit_event(Event::SubnetOwnerHotkeySet(netuid, hotkey.clone()));
     }
 
     // Get the uid of the Owner Hotkey for a subnet.
-    pub fn get_owner_uid(netuid: u16) -> Option<u16> {
+    pub fn get_owner_uid(netuid: NetUid) -> Option<u16> {
         match SubnetOwnerHotkey::<T>::try_get(netuid) {
             Ok(owner_hotkey) => Uids::<T>::get(netuid, &owner_hotkey),
             Err(_) => None,
diff --git a/pallets/subtensor/src/utils/rate_limiting.rs b/pallets/subtensor/src/utils/rate_limiting.rs
index 7edaebc98a..eeb5b96ddb 100644
--- a/pallets/subtensor/src/utils/rate_limiting.rs
+++ b/pallets/subtensor/src/utils/rate_limiting.rs
@@ -1,3 +1,5 @@
+use subtensor_runtime_common::NetUid;
+
 use super::*;
 
 /// Enum representing different types of transactions
@@ -54,7 +56,7 @@ impl<T: Config> Pallet<T> {
         }
     }
 
-    pub fn get_rate_limit_on_subnet(tx_type: &TransactionType, netuid: u16) -> u64 {
+    pub fn get_rate_limit_on_subnet(tx_type: &TransactionType, netuid: NetUid) -> u64 {
         #[allow(clippy::match_single_binding)]
         match tx_type {
             TransactionType::SetWeightsVersionKey => (Tempo::<T>::get(netuid) as u64)
@@ -82,7 +84,7 @@ impl<T: Config> Pallet<T> {
     pub fn passes_rate_limit_on_subnet(
         tx_type: &TransactionType,
         hotkey: &T::AccountId,
-        netuid: u16,
+        netuid: NetUid,
     ) -> bool {
         let block: u64 = Self::get_current_block_as_u64();
         let limit: u64 = Self::get_rate_limit_on_subnet(tx_type, netuid);
@@ -95,14 +97,14 @@ impl<T: Config> Pallet<T> {
     pub fn get_last_transaction_block(key: &T::AccountId, tx_type: &TransactionType) -> u64 {
         match tx_type {
             TransactionType::RegisterNetwork => Self::get_network_last_lock_block(),
-            _ => Self::get_last_transaction_block_on_subnet(key, 0, tx_type),
+            _ => Self::get_last_transaction_block_on_subnet(key, NetUid::ROOT, tx_type),
         }
     }
 
     /// Get the block number of the last transaction for a specific hotkey, network, and transaction type
     pub fn get_last_transaction_block_on_subnet(
         hotkey: &T::AccountId,
-        netuid: u16,
+        netuid: NetUid,
         tx_type: &TransactionType,
     ) -> u64 {
         match tx_type {
@@ -121,14 +123,14 @@ impl<T: Config> Pallet<T> {
     pub fn set_last_transaction_block(key: &T::AccountId, tx_type: &TransactionType, block: u64) {
         match tx_type {
             TransactionType::RegisterNetwork => Self::set_network_last_lock_block(block),
-            _ => Self::set_last_transaction_block_on_subnet(key, 0, tx_type, block),
+            _ => Self::set_last_transaction_block_on_subnet(key, NetUid::ROOT, tx_type, block),
         }
     }
 
     /// Set the block number of the last transaction for a specific hotkey, network, and transaction type
     pub fn set_last_transaction_block_on_subnet(
         key: &T::AccountId,
-        netuid: u16,
+        netuid: NetUid,
         tx_type: &TransactionType,
         block: u64,
     ) {

From fab5aaf49d4b428effd34ce754f8ad282a5c471d Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Wed, 4 Jun 2025 16:13:16 -0400
Subject: [PATCH 239/418] Convert println comments into log::info. Fix clippy

---
 Cargo.lock                       |  1 +
 pallets/swap/Cargo.toml          |  1 +
 pallets/swap/src/pallet/impls.rs | 66 ++++++++++++++++----------------
 3 files changed, 34 insertions(+), 34 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 77848ae978..35f7321427 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6930,6 +6930,7 @@ dependencies = [
  "frame-benchmarking",
  "frame-support",
  "frame-system",
+ "log",
  "pallet-subtensor-swap-runtime-api",
  "parity-scale-codec",
  "safe-math",
diff --git a/pallets/swap/Cargo.toml b/pallets/swap/Cargo.toml
index df7ee91686..122dbead02 100644
--- a/pallets/swap/Cargo.toml
+++ b/pallets/swap/Cargo.toml
@@ -10,6 +10,7 @@ codec = { workspace = true }
 frame-benchmarking = { workspace = true, optional = true }
 frame-support = { workspace = true }
 frame-system = { workspace = true }
+log = { workspace = true }
 safe-math = { workspace = true }
 scale-info = { workspace = true }
 serde = { workspace = true, optional = true }
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 80f31b3f1a..0c238050ec 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -157,27 +157,26 @@ impl<T: Config> SwapStep<T> {
             recalculate_fee = true;
         }
 
-        // println!("\tAction           : {:?}", self.action);
-        // println!(
-        //     "\tCurrent Price    : {}",
-        //     self.current_sqrt_price * self.current_sqrt_price
-        // );
-        // println!(
-        //     "\tTarget Price     : {}",
-        //     self.target_sqrt_price * self.target_sqrt_price
-        // );
-        // println!(
-        //     "\tLimit Price      : {}",
-        //     self.limit_sqrt_price * self.limit_sqrt_price
-        // );
-        // println!(
-        //     "\tEdge Price       : {}",
-        //     self.edge_sqrt_price * self.edge_sqrt_price
-        // );
-        // println!(
-        //     "\t{}",
-        //     format!("Delta In         : {}", self.delta_in).yellow()
-        // );
+        log::info!("\tAction           : {:?}", self.action);
+        log::info!(
+            "\tCurrent Price    : {}",
+            self.current_sqrt_price
+                .saturating_mul(self.current_sqrt_price)
+        );
+        log::info!(
+            "\tTarget Price     : {}",
+            self.target_sqrt_price
+                .saturating_mul(self.target_sqrt_price)
+        );
+        log::info!(
+            "\tLimit Price      : {}",
+            self.limit_sqrt_price.saturating_mul(self.limit_sqrt_price)
+        );
+        log::info!(
+            "\tEdge Price       : {}",
+            self.edge_sqrt_price.saturating_mul(self.edge_sqrt_price)
+        );
+        log::info!("\tDelta In         : {}", self.delta_in);
 
         // Because on step creation we calculate fee off the total amount, we might need to recalculate it
         // in case if we hit the limit price or the edge price.
@@ -211,7 +210,7 @@ impl<T: Config> SwapStep<T> {
         // Hold the fees
         Pallet::<T>::add_fees(self.netuid, self.order_type, self.fee);
         let delta_out = Pallet::<T>::convert_deltas(self.netuid, self.order_type, self.delta_in);
-        // println!("\t{}", format!("Delta Out        : {}", delta_out).green());
+        log::info!("\tDelta Out        : {:?}", delta_out);
 
         // Get current tick
         let current_tick_index = TickIndex::current_bounded::<T>(self.netuid);
@@ -423,16 +422,16 @@ impl<T: Config> Pallet<T> {
         let mut in_acc: u64 = 0;
         let mut fee_acc: u64 = 0;
 
-        // println!("======== Start Swap ========");
-        // println!("Amount Remaining: {}", amount_remaining);
+        log::info!("======== Start Swap ========");
+        log::info!("Amount Remaining: {}", amount_remaining);
 
         // Swap one tick at a time until we reach one of the stop conditions
         while amount_remaining > 0 {
-            // println!("\nIteration: {}", iteration_counter);
-            // println!(
-            //     "\tCurrent Liquidity: {}",
-            //     CurrentLiquidity::<T>::get(netuid)
-            // );
+            log::info!("\nIteration: {}", iteration_counter);
+            log::info!(
+                "\tCurrent Liquidity: {}",
+                CurrentLiquidity::<T>::get(netuid)
+            );
 
             // Create and execute a swap step
             let mut swap_step =
@@ -462,8 +461,8 @@ impl<T: Config> Pallet<T> {
             );
         }
 
-        // println!("\nAmount Paid Out: {}", amount_paid_out);
-        // println!("======== End Swap ========");
+        log::info!("\nAmount Paid Out: {}", amount_paid_out);
+        log::info!("======== End Swap ========");
 
         let tao_reserve = T::SubnetInfo::tao_reserve(netuid.into());
         let alpha_reserve = T::SubnetInfo::alpha_reserve(netuid.into());
@@ -505,7 +504,7 @@ impl<T: Config> Pallet<T> {
                 let current_tick_price = current_tick.as_sqrt_price_bounded();
                 let is_active = ActiveTickIndexManager::<T>::tick_is_active(netuid, current_tick);
 
-                let lower_tick = if is_active && current_price > current_tick_price {
+                if is_active && current_price > current_tick_price {
                     ActiveTickIndexManager::<T>::find_closest_lower(netuid, current_tick)
                         .unwrap_or(TickIndex::MIN)
                 } else {
@@ -514,8 +513,7 @@ impl<T: Config> Pallet<T> {
                         current_tick.prev().unwrap_or(TickIndex::MIN),
                     )
                     .unwrap_or(TickIndex::MIN)
-                };
-                lower_tick
+                }
             }
         }
     }

From 3f187890d41cb724e693bc8d4158b341da1fb34e Mon Sep 17 00:00:00 2001
From: Ken Jon <kenjon@Kens-MacBook-Air.local>
Date: Thu, 5 Jun 2025 14:22:55 +0100
Subject: [PATCH 240/418] updated alpha precompile index

---
 precompiles/src/alpha.rs           | 2 +-
 precompiles/src/solidity/alpha.sol | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/precompiles/src/alpha.rs b/precompiles/src/alpha.rs
index a806f9f07b..45aab10bf7 100644
--- a/precompiles/src/alpha.rs
+++ b/precompiles/src/alpha.rs
@@ -14,7 +14,7 @@ where
     R: frame_system::Config + pallet_subtensor::Config,
     R::AccountId: From<[u8; 32]>,
 {
-    const INDEX: u64 = 2055;
+    const INDEX: u64 = 2056;
 }
 
 #[precompile_utils::precompile]
diff --git a/precompiles/src/solidity/alpha.sol b/precompiles/src/solidity/alpha.sol
index cafbaa10cb..7bb529f684 100644
--- a/precompiles/src/solidity/alpha.sol
+++ b/precompiles/src/solidity/alpha.sol
@@ -1,6 +1,6 @@
 pragma solidity ^0.8.0;
 
-address constant IALPHA_ADDRESS = 0x0000000000000000000000000000000000000807;
+address constant IALPHA_ADDRESS = 0x0000000000000000000000000000000000000808;
 
 interface IAlpha {
     /// @dev Returns the current alpha price for a subnet.

From a139021151c8de9b641ddcf2c7388f9d2ef0fa00 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Thu, 5 Jun 2025 11:27:02 -0400
Subject: [PATCH 241/418] Use prices in determine_action

---
 pallets/subtensor/src/tests/staking.rs |  4 +--
 pallets/swap/src/pallet/impls.rs       | 41 +++++++++++---------------
 2 files changed, 19 insertions(+), 26 deletions(-)

diff --git a/pallets/subtensor/src/tests/staking.rs b/pallets/subtensor/src/tests/staking.rs
index 08b0331a8d..fb12af9908 100644
--- a/pallets/subtensor/src/tests/staking.rs
+++ b/pallets/subtensor/src/tests/staking.rs
@@ -4157,8 +4157,8 @@ fn test_max_amount_remove_dynamic() {
             (10_000_000_000, 10_000_000_000, 0, Ok(u64::MAX)),
             // Low bounds (numbers are empirical, it is only important that result
             // is sharply decreasing when limit price increases)
-            (1_000, 1_000, 0, Ok(u64::MAX)),
-            (1_001, 1_001, 0, Ok(u64::MAX)),
+            (1_000, 1_000, 0, Err(Error::<Test>::ZeroMaxStakeAmount)),
+            (1_001, 1_001, 0, Ok(4_307_770_117)),
             (1_001, 1_001, 1, Ok(31_715)),
             (1_001, 1_001, 2, Ok(22_426)),
             (1_001, 1_001, 1_001, Ok(1_000)),
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 35f7f573c2..5e774e7f4c 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -34,9 +34,6 @@ struct SwapStep<T: frame_system::Config> {
     limit_sqrt_price: SqrtPrice,
     current_sqrt_price: SqrtPrice,
     edge_sqrt_price: SqrtPrice,
-    target_tick: TickIndex,
-    limit_tick: TickIndex,
-    edge_tick: TickIndex,
 
     // Result values
     action: SwapStepAction,
@@ -73,8 +70,6 @@ impl<T: Config> SwapStep<T> {
             current_sqrt_price,
             possible_delta_in,
         );
-        let target_tick = TickIndex::from_sqrt_price_bounded(target_sqrt_price);
-        let limit_tick = TickIndex::from_sqrt_price_bounded(limit_sqrt_price);
 
         Self {
             netuid,
@@ -83,9 +78,6 @@ impl<T: Config> SwapStep<T> {
             limit_sqrt_price,
             current_sqrt_price,
             edge_sqrt_price,
-            target_tick,
-            limit_tick,
-            edge_tick,
             possible_delta_in,
             current_liquidity,
             action: SwapStepAction::Stop,
@@ -102,15 +94,15 @@ impl<T: Config> SwapStep<T> {
         self.process_swap()
     }
 
-    /// Returns True if tick1 is closer to the current tick than tick2
+    /// Returns True if sq_price1 is closer to the current price than sq_price2
     /// in terms of order direction.
-    ///    For buying:  tick1 <= tick2
-    ///    For selling: tick1 >= tick2
+    ///    For buying:  sq_price1 <= sq_price2
+    ///    For selling: sq_price1 >= sq_price2
     ///
-    fn tick_is_closer(&self, tick1: &TickIndex, tick2: &TickIndex) -> bool {
+    fn price_is_closer(&self, sq_price1: &SqrtPrice, sq_price2: &SqrtPrice) -> bool {
         match self.order_type {
-            OrderType::Buy => tick1 <= tick2,
-            OrderType::Sell => tick1 >= tick2,
+            OrderType::Buy => sq_price1 <= sq_price2,
+            OrderType::Sell => sq_price1 >= sq_price2,
         }
     }
 
@@ -120,16 +112,16 @@ impl<T: Config> SwapStep<T> {
 
         // Calculate the stopping price: The price at which we either reach the limit price,
         // exchange the full amount, or reach the edge price.
-        if self.tick_is_closer(&self.target_tick, &self.limit_tick)
-            && self.tick_is_closer(&self.target_tick, &self.edge_tick)
+        if self.price_is_closer(&self.target_sqrt_price, &self.limit_sqrt_price)
+            && self.price_is_closer(&self.target_sqrt_price, &self.edge_sqrt_price)
         {
             // Case 1. target_quantity is the lowest
             // The trade completely happens within one tick, no tick crossing happens.
             self.action = SwapStepAction::Stop;
             self.final_price = self.target_sqrt_price;
             self.delta_in = self.possible_delta_in;
-        } else if self.tick_is_closer(&self.limit_tick, &self.target_tick)
-            && self.tick_is_closer(&self.limit_tick, &self.edge_tick)
+        } else if self.price_is_closer(&self.limit_sqrt_price, &self.target_sqrt_price)
+            && self.price_is_closer(&self.limit_sqrt_price, &self.edge_sqrt_price)
         {
             // Case 2. lim_quantity is the lowest
             // The trade also completely happens within one tick, no tick crossing happens.
@@ -191,12 +183,13 @@ impl<T: Config> SwapStep<T> {
         // Now correct the action if we stopped exactly at the edge no matter what was the case above
         // Because order type buy moves the price up and tick semi-open interval doesn't include its right
         // point, we cross on buys and stop on sells.
-        let natural_reason_stop_tick = if self.tick_is_closer(&self.limit_tick, &self.target_tick) {
-            self.limit_tick
-        } else {
-            self.target_tick
-        };
-        if natural_reason_stop_tick == self.edge_tick {
+        let natural_reason_stop_price =
+            if self.price_is_closer(&self.limit_sqrt_price, &self.target_sqrt_price) {
+                self.limit_sqrt_price
+            } else {
+                self.target_sqrt_price
+            };
+        if natural_reason_stop_price == self.edge_sqrt_price {
             self.action = match self.order_type {
                 OrderType::Buy => SwapStepAction::Crossing,
                 OrderType::Sell => SwapStepAction::Stop,

From 7de5d89b2f97f897d093e5744939c93faf7f861c Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Thu, 5 Jun 2025 11:35:46 -0400
Subject: [PATCH 242/418] Add #[repr(transparent)] for NetUid type

---
 common/src/lib.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/common/src/lib.rs b/common/src/lib.rs
index 0b691ce48e..a33220d47c 100644
--- a/common/src/lib.rs
+++ b/common/src/lib.rs
@@ -35,6 +35,7 @@ pub type Nonce = u32;
 pub const SMALL_TRANSFER_LIMIT: Balance = 500_000_000; // 0.5 TAO
 
 #[freeze_struct("2a62496e31bbcddc")]
+#[repr(transparent)]
 #[derive(
     Clone, Copy, Decode, Default, Encode, Eq, MaxEncodedLen, PartialEq, RuntimeDebug, TypeInfo,
 )]

From 855e0ba0f15f5edde6280c6cb40738413b11a547 Mon Sep 17 00:00:00 2001
From: Ken Jon <kenjon@Kens-MacBook-Air.local>
Date: Thu, 5 Jun 2025 16:49:15 +0100
Subject: [PATCH 243/418] updating alpha test address

---
 evm-tests/src/contracts/alpha.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/evm-tests/src/contracts/alpha.ts b/evm-tests/src/contracts/alpha.ts
index 7dfb19be6c..35baf83129 100644
--- a/evm-tests/src/contracts/alpha.ts
+++ b/evm-tests/src/contracts/alpha.ts
@@ -1,4 +1,4 @@
-export const IALPHA_ADDRESS = "0x0000000000000000000000000000000000000807";
+export const IALPHA_ADDRESS = "0x0000000000000000000000000000000000000808";
 
 export const IAlphaABI = [
   {

From c032dd804abd7cfd457a9ef9352c2518a5d359f3 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Thu, 5 Jun 2025 18:23:10 +0200
Subject: [PATCH 244/418] Fix tests compilation

---
 common/src/lib.rs                            |   3 +-
 pallets/subtensor/src/rpc_info/metagraph.rs  |   6 +-
 pallets/subtensor/src/tests/children.rs      | 158 +++++++------
 pallets/subtensor/src/tests/coinbase.rs      | 209 ++++++++--------
 pallets/subtensor/src/tests/consensus.rs     |   8 +-
 pallets/subtensor/src/tests/delegate_info.rs |  12 +-
 pallets/subtensor/src/tests/difficulty.rs    |   3 +-
 pallets/subtensor/src/tests/emission.rs      |  49 ++--
 pallets/subtensor/src/tests/epoch.rs         |  64 ++---
 pallets/subtensor/src/tests/evm.rs           |  10 +-
 pallets/subtensor/src/tests/migration.rs     |  40 ++--
 pallets/subtensor/src/tests/mock.rs          |  37 +--
 pallets/subtensor/src/tests/move_stake.rs    |  24 +-
 pallets/subtensor/src/tests/networks.rs      |  14 +-
 pallets/subtensor/src/tests/neuron_info.rs   |   9 +-
 pallets/subtensor/src/tests/recycle_alpha.rs |   8 +-
 pallets/subtensor/src/tests/registration.rs  |  83 +++----
 pallets/subtensor/src/tests/senate.rs        |  33 ++-
 pallets/subtensor/src/tests/serving.rs       |  42 ++--
 pallets/subtensor/src/tests/staking.rs       | 200 ++++++++--------
 pallets/subtensor/src/tests/staking2.rs      |  22 +-
 pallets/subtensor/src/tests/subnet.rs        |  27 ++-
 pallets/subtensor/src/tests/swap_coldkey.rs  |  58 ++---
 pallets/subtensor/src/tests/swap_hotkey.rs   |  50 ++--
 pallets/subtensor/src/tests/uids.rs          |   8 +-
 pallets/subtensor/src/tests/weights.rs       | 237 ++++++++++---------
 26 files changed, 735 insertions(+), 679 deletions(-)

diff --git a/common/src/lib.rs b/common/src/lib.rs
index ea624081a0..f289977217 100644
--- a/common/src/lib.rs
+++ b/common/src/lib.rs
@@ -34,9 +34,10 @@ pub type Nonce = u32;
 /// Transfers below SMALL_TRANSFER_LIMIT are considered small transfers
 pub const SMALL_TRANSFER_LIMIT: Balance = 500_000_000; // 0.5 TAO
 
-#[freeze_struct("45dfe0bb8f7886a9")]
+#[freeze_struct("3a97f3950116ef68")]
 #[repr(transparent)]
 #[derive(
+    Hash,
     Clone,
     Copy,
     Decode,
diff --git a/pallets/subtensor/src/rpc_info/metagraph.rs b/pallets/subtensor/src/rpc_info/metagraph.rs
index 48455c4436..62cc86465e 100644
--- a/pallets/subtensor/src/rpc_info/metagraph.rs
+++ b/pallets/subtensor/src/rpc_info/metagraph.rs
@@ -1370,7 +1370,7 @@ impl<T: Config> Pallet<T> {
 fn test_selective_metagraph() {
     let mut metagraph = SelectiveMetagraph::<u32>::default();
     let expected = SelectiveMetagraph::<u32> {
-        netuid: 0_u16.into(),
+        netuid: NetUid::ROOT.into(),
         name: None,
         symbol: None,
         identity: None,
@@ -1449,7 +1449,7 @@ fn test_selective_metagraph() {
 
     let wrong_index: usize = 100;
     let metagraph_name = SelectiveMetagraph::<u32> {
-        netuid: 0_u16.into(),
+        netuid: NetUid::ROOT.into(),
         name: Some(vec![1_u8].into_iter().map(Compact).collect()),
         ..Default::default()
     };
@@ -1464,7 +1464,7 @@ fn test_selective_metagraph() {
 
     let alph_low_index: usize = 50;
     let metagraph_alpha_low = SelectiveMetagraph::<u32> {
-        netuid: 0_u16.into(),
+        netuid: NetUid::ROOT.into(),
         alpha_low: Some(0_u16.into()),
         ..Default::default()
     };
diff --git a/pallets/subtensor/src/tests/children.rs b/pallets/subtensor/src/tests/children.rs
index 1a9016f13f..556b19c380 100644
--- a/pallets/subtensor/src/tests/children.rs
+++ b/pallets/subtensor/src/tests/children.rs
@@ -28,7 +28,7 @@ fn test_do_set_child_singular_success() {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
         let child = U256::from(3);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let proportion: u64 = 1000;
 
         // Add network and register hotkey
@@ -52,7 +52,7 @@ fn test_do_set_child_singular_network_does_not_exist() {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
         let child = U256::from(3);
-        let netuid: u16 = 999; // Non-existent network
+        let netuid = NetUid::from(999); // Non-existent network
         let proportion: u64 = 1000;
 
         // Attempt to set child
@@ -75,7 +75,7 @@ fn test_do_set_child_singular_invalid_child() {
     new_test_ext(1).execute_with(|| {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let proportion: u64 = 1000;
 
         // Add network and register hotkey
@@ -105,7 +105,7 @@ fn test_do_set_child_singular_non_associated_coldkey() {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
         let child = U256::from(3);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let proportion: u64 = 1000;
 
         // Add network and register hotkey with a different coldkey
@@ -133,7 +133,7 @@ fn test_do_set_child_singular_root_network() {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
         let child = U256::from(3);
-        let netuid: u16 = SubtensorModule::get_root_netuid(); // Root network
+        let netuid = NetUid::ROOT; // Root network
         let proportion: u64 = 1000;
 
         // Add network and register hotkey
@@ -167,7 +167,7 @@ fn test_do_set_child_singular_old_children_cleanup() {
         let hotkey = U256::from(2);
         let old_child = U256::from(3);
         let new_child = U256::from(4);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let proportion: u64 = 1000;
 
         // Add network and register hotkey
@@ -205,7 +205,7 @@ fn test_do_set_child_singular_new_children_assignment() {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
         let child = U256::from(3);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let proportion: u64 = 1000;
 
         // Add network and register hotkey
@@ -238,7 +238,7 @@ fn test_do_set_child_singular_proportion_edge_cases() {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
         let child = U256::from(3);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
 
         // Add network and register hotkey
         add_network(netuid, 13, 0);
@@ -279,7 +279,7 @@ fn test_do_set_child_singular_multiple_children() {
         let hotkey = U256::from(2);
         let child1 = U256::from(3);
         let child2 = U256::from(4);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let proportion1: u64 = 500;
         let proportion2: u64 = 500;
 
@@ -318,7 +318,7 @@ fn test_do_set_child_singular_multiple_children() {
 #[test]
 fn test_add_singular_child() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let child = U256::from(1);
         let hotkey = U256::from(1);
         let coldkey = U256::from(2);
@@ -371,7 +371,7 @@ fn test_add_singular_child() {
 #[test]
 fn test_get_stake_for_hotkey_on_subnet() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let parent = U256::from(1);
         let child = U256::from(2);
         let coldkey1 = U256::from(3);
@@ -423,7 +423,7 @@ fn test_do_revoke_child_singular_success() {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
         let child = U256::from(3);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let proportion: u64 = 1000;
         // Add network and register hotkey
         add_network(netuid, 13, 0);
@@ -452,7 +452,7 @@ fn test_do_set_empty_children_network_does_not_exist() {
     new_test_ext(1).execute_with(|| {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
-        let netuid: u16 = 999; // Non-existent network
+        let netuid = NetUid::from(999); // Non-existent network
         // Attempt to revoke child
         assert_err!(
             SubtensorModule::do_schedule_children(
@@ -477,7 +477,7 @@ fn test_do_revoke_child_singular_non_associated_coldkey() {
     new_test_ext(1).execute_with(|| {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
 
         // Add network and register hotkey with a different coldkey
         add_network(netuid, 13, 0);
@@ -508,7 +508,7 @@ fn test_do_revoke_child_singular_child_not_associated() {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
         let child = U256::from(3);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
 
         // Add network and register hotkey
         add_network(netuid, 13, 0);
@@ -539,7 +539,7 @@ fn test_do_schedule_children_multiple_success() {
         let hotkey = U256::from(2);
         let child1 = U256::from(3);
         let child2 = U256::from(4);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let proportion1: u64 = 1000;
         let proportion2: u64 = 2000;
 
@@ -579,7 +579,7 @@ fn test_do_schedule_children_multiple_network_does_not_exist() {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
         let child1 = U256::from(3);
-        let netuid: u16 = 999; // Non-existent network
+        let netuid = NetUid::from(999); // Non-existent network
         let proportion: u64 = 1000;
 
         // Attempt to set children
@@ -606,7 +606,7 @@ fn test_do_schedule_children_multiple_invalid_child() {
     new_test_ext(1).execute_with(|| {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let proportion: u64 = 1000;
 
         // Add network and register hotkey
@@ -638,7 +638,7 @@ fn test_do_schedule_children_multiple_non_associated_coldkey() {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
         let child = U256::from(3);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let proportion: u64 = 1000;
 
         // Add network and register hotkey with a different coldkey
@@ -670,7 +670,7 @@ fn test_do_schedule_children_multiple_root_network() {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
         let child = U256::from(3);
-        let netuid: u16 = SubtensorModule::get_root_netuid(); // Root network
+        let netuid = NetUid::ROOT; // Root network
         let proportion: u64 = 1000;
 
         // Add network and register hotkey
@@ -705,7 +705,7 @@ fn test_do_schedule_children_multiple_old_children_cleanup() {
         let old_child = U256::from(3);
         let new_child1 = U256::from(4);
         let new_child2 = U256::from(5);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let proportion: u64 = 1000;
 
         // Add network and register hotkey
@@ -751,7 +751,7 @@ fn test_do_schedule_children_multiple_proportion_edge_cases() {
         let hotkey = U256::from(2);
         let child1 = U256::from(3);
         let child2 = U256::from(4);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
 
         // Add network and register hotkey
         add_network(netuid, 13, 0);
@@ -792,7 +792,7 @@ fn test_do_schedule_children_multiple_overwrite_existing() {
         let child1 = U256::from(3);
         let child2 = U256::from(4);
         let child3 = U256::from(5);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let proportion: u64 = 1000;
 
         // Add network and register hotkey
@@ -850,7 +850,7 @@ fn test_childkey_take_functionality() {
     new_test_ext(1).execute_with(|| {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
 
         // Add network and register hotkey
         add_network(netuid, 13, 0);
@@ -926,7 +926,7 @@ fn test_childkey_take_rate_limiting() {
     new_test_ext(1).execute_with(|| {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
 
         // Add network and register hotkey
         add_network(netuid, 13, 0);
@@ -1030,6 +1030,7 @@ fn test_multiple_networks_childkey_take() {
 
         // Create 10 networks and set up neurons (skip network 0)
         for netuid in 1..NUM_NETWORKS {
+            let netuid = NetUid::from(netuid);
             // Add network
             add_network(netuid, 13, 0);
 
@@ -1037,7 +1038,7 @@ fn test_multiple_networks_childkey_take() {
             register_ok_neuron(netuid, hotkey, coldkey, 0);
 
             // Set a unique childkey take value for each network
-            let take_value = (netuid + 1) * 100; // Values will be 200, 300, ..., 1000
+            let take_value = u16::from(netuid.next()) * 100; // Values will be 200, 300, ..., 1000
             assert_ok!(SubtensorModule::set_childkey_take(
                 RuntimeOrigin::signed(coldkey),
                 hotkey,
@@ -1060,8 +1061,8 @@ fn test_multiple_networks_childkey_take() {
         // Verify all networks have different childkey take values
         for i in 1..NUM_NETWORKS {
             for j in (i + 1)..NUM_NETWORKS {
-                let take_i = SubtensorModule::get_childkey_take(&hotkey, i);
-                let take_j = SubtensorModule::get_childkey_take(&hotkey, j);
+                let take_i = SubtensorModule::get_childkey_take(&hotkey, i.into());
+                let take_j = SubtensorModule::get_childkey_take(&hotkey, j.into());
                 assert_ne!(
                     take_i, take_j,
                     "Childkey take values should be different for networks {} and {}",
@@ -1071,8 +1072,12 @@ fn test_multiple_networks_childkey_take() {
         }
 
         // Attempt to set childkey take again (should fail due to rate limit)
-        let result =
-            SubtensorModule::set_childkey_take(RuntimeOrigin::signed(coldkey), hotkey, 1, 1100);
+        let result = SubtensorModule::set_childkey_take(
+            RuntimeOrigin::signed(coldkey),
+            hotkey,
+            1.into(),
+            1100,
+        );
         assert_noop!(result, Error::<Test>::TxChildkeyTakeRateLimitExceeded);
 
         // Advance blocks to bypass rate limit
@@ -1082,12 +1087,12 @@ fn test_multiple_networks_childkey_take() {
         assert_ok!(SubtensorModule::set_childkey_take(
             RuntimeOrigin::signed(coldkey),
             hotkey,
-            1,
+            1.into(),
             1100
         ));
 
         // Verify the new take value
-        let new_take = SubtensorModule::get_childkey_take(&hotkey, 1);
+        let new_take = SubtensorModule::get_childkey_take(&hotkey, 1.into());
         assert_eq!(new_take, 1100, "Childkey take not updated after rate limit");
     });
 }
@@ -1103,7 +1108,7 @@ fn test_do_schedule_children_multiple_empty_list() {
     new_test_ext(1).execute_with(|| {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
 
         // Add network and register hotkey
         add_network(netuid, 13, 0);
@@ -1133,7 +1138,7 @@ fn test_do_revoke_children_multiple_success() {
         let hotkey = U256::from(2);
         let child1 = U256::from(3);
         let child2 = U256::from(4);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let proportion1: u64 = 1000;
         let proportion2: u64 = 2000;
 
@@ -1179,7 +1184,7 @@ fn test_do_revoke_children_multiple_network_does_not_exist() {
         let hotkey = U256::from(2);
         let child1 = U256::from(3);
         let child2 = U256::from(4);
-        let netuid: u16 = 999; // Non-existent network
+        let netuid = NetUid::from(999); // Non-existent network
         // Attempt to revoke children
         assert_err!(
             SubtensorModule::do_schedule_children(
@@ -1206,7 +1211,7 @@ fn test_do_revoke_children_multiple_non_associated_coldkey() {
         let hotkey = U256::from(2);
         let child1 = U256::from(3);
         let child2 = U256::from(4);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
 
         // Add network and register hotkey with a different coldkey
         add_network(netuid, 13, 0);
@@ -1241,7 +1246,7 @@ fn test_do_revoke_children_multiple_partial_revocation() {
         let child1 = U256::from(3);
         let child2 = U256::from(4);
         let child3 = U256::from(5);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let proportion: u64 = 1000;
 
         // Add network and register hotkey
@@ -1298,7 +1303,7 @@ fn test_do_revoke_children_multiple_non_existent_children() {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
         let child1 = U256::from(3);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let proportion: u64 = 1000;
 
         // Add network and register hotkey
@@ -1334,7 +1339,7 @@ fn test_do_revoke_children_multiple_empty_list() {
     new_test_ext(1).execute_with(|| {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
 
         // Add network and register hotkey
         add_network(netuid, 13, 0);
@@ -1365,7 +1370,7 @@ fn test_do_revoke_children_multiple_complex_scenario() {
         let child1 = U256::from(3);
         let child2 = U256::from(4);
         let child3 = U256::from(5);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let proportion1: u64 = 1000;
         let proportion2: u64 = 2000;
         let proportion3: u64 = 3000;
@@ -1434,7 +1439,7 @@ fn test_children_stake_values() {
     new_test_ext(1).execute_with(|| {
         let subnet_owner_coldkey = U256::from(1001);
         let subnet_owner_hotkey = U256::from(1002);
-        let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
 
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
@@ -1507,7 +1512,7 @@ fn test_children_stake_values() {
 #[test]
 fn test_get_parents_chain() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let coldkey = U256::from(1);
         let num_keys: usize = 5;
         let proportion = u64::MAX / 2; // 50% stake allocation
@@ -1651,7 +1656,7 @@ fn test_get_parents_chain() {
 #[test]
 fn test_get_stake_for_hotkey_on_subnet_basic() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let hotkey = U256::from(1);
         let coldkey = U256::from(2);
 
@@ -1676,7 +1681,7 @@ fn test_get_stake_for_hotkey_on_subnet_basic() {
 #[test]
 fn test_get_stake_for_hotkey_on_subnet_multiple_coldkeys() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let hotkey = U256::from(1);
         let coldkey1 = U256::from(2);
         let coldkey2 = U256::from(3);
@@ -1714,7 +1719,7 @@ fn test_get_stake_for_hotkey_on_subnet_single_parent_child() {
         let parent = U256::from(1);
         let child = U256::from(2);
         let coldkey = U256::from(3);
-        let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
         register_ok_neuron(netuid, parent, coldkey, 0);
         register_ok_neuron(netuid, child, coldkey, 0);
 
@@ -1751,7 +1756,7 @@ fn test_get_stake_for_hotkey_on_subnet_multiple_parents_single_child() {
     new_test_ext(1).execute_with(|| {
         let subnet_owner_coldkey = U256::from(1001);
         let subnet_owner_hotkey = U256::from(1002);
-        let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
 
         let parent1 = U256::from(1);
         let parent2 = U256::from(2);
@@ -1806,7 +1811,7 @@ fn test_get_stake_for_hotkey_on_subnet_single_parent_multiple_children() {
     new_test_ext(1).execute_with(|| {
         let subnet_owner_coldkey = U256::from(1001);
         let subnet_owner_hotkey = U256::from(1002);
-        let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
 
         let parent = U256::from(1);
         let child1 = U256::from(2);
@@ -1870,7 +1875,7 @@ fn test_get_stake_for_hotkey_on_subnet_edge_cases() {
     new_test_ext(1).execute_with(|| {
         let subnet_owner_coldkey = U256::from(1001);
         let subnet_owner_hotkey = U256::from(1002);
-        let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
 
         let parent = U256::from(1);
         let child1 = U256::from(2);
@@ -1934,7 +1939,7 @@ fn test_get_stake_for_hotkey_on_subnet_complex_hierarchy() {
     new_test_ext(1).execute_with(|| {
         let subnet_owner_coldkey = U256::from(1001);
         let subnet_owner_hotkey = U256::from(1002);
-        let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
 
         let parent = U256::from(1);
         let child1 = U256::from(2);
@@ -2128,8 +2133,8 @@ fn test_get_stake_for_hotkey_on_subnet_complex_hierarchy() {
 #[test]
 fn test_get_stake_for_hotkey_on_subnet_multiple_networks() {
     new_test_ext(1).execute_with(|| {
-        let netuid1: u16 = 1;
-        let netuid2: u16 = 2;
+        let netuid1 = NetUid::from(1);
+        let netuid2 = NetUid::from(2);
         let hotkey = U256::from(1);
         let coldkey = U256::from(2);
 
@@ -2165,7 +2170,7 @@ fn test_do_set_child_below_min_stake() {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
         let child = U256::from(3);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let proportion: u64 = 1000;
 
         // Add network and register hotkey
@@ -2200,8 +2205,8 @@ fn test_do_remove_stake_clears_pending_childkeys() {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
         let child = U256::from(3);
-        let netuid: u16 = 0;
-        let child_netuid: u16 = 1;
+        let netuid = NetUid::from(0);
+        let child_netuid = NetUid::from(1);
         let proportion: u64 = 1000;
 
         // Add network and register hotkey
@@ -2262,7 +2267,7 @@ fn test_do_set_child_cooldown_period() {
         let coldkey = U256::from(1);
         let parent = U256::from(2);
         let child = U256::from(3);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let proportion: u64 = 1000;
 
         // Add network and register hotkey
@@ -2335,7 +2340,7 @@ fn test_do_set_pending_children_runs_in_epoch() {
         let coldkey = U256::from(1);
         let parent = U256::from(2);
         let child = U256::from(3);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let proportion: u64 = 1000;
 
         // Add network and register hotkey
@@ -2400,12 +2405,11 @@ fn test_revoke_child_no_min_stake_check() {
         let coldkey = U256::from(1);
         let parent = U256::from(2);
         let child = U256::from(3);
-        let root: u16 = 0;
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let proportion: u64 = 1000;
 
         // Add network and register hotkey
-        add_network(root, 13, 0);
+        add_network(NetUid::ROOT, 13, 0);
         add_network(netuid, 13, 0);
         register_ok_neuron(netuid, parent, coldkey, 0);
 
@@ -2414,7 +2418,7 @@ fn test_revoke_child_no_min_stake_check() {
         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
             &parent,
             &coldkey,
-            root,
+            NetUid::ROOT,
             StakeThreshold::<Test>::get(),
         );
 
@@ -2434,7 +2438,7 @@ fn test_revoke_child_no_min_stake_check() {
         SubtensorModule::decrease_stake_for_hotkey_and_coldkey_on_subnet(
             &parent,
             &coldkey,
-            root,
+            NetUid::ROOT,
             StakeThreshold::<Test>::get(),
         );
 
@@ -2474,7 +2478,7 @@ fn test_do_set_child_registration_disabled() {
         let coldkey = U256::from(1);
         let parent = U256::from(2);
         let child = U256::from(3);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let proportion: u64 = 1000;
 
         // Add network and register hotkey
@@ -2532,7 +2536,7 @@ fn test_set_children_rate_limit_fail_then_succeed() {
         let hotkey = U256::from(2);
         let child = U256::from(3);
         let child2 = U256::from(4);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo = 13;
 
         // Add network and register hotkey
@@ -2587,7 +2591,7 @@ fn test_childkey_set_weights_single_parent() {
     new_test_ext(1).execute_with(|| {
         let subnet_owner_coldkey = U256::from(1001);
         let subnet_owner_hotkey = U256::from(1002);
-        let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
         Tempo::<Test>::insert(netuid, 1);
 
         // Define hotkeys
@@ -2696,7 +2700,7 @@ fn test_set_weights_no_parent() {
     new_test_ext(1).execute_with(|| {
         let subnet_owner_coldkey = U256::from(1001);
         let subnet_owner_hotkey = U256::from(1002);
-        let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
 
         let hotkey: U256 = U256::from(2);
         let spare_hk: U256 = U256::from(3);
@@ -2806,7 +2810,7 @@ fn test_childkey_take_drain() {
             let miner_coldkey = U256::from(5);
             let miner_hotkey = U256::from(6);
             let nominator = U256::from(7);
-            let netuid: u16 = 1;
+            let netuid = NetUid::from(1);
             let subnet_tempo = 10;
             let stake = 100_000_000_000;
             let proportion: u64 = u64::MAX / 2;
@@ -2922,7 +2926,7 @@ fn test_parent_child_chain_emission() {
     new_test_ext(1).execute_with(|| {
         let subnet_owner_coldkey = U256::from(1001);
         let subnet_owner_hotkey = U256::from(1002);
-        let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
         Tempo::<Test>::insert(netuid, 1);
 
         // Setup large LPs to prevent slippage
@@ -3131,7 +3135,7 @@ fn test_parent_child_chain_emission() {
 #[test]
 fn test_parent_child_chain_epoch() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         add_network(netuid, 1, 0);
         // Set owner cut to 0
         SubtensorModule::set_subnet_owner_cut(0_u16);
@@ -3262,7 +3266,7 @@ fn test_parent_child_chain_epoch() {
 #[test]
 fn test_dividend_distribution_with_children() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         add_network(netuid, 1, 0);
         // Set owner cut to 0
         SubtensorModule::set_subnet_owner_cut(0_u16);
@@ -3487,7 +3491,7 @@ fn test_dividend_distribution_with_children() {
 #[test]
 fn test_dynamic_parent_child_relationships() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         add_network(netuid, 1, 0);
 
         // Define hotkeys and coldkeys
@@ -3742,7 +3746,7 @@ fn test_do_set_child_as_sn_owner_not_enough_stake() {
 
         let proportion: u64 = 1000;
 
-        let netuid: u16 = add_dynamic_network(&sn_owner_hotkey, &coldkey);
+        let netuid = add_dynamic_network(&sn_owner_hotkey, &coldkey);
         register_ok_neuron(netuid, child_hotkey, child_coldkey, 0);
 
         // Verify stake of sn_owner_hotkey is NOT enough
@@ -3787,7 +3791,7 @@ fn test_do_set_child_as_sn_owner_not_enough_stake() {
 #[test]
 fn test_dividend_distribution_with_children_same_coldkey_owner() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         add_network(netuid, 1, 0);
         // Set SN owner cut to 0
         SubtensorModule::set_subnet_owner_cut(0_u16);
@@ -3963,7 +3967,7 @@ fn test_pending_cooldown_one_day() {
         let hotkey = U256::from(2);
         let child1 = U256::from(3);
         let child2 = U256::from(4);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let proportion1: u64 = 1000;
         let proportion2: u64 = 2000;
 
@@ -3995,7 +3999,7 @@ fn test_do_set_childkey_take_success() {
         // Setup
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let take = 5000;
 
         // Add network and register hotkey
@@ -4024,7 +4028,7 @@ fn test_do_set_childkey_take_non_associated_coldkey() {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
         let hotkey2 = U256::from(3);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let take = 5000;
 
         // Add network and register hotkey
@@ -4045,7 +4049,7 @@ fn test_do_set_childkey_take_invalid_take_value() {
         // Setup
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let take = SubtensorModule::get_max_childkey_take() + 1;
 
         // Add network and register hotkey
@@ -4066,7 +4070,7 @@ fn test_do_set_childkey_take_rate_limit_exceeded() {
         // Setup
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let initial_take = 3000;
         let higher_take = 5000;
         let lower_take = 1000;
diff --git a/pallets/subtensor/src/tests/coinbase.rs b/pallets/subtensor/src/tests/coinbase.rs
index 1345f36b7d..338b8ad9a2 100644
--- a/pallets/subtensor/src/tests/coinbase.rs
+++ b/pallets/subtensor/src/tests/coinbase.rs
@@ -48,10 +48,10 @@ fn test_dynamic_function_various_values() {
             for &tao_in in tao_in_values.iter() {
                 for &alpha_emission in alpha_emission_values.iter() {
                     // Set the price.
-                    SubnetMechanism::<Test>::insert(1, 1);
-                    SubnetTAO::<Test>::insert(1, (price * 1_000_000_000.0) as u64);
-                    SubnetAlphaIn::<Test>::insert(1, 1_000_000_000);
-                    let (tao_in_emission, alpha_in_emission, alpha_out_emission) = SubtensorModule::get_dynamic_tao_emission( 1, tao_in, alpha_emission);
+                    SubnetMechanism::<Test>::insert(NetUid::from(1), 1);
+                    SubnetTAO::<Test>::insert(NetUid::from(1), (price * 1_000_000_000.0) as u64);
+                    SubnetAlphaIn::<Test>::insert(NetUid::from(1), 1_000_000_000);
+                    let (tao_in_emission, alpha_in_emission, alpha_out_emission) = SubtensorModule::get_dynamic_tao_emission(1.into(), tao_in, alpha_emission);
                     assert!(tao_in_emission <= tao_in, "tao_in_emission is greater than tao_in");
                     assert!(alpha_in_emission <= alpha_emission, "alpha_in_emission is greater than alpha_emission");
                     assert!(alpha_out_emission <= 2 * alpha_emission, "alpha_out_emission is greater than 2 * alpha_emission");
@@ -86,7 +86,7 @@ fn test_coinbase_basecase() {
 #[test]
 fn test_coinbase_tao_issuance_base() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let emission: u64 = 1_234_567;
         add_network(netuid, 1, 0);
         assert_eq!(SubnetTAO::<Test>::get(netuid), 0);
@@ -101,7 +101,7 @@ fn test_coinbase_tao_issuance_base() {
 #[test]
 fn test_coinbase_tao_issuance_base_low() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let emission: u64 = 1;
         add_network(netuid, 1, 0);
         assert_eq!(SubnetTAO::<Test>::get(netuid), 0);
@@ -122,9 +122,9 @@ fn test_coinbase_tao_issuance_base_low() {
 #[test]
 fn test_coinbase_tao_issuance_multiple() {
     new_test_ext(1).execute_with(|| {
-        let netuid1: u16 = 1;
-        let netuid2: u16 = 2;
-        let netuid3: u16 = 3;
+        let netuid1 = NetUid::from(1);
+        let netuid2 = NetUid::from(2);
+        let netuid3 = NetUid::from(3);
         let emission: u64 = 3_333_333;
         add_network(netuid1, 1, 0);
         add_network(netuid2, 1, 0);
@@ -150,8 +150,8 @@ fn test_coinbase_tao_issuance_multiple() {
 #[test]
 fn test_coinbase_tao_issuance_different_prices() {
     new_test_ext(1).execute_with(|| {
-        let netuid1: u16 = 1;
-        let netuid2: u16 = 2;
+        let netuid1 = NetUid::from(1);
+        let netuid2 = NetUid::from(2);
         let emission: u64 = 100_000_000;
         add_network(netuid1, 1, 0);
         add_network(netuid2, 1, 0);
@@ -183,7 +183,7 @@ fn test_coinbase_tao_issuance_different_prices() {
 #[test]
 fn test_coinbase_moving_prices() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         add_network(netuid, 1, 0);
         // Set price to 1.0
         SubnetTAO::<Test>::insert(netuid, 1_000_000);
@@ -239,7 +239,7 @@ fn test_coinbase_moving_prices() {
 #[test]
 fn test_update_moving_price_initial() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         add_network(netuid, 1, 0);
         // Set current price to 1.0
         SubnetTAO::<Test>::insert(netuid, 1_000_000);
@@ -264,7 +264,7 @@ fn test_update_moving_price_initial() {
 #[test]
 fn test_update_moving_price_after_time() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         add_network(netuid, 1, 0);
         // Set current price to 1.0
         SubnetTAO::<Test>::insert(netuid, 1_000_000);
@@ -293,8 +293,8 @@ fn test_update_moving_price_after_time() {
 #[test]
 fn test_coinbase_alpha_issuance_base() {
     new_test_ext(1).execute_with(|| {
-        let netuid1: u16 = 1;
-        let netuid2: u16 = 2;
+        let netuid1 = NetUid::from(1);
+        let netuid2 = NetUid::from(2);
         let emission: u64 = 1_000_000;
         add_network(netuid1, 1, 0);
         add_network(netuid2, 1, 0);
@@ -322,8 +322,8 @@ fn test_coinbase_alpha_issuance_base() {
 #[test]
 fn test_coinbase_alpha_issuance_different() {
     new_test_ext(1).execute_with(|| {
-        let netuid1: u16 = 1;
-        let netuid2: u16 = 2;
+        let netuid1 = NetUid::from(1);
+        let netuid2 = NetUid::from(2);
         let emission: u64 = 1_000_000;
         add_network(netuid1, 1, 0);
         add_network(netuid2, 1, 0);
@@ -357,8 +357,8 @@ fn test_coinbase_alpha_issuance_different() {
 #[test]
 fn test_coinbase_alpha_issuance_with_cap_trigger() {
     new_test_ext(1).execute_with(|| {
-        let netuid1: u16 = 1;
-        let netuid2: u16 = 2;
+        let netuid1 = NetUid::from(1);
+        let netuid2 = NetUid::from(2);
         let emission: u64 = 1_000_000;
         add_network(netuid1, 1, 0);
         add_network(netuid2, 1, 0);
@@ -398,8 +398,8 @@ fn test_coinbase_alpha_issuance_with_cap_trigger() {
 #[test]
 fn test_coinbase_alpha_issuance_with_cap_trigger_and_block_emission() {
     new_test_ext(1).execute_with(|| {
-        let netuid1: u16 = 1;
-        let netuid2: u16 = 2;
+        let netuid1 = NetUid::from(1);
+        let netuid2 = NetUid::from(2);
         let emission: u64 = 1_000_000;
         add_network(netuid1, 1, 0);
         add_network(netuid2, 1, 0);
@@ -437,7 +437,7 @@ fn test_coinbase_alpha_issuance_with_cap_trigger_and_block_emission() {
 #[test]
 fn test_owner_cut_base() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         add_network(netuid, 1, 0);
         SubtensorModule::set_tempo(netuid, 10000); // Large number (dont drain)
         SubtensorModule::set_subnet_owner_cut(0);
@@ -453,12 +453,12 @@ fn test_owner_cut_base() {
 #[test]
 fn test_pending_swapped() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let emission: u64 = 1_000_000;
         add_network(netuid, 1, 0);
         SubtensorModule::run_coinbase(U96F32::from_num(0));
         assert_eq!(PendingAlphaSwapped::<Test>::get(netuid), 0); // Zero tao weight and no root.
-        SubnetTAO::<Test>::insert(0, 1_000_000_000); // Add root weight.
+        SubnetTAO::<Test>::insert(NetUid::ROOT, 1_000_000_000); // Add root weight.
         SubtensorModule::run_coinbase(U96F32::from_num(0));
         assert_eq!(PendingAlphaSwapped::<Test>::get(netuid), 0); // Zero tao weight with 1 root.
         SubtensorModule::set_tempo(netuid, 10000); // Large number (dont drain)
@@ -476,14 +476,14 @@ fn test_pending_swapped() {
 // SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor --lib -- tests::coinbase::test_drain_base --exact --show-output --nocapture
 #[test]
 fn test_drain_base() {
-    new_test_ext(1).execute_with(|| SubtensorModule::drain_pending_emission(0, 0, 0, 0, 0));
+    new_test_ext(1).execute_with(|| SubtensorModule::drain_pending_emission(0.into(), 0, 0, 0, 0));
 }
 
 // SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor --lib -- tests::coinbase::test_drain_base_with_subnet --exact --show-output --nocapture
 #[test]
 fn test_drain_base_with_subnet() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         add_network(netuid, 1, 0);
         SubtensorModule::drain_pending_emission(netuid, 0, 0, 0, 0)
     });
@@ -493,7 +493,7 @@ fn test_drain_base_with_subnet() {
 #[test]
 fn test_drain_base_with_subnet_with_single_staker_not_registered() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         add_network(netuid, 1, 0);
         let hotkey = U256::from(1);
         let coldkey = U256::from(2);
@@ -516,7 +516,7 @@ fn test_drain_base_with_subnet_with_single_staker_not_registered() {
 #[test]
 fn test_drain_base_with_subnet_with_single_staker_registered() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         add_network(netuid, 1, 0);
         let hotkey = U256::from(1);
         let coldkey = U256::from(2);
@@ -540,8 +540,7 @@ fn test_drain_base_with_subnet_with_single_staker_registered() {
 #[test]
 fn test_drain_base_with_subnet_with_single_staker_registered_root_weight() {
     new_test_ext(1).execute_with(|| {
-        let root: u16 = 0;
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         add_network(netuid, 1, 0);
         let hotkey = U256::from(1);
         let coldkey = U256::from(2);
@@ -553,7 +552,7 @@ fn test_drain_base_with_subnet_with_single_staker_registered_root_weight() {
         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
             &hotkey,
             &coldkey,
-            root,
+            NetUid::ROOT,
             stake_before,
         );
         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
@@ -567,8 +566,11 @@ fn test_drain_base_with_subnet_with_single_staker_registered_root_weight() {
         SubtensorModule::drain_pending_emission(netuid, pending_alpha, pending_tao, 0, 0);
         let stake_after =
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid);
-        let root_after =
-            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, root);
+        let root_after = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+            &hotkey,
+            &coldkey,
+            NetUid::ROOT,
+        );
         close(stake_before + pending_alpha, stake_after, 10); // Registered gets all alpha emission.
         close(stake_before + pending_tao, root_after, 10); // Registered gets all tao emission
     });
@@ -578,7 +580,7 @@ fn test_drain_base_with_subnet_with_single_staker_registered_root_weight() {
 #[test]
 fn test_drain_base_with_subnet_with_two_stakers_registered() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         add_network(netuid, 1, 0);
         let hotkey1 = U256::from(1);
         let hotkey2 = U256::from(2);
@@ -613,8 +615,7 @@ fn test_drain_base_with_subnet_with_two_stakers_registered() {
 #[test]
 fn test_drain_base_with_subnet_with_two_stakers_registered_and_root() {
     new_test_ext(1).execute_with(|| {
-        let root: u16 = 0;
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         add_network(netuid, 1, 0);
         let hotkey1 = U256::from(1);
         let hotkey2 = U256::from(2);
@@ -634,7 +635,7 @@ fn test_drain_base_with_subnet_with_two_stakers_registered_and_root() {
         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
             &hotkey1,
             &coldkey,
-            root,
+            NetUid::ROOT,
             stake_before,
         );
         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
@@ -646,7 +647,7 @@ fn test_drain_base_with_subnet_with_two_stakers_registered_and_root() {
         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
             &hotkey2,
             &coldkey,
-            root,
+            NetUid::ROOT,
             stake_before,
         );
         let pending_tao: u64 = 1_000_000_000;
@@ -654,12 +655,18 @@ fn test_drain_base_with_subnet_with_two_stakers_registered_and_root() {
         SubtensorModule::drain_pending_emission(netuid, pending_alpha, pending_tao, 0, 0);
         let stake_after1 =
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey1, &coldkey, netuid);
-        let root_after1 =
-            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey1, &coldkey, root);
+        let root_after1 = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+            &hotkey1,
+            &coldkey,
+            NetUid::ROOT,
+        );
         let stake_after2 =
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey2, &coldkey, netuid);
-        let root_after2 =
-            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey2, &coldkey, root);
+        let root_after2 = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+            &hotkey2,
+            &coldkey,
+            NetUid::ROOT,
+        );
         close(stake_before + pending_alpha / 2, stake_after1, 10); // Registered gets 1/2 emission
         close(stake_before + pending_alpha / 2, stake_after2, 10); // Registered gets 1/2 emission.
         close(stake_before + pending_tao / 2, root_after1, 10); // Registered gets 1/2 tao emission
@@ -671,8 +678,7 @@ fn test_drain_base_with_subnet_with_two_stakers_registered_and_root() {
 #[test]
 fn test_drain_base_with_subnet_with_two_stakers_registered_and_root_different_amounts() {
     new_test_ext(1).execute_with(|| {
-        let root: u16 = 0;
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         add_network(netuid, 1, 0);
         let hotkey1 = U256::from(1);
         let hotkey2 = U256::from(2);
@@ -692,7 +698,7 @@ fn test_drain_base_with_subnet_with_two_stakers_registered_and_root_different_am
         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
             &hotkey1,
             &coldkey,
-            root,
+            NetUid::ROOT,
             2 * stake_before, // Hotkey 1 has twice as much root weight.
         );
         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
@@ -704,7 +710,7 @@ fn test_drain_base_with_subnet_with_two_stakers_registered_and_root_different_am
         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
             &hotkey2,
             &coldkey,
-            root,
+            NetUid::ROOT,
             stake_before,
         );
         let pending_tao: u64 = 1_000_000_000;
@@ -712,12 +718,18 @@ fn test_drain_base_with_subnet_with_two_stakers_registered_and_root_different_am
         SubtensorModule::drain_pending_emission(netuid, pending_alpha, pending_tao, 0, 0);
         let stake_after1 =
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey1, &coldkey, netuid);
-        let root_after1 =
-            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey1, &coldkey, root);
+        let root_after1 = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+            &hotkey1,
+            &coldkey,
+            NetUid::ROOT,
+        );
         let stake_after2 =
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey2, &coldkey, netuid);
-        let root_after2 =
-            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey2, &coldkey, root);
+        let root_after2 = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+            &hotkey2,
+            &coldkey,
+            NetUid::ROOT,
+        );
         let expected_stake = I96F32::from_num(stake_before)
             + (I96F32::from_num(pending_alpha) * I96F32::from_num(1.0 / 2.0));
         assert_abs_diff_eq!(expected_stake.to_num::<u64>(), stake_after1, epsilon = 10); // Registered gets 50% of alpha emission
@@ -738,8 +750,7 @@ fn test_drain_base_with_subnet_with_two_stakers_registered_and_root_different_am
 fn test_drain_base_with_subnet_with_two_stakers_registered_and_root_different_amounts_half_tao_weight()
  {
     new_test_ext(1).execute_with(|| {
-        let root: u16 = 0;
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         add_network(netuid, 1, 0);
         let hotkey1 = U256::from(1);
         let hotkey2 = U256::from(2);
@@ -759,7 +770,7 @@ fn test_drain_base_with_subnet_with_two_stakers_registered_and_root_different_am
         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
             &hotkey1,
             &coldkey,
-            root,
+            NetUid::ROOT,
             2 * stake_before, // Hotkey 1 has twice as much root weight.
         );
         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
@@ -771,7 +782,7 @@ fn test_drain_base_with_subnet_with_two_stakers_registered_and_root_different_am
         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
             &hotkey2,
             &coldkey,
-            root,
+            NetUid::ROOT,
             stake_before,
         );
         let pending_tao: u64 = 1_000_000_000;
@@ -779,12 +790,18 @@ fn test_drain_base_with_subnet_with_two_stakers_registered_and_root_different_am
         SubtensorModule::drain_pending_emission(netuid, pending_alpha, pending_tao, 0, 0);
         let stake_after1 =
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey1, &coldkey, netuid);
-        let root_after1 =
-            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey1, &coldkey, root);
+        let root_after1 = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+            &hotkey1,
+            &coldkey,
+            NetUid::ROOT,
+        );
         let stake_after2 =
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey2, &coldkey, netuid);
-        let root_after2 =
-            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey2, &coldkey, root);
+        let root_after2 = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+            &hotkey2,
+            &coldkey,
+            NetUid::ROOT,
+        );
         let expected_stake = I96F32::from_num(stake_before)
             + I96F32::from_num(pending_alpha) * I96F32::from_num(1.0 / 2.0);
         assert_abs_diff_eq!(expected_stake.to_num::<u64>(), stake_after1, epsilon = 10);
@@ -806,7 +823,7 @@ fn test_drain_base_with_subnet_with_two_stakers_registered_and_root_different_am
 #[test]
 fn test_drain_alpha_childkey_parentkey() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         add_network(netuid, 1, 0);
         let parent = U256::from(1);
         let child = U256::from(2);
@@ -848,9 +865,8 @@ fn test_drain_alpha_childkey_parentkey() {
 fn test_get_root_children() {
     new_test_ext(1).execute_with(|| {
         // Init netuid 1
-        let root: u16 = 0;
-        let alpha: u16 = 1;
-        add_network(root, 1, 0);
+        let alpha = NetUid::from(1);
+        add_network(NetUid::ROOT, 1, 0);
         add_network(alpha, 1, 0);
 
         // Set TAO weight to 1.
@@ -878,14 +894,14 @@ fn test_get_root_children() {
         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
             &alice,
             &cold,
-            root,
+            NetUid::ROOT,
             alice_root_stake,
         );
         let bob_root_stake: u64 = 1_000_000_000;
         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
             &bob,
             &cold,
-            root,
+            NetUid::ROOT,
             alice_root_stake,
         );
 
@@ -906,16 +922,16 @@ fn test_get_root_children() {
         );
 
         // Set Bob as 100% child of Alice on root.
-        // mock_set_children_no_epochs( root, &alice, &[(u64::MAX, bob)]);
+        // mock_set_children_no_epochs( NetUid::ROOT, &alice, &[(u64::MAX, bob)]);
         mock_set_children_no_epochs(alpha, &alice, &[(u64::MAX, bob)]);
 
         // Assert Alice and Bob stake on root and netuid
         assert_eq!(
-            SubtensorModule::get_stake_for_hotkey_on_subnet(&alice, root),
+            SubtensorModule::get_stake_for_hotkey_on_subnet(&alice, NetUid::ROOT),
             alice_root_stake
         );
         assert_eq!(
-            SubtensorModule::get_stake_for_hotkey_on_subnet(&bob, root),
+            SubtensorModule::get_stake_for_hotkey_on_subnet(&bob, NetUid::ROOT),
             bob_root_stake
         );
         assert_eq!(
@@ -929,7 +945,7 @@ fn test_get_root_children() {
 
         // Assert Alice and Bob inherited stakes
         assert_eq!(
-            SubtensorModule::get_inherited_for_hotkey_on_subnet(&alice, root),
+            SubtensorModule::get_inherited_for_hotkey_on_subnet(&alice, NetUid::ROOT),
             alice_root_stake
         );
         assert_eq!(
@@ -937,7 +953,7 @@ fn test_get_root_children() {
             0
         );
         assert_eq!(
-            SubtensorModule::get_inherited_for_hotkey_on_subnet(&bob, root),
+            SubtensorModule::get_inherited_for_hotkey_on_subnet(&bob, NetUid::ROOT),
             bob_root_stake
         );
         assert_eq!(
@@ -972,9 +988,8 @@ fn test_get_root_children() {
 fn test_get_root_children_drain() {
     new_test_ext(1).execute_with(|| {
         // Init netuid 1
-        let root: u16 = 0;
-        let alpha: u16 = 1;
-        add_network(root, 1, 0);
+        let alpha = NetUid::from(1);
+        add_network(NetUid::ROOT, 1, 0);
         add_network(alpha, 1, 0);
         // Set TAO weight to 1.
         SubtensorModule::set_tao_weight(u64::MAX); // Set TAO weight to 1.
@@ -999,14 +1014,14 @@ fn test_get_root_children_drain() {
         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
             &alice,
             &cold_alice,
-            root,
+            NetUid::ROOT,
             alice_root_stake,
         );
         let bob_root_stake: u64 = 1_000_000_000;
         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
             &bob,
             &cold_bob,
-            root,
+            NetUid::ROOT,
             alice_root_stake,
         );
         // Add stake for Alice and Bob on netuid.
@@ -1062,11 +1077,11 @@ fn test_get_root_children_drain() {
 
         // Alice and Bob both made half of the dividends.
         assert_eq!(
-            SubtensorModule::get_stake_for_hotkey_on_subnet(&alice, root),
+            SubtensorModule::get_stake_for_hotkey_on_subnet(&alice, NetUid::ROOT),
             alice_root_stake + pending_root / 2
         );
         assert_eq!(
-            SubtensorModule::get_stake_for_hotkey_on_subnet(&bob, root),
+            SubtensorModule::get_stake_for_hotkey_on_subnet(&bob, NetUid::ROOT),
             bob_root_stake + pending_root / 2
         );
 
@@ -1096,9 +1111,8 @@ fn test_get_root_children_drain() {
 fn test_get_root_children_drain_half_proportion() {
     new_test_ext(1).execute_with(|| {
         // Init netuid 1
-        let root: u16 = 0;
-        let alpha: u16 = 1;
-        add_network(root, 1, 0);
+        let alpha = NetUid::from(1);
+        add_network(NetUid::ROOT, 1, 0);
         add_network(alpha, 1, 0);
         // Set TAO weight to 1.
         SubtensorModule::set_tao_weight(u64::MAX); // Set TAO weight to 1.
@@ -1123,14 +1137,14 @@ fn test_get_root_children_drain_half_proportion() {
         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
             &alice,
             &cold_alice,
-            root,
+            NetUid::ROOT,
             alice_root_stake,
         );
         let bob_root_stake: u64 = 1_000_000_000;
         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
             &bob,
             &cold_bob,
-            root,
+            NetUid::ROOT,
             alice_root_stake,
         );
         // Add stake for Alice and Bob on netuid.
@@ -1179,9 +1193,8 @@ fn test_get_root_children_drain_half_proportion() {
 fn test_get_root_children_drain_with_take() {
     new_test_ext(1).execute_with(|| {
         // Init netuid 1
-        let root: u16 = 0;
-        let alpha: u16 = 1;
-        add_network(root, 1, 0);
+        let alpha = NetUid::from(1);
+        add_network(NetUid::ROOT, 1, 0);
         add_network(alpha, 1, 0);
         // Set TAO weight to 1.
         SubtensorModule::set_tao_weight(u64::MAX); // Set TAO weight to 1.
@@ -1206,14 +1219,14 @@ fn test_get_root_children_drain_with_take() {
         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
             &alice,
             &cold_alice,
-            root,
+            NetUid::ROOT,
             alice_root_stake,
         );
         let bob_root_stake: u64 = 1_000_000_000;
         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
             &bob,
             &cold_bob,
-            root,
+            NetUid::ROOT,
             alice_root_stake,
         );
         // Add stake for Alice and Bob on netuid.
@@ -1257,9 +1270,8 @@ fn test_get_root_children_drain_with_take() {
 fn test_get_root_children_drain_with_half_take() {
     new_test_ext(1).execute_with(|| {
         // Init netuid 1
-        let root: u16 = 0;
-        let alpha: u16 = 1;
-        add_network(root, 1, 0);
+        let alpha = NetUid::from(1);
+        add_network(NetUid::ROOT, 1, 0);
         add_network(alpha, 1, 0);
         // Set TAO weight to 1.
         SubtensorModule::set_tao_weight(u64::MAX); // Set TAO weight to 1.
@@ -1284,14 +1296,14 @@ fn test_get_root_children_drain_with_half_take() {
         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
             &alice,
             &cold_alice,
-            root,
+            NetUid::ROOT,
             alice_root_stake,
         );
         let bob_root_stake: u64 = 1_000_000_000;
         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
             &bob,
             &cold_bob,
-            root,
+            NetUid::ROOT,
             alice_root_stake,
         );
         // Add stake for Alice and Bob on netuid.
@@ -1339,9 +1351,8 @@ fn test_get_root_children_drain_with_half_take() {
 // fn test_get_root_children_with_weights() {
 //     new_test_ext(1).execute_with(|| {
 //         // Init netuid 1
-//         let root: u16 = 0;
-//         let alpha: u16 = 1;
-//         add_network(root, 1, 0);
+//         let alpha = NetUid::from(1);
+//         add_network(NetUid::ROOT, 1, 0);
 //         add_network(alpha, 1, 0);
 //         // Set TAO weight to 1.
 //         SubtensorModule::set_tao_weight(u64::MAX); // Set TAO weight to 1.
@@ -1365,14 +1376,14 @@ fn test_get_root_children_drain_with_half_take() {
 //         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
 //             &alice,
 //             &cold,
-//             root,
+//             NetUid::ROOT,
 //             alice_root_stake,
 //         );
 //         let bob_root_stake: u64 = 1_000_000_000;
 //         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
 //             &bob,
 //             &cold,
-//             root,
+//             NetUid::ROOT,
 //             alice_root_stake,
 //         );
 //         // Add stake for Alice and Bob on netuid.
@@ -1955,7 +1966,7 @@ fn test_drain_pending_emission_zero_emission() {
 #[test]
 fn test_run_coinbase_not_started() {
     new_test_ext(1).execute_with(|| {
-        let netuid = 1;
+        let netuid = NetUid::from(1);
         let tempo = 2;
 
         let sn_owner_hk = U256::from(7);
@@ -2037,7 +2048,7 @@ fn test_run_coinbase_not_started() {
 #[test]
 fn test_run_coinbase_not_started_start_after() {
     new_test_ext(1).execute_with(|| {
-        let netuid = 1;
+        let netuid = NetUid::from(1);
         let tempo = 2;
 
         let sn_owner_hk = U256::from(7);
diff --git a/pallets/subtensor/src/tests/consensus.rs b/pallets/subtensor/src/tests/consensus.rs
index e1db49203e..b11cd44e06 100644
--- a/pallets/subtensor/src/tests/consensus.rs
+++ b/pallets/subtensor/src/tests/consensus.rs
@@ -118,7 +118,7 @@ fn distribute_nodes(
 }
 
 #[allow(dead_code)]
-fn uid_stats(netuid: u16, uid: u16) {
+fn uid_stats(netuid: NetUid, uid: u16) {
     log::info!(
         "stake: {:?}",
         SubtensorModule::get_total_stake_for_hotkey(&(U256::from(uid)))
@@ -148,7 +148,7 @@ fn uid_stats(netuid: u16, uid: u16) {
 
 #[allow(clippy::too_many_arguments)]
 fn init_run_epochs(
-    netuid: u16,
+    netuid: NetUid,
     n: u16,
     validators: &[u16],
     servers: &[u16],
@@ -401,7 +401,7 @@ fn split_graph(
 // Test consensus guarantees with an epoch on a graph with 4096 nodes, of which the first 128 are validators, the graph is split into a major and minor set, each setting specific weight on itself and the complement on the other. Asserts that the major emission ratio >= major stake ratio.
 // #[test]
 // fn test_consensus_guarantees() {
-//     let netuid: u16 = 0;
+//     let netuid = NetUid::from(0);
 //     let network_n: u16 = 512;
 //     let validators_n: u16 = 64;
 //     let epochs: u16 = 1;
@@ -486,7 +486,7 @@ fn split_graph(
 #[test]
 #[ignore] // Not an automated test!
 fn map_consensus_guarantees() {
-    let netuid: u16 = 1;
+    let netuid = NetUid::from(1);
     let network_n: u16 = 512;
     let validators_n: u16 = 64;
     let epochs: u16 = 1;
diff --git a/pallets/subtensor/src/tests/delegate_info.rs b/pallets/subtensor/src/tests/delegate_info.rs
index fa9aa942f7..8168755439 100644
--- a/pallets/subtensor/src/tests/delegate_info.rs
+++ b/pallets/subtensor/src/tests/delegate_info.rs
@@ -5,6 +5,7 @@ use frame_support::assert_ok;
 use scale_info::prelude::collections::HashMap;
 use sp_core::U256;
 use substrate_fixed::types::U64F64;
+use subtensor_runtime_common::NetUid;
 
 #[test]
 fn test_return_per_1000_tao() {
@@ -110,7 +111,7 @@ fn test_get_delegated() {
             delegatee_4,
         ];
         let to_stakes = [to_stake_0, to_stake_1, to_stake_2, to_stake_3, to_stake_4];
-        let mut expected_stake_map: HashMap<U256, HashMap<U256, HashMap<u16, u64>>> =
+        let mut expected_stake_map: HashMap<U256, HashMap<U256, HashMap<NetUid, u64>>> =
             HashMap::new();
 
         for (i, to_stake) in to_stakes.iter().enumerate() {
@@ -147,15 +148,10 @@ fn test_get_delegated() {
                     if let Some(expected_under_delegate) =
                         coldkey_stakes_map.get(&delegate_info.delegate_ss58)
                     {
-                        if let Some(expected_stake) =
-                            expected_under_delegate.get(&u16::from(*netuid))
-                        {
+                        if let Some(expected_stake) = expected_under_delegate.get(&netuid.0) {
                             assert_eq!(u64::from(*staked), *expected_stake);
                         } else {
-                            panic!(
-                                "Netuid {} not found in expected stake map",
-                                u16::from(*netuid)
-                            );
+                            panic!("Netuid {} not found in expected stake map", netuid.0);
                         };
                     } else {
                         panic!(
diff --git a/pallets/subtensor/src/tests/difficulty.rs b/pallets/subtensor/src/tests/difficulty.rs
index d6c151b64f..78ac8620c9 100644
--- a/pallets/subtensor/src/tests/difficulty.rs
+++ b/pallets/subtensor/src/tests/difficulty.rs
@@ -1,6 +1,7 @@
 #![allow(clippy::unwrap_used)]
 
 use sp_core::U256;
+use subtensor_runtime_common::NetUid;
 
 use super::mock::*;
 
@@ -9,7 +10,7 @@ use super::mock::*;
 fn test_registration_difficulty_adjustment() {
     new_test_ext(1).execute_with(|| {
         // Create Net 1
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 1;
         let modality: u16 = 1;
         add_network(netuid, tempo, modality);
diff --git a/pallets/subtensor/src/tests/emission.rs b/pallets/subtensor/src/tests/emission.rs
index c4d8d51e3c..ecd2df544b 100644
--- a/pallets/subtensor/src/tests/emission.rs
+++ b/pallets/subtensor/src/tests/emission.rs
@@ -1,3 +1,5 @@
+use subtensor_runtime_common::NetUid;
+
 use super::mock::*;
 
 // 1. Test Zero Tempo
@@ -7,7 +9,7 @@ use super::mock::*;
 fn test_zero_tempo() {
     new_test_ext(1).execute_with(|| {
         assert_eq!(
-            SubtensorModule::blocks_until_next_epoch(1, 0, 100),
+            SubtensorModule::blocks_until_next_epoch(1.into(), 0, 100),
             u64::MAX
         );
     });
@@ -19,9 +21,15 @@ fn test_zero_tempo() {
 #[test]
 fn test_regular_case() {
     new_test_ext(1).execute_with(|| {
-        assert_eq!(SubtensorModule::blocks_until_next_epoch(1, 10, 5), 3);
-        assert_eq!(SubtensorModule::blocks_until_next_epoch(2, 20, 15), 2);
-        assert_eq!(SubtensorModule::blocks_until_next_epoch(3, 30, 25), 1);
+        assert_eq!(SubtensorModule::blocks_until_next_epoch(1.into(), 10, 5), 3);
+        assert_eq!(
+            SubtensorModule::blocks_until_next_epoch(2.into(), 20, 15),
+            2
+        );
+        assert_eq!(
+            SubtensorModule::blocks_until_next_epoch(3.into(), 30, 25),
+            1
+        );
     });
 }
 
@@ -32,11 +40,11 @@ fn test_regular_case() {
 fn test_boundary_conditions() {
     new_test_ext(1).execute_with(|| {
         assert_eq!(
-            SubtensorModule::blocks_until_next_epoch(u16::MAX, u16::MAX, u64::MAX),
+            SubtensorModule::blocks_until_next_epoch(u16::MAX.into(), u16::MAX, u64::MAX),
             0
         );
         assert_eq!(
-            SubtensorModule::blocks_until_next_epoch(u16::MAX, u16::MAX, 0),
+            SubtensorModule::blocks_until_next_epoch(u16::MAX.into(), u16::MAX, 0),
             u16::MAX as u64
         );
     });
@@ -49,7 +57,7 @@ fn test_boundary_conditions() {
 fn test_overflow_handling() {
     new_test_ext(1).execute_with(|| {
         assert_eq!(
-            SubtensorModule::blocks_until_next_epoch(u16::MAX, u16::MAX, u64::MAX - 1),
+            SubtensorModule::blocks_until_next_epoch(u16::MAX.into(), u16::MAX, u64::MAX - 1),
             1
         );
     });
@@ -61,8 +69,14 @@ fn test_overflow_handling() {
 #[test]
 fn test_epoch_alignment() {
     new_test_ext(1).execute_with(|| {
-        assert_eq!(SubtensorModule::blocks_until_next_epoch(1, 10, 9), 10);
-        assert_eq!(SubtensorModule::blocks_until_next_epoch(2, 20, 21), 17);
+        assert_eq!(
+            SubtensorModule::blocks_until_next_epoch(1.into(), 10, 9),
+            10
+        );
+        assert_eq!(
+            SubtensorModule::blocks_until_next_epoch(2.into(), 20, 21),
+            17
+        );
     });
 }
 
@@ -72,9 +86,9 @@ fn test_epoch_alignment() {
 #[test]
 fn test_different_network_ids() {
     new_test_ext(1).execute_with(|| {
-        assert_eq!(SubtensorModule::blocks_until_next_epoch(1, 10, 5), 3);
-        assert_eq!(SubtensorModule::blocks_until_next_epoch(2, 10, 5), 2);
-        assert_eq!(SubtensorModule::blocks_until_next_epoch(3, 10, 5), 1);
+        assert_eq!(SubtensorModule::blocks_until_next_epoch(1.into(), 10, 5), 3);
+        assert_eq!(SubtensorModule::blocks_until_next_epoch(2.into(), 10, 5), 2);
+        assert_eq!(SubtensorModule::blocks_until_next_epoch(3.into(), 10, 5), 1);
     });
 }
 
@@ -85,7 +99,7 @@ fn test_different_network_ids() {
 fn test_large_tempo_values() {
     new_test_ext(1).execute_with(|| {
         assert_eq!(
-            SubtensorModule::blocks_until_next_epoch(1, u16::MAX - 1, 100),
+            SubtensorModule::blocks_until_next_epoch(1.into(), u16::MAX - 1, 100),
             u16::MAX as u64 - 103
         );
     });
@@ -98,7 +112,7 @@ fn test_large_tempo_values() {
 fn test_consecutive_blocks() {
     new_test_ext(1).execute_with(|| {
         let tempo = 10;
-        let netuid = 1;
+        let netuid = NetUid::from(1);
         let mut last_result = SubtensorModule::blocks_until_next_epoch(netuid, tempo, 0);
         for i in 1..tempo - 1 {
             let current_result = SubtensorModule::blocks_until_next_epoch(netuid, tempo, i as u64);
@@ -114,9 +128,12 @@ fn test_consecutive_blocks() {
 #[test]
 fn test_wrap_around_behavior() {
     new_test_ext(1).execute_with(|| {
-        assert_eq!(SubtensorModule::blocks_until_next_epoch(1, 10, u64::MAX), 9);
         assert_eq!(
-            SubtensorModule::blocks_until_next_epoch(1, 10, u64::MAX - 1),
+            SubtensorModule::blocks_until_next_epoch(1.into(), 10, u64::MAX),
+            9
+        );
+        assert_eq!(
+            SubtensorModule::blocks_until_next_epoch(1.into(), 10, u64::MAX - 1),
             10
         );
     });
diff --git a/pallets/subtensor/src/tests/epoch.rs b/pallets/subtensor/src/tests/epoch.rs
index 2557709912..0e567796d7 100644
--- a/pallets/subtensor/src/tests/epoch.rs
+++ b/pallets/subtensor/src/tests/epoch.rs
@@ -111,7 +111,7 @@ fn distribute_nodes(
 }
 
 #[allow(dead_code)]
-fn uid_stats(netuid: u16, uid: u16) {
+fn uid_stats(netuid: NetUid, uid: u16) {
     log::info!(
         "stake: {:?}",
         SubtensorModule::get_total_stake_for_hotkey(&(U256::from(uid)))
@@ -141,7 +141,7 @@ fn uid_stats(netuid: u16, uid: u16) {
 
 #[allow(clippy::too_many_arguments)]
 fn init_run_epochs(
-    netuid: u16,
+    netuid: NetUid,
     n: u16,
     validators: &[u16],
     servers: &[u16],
@@ -402,7 +402,7 @@ fn init_run_epochs(
 // Test consensus guarantees with an epoch on a graph with 4096 nodes, of which the first 128 are validators, the graph is split into a major and minor set, each setting specific weight on itself and the complement on the other. Asserts that the major emission ratio >= major stake ratio.
 // #[test]
 // fn test_consensus_guarantees() {
-//     let netuid: u16 = 0;
+//     let netuid = NetUid::from(0);
 //     let network_n: u16 = 512;
 //     let validators_n: u16 = 64;
 //     let epochs: u16 = 1;
@@ -493,7 +493,7 @@ fn init_run_epochs(
 // fn test_overflow() {
 //     new_test_ext(1).execute_with(|| {
 //         log::info!("test_overflow:");
-//         let netuid: u16 = 1;
+//         let netuid = NetUid::from(1);
 //         add_network(netuid, 1,  0);
 //         SubtensorModule::set_max_allowed_uids(netuid, 3);
 //         SubtensorModule::increase_stake_on_coldkey_hotkey_account(
@@ -557,7 +557,7 @@ fn init_run_epochs(
 fn test_1_graph() {
     new_test_ext(1).execute_with(|| {
         log::info!("test_1_graph:");
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let coldkey = U256::from(0);
         let hotkey = U256::from(0);
         let uid: u16 = 0;
@@ -603,7 +603,7 @@ fn test_10_graph() {
     new_test_ext(1).execute_with(|| {
         log::info!("test_10_graph");
         // Function for adding a nodes to the graph.
-        pub fn add_node(netuid: u16, coldkey: U256, hotkey: U256, uid: u16, stake_amount: u64) {
+        pub fn add_node(netuid: NetUid, coldkey: U256, hotkey: U256, uid: u16, stake_amount: u64) {
             log::info!(
                 "+Add net:{:?} coldkey:{:?} hotkey:{:?} uid:{:?} stake_amount: {:?} subn: {:?}",
                 netuid,
@@ -625,7 +625,7 @@ fn test_10_graph() {
         // Build the graph with 10 items
         // each with 1 stake and self weights.
         let n: usize = 10;
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         add_network(netuid, u16::MAX - 1, 0); // set higher tempo to avoid built-in epoch, then manual epoch instead
         SubtensorModule::set_max_allowed_uids(netuid, n as u16);
         for i in 0..10 {
@@ -667,7 +667,7 @@ fn test_10_graph() {
 // SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor --lib -- tests::epoch::test_512_graph --exact --show-output --nocapture
 #[test]
 fn test_512_graph() {
-    let netuid: u16 = 1;
+    let netuid = NetUid::from(1);
     let network_n: u16 = 512;
     let validators_n: u16 = 64;
     let max_stake_per_validator: u64 = 328_125_000_000_000; // 21_000_000_000_000_000 / 64
@@ -740,7 +740,7 @@ fn test_512_graph() {
 // SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor --lib -- tests::epoch::test_512_graph_random_weights --exact --show-output --nocapture
 #[test]
 fn test_512_graph_random_weights() {
-    let netuid: u16 = 1;
+    let netuid = NetUid::from(1);
     let network_n: u16 = 512;
     let validators_n: u16 = 64;
     let epochs: u16 = 1;
@@ -846,7 +846,7 @@ fn test_512_graph_random_weights() {
 // Test an epoch on a graph with 4096 nodes, of which the first 256 are validators setting non-self weights, and the rest servers setting only self-weights.
 // #[test]
 // fn test_4096_graph() {
-//     let netuid: u16 = 1;
+//     let netuid = NetUid::from(1);
 //     let network_n: u16 = 4096;
 //     let validators_n: u16 = 256;
 //     let epochs: u16 = 1;
@@ -923,7 +923,7 @@ fn test_512_graph_random_weights() {
 // #[test]
 // fn test_16384_graph_sparse() {
 //     new_test_ext(1).execute_with(|| {
-//         let netuid: u16 = 1;
+//         let netuid = NetUid::from(1);
 //         let n: u16 = 16384;
 //         let validators_n: u16 = 512;
 //         let validators: Vec<u16> = (0..validators_n).collect();
@@ -989,7 +989,7 @@ fn test_bonds() {
     new_test_ext(1).execute_with(|| {
 		let sparse: bool = true;
 		let n: u16 = 8;
-		let netuid: u16 = 1;
+		let netuid = NetUid::from(1);
 		let tempo: u16 = 1;
 		let max_stake: u64 = 4;
 		let stakes: Vec<u64> = vec![1, 2, 3, 4, 0, 0, 0, 0];
@@ -1333,7 +1333,7 @@ fn test_active_stake() {
         System::set_block_number(0);
         let sparse: bool = true;
         let n: u16 = 4;
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 1;
         let block_number: u64 = System::block_number();
         let stake: u64 = 1;
@@ -1540,7 +1540,7 @@ fn test_outdated_weights() {
     new_test_ext(1).execute_with(|| {
         let sparse: bool = true;
         let n: u16 = 4;
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 0;
         let mut block_number: u64 = System::block_number();
         let stake: u64 = 1;
@@ -1727,7 +1727,7 @@ fn test_zero_weights() {
     new_test_ext(1).execute_with(|| {
         let sparse: bool = true;
         let n: u16 = 2;
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = u16::MAX - 1; // high tempo to skip automatic epochs in on_initialize, use manual epochs instead
         let mut block_number: u64 = 0;
         let stake: u64 = 1;
@@ -1921,7 +1921,7 @@ fn test_deregistered_miner_bonds() {
     new_test_ext(1).execute_with(|| {
         let sparse: bool = true;
         let n: u16 = 4;
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let high_tempo: u16 = u16::MAX - 1; // high tempo to skip automatic epochs in on_initialize, use manual epochs instead
 
         let stake: u64 = 1;
@@ -2098,7 +2098,7 @@ fn test_deregistered_miner_bonds() {
 // Test that epoch assigns validator permits to highest stake uids that are over the stake threshold, varies uid interleaving and stake values.
 #[test]
 fn test_validator_permits() {
-    let netuid: u16 = 1;
+    let netuid = NetUid::from(1);
     let tempo: u16 = u16::MAX - 1; // high tempo to skip automatic epochs in on_initialize, use manual epochs instead
     for interleave in 0..3 {
         for (network_n, validators_n) in [(2, 1), (4, 2), (8, 4)] {
@@ -2226,7 +2226,7 @@ fn test_validator_permits() {
 #[test]
 fn test_get_set_alpha() {
     new_test_ext(1).execute_with(|| {
-        let netuid = 1;
+        let netuid = NetUid::from(1);
         let alpha_low: u16 = 12_u16;
         let alpha_high: u16 = u16::MAX - 10;
 
@@ -2377,7 +2377,7 @@ fn test_blocks_since_last_step() {
     new_test_ext(1).execute_with(|| {
         System::set_block_number(0);
 
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 7200;
         add_network(netuid, tempo, 0);
 
@@ -2478,7 +2478,7 @@ fn test_can_set_self_weight_as_subnet_owner() {
 #[test]
 fn test_epoch_outputs_single_staker_registered_no_weights() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let high_tempo: u16 = u16::MAX - 1; // Don't run automatically.
         add_network(netuid, high_tempo, 0);
 
@@ -2553,7 +2553,7 @@ fn test_epoch_outputs_single_staker_registered_no_weights() {
 // ```
 // #[test]
 // fn _map_consensus_guarantees() {
-//     let netuid: u16 = 1;
+//     let netuid = NetUid::from(1);
 //     let network_n: u16 = 512;
 //     let validators_n: u16 = 64;
 //     let epochs: u16 = 1;
@@ -2630,7 +2630,7 @@ pub fn assert_approx_eq(left: I32F32, right: I32F32, epsilon: I32F32) {
 }
 
 // test Yuma 3 scenarios over a sequence of epochs.
-fn setup_yuma_3_scenario(netuid: u16, n: u16, sparse: bool, max_stake: u64, stakes: Vec<u64>) {
+fn setup_yuma_3_scenario(netuid: NetUid, n: u16, sparse: bool, max_stake: u64, stakes: Vec<u64>) {
     let block_number = System::block_number();
     let tempo: u16 = 1; // high tempo to skip automatic epochs in on_initialize, use manual epochs instead
     add_network(netuid, tempo, 0);
@@ -2690,7 +2690,7 @@ fn setup_yuma_3_scenario(netuid: u16, n: u16, sparse: bool, max_stake: u64, stak
     run_epoch(netuid, sparse);
 }
 
-fn run_epoch(netuid: u16, sparse: bool) {
+fn run_epoch(netuid: NetUid, sparse: bool) {
     next_block_no_epoch(netuid);
     if sparse {
         SubtensorModule::epoch(netuid, 1_000_000_000);
@@ -2700,7 +2700,7 @@ fn run_epoch(netuid: u16, sparse: bool) {
 }
 
 fn run_epoch_and_check_bonds_dividends(
-    netuid: u16,
+    netuid: NetUid,
     sparse: bool,
     target_bonds: &[Vec<f32>],
     target_dividends: &[f32],
@@ -2727,7 +2727,7 @@ fn run_epoch_and_check_bonds_dividends(
     }
 }
 
-fn set_yuma_3_weights(netuid: u16, weights: Vec<Vec<u16>>, indices: Vec<u16>) {
+fn set_yuma_3_weights(netuid: NetUid, weights: Vec<Vec<u16>>, indices: Vec<u16>) {
     for (uid, weight) in weights.iter().enumerate() {
         assert_ok!(SubtensorModule::set_weights(
             RuntimeOrigin::signed(U256::from(uid as u64)),
@@ -2744,7 +2744,7 @@ fn test_yuma_3_kappa_moves_first() {
     for sparse in [true, false].iter() {
         new_test_ext(1).execute_with(|| {
             let n: u16 = 5; // 3 validators, 2 servers
-            let netuid: u16 = 1;
+            let netuid = NetUid::from(1);
             let max_stake: u64 = 8;
 
             // Validator A: kappa / Big validator (0.8) - moves first
@@ -2847,7 +2847,7 @@ fn test_yuma_3_kappa_moves_second() {
     for sparse in [true, false].iter() {
         new_test_ext(1).execute_with(|| {
             let n: u16 = 5; // 3 validators, 2 servers
-            let netuid: u16 = 1;
+            let netuid = NetUid::from(1);
             let max_stake: u64 = 8;
 
             // Validator A: kappa / Big validator (0.8) - moves second
@@ -2949,7 +2949,7 @@ fn test_yuma_3_kappa_moves_last() {
     for sparse in [true, false].iter() {
         new_test_ext(1).execute_with(|| {
             let n: u16 = 5; // 3 validators, 2 servers
-            let netuid: u16 = 1;
+            let netuid = NetUid::from(1);
             let max_stake: u64 = 8;
 
             // Validator A: kappa / Big validator (0.8) - moves last
@@ -3051,7 +3051,7 @@ fn test_yuma_3_one_epoch_switch() {
     for sparse in [true, false].iter() {
         new_test_ext(1).execute_with(|| {
             let n: u16 = 5; // 3 validators, 2 servers
-            let netuid: u16 = 1;
+            let netuid = NetUid::from(1);
             let max_stake: u64 = 8;
 
             // Equal stake validators
@@ -3136,7 +3136,7 @@ fn test_yuma_3_one_epoch_switch() {
 fn test_yuma_3_liquid_alpha_disabled() {
     for sparse in [true, false].iter() {
         new_test_ext(1).execute_with(|| {
-            let netuid: u16 = 1;
+            let netuid = NetUid::from(1);
             let n: u16 = 5; // 3 validators, 2 servers
             let max_stake: u64 = 8;
 
@@ -3225,7 +3225,7 @@ fn test_yuma_3_liquid_alpha_disabled() {
 fn test_yuma_3_stable_miner() {
     for sparse in [true, false].iter() {
         new_test_ext(1).execute_with(|| {
-            let netuid: u16 = 1;
+            let netuid = NetUid::from(1);
             let n: u16 = 6; // 3 validators, 3 servers
             let max_stake: u64 = 8;
 
@@ -3340,7 +3340,7 @@ fn test_yuma_3_bonds_reset() {
     new_test_ext(1).execute_with(|| {
         let sparse: bool = true;
         let n: u16 = 5; // 3 validators, 2 servers
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let max_stake: u64 = 8;
 
         // "Case 8 - big vali moves late, then late"
diff --git a/pallets/subtensor/src/tests/evm.rs b/pallets/subtensor/src/tests/evm.rs
index fd0ea51061..95d0c4e6db 100644
--- a/pallets/subtensor/src/tests/evm.rs
+++ b/pallets/subtensor/src/tests/evm.rs
@@ -32,7 +32,7 @@ fn sign_evm_message<M: AsRef<[u8]>>(pair: &ecdsa::Pair, message: M) -> ecdsa::Si
 #[test]
 fn test_associate_evm_key_success() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
 
         let tempo: u16 = 2;
         let modality: u16 = 2;
@@ -81,7 +81,7 @@ fn test_associate_evm_key_success() {
 #[test]
 fn test_associate_evm_key_different_block_number_success() {
     new_test_ext(100).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
 
         let tempo: u16 = 2;
         let modality: u16 = 2;
@@ -128,7 +128,7 @@ fn test_associate_evm_key_different_block_number_success() {
 #[test]
 fn test_associate_evm_key_coldkey_does_not_own_hotkey() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
 
         let tempo: u16 = 2;
         let modality: u16 = 2;
@@ -165,7 +165,7 @@ fn test_associate_evm_key_coldkey_does_not_own_hotkey() {
 #[test]
 fn test_associate_evm_key_hotkey_not_registered_in_subnet() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
 
         let tempo: u16 = 2;
         let modality: u16 = 2;
@@ -203,7 +203,7 @@ fn test_associate_evm_key_hotkey_not_registered_in_subnet() {
 #[test]
 fn test_associate_evm_key_using_wrong_hash_function() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
 
         let tempo: u16 = 2;
         let modality: u16 = 2;
diff --git a/pallets/subtensor/src/tests/migration.rs b/pallets/subtensor/src/tests/migration.rs
index 1dfac06ad5..adb4601724 100644
--- a/pallets/subtensor/src/tests/migration.rs
+++ b/pallets/subtensor/src/tests/migration.rs
@@ -37,8 +37,8 @@ fn test_initialise_ti() {
 
     new_test_ext(1).execute_with(|| {
         pallet_balances::TotalIssuance::<Test>::put(1000);
-        crate::SubnetTAO::<Test>::insert(1, 100);
-        crate::SubnetTAO::<Test>::insert(2, 5);
+        crate::SubnetTAO::<Test>::insert(NetUid::from(1), 100);
+        crate::SubnetTAO::<Test>::insert(NetUid::from(2), 5);
 
         // Ensure values are NOT initialized prior to running migration
         assert!(crate::TotalIssuance::<Test>::get() == 0);
@@ -59,11 +59,11 @@ fn test_initialise_ti() {
 fn test_migration_transfer_nets_to_foundation() {
     new_test_ext(1).execute_with(|| {
         // Create subnet 1
-        add_network(1, 1, 0);
+        add_network(1.into(), 1, 0);
         // Create subnet 11
-        add_network(11, 1, 0);
+        add_network(11.into(), 1, 0);
 
-        log::info!("{:?}", SubtensorModule::get_subnet_owner(1));
+        log::info!("{:?}", SubtensorModule::get_subnet_owner(1.into()));
         //assert_eq!(SubtensorModule::<T>::get_subnet_owner(1), );
 
         // Run the migration to transfer ownership
@@ -71,7 +71,7 @@ fn test_migration_transfer_nets_to_foundation() {
             hex_literal::hex!["feabaafee293d3b76dae304e2f9d885f77d2b17adab9e17e921b321eccd61c77"];
         crate::migrations::migrate_transfer_ownership_to_foundation::migrate_transfer_ownership_to_foundation::<Test>(hex);
 
-        log::info!("new owner: {:?}", SubtensorModule::get_subnet_owner(1));
+        log::info!("new owner: {:?}", SubtensorModule::get_subnet_owner(1.into()));
     })
 }
 
@@ -79,13 +79,13 @@ fn test_migration_transfer_nets_to_foundation() {
 fn test_migration_delete_subnet_3() {
     new_test_ext(1).execute_with(|| {
         // Create subnet 3
-        add_network(3, 1, 0);
-        assert!(SubtensorModule::if_subnet_exist(3));
+        add_network(3.into(), 1, 0);
+        assert!(SubtensorModule::if_subnet_exist(3.into()));
 
         // Run the migration to transfer ownership
         crate::migrations::migrate_delete_subnet_3::migrate_delete_subnet_3::<Test>();
 
-        assert!(!SubtensorModule::if_subnet_exist(3));
+        assert!(!SubtensorModule::if_subnet_exist(3.into()));
     })
 }
 
@@ -93,13 +93,13 @@ fn test_migration_delete_subnet_3() {
 fn test_migration_delete_subnet_21() {
     new_test_ext(1).execute_with(|| {
         // Create subnet 21
-        add_network(21, 1, 0);
-        assert!(SubtensorModule::if_subnet_exist(21));
+        add_network(21.into(), 1, 0);
+        assert!(SubtensorModule::if_subnet_exist(21.into()));
 
         // Run the migration to transfer ownership
         crate::migrations::migrate_delete_subnet_21::migrate_delete_subnet_21::<Test>();
 
-        assert!(!SubtensorModule::if_subnet_exist(21));
+        assert!(!SubtensorModule::if_subnet_exist(21.into()));
     })
 }
 
@@ -115,7 +115,7 @@ fn test_migrate_commit_reveal_2() {
         let storage_prefix_interval = twox_128("WeightCommitRevealInterval".as_bytes());
         let storage_prefix_commits = twox_128("WeightCommits".as_bytes());
 
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let interval_value: u64 = 50u64;
 
         // Construct the full key for WeightCommitRevealInterval
@@ -385,7 +385,7 @@ fn test_migrate_commit_reveal_2() {
 fn test_migrate_subnet_volume() {
     new_test_ext(1).execute_with(|| {
         // Setup initial state
-        let netuid_1: u16 = 1;
+        let netuid_1 = NetUid::from(1);
         add_network(netuid_1, 1, 0);
 
         // SubnetValue for netuid 1 key
@@ -422,7 +422,7 @@ fn test_migrate_subnet_volume() {
 #[test]
 fn test_migrate_set_first_emission_block_number() {
     new_test_ext(1).execute_with(|| {
-    let netuids: [u16; 3] = [1, 2, 3];
+    let netuids: [NetUid; 3] = [1.into(), 2.into(), 3.into()];
     let block_number = 100;
     for netuid in netuids.iter() {
         add_network(*netuid, 1, 0);
@@ -433,7 +433,7 @@ fn test_migrate_set_first_emission_block_number() {
     let expected_weight: Weight = <Test as Config>::DbWeight::get().reads(3) + <Test as Config>::DbWeight::get().writes(netuids.len() as u64);
     assert_eq!(weight, expected_weight);
 
-    assert_eq!(FirstEmissionBlockNumber::<Test>::get(0), None);
+    assert_eq!(FirstEmissionBlockNumber::<Test>::get(NetUid::ROOT), None);
     for netuid in netuids.iter() {
         assert_eq!(FirstEmissionBlockNumber::<Test>::get(netuid), Some(block_number));
     }
@@ -443,13 +443,13 @@ fn test_migrate_set_first_emission_block_number() {
 #[test]
 fn test_migrate_set_subtoken_enable() {
     new_test_ext(1).execute_with(|| {
-        let netuids: [u16; 3] = [1, 2, 3];
+        let netuids: [NetUid; 3] = [1.into(), 2.into(), 3.into()];
         let block_number = 100;
         for netuid in netuids.iter() {
             add_network(*netuid, 1, 0);
         }
 
-        let new_netuid = 4;
+        let new_netuid = NetUid::from(4);
         add_network_without_emission_block(new_netuid, 1, 0);
 
         let weight =
@@ -470,7 +470,7 @@ fn test_migrate_set_subtoken_enable() {
 fn test_migrate_remove_zero_total_hotkey_alpha() {
     new_test_ext(1).execute_with(|| {
         const MIGRATION_NAME: &str = "migrate_remove_zero_total_hotkey_alpha";
-        let netuid = 1u16;
+        let netuid = NetUid::from(1u16);
 
         let hotkey_zero = U256::from(100u64);
         let hotkey_nonzero = U256::from(101u64);
@@ -524,7 +524,7 @@ fn test_migrate_revealed_commitments() {
         // Example keys for the DoubleMap:
         //   Key1 (netuid) uses Identity (no hash)
         //   Key2 (account) uses Twox64Concat
-        let netuid: u16 = 123;
+        let netuid = NetUid::from(123);
         let account_id: u64 = 999; // Or however your test `AccountId` is represented
 
         // Construct the full storage key for `RevealedCommitments(netuid, account_id)`
diff --git a/pallets/subtensor/src/tests/mock.rs b/pallets/subtensor/src/tests/mock.rs
index d5d302d5c1..27c1e4f0e8 100644
--- a/pallets/subtensor/src/tests/mock.rs
+++ b/pallets/subtensor/src/tests/mock.rs
@@ -19,6 +19,7 @@ use sp_runtime::{
     traits::{BlakeTwo256, IdentityLookup},
 };
 use sp_std::cmp::Ordering;
+use subtensor_runtime_common::NetUid;
 
 use crate::*;
 
@@ -632,7 +633,7 @@ pub(crate) fn run_to_block_ext(n: u64, enable_events: bool) {
 }
 
 #[allow(dead_code)]
-pub(crate) fn next_block_no_epoch(netuid: u16) -> u64 {
+pub(crate) fn next_block_no_epoch(netuid: NetUid) -> u64 {
     // high tempo to skip automatic epochs in on_initialize
     let high_tempo: u16 = u16::MAX - 1;
     let old_tempo: u16 = SubtensorModule::get_tempo(netuid);
@@ -645,7 +646,7 @@ pub(crate) fn next_block_no_epoch(netuid: u16) -> u64 {
 }
 
 #[allow(dead_code)]
-pub(crate) fn run_to_block_no_epoch(netuid: u16, n: u64) {
+pub(crate) fn run_to_block_no_epoch(netuid: NetUid, n: u64) {
     // high tempo to skip automatic epochs in on_initialize
     let high_tempo: u16 = u16::MAX - 1;
     let old_tempo: u16 = SubtensorModule::get_tempo(netuid);
@@ -656,7 +657,7 @@ pub(crate) fn run_to_block_no_epoch(netuid: u16, n: u64) {
 }
 
 #[allow(dead_code)]
-pub(crate) fn step_epochs(count: u16, netuid: u16) {
+pub(crate) fn step_epochs(count: u16, netuid: NetUid) {
     for _ in 0..count {
         let blocks_to_next_epoch = SubtensorModule::blocks_until_next_epoch(
             netuid,
@@ -690,7 +691,7 @@ pub(crate) fn next_block() -> u64 {
 
 #[allow(dead_code)]
 pub fn register_ok_neuron(
-    netuid: u16,
+    netuid: NetUid,
     hotkey_account_id: U256,
     coldkey_account_id: U256,
     start_nonce: u64,
@@ -721,7 +722,7 @@ pub fn register_ok_neuron(
 }
 
 #[allow(dead_code)]
-pub fn add_network(netuid: u16, tempo: u16, _modality: u16) {
+pub fn add_network(netuid: NetUid, tempo: u16, _modality: u16) {
     SubtensorModule::init_new_network(netuid, tempo);
     SubtensorModule::set_network_registration_allowed(netuid, true);
     SubtensorModule::set_network_pow_registration_allowed(netuid, true);
@@ -730,14 +731,14 @@ pub fn add_network(netuid: u16, tempo: u16, _modality: u16) {
 }
 
 #[allow(dead_code)]
-pub fn add_network_without_emission_block(netuid: u16, tempo: u16, _modality: u16) {
+pub fn add_network_without_emission_block(netuid: NetUid, tempo: u16, _modality: u16) {
     SubtensorModule::init_new_network(netuid, tempo);
     SubtensorModule::set_network_registration_allowed(netuid, true);
     SubtensorModule::set_network_pow_registration_allowed(netuid, true);
 }
 
 #[allow(dead_code)]
-pub fn add_network_disable_subtoken(netuid: u16, tempo: u16, _modality: u16) {
+pub fn add_network_disable_subtoken(netuid: NetUid, tempo: u16, _modality: u16) {
     SubtensorModule::init_new_network(netuid, tempo);
     SubtensorModule::set_network_registration_allowed(netuid, true);
     SubtensorModule::set_network_pow_registration_allowed(netuid, true);
@@ -745,7 +746,7 @@ pub fn add_network_disable_subtoken(netuid: u16, tempo: u16, _modality: u16) {
 }
 
 #[allow(dead_code)]
-pub fn add_dynamic_network(hotkey: &U256, coldkey: &U256) -> u16 {
+pub fn add_dynamic_network(hotkey: &U256, coldkey: &U256) -> NetUid {
     let netuid = SubtensorModule::get_next_netuid();
     let lock_cost = SubtensorModule::get_network_lock_cost();
     SubtensorModule::add_balance_to_coldkey_account(coldkey, lock_cost);
@@ -762,7 +763,7 @@ pub fn add_dynamic_network(hotkey: &U256, coldkey: &U256) -> u16 {
 }
 
 #[allow(dead_code)]
-pub fn add_dynamic_network_without_emission_block(hotkey: &U256, coldkey: &U256) -> u16 {
+pub fn add_dynamic_network_without_emission_block(hotkey: &U256, coldkey: &U256) -> NetUid {
     let netuid = SubtensorModule::get_next_netuid();
     let lock_cost = SubtensorModule::get_network_lock_cost();
     SubtensorModule::add_balance_to_coldkey_account(coldkey, lock_cost);
@@ -778,20 +779,20 @@ pub fn add_dynamic_network_without_emission_block(hotkey: &U256, coldkey: &U256)
 
 // Helper function to set up a neuron with stake
 #[allow(dead_code)]
-pub fn setup_neuron_with_stake(netuid: u16, hotkey: U256, coldkey: U256, stake: u64) {
+pub fn setup_neuron_with_stake(netuid: NetUid, hotkey: U256, coldkey: U256, stake: u64) {
     register_ok_neuron(netuid, hotkey, coldkey, stake);
     increase_stake_on_coldkey_hotkey_account(&coldkey, &hotkey, stake, netuid);
 }
 
 #[allow(dead_code)]
-pub fn wait_set_pending_children_cooldown(netuid: u16) {
+pub fn wait_set_pending_children_cooldown(netuid: NetUid) {
     let cooldown = DefaultPendingCooldown::<Test>::get();
     step_block(cooldown as u16); // Wait for cooldown to pass
     step_epochs(1, netuid); // Run next epoch
 }
 
 #[allow(dead_code)]
-pub fn wait_and_set_pending_children(netuid: u16) {
+pub fn wait_and_set_pending_children(netuid: NetUid) {
     let original_block = System::block_number();
     wait_set_pending_children_cooldown(netuid);
     SubtensorModule::do_set_pending_children(netuid);
@@ -802,7 +803,7 @@ pub fn wait_and_set_pending_children(netuid: u16) {
 pub fn mock_schedule_children(
     coldkey: &U256,
     parent: &U256,
-    netuid: u16,
+    netuid: NetUid,
     child_vec: &[(u64, U256)],
 ) {
     // Set minimum stake for setting children
@@ -818,13 +819,13 @@ pub fn mock_schedule_children(
 }
 
 #[allow(dead_code)]
-pub fn mock_set_children(coldkey: &U256, parent: &U256, netuid: u16, child_vec: &[(u64, U256)]) {
+pub fn mock_set_children(coldkey: &U256, parent: &U256, netuid: NetUid, child_vec: &[(u64, U256)]) {
     mock_schedule_children(coldkey, parent, netuid, child_vec);
     wait_and_set_pending_children(netuid);
 }
 
 #[allow(dead_code)]
-pub fn mock_set_children_no_epochs(netuid: u16, parent: &U256, child_vec: &[(u64, U256)]) {
+pub fn mock_set_children_no_epochs(netuid: NetUid, parent: &U256, child_vec: &[(u64, U256)]) {
     let backup_block = SubtensorModule::get_current_block_as_u64();
     PendingChildKeys::<Test>::insert(netuid, parent, (child_vec, 0));
     System::set_block_number(1);
@@ -834,7 +835,7 @@ pub fn mock_set_children_no_epochs(netuid: u16, parent: &U256, child_vec: &[(u64
 
 // Helper function to wait for the rate limit
 #[allow(dead_code)]
-pub fn step_rate_limit(transaction_type: &TransactionType, netuid: u16) {
+pub fn step_rate_limit(transaction_type: &TransactionType, netuid: NetUid) {
     // Check rate limit
     let limit = SubtensorModule::get_rate_limit_on_subnet(transaction_type, netuid);
 
@@ -849,7 +850,7 @@ pub fn increase_stake_on_coldkey_hotkey_account(
     coldkey: &U256,
     hotkey: &U256,
     tao_staked: u64,
-    netuid: u16,
+    netuid: NetUid,
 ) {
     let fee = 0;
     SubtensorModule::stake_into_subnet(hotkey, coldkey, netuid, tao_staked, fee);
@@ -861,7 +862,7 @@ pub fn increase_stake_on_coldkey_hotkey_account(
 /// * `hotkey` - The hotkey account ID.
 /// * `increment` - The amount to be incremented.
 #[allow(dead_code)]
-pub fn increase_stake_on_hotkey_account(hotkey: &U256, increment: u64, netuid: u16) {
+pub fn increase_stake_on_hotkey_account(hotkey: &U256, increment: u64, netuid: NetUid) {
     increase_stake_on_coldkey_hotkey_account(
         &SubtensorModule::get_owning_coldkey_for_hotkey(hotkey),
         hotkey,
diff --git a/pallets/subtensor/src/tests/move_stake.rs b/pallets/subtensor/src/tests/move_stake.rs
index dd85ab9075..fd8b890f96 100644
--- a/pallets/subtensor/src/tests/move_stake.rs
+++ b/pallets/subtensor/src/tests/move_stake.rs
@@ -13,7 +13,7 @@ fn test_do_move_success() {
     new_test_ext(1).execute_with(|| {
         let subnet_owner_coldkey = U256::from(1001);
         let subnet_owner_hotkey = U256::from(1002);
-        let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
         let coldkey = U256::from(1);
         let origin_hotkey = U256::from(2);
         let destination_hotkey = U256::from(3);
@@ -141,7 +141,7 @@ fn test_do_move_nonexistent_subnet() {
         let coldkey = U256::from(1);
         let origin_hotkey = U256::from(2);
         let destination_hotkey = U256::from(3);
-        let nonexistent_netuid = 99; // Assuming this subnet doesn't exist
+        let nonexistent_netuid = NetUid::from(99); // Assuming this subnet doesn't exist
         let stake_amount = 1_000_000;
         let fee = 0;
 
@@ -240,7 +240,7 @@ fn test_do_move_nonexistent_destination_hotkey() {
         let coldkey = U256::from(1);
         let origin_hotkey = U256::from(2);
         let nonexistent_destination_hotkey = U256::from(99); // Assuming this hotkey doesn't exist
-        let netuid = 1;
+        let netuid = NetUid::from(1);
         let stake_amount = 1_000_000;
         let fee = 0;
 
@@ -518,7 +518,7 @@ fn test_do_move_wrong_origin() {
         let wrong_coldkey = U256::from(99);
         let origin_hotkey = U256::from(2);
         let destination_hotkey = U256::from(3);
-        let netuid = 1;
+        let netuid = NetUid::from(1);
         let stake_amount = DefaultMinStake::<Test>::get() * 10;
         let fee = 0;
 
@@ -738,7 +738,7 @@ fn test_do_move_max_values() {
         let origin_hotkey = U256::from(2);
         let destination_hotkey = U256::from(3);
         let max_stake = u64::MAX;
-        let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
         let fee = 0;
 
         // Set up initial stake with maximum value
@@ -797,8 +797,8 @@ fn test_moving_too_little_unstakes() {
         let fee = DefaultStakingFee::<Test>::get();
 
         //add network
-        let netuid: u16 = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
-        let netuid2: u16 = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
+        let netuid = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
+        let netuid2 = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
 
         // Give it some $$$ in his coldkey balance
         SubtensorModule::add_balance_to_coldkey_account(&coldkey_account_id, amount + fee);
@@ -886,7 +886,7 @@ fn test_do_transfer_nonexistent_subnet() {
         let origin_coldkey = U256::from(1);
         let destination_coldkey = U256::from(2);
         let hotkey = U256::from(3);
-        let nonexistent_netuid = 9999;
+        let nonexistent_netuid = NetUid::from(9999);
         let stake_amount = DefaultMinStake::<Test>::get() * 5;
 
         assert_noop!(
@@ -1153,8 +1153,8 @@ fn test_do_swap_nonexistent_subnet() {
     new_test_ext(1).execute_with(|| {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
-        let nonexistent_netuid1: u16 = 9998;
-        let nonexistent_netuid2: u16 = 9999;
+        let nonexistent_netuid1 = NetUid::from(9998);
+        let nonexistent_netuid2 = NetUid::from(9999);
         let stake_amount = 1_000_000;
 
         SubtensorModule::create_account_if_non_existent(&coldkey, &hotkey);
@@ -1666,9 +1666,9 @@ fn test_move_stake_specific_stake_into_subnet_fail() {
         let tao_staked = 200_000_000;
 
         //add network
-        let netuid: u16 = add_dynamic_network(&sn_owner_coldkey, &sn_owner_coldkey);
+        let netuid = add_dynamic_network(&sn_owner_coldkey, &sn_owner_coldkey);
 
-        let origin_netuid: u16 = add_dynamic_network(&sn_owner_coldkey, &sn_owner_coldkey);
+        let origin_netuid = add_dynamic_network(&sn_owner_coldkey, &sn_owner_coldkey);
 
         // Register hotkey on netuid
         register_ok_neuron(netuid, hotkey_account_id, hotkey_owner_account_id, 0);
diff --git a/pallets/subtensor/src/tests/networks.rs b/pallets/subtensor/src/tests/networks.rs
index 7dda0502c1..ff14a641db 100644
--- a/pallets/subtensor/src/tests/networks.rs
+++ b/pallets/subtensor/src/tests/networks.rs
@@ -8,7 +8,7 @@ use sp_core::U256;
 fn test_registration_ok() {
     new_test_ext(1).execute_with(|| {
         let block_number: u64 = 0;
-        let netuid: u16 = 2;
+        let netuid = NetUid::from(2);
         let tempo: u16 = 13;
         let hotkey_account_id: U256 = U256::from(1);
         let coldkey_account_id = U256::from(0); // Neighbour of the beast, har har
@@ -45,7 +45,7 @@ fn test_registration_ok() {
 // fn test_schedule_dissolve_network_execution() {
 //     new_test_ext(1).execute_with(|| {
 //         let block_number: u64 = 0;
-//         let netuid: u16 = 2;
+//         let netuid = NetUid::from(2);
 //         let tempo: u16 = 13;
 //         let hotkey_account_id: U256 = U256::from(1);
 //         let coldkey_account_id = U256::from(0); // Neighbour of the beast, har har
@@ -97,7 +97,7 @@ fn test_registration_ok() {
 // fn test_non_owner_schedule_dissolve_network_execution() {
 //     new_test_ext(1).execute_with(|| {
 //         let block_number: u64 = 0;
-//         let netuid: u16 = 2;
+//         let netuid = NetUid::from(2);
 //         let tempo: u16 = 13;
 //         let hotkey_account_id: U256 = U256::from(1);
 //         let coldkey_account_id = U256::from(0); // Neighbour of the beast, har har
@@ -151,7 +151,7 @@ fn test_registration_ok() {
 // fn test_new_owner_schedule_dissolve_network_execution() {
 //     new_test_ext(1).execute_with(|| {
 //         let block_number: u64 = 0;
-//         let netuid: u16 = 2;
+//         let netuid = NetUid::from(2);
 //         let tempo: u16 = 13;
 //         let hotkey_account_id: U256 = U256::from(1);
 //         let coldkey_account_id = U256::from(0); // Neighbour of the beast, har har
@@ -209,7 +209,7 @@ fn test_registration_ok() {
 // fn test_schedule_dissolve_network_execution_with_coldkey_swap() {
 //     new_test_ext(1).execute_with(|| {
 //         let block_number: u64 = 0;
-//         let netuid: u16 = 2;
+//         let netuid = NetUid::from(2);
 //         let tempo: u16 = 13;
 //         let hotkey_account_id: U256 = U256::from(1);
 //         let coldkey_account_id = U256::from(0); // Neighbour of the beast, har har
@@ -294,7 +294,7 @@ fn test_register_subnet_low_lock_cost() {
 
         let subnet_owner_coldkey = U256::from(1);
         let subnet_owner_hotkey = U256::from(2);
-        let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
         assert!(SubtensorModule::if_subnet_exist(netuid));
 
         // Ensure that both Subnet TAO and Subnet Alpha In equal to (actual) lock_cost
@@ -317,7 +317,7 @@ fn test_register_subnet_high_lock_cost() {
 
         let subnet_owner_coldkey = U256::from(1);
         let subnet_owner_hotkey = U256::from(2);
-        let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
         assert!(SubtensorModule::if_subnet_exist(netuid));
 
         // Ensure that both Subnet TAO and Subnet Alpha In equal to 100 TAO
diff --git a/pallets/subtensor/src/tests/neuron_info.rs b/pallets/subtensor/src/tests/neuron_info.rs
index c51c1e7dad..a954ef6e26 100644
--- a/pallets/subtensor/src/tests/neuron_info.rs
+++ b/pallets/subtensor/src/tests/neuron_info.rs
@@ -1,11 +1,12 @@
 use super::mock::*;
 
 use sp_core::U256;
+use subtensor_runtime_common::NetUid;
 
 #[test]
 fn test_get_neuron_none() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let uid: u16 = 42;
 
         let neuron = SubtensorModule::get_neuron(netuid, uid);
@@ -16,7 +17,7 @@ fn test_get_neuron_none() {
 #[test]
 fn test_get_neuron_some() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
 
         let tempo: u16 = 2;
         let modality: u16 = 2;
@@ -37,7 +38,7 @@ fn test_get_neuron_some() {
 #[test]
 fn test_get_neurons_list() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
 
         let tempo: u16 = 2;
         let modality: u16 = 2;
@@ -62,7 +63,7 @@ fn test_get_neurons_list() {
 #[test]
 fn test_get_neurons_empty() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
 
         let neuron_count = 0;
         let neurons = SubtensorModule::get_neurons(netuid);
diff --git a/pallets/subtensor/src/tests/recycle_alpha.rs b/pallets/subtensor/src/tests/recycle_alpha.rs
index b142e5d3c9..277d56c81f 100644
--- a/pallets/subtensor/src/tests/recycle_alpha.rs
+++ b/pallets/subtensor/src/tests/recycle_alpha.rs
@@ -422,7 +422,7 @@ fn test_recycle_errors() {
                 RuntimeOrigin::signed(coldkey),
                 hotkey,
                 100_000,
-                99 // non-existent subnet
+                99.into() // non-existent subnet
             ),
             Error::<Test>::SubNetworkDoesNotExist
         );
@@ -432,7 +432,7 @@ fn test_recycle_errors() {
                 RuntimeOrigin::signed(coldkey),
                 hotkey,
                 100_000,
-                SubtensorModule::get_root_netuid(),
+                NetUid::ROOT,
             ),
             Error::<Test>::CannotBurnOrRecycleOnRootSubnet
         );
@@ -504,7 +504,7 @@ fn test_burn_errors() {
                 RuntimeOrigin::signed(coldkey),
                 hotkey,
                 100_000,
-                99 // non-existent subnet
+                99.into() // non-existent subnet
             ),
             Error::<Test>::SubNetworkDoesNotExist
         );
@@ -514,7 +514,7 @@ fn test_burn_errors() {
                 RuntimeOrigin::signed(coldkey),
                 hotkey,
                 100_000,
-                SubtensorModule::get_root_netuid(),
+                NetUid::ROOT,
             ),
             Error::<Test>::CannotBurnOrRecycleOnRootSubnet
         );
diff --git a/pallets/subtensor/src/tests/registration.rs b/pallets/subtensor/src/tests/registration.rs
index 3a8ce39ba3..d3dd827898 100644
--- a/pallets/subtensor/src/tests/registration.rs
+++ b/pallets/subtensor/src/tests/registration.rs
@@ -11,6 +11,7 @@ use frame_support::{assert_err, assert_noop, assert_ok};
 use frame_system::Config;
 use sp_core::U256;
 use sp_runtime::traits::{DispatchInfoOf, SignedExtension};
+use subtensor_runtime_common::NetUid;
 
 /********************************************
     subscribing::subscribe() tests
@@ -22,7 +23,7 @@ fn test_registration_subscribe_ok_dispatch_info_ok() {
     new_test_ext(1).execute_with(|| {
         let block_number: u64 = 0;
         let nonce: u64 = 0;
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let work: Vec<u8> = vec![0; 32];
         let hotkey: U256 = U256::from(0);
         let coldkey: U256 = U256::from(0);
@@ -48,7 +49,7 @@ fn test_registration_subscribe_ok_dispatch_info_ok() {
 #[test]
 fn test_registration_difficulty() {
     new_test_ext(1).execute_with(|| {
-        assert_eq!(SubtensorModule::get_difficulty(1).as_u64(), 10000);
+        assert_eq!(SubtensorModule::get_difficulty(1.into()).as_u64(), 10000);
     });
 }
 
@@ -56,7 +57,7 @@ fn test_registration_difficulty() {
 fn test_registration_invalid_seal_hotkey() {
     new_test_ext(1).execute_with(|| {
         let block_number: u64 = 0;
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let hotkey_account_id_1: U256 = U256::from(1);
         let hotkey_account_id_2: U256 = U256::from(2);
@@ -103,7 +104,7 @@ fn test_registration_invalid_seal_hotkey() {
 fn test_registration_ok() {
     new_test_ext(1).execute_with(|| {
         let block_number: u64 = 0;
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let hotkey_account_id: U256 = U256::from(1);
         let coldkey_account_id = U256::from(667); // Neighbour of the beast, har har
@@ -159,7 +160,7 @@ fn test_registration_ok() {
 fn test_registration_without_neuron_slot() {
     new_test_ext(1).execute_with(|| {
         let block_number: u64 = 0;
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let hotkey_account_id: U256 = U256::from(1);
         let coldkey_account_id = U256::from(667); // Neighbour of the beast, har har
@@ -192,7 +193,7 @@ fn test_registration_without_neuron_slot() {
 #[test]
 fn test_registration_under_limit() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let block_number: u64 = 0;
         let hotkey_account_id: U256 = U256::from(1);
         let coldkey_account_id = U256::from(667);
@@ -244,7 +245,7 @@ fn test_registration_under_limit() {
 #[test]
 fn test_registration_rate_limit_exceeded() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let block_number: u64 = 0;
         let hotkey_account_id: U256 = U256::from(1);
         let coldkey_account_id = U256::from(667);
@@ -292,7 +293,7 @@ fn test_registration_rate_limit_exceeded() {
 #[test]
 fn test_burned_registration_under_limit() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let hotkey_account_id: U256 = U256::from(1);
         let coldkey_account_id = U256::from(667);
         let who: <Test as frame_system::Config>::AccountId = coldkey_account_id;
@@ -336,7 +337,7 @@ fn test_burned_registration_under_limit() {
 #[test]
 fn test_burned_registration_rate_limit_exceeded() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let hotkey_account_id: U256 = U256::from(1);
         let coldkey_account_id = U256::from(667);
         let who: <Test as frame_system::Config>::AccountId = coldkey_account_id;
@@ -374,7 +375,7 @@ fn test_burned_registration_rate_limit_exceeded() {
 fn test_burned_registration_rate_allows_burn_adjustment() {
     // We need to be able to register more than the *target* registrations per interval
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let hotkey_account_id: U256 = U256::from(1);
         let coldkey_account_id = U256::from(667);
         let who: <Test as frame_system::Config>::AccountId = coldkey_account_id;
@@ -421,7 +422,7 @@ fn test_burned_registration_rate_allows_burn_adjustment() {
 #[test]
 fn test_burned_registration_ok() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let hotkey_account_id = U256::from(1);
         let burn_cost = 1000;
@@ -468,7 +469,7 @@ fn test_burned_registration_ok() {
 #[test]
 fn test_burn_registration_without_neuron_slot() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let hotkey_account_id = U256::from(1);
         let burn_cost = 1000;
@@ -494,7 +495,7 @@ fn test_burn_registration_without_neuron_slot() {
 #[test]
 fn test_burn_registration_doesnt_write_on_failure() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let hotkey_account_id = U256::from(1);
         let burn_cost = 1000;
@@ -534,7 +535,7 @@ fn test_burn_registration_doesnt_write_on_failure() {
 #[test]
 fn test_burn_adjustment() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let init_burn_cost: u64 = InitialMinBurn::get() + 10_000;
         let adjustment_interval = 1;
@@ -585,7 +586,7 @@ fn test_burn_adjustment() {
 #[test]
 fn test_burn_registration_pruning_scenarios() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let burn_cost = 1000;
         let coldkey_account_id = U256::from(667);
@@ -701,7 +702,7 @@ fn test_burn_registration_pruning_scenarios() {
 #[test]
 fn test_registration_too_many_registrations_per_block() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         add_network(netuid, tempo, 0);
         SubtensorModule::set_max_registrations_per_block(netuid, 10);
@@ -897,7 +898,7 @@ fn test_registration_too_many_registrations_per_block() {
 #[test]
 fn test_registration_too_many_registrations_per_interval() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         add_network(netuid, tempo, 0);
         SubtensorModule::set_max_registrations_per_block(netuid, 11);
@@ -1089,7 +1090,7 @@ fn test_registration_immunity_period() { //impl this test when epoch impl and ca
 fn test_registration_already_active_hotkey() {
     new_test_ext(1).execute_with(|| {
         let block_number: u64 = 0;
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let hotkey_account_id = U256::from(1);
         let coldkey_account_id = U256::from(667);
@@ -1142,7 +1143,7 @@ fn test_registration_already_active_hotkey() {
 fn test_registration_invalid_seal() {
     new_test_ext(1).execute_with(|| {
         let block_number: u64 = 0;
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let hotkey_account_id = U256::from(1);
         let coldkey_account_id = U256::from(667);
@@ -1170,7 +1171,7 @@ fn test_registration_invalid_block_number() {
     new_test_ext(1).execute_with(|| {
         System::set_block_number(0);
         let block_number: u64 = 1;
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let hotkey_account_id = U256::from(1);
         let coldkey_account_id = U256::from(667);
@@ -1201,7 +1202,7 @@ fn test_registration_invalid_block_number() {
 fn test_registration_invalid_difficulty() {
     new_test_ext(1).execute_with(|| {
         let block_number: u64 = 0;
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let hotkey_account_id = U256::from(1);
         let coldkey_account_id = U256::from(667);
@@ -1234,7 +1235,7 @@ fn test_registration_invalid_difficulty() {
 fn test_registration_failed_no_signature() {
     new_test_ext(1).execute_with(|| {
         let block_number: u64 = 1;
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let hotkey_account_id = U256::from(1);
         let coldkey_account_id = U256::from(667); // Neighbour of the beast, har har
         let (nonce, work): (u64, Vec<u8>) = SubtensorModule::create_work_for_block_number(
@@ -1262,7 +1263,7 @@ fn test_registration_failed_no_signature() {
 fn test_registration_get_uid_to_prune_all_in_immunity_period() {
     new_test_ext(1).execute_with(|| {
         System::set_block_number(0);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         add_network(netuid, 1, 0);
         log::info!("add network");
         register_ok_neuron(netuid, U256::from(0), U256::from(0), 39420842);
@@ -1278,7 +1279,7 @@ fn test_registration_get_uid_to_prune_all_in_immunity_period() {
             SubtensorModule::get_neuron_block_at_registration(netuid, 0),
             0
         );
-        assert_eq!(SubtensorModule::get_neuron_to_prune(0), 0);
+        assert_eq!(SubtensorModule::get_neuron_to_prune(NetUid::ROOT), 0);
     });
 }
 
@@ -1286,7 +1287,7 @@ fn test_registration_get_uid_to_prune_all_in_immunity_period() {
 fn test_registration_get_uid_to_prune_none_in_immunity_period() {
     new_test_ext(1).execute_with(|| {
         System::set_block_number(0);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         add_network(netuid, 1, 0);
         log::info!("add network");
         register_ok_neuron(netuid, U256::from(0), U256::from(0), 39420842);
@@ -1304,14 +1305,14 @@ fn test_registration_get_uid_to_prune_none_in_immunity_period() {
         );
         step_block(3);
         assert_eq!(SubtensorModule::get_current_block_as_u64(), 3);
-        assert_eq!(SubtensorModule::get_neuron_to_prune(0), 0);
+        assert_eq!(SubtensorModule::get_neuron_to_prune(NetUid::ROOT), 0);
     });
 }
 
 #[test]
 fn test_registration_pruning() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let block_number: u64 = 0;
         let tempo: u16 = 13;
         let hotkey_account_id = U256::from(1);
@@ -1387,7 +1388,7 @@ fn test_registration_pruning() {
 #[test]
 fn test_registration_get_neuron_metadata() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let block_number: u64 = 0;
         let tempo: u16 = 13;
         let hotkey_account_id = U256::from(1);
@@ -1423,8 +1424,8 @@ fn test_registration_get_neuron_metadata() {
 #[test]
 fn test_registration_add_network_size() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
-        let netuid2: u16 = 2;
+        let netuid = NetUid::from(1);
+        let netuid2 = NetUid::from(2);
         let block_number: u64 = 0;
         let hotkey_account_id = U256::from(1);
         let hotkey_account_id1 = U256::from(2);
@@ -1493,8 +1494,8 @@ fn test_registration_add_network_size() {
 #[test]
 fn test_burn_registration_increase_recycled_rao() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
-        let netuid2: u16 = 2;
+        let netuid = NetUid::from(1);
+        let netuid2 = NetUid::from(2);
 
         let hotkey_account_id = U256::from(1);
         let coldkey_account_id = U256::from(667);
@@ -1542,9 +1543,9 @@ fn test_burn_registration_increase_recycled_rao() {
 fn test_full_pass_through() {
     new_test_ext(1).execute_with(|| {
         // Create 3 networks.
-        let netuid0: u16 = 1;
-        let netuid1: u16 = 2;
-        let netuid2: u16 = 3;
+        let netuid0 = NetUid::from(1);
+        let netuid1 = NetUid::from(2);
+        let netuid2 = NetUid::from(3);
 
         // With 3 tempos
         let tempo0: u16 = 2;
@@ -1961,7 +1962,7 @@ fn test_full_pass_through() {
 fn test_registration_origin_hotkey_mismatch() {
     new_test_ext(1).execute_with(|| {
         let block_number: u64 = 0;
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let hotkey_account_id_1: U256 = U256::from(1);
         let hotkey_account_id_2: U256 = U256::from(2);
@@ -1996,7 +1997,7 @@ fn test_registration_origin_hotkey_mismatch() {
 fn test_registration_disabled() {
     new_test_ext(1).execute_with(|| {
         let block_number: u64 = 0;
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let hotkey_account_id: U256 = U256::from(1);
         let coldkey_account_id: U256 = U256::from(668);
@@ -2032,7 +2033,7 @@ fn test_registration_disabled() {
 // #[test]
 // fn test_hotkey_swap_ok() {
 //     new_test_ext(1).execute_with(|| {
-//         let netuid: u16 = 1;
+//         let netuid = NetUid::from(1);
 //         let tempo: u16 = 13;
 //         let hotkey_account_id = U256::from(1);
 //         let burn_cost = 1000;
@@ -2072,7 +2073,7 @@ fn test_registration_disabled() {
 // #[test]
 // fn test_hotkey_swap_not_owner() {
 //     new_test_ext(1).execute_with(|| {
-//         let netuid: u16 = 1;
+//         let netuid = NetUid::from(1);
 //         let tempo: u16 = 13;
 //         let hotkey_account_id = U256::from(1);
 //         let burn_cost = 1000;
@@ -2108,7 +2109,7 @@ fn test_registration_disabled() {
 // #[test]
 // fn test_hotkey_swap_same_key() {
 //     new_test_ext(1).execute_with(|| {
-//         let netuid: u16 = 1;
+//         let netuid = NetUid::from(1);
 //         let tempo: u16 = 13;
 //         let hotkey_account_id = U256::from(1);
 //         let burn_cost = 1000;
@@ -2142,7 +2143,7 @@ fn test_registration_disabled() {
 // #[test]
 // fn test_hotkey_swap_registered_key() {
 //     new_test_ext(1).execute_with(|| {
-//         let netuid: u16 = 1;
+//         let netuid = NetUid::from(1);
 //         let tempo: u16 = 13;
 //         let hotkey_account_id = U256::from(1);
 //         let burn_cost = 1000;
diff --git a/pallets/subtensor/src/tests/senate.rs b/pallets/subtensor/src/tests/senate.rs
index 52b0c240c2..a71a97b1e2 100644
--- a/pallets/subtensor/src/tests/senate.rs
+++ b/pallets/subtensor/src/tests/senate.rs
@@ -61,7 +61,7 @@ fn test_senate_join_works() {
     new_test_ext().execute_with(|| {
         migrations::migrate_create_root_network::migrate_create_root_network::<Test>();
 
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let hotkey_account_id = U256::from(6);
         let burn_cost = 1000;
@@ -135,7 +135,7 @@ fn test_senate_vote_works() {
     new_test_ext().execute_with(|| {
         migrations::migrate_create_root_network::migrate_create_root_network::<Test>();
 
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let senate_hotkey = U256::from(1);
         let hotkey_account_id = U256::from(6);
@@ -248,7 +248,7 @@ fn test_senate_vote_not_member() {
     new_test_ext().execute_with(|| {
         migrations::migrate_create_root_network::migrate_create_root_network::<Test>();
 
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let senate_hotkey = U256::from(1);
         let hotkey_account_id = U256::from(6);
@@ -309,7 +309,7 @@ fn test_senate_leave_works() {
     new_test_ext().execute_with(|| {
         migrations::migrate_create_root_network::migrate_create_root_network::<Test>();
 
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let hotkey_account_id = U256::from(6);
         let burn_cost = 1000;
@@ -382,7 +382,7 @@ fn test_senate_leave_vote_removal() {
     new_test_ext().execute_with(|| {
         migrations::migrate_create_root_network::migrate_create_root_network::<Test>();
 
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let senate_hotkey = U256::from(1);
         let hotkey_account_id = U256::from(6);
@@ -472,15 +472,14 @@ fn test_senate_leave_vote_removal() {
         // Fill the root network with many large stake keys.
         // This removes all other keys.
         // Add two networks.
-        let root_netuid: u16 = 0;
-        let other_netuid: u16 = 5;
+        let other_netuid = NetUid::from(5);
         add_network(other_netuid, 1, 0);
         SubtensorModule::set_burn(other_netuid, 0);
         SubtensorModule::set_max_registrations_per_block(other_netuid, 1000);
         SubtensorModule::set_target_registrations_per_interval(other_netuid, 1000);
-        SubtensorModule::set_max_registrations_per_block(root_netuid, 1000);
-        SubtensorModule::set_target_registrations_per_interval(root_netuid, 1000);
-        SubtokenEnabled::<Test>::insert(root_netuid, true);
+        SubtensorModule::set_max_registrations_per_block(NetUid::ROOT, 1000);
+        SubtensorModule::set_target_registrations_per_interval(NetUid::ROOT, 1000);
+        SubtokenEnabled::<Test>::insert(NetUid::ROOT, true);
         SubtokenEnabled::<Test>::insert(other_netuid, true);
 
         for i in 0..200 {
@@ -498,7 +497,7 @@ fn test_senate_leave_vote_removal() {
             assert_ok!(SubtensorModule::add_stake(
                 <<Test as Config>::RuntimeOrigin>::signed(cold),
                 hot,
-                root_netuid,
+                NetUid::ROOT,
                 100_000_000 + (i as u64)
             ));
             // Register them on the root network.
@@ -508,13 +507,13 @@ fn test_senate_leave_vote_removal() {
             ));
             // Check succesfull registration.
             assert!(SubtensorModule::get_uid_for_net_and_hotkey(other_netuid, &hot).is_ok());
-            assert!(SubtensorModule::get_uid_for_net_and_hotkey(root_netuid, &hot).is_ok());
+            assert!(SubtensorModule::get_uid_for_net_and_hotkey(NetUid::ROOT, &hot).is_ok());
             // Check that they are all delegates
             assert!(SubtensorModule::hotkey_is_delegate(&hot));
         }
         // No longer a root member
         assert!(
-            SubtensorModule::get_uid_for_net_and_hotkey(root_netuid, &hotkey_account_id).is_err()
+            SubtensorModule::get_uid_for_net_and_hotkey(NetUid::ROOT, &hotkey_account_id).is_err()
         );
         // No longer a member of the senate
         assert!(!Senate::is_member(&hotkey_account_id));
@@ -531,7 +530,7 @@ fn test_senate_not_leave_when_stake_removed() {
     new_test_ext().execute_with(|| {
         migrations::migrate_create_root_network::migrate_create_root_network::<Test>();
 
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let hotkey_account_id = U256::from(6);
         let burn_cost = 1000;
@@ -615,7 +614,7 @@ fn test_senate_join_current_delegate() {
     new_test_ext().execute_with(|| {
         migrations::migrate_create_root_network::migrate_create_root_network::<Test>();
 
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let hotkey_account_id = U256::from(6);
         let burn_cost = 1000;
@@ -689,12 +688,12 @@ fn test_adjust_senate_events() {
     new_test_ext().execute_with(|| {
         migrations::migrate_create_root_network::migrate_create_root_network::<Test>();
 
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let hotkey_account_id = U256::from(6);
         let burn_cost = 1000;
         let coldkey_account_id = U256::from(667);
-        let root_netuid = SubtensorModule::get_root_netuid();
+        let root_netuid = NetUid::ROOT;
         let fee = DefaultStakingFee::<Test>::get();
 
         let max_senate_size: u16 = SenateMaxMembers::get() as u16;
diff --git a/pallets/subtensor/src/tests/serving.rs b/pallets/subtensor/src/tests/serving.rs
index 6711862a6b..faf68b2e81 100644
--- a/pallets/subtensor/src/tests/serving.rs
+++ b/pallets/subtensor/src/tests/serving.rs
@@ -32,7 +32,7 @@ mod test {
 #[test]
 fn test_serving_subscribe_ok_dispatch_info_ok() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let version: u32 = 2;
         let ip: u128 = 1676056785;
         let port: u16 = 128;
@@ -65,7 +65,7 @@ fn test_serving_subscribe_ok_dispatch_info_ok() {
 fn test_serving_ok() {
     new_test_ext(1).execute_with(|| {
         let hotkey_account_id = U256::from(1);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let version: u32 = 2;
         let ip: u128 = 1676056785;
@@ -103,7 +103,7 @@ fn test_serving_ok() {
 fn test_serving_tls_ok() {
     new_test_ext(1).execute_with(|| {
         let hotkey_account_id = U256::from(1);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let version: u32 = 2;
         let ip: u128 = 1676056785;
@@ -161,7 +161,7 @@ fn test_serving_tls_ok() {
 fn test_serving_set_metadata_update() {
     new_test_ext(1).execute_with(|| {
         let hotkey_account_id = U256::from(1);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let version: u32 = 2;
         let ip: u128 = 1676056785;
@@ -225,7 +225,7 @@ fn test_serving_set_metadata_update() {
 fn test_axon_serving_rate_limit_exceeded() {
     new_test_ext(1).execute_with(|| {
         let hotkey_account_id = U256::from(1);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let version: u32 = 2;
         let ip: u128 = 1676056785;
@@ -307,7 +307,7 @@ fn test_axon_serving_rate_limit_exceeded() {
 fn test_axon_invalid_port() {
     new_test_ext(1).execute_with(|| {
         let hotkey_account_id = U256::from(1);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let version: u32 = 2;
         let ip: u128 = 1676056785;
@@ -340,7 +340,7 @@ fn test_axon_invalid_port() {
 #[test]
 fn test_prometheus_serving_subscribe_ok_dispatch_info_ok() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let version: u32 = 2;
         let ip: u128 = 1676056785;
         let port: u16 = 128;
@@ -367,7 +367,7 @@ fn test_prometheus_serving_subscribe_ok_dispatch_info_ok() {
 fn test_prometheus_serving_ok() {
     new_test_ext(1).execute_with(|| {
         let hotkey_account_id = U256::from(1);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let version: u32 = 2;
         let ip: u128 = 1676056785;
@@ -396,7 +396,7 @@ fn test_prometheus_serving_ok() {
 fn test_prometheus_serving_set_metadata_update() {
     new_test_ext(1).execute_with(|| {
         let hotkey_account_id = U256::from(1);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let version: u32 = 2;
         let ip: u128 = 1676056785;
@@ -442,7 +442,7 @@ fn test_prometheus_serving_set_metadata_update() {
 fn test_prometheus_serving_rate_limit_exceeded() {
     new_test_ext(1).execute_with(|| {
         let hotkey_account_id = U256::from(1);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let version: u32 = 2;
         let ip: u128 = 1676056785;
@@ -505,7 +505,7 @@ fn test_prometheus_serving_rate_limit_exceeded() {
 fn test_prometheus_invalid_port() {
     new_test_ext(1).execute_with(|| {
         let hotkey_account_id = U256::from(1);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let version: u32 = 2;
         let ip: u128 = 1676056785;
@@ -660,7 +660,7 @@ fn test_do_set_identity() {
     new_test_ext(1).execute_with(|| {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
-        let netuid = 1;
+        let netuid = NetUid::from(1);
 
         // Register a hotkey for the coldkey
         add_network(netuid, 13, 0);
@@ -847,7 +847,7 @@ fn test_set_and_get_identity() {
     new_test_ext(1).execute_with(|| {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
-        let netuid = 1;
+        let netuid = NetUid::from(1);
 
         // Register a hotkey for the coldkey
         add_network(netuid, 13, 0);
@@ -989,7 +989,7 @@ fn test_migrate_identities_to_v2() {
         let old_subnet_contact = b"subnet@example".to_vec();
 
         SubnetIdentities::<Test>::insert(
-            42u16,
+            NetUid::from(42),
             SubnetIdentity {
                 subnet_name: old_subnet_name.clone(),
                 github_repo: old_github_repo.clone(),
@@ -999,7 +999,7 @@ fn test_migrate_identities_to_v2() {
 
         assert!(Identities::<Test>::get(account_id_1).is_some());
         assert!(Identities::<Test>::get(account_id_2).is_some());
-        assert!(SubnetIdentities::<Test>::get(42u16).is_some());
+        assert!(SubnetIdentities::<Test>::get(NetUid::from(42)).is_some());
         assert!(!HasMigrationRun::<Test>::get(
             b"migrate_identities_to_v2".to_vec()
         ));
@@ -1012,7 +1012,7 @@ fn test_migrate_identities_to_v2() {
         );
         assert!(Identities::<Test>::get(account_id_1).is_none());
         assert!(Identities::<Test>::get(account_id_2).is_none());
-        assert!(SubnetIdentities::<Test>::get(42u16).is_none());
+        assert!(SubnetIdentities::<Test>::get(NetUid::from(42)).is_none());
 
         let new_identity_1 = IdentitiesV2::<Test>::get(account_id_1)
             .expect("ChainOne should be migrated to IdentitiesV2");
@@ -1032,7 +1032,7 @@ fn test_migrate_identities_to_v2() {
         assert_eq!(new_identity_2.url, chaintwo_url);
         assert_eq!(new_identity_2.github_repo, b"".to_vec());
 
-        let new_subnet_identity = SubnetIdentitiesV2::<Test>::get(42u16)
+        let new_subnet_identity = SubnetIdentitiesV2::<Test>::get(NetUid::from(42))
             .expect("SubnetExample should be migrated to SubnetIdentitiesV2");
 
         let expected_subnet_url = b"".to_vec();
@@ -1061,7 +1061,7 @@ fn test_do_set_subnet_identity() {
     new_test_ext(1).execute_with(|| {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
-        let netuid = 1;
+        let netuid = NetUid::from(1);
 
         // Register a hotkey for the coldkey
         add_network(netuid, 13, 0);
@@ -1243,7 +1243,7 @@ fn test_is_valid_subnet_identity() {
 fn test_set_identity_for_non_existent_subnet() {
     new_test_ext(1).execute_with(|| {
         let coldkey = U256::from(1);
-        let netuid = 999; // Non-existent subnet ID
+        let netuid = NetUid::from(999); // Non-existent subnet ID
 
         // Subnet identity data
         let subnet_name = b"Non-existent Subnet".to_vec();
@@ -1275,7 +1275,7 @@ fn test_set_identity_for_non_existent_subnet() {
 #[test]
 fn test_set_subnet_identity_dispatch_info_ok() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let subnet_name: Vec<u8> = b"JesusSubnet".to_vec();
         let github_repo: Vec<u8> = b"bible.com".to_vec();
         let subnet_contact: Vec<u8> = b"https://www.vatican.va".to_vec();
@@ -1310,7 +1310,7 @@ fn test_serve_axon_validate() {
 
     new_test_ext(0).execute_with(|| {
         let hotkey = U256::from(1);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let version: u32 = 2;
         let ip: u128 = 1676056785;
         let port: u16 = 128;
diff --git a/pallets/subtensor/src/tests/staking.rs b/pallets/subtensor/src/tests/staking.rs
index 9220fa7296..7efc9aaaf5 100644
--- a/pallets/subtensor/src/tests/staking.rs
+++ b/pallets/subtensor/src/tests/staking.rs
@@ -22,7 +22,7 @@ fn test_add_stake_dispatch_info_ok() {
     new_test_ext(1).execute_with(|| {
         let hotkey = U256::from(0);
         let amount_staked = 5000;
-        let netuid = 1;
+        let netuid = NetUid::from(1);
         let call = RuntimeCall::SubtensorModule(SubtensorCall::add_stake {
             hotkey,
             netuid,
@@ -47,7 +47,7 @@ fn test_add_stake_ok_no_emission() {
         let fee = DefaultStakingFee::<Test>::get();
 
         //add network
-        let netuid: u16 = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
+        let netuid = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
 
         // Give it some $$$ in his coldkey balance
         SubtensorModule::add_balance_to_coldkey_account(&coldkey_account_id, amount);
@@ -98,7 +98,7 @@ fn test_add_stake_ok_no_emission() {
 //         let fee = DefaultStakingFee::<Test>::get();
 //
 //         //add network
-//         let netuid: u16 = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
+//         let netuid = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
 //
 //         // Give it some $$$ in his coldkey balance
 //         SubtensorModule::add_balance_to_coldkey_account(&coldkey_account_id, amount);
@@ -184,7 +184,7 @@ fn test_add_stake_ok_no_emission() {
 //         let coldkey_account_id = U256::from(55453);
 //         let amount = DefaultMinStake::<Test>::get() * 100;
 //         //add network
-//         let netuid: u16 = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
+//         let netuid = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
 //
 //         // Transfer to hotkey account, and check if the result is ok
 //         assert_ok!(SubtensorModule::add_stake_aggregate(
@@ -967,12 +967,12 @@ fn test_dividends_with_run_to_block() {
         let initial_stake: u64 = 5000;
 
         //add network
-        let netuid: u16 = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
+        let netuid = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
         Tempo::<Test>::insert(netuid, 13);
 
         // Register neuron, this will set a self weight
         SubtensorModule::set_max_registrations_per_block(netuid, 3);
-        SubtensorModule::set_max_allowed_uids(1, 5);
+        SubtensorModule::set_max_allowed_uids(1.into(), 5);
 
         register_ok_neuron(netuid, neuron_src_hotkey_id, coldkey_account_id, 192213123);
         register_ok_neuron(netuid, neuron_dest_hotkey_id, coldkey_account_id, 12323);
@@ -1016,7 +1016,7 @@ fn test_add_stake_err_signature() {
     new_test_ext(1).execute_with(|| {
         let hotkey_account_id = U256::from(654); // bogus
         let amount = 20000; // Not used
-        let netuid = 1;
+        let netuid = NetUid::from(1);
 
         assert_err!(
             SubtensorModule::add_stake(RawOrigin::None.into(), hotkey_account_id, netuid, amount),
@@ -1054,7 +1054,7 @@ fn test_add_stake_ok_neuron_does_not_belong_to_coldkey() {
         let coldkey_id = U256::from(544);
         let hotkey_id = U256::from(54544);
         let other_cold_key = U256::from(99498);
-        let netuid: u16 = add_dynamic_network(&hotkey_id, &coldkey_id);
+        let netuid = add_dynamic_network(&hotkey_id, &coldkey_id);
         let stake = DefaultMinStake::<Test>::get() * 10;
 
         // Give it some $$$ in his coldkey balance
@@ -1076,7 +1076,7 @@ fn test_add_stake_err_not_enough_belance() {
         let coldkey_id = U256::from(544);
         let hotkey_id = U256::from(54544);
         let stake = DefaultMinStake::<Test>::get() * 10;
-        let netuid: u16 = add_dynamic_network(&hotkey_id, &coldkey_id);
+        let netuid = add_dynamic_network(&hotkey_id, &coldkey_id);
 
         // Lets try to stake with 0 balance in cold key account
         assert!(SubtensorModule::get_coldkey_balance(&coldkey_id) < stake);
@@ -1100,7 +1100,7 @@ fn test_add_stake_total_balance_no_change() {
     new_test_ext(1).execute_with(|| {
         let hotkey_account_id = U256::from(551337);
         let coldkey_account_id = U256::from(51337);
-        let netuid: u16 = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
+        let netuid = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
 
         // Give it some $$$ in his coldkey balance
         let initial_balance = 10000;
@@ -1150,7 +1150,7 @@ fn test_add_stake_total_issuance_no_change() {
     new_test_ext(1).execute_with(|| {
         let hotkey_account_id = U256::from(561337);
         let coldkey_account_id = U256::from(61337);
-        let netuid: u16 = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
+        let netuid = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
 
         // Give it some $$$ in his coldkey balance
         let initial_balance = 10000;
@@ -1201,7 +1201,7 @@ fn test_remove_stake_dispatch_info_ok() {
     new_test_ext(1).execute_with(|| {
         let hotkey = U256::from(0);
         let amount_unstaked = 5000;
-        let netuid = 1;
+        let netuid = NetUid::from(1);
         let call = RuntimeCall::SubtensorModule(SubtensorCall::remove_stake {
             hotkey,
             netuid,
@@ -1227,7 +1227,7 @@ fn test_remove_stake_ok_no_emission() {
         let coldkey_account_id = U256::from(4343);
         let hotkey_account_id = U256::from(4968585);
         let amount = DefaultMinStake::<Test>::get() * 10;
-        let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
         register_ok_neuron(netuid, hotkey_account_id, coldkey_account_id, 192213123);
 
         // Some basic assertions
@@ -1296,7 +1296,7 @@ fn test_remove_stake_ok_no_emission() {
 //         let coldkey_account_id = U256::from(4343);
 //         let hotkey_account_id = U256::from(4968585);
 //         let amount = DefaultMinStake::<Test>::get() * 10;
-//         let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+//         let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
 //         register_ok_neuron(netuid, hotkey_account_id, coldkey_account_id, 192213123);
 //
 //         // Some basic assertions
@@ -1393,7 +1393,7 @@ fn test_remove_stake_ok_no_emission() {
 //         let coldkey_account_id = U256::from(4343);
 //         let hotkey_account_id = U256::from(4968585);
 //         let amount = DefaultMinStake::<Test>::get() * 10;
-//         let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+//         let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
 //         register_ok_neuron(netuid, hotkey_account_id, coldkey_account_id, 192213123);
 //
 //         assert_ok!(SubtensorModule::remove_stake_aggregate(
@@ -1435,7 +1435,7 @@ fn test_remove_stake_amount_too_low() {
         let coldkey_account_id = U256::from(4343);
         let hotkey_account_id = U256::from(4968585);
         let amount = 10_000;
-        let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
         register_ok_neuron(netuid, hotkey_account_id, coldkey_account_id, 192213123);
 
         // Some basic assertions
@@ -1475,7 +1475,7 @@ fn test_remove_stake_err_signature() {
     new_test_ext(1).execute_with(|| {
         let hotkey_account_id = U256::from(4968585);
         let amount = 10000; // Amount to be removed
-        let netuid = 1;
+        let netuid = NetUid::from(1);
 
         assert_err!(
             SubtensorModule::remove_stake(
@@ -1496,7 +1496,7 @@ fn test_remove_stake_ok_hotkey_does_not_belong_to_coldkey() {
         let hotkey_id = U256::from(54544);
         let other_cold_key = U256::from(99498);
         let amount = DefaultMinStake::<Test>::get() * 10;
-        let netuid: u16 = add_dynamic_network(&hotkey_id, &coldkey_id);
+        let netuid = add_dynamic_network(&hotkey_id, &coldkey_id);
 
         // Give the neuron some stake to remove
         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
@@ -1549,7 +1549,7 @@ fn test_remove_stake_total_balance_no_change() {
         let hotkey_account_id = U256::from(571337);
         let coldkey_account_id = U256::from(71337);
         let amount = DefaultMinStake::<Test>::get() * 10;
-        let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
         register_ok_neuron(netuid, hotkey_account_id, coldkey_account_id, 192213123);
 
         // Some basic assertions
@@ -1697,7 +1697,7 @@ fn test_remove_stake_total_issuance_no_change() {
         let hotkey_account_id = U256::from(581337);
         let coldkey_account_id = U256::from(81337);
         let amount = DefaultMinStake::<Test>::get() * 10;
-        let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
         let fee = DefaultStakingFee::<Test>::get();
         register_ok_neuron(netuid, hotkey_account_id, coldkey_account_id, 192213123);
 
@@ -1837,7 +1837,7 @@ fn test_remove_prev_epoch_stake() {
                 let hotkey_account_id = U256::from(581337);
                 let coldkey_account_id = U256::from(81337);
                 let amount = *amount_to_stake;
-                let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+                let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
                 register_ok_neuron(netuid, hotkey_account_id, coldkey_account_id, 192213123);
 
                 // Give it some $$$ in his coldkey balance
@@ -1887,7 +1887,7 @@ fn test_staking_sets_div_variables() {
         let hotkey_account_id = U256::from(581337);
         let coldkey_account_id = U256::from(81337);
         let amount = 100_000_000_000;
-        let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
         let tempo = 10;
         Tempo::<Test>::insert(netuid, tempo);
         register_ok_neuron(netuid, hotkey_account_id, coldkey_account_id, 192213123);
@@ -1983,7 +1983,7 @@ fn test_add_stake_to_hotkey_account_ok() {
         let hotkey_id = U256::from(5445);
         let coldkey_id = U256::from(5443433);
         let amount = 10_000;
-        let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
         register_ok_neuron(netuid, hotkey_id, coldkey_id, 192213123);
 
         // There is no stake in the system at first, other than the network initial lock so result;
@@ -2018,7 +2018,7 @@ fn test_remove_stake_from_hotkey_account() {
         let hotkey_id = U256::from(5445);
         let coldkey_id = U256::from(5443433);
         let amount = 10_000;
-        let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
         register_ok_neuron(netuid, hotkey_id, coldkey_id, 192213123);
 
         // Add some stake that can be removed
@@ -2194,7 +2194,7 @@ fn test_hotkey_belongs_to_coldkey_ok() {
     new_test_ext(1).execute_with(|| {
         let hotkey_id = U256::from(4434334);
         let coldkey_id = U256::from(34333);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let start_nonce: u64 = 0;
         add_network(netuid, tempo, 0);
@@ -2244,7 +2244,7 @@ fn test_has_enough_stake_yes() {
         let hotkey_id = U256::from(4334);
         let coldkey_id = U256::from(87989);
         let intial_amount = 10_000;
-        let netuid = add_dynamic_network(&hotkey_id, &coldkey_id);
+        let netuid = NetUid::from(add_dynamic_network(&hotkey_id, &coldkey_id));
         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
             &hotkey_id,
             &coldkey_id,
@@ -2340,7 +2340,7 @@ fn test_has_enough_stake_no_for_zero() {
 #[test]
 fn test_non_existent_account() {
     new_test_ext(1).execute_with(|| {
-        let netuid = 1;
+        let netuid = NetUid::from(1);
         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
             &U256::from(0),
             &(U256::from(0)),
@@ -2418,7 +2418,7 @@ fn test_clear_small_nominations() {
         let hot2 = U256::from(2);
         let cold1 = U256::from(3);
         let cold2 = U256::from(4);
-        let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
         let amount = DefaultMinStake::<Test>::get() * 10;
         let fee: u64 = DefaultMinStake::<Test>::get();
         let init_balance = amount + fee + ExistentialDeposit::get();
@@ -2595,7 +2595,7 @@ fn test_delegate_take_can_be_decreased() {
         SubtensorModule::add_balance_to_coldkey_account(&coldkey0, 100000);
 
         // Register the neuron to a new network
-        let netuid = 1;
+        let netuid = NetUid::from(1);
         add_network(netuid, 1, 0);
         register_ok_neuron(netuid, hotkey0, coldkey0, 124124);
 
@@ -2630,7 +2630,7 @@ fn test_can_set_min_take_ok() {
         SubtensorModule::add_balance_to_coldkey_account(&coldkey0, 100000);
 
         // Register the neuron to a new network
-        let netuid = 1;
+        let netuid = NetUid::from(1);
         add_network(netuid, 1, 0);
         register_ok_neuron(netuid, hotkey0, coldkey0, 124124);
 
@@ -2662,7 +2662,7 @@ fn test_delegate_take_can_not_be_increased_with_decrease_take() {
         SubtensorModule::add_balance_to_coldkey_account(&coldkey0, 100000);
 
         // Register the neuron to a new network
-        let netuid = 1;
+        let netuid = NetUid::from(1);
         add_network(netuid, 1, 0);
         register_ok_neuron(netuid, hotkey0, coldkey0, 124124);
 
@@ -2697,7 +2697,7 @@ fn test_delegate_take_can_be_increased() {
         SubtensorModule::add_balance_to_coldkey_account(&coldkey0, 100000);
 
         // Register the neuron to a new network
-        let netuid = 1;
+        let netuid = NetUid::from(1);
         add_network(netuid, 1, 0);
         register_ok_neuron(netuid, hotkey0, coldkey0, 124124);
 
@@ -2732,7 +2732,7 @@ fn test_delegate_take_can_not_be_decreased_with_increase_take() {
         SubtensorModule::add_balance_to_coldkey_account(&coldkey0, 100000);
 
         // Register the neuron to a new network
-        let netuid = 1;
+        let netuid = NetUid::from(1);
         add_network(netuid, 1, 0);
         register_ok_neuron(netuid, hotkey0, coldkey0, 124124);
 
@@ -2771,7 +2771,7 @@ fn test_delegate_take_can_be_increased_to_limit() {
         SubtensorModule::add_balance_to_coldkey_account(&coldkey0, 100000);
 
         // Register the neuron to a new network
-        let netuid = 1;
+        let netuid = NetUid::from(1);
         add_network(netuid, 1, 0);
         register_ok_neuron(netuid, hotkey0, coldkey0, 124124);
 
@@ -2809,7 +2809,7 @@ fn test_delegate_take_can_not_be_increased_beyond_limit() {
         SubtensorModule::add_balance_to_coldkey_account(&coldkey0, 100000);
 
         // Register the neuron to a new network
-        let netuid = 1;
+        let netuid = NetUid::from(1);
         add_network(netuid, 1, 0);
         register_ok_neuron(netuid, hotkey0, coldkey0, 124124);
 
@@ -2851,7 +2851,7 @@ fn test_rate_limits_enforced_on_increase_take() {
         SubtensorModule::add_balance_to_coldkey_account(&coldkey0, 100000);
 
         // Register the neuron to a new network
-        let netuid = 1;
+        let netuid = NetUid::from(1);
         add_network(netuid, 1, 0);
         register_ok_neuron(netuid, hotkey0, coldkey0, 124124);
 
@@ -2911,7 +2911,7 @@ fn test_rate_limits_enforced_on_decrease_before_increase_take() {
         SubtensorModule::add_balance_to_coldkey_account(&coldkey0, 100000);
 
         // Register the neuron to a new network
-        let netuid = 1;
+        let netuid = NetUid::from(1);
         add_network(netuid, 1, 0);
         register_ok_neuron(netuid, hotkey0, coldkey0, 124124);
 
@@ -3041,7 +3041,7 @@ fn test_get_total_delegated_stake_no_delegations() {
     new_test_ext(1).execute_with(|| {
         let delegate = U256::from(1);
         let coldkey = U256::from(2);
-        let netuid = 1u16;
+        let netuid = NetUid::from(1u16);
 
         add_network(netuid, 1, 0);
         register_ok_neuron(netuid, delegate, coldkey, 0);
@@ -3236,7 +3236,7 @@ fn test_mining_emission_distribution_validator_valiminer_miner() {
         let validator_miner_hotkey = U256::from(4);
         let miner_coldkey = U256::from(5);
         let miner_hotkey = U256::from(6);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let subnet_tempo = 10;
         let stake = 100_000_000_000;
 
@@ -3329,7 +3329,7 @@ fn test_staking_too_little_fails() {
         let amount = 10_000;
 
         //add network
-        let netuid: u16 = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
+        let netuid = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
 
         // Give it some $$$ in his coldkey balance
         SubtensorModule::add_balance_to_coldkey_account(&coldkey_account_id, amount);
@@ -3590,7 +3590,7 @@ fn test_add_stake_limit_validate() {
         let amount = 900_000_000_000;
 
         // add network
-        let netuid: u16 = add_dynamic_network(&hotkey, &coldkey);
+        let netuid = add_dynamic_network(&hotkey, &coldkey);
 
         // Force-set alpha in and tao reserve to make price equal 1.5
         let tao_reserve: U96F32 = U96F32::from_num(150_000_000_000_u64);
@@ -3646,7 +3646,7 @@ fn test_remove_stake_limit_validate() {
         let unstake_amount = 150_000_000_000;
 
         // add network
-        let netuid: u16 = add_dynamic_network(&hotkey, &coldkey);
+        let netuid = add_dynamic_network(&hotkey, &coldkey);
 
         // Give the neuron some stake to remove
         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
@@ -3897,31 +3897,31 @@ fn test_max_amount_add_root() {
     new_test_ext(0).execute_with(|| {
         // 0 price on root => max is 0
         assert_eq!(
-            SubtensorModule::get_max_amount_add(0, 0),
+            SubtensorModule::get_max_amount_add(NetUid::ROOT, 0),
             Err(Error::<Test>::ZeroMaxStakeAmount)
         );
 
         // 0.999999... price on root => max is 0
         assert_eq!(
-            SubtensorModule::get_max_amount_add(0, 999_999_999),
+            SubtensorModule::get_max_amount_add(NetUid::ROOT, 999_999_999),
             Err(Error::<Test>::ZeroMaxStakeAmount)
         );
 
         // 1.0 price on root => max is u64::MAX
         assert_eq!(
-            SubtensorModule::get_max_amount_add(0, 1_000_000_000),
+            SubtensorModule::get_max_amount_add(NetUid::ROOT, 1_000_000_000),
             Ok(u64::MAX)
         );
 
         // 1.000...001 price on root => max is u64::MAX
         assert_eq!(
-            SubtensorModule::get_max_amount_add(0, 1_000_000_001),
+            SubtensorModule::get_max_amount_add(NetUid::ROOT, 1_000_000_001),
             Ok(u64::MAX)
         );
 
         // 2.0 price on root => max is u64::MAX
         assert_eq!(
-            SubtensorModule::get_max_amount_add(0, 2_000_000_000),
+            SubtensorModule::get_max_amount_add(NetUid::ROOT, 2_000_000_000),
             Ok(u64::MAX)
         );
     });
@@ -3930,7 +3930,7 @@ fn test_max_amount_add_root() {
 #[test]
 fn test_max_amount_add_stable() {
     new_test_ext(0).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         add_network(netuid, 1, 0);
 
         // 0 price => max is 0
@@ -4134,35 +4134,38 @@ fn test_max_amount_add_dynamic() {
 fn test_max_amount_remove_root() {
     new_test_ext(0).execute_with(|| {
         // 0 price on root => max is u64::MAX
-        assert_eq!(SubtensorModule::get_max_amount_remove(0, 0), Ok(u64::MAX));
+        assert_eq!(
+            SubtensorModule::get_max_amount_remove(NetUid::ROOT, 0),
+            Ok(u64::MAX)
+        );
 
         // 0.5 price on root => max is u64::MAX
         assert_eq!(
-            SubtensorModule::get_max_amount_remove(0, 500_000_000),
+            SubtensorModule::get_max_amount_remove(NetUid::ROOT, 500_000_000),
             Ok(u64::MAX)
         );
 
         // 0.999999... price on root => max is u64::MAX
         assert_eq!(
-            SubtensorModule::get_max_amount_remove(0, 999_999_999),
+            SubtensorModule::get_max_amount_remove(NetUid::ROOT, 999_999_999),
             Ok(u64::MAX)
         );
 
         // 1.0 price on root => max is u64::MAX
         assert_eq!(
-            SubtensorModule::get_max_amount_remove(0, 1_000_000_000),
+            SubtensorModule::get_max_amount_remove(NetUid::ROOT, 1_000_000_000),
             Ok(u64::MAX)
         );
 
         // 1.000...001 price on root => max is 0
         assert_eq!(
-            SubtensorModule::get_max_amount_remove(0, 1_000_000_001),
+            SubtensorModule::get_max_amount_remove(NetUid::ROOT, 1_000_000_001),
             Err(Error::<Test>::ZeroMaxStakeAmount)
         );
 
         // 2.0 price on root => max is 0
         assert_eq!(
-            SubtensorModule::get_max_amount_remove(0, 2_000_000_000),
+            SubtensorModule::get_max_amount_remove(NetUid::ROOT, 2_000_000_000),
             Err(Error::<Test>::ZeroMaxStakeAmount)
         );
     });
@@ -4171,7 +4174,7 @@ fn test_max_amount_remove_root() {
 #[test]
 fn test_max_amount_remove_stable() {
     new_test_ext(0).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         add_network(netuid, 1, 0);
 
         // 0 price => max is u64::MAX
@@ -4370,35 +4373,38 @@ fn test_max_amount_remove_dynamic() {
 fn test_max_amount_move_root_root() {
     new_test_ext(0).execute_with(|| {
         // 0 price on (root, root) exchange => max is u64::MAX
-        assert_eq!(SubtensorModule::get_max_amount_move(0, 0, 0), Ok(u64::MAX));
+        assert_eq!(
+            SubtensorModule::get_max_amount_move(NetUid::ROOT, NetUid::ROOT, 0),
+            Ok(u64::MAX)
+        );
 
         // 0.5 price on (root, root) => max is u64::MAX
         assert_eq!(
-            SubtensorModule::get_max_amount_move(0, 0, 500_000_000),
+            SubtensorModule::get_max_amount_move(NetUid::ROOT, NetUid::ROOT, 500_000_000),
             Ok(u64::MAX)
         );
 
         // 0.999999... price on (root, root) => max is u64::MAX
         assert_eq!(
-            SubtensorModule::get_max_amount_move(0, 0, 999_999_999),
+            SubtensorModule::get_max_amount_move(NetUid::ROOT, NetUid::ROOT, 999_999_999),
             Ok(u64::MAX)
         );
 
         // 1.0 price on (root, root) => max is u64::MAX
         assert_eq!(
-            SubtensorModule::get_max_amount_move(0, 0, 1_000_000_000),
+            SubtensorModule::get_max_amount_move(NetUid::ROOT, NetUid::ROOT, 1_000_000_000),
             Ok(u64::MAX)
         );
 
         // 1.000...001 price on (root, root) => max is 0
         assert_eq!(
-            SubtensorModule::get_max_amount_move(0, 0, 1_000_000_001),
+            SubtensorModule::get_max_amount_move(NetUid::ROOT, NetUid::ROOT, 1_000_000_001),
             Err(Error::<Test>::ZeroMaxStakeAmount)
         );
 
         // 2.0 price on (root, root) => max is 0
         assert_eq!(
-            SubtensorModule::get_max_amount_move(0, 0, 2_000_000_000),
+            SubtensorModule::get_max_amount_move(NetUid::ROOT, NetUid::ROOT, 2_000_000_000),
             Err(Error::<Test>::ZeroMaxStakeAmount)
         );
     });
@@ -4408,42 +4414,42 @@ fn test_max_amount_move_root_root() {
 #[test]
 fn test_max_amount_move_root_stable() {
     new_test_ext(0).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         add_network(netuid, 1, 0);
 
         // 0 price on (root, stable) exchange => max is u64::MAX
         assert_eq!(
-            SubtensorModule::get_max_amount_move(0, netuid, 0),
+            SubtensorModule::get_max_amount_move(NetUid::ROOT, netuid, 0),
             Ok(u64::MAX)
         );
 
         // 0.5 price on (root, stable) => max is u64::MAX
         assert_eq!(
-            SubtensorModule::get_max_amount_move(0, netuid, 500_000_000),
+            SubtensorModule::get_max_amount_move(NetUid::ROOT, netuid, 500_000_000),
             Ok(u64::MAX)
         );
 
         // 0.999999... price on (root, stable) => max is u64::MAX
         assert_eq!(
-            SubtensorModule::get_max_amount_move(0, netuid, 999_999_999),
+            SubtensorModule::get_max_amount_move(NetUid::ROOT, netuid, 999_999_999),
             Ok(u64::MAX)
         );
 
         // 1.0 price on (root, stable) => max is u64::MAX
         assert_eq!(
-            SubtensorModule::get_max_amount_move(0, netuid, 1_000_000_000),
+            SubtensorModule::get_max_amount_move(NetUid::ROOT, netuid, 1_000_000_000),
             Ok(u64::MAX)
         );
 
         // 1.000...001 price on (root, stable) => max is 0
         assert_eq!(
-            SubtensorModule::get_max_amount_move(0, netuid, 1_000_000_001),
+            SubtensorModule::get_max_amount_move(NetUid::ROOT, netuid, 1_000_000_001),
             Err(Error::<Test>::ZeroMaxStakeAmount)
         );
 
         // 2.0 price on (root, stable) => max is 0
         assert_eq!(
-            SubtensorModule::get_max_amount_move(0, netuid, 2_000_000_000),
+            SubtensorModule::get_max_amount_move(NetUid::ROOT, netuid, 2_000_000_000),
             Err(Error::<Test>::ZeroMaxStakeAmount)
         );
     });
@@ -4454,7 +4460,7 @@ fn test_max_amount_move_root_stable() {
 fn test_max_amount_move_stable_dynamic() {
     new_test_ext(0).execute_with(|| {
         // Add stable subnet
-        let stable_netuid: u16 = 1;
+        let stable_netuid = NetUid::from(1);
         add_network(stable_netuid, 1, 0);
 
         // Add dynamic subnet
@@ -4528,7 +4534,7 @@ fn test_max_amount_move_stable_dynamic() {
 fn test_max_amount_move_dynamic_stable() {
     new_test_ext(0).execute_with(|| {
         // Add stable subnet
-        let stable_netuid: u16 = 1;
+        let stable_netuid = NetUid::from(1);
         add_network(stable_netuid, 1, 0);
 
         // Add dynamic subnet
@@ -4850,7 +4856,7 @@ fn test_add_stake_limit_ok() {
         let fee = DefaultStakingFee::<Test>::get();
 
         // add network
-        let netuid: u16 = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
+        let netuid = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
 
         // Forse-set alpha in and tao reserve to make price equal 1.5
         let tao_reserve: U96F32 = U96F32::from_num(150_000_000_000_u64);
@@ -4917,7 +4923,7 @@ fn test_add_stake_limit_ok() {
 //         let fee = DefaultStakingFee::<Test>::get();
 //
 //         // add network
-//         let netuid: u16 = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
+//         let netuid = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
 //
 //         // Forse-set alpha in and tao reserve to make price equal 1.5
 //         let tao_reserve: U96F32 = U96F32::from_num(150_000_000_000_u64);
@@ -5012,7 +5018,7 @@ fn test_add_stake_limit_ok() {
 //         let amount = 900_000_000_000;
 //         let limit_price = 6_000_000_000;
 //         // add network
-//         let netuid: u16 = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
+//         let netuid = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
 //
 //         assert_ok!(SubtensorModule::add_stake_limit_aggregate(
 //             RuntimeOrigin::signed(coldkey_account_id),
@@ -5055,7 +5061,7 @@ fn test_add_stake_limit_fill_or_kill() {
         let amount = 900_000_000_000; // over the maximum
 
         // add network
-        let netuid: u16 = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
+        let netuid = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
 
         // Force-set alpha in and tao reserve to make price equal 1.5
         let tao_reserve: U96F32 = U96F32::from_num(150_000_000_000_u64);
@@ -5112,7 +5118,7 @@ fn test_add_stake_limit_partial_zero_max_stake_amount_error() {
         let tao_reserve: U96F32 = U96F32::from_num(5_032_494_439_940_u64);
         let alpha_in: U96F32 = U96F32::from_num(186_268_425_402_874_u64);
 
-        let netuid: u16 = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
+        let netuid = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
         SubnetTAO::<Test>::insert(netuid, tao_reserve.to_num::<u64>());
         SubnetAlphaIn::<Test>::insert(netuid, alpha_in.to_num::<u64>());
 
@@ -5142,7 +5148,7 @@ fn test_remove_stake_limit_ok() {
         let fee = DefaultStakingFee::<Test>::get();
 
         // add network
-        let netuid: u16 = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
+        let netuid = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
 
         // Give the neuron some stake to remove
         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
@@ -5204,7 +5210,7 @@ fn test_remove_stake_limit_ok() {
 //         let fee = DefaultStakingFee::<Test>::get();
 //
 //         // add network
-//         let netuid: u16 = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
+//         let netuid = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
 //
 //         // Give the neuron some stake to remove
 //         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
@@ -5294,7 +5300,7 @@ fn test_remove_stake_limit_ok() {
 //         let unstake_amount = 150_000_000_000;
 //         let limit_price = 1_350_000_000;
 //         // add network
-//         let netuid: u16 = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
+//         let netuid = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
 //
 //         // Give the neuron some stake to remove
 //         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
@@ -5346,7 +5352,7 @@ fn test_remove_stake_limit_fill_or_kill() {
         let unstake_amount = 150_000_000_000;
 
         // add network
-        let netuid: u16 = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
+        let netuid = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
 
         // Give the neuron some stake to remove
         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
@@ -5407,7 +5413,7 @@ fn test_remove_stake_limit_fill_or_kill() {
 //         let amount_added = 1_274_280_132;
 
 //         //add network
-//         let netuid: u16 = add_dynamic_network(&sn_owner_coldkey, &sn_owner_coldkey);
+//         let netuid = add_dynamic_network(&sn_owner_coldkey, &sn_owner_coldkey);
 
 //         // Register hotkey on netuid
 //         register_ok_neuron(netuid, hotkey_account_id, hotkey_owner_account_id, 0);
@@ -5466,7 +5472,7 @@ fn test_remove_stake_limit_fill_or_kill() {
 //         let fee = DefaultStakingFee::<Test>::get();
 
 //         //add network
-//         let netuid: u16 = add_dynamic_network(&sn_owner_coldkey, &sn_owner_coldkey);
+//         let netuid = add_dynamic_network(&sn_owner_coldkey, &sn_owner_coldkey);
 
 //         // Register hotkey on netuid
 //         register_ok_neuron(netuid, hotkey_account_id, hotkey_owner_account_id, 0);
@@ -5533,7 +5539,7 @@ fn test_add_stake_specific_stake_into_subnet_fail() {
         let tao_staked = 200_000_000;
 
         //add network
-        let netuid: u16 = add_dynamic_network(&sn_owner_coldkey, &sn_owner_coldkey);
+        let netuid = add_dynamic_network(&sn_owner_coldkey, &sn_owner_coldkey);
 
         // Register hotkey on netuid
         register_ok_neuron(netuid, hotkey_account_id, hotkey_owner_account_id, 0);
@@ -5597,7 +5603,7 @@ fn test_remove_99_9991_per_cent_stake_removes_all() {
         let hotkey_account_id = U256::from(581337);
         let coldkey_account_id = U256::from(81337);
         let amount = 10_000_000_000;
-        let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
         let mut fee = DefaultStakingFee::<Test>::get();
         register_ok_neuron(netuid, hotkey_account_id, coldkey_account_id, 192213123);
 
@@ -5655,7 +5661,7 @@ fn test_remove_99_9989_per_cent_stake_leaves_a_little() {
         let hotkey_account_id = U256::from(581337);
         let coldkey_account_id = U256::from(81337);
         let amount = 10_000_000_000;
-        let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
         let fee = DefaultStakingFee::<Test>::get();
         register_ok_neuron(netuid, hotkey_account_id, coldkey_account_id, 192213123);
 
@@ -5714,9 +5720,8 @@ fn test_move_stake_limit_partial() {
         let move_amount = 150_000_000_000;
 
         // add network
-        let origin_netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
-        let destination_netuid: u16 =
-            add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+        let origin_netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+        let destination_netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
         register_ok_neuron(origin_netuid, hotkey, coldkey, 192213123);
         register_ok_neuron(destination_netuid, hotkey, coldkey, 192213123);
 
@@ -5775,7 +5780,7 @@ fn test_unstake_all_hits_liquidity_min() {
 
         let stake_amount = 190_000_000_000; // 190 Alpha
 
-        let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
         register_ok_neuron(netuid, hotkey, coldkey, 192213123);
         // Give the neuron some stake to remove
         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
@@ -5822,7 +5827,7 @@ fn test_unstake_all_alpha_hits_liquidity_min() {
 
         let stake_amount = 190_000_000_000; // 190 Alpha
 
-        let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
         register_ok_neuron(netuid, hotkey, coldkey, 192213123);
         // Give the neuron some stake to remove
         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
@@ -5869,7 +5874,7 @@ fn test_unstake_all_alpha_works() {
 
         let stake_amount = 190_000_000_000; // 190 Alpha
 
-        let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
         register_ok_neuron(netuid, hotkey, coldkey, 192213123);
         // Give the neuron some stake to remove
         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
@@ -5901,8 +5906,11 @@ fn test_unstake_all_alpha_works() {
         let new_alpha =
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid);
         assert_abs_diff_eq!(new_alpha, 0, epsilon = 1_000,);
-        let new_root =
-            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, 0);
+        let new_root = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+            &hotkey,
+            &coldkey,
+            NetUid::ROOT,
+        );
         assert!(new_root > 100_000);
     });
 }
@@ -5916,7 +5924,7 @@ fn test_unstake_all_alpha_works() {
 //
 //         let stake_amount = 190_000_000_000; // 190 Alpha
 //
-//         let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+//         let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
 //         register_ok_neuron(netuid, hotkey, coldkey, 192213123);
 //         // Give the neuron some stake to remove
 //         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
@@ -6021,7 +6029,7 @@ fn test_unstake_all_works() {
 
         let stake_amount = 190_000_000_000; // 190 Alpha
 
-        let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
         register_ok_neuron(netuid, hotkey, coldkey, 192213123);
         // Give the neuron some stake to remove
         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
@@ -6068,7 +6076,7 @@ fn test_unstake_all_works() {
 //
 //         let stake_amount = 190_000_000_000; // 190 Alpha
 //
-//         let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+//         let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
 //         register_ok_neuron(netuid, hotkey, coldkey, 192213123);
 //         // Give the neuron some stake to remove
 //         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
@@ -6170,7 +6178,7 @@ fn test_increase_stake_for_hotkey_and_coldkey_on_subnet_adds_to_staking_hotkeys_
         let coldkey1 = U256::from(2);
         let hotkey = U256::from(3);
 
-        let netuid = 1;
+        let netuid = NetUid::from(1);
         let stake_amount = 100_000_000_000;
 
         // Check no entry in the staking hotkeys map
diff --git a/pallets/subtensor/src/tests/staking2.rs b/pallets/subtensor/src/tests/staking2.rs
index 6fbabf83b2..7b50dd5e85 100644
--- a/pallets/subtensor/src/tests/staking2.rs
+++ b/pallets/subtensor/src/tests/staking2.rs
@@ -12,7 +12,7 @@ use substrate_fixed::types::{I96F32, U96F32};
 #[test]
 fn test_stake_base_case() {
     new_test_ext(1).execute_with(|| {
-        let netuid = 1;
+        let netuid = NetUid::from(1);
         let tao_to_swap = 1_000_000_000; // 1 TAO
 
         // Set up the subnet with dynamic mechanism
@@ -78,7 +78,7 @@ fn test_stake_base_case() {
 #[test]
 fn test_share_based_staking() {
     new_test_ext(1).execute_with(|| {
-        let netuid = 1;
+        let netuid = NetUid::from(1);
         let primary_hotkey = U256::from(1);
         let primary_coldkey = U256::from(2);
         let stake_amount = 1_000_000_000; // 1 TAO
@@ -403,7 +403,7 @@ fn test_share_based_staking_denominator_precision() {
     .iter()
     .for_each(|test_case| {
         new_test_ext(1).execute_with(|| {
-            let netuid = 1;
+            let netuid = NetUid::from(1);
             let hotkey1 = U256::from(1);
             let coldkey1 = U256::from(2);
             let stake_amount = test_case.0;
@@ -457,7 +457,7 @@ fn test_share_based_staking_stake_unstake_inject() {
     .iter()
     .for_each(|test_case| {
         new_test_ext(1).execute_with(|| {
-            let netuid = 1;
+            let netuid = NetUid::from(1);
             let hotkey1 = U256::from(1);
             let coldkey1 = U256::from(2);
             let coldkey2 = U256::from(3);
@@ -527,7 +527,7 @@ fn test_share_based_staking_stake_inject_stake_new() {
     .iter()
     .for_each(|test_case| {
         new_test_ext(1).execute_with(|| {
-            let netuid = 1;
+            let netuid = NetUid::from(1);
             let hotkey1 = U256::from(1);
             let coldkey1 = U256::from(2);
             let coldkey2 = U256::from(3);
@@ -633,9 +633,9 @@ fn test_stake_fee_api() {
         let hotkey2 = U256::from(3);
         let coldkey2 = U256::from(4);
 
-        let netuid0 = 1;
-        let netuid1 = 2;
-        let root_netuid = SubtensorModule::get_root_netuid();
+        let netuid0 = NetUid::from(1);
+        let netuid1 = NetUid::from(2);
+        let root_netuid = NetUid::ROOT;
 
         let alpha_divs = 100_000_000_000;
         let total_hotkey_alpha = 100_000_000_000;
@@ -823,9 +823,9 @@ fn test_stake_fee_calculation() {
         let hotkey2 = U256::from(3);
         let coldkey2 = U256::from(4);
 
-        let netuid0 = 1;
-        let netuid1 = 2;
-        let root_netuid = SubtensorModule::get_root_netuid();
+        let netuid0 = NetUid::from(1);
+        let netuid1 = NetUid::from(2);
+        let root_netuid = NetUid::ROOT;
         // Set SubnetMechanism to 1 (Dynamic)
         SubnetMechanism::<Test>::insert(netuid0, 1);
         SubnetMechanism::<Test>::insert(netuid1, 1);
diff --git a/pallets/subtensor/src/tests/subnet.rs b/pallets/subtensor/src/tests/subnet.rs
index ec737f8601..4134a8226e 100644
--- a/pallets/subtensor/src/tests/subnet.rs
+++ b/pallets/subtensor/src/tests/subnet.rs
@@ -11,7 +11,7 @@ use sp_core::U256;
 #[test]
 fn test_do_start_call_ok() {
     new_test_ext(0).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let coldkey_account_id = U256::from(0);
 
@@ -39,7 +39,7 @@ fn test_do_start_call_ok() {
 #[test]
 fn test_do_start_call_fail_with_not_existed_subnet() {
     new_test_ext(0).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let coldkey_account_id = U256::from(0);
         assert_noop!(
             SubtensorModule::start_call(
@@ -54,7 +54,7 @@ fn test_do_start_call_fail_with_not_existed_subnet() {
 #[test]
 fn test_do_start_call_fail_not_owner() {
     new_test_ext(0).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let coldkey_account_id = U256::from(0);
         let wrong_owner_account_id = U256::from(1);
@@ -78,7 +78,7 @@ fn test_do_start_call_fail_not_owner() {
 #[test]
 fn test_do_start_call_fail_with_cannot_start_call_now() {
     new_test_ext(0).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let coldkey_account_id = U256::from(0);
 
@@ -99,7 +99,7 @@ fn test_do_start_call_fail_with_cannot_start_call_now() {
 #[test]
 fn test_do_start_call_fail_for_set_again() {
     new_test_ext(0).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let coldkey_account_id = U256::from(0);
 
@@ -129,7 +129,7 @@ fn test_do_start_call_fail_for_set_again() {
 #[test]
 fn test_do_start_call_ok_with_same_block_number_after_coinbase() {
     new_test_ext(0).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let coldkey_account_id = U256::from(0);
 
@@ -205,6 +205,7 @@ fn test_no_duplicates_in_get_symbol_for_subnet() {
 
     let mut seen = HashSet::new();
     for netuid in 0u16..=438 {
+        let netuid = NetUid::from(netuid);
         let symbol = Pallet::<Test>::get_symbol_for_subnet(netuid);
         assert!(
             seen.insert(symbol.clone()),
@@ -222,7 +223,7 @@ fn test_subtoken_enable() {
     // ensure_subtoken_enabled
     new_test_ext(1).execute_with(|| {
         let account = U256::from(0);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         // let to_be_set: u64 = 10
         add_network_disable_subtoken(netuid, 10, 0);
         assert!(!SubtokenEnabled::<Test>::get(netuid));
@@ -244,8 +245,8 @@ fn test_subtoken_enable() {
 fn test_subtoken_enable_reject_trading_before_enable() {
     // ensure_subtoken_enabled
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
-        let netuid2: u16 = 2;
+        let netuid = NetUid::from(1);
+        let netuid2 = NetUid::from(2);
         let hotkey_account_id: U256 = U256::from(1);
         let coldkey_account_id = U256::from(2);
         let hotkey_account_2_id: U256 = U256::from(3);
@@ -344,8 +345,8 @@ fn test_subtoken_enable_reject_trading_before_enable() {
 #[test]
 fn test_subtoken_enable_trading_ok_with_enable() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
-        let netuid2: u16 = 2;
+        let netuid = NetUid::from(1);
+        let netuid2 = NetUid::from(2);
         let hotkey_account_id: U256 = U256::from(1);
         let coldkey_account_id = U256::from(2);
         let hotkey_account_2_id: U256 = U256::from(3);
@@ -457,8 +458,8 @@ fn test_subtoken_enable_trading_ok_with_enable() {
 fn test_subtoken_enable_ok_for_burn_register_before_enable() {
     // ensure_subtoken_enabled
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
-        let netuid2: u16 = 2;
+        let netuid = NetUid::from(1);
+        let netuid2 = NetUid::from(2);
         let hotkey_account_id: U256 = U256::from(1);
         let coldkey_account_id = U256::from(2);
         let hotkey_account_2_id: U256 = U256::from(3);
diff --git a/pallets/subtensor/src/tests/swap_coldkey.rs b/pallets/subtensor/src/tests/swap_coldkey.rs
index 385830904c..e2afc98c89 100644
--- a/pallets/subtensor/src/tests/swap_coldkey.rs
+++ b/pallets/subtensor/src/tests/swap_coldkey.rs
@@ -53,7 +53,7 @@ fn test_swap_subnet_owner() {
     new_test_ext(1).execute_with(|| {
         let old_coldkey = U256::from(1);
         let new_coldkey = U256::from(2);
-        let netuid = 1u16;
+        let netuid = NetUid::from(1u16);
 
         add_network(netuid, 1, 0);
         SubnetOwner::<Test>::insert(netuid, old_coldkey);
@@ -80,7 +80,7 @@ fn test_swap_total_coldkey_stake() {
         let other_hotkey = U256::from(5);
         let stake = DefaultMinStake::<Test>::get() * 10;
 
-        let netuid = 1u16;
+        let netuid = NetUid::from(1u16);
         add_network(netuid, 1, 0);
         SubtensorModule::add_balance_to_coldkey_account(&old_coldkey, stake * 2 + 1_000);
         register_ok_neuron(netuid, hotkey, old_coldkey, 1001000);
@@ -242,8 +242,8 @@ fn test_swap_with_multiple_subnets() {
     new_test_ext(1).execute_with(|| {
         let old_coldkey = U256::from(1);
         let new_coldkey = U256::from(2);
-        let netuid1 = 1u16;
-        let netuid2 = 2u16;
+        let netuid1 = NetUid::from(1);
+        let netuid2 = NetUid::from(2);
 
         add_network(netuid1, 1, 0);
         add_network(netuid2, 1, 0);
@@ -288,7 +288,7 @@ fn test_swap_idempotency() {
         let old_coldkey = U256::from(1);
         let new_coldkey = U256::from(2);
         let hotkey = U256::from(3);
-        let netuid = 1u16;
+        let netuid = NetUid::from(1u16);
         let stake = DefaultMinStake::<Test>::get() * 10;
 
         // Add a network
@@ -340,8 +340,8 @@ fn test_swap_with_max_values() {
         let hotkey = U256::from(5);
         let hotkey2 = U256::from(6);
         let other_coldkey = U256::from(7);
-        let netuid = 1u16;
-        let netuid2 = 2u16;
+        let netuid = NetUid::from(1);
+        let netuid2 = NetUid::from(2);
         let stake = 10_000;
         let max_stake = 21_000_000_000_000_000; // 21 Million TAO; max possible balance.
         let fee = DefaultStakingFee::<Test>::get();
@@ -412,7 +412,7 @@ fn test_swap_with_non_existent_new_coldkey() {
         let new_coldkey = U256::from(2);
         let hotkey = U256::from(3);
         let stake = DefaultMinStake::<Test>::get() * 10;
-        let netuid = 1u16;
+        let netuid = NetUid::from(1u16);
         let fee = DefaultStakingFee::<Test>::get();
 
         add_network(netuid, 1, 0);
@@ -535,7 +535,7 @@ fn test_swap_concurrent_modifications() {
         let old_coldkey = U256::from(1);
         let new_coldkey = U256::from(2);
         let hotkey = U256::from(3);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let initial_stake = 1_000_000_000_000;
         let additional_stake = 500_000_000_000;
         let initial_stake_alpha =
@@ -616,7 +616,7 @@ fn test_swap_with_invalid_subnet_ownership() {
     new_test_ext(1).execute_with(|| {
         let old_coldkey = U256::from(1);
         let new_coldkey = U256::from(2);
-        let netuid = 1u16;
+        let netuid = NetUid::from(1u16);
 
         SubnetOwner::<Test>::insert(netuid, old_coldkey);
 
@@ -643,7 +643,7 @@ fn test_do_swap_coldkey_success() {
         let new_coldkey = U256::from(2);
         let hotkey1 = U256::from(3);
         let hotkey2 = U256::from(4);
-        let netuid = 1u16;
+        let netuid = NetUid::from(1u16);
         let stake_amount1 = DefaultMinStake::<Test>::get() * 10;
         let stake_amount2 = DefaultMinStake::<Test>::get() * 20;
         let swap_cost = SubtensorModule::get_key_swap_cost();
@@ -828,7 +828,7 @@ fn test_swap_stake_for_coldkey() {
 
         // Setup initial state
         // Add a network
-        let netuid = 1u16;
+        let netuid = NetUid::from(1u16);
         add_network(netuid, 1, 0);
 
         // Register hotkeys
@@ -984,7 +984,7 @@ fn test_swap_staking_hotkeys_for_coldkey() {
 
         // Setup initial state
         // Add a network
-        let netuid = 1u16;
+        let netuid = NetUid::from(1u16);
         add_network(netuid, 1, 0);
         // Give some balance to old coldkey
         SubtensorModule::add_balance_to_coldkey_account(
@@ -1051,7 +1051,7 @@ fn test_swap_delegated_stake_for_coldkey() {
         let stake_amount1 = DefaultMinStake::<Test>::get() * 10;
         let stake_amount2 = DefaultMinStake::<Test>::get() * 20;
         let mut weight = Weight::zero();
-        let netuid = 1u16;
+        let netuid = NetUid::from(1u16);
         let fee = DefaultStakingFee::<Test>::get();
 
         // Setup initial state
@@ -1174,8 +1174,8 @@ fn test_swap_subnet_owner_for_coldkey() {
     new_test_ext(1).execute_with(|| {
         let old_coldkey = U256::from(1);
         let new_coldkey = U256::from(2);
-        let netuid1 = 1u16;
-        let netuid2 = 2u16;
+        let netuid1 = NetUid::from(1);
+        let netuid2 = NetUid::from(2);
         let mut weight = Weight::zero();
 
         // Initialize SubnetOwner for old_coldkey
@@ -1203,7 +1203,7 @@ fn test_do_swap_coldkey_with_subnet_ownership() {
         let old_coldkey = U256::from(1);
         let new_coldkey = U256::from(2);
         let hotkey = U256::from(3);
-        let netuid = 1u16;
+        let netuid = NetUid::from(1u16);
         let stake_amount: u64 = 1000u64;
         let swap_cost = SubtensorModule::get_key_swap_cost();
 
@@ -1237,7 +1237,7 @@ fn test_coldkey_has_associated_hotkeys() {
     new_test_ext(1).execute_with(|| {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
-        let netuid = 1u16;
+        let netuid = NetUid::from(1u16);
 
         // Setup initial state
         add_network(netuid, 13, 0);
@@ -1260,9 +1260,9 @@ fn test_coldkey_swap_total() {
         let hotkey1 = U256::from(2);
         let hotkey2 = U256::from(3);
         let hotkey3 = U256::from(4);
-        let netuid1 = 1u16;
-        let netuid2 = 2u16;
-        let netuid3 = 3u16;
+        let netuid1 = NetUid::from(1);
+        let netuid2 = NetUid::from(2);
+        let netuid3 = NetUid::from(3);
         let stake = DefaultMinStake::<Test>::get() * 10;
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, stake * 6);
         SubtensorModule::add_balance_to_coldkey_account(&delegate1, stake * 2);
@@ -1610,8 +1610,8 @@ fn test_coldkey_delegations() {
         let owner = U256::from(1);
         let coldkey = U256::from(4);
         let delegate = U256::from(2);
-        let netuid = 0u16; // Stake to 0
-        let netuid2 = 1u16; // Stake to 1
+        let netuid = NetUid::from(0); // Stake to 0
+        let netuid2 = NetUid::from(1); // Stake to 1
         let stake = DefaultMinStake::<Test>::get() * 10;
         let fee = DefaultStakingFee::<Test>::get();
 
@@ -1750,7 +1750,7 @@ fn test_schedule_swap_coldkey_execution() {
         let old_coldkey = U256::from(1);
         let new_coldkey = U256::from(2);
         let hotkey = U256::from(3);
-        let netuid = 1u16;
+        let netuid = NetUid::from(1u16);
         let stake_amount = DefaultMinStake::<Test>::get() * 10;
 
         add_network(netuid, 13, 0);
@@ -1954,7 +1954,7 @@ fn test_coldkey_swap_delegate_identity_updated() {
         let old_coldkey = U256::from(1);
         let new_coldkey = U256::from(2);
 
-        let netuid = 1;
+        let netuid = NetUid::from(1);
         let burn_cost = 10;
         let tempo = 1;
 
@@ -2006,7 +2006,7 @@ fn test_coldkey_swap_no_identity_no_changes() {
         let old_coldkey = U256::from(1);
         let new_coldkey = U256::from(2);
 
-        let netuid = 1;
+        let netuid = NetUid::from(1);
         let burn_cost = 10;
         let tempo = 1;
 
@@ -2043,7 +2043,7 @@ fn test_coldkey_swap_no_identity_no_changes_newcoldkey_exists() {
         let old_coldkey = U256::from(3);
         let new_coldkey = U256::from(4);
 
-        let netuid = 1;
+        let netuid = NetUid::from(1);
         let burn_cost = 10;
         let tempo = 1;
 
@@ -2113,7 +2113,7 @@ fn test_coldkey_in_swap_schedule_prevents_funds_usage() {
     // while a coldkey swap is scheduled.
 
     new_test_ext(0).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let version_key: u64 = 0;
         let coldkey = U256::from(0);
         let new_coldkey = U256::from(1);
@@ -2368,7 +2368,7 @@ fn test_coldkey_in_swap_schedule_prevents_critical_calls() {
     // while a coldkey swap is scheduled.
 
     new_test_ext(0).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let version_key: u64 = 0;
         let coldkey = U256::from(0);
         let new_coldkey = U256::from(1);
diff --git a/pallets/subtensor/src/tests/swap_hotkey.rs b/pallets/subtensor/src/tests/swap_hotkey.rs
index a82972c2f7..04786bfd18 100644
--- a/pallets/subtensor/src/tests/swap_hotkey.rs
+++ b/pallets/subtensor/src/tests/swap_hotkey.rs
@@ -69,7 +69,7 @@ fn test_swap_total_hotkey_stake() {
         let fee = DefaultStakingFee::<Test>::get();
 
         //add network
-        let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
+        let netuid = add_dynamic_network(&old_hotkey, &coldkey);
 
         // Give it some $$$ in his coldkey balance
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, amount);
@@ -169,7 +169,7 @@ fn test_swap_subnet_membership() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let netuid = 0u16;
+        let netuid = NetUid::from(0u16);
         let mut weight = Weight::zero();
 
         add_network(netuid, 1, 1);
@@ -193,7 +193,7 @@ fn test_swap_uids_and_keys() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let netuid = 0u16;
+        let netuid = NetUid::from(0u16);
         let uid = 5u16;
         let mut weight = Weight::zero();
 
@@ -222,7 +222,7 @@ fn test_swap_prometheus() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let netuid = 0u16;
+        let netuid = NetUid::from(0u16);
         let prometheus_info = PrometheusInfo::default();
         let mut weight = Weight::zero();
 
@@ -252,7 +252,7 @@ fn test_swap_axons() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let netuid = 0u16;
+        let netuid = NetUid::from(0u16);
         let axon_info = AxonInfo::default();
         let mut weight = Weight::zero();
 
@@ -279,7 +279,7 @@ fn test_swap_certificates() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let netuid = 0u16;
+        let netuid = NetUid::from(0u16);
         let certificate = NeuronCertificate::try_from(vec![1, 2, 3]).unwrap();
         let mut weight = Weight::zero();
 
@@ -311,7 +311,7 @@ fn test_swap_weight_commits() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let netuid = 0u16;
+        let netuid = NetUid::from(0u16);
         let mut weight_commits: VecDeque<(H256, u64, u64, u64)> = VecDeque::new();
         weight_commits.push_back((H256::from_low_u64_be(100), 200, 1, 1));
         let mut weight = Weight::zero();
@@ -342,7 +342,7 @@ fn test_swap_loaded_emission() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let netuid = 0u16;
+        let netuid = NetUid::from(0u16);
         let server_emission = 1000u64;
         let validator_emission = 1000u64;
         let mut weight = Weight::zero();
@@ -377,7 +377,7 @@ fn test_swap_staking_hotkeys() {
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
         let mut weight = Weight::zero();
-        let netuid = 1;
+        let netuid = NetUid::from(1);
 
         StakingHotkeys::<Test>::insert(coldkey, vec![old_hotkey]);
         Alpha::<Test>::insert((old_hotkey, coldkey, netuid), U64F64::from_num(100));
@@ -464,8 +464,8 @@ fn test_swap_hotkey_with_multiple_subnets() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let netuid1 = 0;
-        let netuid2 = 1;
+        let netuid1 = NetUid::from(0);
+        let netuid2 = NetUid::from(1);
         let mut weight = Weight::zero();
 
         add_network(netuid1, 1, 1);
@@ -589,8 +589,8 @@ fn test_swap_hotkey_with_multiple_coldkeys_and_subnets() {
         let new_hotkey = U256::from(2);
         let coldkey1 = U256::from(3);
         let coldkey2 = U256::from(4);
-        let netuid1 = 1;
-        let netuid2 = 2;
+        let netuid1 = NetUid::from(1);
+        let netuid2 = NetUid::from(2);
         let stake = DefaultMinStake::<Test>::get() * 10;
         let mut weight = Weight::zero();
 
@@ -714,7 +714,7 @@ fn test_swap_hotkey_with_multiple_coldkeys_and_subnets() {
 #[test]
 fn test_swap_hotkey_tx_rate_limit_exceeded() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let old_hotkey = U256::from(1);
         let new_hotkey_1 = U256::from(2);
@@ -769,7 +769,7 @@ fn test_swap_hotkey_tx_rate_limit_exceeded() {
 #[test]
 fn test_do_swap_hotkey_err_not_owner() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
@@ -955,7 +955,7 @@ fn test_swap_stake_old_hotkey_not_exist() {
         let coldkey = U256::from(3);
         let alpha_share = U64F64::from_num(1234);
         let mut weight = Weight::zero();
-        let netuid = 1;
+        let netuid = NetUid::from(1);
 
         // Initialize Stake for old_hotkey
         Alpha::<Test>::insert((old_hotkey, coldkey, netuid), alpha_share);
@@ -1038,7 +1038,7 @@ fn test_swap_hotkey_error_cases() {
         );
 
         // Test new hotkey already registered
-        IsNetworkMember::<Test>::insert(new_hotkey, 0, true);
+        IsNetworkMember::<Test>::insert(new_hotkey, NetUid::ROOT, true);
         assert_noop!(
             SubtensorModule::do_swap_hotkey(
                 RuntimeOrigin::signed(coldkey),
@@ -1047,7 +1047,7 @@ fn test_swap_hotkey_error_cases() {
             ),
             Error::<Test>::HotKeyAlreadyRegisteredInSubNet
         );
-        IsNetworkMember::<Test>::remove(new_hotkey, 0);
+        IsNetworkMember::<Test>::remove(new_hotkey, NetUid::ROOT);
 
         // Test non-associated coldkey
         assert_noop!(
@@ -1078,7 +1078,7 @@ fn test_swap_child_keys() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let netuid = 0u16;
+        let netuid = NetUid::from(0u16);
         let children = vec![(100u64, U256::from(4)), (200u64, U256::from(5))];
         let mut weight = Weight::zero();
 
@@ -1102,7 +1102,7 @@ fn test_swap_parent_keys() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let netuid = 0u16;
+        let netuid = NetUid::from(0u16);
         let parents = vec![(100u64, U256::from(4)), (200u64, U256::from(5))];
         let mut weight = Weight::zero();
 
@@ -1140,8 +1140,8 @@ fn test_swap_multiple_subnets() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let netuid1 = 0u16;
-        let netuid2 = 1u16;
+        let netuid1 = NetUid::from(0);
+        let netuid2 = NetUid::from(1);
         let children1 = vec![(100u64, U256::from(4)), (200u64, U256::from(5))];
         let children2 = vec![(300u64, U256::from(6))];
         let mut weight = Weight::zero();
@@ -1171,7 +1171,7 @@ fn test_swap_complex_parent_child_structure() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let netuid = 0u16;
+        let netuid = NetUid::from(0u16);
         let parent1 = U256::from(4);
         let parent2 = U256::from(5);
         let child1 = U256::from(6);
@@ -1230,7 +1230,7 @@ fn test_swap_complex_parent_child_structure() {
 #[test]
 fn test_swap_parent_hotkey_childkey_maps() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let parent_old = U256::from(1);
         let coldkey = U256::from(2);
         let child = U256::from(3);
@@ -1285,7 +1285,7 @@ fn test_swap_parent_hotkey_childkey_maps() {
 #[test]
 fn test_swap_child_hotkey_childkey_maps() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let parent = U256::from(1);
         let coldkey = U256::from(2);
         let child_old = U256::from(3);
diff --git a/pallets/subtensor/src/tests/uids.rs b/pallets/subtensor/src/tests/uids.rs
index 92a8a64048..49233f105c 100644
--- a/pallets/subtensor/src/tests/uids.rs
+++ b/pallets/subtensor/src/tests/uids.rs
@@ -18,7 +18,7 @@ use sp_core::U256;
 fn test_replace_neuron() {
     new_test_ext(1).execute_with(|| {
         let block_number: u64 = 0;
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let hotkey_account_id = U256::from(1);
         let (nonce, work): (u64, Vec<u8>) = SubtensorModule::create_work_for_block_number(
@@ -149,7 +149,7 @@ fn test_replace_neuron() {
 fn test_bonds_cleared_on_replace() {
     new_test_ext(1).execute_with(|| {
         let block_number: u64 = 0;
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let hotkey_account_id = U256::from(1);
         let (nonce, work): (u64, Vec<u8>) = SubtensorModule::create_work_for_block_number(
@@ -216,8 +216,8 @@ fn test_bonds_cleared_on_replace() {
 fn test_replace_neuron_multiple_subnets() {
     new_test_ext(1).execute_with(|| {
         let block_number: u64 = 0;
-        let netuid: u16 = 1;
-        let netuid1: u16 = 2;
+        let netuid = NetUid::from(1);
+        let netuid1 = NetUid::from(2);
         let tempo: u16 = 13;
         let hotkey_account_id = U256::from(1);
         let new_hotkey_account_id = U256::from(2);
diff --git a/pallets/subtensor/src/tests/weights.rs b/pallets/subtensor/src/tests/weights.rs
index 3d240750cf..eb189d1ab5 100644
--- a/pallets/subtensor/src/tests/weights.rs
+++ b/pallets/subtensor/src/tests/weights.rs
@@ -40,7 +40,7 @@ fn test_set_weights_dispatch_info_ok() {
     new_test_ext(0).execute_with(|| {
         let dests = vec![1, 1];
         let weights = vec![1, 1];
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let version_key: u64 = 0;
         let call = RuntimeCall::SubtensorModule(SubtensorCall::set_weights {
             netuid,
@@ -64,7 +64,7 @@ fn test_set_rootweights_validate() {
     new_test_ext(0).execute_with(|| {
         let dests = vec![1, 1];
         let weights = vec![1, 1];
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let version_key: u64 = 0;
         let coldkey = U256::from(0);
         let hotkey: U256 = U256::from(1); // Add the hotkey field
@@ -152,7 +152,7 @@ fn test_commit_weights_dispatch_info_ok() {
     new_test_ext(0).execute_with(|| {
         let dests = vec![1, 1];
         let weights = vec![1, 1];
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let salt: Vec<u16> = vec![1, 2, 3, 4, 5, 6, 7, 8];
         let version_key: u64 = 0;
         let hotkey: U256 = U256::from(1);
@@ -180,7 +180,7 @@ fn test_commit_weights_validate() {
     new_test_ext(0).execute_with(|| {
         let dests = vec![1, 1];
         let weights = vec![1, 1];
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let salt: Vec<u16> = vec![1, 2, 3, 4, 5, 6, 7, 8];
         let version_key: u64 = 0;
         let coldkey = U256::from(0);
@@ -267,7 +267,7 @@ fn test_reveal_weights_dispatch_info_ok() {
     new_test_ext(0).execute_with(|| {
         let dests = vec![1, 1];
         let weights = vec![1, 1];
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let salt: Vec<u16> = vec![1, 2, 3, 4, 5, 6, 7, 8];
         let version_key: u64 = 0;
 
@@ -292,7 +292,7 @@ fn test_set_weights_validate() {
     // correctly filters the `set_weights` transaction.
 
     new_test_ext(0).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let coldkey = U256::from(0);
         let hotkey: U256 = U256::from(1);
         assert_ne!(hotkey, coldkey);
@@ -365,7 +365,7 @@ fn test_reveal_weights_validate() {
     new_test_ext(0).execute_with(|| {
         let dests = vec![1, 1];
         let weights = vec![1, 1];
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let salt: Vec<u16> = vec![1, 2, 3, 4, 5, 6, 7, 8];
         let version_key: u64 = 0;
         let coldkey = U256::from(0);
@@ -451,8 +451,6 @@ fn test_reveal_weights_validate() {
 #[test]
 fn test_set_weights_is_root_error() {
     new_test_ext(0).execute_with(|| {
-        let root_netuid: u16 = 0;
-
         let uids = vec![0];
         let weights = vec![1];
         let version_key: u64 = 0;
@@ -461,7 +459,7 @@ fn test_set_weights_is_root_error() {
         assert_err!(
             SubtensorModule::set_weights(
                 RuntimeOrigin::signed(hotkey),
-                root_netuid,
+                NetUid::ROOT,
                 uids.clone(),
                 weights.clone(),
                 version_key,
@@ -477,7 +475,7 @@ fn test_set_weights_is_root_error() {
 fn test_weights_err_no_validator_permit() {
     new_test_ext(0).execute_with(|| {
         let hotkey_account_id = U256::from(55);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         add_network(netuid, tempo, 0);
         SubtensorModule::set_min_allowed_weights(netuid, 0);
@@ -522,7 +520,7 @@ fn test_set_stake_threshold_failed() {
     new_test_ext(0).execute_with(|| {
         let dests = vec![0];
         let weights = vec![1];
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let version_key: u64 = 0;
         let hotkey = U256::from(0);
         let coldkey = U256::from(0);
@@ -586,8 +584,8 @@ fn test_weights_version_key() {
     new_test_ext(0).execute_with(|| {
         let hotkey = U256::from(55);
         let coldkey = U256::from(66);
-        let netuid0: u16 = 1;
-        let netuid1: u16 = 2;
+        let netuid0 = NetUid::from(1);
+        let netuid1 = NetUid::from(2);
 
         add_network(netuid0, 1, 0);
         add_network(netuid1, 1, 0);
@@ -663,7 +661,7 @@ fn test_weights_version_key() {
 fn test_weights_err_setting_weights_too_fast() {
     new_test_ext(0).execute_with(|| {
         let hotkey_account_id = U256::from(55);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         add_network(netuid, tempo, 0);
         SubtensorModule::set_min_allowed_weights(netuid, 0);
@@ -726,11 +724,11 @@ fn test_weights_err_setting_weights_too_fast() {
 fn test_weights_err_weights_vec_not_equal_size() {
     new_test_ext(0).execute_with(|| {
         let hotkey_account_id = U256::from(55);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let salt: Vec<u16> = vec![1, 2, 3, 4, 5, 6, 7, 8];
         add_network(netuid, tempo, 0);
-        register_ok_neuron(1, hotkey_account_id, U256::from(66), 0);
+        register_ok_neuron(netuid, hotkey_account_id, U256::from(66), 0);
         let neuron_uid: u16 =
             SubtensorModule::get_uid_for_net_and_hotkey(netuid, &hotkey_account_id)
                 .expect("Not registered.");
@@ -739,7 +737,7 @@ fn test_weights_err_weights_vec_not_equal_size() {
         let weight_values: Vec<u16> = vec![1, 2, 3, 4, 5]; // Uneven sizes
         let result = commit_reveal_set_weights(
             hotkey_account_id,
-            1,
+            1.into(),
             weights_keys.clone(),
             weight_values.clone(),
             salt.clone(),
@@ -755,7 +753,7 @@ fn test_weights_err_weights_vec_not_equal_size() {
 fn test_weights_err_has_duplicate_ids() {
     new_test_ext(0).execute_with(|| {
         let hotkey_account_id = U256::from(666);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let salt: Vec<u16> = vec![1, 2, 3, 4, 5, 6, 7, 8];
         add_network(netuid, tempo, 0);
@@ -816,7 +814,7 @@ fn test_weights_err_max_weight_limit() {
     //TO DO SAM: uncomment when we implement run_to_block fn
     new_test_ext(0).execute_with(|| {
         // Add network.
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 100;
         add_network(netuid, tempo, 0);
 
@@ -878,8 +876,13 @@ fn test_weights_err_max_weight_limit() {
         // Non self-weight fails.
         let uids: Vec<u16> = vec![1, 2, 3, 4];
         let values: Vec<u16> = vec![u16::MAX / 4, u16::MAX / 4, u16::MAX / 54, u16::MAX / 4];
-        let result =
-            SubtensorModule::set_weights(RuntimeOrigin::signed(U256::from(0)), 1, uids, values, 0);
+        let result = SubtensorModule::set_weights(
+            RuntimeOrigin::signed(U256::from(0)),
+            1.into(),
+            uids,
+            values,
+            0,
+        );
         assert_eq!(result, Err(Error::<Test>::MaxWeightExceeded.into()));
 
         // Self-weight is a success.
@@ -887,7 +890,7 @@ fn test_weights_err_max_weight_limit() {
         let values: Vec<u16> = vec![u16::MAX]; // normalizes to u32::MAX
         assert_ok!(SubtensorModule::set_weights(
             RuntimeOrigin::signed(U256::from(0)),
-            1,
+            1.into(),
             uids,
             values,
             0
@@ -902,7 +905,7 @@ fn test_no_signature() {
     new_test_ext(0).execute_with(|| {
         let uids: Vec<u16> = vec![];
         let values: Vec<u16> = vec![];
-        let result = SubtensorModule::set_weights(RuntimeOrigin::none(), 1, uids, values, 0);
+        let result = SubtensorModule::set_weights(RuntimeOrigin::none(), 1.into(), uids, values, 0);
         assert_eq!(result, Err(DispatchError::BadOrigin));
     });
 }
@@ -912,21 +915,27 @@ fn test_no_signature() {
 #[test]
 fn test_set_weights_err_not_active() {
     new_test_ext(0).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let salt: Vec<u16> = vec![1, 2, 3, 4, 5, 6, 7, 8];
         add_network(netuid, tempo, 0);
 
         // Register one neuron. Should have uid 0
-        register_ok_neuron(1, U256::from(666), U256::from(2), 100000);
+        register_ok_neuron(netuid, U256::from(666), U256::from(2), 100000);
         SubtensorModule::get_uid_for_net_and_hotkey(netuid, &U256::from(666))
             .expect("Not registered.");
 
         let weights_keys: Vec<u16> = vec![0]; // Uid 0 is valid.
         let weight_values: Vec<u16> = vec![1];
         // This hotkey is NOT registered.
-        let result =
-            commit_reveal_set_weights(U256::from(1), 1, weights_keys, weight_values, salt, 0);
+        let result = commit_reveal_set_weights(
+            U256::from(1),
+            1.into(),
+            weights_keys,
+            weight_values,
+            salt,
+            0,
+        );
         assert_eq!(
             result,
             Err(Error::<Test>::HotKeyNotRegisteredInSubNet.into())
@@ -940,11 +949,11 @@ fn test_set_weights_err_not_active() {
 fn test_set_weights_err_invalid_uid() {
     new_test_ext(0).execute_with(|| {
         let hotkey_account_id = U256::from(55);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let salt: Vec<u16> = vec![1, 2, 3, 4, 5, 6, 7, 8];
         add_network(netuid, tempo, 0);
-        register_ok_neuron(1, hotkey_account_id, U256::from(66), 0);
+        register_ok_neuron(netuid, hotkey_account_id, U256::from(66), 0);
         let neuron_uid: u16 =
             SubtensorModule::get_uid_for_net_and_hotkey(netuid, &hotkey_account_id)
                 .expect("Not registered.");
@@ -959,8 +968,14 @@ fn test_set_weights_err_invalid_uid() {
         );
         let weight_keys: Vec<u16> = vec![9999]; // Does not exist
         let weight_values: Vec<u16> = vec![88]; // random value
-        let result =
-            commit_reveal_set_weights(hotkey_account_id, 1, weight_keys, weight_values, salt, 0);
+        let result = commit_reveal_set_weights(
+            hotkey_account_id,
+            netuid,
+            weight_keys,
+            weight_values,
+            salt,
+            0,
+        );
         assert_eq!(result, Err(Error::<Test>::UidVecContainInvalidOne.into()));
     });
 }
@@ -970,13 +985,13 @@ fn test_set_weights_err_invalid_uid() {
 #[test]
 fn test_set_weight_not_enough_values() {
     new_test_ext(0).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let salt: Vec<u16> = vec![1, 2, 3, 4, 5, 6, 7, 8];
         let account_id = U256::from(1);
         add_network(netuid, tempo, 0);
 
-        register_ok_neuron(1, account_id, U256::from(2), 100000);
+        register_ok_neuron(netuid, account_id, U256::from(2), 100000);
         let neuron_uid: u16 = SubtensorModule::get_uid_for_net_and_hotkey(netuid, &U256::from(1))
             .expect("Not registered.");
         SubtensorModule::set_validator_permit_for_uid(netuid, neuron_uid, true);
@@ -989,7 +1004,7 @@ fn test_set_weight_not_enough_values() {
             1,
         );
 
-        register_ok_neuron(1, U256::from(3), U256::from(4), 300000);
+        register_ok_neuron(netuid, U256::from(3), U256::from(4), 300000);
         SubtensorModule::set_min_allowed_weights(netuid, 2);
 
         // Should fail because we are only setting a single value and its not the self weight.
@@ -997,7 +1012,7 @@ fn test_set_weight_not_enough_values() {
         let weight_values: Vec<u16> = vec![88]; // random value.
         let result = SubtensorModule::set_weights(
             RuntimeOrigin::signed(account_id),
-            1,
+            1.into(),
             weight_keys,
             weight_values,
             0,
@@ -1009,7 +1024,7 @@ fn test_set_weight_not_enough_values() {
         let weight_values: Vec<u16> = vec![88]; // random value.
         assert_ok!(SubtensorModule::set_weights(
             RuntimeOrigin::signed(account_id),
-            1,
+            1.into(),
             weight_keys,
             weight_values,
             0
@@ -1021,7 +1036,7 @@ fn test_set_weight_not_enough_values() {
         SubtensorModule::set_min_allowed_weights(netuid, 1);
         assert_ok!(commit_reveal_set_weights(
             account_id,
-            1,
+            1.into(),
             weight_keys,
             weight_values,
             salt,
@@ -1035,17 +1050,17 @@ fn test_set_weight_not_enough_values() {
 #[test]
 fn test_set_weight_too_many_uids() {
     new_test_ext(0).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         add_network(netuid, tempo, 0);
 
-        register_ok_neuron(1, U256::from(1), U256::from(2), 100_000);
+        register_ok_neuron(1.into(), U256::from(1), U256::from(2), 100_000);
         let neuron_uid: u16 = SubtensorModule::get_uid_for_net_and_hotkey(netuid, &U256::from(1))
             .expect("Not registered.");
         SubtensorModule::set_validator_permit_for_uid(netuid, neuron_uid, true);
 
-        register_ok_neuron(1, U256::from(3), U256::from(4), 300_000);
-        SubtensorModule::set_min_allowed_weights(1, 2);
+        register_ok_neuron(1.into(), U256::from(3), U256::from(4), 300_000);
+        SubtensorModule::set_min_allowed_weights(1.into(), 2);
         SubtensorModule::set_max_weight_limit(netuid, u16::MAX);
 
         // Should fail because we are setting more weights than there are neurons.
@@ -1053,7 +1068,7 @@ fn test_set_weight_too_many_uids() {
         let weight_values: Vec<u16> = vec![88, 102, 303, 1212, 11]; // random value.
         let result = SubtensorModule::set_weights(
             RuntimeOrigin::signed(U256::from(1)),
-            1,
+            1.into(),
             weight_keys,
             weight_values,
             0,
@@ -1068,7 +1083,7 @@ fn test_set_weight_too_many_uids() {
         let weight_values: Vec<u16> = vec![10, 10]; // random value.
         assert_ok!(SubtensorModule::set_weights(
             RuntimeOrigin::signed(U256::from(1)),
-            1,
+            1.into(),
             weight_keys,
             weight_values,
             0
@@ -1081,12 +1096,12 @@ fn test_set_weight_too_many_uids() {
 #[test]
 fn test_set_weights_sum_larger_than_u16_max() {
     new_test_ext(0).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 13;
         let salt: Vec<u16> = vec![1, 2, 3, 4, 5, 6, 7, 8];
         add_network(netuid, tempo, 0);
 
-        register_ok_neuron(1, U256::from(1), U256::from(2), 100_000);
+        register_ok_neuron(1.into(), U256::from(1), U256::from(2), 100_000);
         let neuron_uid: u16 = SubtensorModule::get_uid_for_net_and_hotkey(netuid, &U256::from(1))
             .expect("Not registered.");
         SubtensorModule::set_stake_threshold(0);
@@ -1100,8 +1115,8 @@ fn test_set_weights_sum_larger_than_u16_max() {
             1,
         );
 
-        register_ok_neuron(1, U256::from(3), U256::from(4), 300_000);
-        SubtensorModule::set_min_allowed_weights(1, 2);
+        register_ok_neuron(1.into(), U256::from(3), U256::from(4), 300_000);
+        SubtensorModule::set_min_allowed_weights(1.into(), 2);
 
         // Shouldn't fail because we are setting the right number of weights.
         let weight_keys: Vec<u16> = vec![0, 1];
@@ -1110,7 +1125,7 @@ fn test_set_weights_sum_larger_than_u16_max() {
         assert!(weight_values.iter().map(|x| *x as u64).sum::<u64>() > (u16::MAX as u64));
 
         let result =
-            commit_reveal_set_weights(U256::from(1), 1, weight_keys, weight_values, salt, 0);
+            commit_reveal_set_weights(U256::from(1), 1.into(), weight_keys, weight_values, salt, 0);
         assert_ok!(result);
 
         // Get max-upscaled unnormalized weights.
@@ -1126,7 +1141,7 @@ fn test_set_weights_sum_larger_than_u16_max() {
 #[test]
 fn test_check_length_allows_singleton() {
     new_test_ext(0).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
 
         let max_allowed: u16 = 1;
         let min_allowed_weights = max_allowed;
@@ -1149,7 +1164,7 @@ fn test_check_length_allows_singleton() {
 #[test]
 fn test_check_length_weights_length_exceeds_min_allowed() {
     new_test_ext(0).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
 
         let max_allowed: u16 = 3;
         let min_allowed_weights = max_allowed;
@@ -1172,7 +1187,7 @@ fn test_check_length_weights_length_exceeds_min_allowed() {
 #[test]
 fn test_check_length_to_few_weights() {
     new_test_ext(0).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
 
         let min_allowed_weights = 3;
 
@@ -1180,13 +1195,13 @@ fn test_check_length_to_few_weights() {
         SubtensorModule::set_target_registrations_per_interval(netuid, 100);
         SubtensorModule::set_max_registrations_per_block(netuid, 100);
         // register morw than min allowed
-        register_ok_neuron(1, U256::from(1), U256::from(1), 300_000);
-        register_ok_neuron(1, U256::from(2), U256::from(2), 300_001);
-        register_ok_neuron(1, U256::from(3), U256::from(3), 300_002);
-        register_ok_neuron(1, U256::from(4), U256::from(4), 300_003);
-        register_ok_neuron(1, U256::from(5), U256::from(5), 300_004);
-        register_ok_neuron(1, U256::from(6), U256::from(6), 300_005);
-        register_ok_neuron(1, U256::from(7), U256::from(7), 300_006);
+        register_ok_neuron(1.into(), U256::from(1), U256::from(1), 300_000);
+        register_ok_neuron(1.into(), U256::from(2), U256::from(2), 300_001);
+        register_ok_neuron(1.into(), U256::from(3), U256::from(3), 300_002);
+        register_ok_neuron(1.into(), U256::from(4), U256::from(4), 300_003);
+        register_ok_neuron(1.into(), U256::from(5), U256::from(5), 300_004);
+        register_ok_neuron(1.into(), U256::from(6), U256::from(6), 300_005);
+        register_ok_neuron(1.into(), U256::from(7), U256::from(7), 300_006);
         SubtensorModule::set_min_allowed_weights(netuid, min_allowed_weights);
 
         let uids: Vec<u16> = Vec::from_iter((0..2).map(|id| id + 1));
@@ -1242,7 +1257,7 @@ fn test_max_weight_limited_allow_self_weights_to_exceed_max_weight_limit() {
     new_test_ext(0).execute_with(|| {
         let max_allowed: u16 = 1;
 
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let uids: Vec<u16> = Vec::from_iter((0..max_allowed).map(|id| id + 1));
         let uid: u16 = uids[0];
         let weights: Vec<u16> = vec![0];
@@ -1264,7 +1279,7 @@ fn test_max_weight_limited_when_weight_limit_is_u16_max() {
     new_test_ext(0).execute_with(|| {
         let max_allowed: u16 = 3;
 
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let uids: Vec<u16> = Vec::from_iter((0..max_allowed).map(|id| id + 1));
         let uid: u16 = uids[0];
         let weights: Vec<u16> = Vec::from_iter((0..max_allowed).map(|_id| u16::MAX));
@@ -1287,7 +1302,7 @@ fn test_max_weight_limited_when_max_weight_is_within_limit() {
         let max_allowed: u16 = 1;
         let max_weight_limit = u16::MAX / 5;
 
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let uids: Vec<u16> = Vec::from_iter((0..max_allowed).map(|id| id + 1));
         let uid: u16 = uids[0];
         let weights: Vec<u16> = Vec::from_iter((0..max_allowed).map(|id| max_weight_limit - id));
@@ -1312,7 +1327,7 @@ fn test_max_weight_limited_when_guard_checks_are_not_triggered() {
         let max_allowed: u16 = 3;
         let max_weight_limit = u16::MAX / 5;
 
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let uids: Vec<u16> = Vec::from_iter((0..max_allowed).map(|id| id + 1));
         let uid: u16 = uids[0];
         let weights: Vec<u16> = Vec::from_iter((0..max_allowed).map(|id| max_weight_limit + id));
@@ -1398,7 +1413,7 @@ fn test_is_self_weight_uid_in_uids() {
 #[test]
 fn test_check_len_uids_within_allowed_within_network_pool() {
     new_test_ext(0).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
 
         let tempo: u16 = 13;
         let modality: u16 = 0;
@@ -1431,7 +1446,7 @@ fn test_check_len_uids_within_allowed_within_network_pool() {
 #[test]
 fn test_check_len_uids_within_allowed_not_within_network_pool() {
     new_test_ext(0).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
 
         let tempo: u16 = 13;
         let modality: u16 = 0;
@@ -1464,7 +1479,7 @@ fn test_check_len_uids_within_allowed_not_within_network_pool() {
 #[test]
 fn test_set_weights_commit_reveal_enabled_error() {
     new_test_ext(0).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         add_network(netuid, 1, 0);
         register_ok_neuron(netuid, U256::from(1), U256::from(2), 10);
 
@@ -1502,7 +1517,7 @@ fn test_set_weights_commit_reveal_enabled_error() {
 #[test]
 fn test_reveal_weights_when_commit_reveal_disabled() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let uids: Vec<u16> = vec![0, 1];
         let weight_values: Vec<u16> = vec![10, 10];
         let salt: Vec<u16> = vec![1, 2, 3, 4, 5, 6, 7, 8];
@@ -1562,7 +1577,7 @@ fn test_reveal_weights_when_commit_reveal_disabled() {
 #[test]
 fn test_commit_reveal_weights_ok() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let uids: Vec<u16> = vec![0, 1];
         let weight_values: Vec<u16> = vec![10, 10];
         let salt: Vec<u16> = vec![1, 2, 3, 4, 5, 6, 7, 8];
@@ -1631,7 +1646,7 @@ fn test_commit_reveal_weights_ok() {
 #[test]
 fn test_commit_reveal_tempo_interval() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let uids: Vec<u16> = vec![0, 1];
         let weight_values: Vec<u16> = vec![10, 10];
         let salt: Vec<u16> = vec![1, 2, 3, 4, 5, 6, 7, 8];
@@ -1777,7 +1792,7 @@ fn test_commit_reveal_tempo_interval() {
 #[test]
 fn test_commit_reveal_hash() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let uids: Vec<u16> = vec![0, 1];
         let weight_values: Vec<u16> = vec![10, 10];
         let salt: Vec<u16> = vec![1, 2, 3, 4, 5, 6, 7, 8];
@@ -1869,7 +1884,7 @@ fn test_commit_reveal_hash() {
 #[test]
 fn test_commit_reveal_disabled_or_enabled() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let uids: Vec<u16> = vec![0, 1];
         let weight_values: Vec<u16> = vec![10, 10];
         let salt: Vec<u16> = vec![1, 2, 3, 4, 5, 6, 7, 8];
@@ -1946,7 +1961,7 @@ fn test_commit_reveal_disabled_or_enabled() {
 #[test]
 fn test_toggle_commit_reveal_weights_and_set_weights() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let uids: Vec<u16> = vec![0, 1];
         let weight_values: Vec<u16> = vec![10, 10];
         let salt: Vec<u16> = vec![1, 2, 3, 4, 5, 6, 7, 8];
@@ -2029,7 +2044,7 @@ fn test_toggle_commit_reveal_weights_and_set_weights() {
 #[test]
 fn test_tempo_change_during_commit_reveal_process() {
     new_test_ext(0).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let uids: Vec<u16> = vec![0, 1];
         let weight_values: Vec<u16> = vec![10, 10];
         let salt: Vec<u16> = vec![1, 2, 3, 4, 5, 6, 7, 8];
@@ -2187,7 +2202,7 @@ fn test_tempo_change_during_commit_reveal_process() {
 #[test]
 fn test_commit_reveal_multiple_commits() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let uids: Vec<u16> = vec![0, 1];
         let weight_values: Vec<u16> = vec![10, 10];
         let version_key: u64 = 0;
@@ -2553,7 +2568,7 @@ fn test_commit_reveal_multiple_commits() {
 
 fn commit_reveal_set_weights(
     hotkey: U256,
-    netuid: u16,
+    netuid: NetUid,
     uids: Vec<u16>,
     weights: Vec<u16>,
     salt: Vec<u16>,
@@ -2590,7 +2605,7 @@ fn commit_reveal_set_weights(
 #[test]
 fn test_expired_commits_handling_in_commit_and_reveal() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let hotkey: <Test as frame_system::Config>::AccountId = U256::from(1);
         let version_key: u64 = 0;
         let uids: Vec<u16> = vec![0, 1];
@@ -2789,7 +2804,7 @@ fn test_expired_commits_handling_in_commit_and_reveal() {
 #[test]
 fn test_reveal_at_exact_epoch() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let hotkey: <Test as frame_system::Config>::AccountId = U256::from(1);
         let version_key: u64 = 0;
         let uids: Vec<u16> = vec![0, 1];
@@ -2939,7 +2954,7 @@ fn test_reveal_at_exact_epoch() {
 #[test]
 fn test_tempo_and_reveal_period_change_during_commit_reveal_process() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let uids: Vec<u16> = vec![0, 1];
         let weight_values: Vec<u16> = vec![10, 10];
         let salt: Vec<u16> = vec![42; 8];
@@ -3143,7 +3158,7 @@ fn test_tempo_and_reveal_period_change_during_commit_reveal_process() {
 #[test]
 fn test_commit_reveal_order_enforcement() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let hotkey: <Test as frame_system::Config>::AccountId = U256::from(1);
         let version_key: u64 = 0;
         let uids: Vec<u16> = vec![0, 1];
@@ -3245,7 +3260,7 @@ fn test_commit_reveal_order_enforcement() {
 #[test]
 fn test_reveal_at_exact_block() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let hotkey: <Test as frame_system::Config>::AccountId = U256::from(1);
         let version_key: u64 = 0;
         let uids: Vec<u16> = vec![0, 1];
@@ -3304,7 +3319,7 @@ fn test_reveal_at_exact_block() {
 
             // Calculate the block number where the reveal epoch starts
             let tempo_plus_one = (tempo as u64).saturating_add(1);
-            let netuid_plus_one = (netuid as u64).saturating_add(1);
+            let netuid_plus_one = (u16::from(netuid) as u64).saturating_add(1);
             let reveal_epoch_start_block = reveal_epoch
                 .saturating_mul(tempo_plus_one)
                 .saturating_sub(netuid_plus_one);
@@ -3415,7 +3430,7 @@ fn test_reveal_at_exact_block() {
 #[test]
 fn test_successful_batch_reveal() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let hotkey = U256::from(1);
         let version_keys: Vec<u64> = vec![0, 0, 0];
         let uids_list: Vec<Vec<u16>> = vec![vec![0, 1], vec![1, 0], vec![0, 1]];
@@ -3493,7 +3508,7 @@ fn test_successful_batch_reveal() {
 #[test]
 fn test_batch_reveal_with_expired_commits() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let hotkey = U256::from(1);
         let version_keys: Vec<u64> = vec![0, 0, 0];
         let uids_list: Vec<Vec<u16>> = vec![vec![0, 1], vec![1, 0], vec![0, 1]];
@@ -3614,7 +3629,7 @@ fn test_batch_reveal_with_expired_commits() {
 #[test]
 fn test_batch_reveal_with_invalid_input_lengths() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let hotkey = U256::from(1);
         let tempo: u16 = 100;
 
@@ -3712,7 +3727,7 @@ fn test_batch_reveal_with_invalid_input_lengths() {
 #[test]
 fn test_batch_reveal_with_no_commits() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let hotkey = U256::from(1);
         let version_keys: Vec<u64> = vec![0];
         let uids_list: Vec<Vec<u16>> = vec![vec![0, 1]];
@@ -3742,7 +3757,7 @@ fn test_batch_reveal_with_no_commits() {
 #[test]
 fn test_batch_reveal_before_reveal_period() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let hotkey = U256::from(1);
         let version_keys: Vec<u64> = vec![0, 0];
         let uids_list: Vec<Vec<u16>> = vec![vec![0, 1], vec![1, 0]];
@@ -3800,7 +3815,7 @@ fn test_batch_reveal_before_reveal_period() {
 #[test]
 fn test_batch_reveal_after_commits_expired() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let hotkey = U256::from(1);
         let version_keys: Vec<u64> = vec![0, 0];
         let uids_list: Vec<Vec<u16>> = vec![vec![0, 1], vec![1, 0]];
@@ -3880,7 +3895,7 @@ fn test_batch_reveal_after_commits_expired() {
 #[test]
 fn test_batch_reveal_when_commit_reveal_disabled() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let hotkey = U256::from(1);
         let version_keys: Vec<u64> = vec![0];
         let uids_list: Vec<Vec<u16>> = vec![vec![0, 1]];
@@ -3910,7 +3925,7 @@ fn test_batch_reveal_when_commit_reveal_disabled() {
 #[test]
 fn test_batch_reveal_with_out_of_order_commits() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let hotkey = U256::from(1);
         let version_keys: Vec<u64> = vec![0, 0, 0];
         let uids_list: Vec<Vec<u16>> = vec![vec![0, 1], vec![1, 0], vec![0, 1]];
@@ -4022,7 +4037,7 @@ fn test_batch_reveal_with_out_of_order_commits() {
 fn test_highly_concurrent_commits_and_reveals_with_multiple_hotkeys() {
     new_test_ext(1).execute_with(|| {
         // ==== Test Configuration ====
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let num_hotkeys: usize = 10;
         let max_unrevealed_commits: usize = 10;
         let commits_per_hotkey: usize = 20;
@@ -4301,7 +4316,7 @@ fn test_highly_concurrent_commits_and_reveals_with_multiple_hotkeys() {
 fn test_get_reveal_blocks() {
     new_test_ext(1).execute_with(|| {
         // **1. Define Test Parameters**
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let uids: Vec<u16> = vec![0, 1];
         let weight_values: Vec<u16> = vec![10, 10];
         let salt: Vec<u16> = vec![1, 2, 3, 4, 5, 6, 7, 8];
@@ -4440,7 +4455,7 @@ fn test_get_reveal_blocks() {
 #[test]
 fn test_commit_weights_rate_limit() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let uids: Vec<u16> = vec![0, 1];
         let weight_values: Vec<u16> = vec![10, 10];
         let salt: Vec<u16> = vec![1, 2, 3, 4, 5, 6, 7, 8];
@@ -4637,7 +4652,7 @@ fn test_reveal_crv3_commits_success() {
     new_test_ext(100).execute_with(|| {
         use ark_serialize::CanonicalSerialize;
 
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let hotkey1: AccountId = U256::from(1);
         let hotkey2: AccountId = U256::from(2);
         let reveal_round: u64 = 1000;
@@ -4793,7 +4808,7 @@ fn test_reveal_crv3_commits_cannot_reveal_after_reveal_epoch() {
     new_test_ext(100).execute_with(|| {
         use ark_serialize::CanonicalSerialize;
 
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let hotkey1: AccountId = U256::from(1);
         let hotkey2: AccountId = U256::from(2);
         let reveal_round: u64 = 1000;
@@ -4918,7 +4933,7 @@ fn test_reveal_crv3_commits_cannot_reveal_after_reveal_epoch() {
 #[test]
 fn test_do_commit_crv3_weights_success() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let hotkey: AccountId = U256::from(1);
         let commit_data: Vec<u8> = vec![1, 2, 3, 4, 5];
         let reveal_round: u64 = 1000;
@@ -4952,7 +4967,7 @@ fn test_do_commit_crv3_weights_success() {
 #[test]
 fn test_do_commit_crv3_weights_disabled() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let hotkey: AccountId = U256::from(1);
         let commit_data: Vec<u8> = vec![1, 2, 3, 4, 5];
         let reveal_round: u64 = 1000;
@@ -4980,7 +4995,7 @@ fn test_do_commit_crv3_weights_disabled() {
 #[test]
 fn test_do_commit_crv3_weights_hotkey_not_registered() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let unregistered_hotkey: AccountId = U256::from(99);
         let commit_data: Vec<u8> = vec![1, 2, 3, 4, 5];
         let reveal_round: u64 = 1000;
@@ -5009,7 +5024,7 @@ fn test_do_commit_crv3_weights_hotkey_not_registered() {
 #[test]
 fn test_do_commit_crv3_weights_committing_too_fast() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let hotkey: AccountId = U256::from(1);
         let commit_data_1: Vec<u8> = vec![1, 2, 3];
         let commit_data_2: Vec<u8> = vec![4, 5, 6];
@@ -5078,7 +5093,7 @@ fn test_do_commit_crv3_weights_committing_too_fast() {
 #[test]
 fn test_do_commit_crv3_weights_too_many_unrevealed_commits() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let hotkey1: AccountId = U256::from(1);
         let hotkey2: AccountId = U256::from(2);
         let reveal_round: u64 = 1000;
@@ -5183,7 +5198,7 @@ fn test_do_commit_crv3_weights_too_many_unrevealed_commits() {
 #[test]
 fn test_reveal_crv3_commits_decryption_failure() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let hotkey: AccountId = U256::from(1);
         let reveal_round: u64 = 1000;
 
@@ -5236,7 +5251,7 @@ fn test_reveal_crv3_commits_multiple_commits_some_fail_some_succeed() {
     new_test_ext(100).execute_with(|| {
         use ark_serialize::CanonicalSerialize;
 
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let hotkey1: AccountId = U256::from(1);
         let hotkey2: AccountId = U256::from(2);
         let reveal_round: u64 = 1000;
@@ -5360,7 +5375,7 @@ fn test_reveal_crv3_commits_do_set_weights_failure() {
     new_test_ext(1).execute_with(|| {
         use ark_serialize::CanonicalSerialize;
 
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let hotkey: AccountId = U256::from(1);
         let reveal_round: u64 = 1000;
 
@@ -5446,7 +5461,7 @@ fn test_reveal_crv3_commits_payload_decoding_failure() {
     new_test_ext(1).execute_with(|| {
         use ark_serialize::CanonicalSerialize;
 
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let hotkey: AccountId = U256::from(1);
         let reveal_round: u64 = 1000;
 
@@ -5525,7 +5540,7 @@ fn test_reveal_crv3_commits_signature_deserialization_failure() {
     new_test_ext(1).execute_with(|| {
         use ark_serialize::CanonicalSerialize;
 
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let hotkey: AccountId = U256::from(1);
         let reveal_round: u64 = 1000;
 
@@ -5605,7 +5620,7 @@ fn test_reveal_crv3_commits_signature_deserialization_failure() {
 #[test]
 fn test_do_commit_crv3_weights_commit_size_exceeds_limit() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let hotkey: AccountId = U256::from(1);
         let reveal_round: u64 = 1000;
 
@@ -5648,7 +5663,7 @@ fn test_do_commit_crv3_weights_commit_size_exceeds_limit() {
 #[test]
 fn test_reveal_crv3_commits_with_empty_commit_queue() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
 
         add_network(netuid, 5, 0);
         SubtensorModule::set_commit_reveal_weights_enabled(netuid, true);
@@ -5670,7 +5685,7 @@ fn test_reveal_crv3_commits_with_incorrect_identity_message() {
     new_test_ext(1).execute_with(|| {
         use ark_serialize::CanonicalSerialize;
 
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let hotkey: AccountId = U256::from(1);
         let reveal_round: u64 = 1000;
 
@@ -5756,7 +5771,7 @@ fn test_reveal_crv3_commits_with_incorrect_identity_message() {
 #[test]
 fn test_multiple_commits_by_same_hotkey_within_limit() {
     new_test_ext(1).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let hotkey: AccountId = U256::from(1);
         let reveal_round: u64 = 1000;
 
@@ -5793,7 +5808,7 @@ fn test_multiple_commits_by_same_hotkey_within_limit() {
 #[test]
 fn test_reveal_crv3_commits_removes_past_epoch_commits() {
     new_test_ext(100).execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let hotkey: AccountId = U256::from(1);
         let reveal_round: u64 = 1000;
 
@@ -5860,7 +5875,7 @@ fn test_reveal_crv3_commits_multiple_valid_commits_all_processed() {
     new_test_ext(100).execute_with(|| {
         use ark_serialize::CanonicalSerialize;
 
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let reveal_round: u64 = 1000;
 
         // Initialize the network
@@ -6049,7 +6064,7 @@ fn test_reveal_crv3_commits_max_neurons() {
     new_test_ext(100).execute_with(|| {
         use ark_serialize::CanonicalSerialize;
 
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let reveal_round: u64 = 1000;
 
         add_network(netuid, 5, 0);

From 87426500e37ce1b54a17973f3834a579ae6281ca Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Thu, 5 Jun 2025 19:17:46 -0400
Subject: [PATCH 245/418] Fee test/debugging in progress

---
 pallets/subtensor/src/tests/staking.rs | 8 ++++----
 pallets/swap/src/pallet/impls.rs       | 2 ++
 pallets/swap/src/position.rs           | 6 ++++++
 pallets/swap/src/tick.rs               | 5 +++++
 4 files changed, 17 insertions(+), 4 deletions(-)

diff --git a/pallets/subtensor/src/tests/staking.rs b/pallets/subtensor/src/tests/staking.rs
index 8dc5b7c589..df43b4d7c8 100644
--- a/pallets/subtensor/src/tests/staking.rs
+++ b/pallets/subtensor/src/tests/staking.rs
@@ -6703,10 +6703,10 @@ fn test_update_position_fees() {
 
         // Add owner coldkey Alpha as concentrated liquidity
         // between current price current price + 0.01
-        let current_price = <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid)
+        let current_price = <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid.into())
             .to_num::<f64>()
-            + 0.0001;
-        let limit_price = current_price + 0.01;
+            - 0.0001;
+        let limit_price = current_price + 0.001 ;
         let tick_low = price_to_tick(current_price);
         let tick_high = price_to_tick(limit_price);
         let liquidity = amount;
@@ -6755,7 +6755,7 @@ fn test_update_position_fees() {
         assert_ok!(Swap::modify_position(
             RuntimeOrigin::signed(owner_coldkey),
             owner_hotkey,
-            netuid,
+            netuid.into(),
             position_id.into(),
             delta as i64,
         ));
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index ce8e0d0a2f..35daf03518 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -229,6 +229,8 @@ impl<T: Config> SwapStep<T> {
                 FeeGlobalTao::<T>::get(self.netuid).saturating_sub(tick.fees_out_tao);
             tick.fees_out_alpha =
                 FeeGlobalAlpha::<T>::get(self.netuid).saturating_sub(tick.fees_out_alpha);
+            println!("Tick after processing step: {:?}", tick);
+
             Pallet::<T>::update_liquidity_at_crossing(self.netuid, self.order_type)?;
             Ticks::<T>::insert(self.netuid, current_tick_index, tick);
         }
diff --git a/pallets/swap/src/position.rs b/pallets/swap/src/position.rs
index a5abbb6a00..e0423c45de 100644
--- a/pallets/swap/src/position.rs
+++ b/pallets/swap/src/position.rs
@@ -99,9 +99,14 @@ impl<T: Config> Position<T> {
         let fee_tao_agg = self.fees_in_range(true);
         let fee_alpha_agg = self.fees_in_range(false);
 
+        println!("fee_tao_agg = {:?}", fee_tao_agg);
+
         let mut fee_tao = fee_tao_agg.saturating_sub(self.fees_tao);
         let mut fee_alpha = fee_alpha_agg.saturating_sub(self.fees_alpha);
 
+        println!("fee_tao = {:?}", fee_tao);
+
+
         self.fees_tao = fee_tao_agg;
         self.fees_alpha = fee_alpha_agg;
 
@@ -120,6 +125,7 @@ impl<T: Config> Position<T> {
     /// If quote flag is true, Tao is returned, otherwise alpha.
     fn fees_in_range(&self, quote: bool) -> U64F64 {
         if quote {
+            println!("FeeGlobalTao::<T>::get(self.netuid) = {:?}", FeeGlobalTao::<T>::get(self.netuid));
             FeeGlobalTao::<T>::get(self.netuid)
         } else {
             FeeGlobalAlpha::<T>::get(self.netuid)
diff --git a/pallets/swap/src/tick.rs b/pallets/swap/src/tick.rs
index 308890d3a1..23a24d2e88 100644
--- a/pallets/swap/src/tick.rs
+++ b/pallets/swap/src/tick.rs
@@ -222,6 +222,9 @@ impl TickIndex {
         };
 
         let tick = Ticks::<T>::get(netuid, tick_index).unwrap_or_default();
+
+        println!("fees_above tick = {:?}", tick);
+
         if tick_index <= current_tick {
             if quote {
                 FeeGlobalTao::<T>::get(netuid).saturating_sub(tick.fees_out_tao)
@@ -246,6 +249,8 @@ impl TickIndex {
 
         let tick = Ticks::<T>::get(netuid, tick_index).unwrap_or_default();
 
+        println!("fees_below tick = {:?}", tick);
+
         if tick_index <= current_tick {
             if quote {
                 tick.fees_out_tao

From d74dc9dabe78d86a35a0b4c7034c76e15bd22672 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Thu, 5 Jun 2025 19:21:28 -0400
Subject: [PATCH 246/418] Fix freeze struct for NetUid

---
 common/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/common/src/lib.rs b/common/src/lib.rs
index a33220d47c..ad1648c3ab 100644
--- a/common/src/lib.rs
+++ b/common/src/lib.rs
@@ -34,7 +34,7 @@ pub type Nonce = u32;
 /// Transfers below SMALL_TRANSFER_LIMIT are considered small transfers
 pub const SMALL_TRANSFER_LIMIT: Balance = 500_000_000; // 0.5 TAO
 
-#[freeze_struct("2a62496e31bbcddc")]
+#[freeze_struct("bd904a1df2f6cadb")]
 #[repr(transparent)]
 #[derive(
     Clone, Copy, Decode, Default, Encode, Eq, MaxEncodedLen, PartialEq, RuntimeDebug, TypeInfo,

From a54bd4aac033eda2b2d2557c07d456bda39db49c Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Thu, 5 Jun 2025 21:22:40 -0400
Subject: [PATCH 247/418] Fix zepter

---
 pallets/swap/Cargo.toml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/pallets/swap/Cargo.toml b/pallets/swap/Cargo.toml
index 33fb89a44c..e1727a3b28 100644
--- a/pallets/swap/Cargo.toml
+++ b/pallets/swap/Cargo.toml
@@ -37,6 +37,7 @@ std = [
 	"frame-benchmarking/std",
 	"frame-support/std",
 	"frame-system/std",
+	"log/std",
 	"pallet-subtensor-swap-runtime-api/std",
 	"safe-math/std",
 	"scale-info/std",

From b389891370c1d1ed9103a216ba4fe6f475334c91 Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Fri, 6 Jun 2025 12:16:59 +0200
Subject: [PATCH 248/418] bump polkadot sdk to stable2412-6 and frontier

---
 Cargo.lock | 522 +++++++++++++++++++++++++++--------------------------
 Cargo.toml | 198 ++++++++++----------
 2 files changed, 369 insertions(+), 351 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index fd60abf24a..f9a51feefd 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -922,7 +922,7 @@ dependencies = [
 [[package]]
 name = "binary-merkle-tree"
 version = "16.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "hash-db",
  "log",
@@ -1888,7 +1888,7 @@ dependencies = [
 [[package]]
 name = "cumulus-client-parachain-inherent"
 version = "0.15.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "async-trait",
  "cumulus-primitives-core",
@@ -1898,7 +1898,7 @@ dependencies = [
  "parity-scale-codec",
  "sc-client-api",
  "sp-api",
- "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6)",
  "sp-inherents",
  "sp-runtime",
  "sp-state-machine",
@@ -1910,7 +1910,7 @@ dependencies = [
 [[package]]
 name = "cumulus-primitives-core"
 version = "0.17.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "parity-scale-codec",
  "polkadot-core-primitives",
@@ -1926,7 +1926,7 @@ dependencies = [
 [[package]]
 name = "cumulus-primitives-parachain-inherent"
 version = "0.17.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "async-trait",
  "cumulus-primitives-core",
@@ -1940,22 +1940,39 @@ dependencies = [
 [[package]]
 name = "cumulus-primitives-proof-size-hostfunction"
 version = "0.11.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "sp-externalities 0.30.0",
  "sp-runtime-interface 29.0.0",
  "sp-trie",
 ]
 
+[[package]]
+name = "cumulus-primitives-storage-weight-reclaim"
+version = "9.1.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
+dependencies = [
+ "cumulus-primitives-core",
+ "cumulus-primitives-proof-size-hostfunction",
+ "docify",
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "log",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-runtime",
+]
+
 [[package]]
 name = "cumulus-relay-chain-interface"
 version = "0.21.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "async-trait",
  "cumulus-primitives-core",
  "futures",
- "jsonrpsee-core 0.24.7",
+ "jsonrpsee-core 0.24.9",
  "parity-scale-codec",
  "polkadot-overseer",
  "sc-client-api",
@@ -1969,7 +1986,7 @@ dependencies = [
 [[package]]
 name = "cumulus-test-relay-sproof-builder"
 version = "0.17.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "cumulus-primitives-core",
  "parity-scale-codec",
@@ -2844,7 +2861,7 @@ dependencies = [
 [[package]]
 name = "fc-api"
 version = "1.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
+source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
 dependencies = [
  "async-trait",
  "fp-storage",
@@ -2856,7 +2873,7 @@ dependencies = [
 [[package]]
 name = "fc-aura"
 version = "1.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
+source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
 dependencies = [
  "fc-rpc",
  "fp-storage",
@@ -2872,7 +2889,7 @@ dependencies = [
 [[package]]
 name = "fc-consensus"
 version = "2.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
+source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
 dependencies = [
  "async-trait",
  "fp-consensus",
@@ -2882,13 +2899,13 @@ dependencies = [
  "sp-block-builder",
  "sp-consensus",
  "sp-runtime",
- "thiserror 1.0.64",
+ "thiserror 2.0.12",
 ]
 
 [[package]]
 name = "fc-db"
 version = "2.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
+source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
 dependencies = [
  "async-trait",
  "ethereum",
@@ -2918,7 +2935,7 @@ dependencies = [
 [[package]]
 name = "fc-mapping-sync"
 version = "2.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
+source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
 dependencies = [
  "fc-db",
  "fc-storage",
@@ -2941,7 +2958,7 @@ dependencies = [
 [[package]]
 name = "fc-rpc"
 version = "2.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
+source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
 dependencies = [
  "ethereum",
  "ethereum-types 0.15.1",
@@ -2955,20 +2972,19 @@ dependencies = [
  "fp-storage",
  "futures",
  "hex",
- "jsonrpsee 0.24.7",
+ "jsonrpsee 0.24.9",
  "libsecp256k1",
  "log",
  "pallet-evm",
  "parity-scale-codec",
  "prometheus",
- "rand 0.8.5",
+ "rand 0.9.1",
  "rlp 0.6.1",
  "sc-client-api",
  "sc-network",
  "sc-network-sync",
  "sc-rpc",
  "sc-service",
- "sc-transaction-pool",
  "sc-transaction-pool-api",
  "sc-utils",
  "schnellru",
@@ -2984,30 +3000,31 @@ dependencies = [
  "sp-runtime",
  "sp-state-machine",
  "sp-storage 22.0.0",
+ "sp-trie",
  "substrate-prometheus-endpoint",
- "thiserror 1.0.64",
+ "thiserror 2.0.12",
  "tokio",
 ]
 
 [[package]]
 name = "fc-rpc-core"
 version = "1.1.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
+source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
 dependencies = [
  "ethereum",
  "ethereum-types 0.15.1",
- "jsonrpsee 0.24.7",
+ "jsonrpsee 0.24.9",
  "rlp 0.6.1",
  "rustc-hex",
  "serde",
  "serde_json",
- "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6)",
 ]
 
 [[package]]
 name = "fc-storage"
 version = "1.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
+source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
 dependencies = [
  "ethereum",
  "ethereum-types 0.15.1",
@@ -3173,7 +3190,7 @@ checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
 [[package]]
 name = "fork-tree"
 version = "13.0.1"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "parity-scale-codec",
 ]
@@ -3200,7 +3217,7 @@ dependencies = [
 [[package]]
 name = "fp-account"
 version = "1.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
+source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
 dependencies = [
  "hex",
  "impl-serde 0.5.0",
@@ -3219,7 +3236,7 @@ dependencies = [
 [[package]]
 name = "fp-consensus"
 version = "2.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
+source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
 dependencies = [
  "ethereum",
  "parity-scale-codec",
@@ -3230,7 +3247,7 @@ dependencies = [
 [[package]]
 name = "fp-ethereum"
 version = "1.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
+source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
 dependencies = [
  "ethereum",
  "ethereum-types 0.15.1",
@@ -3242,7 +3259,7 @@ dependencies = [
 [[package]]
 name = "fp-evm"
 version = "3.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
+source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
 dependencies = [
  "environmental",
  "evm",
@@ -3258,7 +3275,7 @@ dependencies = [
 [[package]]
 name = "fp-rpc"
 version = "3.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
+source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
 dependencies = [
  "ethereum",
  "ethereum-types 0.15.1",
@@ -3274,7 +3291,7 @@ dependencies = [
 [[package]]
 name = "fp-self-contained"
 version = "1.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
+source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
 dependencies = [
  "frame-support",
  "parity-scale-codec",
@@ -3286,7 +3303,7 @@ dependencies = [
 [[package]]
 name = "fp-storage"
 version = "2.0.0"
-source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
+source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
 dependencies = [
  "parity-scale-codec",
  "serde",
@@ -3300,8 +3317,8 @@ checksum = "6c2141d6d6c8512188a7891b4b01590a45f6dac67afb4f255c4124dbb86d4eaa"
 
 [[package]]
 name = "frame-benchmarking"
-version = "39.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+version = "39.1.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "frame-support",
  "frame-support-procedural",
@@ -3324,8 +3341,8 @@ dependencies = [
 
 [[package]]
 name = "frame-benchmarking-cli"
-version = "46.1.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+version = "46.2.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "Inflector",
  "array-bytes",
@@ -3363,7 +3380,7 @@ dependencies = [
  "sp-block-builder",
  "sp-blockchain",
  "sp-core",
- "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6)",
  "sp-database",
  "sp-externalities 0.30.0",
  "sp-genesis-builder",
@@ -3387,7 +3404,7 @@ dependencies = [
 [[package]]
 name = "frame-executive"
 version = "39.1.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "aquamarine",
  "frame-support",
@@ -3440,7 +3457,7 @@ dependencies = [
 [[package]]
 name = "frame-metadata-hash-extension"
 version = "0.7.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "array-bytes",
  "const-hex",
@@ -3456,7 +3473,7 @@ dependencies = [
 [[package]]
 name = "frame-support"
 version = "39.1.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "aquamarine",
  "array-bytes",
@@ -3480,7 +3497,7 @@ dependencies = [
  "sp-arithmetic",
  "sp-core",
  "sp-crypto-hashing-proc-macro",
- "sp-debug-derive 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-debug-derive 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6)",
  "sp-genesis-builder",
  "sp-inherents",
  "sp-io",
@@ -3488,7 +3505,7 @@ dependencies = [
  "sp-runtime",
  "sp-staking",
  "sp-state-machine",
- "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6)",
  "sp-tracing 17.0.1",
  "sp-trie",
  "sp-weights",
@@ -3499,7 +3516,7 @@ dependencies = [
 [[package]]
 name = "frame-support-procedural"
 version = "31.1.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "Inflector",
  "cfg-expr",
@@ -3512,7 +3529,7 @@ dependencies = [
  "proc-macro-warning 1.0.2",
  "proc-macro2",
  "quote",
- "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6)",
  "syn 2.0.101",
 ]
 
@@ -3532,7 +3549,7 @@ dependencies = [
 [[package]]
 name = "frame-support-procedural-tools"
 version = "13.0.1"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "frame-support-procedural-tools-derive 12.0.0",
  "proc-macro-crate 3.2.0",
@@ -3555,7 +3572,7 @@ dependencies = [
 [[package]]
 name = "frame-support-procedural-tools-derive"
 version = "12.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3565,7 +3582,7 @@ dependencies = [
 [[package]]
 name = "frame-system"
 version = "39.1.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "cfg-if",
  "docify",
@@ -3577,7 +3594,7 @@ dependencies = [
  "sp-core",
  "sp-io",
  "sp-runtime",
- "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6)",
  "sp-version",
  "sp-weights",
 ]
@@ -3585,7 +3602,7 @@ dependencies = [
 [[package]]
 name = "frame-system-benchmarking"
 version = "39.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "frame-benchmarking",
  "frame-support",
@@ -3599,7 +3616,7 @@ dependencies = [
 [[package]]
 name = "frame-system-rpc-runtime-api"
 version = "35.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "docify",
  "parity-scale-codec",
@@ -3609,7 +3626,7 @@ dependencies = [
 [[package]]
 name = "frame-try-runtime"
 version = "0.45.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "frame-support",
  "parity-scale-codec",
@@ -4290,7 +4307,7 @@ dependencies = [
  "httpdate",
  "itoa",
  "pin-project-lite",
- "socket2 0.4.10",
+ "socket2 0.5.9",
  "tokio",
  "tower-service",
  "tracing",
@@ -4873,14 +4890,14 @@ dependencies = [
 
 [[package]]
 name = "jsonrpsee"
-version = "0.24.7"
+version = "0.24.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c5c71d8c1a731cc4227c2f698d377e7848ca12c8a48866fc5e6951c43a4db843"
+checksum = "37b26c20e2178756451cfeb0661fb74c47dd5988cb7e3939de7e9241fd604d42"
 dependencies = [
- "jsonrpsee-core 0.24.7",
+ "jsonrpsee-core 0.24.9",
  "jsonrpsee-proc-macros",
  "jsonrpsee-server",
- "jsonrpsee-types 0.24.7",
+ "jsonrpsee-types 0.24.9",
  "tokio",
  "tracing",
 ]
@@ -4976,9 +4993,9 @@ dependencies = [
 
 [[package]]
 name = "jsonrpsee-core"
-version = "0.24.7"
+version = "0.24.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2882f6f8acb9fdaec7cefc4fd607119a9bd709831df7d7672a1d3b644628280"
+checksum = "456196007ca3a14db478346f58c7238028d55ee15c1df15115596e411ff27925"
 dependencies = [
  "async-trait",
  "bytes",
@@ -4986,7 +5003,7 @@ dependencies = [
  "http 1.1.0",
  "http-body 1.0.1",
  "http-body-util",
- "jsonrpsee-types 0.24.7",
+ "jsonrpsee-types 0.24.9",
  "parking_lot 0.12.3",
  "rand 0.8.5",
  "rustc-hash 2.0.0",
@@ -5019,9 +5036,9 @@ dependencies = [
 
 [[package]]
 name = "jsonrpsee-proc-macros"
-version = "0.24.7"
+version = "0.24.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c06c01ae0007548e73412c08e2285ffe5d723195bf268bce67b1b77c3bb2a14d"
+checksum = "5e65763c942dfc9358146571911b0cd1c361c2d63e2d2305622d40d36376ca80"
 dependencies = [
  "heck 0.5.0",
  "proc-macro-crate 3.2.0",
@@ -5032,9 +5049,9 @@ dependencies = [
 
 [[package]]
 name = "jsonrpsee-server"
-version = "0.24.7"
+version = "0.24.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "82ad8ddc14be1d4290cd68046e7d1d37acd408efed6d3ca08aefcc3ad6da069c"
+checksum = "55e363146da18e50ad2b51a0a7925fc423137a0b1371af8235b1c231a0647328"
 dependencies = [
  "futures-util",
  "http 1.1.0",
@@ -5042,8 +5059,8 @@ dependencies = [
  "http-body-util",
  "hyper 1.5.0",
  "hyper-util",
- "jsonrpsee-core 0.24.7",
- "jsonrpsee-types 0.24.7",
+ "jsonrpsee-core 0.24.9",
+ "jsonrpsee-types 0.24.9",
  "pin-project",
  "route-recognizer",
  "serde",
@@ -5085,9 +5102,9 @@ dependencies = [
 
 [[package]]
 name = "jsonrpsee-types"
-version = "0.24.7"
+version = "0.24.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a178c60086f24cc35bb82f57c651d0d25d99c4742b4d335de04e97fa1f08a8a1"
+checksum = "08a8e70baf945b6b5752fc8eb38c918a48f1234daf11355e07106d963f860089"
 dependencies = [
  "http 1.1.0",
  "serde",
@@ -6492,7 +6509,7 @@ dependencies = [
  "frame-system-rpc-runtime-api",
  "futures",
  "hex",
- "jsonrpsee 0.24.7",
+ "jsonrpsee 0.24.9",
  "memmap2 0.9.5",
  "node-subtensor-runtime",
  "num-traits",
@@ -6620,7 +6637,7 @@ dependencies = [
  "sp-offchain",
  "sp-runtime",
  "sp-session",
- "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6)",
  "sp-storage 22.0.0",
  "sp-tracing 17.0.1",
  "sp-transaction-pool",
@@ -6984,7 +7001,7 @@ dependencies = [
  "sp-core",
  "sp-io",
  "sp-runtime",
- "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6)",
  "sp-tracing 17.0.1",
  "sp-weights",
  "substrate-fixed",
@@ -6994,7 +7011,7 @@ dependencies = [
 [[package]]
 name = "pallet-aura"
 version = "38.1.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "frame-support",
  "frame-system",
@@ -7010,7 +7027,7 @@ dependencies = [
 [[package]]
 name = "pallet-authorship"
 version = "39.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "frame-support",
  "frame-system",
@@ -7023,7 +7040,7 @@ dependencies = [
 [[package]]
 name = "pallet-balances"
 version = "40.1.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "docify",
  "frame-benchmarking",
@@ -7038,7 +7055,7 @@ dependencies = [
 [[package]]
 name = "pallet-base-fee"
 version = "1.0.0"
-source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
+source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
 dependencies = [
  "fp-evm",
  "frame-support",
@@ -7062,7 +7079,7 @@ dependencies = [
  "sp-core",
  "sp-io",
  "sp-runtime",
- "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6)",
  "subtensor-macros",
 ]
 
@@ -7087,7 +7104,7 @@ dependencies = [
  "sp-core",
  "sp-io",
  "sp-runtime",
- "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6)",
  "subtensor-macros",
  "tle",
  "w3f-bls",
@@ -7108,7 +7125,7 @@ dependencies = [
  "sp-core",
  "sp-io",
  "sp-runtime",
- "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6)",
  "subtensor-macros",
 ]
 
@@ -7148,7 +7165,7 @@ dependencies = [
 [[package]]
 name = "pallet-ethereum"
 version = "4.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
+source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
 dependencies = [
  "ethereum",
  "ethereum-types 0.15.1",
@@ -7171,8 +7188,9 @@ dependencies = [
 [[package]]
 name = "pallet-evm"
 version = "6.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
+source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
 dependencies = [
+ "cumulus-primitives-storage-weight-reclaim",
  "environmental",
  "evm",
  "fp-account",
@@ -7194,7 +7212,7 @@ dependencies = [
 [[package]]
 name = "pallet-evm-chain-id"
 version = "1.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
+source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
 dependencies = [
  "frame-support",
  "frame-system",
@@ -7205,7 +7223,7 @@ dependencies = [
 [[package]]
 name = "pallet-evm-precompile-modexp"
 version = "2.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
+source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
 dependencies = [
  "fp-evm",
  "num",
@@ -7214,7 +7232,7 @@ dependencies = [
 [[package]]
 name = "pallet-evm-precompile-sha3fips"
 version = "2.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
+source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
 dependencies = [
  "fp-evm",
  "tiny-keccak",
@@ -7223,7 +7241,7 @@ dependencies = [
 [[package]]
 name = "pallet-evm-precompile-simple"
 version = "2.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
+source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
 dependencies = [
  "fp-evm",
  "ripemd",
@@ -7233,7 +7251,7 @@ dependencies = [
 [[package]]
 name = "pallet-grandpa"
 version = "39.1.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "frame-benchmarking",
  "frame-support",
@@ -7255,7 +7273,7 @@ dependencies = [
 [[package]]
 name = "pallet-hotfix-sufficients"
 version = "1.0.0"
-source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
+source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
 dependencies = [
  "frame-benchmarking",
  "frame-support",
@@ -7270,7 +7288,7 @@ dependencies = [
 [[package]]
 name = "pallet-insecure-randomness-collective-flip"
 version = "27.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "frame-support",
  "frame-system",
@@ -7283,7 +7301,7 @@ dependencies = [
 [[package]]
 name = "pallet-membership"
 version = "39.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "frame-benchmarking",
  "frame-support",
@@ -7299,7 +7317,7 @@ dependencies = [
 [[package]]
 name = "pallet-multisig"
 version = "39.1.1"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "log",
  "parity-scale-codec",
@@ -7310,7 +7328,7 @@ dependencies = [
 [[package]]
 name = "pallet-preimage"
 version = "39.1.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "frame-benchmarking",
  "frame-support",
@@ -7343,7 +7361,7 @@ dependencies = [
 [[package]]
 name = "pallet-proxy"
 version = "39.1.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "parity-scale-codec",
  "polkadot-sdk-frame",
@@ -7363,14 +7381,14 @@ dependencies = [
  "sp-core",
  "sp-io",
  "sp-runtime",
- "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6)",
  "subtensor-macros",
 ]
 
 [[package]]
 name = "pallet-root-testing"
 version = "15.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "frame-support",
  "frame-system",
@@ -7384,7 +7402,7 @@ dependencies = [
 [[package]]
 name = "pallet-safe-mode"
 version = "20.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "docify",
  "frame-benchmarking",
@@ -7401,8 +7419,8 @@ dependencies = [
 
 [[package]]
 name = "pallet-scheduler"
-version = "40.1.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+version = "40.2.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "docify",
  "frame-benchmarking",
@@ -7419,7 +7437,7 @@ dependencies = [
 [[package]]
 name = "pallet-session"
 version = "39.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "frame-support",
  "frame-system",
@@ -7477,7 +7495,7 @@ dependencies = [
  "sp-core",
  "sp-io",
  "sp-runtime",
- "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6)",
  "sp-tracing 17.0.1",
  "sp-version",
  "substrate-fixed",
@@ -7489,7 +7507,7 @@ dependencies = [
 [[package]]
 name = "pallet-sudo"
 version = "39.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "docify",
  "frame-benchmarking",
@@ -7504,7 +7522,7 @@ dependencies = [
 [[package]]
 name = "pallet-timestamp"
 version = "38.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "docify",
  "frame-benchmarking",
@@ -7523,7 +7541,7 @@ dependencies = [
 [[package]]
 name = "pallet-transaction-payment"
 version = "39.1.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "frame-benchmarking",
  "frame-support",
@@ -7539,9 +7557,9 @@ dependencies = [
 [[package]]
 name = "pallet-transaction-payment-rpc"
 version = "42.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
- "jsonrpsee 0.24.7",
+ "jsonrpsee 0.24.9",
  "pallet-transaction-payment-rpc-runtime-api",
  "parity-scale-codec",
  "sp-api",
@@ -7555,7 +7573,7 @@ dependencies = [
 [[package]]
 name = "pallet-transaction-payment-rpc-runtime-api"
 version = "39.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "pallet-transaction-payment",
  "parity-scale-codec",
@@ -7586,7 +7604,7 @@ dependencies = [
 [[package]]
 name = "pallet-utility"
 version = "39.1.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "frame-benchmarking",
  "frame-support",
@@ -7921,7 +7939,7 @@ checksum = "953ec861398dccce10c670dfeaf3ec4911ca479e9c02154b3a215178c5f566f2"
 [[package]]
 name = "polkadot-core-primitives"
 version = "16.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "parity-scale-codec",
  "scale-info",
@@ -7932,7 +7950,7 @@ dependencies = [
 [[package]]
 name = "polkadot-node-metrics"
 version = "21.1.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "bs58",
  "futures",
@@ -7951,7 +7969,7 @@ dependencies = [
 [[package]]
 name = "polkadot-node-network-protocol"
 version = "21.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "async-channel 1.9.0",
  "async-trait",
@@ -7976,7 +7994,7 @@ dependencies = [
 [[package]]
 name = "polkadot-node-primitives"
 version = "17.0.1"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "bitvec",
  "bounded-vec",
@@ -8002,7 +8020,7 @@ dependencies = [
 [[package]]
 name = "polkadot-node-subsystem-types"
 version = "21.0.1"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "async-trait",
  "bitvec",
@@ -8031,7 +8049,7 @@ dependencies = [
 [[package]]
 name = "polkadot-overseer"
 version = "21.1.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "async-trait",
  "futures",
@@ -8053,7 +8071,7 @@ dependencies = [
 [[package]]
 name = "polkadot-parachain-primitives"
 version = "15.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "bounded-collections",
  "derive_more 0.99.18",
@@ -8069,7 +8087,7 @@ dependencies = [
 [[package]]
 name = "polkadot-primitives"
 version = "17.1.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "bitvec",
  "hex-literal",
@@ -8090,14 +8108,14 @@ dependencies = [
  "sp-keystore",
  "sp-runtime",
  "sp-staking",
- "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6)",
  "thiserror 1.0.64",
 ]
 
 [[package]]
 name = "polkadot-sdk-frame"
 version = "0.8.1"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "docify",
  "frame-benchmarking",
@@ -8131,7 +8149,7 @@ dependencies = [
 [[package]]
 name = "polkadot-statement-table"
 version = "17.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "parity-scale-codec",
  "polkadot-primitives",
@@ -8293,7 +8311,7 @@ dependencies = [
 [[package]]
 name = "precompile-utils"
 version = "0.1.0"
-source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
+source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
 dependencies = [
  "environmental",
  "evm",
@@ -8317,14 +8335,14 @@ dependencies = [
 [[package]]
 name = "precompile-utils-macro"
 version = "0.1.0"
-source = "git+https://github.com/opentensor/frontier?rev=b0d0c2fe2e#b0d0c2fe2edab5cfa2252c57fab69059201ed3d7"
+source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
 dependencies = [
  "case",
  "num_enum",
  "prettyplease",
  "proc-macro2",
  "quote",
- "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6)",
  "syn 2.0.101",
 ]
 
@@ -9456,7 +9474,7 @@ name = "safe-math"
 version = "0.1.0"
 dependencies = [
  "num-traits",
- "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6)",
  "substrate-fixed",
 ]
 
@@ -9490,7 +9508,7 @@ dependencies = [
 [[package]]
 name = "sc-allocator"
 version = "30.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "log",
  "sp-core",
@@ -9501,7 +9519,7 @@ dependencies = [
 [[package]]
 name = "sc-authority-discovery"
 version = "0.48.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "async-trait",
  "futures",
@@ -9531,7 +9549,7 @@ dependencies = [
 [[package]]
 name = "sc-basic-authorship"
 version = "0.48.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "futures",
  "futures-timer",
@@ -9553,7 +9571,7 @@ dependencies = [
 [[package]]
 name = "sc-block-builder"
 version = "0.43.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "parity-scale-codec",
  "sp-api",
@@ -9568,7 +9586,7 @@ dependencies = [
 [[package]]
 name = "sc-chain-spec"
 version = "41.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "array-bytes",
  "docify",
@@ -9584,7 +9602,7 @@ dependencies = [
  "serde_json",
  "sp-blockchain",
  "sp-core",
- "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6)",
  "sp-genesis-builder",
  "sp-io",
  "sp-runtime",
@@ -9595,7 +9613,7 @@ dependencies = [
 [[package]]
 name = "sc-chain-spec-derive"
 version = "12.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "proc-macro-crate 3.2.0",
  "proc-macro2",
@@ -9606,7 +9624,7 @@ dependencies = [
 [[package]]
 name = "sc-cli"
 version = "0.50.1"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "array-bytes",
  "chrono",
@@ -9648,7 +9666,7 @@ dependencies = [
 [[package]]
 name = "sc-client-api"
 version = "38.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "fnv",
  "futures",
@@ -9675,7 +9693,7 @@ dependencies = [
 [[package]]
 name = "sc-client-db"
 version = "0.45.1"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "hash-db",
  "kvdb",
@@ -9701,7 +9719,7 @@ dependencies = [
 [[package]]
 name = "sc-consensus"
 version = "0.47.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "async-trait",
  "futures",
@@ -9725,7 +9743,7 @@ dependencies = [
 [[package]]
 name = "sc-consensus-aura"
 version = "0.48.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "async-trait",
  "futures",
@@ -9754,7 +9772,7 @@ dependencies = [
 [[package]]
 name = "sc-consensus-babe"
 version = "0.48.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "async-trait",
  "fork-tree",
@@ -9779,7 +9797,7 @@ dependencies = [
  "sp-consensus-babe",
  "sp-consensus-slots",
  "sp-core",
- "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6)",
  "sp-inherents",
  "sp-keystore",
  "sp-runtime",
@@ -9790,7 +9808,7 @@ dependencies = [
 [[package]]
 name = "sc-consensus-epochs"
 version = "0.47.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "fork-tree",
  "parity-scale-codec",
@@ -9803,7 +9821,7 @@ dependencies = [
 [[package]]
 name = "sc-consensus-grandpa"
 version = "0.33.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "ahash 0.8.11",
  "array-bytes",
@@ -9837,7 +9855,7 @@ dependencies = [
  "sp-consensus",
  "sp-consensus-grandpa",
  "sp-core",
- "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6)",
  "sp-keystore",
  "sp-runtime",
  "substrate-prometheus-endpoint",
@@ -9847,11 +9865,11 @@ dependencies = [
 [[package]]
 name = "sc-consensus-grandpa-rpc"
 version = "0.33.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "finality-grandpa",
  "futures",
- "jsonrpsee 0.24.7",
+ "jsonrpsee 0.24.9",
  "log",
  "parity-scale-codec",
  "sc-client-api",
@@ -9867,13 +9885,13 @@ dependencies = [
 [[package]]
 name = "sc-consensus-manual-seal"
 version = "0.49.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "assert_matches",
  "async-trait",
  "futures",
  "futures-timer",
- "jsonrpsee 0.24.7",
+ "jsonrpsee 0.24.9",
  "log",
  "parity-scale-codec",
  "sc-client-api",
@@ -9902,7 +9920,7 @@ dependencies = [
 [[package]]
 name = "sc-consensus-slots"
 version = "0.47.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "async-trait",
  "futures",
@@ -9925,7 +9943,7 @@ dependencies = [
 [[package]]
 name = "sc-executor"
 version = "0.41.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "parity-scale-codec",
  "parking_lot 0.12.3",
@@ -9948,7 +9966,7 @@ dependencies = [
 [[package]]
 name = "sc-executor-common"
 version = "0.36.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "polkavm",
  "sc-allocator",
@@ -9961,7 +9979,7 @@ dependencies = [
 [[package]]
 name = "sc-executor-polkavm"
 version = "0.33.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "log",
  "polkavm",
@@ -9972,7 +9990,7 @@ dependencies = [
 [[package]]
 name = "sc-executor-wasmtime"
 version = "0.36.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "anyhow",
  "cfg-if",
@@ -9990,7 +10008,7 @@ dependencies = [
 [[package]]
 name = "sc-informant"
 version = "0.47.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "console",
  "futures",
@@ -10007,7 +10025,7 @@ dependencies = [
 [[package]]
 name = "sc-keystore"
 version = "34.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "array-bytes",
  "parking_lot 0.12.3",
@@ -10021,7 +10039,7 @@ dependencies = [
 [[package]]
 name = "sc-mixnet"
 version = "0.18.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "array-bytes",
  "arrayvec 0.7.6",
@@ -10049,8 +10067,8 @@ dependencies = [
 
 [[package]]
 name = "sc-network"
-version = "0.48.3"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+version = "0.48.4"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "array-bytes",
  "async-channel 1.9.0",
@@ -10101,7 +10119,7 @@ dependencies = [
 [[package]]
 name = "sc-network-common"
 version = "0.47.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "async-trait",
  "bitflags 1.3.2",
@@ -10119,7 +10137,7 @@ dependencies = [
 [[package]]
 name = "sc-network-gossip"
 version = "0.48.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "ahash 0.8.11",
  "futures",
@@ -10138,7 +10156,7 @@ dependencies = [
 [[package]]
 name = "sc-network-light"
 version = "0.47.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "array-bytes",
  "async-channel 1.9.0",
@@ -10159,7 +10177,7 @@ dependencies = [
 [[package]]
 name = "sc-network-sync"
 version = "0.47.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "array-bytes",
  "async-channel 1.9.0",
@@ -10195,7 +10213,7 @@ dependencies = [
 [[package]]
 name = "sc-network-transactions"
 version = "0.47.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "array-bytes",
  "futures",
@@ -10214,7 +10232,7 @@ dependencies = [
 [[package]]
 name = "sc-network-types"
 version = "0.15.2"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "bs58",
  "ed25519-dalek",
@@ -10231,7 +10249,7 @@ dependencies = [
 [[package]]
 name = "sc-offchain"
 version = "43.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "array-bytes",
  "bytes",
@@ -10268,7 +10286,7 @@ dependencies = [
 [[package]]
 name = "sc-proposer-metrics"
 version = "0.18.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "log",
  "substrate-prometheus-endpoint",
@@ -10277,10 +10295,10 @@ dependencies = [
 [[package]]
 name = "sc-rpc"
 version = "43.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "futures",
- "jsonrpsee 0.24.7",
+ "jsonrpsee 0.24.9",
  "log",
  "parity-scale-codec",
  "parking_lot 0.12.3",
@@ -10309,9 +10327,9 @@ dependencies = [
 [[package]]
 name = "sc-rpc-api"
 version = "0.47.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
- "jsonrpsee 0.24.7",
+ "jsonrpsee 0.24.9",
  "parity-scale-codec",
  "sc-chain-spec",
  "sc-mixnet",
@@ -10329,7 +10347,7 @@ dependencies = [
 [[package]]
 name = "sc-rpc-server"
 version = "20.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "dyn-clone",
  "forwarded-header-value",
@@ -10339,7 +10357,7 @@ dependencies = [
  "http-body-util",
  "hyper 1.5.0",
  "ip_network",
- "jsonrpsee 0.24.7",
+ "jsonrpsee 0.24.9",
  "log",
  "sc-rpc-api",
  "serde",
@@ -10353,14 +10371,14 @@ dependencies = [
 [[package]]
 name = "sc-rpc-spec-v2"
 version = "0.48.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "array-bytes",
  "futures",
  "futures-util",
  "hex",
  "itertools 0.11.0",
- "jsonrpsee 0.24.7",
+ "jsonrpsee 0.24.9",
  "log",
  "parity-scale-codec",
  "parking_lot 0.12.3",
@@ -10385,14 +10403,14 @@ dependencies = [
 [[package]]
 name = "sc-service"
 version = "0.49.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "async-trait",
  "directories",
  "exit-future",
  "futures",
  "futures-timer",
- "jsonrpsee 0.24.7",
+ "jsonrpsee 0.24.9",
  "log",
  "parity-scale-codec",
  "parking_lot 0.12.3",
@@ -10449,7 +10467,7 @@ dependencies = [
 [[package]]
 name = "sc-state-db"
 version = "0.37.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "log",
  "parity-scale-codec",
@@ -10460,7 +10478,7 @@ dependencies = [
 [[package]]
 name = "sc-sysinfo"
 version = "41.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "derive_more 0.99.18",
  "futures",
@@ -10473,15 +10491,15 @@ dependencies = [
  "serde",
  "serde_json",
  "sp-core",
- "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6)",
  "sp-io",
- "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6)",
 ]
 
 [[package]]
 name = "sc-telemetry"
 version = "28.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "chrono",
  "futures",
@@ -10501,7 +10519,7 @@ dependencies = [
 [[package]]
 name = "sc-tracing"
 version = "38.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "chrono",
  "console",
@@ -10529,7 +10547,7 @@ dependencies = [
 [[package]]
 name = "sc-tracing-proc-macro"
 version = "11.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "proc-macro-crate 3.2.0",
  "proc-macro2",
@@ -10540,7 +10558,7 @@ dependencies = [
 [[package]]
 name = "sc-transaction-pool"
 version = "38.1.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "async-trait",
  "futures",
@@ -10558,7 +10576,7 @@ dependencies = [
  "sp-api",
  "sp-blockchain",
  "sp-core",
- "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6)",
  "sp-runtime",
  "sp-tracing 17.0.1",
  "sp-transaction-pool",
@@ -10571,7 +10589,7 @@ dependencies = [
 [[package]]
 name = "sc-transaction-pool-api"
 version = "38.1.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "async-trait",
  "futures",
@@ -10587,7 +10605,7 @@ dependencies = [
 [[package]]
 name = "sc-utils"
 version = "18.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "async-channel 1.9.0",
  "futures",
@@ -11123,7 +11141,7 @@ name = "share-pool"
 version = "0.1.0"
 dependencies = [
  "safe-math",
- "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6)",
  "substrate-fixed",
 ]
 
@@ -11398,7 +11416,7 @@ dependencies = [
 [[package]]
 name = "sp-api"
 version = "35.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "docify",
  "hash-db",
@@ -11420,7 +11438,7 @@ dependencies = [
 [[package]]
 name = "sp-api-proc-macro"
 version = "21.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "Inflector",
  "blake2 0.10.6",
@@ -11434,7 +11452,7 @@ dependencies = [
 [[package]]
 name = "sp-application-crypto"
 version = "39.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "parity-scale-codec",
  "scale-info",
@@ -11446,7 +11464,7 @@ dependencies = [
 [[package]]
 name = "sp-arithmetic"
 version = "26.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "docify",
  "integer-sqrt",
@@ -11469,7 +11487,7 @@ dependencies = [
 [[package]]
 name = "sp-authority-discovery"
 version = "35.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "parity-scale-codec",
  "scale-info",
@@ -11481,7 +11499,7 @@ dependencies = [
 [[package]]
 name = "sp-block-builder"
 version = "35.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "sp-api",
  "sp-inherents",
@@ -11491,7 +11509,7 @@ dependencies = [
 [[package]]
 name = "sp-blockchain"
 version = "38.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "futures",
  "parity-scale-codec",
@@ -11510,7 +11528,7 @@ dependencies = [
 [[package]]
 name = "sp-consensus"
 version = "0.41.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "async-trait",
  "futures",
@@ -11525,7 +11543,7 @@ dependencies = [
 [[package]]
 name = "sp-consensus-aura"
 version = "0.41.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "async-trait",
  "parity-scale-codec",
@@ -11541,7 +11559,7 @@ dependencies = [
 [[package]]
 name = "sp-consensus-babe"
 version = "0.41.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "async-trait",
  "parity-scale-codec",
@@ -11559,7 +11577,7 @@ dependencies = [
 [[package]]
 name = "sp-consensus-grandpa"
 version = "22.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "finality-grandpa",
  "log",
@@ -11576,7 +11594,7 @@ dependencies = [
 [[package]]
 name = "sp-consensus-slots"
 version = "0.41.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "parity-scale-codec",
  "scale-info",
@@ -11587,7 +11605,7 @@ dependencies = [
 [[package]]
 name = "sp-core"
 version = "35.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "array-bytes",
  "bitflags 1.3.2",
@@ -11616,11 +11634,11 @@ dependencies = [
  "secp256k1 0.28.2",
  "secrecy",
  "serde",
- "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
- "sp-debug-derive 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6)",
+ "sp-debug-derive 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6)",
  "sp-externalities 0.30.0",
  "sp-runtime-interface 29.0.0",
- "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6)",
  "sp-storage 22.0.0",
  "ss58-registry",
  "substrate-bip39",
@@ -11653,7 +11671,7 @@ dependencies = [
 [[package]]
 name = "sp-crypto-ec-utils"
 version = "0.15.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "ark-bls12-377",
  "ark-bls12-377-ext",
@@ -11687,7 +11705,7 @@ dependencies = [
 [[package]]
 name = "sp-crypto-hashing"
 version = "0.1.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "blake2b_simd",
  "byteorder",
@@ -11700,17 +11718,17 @@ dependencies = [
 [[package]]
 name = "sp-crypto-hashing-proc-macro"
 version = "0.1.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "quote",
- "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6)",
  "syn 2.0.101",
 ]
 
 [[package]]
 name = "sp-database"
 version = "10.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "kvdb",
  "parking_lot 0.12.3",
@@ -11719,7 +11737,7 @@ dependencies = [
 [[package]]
 name = "sp-debug-derive"
 version = "14.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -11749,7 +11767,7 @@ dependencies = [
 [[package]]
 name = "sp-externalities"
 version = "0.30.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "environmental",
  "parity-scale-codec",
@@ -11759,7 +11777,7 @@ dependencies = [
 [[package]]
 name = "sp-genesis-builder"
 version = "0.16.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "parity-scale-codec",
  "scale-info",
@@ -11771,7 +11789,7 @@ dependencies = [
 [[package]]
 name = "sp-inherents"
 version = "35.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "async-trait",
  "impl-trait-for-tuples",
@@ -11784,7 +11802,7 @@ dependencies = [
 [[package]]
 name = "sp-io"
 version = "39.0.1"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "bytes",
  "docify",
@@ -11796,7 +11814,7 @@ dependencies = [
  "rustversion",
  "secp256k1 0.28.2",
  "sp-core",
- "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6)",
  "sp-externalities 0.30.0",
  "sp-keystore",
  "sp-runtime-interface 29.0.0",
@@ -11810,7 +11828,7 @@ dependencies = [
 [[package]]
 name = "sp-keyring"
 version = "40.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "sp-core",
  "sp-runtime",
@@ -11820,7 +11838,7 @@ dependencies = [
 [[package]]
 name = "sp-keystore"
 version = "0.41.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "parity-scale-codec",
  "parking_lot 0.12.3",
@@ -11831,7 +11849,7 @@ dependencies = [
 [[package]]
 name = "sp-maybe-compressed-blob"
 version = "11.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "thiserror 1.0.64",
  "zstd 0.12.4",
@@ -11840,7 +11858,7 @@ dependencies = [
 [[package]]
 name = "sp-metadata-ir"
 version = "0.8.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "frame-metadata 18.0.0",
  "parity-scale-codec",
@@ -11850,7 +11868,7 @@ dependencies = [
 [[package]]
 name = "sp-mixnet"
 version = "0.13.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "parity-scale-codec",
  "scale-info",
@@ -11861,7 +11879,7 @@ dependencies = [
 [[package]]
 name = "sp-offchain"
 version = "35.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "sp-api",
  "sp-core",
@@ -11871,7 +11889,7 @@ dependencies = [
 [[package]]
 name = "sp-panic-handler"
 version = "13.0.1"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "backtrace",
  "regex",
@@ -11880,7 +11898,7 @@ dependencies = [
 [[package]]
 name = "sp-rpc"
 version = "33.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "rustc-hash 1.1.0",
  "serde",
@@ -11890,7 +11908,7 @@ dependencies = [
 [[package]]
 name = "sp-runtime"
 version = "40.1.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "binary-merkle-tree",
  "docify",
@@ -11909,7 +11927,7 @@ dependencies = [
  "sp-arithmetic",
  "sp-core",
  "sp-io",
- "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6)",
  "sp-trie",
  "sp-weights",
  "tracing",
@@ -11938,7 +11956,7 @@ dependencies = [
 [[package]]
 name = "sp-runtime-interface"
 version = "29.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "bytes",
  "impl-trait-for-tuples",
@@ -11947,7 +11965,7 @@ dependencies = [
  "primitive-types 0.13.1",
  "sp-externalities 0.30.0",
  "sp-runtime-interface-proc-macro 18.0.0",
- "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6)",
  "sp-storage 22.0.0",
  "sp-tracing 17.0.1",
  "sp-wasm-interface 21.0.1",
@@ -11970,7 +11988,7 @@ dependencies = [
 [[package]]
 name = "sp-runtime-interface-proc-macro"
 version = "18.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "Inflector",
  "expander",
@@ -11983,7 +12001,7 @@ dependencies = [
 [[package]]
 name = "sp-session"
 version = "37.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "parity-scale-codec",
  "scale-info",
@@ -11997,7 +12015,7 @@ dependencies = [
 [[package]]
 name = "sp-staking"
 version = "37.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "impl-trait-for-tuples",
  "parity-scale-codec",
@@ -12010,7 +12028,7 @@ dependencies = [
 [[package]]
 name = "sp-state-machine"
 version = "0.44.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "hash-db",
  "log",
@@ -12030,7 +12048,7 @@ dependencies = [
 [[package]]
 name = "sp-statement-store"
 version = "19.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "aes-gcm",
  "curve25519-dalek",
@@ -12043,7 +12061,7 @@ dependencies = [
  "sp-api",
  "sp-application-crypto",
  "sp-core",
- "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-crypto-hashing 0.1.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6)",
  "sp-externalities 0.30.0",
  "sp-runtime",
  "sp-runtime-interface 29.0.0",
@@ -12054,7 +12072,7 @@ dependencies = [
 [[package]]
 name = "sp-std"
 version = "14.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 
 [[package]]
 name = "sp-std"
@@ -12076,19 +12094,19 @@ dependencies = [
 [[package]]
 name = "sp-storage"
 version = "22.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "impl-serde 0.5.0",
  "parity-scale-codec",
  "ref-cast",
  "serde",
- "sp-debug-derive 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-debug-derive 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6)",
 ]
 
 [[package]]
 name = "sp-timestamp"
 version = "35.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "async-trait",
  "parity-scale-codec",
@@ -12111,7 +12129,7 @@ dependencies = [
 [[package]]
 name = "sp-tracing"
 version = "17.0.1"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "parity-scale-codec",
  "tracing",
@@ -12122,7 +12140,7 @@ dependencies = [
 [[package]]
 name = "sp-transaction-pool"
 version = "35.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "sp-api",
  "sp-runtime",
@@ -12131,7 +12149,7 @@ dependencies = [
 [[package]]
 name = "sp-transaction-storage-proof"
 version = "35.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "async-trait",
  "parity-scale-codec",
@@ -12145,7 +12163,7 @@ dependencies = [
 [[package]]
 name = "sp-trie"
 version = "38.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "ahash 0.8.11",
  "hash-db",
@@ -12167,7 +12185,7 @@ dependencies = [
 [[package]]
 name = "sp-version"
 version = "38.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "impl-serde 0.5.0",
  "parity-scale-codec",
@@ -12176,7 +12194,7 @@ dependencies = [
  "serde",
  "sp-crypto-hashing-proc-macro",
  "sp-runtime",
- "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6)",
  "sp-version-proc-macro",
  "thiserror 1.0.64",
 ]
@@ -12184,7 +12202,7 @@ dependencies = [
 [[package]]
 name = "sp-version-proc-macro"
 version = "15.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "parity-scale-codec",
  "proc-macro-warning 1.0.2",
@@ -12207,7 +12225,7 @@ dependencies = [
 [[package]]
 name = "sp-wasm-interface"
 version = "21.0.1"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "anyhow",
  "impl-trait-for-tuples",
@@ -12219,7 +12237,7 @@ dependencies = [
 [[package]]
 name = "sp-weights"
 version = "31.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "bounded-collections",
  "parity-scale-codec",
@@ -12227,7 +12245,7 @@ dependencies = [
  "serde",
  "smallvec",
  "sp-arithmetic",
- "sp-debug-derive 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-debug-derive 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6)",
 ]
 
 [[package]]
@@ -12407,8 +12425,8 @@ checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
 
 [[package]]
 name = "staging-xcm"
-version = "15.0.3"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+version = "15.1.0"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "array-bytes",
  "bounded-collections",
@@ -12516,7 +12534,7 @@ dependencies = [
 [[package]]
 name = "substrate-bip39"
 version = "0.6.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "hmac 0.12.1",
  "pbkdf2",
@@ -12528,7 +12546,7 @@ dependencies = [
 [[package]]
 name = "substrate-build-script-utils"
 version = "11.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 
 [[package]]
 name = "substrate-fixed"
@@ -12544,12 +12562,12 @@ dependencies = [
 [[package]]
 name = "substrate-frame-rpc-system"
 version = "42.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "docify",
  "frame-system-rpc-runtime-api",
  "futures",
- "jsonrpsee 0.24.7",
+ "jsonrpsee 0.24.9",
  "log",
  "parity-scale-codec",
  "sc-rpc-api",
@@ -12564,7 +12582,7 @@ dependencies = [
 [[package]]
 name = "substrate-prometheus-endpoint"
 version = "0.17.1"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "http-body-util",
  "hyper 1.5.0",
@@ -12578,7 +12596,7 @@ dependencies = [
 [[package]]
 name = "substrate-wasm-builder"
 version = "25.0.1"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "array-bytes",
  "build-helper",
@@ -12623,7 +12641,7 @@ dependencies = [
 name = "subtensor-custom-rpc"
 version = "0.0.2"
 dependencies = [
- "jsonrpsee 0.24.7",
+ "jsonrpsee 0.24.9",
  "pallet-subtensor",
  "parity-scale-codec",
  "serde",
@@ -12686,7 +12704,7 @@ dependencies = [
  "precompile-utils",
  "sp-core",
  "sp-runtime",
- "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5)",
+ "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6)",
  "subtensor-runtime-common",
 ]
 
@@ -13405,7 +13423,7 @@ dependencies = [
 [[package]]
 name = "tracing-gum"
 version = "17.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "coarsetime",
  "polkadot-primitives",
@@ -13416,7 +13434,7 @@ dependencies = [
 [[package]]
 name = "tracing-gum-proc-macro"
 version = "5.0.0"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "expander",
  "proc-macro-crate 3.2.0",
@@ -14663,7 +14681,7 @@ dependencies = [
 [[package]]
 name = "xcm-procedural"
 version = "11.0.1"
-source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-5#d77b878daef34cf840eb34657d48f644ed9ca197"
+source = "git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2412-6#bbc435c7667d3283ba280a8fec44676357392753"
 dependencies = [
  "Inflector",
  "proc-macro2",
diff --git a/Cargo.toml b/Cargo.toml
index 51228c94a6..3cb6010d49 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -67,7 +67,7 @@ enumflags2 = "0.7.9"
 futures = "0.3.30"
 hex = { version = "0.4", default-features = false }
 hex-literal = "0.4.1"
-jsonrpsee = { version = "0.24.4", default-features = false }
+jsonrpsee = { version = "0.24.9", default-features = false }
 libsecp256k1 = { version = "0.7.2", default-features = false }
 log = { version = "0.4.21", default-features = false }
 memmap2 = "0.9.4"
@@ -100,128 +100,128 @@ approx = "0.5"
 
 subtensor-macros = { path = "support/macros" }
 
-frame-benchmarking = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
-frame-benchmarking-cli = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
-frame-executive = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
-frame-metadata-hash-extension = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
-frame-support = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
-frame-system = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
-frame-system-benchmarking = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
-frame-system-rpc-runtime-api = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
-frame-try-runtime = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+frame-benchmarking = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
+frame-benchmarking-cli = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6" }
+frame-executive = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
+frame-metadata-hash-extension = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
+frame-support = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
+frame-system = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
+frame-system-benchmarking = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
+frame-system-rpc-runtime-api = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
+frame-try-runtime = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
 
-pallet-aura = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
-pallet-balances = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
-pallet-grandpa = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
-pallet-insecure-randomness-collective-flip = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
-pallet-membership = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
-pallet-multisig = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
-pallet-preimage = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+pallet-aura = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
+pallet-balances = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
+pallet-grandpa = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
+pallet-insecure-randomness-collective-flip = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
+pallet-membership = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
+pallet-multisig = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
+pallet-preimage = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
 pallet-proxy = { path = "pallets/proxy", default-features = false }
-pallet-safe-mode = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
-pallet-scheduler = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
-pallet-sudo = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
-pallet-timestamp = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
-pallet-transaction-payment = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
-pallet-transaction-payment-rpc = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
-pallet-transaction-payment-rpc-runtime-api = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+pallet-safe-mode = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
+pallet-scheduler = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
+pallet-sudo = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
+pallet-timestamp = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
+pallet-transaction-payment = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
+pallet-transaction-payment-rpc = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6" }
+pallet-transaction-payment-rpc-runtime-api = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
 pallet-utility = { path = "pallets/utility", default-features = false }
-pallet-root-testing = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+pallet-root-testing = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
 
-sc-basic-authorship = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
-sc-cli = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
-sc-client-api = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
-sc-consensus = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
-sc-consensus-aura = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
-sc-consensus-grandpa = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
-sc-consensus-grandpa-rpc = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
-sc-chain-spec-derive = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
-sc-chain-spec = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
-sc-consensus-slots = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
-sc-executor = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
-sc-keystore = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
-sc-network = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
-sc-offchain = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
-sc-rpc = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
-sc-rpc-api = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
-sc-service = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
-sc-telemetry = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
-sc-transaction-pool = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
-sc-transaction-pool-api = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
+sc-basic-authorship = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6" }
+sc-cli = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6" }
+sc-client-api = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6" }
+sc-consensus = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6" }
+sc-consensus-aura = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6" }
+sc-consensus-grandpa = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6" }
+sc-consensus-grandpa-rpc = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6" }
+sc-chain-spec-derive = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6" }
+sc-chain-spec = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6" }
+sc-consensus-slots = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6" }
+sc-executor = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6" }
+sc-keystore = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6" }
+sc-network = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6" }
+sc-offchain = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6" }
+sc-rpc = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6" }
+sc-rpc-api = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6" }
+sc-service = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6" }
+sc-telemetry = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6" }
+sc-transaction-pool = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6" }
+sc-transaction-pool-api = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6" }
 
-sp-api = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
-sp-block-builder = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
-sp-blockchain = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
-sp-consensus = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
-sp-consensus-aura = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
-sp-consensus-grandpa = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
-sp-genesis-builder = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
-sp-core = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
-sp-inherents = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
-sp-io = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
-sp-keyring = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
-sp-offchain = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
-sp-rpc = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
-sp-runtime = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
-sp-session = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
-sp-std = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
-sp-storage = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
-sp-timestamp = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
-sp-tracing = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
-sp-transaction-pool = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
-sp-version = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
-sp-weights = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+sp-api = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
+sp-block-builder = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
+sp-blockchain = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
+sp-consensus = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6" }
+sp-consensus-aura = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
+sp-consensus-grandpa = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
+sp-genesis-builder = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
+sp-core = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
+sp-inherents = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
+sp-io = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
+sp-keyring = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
+sp-offchain = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
+sp-rpc = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
+sp-runtime = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
+sp-session = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
+sp-std = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
+sp-storage = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
+sp-timestamp = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6" }
+sp-tracing = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
+sp-transaction-pool = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
+sp-version = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
+sp-weights = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
 
-substrate-build-script-utils = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
+substrate-build-script-utils = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6" }
 substrate-fixed = { git = "https://github.com/opentensor/substrate-fixed.git", tag = "v0.5.9" }
-substrate-frame-rpc-system = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
-substrate-wasm-builder = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5" }
+substrate-frame-rpc-system = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6" }
+substrate-wasm-builder = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6" }
 
-sc-consensus-manual-seal = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
-sc-network-sync = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
-substrate-prometheus-endpoint = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+sc-consensus-manual-seal = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
+sc-network-sync = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
+substrate-prometheus-endpoint = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
 
 # Frontier
-fp-evm = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
-fp-rpc = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
-fp-self-contained = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false, features = [
+fp-evm = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
+fp-rpc = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
+fp-self-contained = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false, features = [
 	"serde",
 ] }
-fp-account = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
-fc-storage = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
-fc-db = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
-fc-consensus = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
-fp-consensus = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
-fp-dynamic-fee = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
-fc-api = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
-fc-rpc = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false, features = [
+fp-account = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
+fc-storage = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
+fc-db = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
+fc-consensus = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
+fp-consensus = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
+fp-dynamic-fee = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
+fc-api = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
+fc-rpc = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false, features = [
 	"rpc-binary-search-estimate",
 ] }
-fc-rpc-core = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
-fc-aura = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
-fc-mapping-sync = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
-precompile-utils = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
+fc-rpc-core = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
+fc-aura = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
+fc-mapping-sync = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
+precompile-utils = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
 
 # Frontier FRAME
-pallet-base-fee = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
-pallet-dynamic-fee = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
-pallet-ethereum = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
-pallet-evm = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
-pallet-evm-chain-id = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
-pallet-evm-precompile-modexp = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
-pallet-evm-precompile-sha3fips = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
-pallet-evm-precompile-simple = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
-pallet-hotfix-sufficients = { git = "https://github.com/opentensor/frontier", rev = "b0d0c2fe2e", default-features = false }
+pallet-base-fee = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
+pallet-dynamic-fee = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
+pallet-ethereum = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
+pallet-evm = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
+pallet-evm-chain-id = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
+pallet-evm-precompile-modexp = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
+pallet-evm-precompile-sha3fips = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
+pallet-evm-precompile-simple = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
+pallet-hotfix-sufficients = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
 
 #DRAND
 pallet-drand = { path = "pallets/drand", default-features = false }
-sp-crypto-ec-utils = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", features = [
+sp-crypto-ec-utils = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", features = [
 	"bls12-381",
 ] }
 getrandom = { version = "0.2.15", features = [
 	"custom",
 ], default-features = false }
-sp-keystore = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-5", default-features = false }
+sp-keystore = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
 w3f-bls = { version = "=0.1.3", default-features = false }
 ark-crypto-primitives = { version = "0.4.0", default-features = false, features = [
 	"r1cs",

From 7d634e6546c0eb339b49d8f43c5bfa023f7603e1 Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Fri, 6 Jun 2025 12:17:51 +0200
Subject: [PATCH 249/418] fix transaction pool from frontier types

---
 node/src/ethereum.rs | 108 ++++++++++++++++++++++++++++---------------
 node/src/rpc.rs      |  26 ++++++-----
 node/src/service.rs  |  34 ++++++++------
 3 files changed, 107 insertions(+), 61 deletions(-)

diff --git a/node/src/ethereum.rs b/node/src/ethereum.rs
index c708efd714..9179f30598 100644
--- a/node/src/ethereum.rs
+++ b/node/src/ethereum.rs
@@ -17,10 +17,9 @@ use sc_client_api::client::BlockchainEvents;
 use sc_network_sync::SyncingService;
 use sc_rpc::SubscriptionTaskExecutor;
 use sc_service::{Configuration, TaskManager, error::Error as ServiceError};
-use sc_transaction_pool::ChainApi;
 use sc_transaction_pool_api::TransactionPool;
 use sp_inherents::CreateInherentDataProviders;
-use sp_runtime::traits::Block as BlockT;
+use sp_runtime::{OpaqueExtrinsic, traits::BlakeTwo256, traits::Block as BlockT};
 use std::path::PathBuf;
 use std::time::Duration;
 use std::{
@@ -196,13 +195,18 @@ pub async fn spawn_frontier_tasks(
     );
 }
 
-fn extend_rpc_aet_api<P, A, CT, CIDP, EC>(
+fn extend_rpc_aet_api<P, CT, CIDP, EC>(
     io: &mut RpcModule<()>,
-    deps: &EthDeps<P, A, CT, CIDP>,
+    deps: &EthDeps<P, CT, CIDP>,
 ) -> Result<(), Box<dyn std::error::Error + Send + Sync>>
 where
-    P: TransactionPool<Block = Block> + 'static,
-    A: ChainApi<Block = Block> + 'static,
+    P: TransactionPool<
+            Block = Block,
+            Hash = <sp_runtime::generic::Block<
+                sp_runtime::generic::Header<u32, BlakeTwo256>,
+                OpaqueExtrinsic,
+            > as BlockT>::Hash,
+        > + 'static,
     CT: ConvertTransaction<<Block as BlockT>::Extrinsic> + Send + Sync + Clone + 'static,
     CIDP: CreateInherentDataProviders<Block, ()> + Send + Clone + 'static,
     EC: EthConfig<Block, FullClient>,
@@ -213,7 +217,7 @@ where
     }
 
     io.merge(
-        Eth::<Block, FullClient, P, CT, FullBackend, A, CIDP, EC>::new(
+        Eth::<Block, FullClient, P, CT, FullBackend, CIDP, EC>::new(
             deps.client.clone(),
             deps.pool.clone(),
             deps.graph.clone(),
@@ -239,13 +243,18 @@ where
     Ok(())
 }
 
-fn extend_rpc_eth_filter<P, A, CT, CIDP>(
+fn extend_rpc_eth_filter<P, CT, CIDP>(
     io: &mut RpcModule<()>,
-    deps: &EthDeps<P, A, CT, CIDP>,
+    deps: &EthDeps<P, CT, CIDP>,
 ) -> Result<(), Box<dyn std::error::Error + Send + Sync>>
 where
-    P: TransactionPool<Block = Block> + 'static,
-    A: ChainApi<Block = Block> + 'static,
+    P: TransactionPool<
+            Block = Block,
+            Hash = <sp_runtime::generic::Block<
+                sp_runtime::generic::Header<u32, BlakeTwo256>,
+                OpaqueExtrinsic,
+            > as BlockT>::Hash,
+        > + 'static,
     CT: ConvertTransaction<<Block as BlockT>::Extrinsic> + Send + Sync + Clone + 'static,
     CIDP: CreateInherentDataProviders<Block, ()> + Send + Clone + 'static,
 {
@@ -267,9 +276,9 @@ where
 }
 
 // Function for EthPubSub merge
-fn extend_rpc_eth_pubsub<P, A, CT, CIDP>(
+fn extend_rpc_eth_pubsub<P, CT, CIDP>(
     io: &mut RpcModule<()>,
-    deps: &EthDeps<P, A, CT, CIDP>,
+    deps: &EthDeps<P, CT, CIDP>,
     subscription_task_executor: SubscriptionTaskExecutor,
     pubsub_notification_sinks: Arc<
         fc_mapping_sync::EthereumBlockNotificationSinks<
@@ -278,8 +287,13 @@ fn extend_rpc_eth_pubsub<P, A, CT, CIDP>(
     >,
 ) -> Result<(), Box<dyn std::error::Error + Send + Sync>>
 where
-    P: TransactionPool<Block = Block> + 'static,
-    A: ChainApi<Block = Block> + 'static,
+    P: TransactionPool<
+            Block = Block,
+            Hash = <sp_runtime::generic::Block<
+                sp_runtime::generic::Header<u32, BlakeTwo256>,
+                OpaqueExtrinsic,
+            > as BlockT>::Hash,
+        > + 'static,
     CT: ConvertTransaction<<Block as BlockT>::Extrinsic> + Send + Sync + 'static,
     CIDP: CreateInherentDataProviders<Block, ()> + Send + 'static,
 {
@@ -297,13 +311,18 @@ where
     Ok(())
 }
 
-fn extend_rpc_net<P, A, CT, CIDP>(
+fn extend_rpc_net<P, CT, CIDP>(
     io: &mut RpcModule<()>,
-    deps: &EthDeps<P, A, CT, CIDP>,
+    deps: &EthDeps<P, CT, CIDP>,
 ) -> Result<(), Box<dyn std::error::Error + Send + Sync>>
 where
-    P: TransactionPool<Block = Block> + 'static,
-    A: ChainApi<Block = Block> + 'static,
+    P: TransactionPool<
+            Block = Block,
+            Hash = <sp_runtime::generic::Block<
+                sp_runtime::generic::Header<u32, BlakeTwo256>,
+                OpaqueExtrinsic,
+            > as BlockT>::Hash,
+        > + 'static,
     CT: ConvertTransaction<<Block as BlockT>::Extrinsic> + Send + Sync + 'static,
     CIDP: CreateInherentDataProviders<Block, ()> + Send + 'static,
 {
@@ -318,13 +337,18 @@ where
     Ok(())
 }
 
-fn extend_rpc_web3<P, A, CT, CIDP>(
+fn extend_rpc_web3<P, CT, CIDP>(
     io: &mut RpcModule<()>,
-    deps: &EthDeps<P, A, CT, CIDP>,
+    deps: &EthDeps<P, CT, CIDP>,
 ) -> Result<(), Box<dyn std::error::Error + Send + Sync>>
 where
-    P: TransactionPool<Block = Block> + 'static,
-    A: ChainApi<Block = Block> + 'static,
+    P: TransactionPool<
+            Block = Block,
+            Hash = <sp_runtime::generic::Block<
+                sp_runtime::generic::Header<u32, BlakeTwo256>,
+                OpaqueExtrinsic,
+            > as BlockT>::Hash,
+        > + 'static,
     CT: ConvertTransaction<<Block as BlockT>::Extrinsic> + Send + Sync + 'static,
     CIDP: CreateInherentDataProviders<Block, ()> + Send + 'static,
 {
@@ -332,13 +356,18 @@ where
     Ok(())
 }
 
-fn extend_rpc_debug<P, A, CT, CIDP>(
+fn extend_rpc_debug<P, CT, CIDP>(
     io: &mut RpcModule<()>,
-    deps: &EthDeps<P, A, CT, CIDP>,
+    deps: &EthDeps<P, CT, CIDP>,
 ) -> Result<(), Box<dyn std::error::Error + Send + Sync>>
 where
-    P: TransactionPool<Block = Block> + 'static,
-    A: ChainApi<Block = Block> + 'static,
+    P: TransactionPool<
+            Block = Block,
+            Hash = <sp_runtime::generic::Block<
+                sp_runtime::generic::Header<u32, BlakeTwo256>,
+                OpaqueExtrinsic,
+            > as BlockT>::Hash,
+        > + 'static,
     CT: ConvertTransaction<<Block as BlockT>::Extrinsic> + Send + Sync + 'static,
     CIDP: CreateInherentDataProviders<Block, ()> + Send + 'static,
 {
@@ -355,9 +384,9 @@ where
 }
 
 /// Extend RpcModule with Eth RPCs
-pub fn create_eth<P, A, CT, CIDP, EC>(
+pub fn create_eth<P, CT, CIDP, EC>(
     mut io: RpcModule<()>,
-    deps: EthDeps<P, A, CT, CIDP>,
+    deps: EthDeps<P, CT, CIDP>,
     subscription_task_executor: SubscriptionTaskExecutor,
     pubsub_notification_sinks: Arc<
         fc_mapping_sync::EthereumBlockNotificationSinks<
@@ -366,23 +395,28 @@ pub fn create_eth<P, A, CT, CIDP, EC>(
     >,
 ) -> Result<RpcModule<()>, Box<dyn std::error::Error + Send + Sync>>
 where
-    P: TransactionPool<Block = Block> + 'static,
-    A: ChainApi<Block = Block> + 'static,
+    P: TransactionPool<
+            Block = Block,
+            Hash = <sp_runtime::generic::Block<
+                sp_runtime::generic::Header<u32, BlakeTwo256>,
+                OpaqueExtrinsic,
+            > as BlockT>::Hash,
+        > + 'static,
     CT: ConvertTransaction<<Block as BlockT>::Extrinsic> + Send + Sync + Clone + 'static,
     CIDP: CreateInherentDataProviders<Block, ()> + Send + Clone + 'static,
     EC: EthConfig<Block, FullClient>,
 {
-    extend_rpc_aet_api::<P, A, CT, CIDP, EC>(&mut io, &deps)?;
-    extend_rpc_eth_filter::<P, A, CT, CIDP>(&mut io, &deps)?;
-    extend_rpc_eth_pubsub::<P, A, CT, CIDP>(
+    extend_rpc_aet_api::<P, CT, CIDP, EC>(&mut io, &deps)?;
+    extend_rpc_eth_filter::<P, CT, CIDP>(&mut io, &deps)?;
+    extend_rpc_eth_pubsub::<P, CT, CIDP>(
         &mut io,
         &deps,
         subscription_task_executor,
         pubsub_notification_sinks,
     )?;
-    extend_rpc_net::<P, A, CT, CIDP>(&mut io, &deps)?;
-    extend_rpc_web3::<P, A, CT, CIDP>(&mut io, &deps)?;
-    extend_rpc_debug::<P, A, CT, CIDP>(&mut io, &deps)?;
+    extend_rpc_net::<P, CT, CIDP>(&mut io, &deps)?;
+    extend_rpc_web3::<P, CT, CIDP>(&mut io, &deps)?;
+    extend_rpc_debug::<P, CT, CIDP>(&mut io, &deps)?;
 
     Ok(io)
 }
diff --git a/node/src/rpc.rs b/node/src/rpc.rs
index 0d4cd355de..5f184ca7e0 100644
--- a/node/src/rpc.rs
+++ b/node/src/rpc.rs
@@ -18,11 +18,10 @@ use sc_consensus_manual_seal::EngineCommand;
 use sc_network::service::traits::NetworkService;
 use sc_network_sync::SyncingService;
 use sc_rpc::SubscriptionTaskExecutor;
-use sc_transaction_pool::{ChainApi, Pool};
 use sc_transaction_pool_api::TransactionPool;
 use sp_core::H256;
 use sp_inherents::CreateInherentDataProviders;
-use sp_runtime::traits::Block as BlockT;
+use sp_runtime::{OpaqueExtrinsic, traits::BlakeTwo256, traits::Block as BlockT};
 use subtensor_runtime_common::Hash;
 
 use crate::{
@@ -31,13 +30,13 @@ use crate::{
 };
 
 /// Extra dependencies for Ethereum compatibility.
-pub struct EthDeps<P, A: ChainApi, CT, CIDP> {
+pub struct EthDeps<P, CT, CIDP> {
     /// The client instance to use.
     pub client: Arc<FullClient>,
     /// Transaction pool instance.
     pub pool: Arc<P>,
     /// Graph pool instance.
-    pub graph: Arc<Pool<A>>,
+    pub graph: Arc<P>,
     /// Ethereum transaction converter.
     pub converter: Option<CT>,
     /// The Node authority flag
@@ -84,7 +83,7 @@ impl fc_rpc::EthConfig<Block, FullClient> for DefaultEthConfig {
 }
 
 /// Full client dependencies.
-pub struct FullDeps<P, A: ChainApi, CT, CIDP> {
+pub struct FullDeps<P, CT, CIDP> {
     /// The client instance to use.
     pub client: Arc<FullClient>,
     /// Transaction pool instance.
@@ -92,12 +91,12 @@ pub struct FullDeps<P, A: ChainApi, CT, CIDP> {
     /// Manual seal command sink
     pub command_sink: Option<mpsc::Sender<EngineCommand<Hash>>>,
     /// Ethereum-compatibility specific dependencies.
-    pub eth: EthDeps<P, A, CT, CIDP>,
+    pub eth: EthDeps<P, CT, CIDP>,
 }
 
 /// Instantiate all full RPC extensions.
-pub fn create_full<P, A, CT, CIDP>(
-    deps: FullDeps<P, A, CT, CIDP>,
+pub fn create_full<P, CT, CIDP>(
+    deps: FullDeps<P, CT, CIDP>,
     subscription_task_executor: SubscriptionTaskExecutor,
     pubsub_notification_sinks: Arc<
         fc_mapping_sync::EthereumBlockNotificationSinks<
@@ -106,8 +105,13 @@ pub fn create_full<P, A, CT, CIDP>(
     >,
 ) -> Result<RpcModule<()>, Box<dyn std::error::Error + Send + Sync>>
 where
-    P: TransactionPool<Block = Block> + 'static,
-    A: ChainApi<Block = Block> + 'static,
+    P: TransactionPool<
+            Block = Block,
+            Hash = <sp_runtime::generic::Block<
+                sp_runtime::generic::Header<u32, BlakeTwo256>,
+                OpaqueExtrinsic,
+            > as BlockT>::Hash,
+        > + 'static,
     CIDP: CreateInherentDataProviders<Block, ()> + Send + Clone + 'static,
     CT: fp_rpc::ConvertTransaction<<Block as BlockT>::Extrinsic> + Send + Sync + Clone + 'static,
 {
@@ -144,7 +148,7 @@ where
     }
 
     // Ethereum compatibility RPCs
-    let module = create_eth::<_, _, _, _, DefaultEthConfig>(
+    let module = create_eth::<_, _, _, DefaultEthConfig>(
         module,
         eth,
         subscription_task_executor,
diff --git a/node/src/service.rs b/node/src/service.rs
index 4ce041b0a4..d729c0ac6c 100644
--- a/node/src/service.rs
+++ b/node/src/service.rs
@@ -13,7 +13,7 @@ use sc_consensus_slots::BackoffAuthoringOnFinalizedHeadLagging;
 use sc_network_sync::strategy::warp::{WarpSyncConfig, WarpSyncProvider};
 use sc_service::{Configuration, PartialComponents, TaskManager, error::Error as ServiceError};
 use sc_telemetry::{Telemetry, TelemetryHandle, TelemetryWorker, log};
-use sc_transaction_pool::FullPool;
+use sc_transaction_pool::TransactionPoolHandle;
 use sc_transaction_pool_api::OffchainTransactionPoolFactory;
 use sp_api::ProvideRuntimeApi;
 use sp_block_builder::BlockBuilder as BlockBuilderApi;
@@ -51,7 +51,7 @@ pub fn new_partial<BIQ>(
         FullBackend,
         FullSelectChain,
         BasicQueue<Block>,
-        FullPool<Block, FullClient>,
+        TransactionPoolHandle<Block, FullClient>,
         (
             Option<Telemetry>,
             BoxBlockImport<Block>,
@@ -148,12 +148,15 @@ where
         grandpa_block_import,
     )?;
 
-    let transaction_pool = sc_transaction_pool::BasicPool::new_full(
-        config.transaction_pool.clone(),
-        config.role.is_authority().into(),
-        config.prometheus_registry(),
-        task_manager.spawn_essential_handle(),
-        client.clone(),
+    let transaction_pool = Arc::from(
+        sc_transaction_pool::Builder::new(
+            task_manager.spawn_essential_handle(),
+            client.clone(),
+            config.role.is_authority().into(),
+        )
+        .with_options(config.transaction_pool.clone())
+        .with_prometheus(config.prometheus_registry())
+        .build(),
     );
 
     Ok(PartialComponents {
@@ -461,7 +464,7 @@ where
                 network_provider: Arc::new(network.clone()),
                 enable_http_requests: true,
                 custom_extensions: |_| vec![],
-            })
+            })?
             .run(client.clone(), task_manager.spawn_handle())
             .boxed(),
         );
@@ -536,7 +539,7 @@ where
             let eth_deps = crate::rpc::EthDeps {
                 client: client.clone(),
                 pool: pool.clone(),
-                graph: pool.pool().clone(),
+                graph: pool.clone(),
                 converter: Some(TransactionConverter::<Block>::default()),
                 is_authority,
                 enable_dev_signer,
@@ -726,12 +729,17 @@ pub async fn build_full(
     sealing: Option<Sealing>,
 ) -> Result<TaskManager, ServiceError> {
     match config.network.network_backend {
-        sc_network::config::NetworkBackendType::Libp2p => {
+        Some(sc_network::config::NetworkBackendType::Libp2p) => {
             new_full::<sc_network::NetworkWorker<_, _>>(config, eth_config, sealing).await
         }
-        sc_network::config::NetworkBackendType::Litep2p => {
+        Some(sc_network::config::NetworkBackendType::Litep2p) => {
             new_full::<sc_network::NetworkWorker<_, _>>(config, eth_config, sealing).await
         }
+        _ => {
+            return Err(ServiceError::Other(
+                "Network backend not supported".to_string(),
+            ));
+        }
     }
 }
 
@@ -764,7 +772,7 @@ pub fn new_chain_ops(
 fn run_manual_seal_authorship(
     sealing: Sealing,
     client: Arc<FullClient>,
-    transaction_pool: Arc<FullPool<Block, FullClient>>,
+    transaction_pool: Arc<TransactionPoolHandle<Block, FullClient>>,
     select_chain: FullSelectChain,
     block_import: BoxBlockImport<Block>,
     task_manager: &TaskManager,

From ca0dd6f705afd099035927c4b6690a613440e80c Mon Sep 17 00:00:00 2001
From: Shamil Gadelshin <shamilgadelshin@gmail.com>
Date: Wed, 21 May 2025 16:22:48 +0400
Subject: [PATCH 250/418] Remove obsolete code

---
 pallets/subtensor/src/benchmarks.rs           |  168 --
 pallets/subtensor/src/lib.rs                  |  190 --
 pallets/subtensor/src/macros/dispatches.rs    |  284 ---
 pallets/subtensor/src/macros/events.rs        |   24 -
 pallets/subtensor/src/staking/add_stake.rs    |  148 --
 pallets/subtensor/src/staking/remove_stake.rs |  222 ---
 pallets/subtensor/src/staking/stake_utils.rs  |  364 ----
 pallets/subtensor/src/tests/staking.rs        | 1618 -----------------
 8 files changed, 3018 deletions(-)

diff --git a/pallets/subtensor/src/benchmarks.rs b/pallets/subtensor/src/benchmarks.rs
index eaad64199e..1b61addc91 100644
--- a/pallets/subtensor/src/benchmarks.rs
+++ b/pallets/subtensor/src/benchmarks.rs
@@ -156,174 +156,6 @@ mod pallet_benchmarks {
         );
     }
 
-    // #[benchmark]
-    // fn add_stake_aggregate() {
-    //     let netuid: u16 = 1;
-    //     let tempo: u16 = 1;
-    //
-    //     Subtensor::<T>::init_new_network(netuid, tempo);
-    //     SubtokenEnabled::<T>::insert(netuid, true);
-    //     Subtensor::<T>::set_burn(netuid, 1);
-    //     Subtensor::<T>::set_network_registration_allowed(netuid, true);
-    //     Subtensor::<T>::set_max_allowed_uids(netuid, 4096);
-    //
-    //     let seed: u32 = 1;
-    //     let coldkey: T::AccountId = account("Test", 0, seed);
-    //     let hotkey: T::AccountId = account("Alice", 0, seed);
-    //     let total_stake: u64 = 1_000_000_000;
-    //     let amount: u64 = 600_000;
-    //
-    //     Subtensor::<T>::add_balance_to_coldkey_account(&coldkey, total_stake);
-    //     assert_ok!(Subtensor::<T>::do_burned_registration(
-    //         RawOrigin::Signed(coldkey.clone()).into(),
-    //         netuid,
-    //         hotkey.clone()
-    //     ));
-    //
-    //     #[extrinsic_call]
-    //     _(
-    //         RawOrigin::Signed(coldkey.clone()),
-    //         hotkey.clone(),
-    //         netuid,
-    //         amount,
-    //     );
-    // }
-    //
-    // #[benchmark]
-    // fn remove_stake_limit_aggregate() {
-    //     let netuid: u16 = 1;
-    //
-    //     Subtensor::<T>::increase_total_stake(1_000_000_000_000);
-    //     Subtensor::<T>::init_new_network(netuid, 1);
-    //     Subtensor::<T>::set_network_registration_allowed(netuid, true);
-    //     SubtokenEnabled::<T>::insert(netuid, true);
-    //     Subtensor::<T>::set_max_allowed_uids(netuid, 4096);
-    //
-    //     let seed: u32 = 1;
-    //     let coldkey: T::AccountId = account("Test", 0, seed);
-    //     let hotkey: T::AccountId = account("Alice", 0, seed);
-    //     Subtensor::<T>::set_burn(netuid, 1);
-    //
-    //     let limit: u64 = 1_000_000_000;
-    //     let tao_reserve: u64 = 150_000_000_000;
-    //     let alpha_in: u64 = 100_000_000_000;
-    //     SubnetTAO::<T>::insert(netuid, tao_reserve);
-    //     SubnetAlphaIn::<T>::insert(netuid, alpha_in);
-    //
-    //     let wallet_bal: u64 = 1_000_000;
-    //     Subtensor::<T>::add_balance_to_coldkey_account(&coldkey, wallet_bal);
-    //
-    //     assert_ok!(Subtensor::<T>::do_burned_registration(
-    //         RawOrigin::Signed(coldkey.clone()).into(),
-    //         netuid,
-    //         hotkey.clone()
-    //     ));
-    //
-    //     Subtensor::<T>::add_balance_to_coldkey_account(&coldkey, 100_000_000_000u64);
-    //     assert_ok!(Subtensor::<T>::add_stake(
-    //         RawOrigin::Signed(coldkey.clone()).into(),
-    //         hotkey.clone(),
-    //         netuid,
-    //         100_000_000_000u64
-    //     ));
-    //
-    //     let amount_unstaked: u64 = 30_000_000_000;
-    //
-    //     #[extrinsic_call]
-    //     _(
-    //         RawOrigin::Signed(coldkey.clone()),
-    //         hotkey.clone(),
-    //         netuid,
-    //         amount_unstaked,
-    //         limit,
-    //         false,
-    //     );
-    // }
-    //
-    // #[benchmark]
-    // fn remove_stake_aggregate() {
-    //     let netuid: u16 = 1;
-    //
-    //     Subtensor::<T>::increase_total_stake(1_000_000_000_000);
-    //     Subtensor::<T>::init_new_network(netuid, 1);
-    //     Subtensor::<T>::set_network_registration_allowed(netuid, true);
-    //     SubtokenEnabled::<T>::insert(netuid, true);
-    //     Subtensor::<T>::set_max_allowed_uids(netuid, 4096);
-    //
-    //     let seed: u32 = 1;
-    //     let coldkey: T::AccountId = account("Test", 0, seed);
-    //     let hotkey: T::AccountId = account("Alice", 0, seed);
-    //     Subtensor::<T>::set_burn(netuid, 1);
-    //
-    //     let wallet_bal: u64 = 1_000_000;
-    //     Subtensor::<T>::add_balance_to_coldkey_account(&coldkey, wallet_bal);
-    //
-    //     assert_ok!(Subtensor::<T>::do_burned_registration(
-    //         RawOrigin::Signed(coldkey.clone()).into(),
-    //         netuid,
-    //         hotkey.clone()
-    //     ));
-    //
-    //     Subtensor::<T>::add_balance_to_coldkey_account(&coldkey, 100_000_000_000u64);
-    //     assert_ok!(Subtensor::<T>::add_stake(
-    //         RawOrigin::Signed(coldkey.clone()).into(),
-    //         hotkey.clone(),
-    //         netuid,
-    //         100_000_000_000u64
-    //     ));
-    //
-    //     let amount_unstaked: u64 = 600_000;
-    //
-    //     #[extrinsic_call]
-    //     _(
-    //         RawOrigin::Signed(coldkey.clone()),
-    //         hotkey.clone(),
-    //         netuid,
-    //         amount_unstaked,
-    //     );
-    // }
-    //
-    // #[benchmark]
-    // fn add_stake_limit_aggregate() {
-    //     let netuid: u16 = 1;
-    //
-    //     Subtensor::<T>::init_new_network(netuid, 1);
-    //     SubtokenEnabled::<T>::insert(netuid, true);
-    //     Subtensor::<T>::set_burn(netuid, 1);
-    //     Subtensor::<T>::set_network_registration_allowed(netuid, true);
-    //     Subtensor::<T>::set_max_allowed_uids(netuid, 4096);
-    //
-    //     let seed: u32 = 1;
-    //     let coldkey: T::AccountId = account("Test", 0, seed);
-    //     let hotkey: T::AccountId = account("Alice", 0, seed);
-    //
-    //     let amount: u64 = 900_000_000_000;
-    //     let limit: u64 = 6_000_000_000;
-    //     let stake_amt: u64 = 440_000_000_000;
-    //     Subtensor::<T>::add_balance_to_coldkey_account(&coldkey, amount);
-    //
-    //     let tao_reserve: u64 = 150_000_000_000;
-    //     let alpha_in: u64 = 100_000_000_000;
-    //     SubnetTAO::<T>::insert(netuid, tao_reserve);
-    //     SubnetAlphaIn::<T>::insert(netuid, alpha_in);
-    //
-    //     assert_ok!(Subtensor::<T>::do_burned_registration(
-    //         RawOrigin::Signed(coldkey.clone()).into(),
-    //         netuid,
-    //         hotkey.clone()
-    //     ));
-    //
-    //     #[extrinsic_call]
-    //     _(
-    //         RawOrigin::Signed(coldkey.clone()),
-    //         hotkey.clone(),
-    //         netuid,
-    //         stake_amt,
-    //         limit,
-    //         false,
-    //     );
-    // }
-
     #[benchmark]
     fn serve_axon() {
         let netuid: u16 = 1;
diff --git a/pallets/subtensor/src/lib.rs b/pallets/subtensor/src/lib.rs
index 3c74adf5d5..ec9d9c7ed9 100644
--- a/pallets/subtensor/src/lib.rs
+++ b/pallets/subtensor/src/lib.rs
@@ -270,79 +270,6 @@ pub mod pallet {
         pub additional: Vec<u8>,
     }
 
-    /// Data structure for stake related jobs.
-    #[derive(Encode, Decode, TypeInfo, Clone, PartialEq, Eq, Debug)]
-    pub enum StakeJob<AccountId> {
-        /// Represents a job for "add_stake" operation
-        AddStake {
-            /// Hotkey account
-            hotkey: AccountId,
-            /// Coldkey account
-            coldkey: AccountId,
-            /// Subnet ID
-            netuid: u16,
-            /// The amount of stake to be added to the hotkey staking account.
-            stake_to_be_added: u64,
-        },
-        /// Represents a job for "remove_stake" operation
-        RemoveStake {
-            /// Hotkey account
-            hotkey: AccountId,
-            /// Coldkey account
-            coldkey: AccountId,
-            /// Subnet ID
-            netuid: u16,
-            /// Alpha value
-            alpha_unstaked: u64,
-        },
-        /// Represents a job for "add_stake_limit" operation
-        AddStakeLimit {
-            /// Coldkey account
-            coldkey: AccountId,
-            /// Hotkey account
-            hotkey: AccountId,
-            /// Subnet ID
-            netuid: u16,
-            /// The amount of stake to be added to the hotkey staking account.
-            stake_to_be_added: u64,
-            /// The limit price expressed in units of RAO per one Alpha.
-            limit_price: u64,
-            /// Allows partial execution of the amount. If set to false, this becomes
-            /// fill or kill type or order.
-            allow_partial: bool,
-        },
-        /// Represents a job for "remove_stake_limit" operation
-        RemoveStakeLimit {
-            /// Coldkey account
-            coldkey: AccountId,
-            /// Hotkey account
-            hotkey: AccountId,
-            /// Subnet ID
-            netuid: u16,
-            /// The amount of stake to be added to the hotkey staking account.
-            alpha_unstaked: u64,
-            /// The limit price
-            limit_price: u64,
-            /// Allows partial execution of the amount. If set to false, this becomes
-            /// fill or kill type or order.
-            allow_partial: bool,
-        },
-        /// Represents a job for "unstake_all" operation
-        UnstakeAll {
-            /// Coldkey account
-            coldkey: AccountId,
-            /// Hotkey account
-            hotkey: AccountId,
-        },
-        /// Represents a job for "unstake_all_alpha" operation
-        UnstakeAllAlpha {
-            /// Coldkey account
-            coldkey: AccountId,
-            /// Hotkey account
-            hotkey: AccountId,
-        },
-    }
-
     /// ============================
     /// ==== Staking + Accounts ====
     /// ============================
@@ -929,17 +856,6 @@ pub mod pallet {
     pub type SenateRequiredStakePercentage<T> =
         StorageValue<_, u64, ValueQuery, DefaultSenateRequiredStakePercentage<T>>;
 
-    #[pallet::storage]
-    pub type StakeJobs<T: Config> = StorageDoubleMap<
-        _,
-        Blake2_128Concat,
-        BlockNumberFor<T>, // first key: current block number
-        Twox64Concat,
-        u64, // second key: unique job ID
-        StakeJob<T::AccountId>,
-        OptionQuery,
-    >;
-
     #[pallet::storage]
     /// --- DMap ( netuid, coldkey ) --> blocknumber | last hotkey swap on network.
     pub type LastHotkeySwapOnNetuid<T: Config> = StorageDoubleMap<
@@ -2207,112 +2123,6 @@ where
                     Self::get_priority_staking(who, hotkey, *amount_unstaked),
                 )
             }
-            // Some(Call::add_stake_aggregate {
-            //     hotkey,
-            //     netuid,
-            //     amount_staked,
-            // }) => {
-            //     if ColdkeySwapScheduled::<T>::contains_key(who) {
-            //         return InvalidTransaction::Custom(
-            //             CustomTransactionError::ColdkeyInSwapSchedule.into(),
-            //         )
-            //         .into();
-            //     }
-            //     // Fully validate the user input
-            //     Self::result_to_validity(
-            //         Pallet::<T>::validate_add_stake(
-            //             who,
-            //             hotkey,
-            //             *netuid,
-            //             *amount_staked,
-            //             *amount_staked,
-            //             false,
-            //         ),
-            //         Self::get_priority_staking(who, hotkey, *amount_staked),
-            //     )
-            // }
-            // Some(Call::add_stake_limit_aggregate {
-            //     hotkey,
-            //     netuid,
-            //     amount_staked,
-            //     limit_price,
-            //     allow_partial,
-            // }) => {
-            //     if ColdkeySwapScheduled::<T>::contains_key(who) {
-            //         return InvalidTransaction::Custom(
-            //             CustomTransactionError::ColdkeyInSwapSchedule.into(),
-            //         )
-            //         .into();
-            //     }
-            //
-            //     // Calculate the maximum amount that can be executed with price limit
-            //     let Ok(max_amount) = Pallet::<T>::get_max_amount_add(*netuid, *limit_price) else {
-            //         return InvalidTransaction::Custom(
-            //             CustomTransactionError::ZeroMaxAmount.into(),
-            //         )
-            //         .into();
-            //     };
-            //
-            //     // Fully validate the user input
-            //     Self::result_to_validity(
-            //         Pallet::<T>::validate_add_stake(
-            //             who,
-            //             hotkey,
-            //             *netuid,
-            //             *amount_staked,
-            //             max_amount,
-            //             *allow_partial,
-            //         ),
-            //         Self::get_priority_staking(who, hotkey, *amount_staked),
-            //     )
-            // }
-            // Some(Call::remove_stake_aggregate {
-            //     hotkey,
-            //     netuid,
-            //     amount_unstaked,
-            // }) => {
-            //     // Fully validate the user input
-            //     Self::result_to_validity(
-            //         Pallet::<T>::validate_remove_stake(
-            //             who,
-            //             hotkey,
-            //             *netuid,
-            //             *amount_unstaked,
-            //             *amount_unstaked,
-            //             false,
-            //         ),
-            //         Self::get_priority_staking(who, hotkey, *amount_unstaked),
-            //     )
-            // }
-            // Some(Call::remove_stake_limit_aggregate {
-            //     hotkey,
-            //     netuid,
-            //     amount_unstaked,
-            //     limit_price,
-            //     allow_partial,
-            // }) => {
-            //     // Calculate the maximum amount that can be executed with price limit
-            //     let Ok(max_amount) = Pallet::<T>::get_max_amount_remove(*netuid, *limit_price)
-            //     else {
-            //         return InvalidTransaction::Custom(
-            //             CustomTransactionError::ZeroMaxAmount.into(),
-            //         )
-            //         .into();
-            //     };
-            //
-            //     // Fully validate the user input
-            //     Self::result_to_validity(
-            //         Pallet::<T>::validate_remove_stake(
-            //             who,
-            //             hotkey,
-            //             *netuid,
-            //             *amount_unstaked,
-            //             max_amount,
-            //             *allow_partial,
-            //         ),
-            //         Self::get_priority_staking(who, hotkey, *amount_unstaked),
-            //     )
-            // }
             Some(Call::unstake_all { hotkey }) => {
                 // Fully validate the user input
                 Self::result_to_validity(
diff --git a/pallets/subtensor/src/macros/dispatches.rs b/pallets/subtensor/src/macros/dispatches.rs
index 434291c45d..1b79721e80 100644
--- a/pallets/subtensor/src/macros/dispatches.rs
+++ b/pallets/subtensor/src/macros/dispatches.rs
@@ -2056,289 +2056,5 @@ mod dispatches {
         ) -> DispatchResult {
             Self::do_burn_alpha(origin, hotkey, amount, netuid)
         }
-
-        // /// --- Adds stake to a hotkey on a subnet with a price limit.
-        // /// This extrinsic allows to specify the limit price for alpha token
-        // /// at which or better (lower) the staking should execute.
-        // ///
-        // /// In case if slippage occurs and the price shall move beyond the limit
-        // /// price, the staking order may execute only partially or not execute
-        // /// at all.
-        // ///
-        // /// The operation will be delayed.
-        // ///
-        // /// # Args:
-        // ///  * 'origin': (<T as frame_system::Config>Origin):
-        // /// 	- The signature of the caller's coldkey.
-        // ///
-        // ///  * 'hotkey' (T::AccountId):
-        // /// 	- The associated hotkey account.
-        // ///
-        // /// * 'netuid' (u16):
-        // ///     - Subnetwork UID
-        // ///
-        // ///  * 'amount_staked' (u64):
-        // /// 	- The amount of stake to be added to the hotkey staking account.
-        // ///
-        // /// # Event:
-        // ///  * StakeAdded;
-        // /// 	- On the successfully adding stake to a global account.
-        // ///
-        // /// # Raises:
-        // ///  * 'NotEnoughBalanceToStake':
-        // /// 	- Not enough balance on the coldkey to add onto the global account.
-        // ///
-        // ///  * 'NonAssociatedColdKey':
-        // /// 	- The calling coldkey is not associated with this hotkey.
-        // ///
-        // ///  * 'BalanceWithdrawalError':
-        // ///  	- Errors stemming from transaction pallet.
-        // ///
-        // #[pallet::call_index(103)]
-        // #[pallet::weight((Weight::from_parts(162_000_000, 5127)
-        // .saturating_add(T::DbWeight::get().reads(15_u64))
-        // .saturating_add(T::DbWeight::get().writes(12_u64)), DispatchClass::Normal, Pays::No))]
-        // pub fn add_stake_aggregate(
-        //     origin: OriginFor<T>,
-        //     hotkey: T::AccountId,
-        //     netuid: u16,
-        //     amount_staked: u64,
-        // ) -> DispatchResult {
-        //     Self::do_add_stake_aggregate(origin, hotkey, netuid, amount_staked)
-        // }
-
-        // /// --- Removes stake from a hotkey on a subnet with a price limit.
-        // /// This extrinsic allows to specify the limit price for alpha token
-        // /// at which or better (higher) the staking should execute.
-        // ///
-        // /// In case if slippage occurs and the price shall move beyond the limit
-        // /// price, the staking order may execute only partially or not execute
-        // /// at all.
-        // ///
-        // /// The operation will be delayed.
-        // ///
-        // /// # Args:
-        // /// * 'origin': (<T as frame_system::Config>Origin):
-        // /// 	- The signature of the caller's coldkey.
-        // ///
-        // /// * 'hotkey' (T::AccountId):
-        // /// 	- The associated hotkey account.
-        // ///
-        // /// * 'netuid' (u16):
-        // ///     - Subnetwork UID
-        // ///
-        // /// * 'amount_unstaked' (u64):
-        // /// 	- The amount of stake to be added to the hotkey staking account.
-        // ///
-        // /// # Event:
-        // /// * StakeRemoved;
-        // /// 	- On the successfully removing stake from the hotkey account.
-        // ///
-        // /// # Raises:
-        // /// * 'NotRegistered':
-        // /// 	- Thrown if the account we are attempting to unstake from is non existent.
-        // ///
-        // /// * 'NonAssociatedColdKey':
-        // /// 	- Thrown if the coldkey does not own the hotkey we are unstaking from.
-        // ///
-        // /// * 'NotEnoughStakeToWithdraw':
-        // /// 	- Thrown if there is not enough stake on the hotkey to withdwraw this amount.
-        // ///
-        // #[pallet::call_index(104)]
-        // #[pallet::weight((Weight::from_parts(213_300_000, 10163)
-        // .saturating_add(T::DbWeight::get().reads(20_u64))
-        // .saturating_add(T::DbWeight::get().writes(12_u64)), DispatchClass::Normal, Pays::No))]
-        // pub fn remove_stake_aggregate(
-        //     origin: OriginFor<T>,
-        //     hotkey: T::AccountId,
-        //     netuid: u16,
-        //     amount_unstaked: u64,
-        // ) -> DispatchResult {
-        //     Self::do_remove_stake_aggregate(origin, hotkey, netuid, amount_unstaked)
-        // }
-
-        // /// --- Adds stake to a hotkey on a subnet with a price limit.
-        // /// This extrinsic allows to specify the limit price for alpha token
-        // /// at which or better (lower) the staking should execute.
-        // ///
-        // /// In case if slippage occurs and the price shall move beyond the limit
-        // /// price, the staking order may execute only partially or not execute
-        // /// at all.
-        // ///
-        // /// The operation will be delayed.
-        // ///
-        // /// # Args:
-        // ///  * 'origin': (<T as frame_system::Config>Origin):
-        // /// 	- The signature of the caller's coldkey.
-        // ///
-        // ///  * 'hotkey' (T::AccountId):
-        // /// 	- The associated hotkey account.
-        // ///
-        // /// * 'netuid' (u16):
-        // ///     - Subnetwork UID
-        // ///
-        // ///  * 'amount_staked' (u64):
-        // /// 	- The amount of stake to be added to the hotkey staking account.
-        // ///
-        // ///  * 'limit_price' (u64):
-        // /// 	- The limit price expressed in units of RAO per one Alpha.
-        // ///
-        // ///  * 'allow_partial' (bool):
-        // /// 	- Allows partial execution of the amount. If set to false, this becomes
-        // ///       fill or kill type or order.
-        // ///
-        // /// # Event:
-        // ///  * StakeAdded;
-        // /// 	- On the successfully adding stake to a global account.
-        // ///
-        // /// # Raises:
-        // ///  * 'NotEnoughBalanceToStake':
-        // /// 	- Not enough balance on the coldkey to add onto the global account.
-        // ///
-        // ///  * 'NonAssociatedColdKey':
-        // /// 	- The calling coldkey is not associated with this hotkey.
-        // ///
-        // ///  * 'BalanceWithdrawalError':
-        // ///  	- Errors stemming from transaction pallet.
-        // ///
-        // #[pallet::call_index(105)]
-        // #[pallet::weight((Weight::from_parts(169_200_000, 5127)
-        // .saturating_add(T::DbWeight::get().reads(14_u64))
-        // .saturating_add(T::DbWeight::get().writes(12_u64)), DispatchClass::Normal, Pays::No))]
-        // pub fn add_stake_limit_aggregate(
-        //     origin: OriginFor<T>,
-        //     hotkey: T::AccountId,
-        //     netuid: u16,
-        //     amount_staked: u64,
-        //     limit_price: u64,
-        //     allow_partial: bool,
-        // ) -> DispatchResult {
-        //     Self::do_add_stake_limit_aggregate(
-        //         origin,
-        //         hotkey,
-        //         netuid,
-        //         amount_staked,
-        //         limit_price,
-        //         allow_partial,
-        //     )
-        // }
-
-        // /// --- Removes stake from a hotkey on a subnet with a price limit.
-        // /// This extrinsic allows to specify the limit price for alpha token
-        // /// at which or better (higher) the staking should execute.
-        // ///
-        // /// In case if slippage occurs and the price shall move beyond the limit
-        // /// price, the staking order may execute only partially or not execute
-        // /// at all.
-        // ///
-        // /// The operation will be delayed.
-        // ///
-        // /// # Args:
-        // /// * 'origin': (<T as frame_system::Config>Origin):
-        // /// 	- The signature of the caller's coldkey.
-        // ///
-        // /// * 'hotkey' (T::AccountId):
-        // /// 	- The associated hotkey account.
-        // ///
-        // /// * 'netuid' (u16):
-        // ///     - Subnetwork UID
-        // ///
-        // /// * 'amount_unstaked' (u64):
-        // /// 	- The amount of stake to be added to the hotkey staking account.
-        // ///
-        // ///  * 'limit_price' (u64):
-        // ///     - The limit price expressed in units of RAO per one Alpha.
-        // ///
-        // ///  * 'allow_partial' (bool):
-        // ///     - Allows partial execution of the amount. If set to false, this becomes
-        // ///       fill or kill type or order.
-        // ///
-        // /// # Event:
-        // /// * StakeRemoved;
-        // /// 	- On the successfully removing stake from the hotkey account.
-        // ///
-        // /// # Raises:
-        // /// * 'NotRegistered':
-        // /// 	- Thrown if the account we are attempting to unstake from is non existent.
-        // ///
-        // /// * 'NonAssociatedColdKey':
-        // /// 	- Thrown if the coldkey does not own the hotkey we are unstaking from.
-        // ///
-        // /// * 'NotEnoughStakeToWithdraw':
-        // /// 	- Thrown if there is not enough stake on the hotkey to withdwraw this amount.
-        // ///
-        // #[pallet::call_index(106)]
-        // #[pallet::weight((Weight::from_parts(211_700_000, 10163)
-        // .saturating_add(T::DbWeight::get().reads(19_u64))
-        // .saturating_add(T::DbWeight::get().writes(12_u64)), DispatchClass::Normal, Pays::No))]
-        // pub fn remove_stake_limit_aggregate(
-        //     origin: OriginFor<T>,
-        //     hotkey: T::AccountId,
-        //     netuid: u16,
-        //     amount_unstaked: u64,
-        //     limit_price: u64,
-        //     allow_partial: bool,
-        // ) -> DispatchResult {
-        //     Self::do_remove_stake_limit_aggregate(
-        //         origin,
-        //         hotkey,
-        //         netuid,
-        //         amount_unstaked,
-        //         limit_price,
-        //         allow_partial,
-        //     )
-        // }
-
-        // /// ---- The implementation for the extrinsic unstake_all_aggregate: Removes all stake from a hotkey account across all subnets and adds it onto a coldkey.
-        // ///
-        // /// The operation will be delayed.
-        // ///
-        // /// # Args:
-        // /// * `origin` - (<T as frame_system::Config>::Origin):
-        // ///     - The signature of the caller's coldkey.
-        // ///
-        // /// * `hotkey` (T::AccountId):
-        // ///     - The associated hotkey account.
-        // ///
-        // /// # Event:
-        // /// * StakeRemoved;
-        // ///     - On the successfully removing stake from the hotkey account.
-        // ///
-        // /// # Raises:
-        // /// * `NotRegistered`:
-        // ///     - Thrown if the account we are attempting to unstake from is non existent.
-        // ///
-        // /// * `NonAssociatedColdKey`:
-        // ///     - Thrown if the coldkey does not own the hotkey we are unstaking from.
-        // ///
-        // /// * `NotEnoughStakeToWithdraw`:
-        // ///     - Thrown if there is not enough stake on the hotkey to withdraw this amount.
-        // ///
-        // /// * `TxRateLimitExceeded`:
-        // ///     - Thrown if key has hit transaction rate limit
-        // #[pallet::call_index(107)]
-        // #[pallet::weight((Weight::from_parts(3_000_000, 0).saturating_add(T::DbWeight::get().writes(1)), DispatchClass::Operational, Pays::No))]
-        // pub fn unstake_all_aggregate(origin: OriginFor<T>, hotkey: T::AccountId) -> DispatchResult {
-        //     Self::do_unstake_all_aggregate(origin, hotkey)
-        // }
-
-        //     /// ---- The implementation for the extrinsic unstake_all_alpha_aggregate: Removes all stake from a hotkey account across all subnets and adds it onto a coldkey.
-        //     ///
-        //     /// The operation will be delayed.
-        //     ///
-        //     /// # Args:
-        //     /// * `origin` - (<T as frame_system::Config>::Origin):
-        //     ///     - The signature of the caller's coldkey.
-        //     ///
-        //     /// * `hotkey` (T::AccountId):
-        //     ///     - The associated hotkey account.
-        //     #[pallet::call_index(108)]
-        //     #[pallet::weight((Weight::from_parts(3_000_000, 0).saturating_add(T::DbWeight::get().writes(1)), DispatchClass::Operational, Pays::No))]
-        //     pub fn unstake_all_alpha_aggregate(
-        //         origin: OriginFor<T>,
-        //         hotkey: T::AccountId,
-        //     ) -> DispatchResult {
-        //         Self::do_unstake_all_alpha_aggregate(origin, hotkey)
-        //     }
     }
 }
diff --git a/pallets/subtensor/src/macros/events.rs b/pallets/subtensor/src/macros/events.rs
index 81694275f0..e331769fca 100644
--- a/pallets/subtensor/src/macros/events.rs
+++ b/pallets/subtensor/src/macros/events.rs
@@ -17,30 +17,6 @@ mod events {
         StakeAdded(T::AccountId, T::AccountId, u64, u64, u16, u64),
         /// stake has been removed from the hotkey staking account onto the coldkey account.
         StakeRemoved(T::AccountId, T::AccountId, u64, u64, u16, u64),
-        /// stake has been transferred from the coldkey account onto the hotkey staking account (at the end of the block)
-        AggregatedStakeAdded(T::AccountId, T::AccountId, u16, u64),
-        /// adding aggregated stake has failed
-        FailedToAddAggregatedStake(T::AccountId, T::AccountId, u16, u64),
-        /// limited stake has been transferred from the coldkey account onto the hotkey staking account (at the end of the block)
-        AggregatedLimitedStakeAdded(T::AccountId, T::AccountId, u16, u64, u64, bool),
-        /// adding limited aggregated stake has failed
-        FailedToAddAggregatedLimitedStake(T::AccountId, T::AccountId, u16, u64, u64, bool),
-        /// stake has been removed from the hotkey staking account into the coldkey account (at the end of the block).
-        AggregatedStakeRemoved(T::AccountId, T::AccountId, u16, u64),
-        /// removing aggregated stake has failed
-        FailedToRemoveAggregatedStake(T::AccountId, T::AccountId, u16, u64),
-        /// aggregated limited stake has been removed from the hotkey staking account into the coldkey account (at the end of the block).
-        AggregatedLimitedStakeRemoved(T::AccountId, T::AccountId, u16, u64, u64, bool),
-        /// removing limited aggregated stake has failed
-        FailedToRemoveAggregatedLimitedStake(T::AccountId, T::AccountId, u16, u64, u64, bool),
-        ///  aggregated unstake_all operation has succeeded
-        AggregatedUnstakeAllSucceeded(T::AccountId, T::AccountId),
-        /// aggregated unstake_all operation has failed
-        AggregatedUnstakeAllFailed(T::AccountId, T::AccountId),
-        ///  aggregated unstake_all_alpha operation has succeeded
-        AggregatedUnstakeAllAlphaSucceeded(T::AccountId, T::AccountId),
-        /// aggregated unstake_all_alpha operation has failed
-        AggregatedUnstakeAllAlphaFailed(T::AccountId, T::AccountId),
         /// stake has been moved from origin (hotkey, subnet ID) to destination (hotkey, subnet ID) of this amount (in TAO).
         StakeMoved(T::AccountId, T::AccountId, u16, T::AccountId, u16, u64),
         /// a caller successfully sets their weights on a subnetwork.
diff --git a/pallets/subtensor/src/staking/add_stake.rs b/pallets/subtensor/src/staking/add_stake.rs
index 8886806cd9..258cd40b8b 100644
--- a/pallets/subtensor/src/staking/add_stake.rs
+++ b/pallets/subtensor/src/staking/add_stake.rs
@@ -81,154 +81,6 @@ impl<T: Config> Pallet<T> {
         Ok(())
     }
 
-    /// ---- The implementation for the extrinsic add_stake_aggregate: Adds stake to a hotkey account.
-    /// The operation will be delayed until the end of the block.
-    /// # Args:
-    /// * 'origin': (<T as frame_system::Config>RuntimeOrigin):
-    ///     -  The signature of the caller's coldkey.
-    ///
-    /// * 'hotkey' (T::AccountId):
-    ///     -  The associated hotkey account.
-    ///
-    /// * 'netuid' (u16):
-    ///     - Subnetwork UID
-    ///
-    /// * 'stake_to_be_added' (u64):
-    ///     -  The amount of stake to be added to the hotkey staking account.
-    ///
-    /// # Event:
-    /// * StakeAdded;
-    ///     -  On the successfully adding stake to a global account.
-    ///
-    /// # Raises:
-    /// * 'NotEnoughBalanceToStake':
-    ///     -  Not enough balance on the coldkey to add onto the global account.
-    ///
-    /// * 'NonAssociatedColdKey':
-    ///     -  The calling coldkey is not associated with this hotkey.
-    ///
-    /// * 'BalanceWithdrawalError':
-    ///     -  Errors stemming from transaction pallet.
-    ///
-    /// * 'TxRateLimitExceeded':
-    ///     -  Thrown if key has hit transaction rate limit
-    ///
-    pub fn do_add_stake_aggregate(
-        origin: T::RuntimeOrigin,
-        hotkey: T::AccountId,
-        netuid: u16,
-        stake_to_be_added: u64,
-    ) -> dispatch::DispatchResult {
-        // We check that the transaction is signed by the caller and retrieve the T::AccountId coldkey information.
-        let coldkey = ensure_signed(origin)?;
-
-        // Consider the weight from on_finalize
-        if cfg!(feature = "runtime-benchmarks") && !cfg!(test) {
-            Self::do_add_stake(
-                crate::dispatch::RawOrigin::Signed(coldkey.clone()).into(),
-                hotkey.clone(),
-                netuid,
-                stake_to_be_added,
-            )?;
-        }
-
-        // Save the staking job for the on_finalize
-        let stake_job = StakeJob::AddStake {
-            hotkey,
-            coldkey,
-            netuid,
-            stake_to_be_added,
-        };
-
-        let stake_job_id = NextStakeJobId::<T>::get();
-        let current_blocknumber = <frame_system::Pallet<T>>::block_number();
-
-        StakeJobs::<T>::insert(current_blocknumber, stake_job_id, stake_job);
-        NextStakeJobId::<T>::set(stake_job_id.saturating_add(1));
-
-        Ok(())
-    }
-
-    /// ---- The implementation for the extrinsic add_stake_limit_aggregate: Adds stake to a hotkey
-    /// account on a subnet with price limit. The operation will be delayed until the end of the
-    /// block.
-    ///
-    /// # Args:
-    /// * 'origin': (<T as frame_system::Config>RuntimeOrigin):
-    ///     -  The signature of the caller's coldkey.
-    ///
-    /// * 'hotkey' (T::AccountId):
-    ///     -  The associated hotkey account.
-    ///
-    /// * 'netuid' (u16):
-    ///     - Subnetwork UID
-    ///
-    /// * 'stake_to_be_added' (u64):
-    ///     -  The amount of stake to be added to the hotkey staking account.
-    ///
-    ///  * 'limit_price' (u64):
-    ///     - The limit price expressed in units of RAO per one Alpha.
-    ///
-    ///  * 'allow_partial' (bool):
-    ///     - Allows partial execution of the amount. If set to false, this becomes
-    ///       fill or kill type or order.
-    ///
-    /// # Event:
-    /// * StakeAdded;
-    ///     -  On the successfully adding stake to a global account.
-    ///
-    /// # Raises:
-    /// * 'NotEnoughBalanceToStake':
-    ///     -  Not enough balance on the coldkey to add onto the global account.
-    ///
-    /// * 'NonAssociatedColdKey':
-    ///     -  The calling coldkey is not associated with this hotkey.
-    ///
-    /// * 'BalanceWithdrawalError':
-    ///     -  Errors stemming from transaction pallet.
-    ///
-    /// * 'TxRateLimitExceeded':
-    ///     -  Thrown if key has hit transaction rate limit
-    ///
-    pub fn do_add_stake_limit_aggregate(
-        origin: T::RuntimeOrigin,
-        hotkey: T::AccountId,
-        netuid: u16,
-        stake_to_be_added: u64,
-        limit_price: u64,
-        allow_partial: bool,
-    ) -> dispatch::DispatchResult {
-        let coldkey = ensure_signed(origin)?;
-
-        if cfg!(feature = "runtime-benchmarks") && !cfg!(test) {
-            Self::do_add_stake_limit(
-                crate::dispatch::RawOrigin::Signed(coldkey.clone()).into(),
-                hotkey.clone(),
-                netuid,
-                stake_to_be_added,
-                limit_price,
-                allow_partial,
-            )?;
-        }
-
-        let stake_job = StakeJob::AddStakeLimit {
-            hotkey,
-            coldkey,
-            netuid,
-            stake_to_be_added,
-            limit_price,
-            allow_partial,
-        };
-
-        let stake_job_id = NextStakeJobId::<T>::get();
-        let current_blocknumber = <frame_system::Pallet<T>>::block_number();
-
-        StakeJobs::<T>::insert(current_blocknumber, stake_job_id, stake_job);
-        NextStakeJobId::<T>::set(stake_job_id.saturating_add(1));
-
-        Ok(())
-    }
-
     /// ---- The implementation for the extrinsic add_stake_limit: Adds stake to a hotkey
     /// account on a subnet with price limit.
     ///
diff --git a/pallets/subtensor/src/staking/remove_stake.rs b/pallets/subtensor/src/staking/remove_stake.rs
index 378ea8001b..e1b09a0032 100644
--- a/pallets/subtensor/src/staking/remove_stake.rs
+++ b/pallets/subtensor/src/staking/remove_stake.rs
@@ -90,74 +90,6 @@ impl<T: Config> Pallet<T> {
         Ok(())
     }
 
-    /// ---- The implementation for the extrinsic remove_stake_aggregate: Removes stake from a hotkey account and adds it onto a coldkey.
-    ///    The operation will be delayed until the end of the block.
-    /// # Args:
-    /// * 'origin': (<T as frame_system::Config>RuntimeOrigin):
-    ///     -  The signature of the caller's coldkey.
-    ///
-    /// * 'hotkey' (T::AccountId):
-    ///     -  The associated hotkey account.
-    ///
-    /// * 'netuid' (u16):
-    ///     - Subnetwork UID
-    ///
-    /// * 'stake_to_be_added' (u64):
-    ///     -  The amount of stake to be added to the hotkey staking account.
-    ///
-    /// # Event:
-    /// * StakeRemoved;
-    ///     -  On the successfully removing stake from the hotkey account.
-    ///
-    /// # Raises:
-    /// * 'NotRegistered':
-    ///     -  Thrown if the account we are attempting to unstake from is non existent.
-    ///
-    /// * 'NonAssociatedColdKey':
-    ///     -  Thrown if the coldkey does not own the hotkey we are unstaking from.
-    ///
-    /// * 'NotEnoughStakeToWithdraw':
-    ///     -  Thrown if there is not enough stake on the hotkey to withdwraw this amount.
-    ///
-    /// * 'TxRateLimitExceeded':
-    ///     -  Thrown if key has hit transaction rate limit
-    ///
-    pub fn do_remove_stake_aggregate(
-        origin: T::RuntimeOrigin,
-        hotkey: T::AccountId,
-        netuid: u16,
-        alpha_unstaked: u64,
-    ) -> dispatch::DispatchResult {
-        // We check the transaction is signed by the caller and retrieve the T::AccountId coldkey information.
-        let coldkey = ensure_signed(origin)?;
-
-        // Consider the weight from on_finalize
-        if cfg!(feature = "runtime-benchmarks") && !cfg!(test) {
-            Self::do_remove_stake(
-                crate::dispatch::RawOrigin::Signed(coldkey.clone()).into(),
-                hotkey.clone(),
-                netuid,
-                alpha_unstaked,
-            )?;
-        }
-
-        // Save the staking job for the on_finalize
-        let stake_job = StakeJob::RemoveStake {
-            hotkey,
-            coldkey,
-            netuid,
-            alpha_unstaked,
-        };
-
-        let stake_job_id = NextStakeJobId::<T>::get();
-        let current_blocknumber = <frame_system::Pallet<T>>::block_number();
-
-        StakeJobs::<T>::insert(current_blocknumber, stake_job_id, stake_job);
-        NextStakeJobId::<T>::set(stake_job_id.saturating_add(1));
-
-        Ok(())
-    }
-
     /// ---- The implementation for the extrinsic unstake_all: Removes all stake from a hotkey account across all subnets and adds it onto a coldkey.
     ///
     /// # Args:
@@ -250,41 +182,6 @@ impl<T: Config> Pallet<T> {
         Ok(())
     }
 
-    /// ---- The implementation for the extrinsic unstake_all_aggregate: Removes all stake from a hotkey account across all subnets and adds it onto a coldkey.
-    ///
-    /// # Args:
-    /// * 'origin': (<T as frame_system::Config>RuntimeOrigin):
-    ///     -  The signature of the caller's coldkey.
-    ///
-    /// * 'hotkey' (T::AccountId):
-    ///     -  The associated hotkey account.
-    pub fn do_unstake_all_aggregate(
-        origin: T::RuntimeOrigin,
-        hotkey: T::AccountId,
-    ) -> dispatch::DispatchResult {
-        // We check the transaction is signed by the caller and retrieve the T::AccountId coldkey information.
-        let coldkey = ensure_signed(origin)?;
-
-        // Consider the weight from on_finalize
-        if cfg!(feature = "runtime-benchmarks") && !cfg!(test) {
-            Self::do_unstake_all(
-                crate::dispatch::RawOrigin::Signed(coldkey.clone()).into(),
-                hotkey.clone(),
-            )?;
-        }
-
-        // Save the unstake_all job for the on_finalize
-        let stake_job = StakeJob::UnstakeAll { hotkey, coldkey };
-
-        let stake_job_id = NextStakeJobId::<T>::get();
-        let current_blocknumber = <frame_system::Pallet<T>>::block_number();
-
-        StakeJobs::<T>::insert(current_blocknumber, stake_job_id, stake_job);
-        NextStakeJobId::<T>::set(stake_job_id.saturating_add(1));
-
-        Ok(())
-    }
-
     /// ---- The implementation for the extrinsic unstake_all: Removes all stake from a hotkey account across all subnets and adds it onto a coldkey.
     ///
     /// # Args:
@@ -390,41 +287,6 @@ impl<T: Config> Pallet<T> {
         Ok(())
     }
 
-    /// ---- The implementation for the extrinsic unstake_all_alpha_aggregate: Removes all stake from a hotkey account across all subnets and adds it onto a coldkey.
-    ///
-    /// # Args:
-    /// * 'origin': (<T as frame_system::Config>RuntimeOrigin):
-    ///     -  The signature of the caller's coldkey.
-    ///
-    /// * 'hotkey' (T::AccountId):
-    ///     -  The associated hotkey account.
-    pub fn do_unstake_all_alpha_aggregate(
-        origin: T::RuntimeOrigin,
-        hotkey: T::AccountId,
-    ) -> dispatch::DispatchResult {
-        // We check the transaction is signed by the caller and retrieve the T::AccountId coldkey information.
-        let coldkey = ensure_signed(origin)?;
-
-        // Consider the weight from on_finalize
-        if cfg!(feature = "runtime-benchmarks") && !cfg!(test) {
-            Self::do_unstake_all_alpha(
-                crate::dispatch::RawOrigin::Signed(coldkey.clone()).into(),
-                hotkey.clone(),
-            )?;
-        }
-
-        // Save the unstake_all_alpha job for the on_finalize
-        let stake_job = StakeJob::UnstakeAllAlpha { hotkey, coldkey };
-
-        let stake_job_id = NextStakeJobId::<T>::get();
-        let current_blocknumber = <frame_system::Pallet<T>>::block_number();
-
-        StakeJobs::<T>::insert(current_blocknumber, stake_job_id, stake_job);
-        NextStakeJobId::<T>::set(stake_job_id.saturating_add(1));
-
-        Ok(())
-    }
-
     /// ---- The implementation for the extrinsic remove_stake_limit: Removes stake from
     /// a hotkey on a subnet with a price limit.
     ///
@@ -529,90 +391,6 @@ impl<T: Config> Pallet<T> {
         Ok(())
     }
 
-    /// ---- The implementation for the extrinsic remove_stake_limit_aggregate: Removes stake from
-    /// a hotkey on a subnet with a price limit.
-    ///
-    /// In case if slippage occurs and the price shall move beyond the limit
-    /// price, the staking order may execute only partially or not execute
-    /// at all.
-    ///
-    /// The operation will be delayed until the end of the block.
-    ///
-    /// # Args:
-    /// * 'origin': (<T as frame_system::Config>Origin):
-    ///     - The signature of the caller's coldkey.
-    ///
-    /// * 'hotkey' (T::AccountId):
-    ///     - The associated hotkey account.
-    ///
-    /// * 'netuid' (u16):
-    ///     - Subnetwork UID
-    ///
-    /// * 'amount_unstaked' (u64):
-    ///     - The amount of stake to be added to the hotkey staking account.
-    ///
-    ///  * 'limit_price' (u64):
-    ///     - The limit price expressed in units of RAO per one Alpha.
-    ///
-    ///  * 'allow_partial' (bool):
-    ///     - Allows partial execution of the amount. If set to false, this becomes
-    ///       fill or kill type or order.
-    ///
-    /// # Event:
-    /// * StakeRemoved;
-    ///     - On the successfully removing stake from the hotkey account.
-    ///
-    /// # Raises:
-    /// * 'NotRegistered':
-    ///     - Thrown if the account we are attempting to unstake from is non existent.
-    ///
-    /// * 'NonAssociatedColdKey':
-    ///     - Thrown if the coldkey does not own the hotkey we are unstaking from.
-    ///
-    /// * 'NotEnoughStakeToWithdraw':
-    ///     - Thrown if there is not enough stake on the hotkey to withdwraw this amount.
-    ///
-    pub fn do_remove_stake_limit_aggregate(
-        origin: T::RuntimeOrigin,
-        hotkey: T::AccountId,
-        netuid: u16,
-        alpha_unstaked: u64,
-        limit_price: u64,
-        allow_partial: bool,
-    ) -> dispatch::DispatchResult {
-        let coldkey = ensure_signed(origin)?;
-
-        // Consider the weight from on_finalize
-        if cfg!(feature = "runtime-benchmarks") && !cfg!(test) {
-            Self::do_remove_stake_limit(
-                crate::dispatch::RawOrigin::Signed(coldkey.clone()).into(),
-                hotkey.clone(),
-                netuid,
-                alpha_unstaked,
-                limit_price,
-                allow_partial,
-            )?;
-        }
-
-        let stake_job = StakeJob::RemoveStakeLimit {
-            hotkey,
-            coldkey,
-            netuid,
-            alpha_unstaked,
-            limit_price,
-            allow_partial,
-        };
-
-        let stake_job_id = NextStakeJobId::<T>::get();
-        let current_blocknumber = <frame_system::Pallet<T>>::block_number();
-
-        StakeJobs::<T>::insert(current_blocknumber, stake_job_id, stake_job);
-        NextStakeJobId::<T>::set(stake_job_id.saturating_add(1));
-
-        // Done and ok.
-        Ok(())
-    }
-
     // Returns the maximum amount of RAO that can be executed with price limit
     pub fn get_max_amount_remove(netuid: u16, limit_price: u64) -> Result<u64, Error<T>> {
         // Corner case: root and stao
diff --git a/pallets/subtensor/src/staking/stake_utils.rs b/pallets/subtensor/src/staking/stake_utils.rs
index 058622177e..4b4aacb4b3 100644
--- a/pallets/subtensor/src/staking/stake_utils.rs
+++ b/pallets/subtensor/src/staking/stake_utils.rs
@@ -1,8 +1,6 @@
 use super::*;
-//use frame_system::pallet_prelude::BlockNumberFor;
 use safe_math::*;
 use share_pool::{SharePool, SharePoolDataOperations};
-//use sp_runtime::Saturating;
 use sp_std::ops::Neg;
 use substrate_fixed::types::{I64F64, I96F32, U64F64, U96F32, U110F18};
 
@@ -1205,368 +1203,6 @@ impl<T: Config> Pallet<T> {
             None => DefaultStakingFee::<T>::get(),
         }
     }
-
-    // // Process staking job for on_finalize() hook.
-    // pub(crate) fn do_on_finalize(current_block_number: BlockNumberFor<T>) {
-    //     // We delay job execution
-    //     const DELAY_IN_BLOCKS: u32 = 1u32;
-    //     let actual_block_with_delay = current_block_number.saturating_sub(DELAY_IN_BLOCKS.into());
-    //
-    //     let stake_jobs = StakeJobs::<T>::drain_prefix(actual_block_with_delay).collect::<Vec<_>>();
-    //
-    //     // Sort jobs by job type
-    //     let mut add_stake = vec![];
-    //     let mut remove_stake = vec![];
-    //     let mut add_stake_limit = vec![];
-    //     let mut remove_stake_limit = vec![];
-    //     let mut unstake_all = vec![];
-    //     let mut unstake_all_aplha = vec![];
-    //
-    //     for (_, job) in stake_jobs.into_iter() {
-    //         match &job {
-    //             StakeJob::AddStake { .. } => add_stake.push(job),
-    //             StakeJob::RemoveStake { .. } => remove_stake.push(job),
-    //             StakeJob::AddStakeLimit { .. } => add_stake_limit.push(job),
-    //             StakeJob::RemoveStakeLimit { .. } => remove_stake_limit.push(job),
-    //             StakeJob::UnstakeAll { .. } => unstake_all.push(job),
-    //             StakeJob::UnstakeAllAlpha { .. } => unstake_all_aplha.push(job),
-    //         }
-    //     }
-    //     // Reorder jobs based on the previous block hash
-    //     let previous_block_hash = <frame_system::Pallet<T>>::parent_hash();
-    //     let hash_bytes = previous_block_hash.as_ref();
-    //     let first_byte = hash_bytes.first().expect("hash operation is infallible");
-    //     // Extract the first bit
-    //     let altered_order = (first_byte & 0b10000000) != 0;
-    //
-    //     // Ascending sort by coldkey
-    //     remove_stake_limit.sort_by(|a, b| match (a, b) {
-    //         (
-    //             StakeJob::RemoveStakeLimit { coldkey: a_key, .. },
-    //             StakeJob::RemoveStakeLimit { coldkey: b_key, .. },
-    //         ) => {
-    //             let direct_order = a_key.cmp(b_key); // ascending
-    //
-    //             if altered_order {
-    //                 direct_order.reverse()
-    //             } else {
-    //                 direct_order
-    //             }
-    //         }
-    //         _ => sp_std::cmp::Ordering::Equal, // unreachable
-    //     });
-    //
-    //     remove_stake.sort_by(|a, b| match (a, b) {
-    //         (
-    //             StakeJob::RemoveStake { coldkey: a_key, .. },
-    //             StakeJob::RemoveStake { coldkey: b_key, .. },
-    //         ) => {
-    //             let direct_order = a_key.cmp(b_key); // ascending
-    //
-    //             if altered_order {
-    //                 direct_order.reverse()
-    //             } else {
-    //                 direct_order
-    //             }
-    //         }
-    //         _ => sp_std::cmp::Ordering::Equal, // unreachable
-    //     });
-    //
-    //     unstake_all.sort_by(|a, b| match (a, b) {
-    //         (
-    //             StakeJob::UnstakeAll { coldkey: a_key, .. },
-    //             StakeJob::UnstakeAll { coldkey: b_key, .. },
-    //         ) => {
-    //             let direct_order = a_key.cmp(b_key); // ascending
-    //
-    //             if altered_order {
-    //                 direct_order.reverse()
-    //             } else {
-    //                 direct_order
-    //             }
-    //         }
-    //         _ => sp_std::cmp::Ordering::Equal, // unreachable
-    //     });
-    //
-    //     unstake_all_aplha.sort_by(|a, b| match (a, b) {
-    //         (
-    //             StakeJob::UnstakeAllAlpha { coldkey: a_key, .. },
-    //             StakeJob::UnstakeAllAlpha { coldkey: b_key, .. },
-    //         ) => {
-    //             let direct_order = a_key.cmp(b_key); // ascending
-    //
-    //             if altered_order {
-    //                 direct_order.reverse()
-    //             } else {
-    //                 direct_order
-    //             }
-    //         }
-    //         _ => sp_std::cmp::Ordering::Equal, // unreachable
-    //     });
-    //
-    //     // Descending sort by coldkey
-    //     add_stake_limit.sort_by(|a, b| match (a, b) {
-    //         (
-    //             StakeJob::AddStakeLimit { coldkey: a_key, .. },
-    //             StakeJob::AddStakeLimit { coldkey: b_key, .. },
-    //         ) => {
-    //             let direct_order = b_key.cmp(a_key); // descending
-    //
-    //             if altered_order {
-    //                 direct_order.reverse()
-    //             } else {
-    //                 direct_order
-    //             }
-    //         }
-    //         _ => sp_std::cmp::Ordering::Equal, // unreachable
-    //     });
-    //
-    //     add_stake.sort_by(|a, b| match (a, b) {
-    //         (
-    //             StakeJob::AddStake { coldkey: a_key, .. },
-    //             StakeJob::AddStake { coldkey: b_key, .. },
-    //         ) => {
-    //             let direct_order = b_key.cmp(a_key); // descending
-    //
-    //             if altered_order {
-    //                 direct_order.reverse()
-    //             } else {
-    //                 direct_order
-    //             }
-    //         }
-    //         _ => sp_std::cmp::Ordering::Equal, // unreachable
-    //     });
-    //
-    //     // direct job order
-    //     let mut job_batches = vec![
-    //         remove_stake_limit,
-    //         remove_stake,
-    //         unstake_all,
-    //         unstake_all_aplha,
-    //         add_stake_limit,
-    //         add_stake,
-    //     ];
-    //     if altered_order {
-    //         job_batches.reverse();
-    //     }
-    //
-    //     for jobs in job_batches.into_iter() {
-    //         for job in jobs.into_iter() {
-    //             match job {
-    //                 StakeJob::RemoveStakeLimit {
-    //                     hotkey,
-    //                     coldkey,
-    //                     netuid,
-    //                     alpha_unstaked,
-    //                     limit_price,
-    //                     allow_partial,
-    //                 } => {
-    //                     let result = Self::do_remove_stake_limit(
-    //                         dispatch::RawOrigin::Signed(coldkey.clone()).into(),
-    //                         hotkey.clone(),
-    //                         netuid,
-    //                         alpha_unstaked,
-    //                         limit_price,
-    //                         allow_partial,
-    //                     );
-    //
-    //                     if let Err(err) = result {
-    //                         log::debug!(
-    //                             "Failed to remove aggregated limited stake: {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}",
-    //                             coldkey,
-    //                             hotkey,
-    //                             netuid,
-    //                             alpha_unstaked,
-    //                             limit_price,
-    //                             allow_partial,
-    //                             err
-    //                         );
-    //                         Self::deposit_event(Event::FailedToRemoveAggregatedLimitedStake(
-    //                             coldkey,
-    //                             hotkey,
-    //                             netuid,
-    //                             alpha_unstaked,
-    //                             limit_price,
-    //                             allow_partial,
-    //                         ));
-    //                     } else {
-    //                         Self::deposit_event(Event::AggregatedLimitedStakeRemoved(
-    //                             coldkey,
-    //                             hotkey,
-    //                             netuid,
-    //                             alpha_unstaked,
-    //                             limit_price,
-    //                             allow_partial,
-    //                         ));
-    //                     }
-    //                 }
-    //                 StakeJob::RemoveStake {
-    //                     coldkey,
-    //                     hotkey,
-    //                     netuid,
-    //                     alpha_unstaked,
-    //                 } => {
-    //                     let result = Self::do_remove_stake(
-    //                         dispatch::RawOrigin::Signed(coldkey.clone()).into(),
-    //                         hotkey.clone(),
-    //                         netuid,
-    //                         alpha_unstaked,
-    //                     );
-    //
-    //                     if let Err(err) = result {
-    //                         log::debug!(
-    //                             "Failed to remove aggregated stake: {:?}, {:?}, {:?}, {:?}, {:?}",
-    //                             coldkey,
-    //                             hotkey,
-    //                             netuid,
-    //                             alpha_unstaked,
-    //                             err
-    //                         );
-    //                         Self::deposit_event(Event::FailedToRemoveAggregatedStake(
-    //                             coldkey,
-    //                             hotkey,
-    //                             netuid,
-    //                             alpha_unstaked,
-    //                         ));
-    //                     } else {
-    //                         Self::deposit_event(Event::AggregatedStakeRemoved(
-    //                             coldkey,
-    //                             hotkey,
-    //                             netuid,
-    //                             alpha_unstaked,
-    //                         ));
-    //                     }
-    //                 }
-    //                 StakeJob::UnstakeAll { hotkey, coldkey } => {
-    //                     let result = Self::do_unstake_all(
-    //                         dispatch::RawOrigin::Signed(coldkey.clone()).into(),
-    //                         hotkey.clone(),
-    //                     );
-    //
-    //                     if let Err(err) = result {
-    //                         log::debug!(
-    //                             "Failed to unstake all: {:?}, {:?}, {:?}",
-    //                             coldkey,
-    //                             hotkey,
-    //                             err
-    //                         );
-    //                         Self::deposit_event(Event::AggregatedUnstakeAllFailed(coldkey, hotkey));
-    //                     } else {
-    //                         Self::deposit_event(Event::AggregatedUnstakeAllSucceeded(
-    //                             coldkey, hotkey,
-    //                         ));
-    //                     }
-    //                 }
-    //                 StakeJob::UnstakeAllAlpha { hotkey, coldkey } => {
-    //                     let result = Self::do_unstake_all_alpha(
-    //                         dispatch::RawOrigin::Signed(coldkey.clone()).into(),
-    //                         hotkey.clone(),
-    //                     );
-    //
-    //                     if let Err(err) = result {
-    //                         log::debug!(
-    //                             "Failed to unstake all alpha: {:?}, {:?}, {:?}",
-    //                             coldkey,
-    //                             hotkey,
-    //                             err
-    //                         );
-    //                         Self::deposit_event(Event::AggregatedUnstakeAllAlphaFailed(
-    //                             coldkey, hotkey,
-    //                         ));
-    //                     } else {
-    //                         Self::deposit_event(Event::AggregatedUnstakeAllAlphaSucceeded(
-    //                             coldkey, hotkey,
-    //                         ));
-    //                     }
-    //                 }
-    //                 StakeJob::AddStakeLimit {
-    //                     hotkey,
-    //                     coldkey,
-    //                     netuid,
-    //                     stake_to_be_added,
-    //                     limit_price,
-    //                     allow_partial,
-    //                 } => {
-    //                     let result = Self::do_add_stake_limit(
-    //                         dispatch::RawOrigin::Signed(coldkey.clone()).into(),
-    //                         hotkey.clone(),
-    //                         netuid,
-    //                         stake_to_be_added,
-    //                         limit_price,
-    //                         allow_partial,
-    //                     );
-    //
-    //                     if let Err(err) = result {
-    //                         log::debug!(
-    //                             "Failed to add aggregated limited stake: {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}",
-    //                             coldkey,
-    //                             hotkey,
-    //                             netuid,
-    //                             stake_to_be_added,
-    //                             limit_price,
-    //                             allow_partial,
-    //                             err
-    //                         );
-    //                         Self::deposit_event(Event::FailedToAddAggregatedLimitedStake(
-    //                             coldkey,
-    //                             hotkey,
-    //                             netuid,
-    //                             stake_to_be_added,
-    //                             limit_price,
-    //                             allow_partial,
-    //                         ));
-    //                     } else {
-    //                         Self::deposit_event(Event::AggregatedLimitedStakeAdded(
-    //                             coldkey,
-    //                             hotkey,
-    //                             netuid,
-    //                             stake_to_be_added,
-    //                             limit_price,
-    //                             allow_partial,
-    //                         ));
-    //                     }
-    //                 }
-    //                 StakeJob::AddStake {
-    //                     hotkey,
-    //                     coldkey,
-    //                     netuid,
-    //                     stake_to_be_added,
-    //                 } => {
-    //                     let result = Self::do_add_stake(
-    //                         dispatch::RawOrigin::Signed(coldkey.clone()).into(),
-    //                         hotkey.clone(),
-    //                         netuid,
-    //                         stake_to_be_added,
-    //                     );
-    //
-    //                     if let Err(err) = result {
-    //                         log::debug!(
-    //                             "Failed to add aggregated stake: {:?}, {:?}, {:?}, {:?}, {:?}",
-    //                             coldkey,
-    //                             hotkey,
-    //                             netuid,
-    //                             stake_to_be_added,
-    //                             err
-    //                         );
-    //                         Self::deposit_event(Event::FailedToAddAggregatedStake(
-    //                             coldkey,
-    //                             hotkey,
-    //                             netuid,
-    //                             stake_to_be_added,
-    //                         ));
-    //                     } else {
-    //                         Self::deposit_event(Event::AggregatedStakeAdded(
-    //                             coldkey,
-    //                             hotkey,
-    //                             netuid,
-    //                             stake_to_be_added,
-    //                         ));
-    //                     }
-    //                 }
-    //             }
-    //         }
-    //     }
-    // }
 }
 
 ///////////////////////////////////////////
diff --git a/pallets/subtensor/src/tests/staking.rs b/pallets/subtensor/src/tests/staking.rs
index 9220fa7296..4d8d765e65 100644
--- a/pallets/subtensor/src/tests/staking.rs
+++ b/pallets/subtensor/src/tests/staking.rs
@@ -89,873 +89,6 @@ fn test_add_stake_ok_no_emission() {
         );
     });
 }
-// #[test]
-// fn test_add_stake_aggregate_ok_no_emission() {
-//     new_test_ext(1).execute_with(|| {
-//         let hotkey_account_id = U256::from(533453);
-//         let coldkey_account_id = U256::from(55453);
-//         let amount = DefaultMinStake::<Test>::get() * 10;
-//         let fee = DefaultStakingFee::<Test>::get();
-//
-//         //add network
-//         let netuid: u16 = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
-//
-//         // Give it some $$$ in his coldkey balance
-//         SubtensorModule::add_balance_to_coldkey_account(&coldkey_account_id, amount);
-//
-//         // Check we have zero staked before transfer
-//         assert_eq!(
-//             SubtensorModule::get_total_stake_for_hotkey(&hotkey_account_id),
-//             0
-//         );
-//
-//         // Also total stake should be equal to the network initial lock
-//         assert_eq!(
-//             SubtensorModule::get_total_stake(),
-//             SubtensorModule::get_network_min_lock()
-//         );
-//
-//         // Transfer to hotkey account, and check if the result is ok
-//         assert_ok!(SubtensorModule::add_stake_aggregate(
-//             RuntimeOrigin::signed(coldkey_account_id),
-//             hotkey_account_id,
-//             netuid,
-//             amount
-//         ));
-//
-//         // Ensure that extrinsic call doesn't change the stake.
-//         assert_eq!(
-//             SubtensorModule::get_total_stake(),
-//             SubtensorModule::get_network_min_lock()
-//         );
-//
-//         // Check for the block delay
-//         run_to_block_ext(2, true);
-//
-//         // Check that event was not emitted.
-//         assert!(System::events().iter().all(|e| {
-//             !matches!(
-//                 &e.event,
-//                 RuntimeEvent::SubtensorModule(Event::AggregatedStakeAdded(..))
-//             )
-//         }));
-//
-//         // Enable on_finalize code to run
-//         run_to_block_ext(3, true);
-//
-//         // Check if stake has increased
-//         assert_abs_diff_eq!(
-//             SubtensorModule::get_total_stake_for_hotkey(&hotkey_account_id),
-//             amount - fee,
-//             epsilon = amount / 1000,
-//         );
-//
-//         // Check if balance has decreased
-//         assert_eq!(SubtensorModule::get_coldkey_balance(&coldkey_account_id), 1);
-//
-//         // Check if total stake has increased accordingly.
-//         assert_eq!(
-//             SubtensorModule::get_total_stake(),
-//             amount + SubtensorModule::get_network_min_lock()
-//         );
-//
-//         // Check that event was emitted.
-//         assert!(System::events().iter().any(|e| {
-//             matches!(
-//                 &e.event,
-//                 RuntimeEvent::SubtensorModule(Event::StakeAdded(..))
-//             )
-//         }));
-//
-//         // Check that event was emitted.
-//         assert!(System::events().iter().any(|e| {
-//             matches!(
-//                 &e.event,
-//                 RuntimeEvent::SubtensorModule(Event::AggregatedStakeAdded(..))
-//             )
-//         }));
-//     });
-// }
-//
-// #[test]
-// fn test_add_stake_aggregate_failed() {
-//     new_test_ext(1).execute_with(|| {
-//         let hotkey_account_id = U256::from(533453);
-//         let coldkey_account_id = U256::from(55453);
-//         let amount = DefaultMinStake::<Test>::get() * 100;
-//         //add network
-//         let netuid: u16 = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
-//
-//         // Transfer to hotkey account, and check if the result is ok
-//         assert_ok!(SubtensorModule::add_stake_aggregate(
-//             RuntimeOrigin::signed(coldkey_account_id),
-//             hotkey_account_id,
-//             netuid,
-//             amount
-//         ));
-//
-//         // Check for the block delay
-//         run_to_block_ext(2, true);
-//
-//         // Check that event was not emitted.
-//         assert!(System::events().iter().all(|e| {
-//             !matches!(
-//                 &e.event,
-//                 RuntimeEvent::SubtensorModule(Event::FailedToAddAggregatedStake(..))
-//             )
-//         }));
-//
-//         // Enable on_finalize code to run
-//         run_to_block_ext(3, true);
-//
-//         // Check that event was emitted.
-//         assert!(System::events().iter().any(|e| {
-//             matches!(
-//                 &e.event,
-//                 RuntimeEvent::SubtensorModule(Event::FailedToAddAggregatedStake(..))
-//             )
-//         }));
-//     });
-// }
-//
-// #[test]
-// fn test_verify_aggregated_stake_order() {
-//     new_test_ext(1).execute_with(|| {
-//         let hotkey_account_id = U256::from(533453);
-//         let coldkey_account_id = U256::from(55453);
-//         let amount = 1_000_000_000_000u64;
-//         let limit_price = 6_000_000_000u64;
-//         let unstake_amount = 150_000_000_000u64;
-//         let limit_price2 = 1_350_000_000;
-//
-//         // add network
-//         let netuid1: u16 = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
-//         let netuid2: u16 = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
-//         let netuid3: u16 = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
-//         let netuid4: u16 = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
-//         let netuid5: u16 = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
-//         let netuid6: u16 = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
-//
-//         let tao_reserve: U96F32 = U96F32::from_num(1_500_000_000_000_u64);
-//         let alpha_in: U96F32 = U96F32::from_num(1_000_000_000_000_u64);
-//
-//         for netuid in [netuid1, netuid3, netuid3, netuid4, netuid5, netuid6] {
-//             SubnetTAO::<Test>::insert(netuid, tao_reserve.to_num::<u64>());
-//             SubnetAlphaIn::<Test>::insert(netuid, alpha_in.to_num::<u64>());
-//         }
-//
-//         // Give it some $$$ in his coldkey balance
-//         SubtensorModule::add_balance_to_coldkey_account(&coldkey_account_id, 6 * amount);
-//         // Give the neuron some stake to remove
-//         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
-//             &hotkey_account_id,
-//             &coldkey_account_id,
-//             netuid3,
-//             amount,
-//         );
-//         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
-//             &hotkey_account_id,
-//             &coldkey_account_id,
-//             netuid4,
-//             amount,
-//         );
-//
-//         // Add stake with slippage safety and check if the result is ok
-//         assert_ok!(SubtensorModule::remove_stake_aggregate(
-//             RuntimeOrigin::signed(coldkey_account_id),
-//             hotkey_account_id,
-//             netuid3,
-//             amount
-//         ));
-//
-//         assert_ok!(SubtensorModule::remove_stake_limit_aggregate(
-//             RuntimeOrigin::signed(coldkey_account_id),
-//             hotkey_account_id,
-//             netuid4,
-//             unstake_amount,
-//             limit_price2,
-//             true
-//         ));
-//
-//         assert_ok!(SubtensorModule::add_stake_aggregate(
-//             RuntimeOrigin::signed(coldkey_account_id),
-//             hotkey_account_id,
-//             netuid1,
-//             amount,
-//         ));
-//
-//         assert_ok!(SubtensorModule::add_stake_limit_aggregate(
-//             RuntimeOrigin::signed(coldkey_account_id),
-//             hotkey_account_id,
-//             netuid2,
-//             amount,
-//             limit_price,
-//             true
-//         ));
-//
-//         assert_ok!(SubtensorModule::unstake_all_aggregate(
-//             RuntimeOrigin::signed(coldkey_account_id),
-//             hotkey_account_id,
-//         ));
-//
-//         assert_ok!(SubtensorModule::unstake_all_alpha_aggregate(
-//             RuntimeOrigin::signed(coldkey_account_id),
-//             hotkey_account_id,
-//         ));
-//
-//         // Enable on_finalize code to run
-//         run_to_block_ext(3, true);
-//
-//         let add_stake_position = System::events()
-//             .iter()
-//             .position(|e| {
-//                 if let RuntimeEvent::SubtensorModule(Event::AggregatedStakeAdded(.., netuid, _)) =
-//                     e.event
-//                 {
-//                     netuid == netuid1
-//                 } else {
-//                     false
-//                 }
-//             })
-//             .expect("Stake event must be present in the event log.");
-//
-//         let add_stake_limit_position = System::events()
-//             .iter()
-//             .position(|e| {
-//                 if let RuntimeEvent::SubtensorModule(Event::AggregatedLimitedStakeAdded(
-//                     _,
-//                     _,
-//                     netuid,
-//                     _,
-//                     _,
-//                     _,
-//                 )) = e.event
-//                 {
-//                     netuid == netuid2
-//                 } else {
-//                     false
-//                 }
-//             })
-//             .expect("Stake event must be present in the event log.");
-//
-//         let remove_stake_position = System::events()
-//             .iter()
-//             .position(|e| {
-//                 if let RuntimeEvent::SubtensorModule(Event::AggregatedStakeRemoved(.., netuid, _)) =
-//                     e.event
-//                 {
-//                     netuid == netuid3
-//                 } else {
-//                     false
-//                 }
-//             })
-//             .expect("Stake event must be present in the event log.");
-//
-//         let remove_stake_limit_position = System::events()
-//             .iter()
-//             .position(|e| {
-//                 if let RuntimeEvent::SubtensorModule(Event::AggregatedLimitedStakeRemoved(
-//                     ..,
-//                     netuid,
-//                     _,
-//                     _,
-//                     _,
-//                 )) = e.event
-//                 {
-//                     netuid == netuid4
-//                 } else {
-//                     false
-//                 }
-//             })
-//             .expect("Stake event must be present in the event log.");
-//
-//         let unstake_all_position = System::events()
-//             .iter()
-//             .position(|e| {
-//                 matches!(
-//                     e.event,
-//                     RuntimeEvent::SubtensorModule(Event::AggregatedUnstakeAllSucceeded(..))
-//                 )
-//             })
-//             .expect("Stake event must be present in the event log.");
-//
-//         let unstake_all_alpha_position = System::events()
-//             .iter()
-//             .position(|e| {
-//                 matches!(
-//                     e.event,
-//                     RuntimeEvent::SubtensorModule(Event::AggregatedUnstakeAllAlphaSucceeded(..))
-//                 )
-//             })
-//             .expect("Stake event must be present in the event log.");
-//
-//         // Check events order
-//         assert!(remove_stake_limit_position < remove_stake_position);
-//         assert!(remove_stake_position < unstake_all_position);
-//         assert!(unstake_all_position < unstake_all_alpha_position);
-//         assert!(add_stake_position > unstake_all_alpha_position);
-//         assert!(add_stake_limit_position < add_stake_position);
-//     });
-// }
-//
-// #[test]
-// #[allow(clippy::indexing_slicing)]
-// fn test_verify_aggregated_stake_order_reversed() {
-//     new_test_ext(1).execute_with(|| {
-//         let amount = 1_000_000_000_000u64;
-//         let limit_price = 6_000_000_000u64;
-//         let unstake_amount = 150_000_000_000u64;
-//         let limit_price2 = 1_350_000_000;
-//
-//         // Coldkeys and hotkeys
-//         let coldkeys = vec![
-//             U256::from(100), // add_stake
-//             U256::from(200), // add_stake_limit
-//             U256::from(300), // remove_stake
-//             U256::from(400), // remove_stake_limit
-//             U256::from(500), // unstake_all
-//             U256::from(600), // unstake_all_alpha
-//         ];
-//
-//         let hotkeys = (1..=6).map(U256::from).collect::<Vec<_>>();
-//
-//         let netuids: Vec<_> = hotkeys
-//             .iter()
-//             .zip(coldkeys.iter())
-//             .map(|(h, c)| add_dynamic_network(h, c))
-//             .collect();
-//
-//         let tao_reserve = U96F32::from_num(1_500_000_000_000u64);
-//         let alpha_in = U96F32::from_num(1_000_000_000_000u64);
-//
-//         for netuid in &netuids {
-//             SubnetTAO::<Test>::insert(*netuid, tao_reserve.to_num::<u64>());
-//             SubnetAlphaIn::<Test>::insert(*netuid, alpha_in.to_num::<u64>());
-//         }
-//
-//         for coldkey in &coldkeys {
-//             SubtensorModule::add_balance_to_coldkey_account(coldkey, amount);
-//         }
-//
-//         for ((hotkey, coldkey), netuid) in hotkeys.iter().zip(coldkeys.iter()).zip(netuids.iter()) {
-//             SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
-//                 hotkey, coldkey, *netuid, amount,
-//             );
-//         }
-//
-//         // Add stake with slippage safety and check if the result is ok
-//         assert_ok!(SubtensorModule::remove_stake_aggregate(
-//             RuntimeOrigin::signed(coldkeys[2]),
-//             hotkeys[2],
-//             netuids[2],
-//             amount
-//         ));
-//
-//         assert_ok!(SubtensorModule::remove_stake_limit_aggregate(
-//             RuntimeOrigin::signed(coldkeys[3]),
-//             hotkeys[3],
-//             netuids[3],
-//             unstake_amount,
-//             limit_price2,
-//             true
-//         ));
-//
-//         assert_ok!(SubtensorModule::add_stake_aggregate(
-//             RuntimeOrigin::signed(coldkeys[0]),
-//             hotkeys[0],
-//             netuids[0],
-//             amount,
-//         ));
-//
-//         assert_ok!(SubtensorModule::add_stake_limit_aggregate(
-//             RuntimeOrigin::signed(coldkeys[1]),
-//             hotkeys[1],
-//             netuids[1],
-//             amount,
-//             limit_price,
-//             true
-//         ));
-//
-//         assert_ok!(SubtensorModule::unstake_all_aggregate(
-//             RuntimeOrigin::signed(coldkeys[4]),
-//             hotkeys[4],
-//         ));
-//
-//         assert_ok!(SubtensorModule::unstake_all_alpha_aggregate(
-//             RuntimeOrigin::signed(coldkeys[5]),
-//             hotkeys[5],
-//         ));
-//
-//         // Enable on_finalize code to run
-//         run_to_block_ext(2, false);
-//         // Reorder jobs based on the previous block hash
-//         let mut parent_hash = <frame_system::Pallet<Test>>::parent_hash();
-//         parent_hash.as_mut()[0] = 0b10000000;
-//         <frame_system::Pallet<Test>>::set_parent_hash(parent_hash);
-//
-//         // Enable on_finalize code to run
-//         run_to_block_ext(3, true);
-//
-//         let add_stake_position = System::events()
-//             .iter()
-//             .position(|e| {
-//                 if let RuntimeEvent::SubtensorModule(Event::AggregatedStakeAdded(.., netuid, _)) =
-//                     e.event
-//                 {
-//                     netuid == netuids[0]
-//                 } else {
-//                     false
-//                 }
-//             })
-//             .expect("Stake event must be present in the event log.");
-//
-//         let add_stake_limit_position = System::events()
-//             .iter()
-//             .position(|e| {
-//                 if let RuntimeEvent::SubtensorModule(Event::AggregatedLimitedStakeAdded(
-//                     _,
-//                     _,
-//                     netuid,
-//                     _,
-//                     _,
-//                     _,
-//                 )) = e.event
-//                 {
-//                     netuid == netuids[1]
-//                 } else {
-//                     false
-//                 }
-//             })
-//             .expect("Stake event must be present in the event log.");
-//
-//         let remove_stake_position = System::events()
-//             .iter()
-//             .position(|e| {
-//                 if let RuntimeEvent::SubtensorModule(Event::AggregatedStakeRemoved(.., netuid, _)) =
-//                     e.event
-//                 {
-//                     netuid == netuids[2]
-//                 } else {
-//                     false
-//                 }
-//             })
-//             .expect("Stake event must be present in the event log.");
-//
-//         let remove_stake_limit_position = System::events()
-//             .iter()
-//             .position(|e| {
-//                 if let RuntimeEvent::SubtensorModule(Event::AggregatedLimitedStakeRemoved(
-//                     ..,
-//                     netuid,
-//                     _,
-//                     _,
-//                     _,
-//                 )) = e.event
-//                 {
-//                     netuid == netuids[3]
-//                 } else {
-//                     false
-//                 }
-//             })
-//             .expect("Stake event must be present in the event log.");
-//
-//         let unstake_all_position = System::events()
-//             .iter()
-//             .position(|e| {
-//                 matches!(
-//                     e.event,
-//                     RuntimeEvent::SubtensorModule(Event::AggregatedUnstakeAllSucceeded(..))
-//                 )
-//             })
-//             .expect("Stake event must be present in the event log.");
-//
-//         let unstake_all_alpha_position = System::events()
-//             .iter()
-//             .position(|e| {
-//                 matches!(
-//                     e.event,
-//                     RuntimeEvent::SubtensorModule(Event::AggregatedUnstakeAllAlphaSucceeded(..))
-//                 )
-//             })
-//             .expect("Stake event must be present in the event log.");
-//
-//         // Check events order
-//         assert!(add_stake_limit_position > add_stake_position);
-//         assert!(add_stake_position < unstake_all_alpha_position);
-//         assert!(unstake_all_position > unstake_all_alpha_position);
-//         assert!(remove_stake_position > unstake_all_position);
-//         assert!(remove_stake_limit_position > remove_stake_position);
-//     });
-// }
-//
-// #[test]
-// #[allow(clippy::indexing_slicing)]
-// fn test_verify_all_job_type_sort_by_coldkey() {
-//     new_test_ext(1).execute_with(|| {
-//         let amount = 1_000_000_000_000u64;
-//         let limit_price = 6_000_000_000u64;
-//         let unstake_amount = 150_000_000_000u64;
-//         let limit_price2 = 1_350_000_000;
-//
-//         // Coldkeys and hotkeys
-//         let coldkeys = vec![
-//             U256::from(100),  // add_stake
-//             U256::from(200),  // add_stake
-//             U256::from(300),  // add_stake_limit
-//             U256::from(400),  // add_stake_limit
-//             U256::from(500),  // remove_stake
-//             U256::from(600),  // remove_stake
-//             U256::from(700),  // remove_stake_limit
-//             U256::from(800),  // remove_stake_limit
-//             U256::from(900),  // unstake_all
-//             U256::from(1000), // unstake_all
-//             U256::from(1100), // unstake_all_alpha
-//             U256::from(1200), // unstake_all_alpha
-//         ];
-//
-//         let hotkeys = (1..=12).map(U256::from).collect::<Vec<_>>();
-//
-//         let netuids: Vec<_> = hotkeys
-//             .iter()
-//             .zip(coldkeys.iter())
-//             .map(|(h, c)| add_dynamic_network(h, c))
-//             .collect();
-//
-//         let tao_reserve = U96F32::from_num(1_500_000_000_000u64);
-//         let alpha_in = U96F32::from_num(1_000_000_000_000u64);
-//
-//         for netuid in &netuids {
-//             SubnetTAO::<Test>::insert(*netuid, tao_reserve.to_num::<u64>());
-//             SubnetAlphaIn::<Test>::insert(*netuid, alpha_in.to_num::<u64>());
-//         }
-//
-//         for coldkey in &coldkeys {
-//             SubtensorModule::add_balance_to_coldkey_account(coldkey, amount);
-//         }
-//
-//         for ((hotkey, coldkey), netuid) in hotkeys.iter().zip(coldkeys.iter()).zip(netuids.iter()) {
-//             SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
-//                 hotkey, coldkey, *netuid, amount,
-//             );
-//         }
-//
-//         // === Submit all job types ===
-//
-//         assert_ok!(SubtensorModule::add_stake_aggregate(
-//             RuntimeOrigin::signed(coldkeys[0]),
-//             hotkeys[0],
-//             netuids[0],
-//             amount
-//         ));
-//         assert_ok!(SubtensorModule::add_stake_aggregate(
-//             RuntimeOrigin::signed(coldkeys[1]),
-//             hotkeys[1],
-//             netuids[1],
-//             amount
-//         ));
-//
-//         assert_ok!(SubtensorModule::add_stake_limit_aggregate(
-//             RuntimeOrigin::signed(coldkeys[2]),
-//             hotkeys[2],
-//             netuids[2],
-//             amount,
-//             limit_price,
-//             true
-//         ));
-//         assert_ok!(SubtensorModule::add_stake_limit_aggregate(
-//             RuntimeOrigin::signed(coldkeys[3]),
-//             hotkeys[3],
-//             netuids[3],
-//             amount,
-//             limit_price,
-//             true
-//         ));
-//
-//         assert_ok!(SubtensorModule::remove_stake_aggregate(
-//             RuntimeOrigin::signed(coldkeys[4]),
-//             hotkeys[4],
-//             netuids[4],
-//             amount
-//         ));
-//         assert_ok!(SubtensorModule::remove_stake_aggregate(
-//             RuntimeOrigin::signed(coldkeys[5]),
-//             hotkeys[5],
-//             netuids[5],
-//             amount
-//         ));
-//
-//         assert_ok!(SubtensorModule::remove_stake_limit_aggregate(
-//             RuntimeOrigin::signed(coldkeys[6]),
-//             hotkeys[6],
-//             netuids[6],
-//             unstake_amount,
-//             limit_price2,
-//             true
-//         ));
-//         assert_ok!(SubtensorModule::remove_stake_limit_aggregate(
-//             RuntimeOrigin::signed(coldkeys[7]),
-//             hotkeys[7],
-//             netuids[7],
-//             unstake_amount,
-//             limit_price2,
-//             true
-//         ));
-//
-//         assert_ok!(SubtensorModule::unstake_all_aggregate(
-//             RuntimeOrigin::signed(coldkeys[8]),
-//             hotkeys[8],
-//         ));
-//         assert_ok!(SubtensorModule::unstake_all_aggregate(
-//             RuntimeOrigin::signed(coldkeys[9]),
-//             hotkeys[9],
-//         ));
-//
-//         assert_ok!(SubtensorModule::unstake_all_alpha_aggregate(
-//             RuntimeOrigin::signed(coldkeys[10]),
-//             hotkeys[10],
-//         ));
-//         assert_ok!(SubtensorModule::unstake_all_alpha_aggregate(
-//             RuntimeOrigin::signed(coldkeys[11]),
-//             hotkeys[11],
-//         ));
-//
-//         // Finalize block
-//         run_to_block_ext(3, true);
-//
-//         // === Collect coldkeys by event type ===
-//         let mut add_coldkeys = vec![];
-//         let mut add_limit_coldkeys = vec![];
-//         let mut remove_coldkeys = vec![];
-//         let mut remove_limit_coldkeys = vec![];
-//         let mut unstake_all_coldkeys = vec![];
-//         let mut unstake_all_alpha_coldkeys = vec![];
-//
-//         for event in System::events().iter().map(|e| &e.event) {
-//             match event {
-//                 RuntimeEvent::SubtensorModule(Event::AggregatedStakeAdded(coldkey, ..)) => {
-//                     add_coldkeys.push(*coldkey);
-//                 }
-//                 RuntimeEvent::SubtensorModule(Event::AggregatedLimitedStakeAdded(coldkey, ..)) => {
-//                     add_limit_coldkeys.push(*coldkey);
-//                 }
-//                 RuntimeEvent::SubtensorModule(Event::AggregatedStakeRemoved(coldkey, ..)) => {
-//                     remove_coldkeys.push(*coldkey);
-//                 }
-//                 RuntimeEvent::SubtensorModule(Event::AggregatedLimitedStakeRemoved(
-//                     coldkey,
-//                     ..,
-//                 )) => {
-//                     remove_limit_coldkeys.push(*coldkey);
-//                 }
-//                 RuntimeEvent::SubtensorModule(Event::AggregatedUnstakeAllSucceeded(coldkey, _)) => {
-//                     unstake_all_coldkeys.push(*coldkey);
-//                 }
-//                 RuntimeEvent::SubtensorModule(Event::AggregatedUnstakeAllAlphaSucceeded(
-//                     coldkey,
-//                     _,
-//                 )) => {
-//                     unstake_all_alpha_coldkeys.push(*coldkey);
-//                 }
-//                 _ => {}
-//             }
-//         }
-//
-//         // === Assertions ===
-//         assert_eq!(add_coldkeys, vec![coldkeys[1], coldkeys[0]]); // descending
-//         assert_eq!(add_limit_coldkeys, vec![coldkeys[3], coldkeys[2]]); // descending
-//         assert_eq!(remove_coldkeys, vec![coldkeys[4], coldkeys[5]]); // ascending
-//         assert_eq!(remove_limit_coldkeys, vec![coldkeys[6], coldkeys[7]]); // ascending
-//         assert_eq!(unstake_all_coldkeys, vec![coldkeys[8], coldkeys[9]]); // ascending
-//         assert_eq!(unstake_all_alpha_coldkeys, vec![coldkeys[10], coldkeys[11]]); // ascending
-//     });
-// }
-//
-// #[test]
-// #[allow(clippy::indexing_slicing)]
-// fn test_verify_all_job_type_sort_by_coldkey_reverse_order() {
-//     new_test_ext(1).execute_with(|| {
-//         let amount = 1_000_000_000_000u64;
-//         let limit_price = 6_000_000_000u64;
-//         let unstake_amount = 150_000_000_000u64;
-//         let limit_price2 = 1_350_000_000;
-//
-//         // Coldkeys and hotkeys
-//         let coldkeys = vec![
-//             U256::from(100),  // add_stake
-//             U256::from(200),  // add_stake
-//             U256::from(300),  // add_stake_limit
-//             U256::from(400),  // add_stake_limit
-//             U256::from(500),  // remove_stake
-//             U256::from(600),  // remove_stake
-//             U256::from(700),  // remove_stake_limit
-//             U256::from(800),  // remove_stake_limit
-//             U256::from(900),  // unstake_all
-//             U256::from(1000), // unstake_all
-//             U256::from(1100), // unstake_all_alpha
-//             U256::from(1200), // unstake_all_alpha
-//         ];
-//
-//         let hotkeys = (1..=12).map(U256::from).collect::<Vec<_>>();
-//
-//         let netuids: Vec<_> = hotkeys
-//             .iter()
-//             .zip(coldkeys.iter())
-//             .map(|(h, c)| add_dynamic_network(h, c))
-//             .collect();
-//
-//         let tao_reserve = U96F32::from_num(1_500_000_000_000u64);
-//         let alpha_in = U96F32::from_num(1_000_000_000_000u64);
-//
-//         for netuid in &netuids {
-//             SubnetTAO::<Test>::insert(*netuid, tao_reserve.to_num::<u64>());
-//             SubnetAlphaIn::<Test>::insert(*netuid, alpha_in.to_num::<u64>());
-//         }
-//
-//         for coldkey in &coldkeys {
-//             SubtensorModule::add_balance_to_coldkey_account(coldkey, amount);
-//         }
-//
-//         for ((hotkey, coldkey), netuid) in hotkeys.iter().zip(coldkeys.iter()).zip(netuids.iter()) {
-//             SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
-//                 hotkey, coldkey, *netuid, amount,
-//             );
-//         }
-//
-//         // === Submit all job types ===
-//
-//         assert_ok!(SubtensorModule::add_stake_aggregate(
-//             RuntimeOrigin::signed(coldkeys[0]),
-//             hotkeys[0],
-//             netuids[0],
-//             amount
-//         ));
-//         assert_ok!(SubtensorModule::add_stake_aggregate(
-//             RuntimeOrigin::signed(coldkeys[1]),
-//             hotkeys[1],
-//             netuids[1],
-//             amount
-//         ));
-//
-//         assert_ok!(SubtensorModule::add_stake_limit_aggregate(
-//             RuntimeOrigin::signed(coldkeys[2]),
-//             hotkeys[2],
-//             netuids[2],
-//             amount,
-//             limit_price,
-//             true
-//         ));
-//         assert_ok!(SubtensorModule::add_stake_limit_aggregate(
-//             RuntimeOrigin::signed(coldkeys[3]),
-//             hotkeys[3],
-//             netuids[3],
-//             amount,
-//             limit_price,
-//             true
-//         ));
-//
-//         assert_ok!(SubtensorModule::remove_stake_aggregate(
-//             RuntimeOrigin::signed(coldkeys[4]),
-//             hotkeys[4],
-//             netuids[4],
-//             amount
-//         ));
-//         assert_ok!(SubtensorModule::remove_stake_aggregate(
-//             RuntimeOrigin::signed(coldkeys[5]),
-//             hotkeys[5],
-//             netuids[5],
-//             amount
-//         ));
-//
-//         assert_ok!(SubtensorModule::remove_stake_limit_aggregate(
-//             RuntimeOrigin::signed(coldkeys[6]),
-//             hotkeys[6],
-//             netuids[6],
-//             unstake_amount,
-//             limit_price2,
-//             true
-//         ));
-//         assert_ok!(SubtensorModule::remove_stake_limit_aggregate(
-//             RuntimeOrigin::signed(coldkeys[7]),
-//             hotkeys[7],
-//             netuids[7],
-//             unstake_amount,
-//             limit_price2,
-//             true
-//         ));
-//
-//         assert_ok!(SubtensorModule::unstake_all_aggregate(
-//             RuntimeOrigin::signed(coldkeys[8]),
-//             hotkeys[8],
-//         ));
-//         assert_ok!(SubtensorModule::unstake_all_aggregate(
-//             RuntimeOrigin::signed(coldkeys[9]),
-//             hotkeys[9],
-//         ));
-//
-//         assert_ok!(SubtensorModule::unstake_all_alpha_aggregate(
-//             RuntimeOrigin::signed(coldkeys[10]),
-//             hotkeys[10],
-//         ));
-//         assert_ok!(SubtensorModule::unstake_all_alpha_aggregate(
-//             RuntimeOrigin::signed(coldkeys[11]),
-//             hotkeys[11],
-//         ));
-//
-//         // Reorder jobs based on the previous block hash
-//         let mut parent_hash = <frame_system::Pallet<Test>>::parent_hash();
-//         parent_hash.as_mut()[0] = 0b10000000;
-//         <frame_system::Pallet<Test>>::set_parent_hash(parent_hash);
-//
-//         // Finalize block
-//         run_to_block_ext(3, true);
-//
-//         // === Collect coldkeys by event type ===
-//         let mut add_coldkeys = vec![];
-//         let mut add_limit_coldkeys = vec![];
-//         let mut remove_coldkeys = vec![];
-//         let mut remove_limit_coldkeys = vec![];
-//         let mut unstake_all_coldkeys = vec![];
-//         let mut unstake_all_alpha_coldkeys = vec![];
-//
-//         for event in System::events().iter().map(|e| &e.event) {
-//             match event {
-//                 RuntimeEvent::SubtensorModule(Event::AggregatedStakeAdded(coldkey, ..)) => {
-//                     add_coldkeys.push(*coldkey);
-//                 }
-//                 RuntimeEvent::SubtensorModule(Event::AggregatedLimitedStakeAdded(coldkey, ..)) => {
-//                     add_limit_coldkeys.push(*coldkey);
-//                 }
-//                 RuntimeEvent::SubtensorModule(Event::AggregatedStakeRemoved(coldkey, ..)) => {
-//                     remove_coldkeys.push(*coldkey);
-//                 }
-//                 RuntimeEvent::SubtensorModule(Event::AggregatedLimitedStakeRemoved(
-//                     coldkey,
-//                     ..,
-//                 )) => {
-//                     remove_limit_coldkeys.push(*coldkey);
-//                 }
-//                 RuntimeEvent::SubtensorModule(Event::AggregatedUnstakeAllSucceeded(coldkey, _)) => {
-//                     unstake_all_coldkeys.push(*coldkey);
-//                 }
-//                 RuntimeEvent::SubtensorModule(Event::AggregatedUnstakeAllAlphaSucceeded(
-//                     coldkey,
-//                     _,
-//                 )) => {
-//                     unstake_all_alpha_coldkeys.push(*coldkey);
-//                 }
-//                 _ => {}
-//             }
-//         }
-//
-//         // === Assertions ===
-//         assert_eq!(add_coldkeys, vec![coldkeys[0], coldkeys[1]]); // ascending (reversed)
-//         assert_eq!(add_limit_coldkeys, vec![coldkeys[2], coldkeys[3]]); // ascending (reversed)
-//         assert_eq!(remove_coldkeys, vec![coldkeys[5], coldkeys[4]]); // descending (reversed)
-//         assert_eq!(remove_limit_coldkeys, vec![coldkeys[7], coldkeys[6]]); // descending (reversed)
-//         assert_eq!(unstake_all_coldkeys, vec![coldkeys[9], coldkeys[8]]); // descending (reversed)
-//         assert_eq!(unstake_all_alpha_coldkeys, vec![coldkeys[11], coldkeys[10]]); // descending (reversed)
-//     });
-// }
 
 #[test]
 fn test_dividends_with_run_to_block() {
@@ -1287,145 +420,6 @@ fn test_remove_stake_ok_no_emission() {
         );
     });
 }
-//
-// #[test]
-// fn test_remove_stake_aggregate_ok_no_emission() {
-//     new_test_ext(1).execute_with(|| {
-//         let subnet_owner_coldkey = U256::from(1);
-//         let subnet_owner_hotkey = U256::from(2);
-//         let coldkey_account_id = U256::from(4343);
-//         let hotkey_account_id = U256::from(4968585);
-//         let amount = DefaultMinStake::<Test>::get() * 10;
-//         let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
-//         register_ok_neuron(netuid, hotkey_account_id, coldkey_account_id, 192213123);
-//
-//         // Some basic assertions
-//         assert_eq!(
-//             SubtensorModule::get_total_stake(),
-//             SubtensorModule::get_network_min_lock()
-//         );
-//         assert_eq!(
-//             SubtensorModule::get_total_stake_for_hotkey(&hotkey_account_id),
-//             0
-//         );
-//         assert_eq!(SubtensorModule::get_coldkey_balance(&coldkey_account_id), 0);
-//
-//         // Give the neuron some stake to remove
-//         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
-//             &hotkey_account_id,
-//             &coldkey_account_id,
-//             netuid,
-//             amount,
-//         );
-//         assert_eq!(
-//             SubtensorModule::get_total_stake_for_hotkey(&hotkey_account_id),
-//             amount
-//         );
-//
-//         // Add subnet TAO for the equivalent amount added at price
-//         let amount_tao =
-//             U96F32::saturating_from_num(amount) * SubtensorModule::get_alpha_price(netuid);
-//         SubnetTAO::<Test>::mutate(netuid, |v| *v += amount_tao.saturating_to_num::<u64>());
-//         TotalStake::<Test>::mutate(|v| *v += amount_tao.saturating_to_num::<u64>());
-//
-//         // Do the magic
-//         assert_ok!(SubtensorModule::remove_stake_aggregate(
-//             RuntimeOrigin::signed(coldkey_account_id),
-//             hotkey_account_id,
-//             netuid,
-//             amount
-//         ));
-//
-//         // Check for the block delay
-//         run_to_block_ext(2, true);
-//
-//         // Check that event was not emitted.
-//         assert!(System::events().iter().all(|e| {
-//             !matches!(
-//                 &e.event,
-//                 RuntimeEvent::SubtensorModule(Event::AggregatedStakeRemoved(..))
-//             )
-//         }));
-//
-//         // Enable on_finalize code to run
-//         run_to_block_ext(3, true);
-//
-//         let fee = SubtensorModule::calculate_staking_fee(
-//             Some((&hotkey_account_id, netuid)),
-//             &coldkey_account_id,
-//             None,
-//             &coldkey_account_id,
-//             U96F32::saturating_from_num(amount),
-//         );
-//
-//         // we do not expect the exact amount due to slippage
-//         assert!(SubtensorModule::get_coldkey_balance(&coldkey_account_id) > amount / 10 * 9 - fee);
-//         assert_eq!(
-//             SubtensorModule::get_total_stake_for_hotkey(&hotkey_account_id),
-//             0
-//         );
-//         assert_eq!(
-//             SubtensorModule::get_total_stake(),
-//             SubtensorModule::get_network_min_lock() + fee
-//         );
-//
-//         // Check that event was emitted.
-//         assert!(System::events().iter().any(|e| {
-//             matches!(
-//                 &e.event,
-//                 RuntimeEvent::SubtensorModule(Event::StakeRemoved(..))
-//             )
-//         }));
-//         // Check that event was emitted.
-//         assert!(System::events().iter().any(|e| {
-//             matches!(
-//                 &e.event,
-//                 RuntimeEvent::SubtensorModule(Event::AggregatedStakeRemoved(..))
-//             )
-//         }));
-//     });
-// }
-// #[test]
-// fn test_remove_stake_aggregate_fail() {
-//     new_test_ext(1).execute_with(|| {
-//         let subnet_owner_coldkey = U256::from(1);
-//         let subnet_owner_hotkey = U256::from(2);
-//         let coldkey_account_id = U256::from(4343);
-//         let hotkey_account_id = U256::from(4968585);
-//         let amount = DefaultMinStake::<Test>::get() * 10;
-//         let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
-//         register_ok_neuron(netuid, hotkey_account_id, coldkey_account_id, 192213123);
-//
-//         assert_ok!(SubtensorModule::remove_stake_aggregate(
-//             RuntimeOrigin::signed(coldkey_account_id),
-//             hotkey_account_id,
-//             netuid,
-//             amount
-//         ));
-//
-//         // Check for the block delay
-//         run_to_block_ext(2, true);
-//
-//         // Check that event was not emitted.
-//         assert!(System::events().iter().all(|e| {
-//             !matches!(
-//                 &e.event,
-//                 RuntimeEvent::SubtensorModule(Event::FailedToRemoveAggregatedStake(..))
-//             )
-//         }));
-//
-//         // Enable on_finalize code to run
-//         run_to_block_ext(3, true);
-//
-//         // Check that event was emitted.
-//         assert!(System::events().iter().any(|e| {
-//             matches!(
-//                 &e.event,
-//                 RuntimeEvent::SubtensorModule(Event::FailedToRemoveAggregatedStake(..))
-//             )
-//         }));
-//     });
-// }
 
 #[test]
 fn test_remove_stake_amount_too_low() {
@@ -4907,145 +3901,6 @@ fn test_add_stake_limit_ok() {
         );
     });
 }
-//
-// #[test]
-// fn test_add_stake_limit_aggregate_ok() {
-//     new_test_ext(1).execute_with(|| {
-//         let hotkey_account_id = U256::from(533453);
-//         let coldkey_account_id = U256::from(55453);
-//         let amount = 900_000_000_000; // over the maximum
-//         let fee = DefaultStakingFee::<Test>::get();
-//
-//         // add network
-//         let netuid: u16 = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
-//
-//         // Forse-set alpha in and tao reserve to make price equal 1.5
-//         let tao_reserve: U96F32 = U96F32::from_num(150_000_000_000_u64);
-//         let alpha_in: U96F32 = U96F32::from_num(100_000_000_000_u64);
-//         SubnetTAO::<Test>::insert(netuid, tao_reserve.to_num::<u64>());
-//         SubnetAlphaIn::<Test>::insert(netuid, alpha_in.to_num::<u64>());
-//         let current_price: U96F32 = U96F32::from_num(SubtensorModule::get_alpha_price(netuid));
-//         assert_eq!(current_price, U96F32::from_num(1.5));
-//
-//         // Give it some $$$ in his coldkey balance
-//         SubtensorModule::add_balance_to_coldkey_account(&coldkey_account_id, amount);
-//
-//         // Setup limit price so that it doesn't peak above 4x of current price
-//         // The amount that can be executed at this price is 450 TAO only
-//         // Alpha produced will be equal to 75 = 450*100/(450+150)
-//         let limit_price = 6_000_000_000;
-//         let expected_executed_stake = 75_000_000_000;
-//
-//         // Add stake with slippage safety and check if the result is ok
-//         assert_ok!(SubtensorModule::add_stake_limit_aggregate(
-//             RuntimeOrigin::signed(coldkey_account_id),
-//             hotkey_account_id,
-//             netuid,
-//             amount,
-//             limit_price,
-//             true
-//         ));
-//
-//         // Check for the block delay
-//         run_to_block_ext(2, true);
-//
-//         // Check that event was not emitted.
-//         assert!(System::events().iter().all(|e| {
-//             !matches!(
-//                 &e.event,
-//                 RuntimeEvent::SubtensorModule(Event::AggregatedLimitedStakeAdded(..))
-//             )
-//         }));
-//
-//         // Enable on_finalize code to run
-//         run_to_block_ext(3, true);
-//
-//         // Check if stake has increased only by 75 Alpha
-//         assert_abs_diff_eq!(
-//             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
-//                 &hotkey_account_id,
-//                 &coldkey_account_id,
-//                 netuid
-//             ),
-//             expected_executed_stake - fee,
-//             epsilon = expected_executed_stake / 1000,
-//         );
-//
-//         // Check that 450 TAO balance still remains free on coldkey
-//         assert_abs_diff_eq!(
-//             SubtensorModule::get_coldkey_balance(&coldkey_account_id),
-//             450_000_000_000,
-//             epsilon = 10_000
-//         );
-//
-//         // Check that price has updated to ~24 = (150+450) / (100 - 75)
-//         let exp_price = U96F32::from_num(24.0);
-//         let current_price: U96F32 = U96F32::from_num(SubtensorModule::get_alpha_price(netuid));
-//         assert_abs_diff_eq!(
-//             exp_price.to_num::<f64>(),
-//             current_price.to_num::<f64>(),
-//             epsilon = 0.0001,
-//         );
-//
-//         // Check that event was emitted.
-//         assert!(System::events().iter().any(|e| {
-//             matches!(
-//                 &e.event,
-//                 RuntimeEvent::SubtensorModule(Event::StakeAdded(..))
-//             )
-//         }));
-//         // Check that event was emitted.
-//         assert!(System::events().iter().any(|e| {
-//             matches!(
-//                 &e.event,
-//                 RuntimeEvent::SubtensorModule(Event::AggregatedLimitedStakeAdded(..))
-//             )
-//         }));
-//     });
-// }
-//
-// #[test]
-// fn test_add_stake_limit_aggregate_fail() {
-//     new_test_ext(1).execute_with(|| {
-//         let hotkey_account_id = U256::from(533453);
-//         let coldkey_account_id = U256::from(55453);
-//         let amount = 900_000_000_000;
-//         let limit_price = 6_000_000_000;
-//         // add network
-//         let netuid: u16 = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
-//
-//         assert_ok!(SubtensorModule::add_stake_limit_aggregate(
-//             RuntimeOrigin::signed(coldkey_account_id),
-//             hotkey_account_id,
-//             netuid,
-//             amount,
-//             limit_price,
-//             true
-//         ));
-//
-//         // Check for the block delay
-//         run_to_block_ext(2, true);
-//
-//         // Check that event was not emitted.
-//         assert!(System::events().iter().all(|e| {
-//             !matches!(
-//                 &e.event,
-//                 RuntimeEvent::SubtensorModule(Event::FailedToAddAggregatedLimitedStake(..))
-//             )
-//         }));
-//
-//         // Enable on_finalize code to run
-//         run_to_block_ext(3, true);
-//
-//         // Check that event was emitted.
-//         assert!(System::events().iter().any(|e| {
-//             matches!(
-//                 &e.event,
-//                 RuntimeEvent::SubtensorModule(Event::FailedToAddAggregatedLimitedStake(..))
-//             )
-//         }));
-//     });
-// }
 
 #[test]
 fn test_add_stake_limit_fill_or_kill() {
@@ -5193,149 +4048,6 @@ fn test_remove_stake_limit_ok() {
         );
     });
 }
-//
-// #[test]
-// fn test_remove_stake_limit_aggregate_ok() {
-//     new_test_ext(1).execute_with(|| {
-//         let hotkey_account_id = U256::from(533453);
-//         let coldkey_account_id = U256::from(55453);
-//         let stake_amount = 300_000_000_000;
-//         let unstake_amount = 150_000_000_000;
-//         let fee = DefaultStakingFee::<Test>::get();
-//
-//         // add network
-//         let netuid: u16 = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
-//
-//         // Give the neuron some stake to remove
-//         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
-//             &hotkey_account_id,
-//             &coldkey_account_id,
-//             netuid,
-//             stake_amount,
-//         );
-//         let alpha_before = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
-//             &hotkey_account_id,
-//             &coldkey_account_id,
-//             netuid,
-//         );
-//
-//         // Forse-set alpha in and tao reserve to make price equal 1.5
-//         let tao_reserve: U96F32 = U96F32::from_num(150_000_000_000_u64);
-//         let alpha_in: U96F32 = U96F32::from_num(100_000_000_000_u64);
-//         SubnetTAO::<Test>::insert(netuid, tao_reserve.to_num::<u64>());
-//         SubnetAlphaIn::<Test>::insert(netuid, alpha_in.to_num::<u64>());
-//         let current_price: U96F32 = U96F32::from_num(SubtensorModule::get_alpha_price(netuid));
-//         assert_eq!(current_price, U96F32::from_num(1.5));
-//
-//         // Setup limit price so resulting average price doesn't drop by more than 10% from current price
-//         let limit_price = 1_350_000_000;
-//
-//         // Alpha unstaked = 150 / 1.35 - 100 ~ 11.1
-//         let expected_alpha_reduction = 11_111_111_111;
-//
-//         // Remove stake with slippage safety
-//         assert_ok!(SubtensorModule::remove_stake_limit_aggregate(
-//             RuntimeOrigin::signed(coldkey_account_id),
-//             hotkey_account_id,
-//             netuid,
-//             unstake_amount,
-//             limit_price,
-//             true
-//         ));
-//
-//         // Check for the block delay
-//         run_to_block_ext(2, true);
-//
-//         // Check that event was not emitted.
-//         assert!(System::events().iter().all(|e| {
-//             !matches!(
-//                 &e.event,
-//                 RuntimeEvent::SubtensorModule(Event::AggregatedLimitedStakeRemoved(..))
-//             )
-//         }));
-//
-//         // Enable on_finalize code to run
-//         run_to_block_ext(3, true);
-//
-//         // Check if stake has decreased only by
-//         assert_abs_diff_eq!(
-//             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
-//                 &hotkey_account_id,
-//                 &coldkey_account_id,
-//                 netuid
-//             ),
-//             alpha_before - expected_alpha_reduction - fee,
-//             epsilon = expected_alpha_reduction / 1_000,
-//         );
-//
-//         // Check that event was emitted.
-//         assert!(System::events().iter().any(|e| {
-//             matches!(
-//                 &e.event,
-//                 RuntimeEvent::SubtensorModule(Event::StakeRemoved(..))
-//             )
-//         }));
-//         // Check that event was emitted.
-//         assert!(System::events().iter().any(|e| {
-//             matches!(
-//                 &e.event,
-//                 RuntimeEvent::SubtensorModule(Event::AggregatedLimitedStakeRemoved(..))
-//             )
-//         }));
-//     });
-// }
-//
-// #[test]
-// fn test_remove_stake_limit_aggregate_fail() {
-//     new_test_ext(1).execute_with(|| {
-//         let hotkey_account_id = U256::from(533453);
-//         let coldkey_account_id = U256::from(55453);
-//         let stake_amount = 300_000_000;
-//         let unstake_amount = 150_000_000_000;
-//         let limit_price = 1_350_000_000;
-//         // add network
-//         let netuid: u16 = add_dynamic_network(&hotkey_account_id, &coldkey_account_id);
-//
-//         // Give the neuron some stake to remove
-//         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
-//             &hotkey_account_id,
-//             &coldkey_account_id,
-//             netuid,
-//             stake_amount,
-//         );
-//
-//         assert_ok!(SubtensorModule::remove_stake_limit_aggregate(
-//             RuntimeOrigin::signed(coldkey_account_id),
-//             hotkey_account_id,
-//             netuid,
-//             unstake_amount,
-//             limit_price,
-//             true
-//         ));
-//
-//         // Check for the block delay
-//         run_to_block_ext(2, true);
-//
-//         // Check that event was not emitted.
-//         assert!(System::events().iter().all(|e| {
-//             !matches!(
-//                 &e.event,
-//                 RuntimeEvent::SubtensorModule(Event::FailedToRemoveAggregatedLimitedStake(..))
-//             )
-//         }));
-//
-//         // Enable on_finalize code to run
-//         run_to_block_ext(3, true);
-//
-//         // Check that event was emitted.
-//         assert!(System::events().iter().any(|e| {
-//             matches!(
-//                 &e.event,
-//                 RuntimeEvent::SubtensorModule(Event::FailedToRemoveAggregatedLimitedStake(..))
-//             )
-//         }));
-//     });
-// }
 
 #[test]
 fn test_remove_stake_limit_fill_or_kill() {
@@ -5392,127 +4104,6 @@ fn test_remove_stake_limit_fill_or_kill() {
     });
 }
 
-// #[test]
-// fn test_add_stake_specific() {
-//     new_test_ext(1).execute_with(|| {
-//         let sn_owner_coldkey = U256::from(55453);
-
-//         let hotkey_account_id = U256::from(533453);
-//         let coldkey_account_id = U256::from(55454);
-//         let hotkey_owner_account_id = U256::from(533454);
-
-//         let existing_shares: U64F64 =
-//             U64F64::from_num(161_986_254).saturating_div(U64F64::from_num(u64::MAX));
-//         let existing_stake = 36_711_495_953;
-//         let amount_added = 1_274_280_132;
-
-//         //add network
-//         let netuid: u16 = add_dynamic_network(&sn_owner_coldkey, &sn_owner_coldkey);
-
-//         // Register hotkey on netuid
-//         register_ok_neuron(netuid, hotkey_account_id, hotkey_owner_account_id, 0);
-//         // Check we have zero staked
-//         assert_eq!(
-//             SubtensorModule::get_total_stake_for_hotkey(&hotkey_account_id),
-//             0
-//         );
-
-//         // Set a hotkey pool for the hotkey
-//         let mut hotkey_pool = SubtensorModule::get_alpha_share_pool(hotkey_account_id, netuid);
-//         hotkey_pool.update_value_for_one(&hotkey_owner_account_id, 1234); // Doesn't matter, will be overridden
-
-//         // Adjust the total hotkey stake and shares to match the existing values
-//         TotalHotkeyShares::<Test>::insert(hotkey_account_id, netuid, existing_shares);
-//         TotalHotkeyAlpha::<Test>::insert(hotkey_account_id, netuid, existing_stake);
-
-//         // Make the hotkey a delegate
-//         Delegates::<Test>::insert(hotkey_account_id, 0);
-
-//         // Add stake as new hotkey
-//         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
-//             &hotkey_account_id,
-//             &coldkey_account_id,
-//             netuid,
-//             amount_added,
-//         );
-
-//         // Check the stake and shares are correct
-//         assert!(Alpha::<Test>::get((&hotkey_account_id, &coldkey_account_id, netuid)) > 0);
-//         assert_eq!(
-//             TotalHotkeyAlpha::<Test>::get(hotkey_account_id, netuid),
-//             amount_added + existing_stake
-//         );
-//     });
-// }
-
-// #[test]
-// // RUST_LOG=info cargo test --package pallet-subtensor --lib -- tests::staking::test_add_stake_specific_stake_into_subnet --exact --show-output
-// fn test_add_stake_specific_stake_into_subnet() {
-//     new_test_ext(1).execute_with(|| {
-//         let sn_owner_coldkey = U256::from(55453);
-
-//         let hotkey_account_id = U256::from(533453);
-//         let coldkey_account_id = U256::from(55454);
-//         let hotkey_owner_account_id = U256::from(533454);
-
-//         let existing_shares: U64F64 =
-//             U64F64::from_num(161_986_254).saturating_div(U64F64::from_num(u64::MAX));
-//         let existing_stake = 36_711_495_953;
-
-//         let tao_in = 2_409_892_148_947;
-//         let alpha_in = 15_358_708_513_716;
-
-//         let tao_staked = 200_000_000;
-//         let fee = DefaultStakingFee::<Test>::get();
-
-//         //add network
-//         let netuid: u16 = add_dynamic_network(&sn_owner_coldkey, &sn_owner_coldkey);
-
-//         // Register hotkey on netuid
-//         register_ok_neuron(netuid, hotkey_account_id, hotkey_owner_account_id, 0);
-//         // Check we have zero staked
-//         assert_eq!(
-//             SubtensorModule::get_total_stake_for_hotkey(&hotkey_account_id),
-//             0
-//         );
-
-//         // Set a hotkey pool for the hotkey
-//         let mut hotkey_pool = SubtensorModule::get_alpha_share_pool(hotkey_account_id, netuid);
-//         hotkey_pool.update_value_for_one(&hotkey_owner_account_id, 1234); // Doesn't matter, will be overridden
-
-//         // Adjust the total hotkey stake and shares to match the existing values
-//         TotalHotkeyShares::<Test>::insert(hotkey_account_id, netuid, existing_shares);
-//         TotalHotkeyAlpha::<Test>::insert(hotkey_account_id, netuid, existing_stake);
-
-//         // Make the hotkey a delegate
-//         Delegates::<Test>::insert(hotkey_account_id, 0);
-
-//         // Setup Subnet pool
-//         SubnetAlphaIn::<Test>::insert(netuid, alpha_in);
-//         SubnetTAO::<Test>::insert(netuid, tao_in);
-
-//         // Add stake as new hotkey
-//         SubtensorModule::stake_into_subnet(
-//             &hotkey_account_id,
-//             &coldkey_account_id,
-//             netuid,
-//             tao_staked,
-//             fee,
-//         );
-
-//         // Check the stake and shares are correct
-//         assert!(Alpha::<Test>::get((&hotkey_account_id, &coldkey_account_id, netuid)) > 0);
-//         log::info!(
-//             "Alpha: {}",
-//             Alpha::<Test>::get((&hotkey_account_id, &coldkey_account_id, netuid))
-//         );
-//         log::info!(
-//             "TotalHotkeyAlpha: {}",
-//             TotalHotkeyAlpha::<Test>::get(hotkey_account_id, netuid)
-//         );
-//     });
-// }
-
 #[test]
 // RUST_LOG=info cargo test --package pallet-subtensor --lib -- tests::staking::test_add_stake_specific_stake_into_subnet_fail --exact --show-output
 fn test_add_stake_specific_stake_into_subnet_fail() {
@@ -5906,110 +4497,6 @@ fn test_unstake_all_alpha_works() {
         assert!(new_root > 100_000);
     });
 }
-// #[test]
-// fn test_unstake_all_alpha_aggregate_works() {
-//     new_test_ext(1).execute_with(|| {
-//         let subnet_owner_coldkey = U256::from(1001);
-//         let subnet_owner_hotkey = U256::from(1002);
-//         let coldkey = U256::from(1);
-//         let hotkey = U256::from(2);
-//
-//         let stake_amount = 190_000_000_000; // 190 Alpha
-//
-//         let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
-//         register_ok_neuron(netuid, hotkey, coldkey, 192213123);
-//         // Give the neuron some stake to remove
-//         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
-//             &hotkey,
-//             &coldkey,
-//             netuid,
-//             stake_amount,
-//         );
-//
-//         // Setup the Alpha pool so that removing all the Alpha will keep liq above min
-//         let remaining_tao: I96F32 =
-//             DefaultMinimumPoolLiquidity::<Test>::get().saturating_add(I96F32::from(10_000_000));
-//         let alpha_reserves: I110F18 = I110F18::from(stake_amount + 10_000_000);
-//         let alpha = stake_amount;
-//
-//         let k: I110F18 = I110F18::from_fixed(remaining_tao)
-//             .saturating_mul(alpha_reserves.saturating_add(I110F18::from(alpha)));
-//         let tao_reserves: I110F18 = k.safe_div(alpha_reserves);
-//
-//         SubnetTAO::<Test>::insert(netuid, tao_reserves.to_num::<u64>());
-//         SubnetAlphaIn::<Test>::insert(netuid, alpha_reserves.to_num::<u64>());
-//
-//         // Unstake all alpha to root
-//         assert_ok!(SubtensorModule::unstake_all_alpha_aggregate(
-//             RuntimeOrigin::signed(coldkey),
-//             hotkey,
-//         ));
-//
-//         // Check for the block delay
-//         run_to_block_ext(2, true);
-//
-//         // Check that event was not emitted.
-//         assert!(System::events().iter().all(|e| {
-//             !matches!(
-//                 &e.event,
-//                 RuntimeEvent::SubtensorModule(Event::AggregatedUnstakeAllAlphaSucceeded(..))
-//             )
-//         }));
-//
-//         // Enable on_finalize code to run
-//         run_to_block_ext(3, true);
-//
-//         let new_alpha =
-//             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid);
-//         assert_abs_diff_eq!(new_alpha, 0, epsilon = 1_000,);
-//         let new_root =
-//             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, 0);
-//         assert!(new_root > 100_000);
-//
-//         // Check that event was emitted.
-//         assert!(System::events().iter().any(|e| {
-//             matches!(
-//                 &e.event,
-//                 RuntimeEvent::SubtensorModule(Event::AggregatedUnstakeAllAlphaSucceeded(..))
-//             )
-//         }));
-//     });
-// }
-//
-// #[test]
-// fn test_unstake_all_alpha_aggregate_fails() {
-//     new_test_ext(1).execute_with(|| {
-//         let coldkey = U256::from(1);
-//         let hotkey = U256::from(2);
-//
-//         assert_ok!(SubtensorModule::unstake_all_alpha_aggregate(
-//             RuntimeOrigin::signed(coldkey),
-//             hotkey,
-//         ));
-//
-//         // Check for the block delay
-//         run_to_block_ext(2, true);
-//
-//         // Check that event was not emitted.
-//         assert!(System::events().iter().all(|e| {
-//             !matches!(
-//                 &e.event,
-//                 RuntimeEvent::SubtensorModule(Event::AggregatedUnstakeAllAlphaFailed(..))
-//             )
-//         }));
-//
-//         // Enable on_finalize code to run
-//         run_to_block_ext(3, true);
-//
-//         // Check that event was emitted.
-//         assert!(System::events().iter().any(|e| {
-//             matches!(
-//                 &e.event,
-//                 RuntimeEvent::SubtensorModule(Event::AggregatedUnstakeAllAlphaFailed(..))
-//             )
-//         }));
-//     });
-// }
 
 #[test]
 fn test_unstake_all_works() {
@@ -6058,111 +4545,6 @@ fn test_unstake_all_works() {
     });
 }
 
-// #[test]
-// fn test_unstake_all_aggregate_works() {
-//     new_test_ext(1).execute_with(|| {
-//         let subnet_owner_coldkey = U256::from(1001);
-//         let subnet_owner_hotkey = U256::from(1002);
-//         let coldkey = U256::from(1);
-//         let hotkey = U256::from(2);
-//
-//         let stake_amount = 190_000_000_000; // 190 Alpha
-//
-//         let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
-//         register_ok_neuron(netuid, hotkey, coldkey, 192213123);
-//         // Give the neuron some stake to remove
-//         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
-//             &hotkey,
-//             &coldkey,
-//             netuid,
-//             stake_amount,
-//         );
-//
-//         // Setup the Alpha pool so that removing all the Alpha will keep liq above min
-//         let remaining_tao: I96F32 =
-//             DefaultMinimumPoolLiquidity::<Test>::get().saturating_add(I96F32::from(10_000_000));
-//         let alpha_reserves: I110F18 = I110F18::from(stake_amount + 10_000_000);
-//         let alpha = stake_amount;
-//
-//         let k: I110F18 = I110F18::from_fixed(remaining_tao)
-//             .saturating_mul(alpha_reserves.saturating_add(I110F18::from(alpha)));
-//         let tao_reserves: I110F18 = k.safe_div(alpha_reserves);
-//
-//         SubnetTAO::<Test>::insert(netuid, tao_reserves.to_num::<u64>());
-//         SubnetAlphaIn::<Test>::insert(netuid, alpha_reserves.to_num::<u64>());
-//
-//         // Unstake all alpha to root
-//         assert_ok!(SubtensorModule::unstake_all_aggregate(
-//             RuntimeOrigin::signed(coldkey),
-//             hotkey,
-//         ));
-//
-//         // Check for the block delay
-//         run_to_block_ext(2, true);
-//
-//         // Check that event was not emitted.
-//         assert!(System::events().iter().all(|e| {
-//             !matches!(
-//                 &e.event,
-//                 RuntimeEvent::SubtensorModule(Event::AggregatedUnstakeAllSucceeded(..))
-//             )
-//         }));
-//
-//         // Enable on_finalize code to run
-//         run_to_block_ext(3, true);
-//
-//         let new_alpha =
-//             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid);
-//         assert_abs_diff_eq!(new_alpha, 0, epsilon = 1_000,);
-//         let new_balance = SubtensorModule::get_coldkey_balance(&coldkey);
-//         assert!(new_balance > 100_000);
-//
-//         // Check that event was emitted.
-//         assert!(System::events().iter().any(|e| {
-//             matches!(
-//                 &e.event,
-//                 RuntimeEvent::SubtensorModule(Event::AggregatedUnstakeAllSucceeded(..))
-//             )
-//         }));
-//     });
-// }
-//
-// #[test]
-// fn test_unstake_all_aggregate_fails() {
-//     new_test_ext(1).execute_with(|| {
-//         let coldkey = U256::from(1);
-//         let hotkey = U256::from(2);
-//
-//         // Unstake all alpha to root
-//         assert_ok!(SubtensorModule::unstake_all_aggregate(
-//             RuntimeOrigin::signed(coldkey),
-//             hotkey,
-//         ));
-//
-//         // Check for the block delay
-//         run_to_block_ext(2, true);
-//
-//         // Check that event was not emitted.
-//         assert!(System::events().iter().all(|e| {
-//             !matches!(
-//                 &e.event,
-//                 RuntimeEvent::SubtensorModule(Event::AggregatedUnstakeAllFailed(..))
-//             )
-//         }));
-//
-//         // Enable on_finalize code to run
-//         run_to_block_ext(3, true);
-//
-//         // Check that event was emitted.
-//         assert!(System::events().iter().any(|e| {
-//             matches!(
-//                 &e.event,
-//                 RuntimeEvent::SubtensorModule(Event::AggregatedUnstakeAllFailed(..))
-//             )
-//         }));
-//     });
-// }
-
 #[test]
 fn test_increase_stake_for_hotkey_and_coldkey_on_subnet_adds_to_staking_hotkeys_map() {
     new_test_ext(1).execute_with(|| {

From 1a16adca31c33d7ad8be9b8631c945edcc067895 Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Fri, 6 Jun 2025 15:07:59 +0200
Subject: [PATCH 251/418] bump frontier commit hash

---
 Cargo.lock | 50 +++++++++++++++++++++++++-------------------------
 Cargo.toml | 48 ++++++++++++++++++++++++------------------------
 2 files changed, 49 insertions(+), 49 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index f9a51feefd..c246c94a4d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2861,7 +2861,7 @@ dependencies = [
 [[package]]
 name = "fc-api"
 version = "1.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
+source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
 dependencies = [
  "async-trait",
  "fp-storage",
@@ -2873,7 +2873,7 @@ dependencies = [
 [[package]]
 name = "fc-aura"
 version = "1.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
+source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
 dependencies = [
  "fc-rpc",
  "fp-storage",
@@ -2889,7 +2889,7 @@ dependencies = [
 [[package]]
 name = "fc-consensus"
 version = "2.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
+source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
 dependencies = [
  "async-trait",
  "fp-consensus",
@@ -2905,7 +2905,7 @@ dependencies = [
 [[package]]
 name = "fc-db"
 version = "2.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
+source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
 dependencies = [
  "async-trait",
  "ethereum",
@@ -2935,7 +2935,7 @@ dependencies = [
 [[package]]
 name = "fc-mapping-sync"
 version = "2.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
+source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
 dependencies = [
  "fc-db",
  "fc-storage",
@@ -2958,7 +2958,7 @@ dependencies = [
 [[package]]
 name = "fc-rpc"
 version = "2.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
+source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
 dependencies = [
  "ethereum",
  "ethereum-types 0.15.1",
@@ -3009,7 +3009,7 @@ dependencies = [
 [[package]]
 name = "fc-rpc-core"
 version = "1.1.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
+source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
 dependencies = [
  "ethereum",
  "ethereum-types 0.15.1",
@@ -3024,7 +3024,7 @@ dependencies = [
 [[package]]
 name = "fc-storage"
 version = "1.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
+source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
 dependencies = [
  "ethereum",
  "ethereum-types 0.15.1",
@@ -3217,7 +3217,7 @@ dependencies = [
 [[package]]
 name = "fp-account"
 version = "1.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
+source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
 dependencies = [
  "hex",
  "impl-serde 0.5.0",
@@ -3236,7 +3236,7 @@ dependencies = [
 [[package]]
 name = "fp-consensus"
 version = "2.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
+source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
 dependencies = [
  "ethereum",
  "parity-scale-codec",
@@ -3247,7 +3247,7 @@ dependencies = [
 [[package]]
 name = "fp-ethereum"
 version = "1.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
+source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
 dependencies = [
  "ethereum",
  "ethereum-types 0.15.1",
@@ -3259,7 +3259,7 @@ dependencies = [
 [[package]]
 name = "fp-evm"
 version = "3.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
+source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
 dependencies = [
  "environmental",
  "evm",
@@ -3275,7 +3275,7 @@ dependencies = [
 [[package]]
 name = "fp-rpc"
 version = "3.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
+source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
 dependencies = [
  "ethereum",
  "ethereum-types 0.15.1",
@@ -3291,7 +3291,7 @@ dependencies = [
 [[package]]
 name = "fp-self-contained"
 version = "1.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
+source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
 dependencies = [
  "frame-support",
  "parity-scale-codec",
@@ -3303,7 +3303,7 @@ dependencies = [
 [[package]]
 name = "fp-storage"
 version = "2.0.0"
-source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
+source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
 dependencies = [
  "parity-scale-codec",
  "serde",
@@ -7055,7 +7055,7 @@ dependencies = [
 [[package]]
 name = "pallet-base-fee"
 version = "1.0.0"
-source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
+source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
 dependencies = [
  "fp-evm",
  "frame-support",
@@ -7165,7 +7165,7 @@ dependencies = [
 [[package]]
 name = "pallet-ethereum"
 version = "4.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
+source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
 dependencies = [
  "ethereum",
  "ethereum-types 0.15.1",
@@ -7188,7 +7188,7 @@ dependencies = [
 [[package]]
 name = "pallet-evm"
 version = "6.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
+source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
 dependencies = [
  "cumulus-primitives-storage-weight-reclaim",
  "environmental",
@@ -7212,7 +7212,7 @@ dependencies = [
 [[package]]
 name = "pallet-evm-chain-id"
 version = "1.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
+source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
 dependencies = [
  "frame-support",
  "frame-system",
@@ -7223,7 +7223,7 @@ dependencies = [
 [[package]]
 name = "pallet-evm-precompile-modexp"
 version = "2.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
+source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
 dependencies = [
  "fp-evm",
  "num",
@@ -7232,7 +7232,7 @@ dependencies = [
 [[package]]
 name = "pallet-evm-precompile-sha3fips"
 version = "2.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
+source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
 dependencies = [
  "fp-evm",
  "tiny-keccak",
@@ -7241,7 +7241,7 @@ dependencies = [
 [[package]]
 name = "pallet-evm-precompile-simple"
 version = "2.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
+source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
 dependencies = [
  "fp-evm",
  "ripemd",
@@ -7273,7 +7273,7 @@ dependencies = [
 [[package]]
 name = "pallet-hotfix-sufficients"
 version = "1.0.0"
-source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
+source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
 dependencies = [
  "frame-benchmarking",
  "frame-support",
@@ -8311,7 +8311,7 @@ dependencies = [
 [[package]]
 name = "precompile-utils"
 version = "0.1.0"
-source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
+source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
 dependencies = [
  "environmental",
  "evm",
@@ -8335,7 +8335,7 @@ dependencies = [
 [[package]]
 name = "precompile-utils-macro"
 version = "0.1.0"
-source = "git+https://github.com/opentensor/frontier?rev=07fe5284ea77602526c63250b9cf8daf319581c8#07fe5284ea77602526c63250b9cf8daf319581c8"
+source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
 dependencies = [
  "case",
  "num_enum",
diff --git a/Cargo.toml b/Cargo.toml
index 3cb6010d49..db7cd8dfec 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -182,36 +182,36 @@ sc-network-sync = { git = "https://github.com/paritytech/polkadot-sdk.git", tag
 substrate-prometheus-endpoint = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
 
 # Frontier
-fp-evm = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
-fp-rpc = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
-fp-self-contained = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false, features = [
+fp-evm = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
+fp-rpc = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
+fp-self-contained = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false, features = [
 	"serde",
 ] }
-fp-account = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
-fc-storage = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
-fc-db = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
-fc-consensus = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
-fp-consensus = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
-fp-dynamic-fee = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
-fc-api = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
-fc-rpc = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false, features = [
+fp-account = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
+fc-storage = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
+fc-db = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
+fc-consensus = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
+fp-consensus = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
+fp-dynamic-fee = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
+fc-api = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
+fc-rpc = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false, features = [
 	"rpc-binary-search-estimate",
 ] }
-fc-rpc-core = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
-fc-aura = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
-fc-mapping-sync = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
-precompile-utils = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
+fc-rpc-core = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
+fc-aura = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
+fc-mapping-sync = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
+precompile-utils = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
 
 # Frontier FRAME
-pallet-base-fee = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
-pallet-dynamic-fee = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
-pallet-ethereum = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
-pallet-evm = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
-pallet-evm-chain-id = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
-pallet-evm-precompile-modexp = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
-pallet-evm-precompile-sha3fips = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
-pallet-evm-precompile-simple = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
-pallet-hotfix-sufficients = { git = "https://github.com/opentensor/frontier", rev = "07fe5284ea77602526c63250b9cf8daf319581c8", default-features = false }
+pallet-base-fee = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
+pallet-dynamic-fee = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
+pallet-ethereum = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
+pallet-evm = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
+pallet-evm-chain-id = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
+pallet-evm-precompile-modexp = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
+pallet-evm-precompile-sha3fips = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
+pallet-evm-precompile-simple = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
+pallet-hotfix-sufficients = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
 
 #DRAND
 pallet-drand = { path = "pallets/drand", default-features = false }

From 3f50ae4d4f75b5fc61adaeec5e0e3e0db1ea5d11 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Fri, 6 Jun 2025 16:31:08 +0200
Subject: [PATCH 252/418] Change log level to trace

---
 pallets/swap/src/pallet/impls.rs | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 5e774e7f4c..365003b96a 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -148,26 +148,26 @@ impl<T: Config> SwapStep<T> {
             recalculate_fee = true;
         }
 
-        log::info!("\tAction           : {:?}", self.action);
-        log::info!(
+        log::trace!("\tAction           : {:?}", self.action);
+        log::trace!(
             "\tCurrent Price    : {}",
             self.current_sqrt_price
                 .saturating_mul(self.current_sqrt_price)
         );
-        log::info!(
+        log::trace!(
             "\tTarget Price     : {}",
             self.target_sqrt_price
                 .saturating_mul(self.target_sqrt_price)
         );
-        log::info!(
+        log::trace!(
             "\tLimit Price      : {}",
             self.limit_sqrt_price.saturating_mul(self.limit_sqrt_price)
         );
-        log::info!(
+        log::trace!(
             "\tEdge Price       : {}",
             self.edge_sqrt_price.saturating_mul(self.edge_sqrt_price)
         );
-        log::info!("\tDelta In         : {}", self.delta_in);
+        log::trace!("\tDelta In         : {}", self.delta_in);
 
         // Because on step creation we calculate fee off the total amount, we might need to recalculate it
         // in case if we hit the limit price or the edge price.
@@ -202,7 +202,7 @@ impl<T: Config> SwapStep<T> {
         // Hold the fees
         Pallet::<T>::add_fees(self.netuid, self.order_type, self.fee);
         let delta_out = Pallet::<T>::convert_deltas(self.netuid, self.order_type, self.delta_in);
-        log::info!("\tDelta Out        : {:?}", delta_out);
+        log::trace!("\tDelta Out        : {:?}", delta_out);
 
         // Get current tick
         let current_tick_index = TickIndex::current_bounded::<T>(self.netuid);
@@ -414,13 +414,13 @@ impl<T: Config> Pallet<T> {
         let mut in_acc: u64 = 0;
         let mut fee_acc: u64 = 0;
 
-        log::info!("======== Start Swap ========");
-        log::info!("Amount Remaining: {}", amount_remaining);
+        log::trace!("======== Start Swap ========");
+        log::trace!("Amount Remaining: {}", amount_remaining);
 
         // Swap one tick at a time until we reach one of the stop conditions
         while amount_remaining > 0 {
-            log::info!("\nIteration: {}", iteration_counter);
-            log::info!(
+            log::trace!("\nIteration: {}", iteration_counter);
+            log::trace!(
                 "\tCurrent Liquidity: {}",
                 CurrentLiquidity::<T>::get(netuid)
             );
@@ -453,8 +453,8 @@ impl<T: Config> Pallet<T> {
             );
         }
 
-        log::info!("\nAmount Paid Out: {}", amount_paid_out);
-        log::info!("======== End Swap ========");
+        log::trace!("\nAmount Paid Out: {}", amount_paid_out);
+        log::trace!("======== End Swap ========");
 
         let tao_reserve = T::SubnetInfo::tao_reserve(netuid.into());
         let alpha_reserve = T::SubnetInfo::alpha_reserve(netuid.into());

From 8bcf1f5ebb95e9f94e224726c31c308d2e4d36c3 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Fri, 6 Jun 2025 14:21:06 -0400
Subject: [PATCH 253/418] Use user provided liquidity in reserves for checks

---
 common/src/lib.rs                            |  4 +
 pallets/subtensor/src/lib.rs                 | 28 ++++++-
 pallets/subtensor/src/staking/move_stake.rs  | 12 ++-
 pallets/subtensor/src/staking/stake_utils.rs | 85 +++++++++++++++++---
 pallets/swap-interface/src/lib.rs            |  6 +-
 pallets/swap/src/mock.rs                     |  5 ++
 pallets/swap/src/pallet/impls.rs             | 22 ++---
 pallets/swap/src/pallet/mod.rs               |  8 ++
 pallets/swap/src/pallet/tests.rs             | 72 +++++++----------
 9 files changed, 163 insertions(+), 79 deletions(-)

diff --git a/common/src/lib.rs b/common/src/lib.rs
index ad1648c3ab..c1f59f5e9f 100644
--- a/common/src/lib.rs
+++ b/common/src/lib.rs
@@ -106,6 +106,10 @@ pub trait BalanceOps<AccountId> {
         netuid: NetUid,
         alpha: u64,
     ) -> Result<u64, DispatchError>;
+    fn increase_provided_tao_reserve(netuid: NetUid, tao: u64);
+    fn decrease_provided_tao_reserve(netuid: NetUid, tao: u64);
+    fn increase_provided_alpha_reserve(netuid: NetUid, alpha: u64);
+    fn decrease_provided_alpha_reserve(netuid: NetUid, alpha: u64);
 }
 
 pub mod time {
diff --git a/pallets/subtensor/src/lib.rs b/pallets/subtensor/src/lib.rs
index cc8eac913f..e22335adf0 100644
--- a/pallets/subtensor/src/lib.rs
+++ b/pallets/subtensor/src/lib.rs
@@ -1097,6 +1097,9 @@ pub mod pallet {
     #[pallet::storage] // --- MAP ( netuid ) --> tao_in_subnet | Returns the amount of TAO in the subnet.
     pub type SubnetTAO<T: Config> =
         StorageMap<_, Identity, u16, u64, ValueQuery, DefaultZeroU64<T>>;
+    #[pallet::storage] // --- MAP ( netuid ) --> tao_in_user_subnet | Returns the amount of TAO in the subnet reserve provided by users as liquidity.
+    pub type SubnetTAOProvided<T: Config> =
+        StorageMap<_, Identity, u16, u64, ValueQuery, DefaultZeroU64<T>>;
     #[pallet::storage] // --- MAP ( netuid ) --> alpha_in_emission | Returns the amount of alph in  emission into the pool per block.
     pub type SubnetAlphaInEmission<T: Config> =
         StorageMap<_, Identity, u16, u64, ValueQuery, DefaultZeroU64<T>>;
@@ -1109,7 +1112,12 @@ pub mod pallet {
     #[pallet::storage] // --- MAP ( netuid ) --> alpha_supply_in_pool | Returns the amount of alpha in the pool.
     pub type SubnetAlphaIn<T: Config> =
         StorageMap<_, Identity, u16, u64, ValueQuery, DefaultZeroU64<T>>;
-    #[pallet::storage] // --- MAP ( netuid ) --> alpha_supply_in_subnet | Returns the amount of alpha in the subnet.
+    #[pallet::storage] // --- MAP ( netuid ) --> alpha_supply_user_in_pool | Returns the amount of alpha in the pool provided by users as liquidity.
+    pub type SubnetAlphaInProvided<T: Config> =
+        StorageMap<_, Identity, u16, u64, ValueQuery, DefaultZeroU64<T>>;
+    #[pallet::storage]
+    /// --- MAP ( netuid ) --> alpha_supply_in_subnet | Returns the amount of alpha in the subnet.
+    /// TODO: Deprecate, not accurate and not used in v3 anymore
     pub type SubnetAlphaOut<T: Config> =
         StorageMap<_, Identity, u16, u64, ValueQuery, DefaultZeroU64<T>>;
     #[pallet::storage] // --- MAP ( cold ) --> Vec<hot> | Maps coldkey to hotkeys that stake to it
@@ -2714,10 +2722,12 @@ impl<T: Config + pallet_balances::Config<Balance = u64>>
 {
     fn tao_reserve(netuid: NetUid) -> u64 {
         SubnetTAO::<T>::get(u16::from(netuid))
+            .saturating_add(SubnetTAOProvided::<T>::get(u16::from(netuid)))
     }
 
     fn alpha_reserve(netuid: NetUid) -> u64 {
         SubnetAlphaIn::<T>::get(u16::from(netuid))
+            .saturating_add(SubnetAlphaInProvided::<T>::get(u16::from(netuid)))
     }
 
     fn exists(netuid: NetUid) -> bool {
@@ -2791,6 +2801,22 @@ impl<T: Config + pallet_balances::Config<Balance = u64>>
             alpha,
         ))
     }
+
+    fn increase_provided_tao_reserve(netuid: NetUid, tao: u64) {
+        Self::increase_provided_tao_reserve(netuid, tao);
+    }
+
+    fn decrease_provided_tao_reserve(netuid: NetUid, tao: u64) {
+        Self::decrease_provided_tao_reserve(netuid, tao);
+    }
+
+    fn increase_provided_alpha_reserve(netuid: NetUid, alpha: u64) {
+        Self::increase_provided_alpha_reserve(netuid, alpha);
+    }
+
+    fn decrease_provided_alpha_reserve(netuid: NetUid, alpha: u64) {
+        Self::decrease_provided_alpha_reserve(netuid, alpha);
+    }
 }
 
 /// Enum that defines types of rate limited operations for
diff --git a/pallets/subtensor/src/staking/move_stake.rs b/pallets/subtensor/src/staking/move_stake.rs
index d491b837d3..4872d3d0b1 100644
--- a/pallets/subtensor/src/staking/move_stake.rs
+++ b/pallets/subtensor/src/staking/move_stake.rs
@@ -440,8 +440,10 @@ impl<T: Config> Pallet<T> {
         }
 
         // Corner case: SubnetTAO for any of two subnets is zero
-        let subnet_tao_1 = SubnetTAO::<T>::get(origin_netuid);
-        let subnet_tao_2 = SubnetTAO::<T>::get(destination_netuid);
+        let subnet_tao_1 = SubnetTAO::<T>::get(origin_netuid)
+            .saturating_add(SubnetTAOProvided::<T>::get(origin_netuid));
+        let subnet_tao_2 = SubnetTAO::<T>::get(destination_netuid)
+            .saturating_add(SubnetTAOProvided::<T>::get(destination_netuid));
         if (subnet_tao_1 == 0) || (subnet_tao_2 == 0) {
             return Err(Error::ZeroMaxStakeAmount);
         }
@@ -449,8 +451,10 @@ impl<T: Config> Pallet<T> {
         let subnet_tao_2_float: U64F64 = U64F64::saturating_from_num(subnet_tao_2);
 
         // Corner case: SubnetAlphaIn for any of two subnets is zero
-        let alpha_in_1 = SubnetAlphaIn::<T>::get(origin_netuid);
-        let alpha_in_2 = SubnetAlphaIn::<T>::get(destination_netuid);
+        let alpha_in_1 = SubnetAlphaIn::<T>::get(origin_netuid)
+            .saturating_add(SubnetAlphaInProvided::<T>::get(origin_netuid));
+        let alpha_in_2 = SubnetAlphaIn::<T>::get(destination_netuid)
+            .saturating_add(SubnetAlphaInProvided::<T>::get(destination_netuid));
         if (alpha_in_1 == 0) || (alpha_in_2 == 0) {
             return Err(Error::ZeroMaxStakeAmount);
         }
diff --git a/pallets/subtensor/src/staking/stake_utils.rs b/pallets/subtensor/src/staking/stake_utils.rs
index 6bb321796d..5ccc77ebb0 100644
--- a/pallets/subtensor/src/staking/stake_utils.rs
+++ b/pallets/subtensor/src/staking/stake_utils.rs
@@ -621,16 +621,27 @@ impl<T: Config> Pallet<T> {
             let swap_result =
                 T::SwapInterface::swap(netuid.into(), OrderType::Buy, tao, price_limit, false)?;
 
-            // update Alpha reserves.
-            SubnetAlphaIn::<T>::set(netuid, swap_result.new_alpha_reserve);
+            // Decrease Alpha reserves.
+            Self::decrease_provided_alpha_reserve(
+                netuid.into(),
+                swap_result
+                    .alpha_reserve_delta
+                    .abs()
+                    .try_into()
+                    .unwrap_or(0),
+            );
 
             // Increase Alpha outstanding.
             SubnetAlphaOut::<T>::mutate(netuid, |total| {
                 *total = total.saturating_add(swap_result.amount_paid_out);
             });
 
-            // update Tao reserves.
-            SubnetTAO::<T>::set(netuid, swap_result.new_tao_reserve);
+            // Increase only the protocol TAO reserve. We only use the sum of
+            // (SubnetTAO + SubnetTAOProvided) in tao_reserve(), so it is irrelevant
+            // which one to increase.
+            SubnetTAO::<T>::mutate(netuid, |total| {
+                *total = total.saturating_add(swap_result.tao_reserve_delta as u64);
+            });
 
             // Increase Total Tao reserves.
             TotalStake::<T>::mutate(|total| *total = total.saturating_add(tao));
@@ -648,8 +659,8 @@ impl<T: Config> Pallet<T> {
                 amount_paid_in: tao,
                 amount_paid_out: tao,
                 fee_paid: 0,
-                new_tao_reserve: 0,
-                new_alpha_reserve: 0,
+                tao_reserve_delta: 0,
+                alpha_reserve_delta: 0,
             })
         }
     }
@@ -669,16 +680,24 @@ impl<T: Config> Pallet<T> {
             let swap_result =
                 T::SwapInterface::swap(netuid.into(), OrderType::Sell, alpha, price_limit, false)?;
 
-            // Increase Alpha reserves.
-            SubnetAlphaIn::<T>::set(netuid, swap_result.new_alpha_reserve);
+            // Increase only the protocol Alpha reserve. We only use the sum of
+            // (SubnetAlphaIn + SubnetAlphaInProvided) in alpha_reserve(), so it is irrelevant
+            // which one to increase.
+            SubnetAlphaIn::<T>::mutate(netuid, |total| {
+                *total = total.saturating_add(swap_result.alpha_reserve_delta as u64);
+            });
 
             // Decrease Alpha outstanding.
+            // TODO: Deprecate, not accurate in v3 anymore
             SubnetAlphaOut::<T>::mutate(netuid, |total| {
                 *total = total.saturating_sub(alpha);
             });
 
             // Decrease tao reserves.
-            SubnetTAO::<T>::set(netuid, swap_result.new_tao_reserve);
+            Self::decrease_provided_tao_reserve(
+                netuid.into(),
+                swap_result.tao_reserve_delta.abs().try_into().unwrap_or(0),
+            );
 
             // Reduce total TAO reserves.
             TotalStake::<T>::mutate(|total| {
@@ -698,8 +717,8 @@ impl<T: Config> Pallet<T> {
                 amount_paid_in: alpha,
                 amount_paid_out: alpha,
                 fee_paid: 0,
-                new_tao_reserve: 0,
-                new_alpha_reserve: 0,
+                tao_reserve_delta: 0,
+                alpha_reserve_delta: 0,
             })
         }
     }
@@ -1079,6 +1098,50 @@ impl<T: Config> Pallet<T> {
 
         Ok(())
     }
+
+    pub fn increase_provided_tao_reserve(netuid: NetUid, tao: u64) {
+        let netuid_u16: u16 = netuid.into();
+        SubnetTAOProvided::<T>::mutate(netuid_u16, |total| {
+            *total = total.saturating_add(tao);
+        });
+    }
+
+    pub fn decrease_provided_tao_reserve(netuid: NetUid, tao: u64) {
+        // First, decrease SubnetTAOProvided, then deduct the rest from SubnetTAO
+        let netuid_u16: u16 = netuid.into();
+        let subnet_tao = SubnetTAO::<T>::get(netuid_u16);
+        let subnet_tao_provided = SubnetTAOProvided::<T>::get(netuid_u16);
+        let remainder = subnet_tao_provided.saturating_sub(tao);
+        let carry_over = tao.saturating_sub(subnet_tao_provided);
+        if carry_over == 0 {
+            SubnetTAOProvided::<T>::set(netuid_u16, remainder);
+        } else {
+            SubnetTAOProvided::<T>::set(netuid_u16, 0_u64);
+            SubnetTAO::<T>::set(netuid_u16, subnet_tao.saturating_sub(carry_over));
+        }
+    }
+
+    pub fn increase_provided_alpha_reserve(netuid: NetUid, alpha: u64) {
+        let netuid_u16: u16 = netuid.into();
+        SubnetAlphaInProvided::<T>::mutate(netuid_u16, |total| {
+            *total = total.saturating_add(alpha);
+        });
+    }
+
+    pub fn decrease_provided_alpha_reserve(netuid: NetUid, alpha: u64) {
+        // First, decrease SubnetAlphaInProvided, then deduct the rest from SubnetAlphaIn
+        let netuid_u16: u16 = netuid.into();
+        let subnet_alpha = SubnetAlphaIn::<T>::get(netuid_u16);
+        let subnet_alpha_provided = SubnetAlphaInProvided::<T>::get(netuid_u16);
+        let remainder = subnet_alpha_provided.saturating_sub(alpha);
+        let carry_over = alpha.saturating_sub(subnet_alpha_provided);
+        if carry_over == 0 {
+            SubnetAlphaInProvided::<T>::set(netuid_u16, remainder);
+        } else {
+            SubnetAlphaInProvided::<T>::set(netuid_u16, 0_u64);
+            SubnetAlphaIn::<T>::set(netuid_u16, subnet_alpha.saturating_sub(carry_over));
+        }
+    }
 }
 
 ///////////////////////////////////////////
diff --git a/pallets/swap-interface/src/lib.rs b/pallets/swap-interface/src/lib.rs
index 6d2c080568..07e33d0948 100644
--- a/pallets/swap-interface/src/lib.rs
+++ b/pallets/swap-interface/src/lib.rs
@@ -34,9 +34,9 @@ pub struct SwapResult {
     pub amount_paid_in: u64,
     pub amount_paid_out: u64,
     pub fee_paid: u64,
-    // calculated new tao/alpha reserves
-    pub new_tao_reserve: u64,
-    pub new_alpha_reserve: u64,
+    // For calculation of new tao/alpha reserves
+    pub tao_reserve_delta: i64,
+    pub alpha_reserve_delta: i64,
 }
 
 #[derive(Debug, PartialEq)]
diff --git a/pallets/swap/src/mock.rs b/pallets/swap/src/mock.rs
index cb241d444e..191e756dcc 100644
--- a/pallets/swap/src/mock.rs
+++ b/pallets/swap/src/mock.rs
@@ -156,6 +156,11 @@ impl BalanceOps<AccountId> for MockBalanceOps {
     ) -> Result<u64, DispatchError> {
         Ok(alpha)
     }
+
+    fn increase_provided_tao_reserve(_netuid: NetUid, _tao: u64) {}
+    fn decrease_provided_tao_reserve(_netuid: NetUid, _tao: u64) {}
+    fn increase_provided_alpha_reserve(_netuid: NetUid, _alpha: u64) {}
+    fn decrease_provided_alpha_reserve(_netuid: NetUid, _alpha: u64) {}
 }
 
 impl crate::pallet::Config for Test {
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 5e774e7f4c..d5f0234c70 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -456,25 +456,17 @@ impl<T: Config> Pallet<T> {
         log::info!("\nAmount Paid Out: {}", amount_paid_out);
         log::info!("======== End Swap ========");
 
-        let tao_reserve = T::SubnetInfo::tao_reserve(netuid.into());
-        let alpha_reserve = T::SubnetInfo::alpha_reserve(netuid.into());
-        let (new_tao_reserve, new_alpha_reserve) = match order_type {
-            OrderType::Buy => (
-                tao_reserve.saturating_add(in_acc),
-                alpha_reserve.saturating_sub(amount_paid_out),
-            ),
-            OrderType::Sell => (
-                tao_reserve.saturating_sub(amount_paid_out),
-                alpha_reserve.saturating_add(in_acc),
-            ),
+        let (tao_reserve_delta, alpha_reserve_delta) = match order_type {
+            OrderType::Buy => (in_acc as i64, (amount_paid_out as i64).neg()),
+            OrderType::Sell => ((amount_paid_out as i64).neg(), in_acc as i64),
         };
 
         Ok(SwapResult {
             amount_paid_in: in_acc,
             amount_paid_out,
             fee_paid: fee_acc,
-            new_tao_reserve,
-            new_alpha_reserve,
+            tao_reserve_delta,
+            alpha_reserve_delta,
         })
     }
 
@@ -1140,8 +1132,8 @@ impl<T: Config> SwapHandler<T::AccountId> for Pallet<T> {
                 amount_paid_in: amount,
                 amount_paid_out: amount,
                 fee_paid: 0,
-                new_tao_reserve: 0,
-                new_alpha_reserve: 0,
+                tao_reserve_delta: 0,
+                alpha_reserve_delta: 0,
             }),
         }
     }
diff --git a/pallets/swap/src/pallet/mod.rs b/pallets/swap/src/pallet/mod.rs
index f9cb9f0f36..77239af276 100644
--- a/pallets/swap/src/pallet/mod.rs
+++ b/pallets/swap/src/pallet/mod.rs
@@ -333,6 +333,10 @@ mod pallet {
                 T::BalanceOps::decrease_stake(&coldkey, &hotkey, netuid.into(), alpha)?;
             ensure!(alpha_provided == alpha, Error::<T>::InsufficientBalance);
 
+            // Add provided liquidity to user-provided reserves
+            T::BalanceOps::increase_provided_tao_reserve(netuid.into(), tao_provided);
+            T::BalanceOps::increase_provided_alpha_reserve(netuid.into(), alpha_provided);
+
             // Emit an event
             Self::deposit_event(Event::LiquidityAdded {
                 coldkey,
@@ -383,6 +387,10 @@ mod pallet {
                 result.alpha.saturating_add(result.fee_alpha),
             )?;
 
+            // Remove withdrawn liquidity from user-provided reserves
+            T::BalanceOps::decrease_provided_tao_reserve(netuid.into(), result.tao);
+            T::BalanceOps::decrease_provided_alpha_reserve(netuid.into(), result.alpha);
+
             // Emit an event
             Self::deposit_event(Event::LiquidityRemoved {
                 coldkey,
diff --git a/pallets/swap/src/pallet/tests.rs b/pallets/swap/src/pallet/tests.rs
index d20ada5c84..a186d4a654 100644
--- a/pallets/swap/src/pallet/tests.rs
+++ b/pallets/swap/src/pallet/tests.rs
@@ -701,26 +701,20 @@ fn test_swap_basic() {
                     epsilon = output_amount / 100
                 );
 
-                let (tao_expected, alpha_expected) = match order_type {
-                    OrderType::Buy => (
-                        MockLiquidityProvider::tao_reserve(netuid.into()) + liquidity,
-                        MockLiquidityProvider::alpha_reserve(netuid.into()) - output_amount,
-                    ),
-                    OrderType::Sell => (
-                        MockLiquidityProvider::tao_reserve(netuid.into()) + output_amount,
-                        MockLiquidityProvider::alpha_reserve(netuid.into()) - liquidity,
-                    ),
+                let (tao_delta_expected, alpha_delta_expected) = match order_type {
+                    OrderType::Buy => (liquidity as i64, -(output_amount as i64)),
+                    OrderType::Sell => (-(output_amount as i64), liquidity as i64),
                 };
 
                 assert_abs_diff_eq!(
-                    swap_result.new_alpha_reserve,
-                    alpha_expected,
-                    epsilon = alpha_expected / 100
+                    swap_result.alpha_reserve_delta,
+                    alpha_delta_expected,
+                    epsilon = alpha_delta_expected.abs() / 10
                 );
                 assert_abs_diff_eq!(
-                    swap_result.new_tao_reserve,
-                    tao_expected,
-                    epsilon = tao_expected / 100
+                    swap_result.tao_reserve_delta,
+                    tao_delta_expected,
+                    epsilon = tao_delta_expected.abs() / 10
                 );
 
                 // Check that low and high ticks' fees were updated properly, and liquidity values were not updated
@@ -953,27 +947,19 @@ fn test_swap_single_position() {
                     );
 
                     if order_liquidity_fraction <= 0.001 {
-                        let tao_reserve_f64 = tao_reserve as f64;
-                        let alpha_reserve_f64 = alpha_reserve as f64;
-                        let (tao_expected, alpha_expected) = match order_type {
-                            OrderType::Buy => (
-                                tao_reserve_f64 + order_liquidity,
-                                alpha_reserve_f64 - output_amount,
-                            ),
-                            OrderType::Sell => (
-                                tao_reserve_f64 - output_amount,
-                                alpha_reserve_f64 + order_liquidity,
-                            ),
+                        let (tao_delta_expected, alpha_delta_expected) = match order_type {
+                            OrderType::Buy => (order_liquidity as i64, -(output_amount as i64)),
+                            OrderType::Sell => (-(output_amount as i64), order_liquidity as i64),
                         };
                         assert_abs_diff_eq!(
-                            swap_result.new_alpha_reserve as f64,
-                            alpha_expected,
-                            epsilon = alpha_expected / 10.0
+                            swap_result.alpha_reserve_delta,
+                            alpha_delta_expected,
+                            epsilon = alpha_delta_expected.abs() / 10
                         );
                         assert_abs_diff_eq!(
-                            swap_result.new_tao_reserve as f64,
-                            tao_expected,
-                            epsilon = tao_expected / 10.0
+                            swap_result.tao_reserve_delta,
+                            tao_delta_expected,
+                            epsilon = tao_delta_expected.abs() / 10
                         );
                     }
 
@@ -1190,23 +1176,19 @@ fn test_swap_multiple_positions() {
             assert!(output_amount > 0);
 
             if alpha_reserve > order_liquidity && tao_reserve > order_liquidity {
-                let (tao_expected, alpha_expected) = match order_type {
-                    OrderType::Buy => {
-                        (tao_reserve + order_liquidity, alpha_reserve - output_amount)
-                    }
-                    OrderType::Sell => {
-                        (tao_reserve - output_amount, alpha_reserve + order_liquidity)
-                    }
+                let (tao_delta_expected, alpha_delta_expected) = match order_type {
+                    OrderType::Buy => (order_liquidity as i64, -(output_amount as i64)),
+                    OrderType::Sell => (-(output_amount as i64), order_liquidity as i64),
                 };
                 assert_abs_diff_eq!(
-                    swap_result.new_alpha_reserve,
-                    alpha_expected,
-                    epsilon = alpha_expected / 100
+                    swap_result.alpha_reserve_delta,
+                    alpha_delta_expected,
+                    epsilon = alpha_delta_expected.abs() / 100
                 );
                 assert_abs_diff_eq!(
-                    swap_result.new_tao_reserve,
-                    tao_expected,
-                    epsilon = tao_expected / 100
+                    swap_result.tao_reserve_delta,
+                    tao_delta_expected,
+                    epsilon = tao_delta_expected.abs() / 100
                 );
             }
 

From c5ff21f297e7f738f8b3eaea592ebb85a42a71d3 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Fri, 6 Jun 2025 16:41:30 -0400
Subject: [PATCH 254/418] Fix benchmarks

---
 pallets/subtensor/src/macros/dispatches.rs | 54 +++++++++++-----------
 1 file changed, 27 insertions(+), 27 deletions(-)

diff --git a/pallets/subtensor/src/macros/dispatches.rs b/pallets/subtensor/src/macros/dispatches.rs
index 434291c45d..cd89dd8118 100644
--- a/pallets/subtensor/src/macros/dispatches.rs
+++ b/pallets/subtensor/src/macros/dispatches.rs
@@ -585,9 +585,9 @@ mod dispatches {
         ///  	- Errors stemming from transaction pallet.
         ///
         #[pallet::call_index(2)]
-        #[pallet::weight((Weight::from_parts(151_000_000, 0)
-		.saturating_add(T::DbWeight::get().reads(14))
-		.saturating_add(T::DbWeight::get().writes(10)), DispatchClass::Normal, Pays::No))]
+        #[pallet::weight((Weight::from_parts(345_500_000, 0)
+		.saturating_add(T::DbWeight::get().reads(24))
+		.saturating_add(T::DbWeight::get().writes(13)), DispatchClass::Normal, Pays::No))]
         pub fn add_stake(
             origin: OriginFor<T>,
             hotkey: T::AccountId,
@@ -924,9 +924,9 @@ mod dispatches {
 
         /// User register a new subnetwork via burning token
         #[pallet::call_index(7)]
-        #[pallet::weight((Weight::from_parts(219_400_000, 0)
-		.saturating_add(T::DbWeight::get().reads(33))
-		.saturating_add(T::DbWeight::get().writes(29)), DispatchClass::Normal, Pays::No))]
+        #[pallet::weight((Weight::from_parts(354_400_000, 0)
+		.saturating_add(T::DbWeight::get().reads(47))
+		.saturating_add(T::DbWeight::get().writes(43)), DispatchClass::Normal, Pays::No))]
         pub fn burned_register(
             origin: OriginFor<T>,
             netuid: u16,
@@ -1606,9 +1606,9 @@ mod dispatches {
         /// * `TxRateLimitExceeded`:
         ///     - Thrown if key has hit transaction rate limit
         #[pallet::call_index(84)]
-        #[pallet::weight((Weight::from_parts(68_730_000, 0)
-        .saturating_add(T::DbWeight::get().reads(12))
-        .saturating_add(T::DbWeight::get().writes(6)), DispatchClass::Operational, Pays::No))]
+        #[pallet::weight((Weight::from_parts(369_500_000, 0)
+        .saturating_add(T::DbWeight::get().reads(30))
+        .saturating_add(T::DbWeight::get().writes(15)), DispatchClass::Operational, Pays::No))]
         pub fn unstake_all_alpha(origin: OriginFor<T>, hotkey: T::AccountId) -> DispatchResult {
             Self::do_unstake_all_alpha(origin, hotkey)
         }
@@ -1635,9 +1635,9 @@ mod dispatches {
         ///     - The alpha stake amount to move.
         ///
         #[pallet::call_index(85)]
-        #[pallet::weight((Weight::from_parts(196_600_000, 0)
-        .saturating_add(T::DbWeight::get().reads(17))
-        .saturating_add(T::DbWeight::get().writes(13)), DispatchClass::Operational, Pays::No))]
+        #[pallet::weight((Weight::from_parts(419_500_000, 0)
+        .saturating_add(T::DbWeight::get().reads(29))
+        .saturating_add(T::DbWeight::get().writes(17)), DispatchClass::Operational, Pays::No))]
         pub fn move_stake(
             origin: T::RuntimeOrigin,
             origin_hotkey: T::AccountId,
@@ -1678,9 +1678,9 @@ mod dispatches {
         /// # Events
         /// May emit a `StakeTransferred` event on success.
         #[pallet::call_index(86)]
-        #[pallet::weight((Weight::from_parts(207_300_000, 0)
-        .saturating_add(T::DbWeight::get().reads(16))
-        .saturating_add(T::DbWeight::get().writes(13)), DispatchClass::Operational, Pays::No))]
+        #[pallet::weight((Weight::from_parts(432_600_000, 0)
+        .saturating_add(T::DbWeight::get().reads(28))
+        .saturating_add(T::DbWeight::get().writes(17)), DispatchClass::Operational, Pays::No))]
         pub fn transfer_stake(
             origin: T::RuntimeOrigin,
             destination_coldkey: T::AccountId,
@@ -1720,9 +1720,9 @@ mod dispatches {
         /// May emit a `StakeSwapped` event on success.
         #[pallet::call_index(87)]
         #[pallet::weight((
-            Weight::from_parts(221_600_000, 0)
-            .saturating_add(T::DbWeight::get().reads(25))
-            .saturating_add(T::DbWeight::get().writes(16)),
+            Weight::from_parts(351_300_000, 0)
+            .saturating_add(T::DbWeight::get().reads(29))
+            .saturating_add(T::DbWeight::get().writes(15)),
             DispatchClass::Operational,
             Pays::No
         ))]
@@ -1785,9 +1785,9 @@ mod dispatches {
         ///  	- Errors stemming from transaction pallet.
         ///
         #[pallet::call_index(88)]
-        #[pallet::weight((Weight::from_parts(159_200_000, 0)
-		.saturating_add(T::DbWeight::get().reads(13))
-		.saturating_add(T::DbWeight::get().writes(10)), DispatchClass::Normal, Pays::No))]
+        #[pallet::weight((Weight::from_parts(402_800_000, 0)
+		.saturating_add(T::DbWeight::get().reads(23))
+		.saturating_add(T::DbWeight::get().writes(13)), DispatchClass::Normal, Pays::No))]
         pub fn add_stake_limit(
             origin: OriginFor<T>,
             hotkey: T::AccountId,
@@ -1849,9 +1849,9 @@ mod dispatches {
         /// 	- Thrown if there is not enough stake on the hotkey to withdwraw this amount.
         ///
         #[pallet::call_index(89)]
-        #[pallet::weight((Weight::from_parts(192_600_000, 0)
-		.saturating_add(T::DbWeight::get().reads(18))
-		.saturating_add(T::DbWeight::get().writes(10)), DispatchClass::Normal, Pays::No))]
+        #[pallet::weight((Weight::from_parts(403_800_000, 0)
+		.saturating_add(T::DbWeight::get().reads(27))
+		.saturating_add(T::DbWeight::get().writes(13)), DispatchClass::Normal, Pays::No))]
         pub fn remove_stake_limit(
             origin: OriginFor<T>,
             hotkey: T::AccountId,
@@ -1893,9 +1893,9 @@ mod dispatches {
         /// May emit a `StakeSwapped` event on success.
         #[pallet::call_index(90)]
         #[pallet::weight((
-            Weight::from_parts(232_000_000, 0)
-            .saturating_add(T::DbWeight::get().reads(25))
-            .saturating_add(T::DbWeight::get().writes(16)),
+            Weight::from_parts(426_500_000, 0)
+            .saturating_add(T::DbWeight::get().reads(29))
+            .saturating_add(T::DbWeight::get().writes(15)),
             DispatchClass::Operational,
             Pays::No
         ))]

From 46736d65636e682ef4c9f6c93e54065cc1687e95 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Fri, 6 Jun 2025 16:53:45 -0400
Subject: [PATCH 255/418] Fix test_add_stake_dispatch_info_ok

---
 pallets/subtensor/src/tests/staking.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pallets/subtensor/src/tests/staking.rs b/pallets/subtensor/src/tests/staking.rs
index fb12af9908..8673106726 100644
--- a/pallets/subtensor/src/tests/staking.rs
+++ b/pallets/subtensor/src/tests/staking.rs
@@ -36,7 +36,7 @@ fn test_add_stake_dispatch_info_ok() {
         assert_eq!(
             call.get_dispatch_info(),
             DispatchInfo {
-                weight: frame_support::weights::Weight::from_parts(1_501_000_000, 0),
+                weight: frame_support::weights::Weight::from_parts(2_245_500_000, 0),
                 class: DispatchClass::Normal,
                 pays_fee: Pays::No
             }

From df810af1c61d08446fb57ae23deb4e8ff1736545 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Mon, 9 Jun 2025 18:37:17 +0200
Subject: [PATCH 256/418] Fix pallet-subtensor benchmarks compilation

---
 pallets/subtensor/src/benchmarks.rs | 77 ++++++++++++++---------------
 1 file changed, 38 insertions(+), 39 deletions(-)

diff --git a/pallets/subtensor/src/benchmarks.rs b/pallets/subtensor/src/benchmarks.rs
index 1b61addc91..f1c7fc4625 100644
--- a/pallets/subtensor/src/benchmarks.rs
+++ b/pallets/subtensor/src/benchmarks.rs
@@ -22,7 +22,7 @@ mod pallet_benchmarks {
 
     #[benchmark]
     fn register() {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 1;
         let hotkey: T::AccountId = account("Alice", 0, 1);
         let coldkey: T::AccountId = account("Test", 0, 2);
@@ -49,7 +49,7 @@ mod pallet_benchmarks {
 
     #[benchmark]
     fn set_weights() {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let version_key: u64 = 1;
         let tempo: u16 = 1;
 
@@ -98,7 +98,7 @@ mod pallet_benchmarks {
 
     #[benchmark]
     fn become_delegate() {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 1;
 
         Subtensor::<T>::init_new_network(netuid, tempo);
@@ -125,7 +125,7 @@ mod pallet_benchmarks {
 
     #[benchmark]
     fn add_stake() {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 1;
 
         Subtensor::<T>::init_new_network(netuid, tempo);
@@ -158,7 +158,7 @@ mod pallet_benchmarks {
 
     #[benchmark]
     fn serve_axon() {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let caller: T::AccountId = whitelisted_caller();
         let version: u32 = 2;
         let ip: u128 = 1676056785;
@@ -199,7 +199,7 @@ mod pallet_benchmarks {
 
     #[benchmark]
     fn serve_prometheus() {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let caller: T::AccountId = whitelisted_caller();
         let version: u32 = 2;
         let ip: u128 = 1676056785;
@@ -234,7 +234,7 @@ mod pallet_benchmarks {
 
     #[benchmark]
     fn burned_register() {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let seed: u32 = 1;
         let hotkey: T::AccountId = account("Alice", 0, seed);
         let coldkey: T::AccountId = account("Test", 0, seed);
@@ -252,7 +252,7 @@ mod pallet_benchmarks {
 
     #[benchmark]
     fn root_register() {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let seed: u32 = 1;
         let coldkey: T::AccountId = account("Test", 0, seed);
         let hotkey: T::AccountId = account("Alice", 0, seed);
@@ -294,7 +294,7 @@ mod pallet_benchmarks {
     #[benchmark]
     fn commit_weights() {
         let tempo: u16 = 1;
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let version_key: u64 = 0;
         let uids: Vec<u16> = vec![0];
         let weight_values: Vec<u16> = vec![10];
@@ -339,7 +339,7 @@ mod pallet_benchmarks {
     #[benchmark]
     fn reveal_weights() {
         let tempo: u16 = 0;
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let version_key: u64 = 0;
         let uids: Vec<u16> = vec![0];
         let weight_values: Vec<u16> = vec![10];
@@ -414,7 +414,7 @@ mod pallet_benchmarks {
 
     #[benchmark]
     fn set_childkey_take() {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let coldkey: T::AccountId = account("Cold", 0, 1);
         let hotkey: T::AccountId = account("Hot", 0, 1);
         let take: u16 = 1000;
@@ -447,7 +447,7 @@ mod pallet_benchmarks {
         let old_coldkey: T::AccountId = account("old_coldkey", 0, 0);
         let new_coldkey: T::AccountId = account("new_coldkey", 0, 0);
         let hotkey1: T::AccountId = account("hotkey1", 0, 0);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let swap_cost: u64 = Subtensor::<T>::get_key_swap_cost();
         let free_balance_old: u64 = 12345 + swap_cost;
 
@@ -492,7 +492,7 @@ mod pallet_benchmarks {
     #[benchmark]
     fn batch_reveal_weights() {
         let tempo: u16 = 0;
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let num_commits: usize = 10;
 
         let hotkey: T::AccountId = account("hot", 0, 1);
@@ -564,7 +564,7 @@ mod pallet_benchmarks {
 
     #[benchmark]
     fn recycle_alpha() {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
 
         let coldkey: T::AccountId = account("Test", 0, 1);
         let hotkey: T::AccountId = account("Alice", 0, 1);
@@ -605,7 +605,7 @@ mod pallet_benchmarks {
 
     #[benchmark]
     fn burn_alpha() {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let coldkey: T::AccountId = account("Test", 0, 1);
         let hotkey: T::AccountId = account("Alice", 0, 1);
 
@@ -643,7 +643,7 @@ mod pallet_benchmarks {
 
     #[benchmark]
     fn start_call() {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let coldkey: T::AccountId = account("Test", 0, 1);
         let hotkey: T::AccountId = account("Alice", 0, 1);
 
@@ -680,10 +680,9 @@ mod pallet_benchmarks {
     fn adjust_senate() {
         let coldkey: T::AccountId = whitelisted_caller();
         let hotkey: T::AccountId = account("Alice", 0, 1);
-        let root: u16 = Subtensor::<T>::get_root_netuid();
 
-        Subtensor::<T>::init_new_network(root, 1);
-        Uids::<T>::insert(root, &hotkey, 0u16);
+        Subtensor::<T>::init_new_network(NetUid::ROOT, 1);
+        Uids::<T>::insert(NetUid::ROOT, &hotkey, 0u16);
 
         #[extrinsic_call]
         _(RawOrigin::Signed(coldkey.clone()), hotkey.clone());
@@ -691,7 +690,7 @@ mod pallet_benchmarks {
 
     #[benchmark]
     fn add_stake_limit() {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 1;
         let seed: u32 = 1;
 
@@ -736,7 +735,7 @@ mod pallet_benchmarks {
         let coldkey: T::AccountId = whitelisted_caller();
         let origin: T::AccountId = account("A", 0, 1);
         let destination: T::AccountId = account("B", 0, 2);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
 
         SubtokenEnabled::<T>::insert(netuid, true);
         Subtensor::<T>::init_new_network(netuid, 1);
@@ -783,7 +782,7 @@ mod pallet_benchmarks {
 
     #[benchmark]
     fn remove_stake_limit() {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo: u16 = 1;
         let seed: u32 = 1;
 
@@ -843,8 +842,8 @@ mod pallet_benchmarks {
     fn swap_stake_limit() {
         let coldkey: T::AccountId = whitelisted_caller::<AccountIdOf<T>>();
         let hot: T::AccountId = account("A", 0, 1);
-        let netuid1: u16 = 1;
-        let netuid2: u16 = 2;
+        let netuid1 = NetUid::from(1);
+        let netuid2 = NetUid::from(2);
         let allow: bool = true;
 
         SubtokenEnabled::<T>::insert(netuid1, true);
@@ -905,7 +904,7 @@ mod pallet_benchmarks {
         let coldkey: T::AccountId = whitelisted_caller();
         let dest: T::AccountId = account("B", 0, 2);
         let hot: T::AccountId = account("A", 0, 1);
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
 
         SubtokenEnabled::<T>::insert(netuid, true);
         Subtensor::<T>::init_new_network(netuid, 1);
@@ -954,8 +953,8 @@ mod pallet_benchmarks {
     fn swap_stake() {
         let coldkey: T::AccountId = whitelisted_caller();
         let hot: T::AccountId = account("A", 0, 9);
-        let netuid1: u16 = 1;
-        let netuid2: u16 = 2;
+        let netuid1 = NetUid::from(1);
+        let netuid2 = NetUid::from(2);
 
         SubtokenEnabled::<T>::insert(netuid1, true);
         Subtensor::<T>::init_new_network(netuid1, 1);
@@ -1004,9 +1003,9 @@ mod pallet_benchmarks {
     #[benchmark]
     fn batch_commit_weights() {
         let hotkey: T::AccountId = whitelisted_caller();
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let count: usize = 3;
-        let mut netuids: Vec<Compact<u16>> = Vec::new();
+        let mut netuids: Vec<Compact<NetUid>> = Vec::new();
         let mut hashes: Vec<H256> = Vec::new();
 
         Subtensor::<T>::init_new_network(netuid, 1);
@@ -1041,10 +1040,10 @@ mod pallet_benchmarks {
     #[benchmark]
     fn batch_set_weights() {
         let hotkey: T::AccountId = whitelisted_caller();
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let version: u64 = 1;
         let entries: Vec<(Compact<u16>, Compact<u16>)> = vec![(Compact(0u16), Compact(0u16))];
-        let netuids: Vec<Compact<u16>> = vec![Compact(netuid)];
+        let netuids: Vec<Compact<NetUid>> = vec![Compact(netuid)];
         let weights: Vec<Vec<(Compact<u16>, Compact<u16>)>> = vec![entries.clone()];
         let keys: Vec<Compact<u64>> = vec![Compact(version)];
 
@@ -1073,7 +1072,7 @@ mod pallet_benchmarks {
     #[benchmark]
     fn commit_crv3_weights() {
         let hotkey: T::AccountId = whitelisted_caller();
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let vec_commit: Vec<u8> = vec![0; MAX_CRV3_COMMIT_SIZE_BYTES as usize];
         let commit: BoundedVec<_, _> = vec_commit.try_into().unwrap();
         let round: u64 = 0;
@@ -1134,7 +1133,7 @@ mod pallet_benchmarks {
         let hotkey: T::AccountId = account("Alice", 0, 1);
         let identity: Option<SubnetIdentityOfV2> = None;
 
-        Subtensor::<T>::set_network_registration_allowed(1, true);
+        Subtensor::<T>::set_network_registration_allowed(1.into(), true);
         Subtensor::<T>::set_network_rate_limit(1);
         let amount: u64 = 9_999_999_999_999;
         Subtensor::<T>::add_balance_to_coldkey_account(&coldkey, amount);
@@ -1150,7 +1149,7 @@ mod pallet_benchmarks {
     #[benchmark]
     fn serve_axon_tls() {
         let caller: T::AccountId = whitelisted_caller();
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let version: u32 = 1;
         let ip: u128 = 0xC0A8_0001;
         let port: u16 = 30333;
@@ -1202,14 +1201,14 @@ mod pallet_benchmarks {
         let add = vec![];
 
         Subtensor::<T>::create_account_if_non_existent(&coldkey, &hotkey);
-        Subtensor::<T>::init_new_network(1, 1);
+        Subtensor::<T>::init_new_network(1.into(), 1);
         let deposit: u64 = 1_000_000_000u64.saturating_mul(2);
         Subtensor::<T>::add_balance_to_coldkey_account(&coldkey, deposit);
-        SubtokenEnabled::<T>::insert(1, true);
+        SubtokenEnabled::<T>::insert(NetUid::from(1), true);
 
         assert_ok!(Subtensor::<T>::burned_register(
             RawOrigin::Signed(coldkey.clone()).into(),
-            1,
+            1.into(),
             hotkey.clone()
         ));
 
@@ -1229,7 +1228,7 @@ mod pallet_benchmarks {
     #[benchmark]
     fn set_subnet_identity() {
         let coldkey: T::AccountId = whitelisted_caller();
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let name = b"n".to_vec();
         let repo = vec![];
         let contact = vec![];
@@ -1257,7 +1256,7 @@ mod pallet_benchmarks {
 
     #[benchmark]
     fn set_tao_weights() {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let hotkey: T::AccountId = account("A", 0, 6);
         let dests = vec![0u16];
         let weights = vec![0u16];

From 377552483bba52d94fb3f53d69572182f780b190 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Mon, 9 Jun 2025 19:34:19 +0200
Subject: [PATCH 257/418] Fix admin-utils compilation

---
 Cargo.lock                               |   2 +
 common/Cargo.toml                        |   2 +
 pallets/admin-utils/Cargo.toml           |   2 +
 pallets/admin-utils/src/benchmarking.rs  | 100 ++++++++++----------
 pallets/admin-utils/src/lib.rs           |  79 ++++++++--------
 pallets/admin-utils/src/tests/mock.rs    |   5 +-
 pallets/admin-utils/src/tests/mod.rs     | 111 ++++++++++++-----------
 pallets/subtensor/src/utils/try_state.rs |   2 +-
 8 files changed, 156 insertions(+), 147 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index e1d8f6dc06..f226ce7e53 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6023,6 +6023,7 @@ dependencies = [
  "sp-weights",
  "substrate-fixed",
  "subtensor-macros",
+ "subtensor-runtime-common",
 ]
 
 [[package]]
@@ -11103,6 +11104,7 @@ version = "0.1.0"
 dependencies = [
  "frame-support",
  "parity-scale-codec",
+ "precompile-utils",
  "scale-info",
  "sp-core",
  "sp-runtime",
diff --git a/common/Cargo.toml b/common/Cargo.toml
index 24fc9947df..de9ea00a02 100644
--- a/common/Cargo.toml
+++ b/common/Cargo.toml
@@ -13,6 +13,7 @@ targets = ["x86_64-unknown-linux-gnu"]
 [dependencies]
 codec = { workspace = true }
 frame-support = { workspace = true }
+precompile-utils = { workspace = true }
 scale-info = { workspace = true }
 sp-core = { workspace = true }
 sp-runtime = { workspace = true }
@@ -27,6 +28,7 @@ fast-blocks = []
 std = [
 	"codec/std",
 	"frame-support/std",
+	"precompile-utils/std",
 	"scale-info/std",
 	"sp-core/std",
 	"sp-runtime/std",
diff --git a/pallets/admin-utils/Cargo.toml b/pallets/admin-utils/Cargo.toml
index b3c1410cca..bc1ed21712 100644
--- a/pallets/admin-utils/Cargo.toml
+++ b/pallets/admin-utils/Cargo.toml
@@ -32,6 +32,7 @@ substrate-fixed = { workspace = true }
 pallet-evm-chain-id = { workspace = true }
 pallet-drand = { workspace = true, default-features = false }
 sp-consensus-grandpa = { workspace = true }
+subtensor-runtime-common = { workspace = true }
 
 [dev-dependencies]
 sp-core = { workspace = true }
@@ -67,6 +68,7 @@ std = [
 	"sp-tracing/std",
 	"sp-weights/std",
 	"substrate-fixed/std",
+	"subtensor-runtime-common/std"
 ]
 runtime-benchmarks = [
 	"frame-benchmarking/runtime-benchmarks",
diff --git a/pallets/admin-utils/src/benchmarking.rs b/pallets/admin-utils/src/benchmarking.rs
index 022ea815f9..20d1e10055 100644
--- a/pallets/admin-utils/src/benchmarking.rs
+++ b/pallets/admin-utils/src/benchmarking.rs
@@ -57,183 +57,183 @@ mod benchmarks {
     #[benchmark]
     fn sudo_set_serving_rate_limit() {
         #[extrinsic_call]
-		_(RawOrigin::Root, 1u16/*netuid*/, 100u64/*serving_rate_limit*/)/*sudo_set_serving_rate_limit*/;
+		_(RawOrigin::Root, 1u16.into()/*netuid*/, 100u64/*serving_rate_limit*/)/*sudo_set_serving_rate_limit*/;
     }
 
     #[benchmark]
     fn sudo_set_max_difficulty() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16 /*netuid*/, 1u16 /*tempo*/);
+        pallet_subtensor::Pallet::<T>::init_new_network(1u16.into() /*netuid*/, 1u16 /*tempo*/);
 
         #[extrinsic_call]
-		_(RawOrigin::Root, 1u16/*netuid*/, 10000u64/*max_difficulty*/)/*sudo_set_max_difficulty*/;
+		_(RawOrigin::Root, 1u16.into()/*netuid*/, 10000u64/*max_difficulty*/)/*sudo_set_max_difficulty*/;
     }
 
     #[benchmark]
     fn sudo_set_min_difficulty() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16 /*netuid*/, 1u16 /*tempo*/);
+        pallet_subtensor::Pallet::<T>::init_new_network(1u16.into() /*netuid*/, 1u16 /*tempo*/);
 
         #[extrinsic_call]
-		_(RawOrigin::Root, 1u16/*netuid*/, 1000u64/*min_difficulty*/)/*sudo_set_min_difficulty*/;
+		_(RawOrigin::Root, 1u16.into()/*netuid*/, 1000u64/*min_difficulty*/)/*sudo_set_min_difficulty*/;
     }
 
     #[benchmark]
     fn sudo_set_weights_set_rate_limit() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16 /*netuid*/, 1u16 /*tempo*/);
+        pallet_subtensor::Pallet::<T>::init_new_network(1u16.into() /*netuid*/, 1u16 /*tempo*/);
 
         #[extrinsic_call]
-		_(RawOrigin::Root, 1u16/*netuid*/, 3u64/*rate_limit*/)/*sudo_set_weights_set_rate_limit*/;
+		_(RawOrigin::Root, 1u16.into()/*netuid*/, 3u64/*rate_limit*/)/*sudo_set_weights_set_rate_limit*/;
     }
 
     #[benchmark]
     fn sudo_set_weights_version_key() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16 /*netuid*/, 1u16 /*tempo*/);
+        pallet_subtensor::Pallet::<T>::init_new_network(1u16.into() /*netuid*/, 1u16 /*tempo*/);
 
         #[extrinsic_call]
-		_(RawOrigin::Root, 1u16/*netuid*/, 1u64/*version_key*/)/*sudo_set_weights_version_key*/;
+		_(RawOrigin::Root, 1u16.into()/*netuid*/, 1u64/*version_key*/)/*sudo_set_weights_version_key*/;
     }
 
     #[benchmark]
     fn sudo_set_bonds_moving_average() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16 /*netuid*/, 1u16 /*tempo*/);
+        pallet_subtensor::Pallet::<T>::init_new_network(1u16.into() /*netuid*/, 1u16 /*tempo*/);
 
         #[extrinsic_call]
-		_(RawOrigin::Root, 1u16/*netuid*/, 100u64/*bonds_moving_average*/)/*sudo_set_bonds_moving_average*/;
+		_(RawOrigin::Root, 1u16.into()/*netuid*/, 100u64/*bonds_moving_average*/)/*sudo_set_bonds_moving_average*/;
     }
 
     #[benchmark]
     fn sudo_set_bonds_penalty() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16 /*netuid*/, 1u16 /*tempo*/);
+        pallet_subtensor::Pallet::<T>::init_new_network(1u16.into() /*netuid*/, 1u16 /*tempo*/);
 
         #[extrinsic_call]
-        _(RawOrigin::Root, 1u16/*netuid*/, 100u16/*bonds_penalty*/)/*sudo_set_bonds_penalty*/;
+        _(RawOrigin::Root, 1u16.into()/*netuid*/, 100u16/*bonds_penalty*/)/*sudo_set_bonds_penalty*/;
     }
 
     #[benchmark]
     fn sudo_set_max_allowed_validators() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16 /*netuid*/, 1u16 /*tempo*/);
+        pallet_subtensor::Pallet::<T>::init_new_network(1u16.into() /*netuid*/, 1u16 /*tempo*/);
 
         #[extrinsic_call]
-		_(RawOrigin::Root, 1u16/*netuid*/, 10u16/*max_allowed_validators*/)/*sudo_set_max_allowed_validators*/;
+		_(RawOrigin::Root, 1u16.into()/*netuid*/, 10u16/*max_allowed_validators*/)/*sudo_set_max_allowed_validators*/;
     }
 
     #[benchmark]
     fn sudo_set_difficulty() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16 /*netuid*/, 1u16 /*tempo*/);
+        pallet_subtensor::Pallet::<T>::init_new_network(1u16.into() /*netuid*/, 1u16 /*tempo*/);
 
         #[extrinsic_call]
-		_(RawOrigin::Root, 1u16/*netuid*/, 1200000u64/*difficulty*/)/*sudo_set_difficulty*/;
+		_(RawOrigin::Root, 1u16.into()/*netuid*/, 1200000u64/*difficulty*/)/*sudo_set_difficulty*/;
     }
 
     #[benchmark]
     fn sudo_set_adjustment_interval() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16 /*netuid*/, 1u16 /*tempo*/);
+        pallet_subtensor::Pallet::<T>::init_new_network(1u16.into() /*netuid*/, 1u16 /*tempo*/);
 
         #[extrinsic_call]
-		_(RawOrigin::Root, 1u16/*netuid*/, 12u16/*adjustment_interval*/)/*sudo_set_adjustment_interval*/;
+		_(RawOrigin::Root, 1u16.into()/*netuid*/, 12u16/*adjustment_interval*/)/*sudo_set_adjustment_interval*/;
     }
 
     #[benchmark]
     fn sudo_set_target_registrations_per_interval() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16 /*netuid*/, 1u16 /*tempo*/);
+        pallet_subtensor::Pallet::<T>::init_new_network(1u16.into() /*netuid*/, 1u16 /*tempo*/);
 
         #[extrinsic_call]
-		_(RawOrigin::Root, 1u16/*netuid*/, 300u16/*target_registrations*/)/*sudo_set_target_registrations_per_interval*/;
+		_(RawOrigin::Root, 1u16.into()/*netuid*/, 300u16/*target_registrations*/)/*sudo_set_target_registrations_per_interval*/;
     }
 
     #[benchmark]
     fn sudo_set_activity_cutoff() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16 /*netuid*/, 1u16 /*tempo*/);
+        pallet_subtensor::Pallet::<T>::init_new_network(1u16.into() /*netuid*/, 1u16 /*tempo*/);
 
         #[extrinsic_call]
-		_(RawOrigin::Root, 1u16/*netuid*/, 361u16/*activity_cutoff*/)/*sudo_set_activity_cutoff*/;
+		_(RawOrigin::Root, 1u16.into()/*netuid*/, 361u16/*activity_cutoff*/)/*sudo_set_activity_cutoff*/;
     }
 
     #[benchmark]
     fn sudo_set_rho() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16 /*netuid*/, 1u16 /*tempo*/);
+        pallet_subtensor::Pallet::<T>::init_new_network(1u16.into() /*netuid*/, 1u16 /*tempo*/);
 
         #[extrinsic_call]
-		_(RawOrigin::Root, 1u16/*netuid*/, 300u16/*rho*/)/*sudo_set_rho*/;
+		_(RawOrigin::Root, 1u16.into()/*netuid*/, 300u16/*rho*/)/*sudo_set_rho*/;
     }
 
     #[benchmark]
     fn sudo_set_kappa() {
         pallet_subtensor::Pallet::<T>::init_new_network(
-            1u16, /*netuid*/
+            1u16.into(), /*netuid*/
             1u16, /*sudo_tempo*/
         );
 
         #[extrinsic_call]
-		_(RawOrigin::Root, 1u16/*netuid*/, 3u16/*kappa*/)/*set_kappa*/;
+		_(RawOrigin::Root, 1u16.into()/*netuid*/, 3u16/*kappa*/)/*set_kappa*/;
     }
 
     #[benchmark]
     fn sudo_set_max_allowed_uids() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16 /*netuid*/, 1u16 /*tempo*/);
+        pallet_subtensor::Pallet::<T>::init_new_network(1u16.into() /*netuid*/, 1u16 /*tempo*/);
 
         #[extrinsic_call]
-		_(RawOrigin::Root, 1u16/*netuid*/, 4097u16/*max_allowed_uids*/)/*sudo_set_max_allowed_uids*/;
+		_(RawOrigin::Root, 1u16.into()/*netuid*/, 4097u16/*max_allowed_uids*/)/*sudo_set_max_allowed_uids*/;
     }
 
     #[benchmark]
     fn sudo_set_min_allowed_weights() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16 /*netuid*/, 1u16 /*tempo*/);
+        pallet_subtensor::Pallet::<T>::init_new_network(1u16.into() /*netuid*/, 1u16 /*tempo*/);
 
         #[extrinsic_call]
-		_(RawOrigin::Root, 1u16/*netuid*/, 10u16/*max_allowed_uids*/)/*sudo_set_min_allowed_weights*/;
+		_(RawOrigin::Root, 1u16.into()/*netuid*/, 10u16/*max_allowed_uids*/)/*sudo_set_min_allowed_weights*/;
     }
 
     #[benchmark]
     fn sudo_set_immunity_period() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16 /*netuid*/, 1u16 /*tempo*/);
+        pallet_subtensor::Pallet::<T>::init_new_network(1u16.into() /*netuid*/, 1u16 /*tempo*/);
 
         #[extrinsic_call]
-		_(RawOrigin::Root, 1u16/*netuid*/, 100u16/*immunity_period*/)/*sudo_set_immunity_period*/;
+		_(RawOrigin::Root, 1u16.into()/*netuid*/, 100u16/*immunity_period*/)/*sudo_set_immunity_period*/;
     }
 
     #[benchmark]
     fn sudo_set_max_weight_limit() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16 /*netuid*/, 1u16 /*tempo*/);
+        pallet_subtensor::Pallet::<T>::init_new_network(1u16.into() /*netuid*/, 1u16 /*tempo*/);
 
         #[extrinsic_call]
-		_(RawOrigin::Root, 1u16/*netuid*/, 100u16/*max_weight_limit*/)/*sudo_set_max_weight_limit*/;
+		_(RawOrigin::Root, 1u16.into()/*netuid*/, 100u16/*max_weight_limit*/)/*sudo_set_max_weight_limit*/;
     }
 
     #[benchmark]
     fn sudo_set_max_registrations_per_block() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16 /*netuid*/, 1u16 /*tempo*/);
+        pallet_subtensor::Pallet::<T>::init_new_network(1u16.into() /*netuid*/, 1u16 /*tempo*/);
 
         #[extrinsic_call]
-		_(RawOrigin::Root, 1u16/*netuid*/, 100u16/*max_registrations*/)/*sudo_set_max_registrations_per_block*/;
+		_(RawOrigin::Root, 1u16.into()/*netuid*/, 100u16/*max_registrations*/)/*sudo_set_max_registrations_per_block*/;
     }
 
     #[benchmark]
     fn sudo_set_max_burn() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16 /*netuid*/, 1u16 /*tempo*/);
+        pallet_subtensor::Pallet::<T>::init_new_network(1u16.into() /*netuid*/, 1u16 /*tempo*/);
 
         #[extrinsic_call]
-		_(RawOrigin::Root, 1u16/*netuid*/, 10u64/*max_burn*/)/*sudo_set_max_burn*/;
+		_(RawOrigin::Root, 1u16.into()/*netuid*/, 10u64/*max_burn*/)/*sudo_set_max_burn*/;
     }
 
     #[benchmark]
     fn sudo_set_min_burn() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16 /*netuid*/, 1u16 /*tempo*/);
+        pallet_subtensor::Pallet::<T>::init_new_network(1u16.into() /*netuid*/, 1u16 /*tempo*/);
 
         #[extrinsic_call]
-		_(RawOrigin::Root, 1u16/*netuid*/, 10u64/*min_burn*/)/*sudo_set_min_burn*/;
+		_(RawOrigin::Root, 1u16.into()/*netuid*/, 10u64/*min_burn*/)/*sudo_set_min_burn*/;
     }
 
     #[benchmark]
     fn sudo_set_network_registration_allowed() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16 /*netuid*/, 1u16 /*tempo*/);
+        pallet_subtensor::Pallet::<T>::init_new_network(1u16.into() /*netuid*/, 1u16 /*tempo*/);
 
         #[extrinsic_call]
-		_(RawOrigin::Root, 1u16/*netuid*/, true/*registration_allowed*/)/*sudo_set_network_registration_allowed*/;
+		_(RawOrigin::Root, 1u16.into()/*netuid*/, true/*registration_allowed*/)/*sudo_set_network_registration_allowed*/;
     }
 
     /*
         benchmark_sudo_set_tempo {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let tempo_default: u16 = 1; <------- unused?
         let tempo: u16 = 15;
         let modality: u16 = 0;
@@ -244,32 +244,32 @@ mod benchmarks {
     */
     #[benchmark]
     fn sudo_set_tempo() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16 /*netuid*/, 1u16 /*tempo*/);
+        pallet_subtensor::Pallet::<T>::init_new_network(1u16.into() /*netuid*/, 1u16 /*tempo*/);
 
         #[extrinsic_call]
-		_(RawOrigin::Root, 1u16/*netuid*/, 1u16/*tempo*/)/*sudo_set_tempo*/;
+		_(RawOrigin::Root, 1u16.into()/*netuid*/, 1u16/*tempo*/)/*sudo_set_tempo*/;
     }
 
     #[benchmark]
     fn sudo_set_commit_reveal_weights_interval() {
         pallet_subtensor::Pallet::<T>::init_new_network(
-            1u16, /*netuid*/
+            1u16.into(), /*netuid*/
             1u16, /*sudo_tempo*/
         );
 
         #[extrinsic_call]
-		_(RawOrigin::Root, 1u16/*netuid*/, 3u64/*interval*/)/*sudo_set_commit_reveal_weights_interval()*/;
+		_(RawOrigin::Root, 1u16.into()/*netuid*/, 3u64/*interval*/)/*sudo_set_commit_reveal_weights_interval()*/;
     }
 
     #[benchmark]
     fn sudo_set_commit_reveal_weights_enabled() {
         pallet_subtensor::Pallet::<T>::init_new_network(
-            1u16, /*netuid*/
+            1u16.into(), /*netuid*/
             1u16, /*sudo_tempo*/
         );
 
         #[extrinsic_call]
-		_(RawOrigin::Root, 1u16/*netuid*/, true/*enabled*/)/*set_commit_reveal_weights_enabled*/;
+		_(RawOrigin::Root, 1u16.into()/*netuid*/, true/*enabled*/)/*set_commit_reveal_weights_enabled*/;
     }
 
     //impl_benchmark_test_suite!(AdminUtils, crate::mock::new_test_ext(), crate::mock::Test);
diff --git a/pallets/admin-utils/src/lib.rs b/pallets/admin-utils/src/lib.rs
index 2b41539816..2b9218a7fb 100644
--- a/pallets/admin-utils/src/lib.rs
+++ b/pallets/admin-utils/src/lib.rs
@@ -31,6 +31,7 @@ pub mod pallet {
     use pallet_subtensor::utils::rate_limiting::TransactionType;
     use sp_runtime::BoundedVec;
     use substrate_fixed::types::I96F32;
+	use subtensor_runtime_common::NetUid;
 
     /// The main data structure of the module.
     #[pallet::pallet]
@@ -80,7 +81,7 @@ pub mod pallet {
         /// Event emitted when the Yuma3 enable is toggled.
         Yuma3EnableToggled {
             /// The network identifier.
-            netuid: u16,
+            netuid: NetUid,
             /// Indicates if the Yuma3 enable was enabled or disabled.
             enabled: bool,
         },
@@ -191,7 +192,7 @@ pub mod pallet {
         .saturating_add(T::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_serving_rate_limit(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             serving_rate_limit: u64,
         ) -> DispatchResult {
             pallet_subtensor::Pallet::<T>::ensure_subnet_owner_or_root(origin, netuid)?;
@@ -213,7 +214,7 @@ pub mod pallet {
         .saturating_add(T::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_min_difficulty(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             min_difficulty: u64,
         ) -> DispatchResult {
             ensure_root(origin)?;
@@ -240,7 +241,7 @@ pub mod pallet {
         .saturating_add(T::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_max_difficulty(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             max_difficulty: u64,
         ) -> DispatchResult {
             pallet_subtensor::Pallet::<T>::ensure_subnet_owner_or_root(origin, netuid)?;
@@ -267,7 +268,7 @@ pub mod pallet {
         .saturating_add(T::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_weights_version_key(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             weights_version_key: u64,
         ) -> DispatchResult {
             pallet_subtensor::Pallet::<T>::ensure_subnet_owner_or_root(origin.clone(), netuid)?;
@@ -317,7 +318,7 @@ pub mod pallet {
         .saturating_add(T::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_weights_set_rate_limit(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             weights_set_rate_limit: u64,
         ) -> DispatchResult {
             ensure_root(origin)?;
@@ -347,7 +348,7 @@ pub mod pallet {
         .saturating_add(T::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_adjustment_interval(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             adjustment_interval: u16,
         ) -> DispatchResult {
             ensure_root(origin)?;
@@ -378,7 +379,7 @@ pub mod pallet {
         ))]
         pub fn sudo_set_adjustment_alpha(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             adjustment_alpha: u64,
         ) -> DispatchResult {
             pallet_subtensor::Pallet::<T>::ensure_subnet_owner_or_root(origin, netuid)?;
@@ -404,7 +405,7 @@ pub mod pallet {
         .saturating_add(T::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_max_weight_limit(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             max_weight_limit: u16,
         ) -> DispatchResult {
             pallet_subtensor::Pallet::<T>::ensure_subnet_owner_or_root(origin, netuid)?;
@@ -431,7 +432,7 @@ pub mod pallet {
         .saturating_add(T::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_immunity_period(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             immunity_period: u16,
         ) -> DispatchResult {
             pallet_subtensor::Pallet::<T>::ensure_subnet_owner_or_root(origin, netuid)?;
@@ -458,7 +459,7 @@ pub mod pallet {
         .saturating_add(T::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_min_allowed_weights(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             min_allowed_weights: u16,
         ) -> DispatchResult {
             pallet_subtensor::Pallet::<T>::ensure_subnet_owner_or_root(origin, netuid)?;
@@ -485,7 +486,7 @@ pub mod pallet {
         .saturating_add(T::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_max_allowed_uids(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             max_allowed_uids: u16,
         ) -> DispatchResult {
             ensure_root(origin)?;
@@ -513,7 +514,7 @@ pub mod pallet {
         #[pallet::weight(Weight::from_parts(19_590_000, 0)
         .saturating_add(T::DbWeight::get().reads(1_u64))
         .saturating_add(T::DbWeight::get().writes(1_u64)))]
-        pub fn sudo_set_kappa(origin: OriginFor<T>, netuid: u16, kappa: u16) -> DispatchResult {
+        pub fn sudo_set_kappa(origin: OriginFor<T>, netuid: NetUid, kappa: u16) -> DispatchResult {
             pallet_subtensor::Pallet::<T>::ensure_subnet_owner_or_root(origin, netuid)?;
 
             ensure!(
@@ -532,7 +533,7 @@ pub mod pallet {
         #[pallet::weight(Weight::from_parts(16_420_000, 0)
         .saturating_add(T::DbWeight::get().reads(1_u64))
         .saturating_add(T::DbWeight::get().writes(1_u64)))]
-        pub fn sudo_set_rho(origin: OriginFor<T>, netuid: u16, rho: u16) -> DispatchResult {
+        pub fn sudo_set_rho(origin: OriginFor<T>, netuid: NetUid, rho: u16) -> DispatchResult {
             pallet_subtensor::Pallet::<T>::ensure_subnet_owner_or_root(origin, netuid)?;
 
             ensure!(
@@ -553,7 +554,7 @@ pub mod pallet {
         .saturating_add(T::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_activity_cutoff(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             activity_cutoff: u16,
         ) -> DispatchResult {
             pallet_subtensor::Pallet::<T>::ensure_subnet_owner_or_root(origin, netuid)?;
@@ -590,7 +591,7 @@ pub mod pallet {
 		))]
         pub fn sudo_set_network_registration_allowed(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             registration_allowed: bool,
         ) -> DispatchResult {
             pallet_subtensor::Pallet::<T>::ensure_subnet_owner_or_root(origin, netuid)?;
@@ -618,7 +619,7 @@ pub mod pallet {
 		))]
         pub fn sudo_set_network_pow_registration_allowed(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             registration_allowed: bool,
         ) -> DispatchResult {
             pallet_subtensor::Pallet::<T>::ensure_subnet_owner_or_root(origin, netuid)?;
@@ -643,7 +644,7 @@ pub mod pallet {
         .saturating_add(T::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_target_registrations_per_interval(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             target_registrations_per_interval: u16,
         ) -> DispatchResult {
             ensure_root(origin)?;
@@ -673,7 +674,7 @@ pub mod pallet {
         .saturating_add(T::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_min_burn(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             min_burn: u64,
         ) -> DispatchResult {
             ensure_root(origin)?;
@@ -700,7 +701,7 @@ pub mod pallet {
         .saturating_add(T::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_max_burn(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             max_burn: u64,
         ) -> DispatchResult {
             ensure_root(origin)?;
@@ -727,7 +728,7 @@ pub mod pallet {
         .saturating_add(T::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_difficulty(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             difficulty: u64,
         ) -> DispatchResult {
             ensure_root(origin)?;
@@ -753,7 +754,7 @@ pub mod pallet {
         .saturating_add(T::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_max_allowed_validators(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             max_allowed_validators: u16,
         ) -> DispatchResult {
             ensure_root(origin)?;
@@ -788,7 +789,7 @@ pub mod pallet {
         .saturating_add(T::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_bonds_moving_average(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             bonds_moving_average: u64,
         ) -> DispatchResult {
             pallet_subtensor::Pallet::<T>::ensure_subnet_owner_or_root(origin.clone(), netuid)?;
@@ -822,7 +823,7 @@ pub mod pallet {
         .saturating_add(T::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_bonds_penalty(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             bonds_penalty: u16,
         ) -> DispatchResult {
             pallet_subtensor::Pallet::<T>::ensure_subnet_owner_or_root(origin, netuid)?;
@@ -849,7 +850,7 @@ pub mod pallet {
         .saturating_add(T::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_max_registrations_per_block(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             max_registrations_per_block: u16,
         ) -> DispatchResult {
             ensure_root(origin)?;
@@ -920,7 +921,7 @@ pub mod pallet {
         #[pallet::weight(Weight::from_parts(19_900_000, 0)
         .saturating_add(T::DbWeight::get().reads(1_u64))
         .saturating_add(T::DbWeight::get().writes(1_u64)))]
-        pub fn sudo_set_tempo(origin: OriginFor<T>, netuid: u16, tempo: u16) -> DispatchResult {
+        pub fn sudo_set_tempo(origin: OriginFor<T>, netuid: NetUid, tempo: u16) -> DispatchResult {
             ensure_root(origin)?;
             ensure!(
                 pallet_subtensor::Pallet::<T>::if_subnet_exist(netuid),
@@ -1038,7 +1039,7 @@ pub mod pallet {
         #[pallet::weight((0, DispatchClass::Operational, Pays::No))]
         pub fn sudo_set_rao_recycled(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             rao_recycled: u64,
         ) -> DispatchResult {
             ensure_root(origin)?;
@@ -1142,7 +1143,7 @@ pub mod pallet {
         .saturating_add(T::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_commit_reveal_weights_enabled(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             enabled: bool,
         ) -> DispatchResult {
             pallet_subtensor::Pallet::<T>::ensure_subnet_owner_or_root(origin, netuid)?;
@@ -1170,7 +1171,7 @@ pub mod pallet {
         #[pallet::weight((0, DispatchClass::Operational, Pays::No))]
         pub fn sudo_set_liquid_alpha_enabled(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             enabled: bool,
         ) -> DispatchResult {
             pallet_subtensor::Pallet::<T>::ensure_subnet_owner_or_root(origin, netuid)?;
@@ -1188,7 +1189,7 @@ pub mod pallet {
         #[pallet::weight((0, DispatchClass::Operational, Pays::No))]
         pub fn sudo_set_alpha_values(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             alpha_low: u16,
             alpha_high: u16,
         ) -> DispatchResult {
@@ -1246,7 +1247,7 @@ pub mod pallet {
         #[pallet::weight((0, DispatchClass::Operational, Pays::No))]
         pub fn sudo_set_network_max_stake(
             origin: OriginFor<T>,
-            _netuid: u16,
+            _netuid: NetUid,
             _max_stake: u64,
         ) -> DispatchResult {
             // Ensure the call is made by the root account
@@ -1343,7 +1344,7 @@ pub mod pallet {
         .saturating_add(T::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_commit_reveal_weights_interval(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             interval: u64,
         ) -> DispatchResult {
             pallet_subtensor::Pallet::<T>::ensure_subnet_owner_or_root(origin, netuid)?;
@@ -1428,7 +1429,7 @@ pub mod pallet {
         #[pallet::weight((0, DispatchClass::Operational, Pays::No))]
         pub fn sudo_set_toggle_transfer(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             toggle: bool,
         ) -> DispatchResult {
             pallet_subtensor::Pallet::<T>::ensure_subnet_owner_or_root(origin, netuid)?;
@@ -1502,7 +1503,7 @@ pub mod pallet {
         #[pallet::weight((0, DispatchClass::Operational, Pays::No))]
         pub fn sudo_set_subnet_owner_hotkey(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             hotkey: T::AccountId,
         ) -> DispatchResult {
             pallet_subtensor::Pallet::<T>::ensure_subnet_owner(origin.clone(), netuid)?;
@@ -1531,7 +1532,7 @@ pub mod pallet {
         #[pallet::weight((0, DispatchClass::Operational, Pays::No))]
         pub fn sudo_set_ema_price_halving_period(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             ema_halving: u64,
         ) -> DispatchResult {
             ensure_root(origin)?;
@@ -1560,7 +1561,7 @@ pub mod pallet {
         #[pallet::weight((0, DispatchClass::Operational, Pays::No))]
         pub fn sudo_set_alpha_sigmoid_steepness(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             steepness: u16,
         ) -> DispatchResult {
             ensure_root(origin)?;
@@ -1587,7 +1588,7 @@ pub mod pallet {
         #[pallet::weight((0, DispatchClass::Operational, Pays::No))]
         pub fn sudo_set_yuma3_enabled(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             enabled: bool,
         ) -> DispatchResult {
             pallet_subtensor::Pallet::<T>::ensure_subnet_owner_or_root(origin, netuid)?;
@@ -1636,7 +1637,7 @@ pub mod pallet {
         #[pallet::weight((0, DispatchClass::Operational, Pays::No))]
         pub fn sudo_set_sn_owner_hotkey(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             hotkey: T::AccountId,
         ) -> DispatchResult {
             pallet_subtensor::Pallet::<T>::do_set_sn_owner_hotkey(origin, netuid, &hotkey)
@@ -1658,7 +1659,7 @@ pub mod pallet {
         #[pallet::weight((0, DispatchClass::Operational, Pays::No))]
         pub fn sudo_set_subtoken_enabled(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             subtoken_enabled: bool,
         ) -> DispatchResult {
             ensure_root(origin)?;
diff --git a/pallets/admin-utils/src/tests/mock.rs b/pallets/admin-utils/src/tests/mock.rs
index 960348cecd..830c659c42 100644
--- a/pallets/admin-utils/src/tests/mock.rs
+++ b/pallets/admin-utils/src/tests/mock.rs
@@ -18,6 +18,7 @@ use sp_runtime::{
 };
 use sp_std::cmp::Ordering;
 use sp_weights::Weight;
+use subtensor_runtime_common::NetUid;
 
 type Block = frame_system::mocking::MockBlock<Test>;
 
@@ -412,7 +413,7 @@ pub(crate) fn run_to_block(n: u64) {
 
 #[allow(dead_code)]
 pub fn register_ok_neuron(
-    netuid: u16,
+    netuid: NetUid,
     hotkey_account_id: U256,
     coldkey_account_id: U256,
     start_nonce: u64,
@@ -443,7 +444,7 @@ pub fn register_ok_neuron(
 }
 
 #[allow(dead_code)]
-pub fn add_network(netuid: u16, tempo: u16) {
+pub fn add_network(netuid: NetUid, tempo: u16) {
     SubtensorModule::init_new_network(netuid, tempo);
     SubtensorModule::set_network_registration_allowed(netuid, true);
     SubtensorModule::set_network_pow_registration_allowed(netuid, true);
diff --git a/pallets/admin-utils/src/tests/mod.rs b/pallets/admin-utils/src/tests/mod.rs
index bb813ce117..07042b3d70 100644
--- a/pallets/admin-utils/src/tests/mod.rs
+++ b/pallets/admin-utils/src/tests/mod.rs
@@ -11,6 +11,7 @@ use pallet_subtensor::Event;
 use sp_consensus_grandpa::AuthorityId as GrandpaId;
 use sp_core::{Pair, U256, ed25519};
 use substrate_fixed::types::I96F32;
+use subtensor_runtime_common::NetUid;
 
 use crate::Error;
 use crate::pallet::PrecompileEnable;
@@ -42,7 +43,7 @@ fn test_sudo_set_default_take() {
 #[test]
 fn test_sudo_set_serving_rate_limit() {
     new_test_ext().execute_with(|| {
-        let netuid: u16 = 3;
+        let netuid = NetUid::from(3);
         let to_be_set: u64 = 10;
         let init_value: u64 = SubtensorModule::get_serving_rate_limit(netuid);
         assert_eq!(
@@ -66,7 +67,7 @@ fn test_sudo_set_serving_rate_limit() {
 #[test]
 fn test_sudo_set_min_difficulty() {
     new_test_ext().execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let to_be_set: u64 = 10;
         add_network(netuid, 10);
         let init_value: u64 = SubtensorModule::get_min_difficulty(netuid);
@@ -81,7 +82,7 @@ fn test_sudo_set_min_difficulty() {
         assert_eq!(
             AdminUtils::sudo_set_min_difficulty(
                 <<Test as Config>::RuntimeOrigin>::root(),
-                netuid + 1,
+                netuid.next(),
                 to_be_set
             ),
             Err(Error::<Test>::SubnetDoesNotExist.into())
@@ -99,7 +100,7 @@ fn test_sudo_set_min_difficulty() {
 #[test]
 fn test_sudo_set_max_difficulty() {
     new_test_ext().execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let to_be_set: u64 = 10;
         add_network(netuid, 10);
         let init_value: u64 = SubtensorModule::get_max_difficulty(netuid);
@@ -114,7 +115,7 @@ fn test_sudo_set_max_difficulty() {
         assert_eq!(
             AdminUtils::sudo_set_max_difficulty(
                 <<Test as Config>::RuntimeOrigin>::root(),
-                netuid + 1,
+                netuid.next(),
                 to_be_set
             ),
             Err(Error::<Test>::SubnetDoesNotExist.into())
@@ -132,7 +133,7 @@ fn test_sudo_set_max_difficulty() {
 #[test]
 fn test_sudo_set_weights_version_key() {
     new_test_ext().execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let to_be_set: u64 = 10;
         add_network(netuid, 10);
         let init_value: u64 = SubtensorModule::get_weights_version_key(netuid);
@@ -147,7 +148,7 @@ fn test_sudo_set_weights_version_key() {
         assert_eq!(
             AdminUtils::sudo_set_weights_version_key(
                 <<Test as Config>::RuntimeOrigin>::root(),
-                netuid + 1,
+                netuid.next(),
                 to_be_set
             ),
             Err(Error::<Test>::SubnetDoesNotExist.into())
@@ -165,7 +166,7 @@ fn test_sudo_set_weights_version_key() {
 #[test]
 fn test_sudo_set_weights_version_key_rate_limit() {
     new_test_ext().execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let to_be_set: u64 = 10;
 
         let sn_owner = U256::from(1);
@@ -228,7 +229,7 @@ fn test_sudo_set_weights_version_key_rate_limit() {
 fn test_sudo_set_weights_version_key_rate_limit_root() {
     // root should not be effected by rate limit
     new_test_ext().execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let to_be_set: u64 = 10;
 
         let sn_owner = U256::from(1);
@@ -266,7 +267,7 @@ fn test_sudo_set_weights_version_key_rate_limit_root() {
 #[test]
 fn test_sudo_set_weights_set_rate_limit() {
     new_test_ext().execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let to_be_set: u64 = 10;
         add_network(netuid, 10);
         let init_value: u64 = SubtensorModule::get_weights_set_rate_limit(netuid);
@@ -281,7 +282,7 @@ fn test_sudo_set_weights_set_rate_limit() {
         assert_eq!(
             AdminUtils::sudo_set_weights_set_rate_limit(
                 <<Test as Config>::RuntimeOrigin>::root(),
-                netuid + 1,
+                netuid.next(),
                 to_be_set
             ),
             Err(Error::<Test>::SubnetDoesNotExist.into())
@@ -305,7 +306,7 @@ fn test_sudo_set_weights_set_rate_limit() {
 #[test]
 fn test_sudo_set_adjustment_interval() {
     new_test_ext().execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let to_be_set: u16 = 10;
         add_network(netuid, 10);
         let init_value: u16 = SubtensorModule::get_adjustment_interval(netuid);
@@ -320,7 +321,7 @@ fn test_sudo_set_adjustment_interval() {
         assert_eq!(
             AdminUtils::sudo_set_adjustment_interval(
                 <<Test as Config>::RuntimeOrigin>::root(),
-                netuid + 1,
+                netuid.next(),
                 to_be_set
             ),
             Err(Error::<Test>::SubnetDoesNotExist.into())
@@ -338,7 +339,7 @@ fn test_sudo_set_adjustment_interval() {
 #[test]
 fn test_sudo_set_adjustment_alpha() {
     new_test_ext().execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let to_be_set: u64 = 10;
         add_network(netuid, 10);
         let init_value: u64 = SubtensorModule::get_adjustment_alpha(netuid);
@@ -353,7 +354,7 @@ fn test_sudo_set_adjustment_alpha() {
         assert_eq!(
             AdminUtils::sudo_set_adjustment_alpha(
                 <<Test as Config>::RuntimeOrigin>::root(),
-                netuid + 1,
+                netuid.next(),
                 to_be_set
             ),
             Err(Error::<Test>::SubnetDoesNotExist.into())
@@ -392,7 +393,7 @@ fn test_sudo_subnet_owner_cut() {
 #[test]
 fn test_sudo_set_max_weight_limit() {
     new_test_ext().execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let to_be_set: u16 = 10;
         add_network(netuid, 10);
         let init_value: u16 = SubtensorModule::get_max_weight_limit(netuid);
@@ -407,7 +408,7 @@ fn test_sudo_set_max_weight_limit() {
         assert_eq!(
             AdminUtils::sudo_set_max_weight_limit(
                 <<Test as Config>::RuntimeOrigin>::root(),
-                netuid + 1,
+                netuid.next(),
                 to_be_set
             ),
             Err(Error::<Test>::SubnetDoesNotExist.into())
@@ -444,7 +445,7 @@ fn test_sudo_set_issuance() {
 #[test]
 fn test_sudo_set_immunity_period() {
     new_test_ext().execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let to_be_set: u16 = 10;
         add_network(netuid, 10);
         let init_value: u16 = SubtensorModule::get_immunity_period(netuid);
@@ -459,7 +460,7 @@ fn test_sudo_set_immunity_period() {
         assert_eq!(
             AdminUtils::sudo_set_immunity_period(
                 <<Test as Config>::RuntimeOrigin>::root(),
-                netuid + 1,
+                netuid.next(),
                 to_be_set
             ),
             Err(Error::<Test>::SubnetDoesNotExist.into())
@@ -477,7 +478,7 @@ fn test_sudo_set_immunity_period() {
 #[test]
 fn test_sudo_set_min_allowed_weights() {
     new_test_ext().execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let to_be_set: u16 = 10;
         add_network(netuid, 10);
         let init_value: u16 = SubtensorModule::get_min_allowed_weights(netuid);
@@ -492,7 +493,7 @@ fn test_sudo_set_min_allowed_weights() {
         assert_eq!(
             AdminUtils::sudo_set_min_allowed_weights(
                 <<Test as Config>::RuntimeOrigin>::root(),
-                netuid + 1,
+                netuid.next(),
                 to_be_set
             ),
             Err(Error::<Test>::SubnetDoesNotExist.into())
@@ -510,7 +511,7 @@ fn test_sudo_set_min_allowed_weights() {
 #[test]
 fn test_sudo_set_max_allowed_uids() {
     new_test_ext().execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let to_be_set: u16 = 10;
         add_network(netuid, 10);
         let init_value: u16 = SubtensorModule::get_max_allowed_uids(netuid);
@@ -525,7 +526,7 @@ fn test_sudo_set_max_allowed_uids() {
         assert_eq!(
             AdminUtils::sudo_set_max_allowed_uids(
                 <<Test as Config>::RuntimeOrigin>::root(),
-                netuid + 1,
+                netuid.next(),
                 to_be_set
             ),
             Err(Error::<Test>::SubnetDoesNotExist.into())
@@ -543,7 +544,7 @@ fn test_sudo_set_max_allowed_uids() {
 #[test]
 fn test_sudo_set_and_decrease_max_allowed_uids() {
     new_test_ext().execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let to_be_set: u16 = 10;
         add_network(netuid, 10);
         let init_value: u16 = SubtensorModule::get_max_allowed_uids(netuid);
@@ -558,7 +559,7 @@ fn test_sudo_set_and_decrease_max_allowed_uids() {
         assert_eq!(
             AdminUtils::sudo_set_max_allowed_uids(
                 <<Test as Config>::RuntimeOrigin>::root(),
-                netuid + 1,
+                netuid.next(),
                 to_be_set
             ),
             Err(Error::<Test>::SubnetDoesNotExist.into())
@@ -580,7 +581,7 @@ fn test_sudo_set_and_decrease_max_allowed_uids() {
 #[test]
 fn test_sudo_set_kappa() {
     new_test_ext().execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let to_be_set: u16 = 10;
         add_network(netuid, 10);
         let init_value: u16 = SubtensorModule::get_kappa(netuid);
@@ -595,7 +596,7 @@ fn test_sudo_set_kappa() {
         assert_eq!(
             AdminUtils::sudo_set_kappa(
                 <<Test as Config>::RuntimeOrigin>::root(),
-                netuid + 1,
+                netuid.next(),
                 to_be_set
             ),
             Err(Error::<Test>::SubnetDoesNotExist.into())
@@ -613,7 +614,7 @@ fn test_sudo_set_kappa() {
 #[test]
 fn test_sudo_set_rho() {
     new_test_ext().execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let to_be_set: u16 = 10;
         add_network(netuid, 10);
         let init_value: u16 = SubtensorModule::get_rho(netuid);
@@ -628,7 +629,7 @@ fn test_sudo_set_rho() {
         assert_eq!(
             AdminUtils::sudo_set_rho(
                 <<Test as Config>::RuntimeOrigin>::root(),
-                netuid + 1,
+                netuid.next(),
                 to_be_set
             ),
             Err(Error::<Test>::SubnetDoesNotExist.into())
@@ -646,7 +647,7 @@ fn test_sudo_set_rho() {
 #[test]
 fn test_sudo_set_activity_cutoff() {
     new_test_ext().execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let to_be_set: u16 = pallet_subtensor::MinActivityCutoff::<Test>::get();
         add_network(netuid, 10);
         let init_value: u16 = SubtensorModule::get_activity_cutoff(netuid);
@@ -661,7 +662,7 @@ fn test_sudo_set_activity_cutoff() {
         assert_eq!(
             AdminUtils::sudo_set_activity_cutoff(
                 <<Test as Config>::RuntimeOrigin>::root(),
-                netuid + 1,
+                netuid.next(),
                 to_be_set
             ),
             Err(Error::<Test>::SubnetDoesNotExist.into())
@@ -679,7 +680,7 @@ fn test_sudo_set_activity_cutoff() {
 #[test]
 fn test_sudo_set_target_registrations_per_interval() {
     new_test_ext().execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let to_be_set: u16 = 10;
         add_network(netuid, 10);
         let init_value: u16 = SubtensorModule::get_target_registrations_per_interval(netuid);
@@ -694,7 +695,7 @@ fn test_sudo_set_target_registrations_per_interval() {
         assert_eq!(
             AdminUtils::sudo_set_target_registrations_per_interval(
                 <<Test as Config>::RuntimeOrigin>::root(),
-                netuid + 1,
+                netuid.next(),
                 to_be_set
             ),
             Err(Error::<Test>::SubnetDoesNotExist.into())
@@ -718,7 +719,7 @@ fn test_sudo_set_target_registrations_per_interval() {
 #[test]
 fn test_sudo_set_difficulty() {
     new_test_ext().execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let to_be_set: u64 = 10;
         add_network(netuid, 10);
         let init_value: u64 = SubtensorModule::get_difficulty_as_u64(netuid);
@@ -733,7 +734,7 @@ fn test_sudo_set_difficulty() {
         assert_eq!(
             AdminUtils::sudo_set_difficulty(
                 <<Test as Config>::RuntimeOrigin>::root(),
-                netuid + 1,
+                netuid.next(),
                 to_be_set
             ),
             Err(Error::<Test>::SubnetDoesNotExist.into())
@@ -763,7 +764,7 @@ fn test_sudo_set_difficulty() {
 #[test]
 fn test_sudo_set_max_allowed_validators() {
     new_test_ext().execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let to_be_set: u16 = 10;
         add_network(netuid, 10);
         let init_value: u16 = SubtensorModule::get_max_allowed_validators(netuid);
@@ -778,7 +779,7 @@ fn test_sudo_set_max_allowed_validators() {
         assert_eq!(
             AdminUtils::sudo_set_max_allowed_validators(
                 <<Test as Config>::RuntimeOrigin>::root(),
-                netuid + 1,
+                netuid.next(),
                 to_be_set
             ),
             Err(Error::<Test>::SubnetDoesNotExist.into())
@@ -823,7 +824,7 @@ fn test_sudo_set_stake_threshold() {
 #[test]
 fn test_sudo_set_bonds_moving_average() {
     new_test_ext().execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let to_be_set: u64 = 10;
         add_network(netuid, 10);
         let init_value: u64 = SubtensorModule::get_bonds_moving_average(netuid);
@@ -838,7 +839,7 @@ fn test_sudo_set_bonds_moving_average() {
         assert_eq!(
             AdminUtils::sudo_set_bonds_moving_average(
                 <<Test as Config>::RuntimeOrigin>::root(),
-                netuid + 1,
+                netuid.next(),
                 to_be_set
             ),
             Err(Error::<Test>::SubnetDoesNotExist.into())
@@ -859,7 +860,7 @@ fn test_sudo_set_bonds_moving_average() {
 #[test]
 fn test_sudo_set_bonds_penalty() {
     new_test_ext().execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let to_be_set: u16 = 10;
         add_network(netuid, 10);
         let init_value: u16 = SubtensorModule::get_bonds_penalty(netuid);
@@ -874,7 +875,7 @@ fn test_sudo_set_bonds_penalty() {
         assert_eq!(
             AdminUtils::sudo_set_bonds_penalty(
                 <<Test as Config>::RuntimeOrigin>::root(),
-                netuid + 1,
+                netuid.next(),
                 to_be_set
             ),
             Err(Error::<Test>::SubnetDoesNotExist.into())
@@ -892,7 +893,7 @@ fn test_sudo_set_bonds_penalty() {
 #[test]
 fn test_sudo_set_rao_recycled() {
     new_test_ext().execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let to_be_set: u64 = 10;
         add_network(netuid, 10);
         let init_value: u64 = SubtensorModule::get_rao_recycled(netuid);
@@ -911,7 +912,7 @@ fn test_sudo_set_rao_recycled() {
         assert_eq!(
             AdminUtils::sudo_set_rao_recycled(
                 <<Test as Config>::RuntimeOrigin>::root(),
-                netuid + 1,
+                netuid.next(),
                 to_be_set
             ),
             Err(Error::<Test>::SubnetDoesNotExist.into())
@@ -954,7 +955,7 @@ fn test_sudo_set_rao_recycled() {
 #[test]
 fn test_sudo_set_network_lock_reduction_interval() {
     new_test_ext().execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let to_be_set: u64 = 7200;
         add_network(netuid, 10);
 
@@ -978,7 +979,7 @@ fn test_sudo_set_network_lock_reduction_interval() {
 #[test]
 fn test_sudo_set_network_pow_registration_allowed() {
     new_test_ext().execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let to_be_set: bool = true;
         add_network(netuid, 10);
 
@@ -1108,7 +1109,7 @@ fn test_sudo_set_min_delegate_take() {
 #[test]
 fn test_sudo_set_commit_reveal_weights_enabled() {
     new_test_ext().execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         add_network(netuid, 10);
 
         let to_be_set: bool = true;
@@ -1131,7 +1132,7 @@ fn test_sudo_set_commit_reveal_weights_enabled() {
 #[test]
 fn test_sudo_set_liquid_alpha_enabled() {
     new_test_ext().execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let enabled: bool = true;
         assert_eq!(!enabled, SubtensorModule::get_liquid_alpha_enabled(netuid));
 
@@ -1148,7 +1149,7 @@ fn test_sudo_set_liquid_alpha_enabled() {
 #[test]
 fn test_set_alpha_values_dispatch_info_ok() {
     new_test_ext().execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let alpha_low: u16 = 12_u16;
         let alpha_high: u16 = u16::MAX - 10;
         let call = RuntimeCall::AdminUtils(crate::Call::sudo_set_alpha_values {
@@ -1167,7 +1168,7 @@ fn test_set_alpha_values_dispatch_info_ok() {
 #[test]
 fn test_sudo_get_set_alpha() {
     new_test_ext().execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let alpha_low: u16 = 12_u16;
         let alpha_high: u16 = u16::MAX - 10;
 
@@ -1385,7 +1386,7 @@ fn test_sudo_set_dissolve_network_schedule_duration() {
 #[test]
 fn sudo_set_commit_reveal_weights_interval() {
     new_test_ext().execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         add_network(netuid, 10);
 
         let to_be_set = 55;
@@ -1565,7 +1566,7 @@ fn test_sets_a_lower_value_clears_small_nominations() {
         assert!(to_stake < nominator_min_required_stake_1); // Should be removed when set
 
         // Create network
-        let netuid = 2;
+        let netuid = NetUid::from(2);
         add_network(netuid, 10);
 
         // Register a neuron
@@ -1630,7 +1631,7 @@ fn test_sets_a_lower_value_clears_small_nominations() {
 #[test]
 fn test_sudo_set_subnet_owner_hotkey() {
     new_test_ext().execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
 
         let coldkey: U256 = U256::from(1);
         let hotkey: U256 = U256::from(2);
@@ -1674,7 +1675,7 @@ fn test_sudo_set_subnet_owner_hotkey() {
 #[test]
 fn test_sudo_set_ema_halving() {
     new_test_ext().execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let to_be_set: u64 = 10;
         add_network(netuid, 10);
 
@@ -1716,7 +1717,7 @@ fn test_sudo_set_ema_halving() {
 #[test]
 fn test_set_sn_owner_hotkey_owner() {
     new_test_ext().execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let hotkey: U256 = U256::from(3);
         let bad_origin_coldkey: U256 = U256::from(4);
         add_network(netuid, 10);
@@ -1761,7 +1762,7 @@ fn test_set_sn_owner_hotkey_owner() {
 #[test]
 fn test_set_sn_owner_hotkey_root() {
     new_test_ext().execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let hotkey: U256 = U256::from(3);
         add_network(netuid, 10);
 
diff --git a/pallets/subtensor/src/utils/try_state.rs b/pallets/subtensor/src/utils/try_state.rs
index 1fb75fd4bb..f5e8d5ffb9 100644
--- a/pallets/subtensor/src/utils/try_state.rs
+++ b/pallets/subtensor/src/utils/try_state.rs
@@ -41,7 +41,7 @@ impl<T: Config> Pallet<T> {
         let total_staked = SubnetTAO::<T>::iter().fold(0u64, |acc, (netuid, stake)| {
             let acc = acc.saturating_add(stake);
 
-            if netuid == Self::get_root_netuid() {
+            if netuid.is_root() {
                 // root network doesn't have initial pool TAO
                 acc
             } else {

From c7074d9e9ee7b186248c575b1bbd80f8590767e2 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Mon, 9 Jun 2025 13:59:01 -0400
Subject: [PATCH 258/418] Fix tick updates in swap step

---
 pallets/subtensor/src/tests/staking.rs | 210 ++++++++++++++-----------
 pallets/swap/src/pallet/impls.rs       |  28 +---
 pallets/swap/src/pallet/mod.rs         |   2 -
 pallets/swap/src/pallet/tests.rs       |   5 +-
 pallets/swap/src/position.rs           |   6 -
 pallets/swap/src/tick.rs               |  24 +--
 6 files changed, 126 insertions(+), 149 deletions(-)

diff --git a/pallets/subtensor/src/tests/staking.rs b/pallets/subtensor/src/tests/staking.rs
index a56539a88d..2b635b8f6f 100644
--- a/pallets/subtensor/src/tests/staking.rs
+++ b/pallets/subtensor/src/tests/staking.rs
@@ -6674,110 +6674,130 @@ fn test_default_min_stake_sufficiency() {
 ///
 #[test]
 fn test_update_position_fees() {
-    new_test_ext(1).execute_with(|| {
-        let owner_hotkey = U256::from(1);
-        let owner_coldkey = U256::from(2);
-        let coldkey = U256::from(4);
-        let amount = 1_000_000_000;
-
-        // add network
-        let netuid: u16 = add_dynamic_network(&owner_hotkey, &owner_coldkey);
-        SubtensorModule::add_balance_to_coldkey_account(&owner_coldkey, amount * 10);
-        SubtensorModule::add_balance_to_coldkey_account(&coldkey, amount * 100);
-        let fee_rate = pallet_subtensor_swap::FeeRate::<Test>::get(NetUid::from(netuid)) as f64
-            / u16::MAX as f64;
-        pallet_subtensor_swap::EnabledUserLiquidity::<Test>::insert(NetUid::from(netuid), true);
-
-        // Forse-set alpha in and tao reserve to make price equal 0.25
-        let tao_reserve = U96F32::from_num(100_000_000_000_u64);
-        let alpha_in = U96F32::from_num(400_000_000_000_u64);
-        mock::setup_reserves(netuid, tao_reserve.to_num(), alpha_in.to_num());
+    // Test cases: add or remove liquidity during modification
+    [false, true].into_iter().for_each(|add| {
+        new_test_ext(1).execute_with(|| {
+            let owner_hotkey = U256::from(1);
+            let owner_coldkey = U256::from(2);
+            let coldkey = U256::from(4);
+            let amount = 1_000_000_000;
+
+            // add network
+            let netuid: u16 = add_dynamic_network(&owner_hotkey, &owner_coldkey);
+            SubtensorModule::add_balance_to_coldkey_account(&owner_coldkey, amount * 10);
+            SubtensorModule::add_balance_to_coldkey_account(&coldkey, amount * 100);
+            pallet_subtensor_swap::EnabledUserLiquidity::<Test>::insert(NetUid::from(netuid), true);
+
+            // Forse-set alpha in and tao reserve to make price equal 0.25
+            let tao_reserve = U96F32::from_num(100_000_000_000_u64);
+            let alpha_in = U96F32::from_num(400_000_000_000_u64);
+            mock::setup_reserves(netuid, tao_reserve.to_num(), alpha_in.to_num());
+
+            // Get alpha for owner
+            assert_ok!(SubtensorModule::add_stake(
+                RuntimeOrigin::signed(owner_coldkey),
+                owner_hotkey,
+                netuid,
+                amount,
+            ));
 
-        // Get alpha for owner
-        assert_ok!(SubtensorModule::add_stake(
-            RuntimeOrigin::signed(owner_coldkey),
-            owner_hotkey,
-            netuid,
-            amount,
-        ));
+            // Add owner coldkey Alpha as concentrated liquidity
+            // between current price current price + 0.01
+            let current_price =
+                <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid.into())
+                    .to_num::<f64>()
+                    + 0.0001;
+            let limit_price = current_price + 0.001;
+            let tick_low = price_to_tick(current_price);
+            let tick_high = price_to_tick(limit_price);
+            let liquidity = amount;
+
+            let (position_id, _, _) = <Test as pallet::Config>::SwapInterface::do_add_liquidity(
+                NetUid::from(netuid),
+                &owner_coldkey,
+                &owner_hotkey,
+                tick_low,
+                tick_high,
+                liquidity,
+            )
+            .unwrap();
 
-        // Add owner coldkey Alpha as concentrated liquidity
-        // between current price current price + 0.01
-        let current_price = <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid.into())
-            .to_num::<f64>()
-            - 0.0001;
-        let limit_price = current_price + 0.001 ;
-        let tick_low = price_to_tick(current_price);
-        let tick_high = price_to_tick(limit_price);
-        let liquidity = amount;
+            // Buy and then sell all alpha for user to hit owner liquidity
+            assert_ok!(SubtensorModule::add_stake(
+                RuntimeOrigin::signed(coldkey),
+                owner_hotkey,
+                netuid,
+                amount,
+            ));
 
-        let (position_id, _, _) = <Test as pallet::Config>::SwapInterface::do_add_liquidity(
-            NetUid::from(netuid),
-            &owner_coldkey,
-            &owner_hotkey,
-            tick_low,
-            tick_high,
-            liquidity,
-        ).unwrap();
+            let user_alpha = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+                &owner_hotkey,
+                &coldkey,
+                netuid,
+            );
+            assert_ok!(SubtensorModule::remove_stake(
+                RuntimeOrigin::signed(coldkey),
+                owner_hotkey,
+                netuid,
+                user_alpha,
+            ));
 
-        // Buy and then sell all alpha for user to hit owner liquidity
-        assert_ok!(SubtensorModule::add_stake(
-            RuntimeOrigin::signed(coldkey),
-            owner_hotkey,
-            netuid,
-            amount,
-        ));
-        let fees_tao = (fee_rate * amount as f64) as u64;
+            // Modify position - fees should be collected and paid to the owner
+            let owner_tao_before = SubtensorModule::get_coldkey_balance(&owner_coldkey);
+            let owner_alpha_before = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+                &owner_hotkey,
+                &owner_coldkey,
+                netuid,
+            );
 
-        let user_alpha = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
-            &owner_hotkey,
-            &coldkey,
-            netuid,
-        );
-        assert_ok!(SubtensorModule::remove_stake(
-            RuntimeOrigin::signed(coldkey),
-            owner_hotkey,
-            netuid,
-            user_alpha,
-        ));
-        let fees_alpha = (fee_rate * user_alpha as f64) as u64;
+            // Make small modification
+            let delta =
+                <tests::mock::Test as pallet_subtensor_swap::Config>::MinimumLiquidity::get()
+                    as i64
+                    * (if add { 1 } else { -1 });
+            assert_ok!(Swap::modify_position(
+                RuntimeOrigin::signed(owner_coldkey),
+                owner_hotkey,
+                netuid.into(),
+                position_id.into(),
+                delta,
+            ));
 
-        // Modify position - fees should be collected and paid to the owner
-        let owner_tao_before = SubtensorModule::get_coldkey_balance(&owner_coldkey);
-        let owner_alpha_before = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
-            &owner_hotkey,
-            &owner_coldkey,
-            netuid,
-        );
+            // Check ending owner TAO and alpha
+            let owner_tao_after_add = SubtensorModule::get_coldkey_balance(&owner_coldkey);
+            let owner_alpha_after_add = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+                &owner_hotkey,
+                &owner_coldkey,
+                netuid,
+            );
 
-        // Make small modification - add liquidity
-        let delta = <tests::mock::Test as pallet_subtensor_swap::Config>::MinimumLiquidity::get();
-        assert_ok!(Swap::modify_position(
-            RuntimeOrigin::signed(owner_coldkey),
-            owner_hotkey,
-            netuid.into(),
-            position_id.into(),
-            delta as i64,
-        ));
+            assert!(owner_tao_after_add > owner_tao_before);
+            assert!(owner_alpha_after_add > owner_alpha_before); // always greater because of claimed fees
 
-        // Check ending owner TAO and alpha
-        let owner_tao_after_add = SubtensorModule::get_coldkey_balance(&owner_coldkey);
-        let owner_alpha_after_add = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
-            &owner_hotkey,
-            &owner_coldkey,
-            netuid,
-        );
+            // Make small modification again - should not claim more fees
+            assert_ok!(Swap::modify_position(
+                RuntimeOrigin::signed(owner_coldkey),
+                owner_hotkey,
+                netuid.into(),
+                position_id.into(),
+                delta,
+            ));
 
-        println!("owner_tao_before = {:?}", owner_tao_before);
-        println!("owner_alpha_before = {:?}", owner_alpha_before);
-        println!("owner_tao_after_add = {:?}", owner_tao_after_add);
-        println!("owner_alpha_after_add = {:?}", owner_alpha_after_add);
-        println!("fees_tao = {:?}", fees_tao);
-        println!("fees_alpha = {:?}", fees_alpha);
-        println!("delta = {:?}", delta);
-        delta
+            // Check ending owner TAO and alpha
+            let owner_tao_after_repeat = SubtensorModule::get_coldkey_balance(&owner_coldkey);
+            let owner_alpha_after_repeat =
+                SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+                    &owner_hotkey,
+                    &owner_coldkey,
+                    netuid,
+                );
 
-        // // Total TAO does not change, leave some epsilon for rounding
-        // assert_abs_diff_eq!(total_tao_before, total_tao_after, epsilon = 2,);
+            assert!(owner_tao_after_add == owner_tao_after_repeat);
+            if add {
+                assert!(owner_alpha_after_add > owner_alpha_after_repeat);
+            } else {
+                assert!(owner_alpha_after_add < owner_alpha_after_repeat);
+            }
+        });
     });
 }
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 8fafb8ad70..66a850279b 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -34,6 +34,7 @@ struct SwapStep<T: frame_system::Config> {
     limit_sqrt_price: SqrtPrice,
     current_sqrt_price: SqrtPrice,
     edge_sqrt_price: SqrtPrice,
+    edge_tick: TickIndex,
 
     // Result values
     action: SwapStepAction,
@@ -78,6 +79,7 @@ impl<T: Config> SwapStep<T> {
             limit_sqrt_price,
             current_sqrt_price,
             edge_sqrt_price,
+            edge_tick,
             possible_delta_in,
             current_liquidity,
             action: SwapStepAction::Stop,
@@ -204,28 +206,14 @@ impl<T: Config> SwapStep<T> {
         let delta_out = Pallet::<T>::convert_deltas(self.netuid, self.order_type, self.delta_in);
         log::trace!("\tDelta Out        : {:?}", delta_out);
 
-        // Get current tick
-        let current_tick_index = TickIndex::current_bounded::<T>(self.netuid);
-
         if self.action == SwapStepAction::Crossing {
-            let mut tick = match self.order_type {
-                OrderType::Sell => {
-                    Pallet::<T>::find_closest_lower_active_tick(self.netuid, current_tick_index)
-                }
-                OrderType::Buy => {
-                    Pallet::<T>::find_closest_higher_active_tick(self.netuid, current_tick_index)
-                }
-            }
-            .ok_or(Error::<T>::InsufficientLiquidity)?;
-
+            let mut tick = Ticks::<T>::get(self.netuid, self.edge_tick).unwrap_or_default();
             tick.fees_out_tao =
                 FeeGlobalTao::<T>::get(self.netuid).saturating_sub(tick.fees_out_tao);
             tick.fees_out_alpha =
                 FeeGlobalAlpha::<T>::get(self.netuid).saturating_sub(tick.fees_out_alpha);
-            println!("Tick after processing step: {:?}", tick);
-
             Pallet::<T>::update_liquidity_at_crossing(self.netuid, self.order_type)?;
-            Ticks::<T>::insert(self.netuid, current_tick_index, tick);
+            Ticks::<T>::insert(self.netuid, self.edge_tick, tick);
         }
 
         // Update current price
@@ -528,20 +516,14 @@ impl<T: Config> Pallet<T> {
         let fee_global_alpha = FeeGlobalAlpha::<T>::get(netuid);
         let fee_fixed = U64F64::saturating_from_num(fee);
 
-        println!("Adding fees. fee = {:?}", fee);
-
         match order_type {
             OrderType::Sell => {
-                println!("Alpha fees added: {:?}", fee_fixed.safe_div(liquidity_curr));
-
                 FeeGlobalAlpha::<T>::set(
                     netuid,
                     fee_global_alpha.saturating_add(fee_fixed.safe_div(liquidity_curr)),
                 );
             }
             OrderType::Buy => {
-                println!("TAO fees added: {:?}", fee_fixed.safe_div(liquidity_curr));
-
                 FeeGlobalTao::<T>::set(
                     netuid,
                     fee_global_tao.saturating_add(fee_fixed.safe_div(liquidity_curr)),
@@ -945,8 +927,6 @@ impl<T: Config> Pallet<T> {
         // Collect fees
         let (fee_tao, fee_alpha) = position.collect_fees();
 
-        println!("Fees collected: {:?}", (fee_tao, fee_alpha));
-
         // If delta brings the position liquidity below MinimumLiquidity, eliminate position and
         // withdraw full amounts
         if (liquidity_delta < 0)
diff --git a/pallets/swap/src/pallet/mod.rs b/pallets/swap/src/pallet/mod.rs
index e6d73e7fc4..77239af276 100644
--- a/pallets/swap/src/pallet/mod.rs
+++ b/pallets/swap/src/pallet/mod.rs
@@ -435,8 +435,6 @@ mod pallet {
             let result =
                 Self::do_modify_position(netuid, &coldkey, &hotkey, position_id, liquidity_delta)?;
 
-            println!("modify result = {:?}", result);
-
             if liquidity_delta > 0 {
                 // Remove TAO and Alpha balances or fail transaction if they can't be removed exactly
                 let tao_provided = T::BalanceOps::decrease_balance(&coldkey, result.tao)?;
diff --git a/pallets/swap/src/pallet/tests.rs b/pallets/swap/src/pallet/tests.rs
index a186d4a654..bbd8909546 100644
--- a/pallets/swap/src/pallet/tests.rs
+++ b/pallets/swap/src/pallet/tests.rs
@@ -557,6 +557,7 @@ fn test_remove_liquidity_nonexisting_position() {
     });
 }
 
+// cargo test --package pallet-subtensor-swap --lib -- pallet::tests::test_modify_position_basic --exact --show-output
 #[test]
 fn test_modify_position_basic() {
     new_test_ext().execute_with(|| {
@@ -564,7 +565,7 @@ fn test_modify_position_basic() {
         let max_tick = price_to_tick(max_price);
         let limit_price = 1000.0_f64;
         assert_eq!(max_tick, TickIndex::MAX);
-        let (_current_price_low, current_price_high) = get_ticked_prices_around_current_price();
+        let (current_price_low, _current_price_high) = get_ticked_prices_around_current_price();
 
         // As a user add liquidity with all possible corner cases
         //   - Initial price is 0.25
@@ -573,7 +574,7 @@ fn test_modify_position_basic() {
         [
             // Repeat the protocol liquidity at current to max range: Expect the same alpha
             (
-                current_price_high,
+                current_price_low,
                 max_price,
                 2_000_000_000_u64,
                 4_000_000_000,
diff --git a/pallets/swap/src/position.rs b/pallets/swap/src/position.rs
index e0423c45de..a5abbb6a00 100644
--- a/pallets/swap/src/position.rs
+++ b/pallets/swap/src/position.rs
@@ -99,14 +99,9 @@ impl<T: Config> Position<T> {
         let fee_tao_agg = self.fees_in_range(true);
         let fee_alpha_agg = self.fees_in_range(false);
 
-        println!("fee_tao_agg = {:?}", fee_tao_agg);
-
         let mut fee_tao = fee_tao_agg.saturating_sub(self.fees_tao);
         let mut fee_alpha = fee_alpha_agg.saturating_sub(self.fees_alpha);
 
-        println!("fee_tao = {:?}", fee_tao);
-
-
         self.fees_tao = fee_tao_agg;
         self.fees_alpha = fee_alpha_agg;
 
@@ -125,7 +120,6 @@ impl<T: Config> Position<T> {
     /// If quote flag is true, Tao is returned, otherwise alpha.
     fn fees_in_range(&self, quote: bool) -> U64F64 {
         if quote {
-            println!("FeeGlobalTao::<T>::get(self.netuid) = {:?}", FeeGlobalTao::<T>::get(self.netuid));
             FeeGlobalTao::<T>::get(self.netuid)
         } else {
             FeeGlobalAlpha::<T>::get(self.netuid)
diff --git a/pallets/swap/src/tick.rs b/pallets/swap/src/tick.rs
index 23a24d2e88..29106acc84 100644
--- a/pallets/swap/src/tick.rs
+++ b/pallets/swap/src/tick.rs
@@ -216,16 +216,8 @@ impl TickIndex {
     pub fn fees_above<T: Config>(&self, netuid: NetUid, quote: bool) -> U64F64 {
         let current_tick = Self::current_bounded::<T>(netuid);
 
-        let Some(tick_index) = ActiveTickIndexManager::<T>::find_closest_lower(netuid, *self)
-        else {
-            return U64F64::from_num(0);
-        };
-
-        let tick = Ticks::<T>::get(netuid, tick_index).unwrap_or_default();
-
-        println!("fees_above tick = {:?}", tick);
-
-        if tick_index <= current_tick {
+        let tick = Ticks::<T>::get(netuid, *self).unwrap_or_default();
+        if *self <= current_tick {
             if quote {
                 FeeGlobalTao::<T>::get(netuid).saturating_sub(tick.fees_out_tao)
             } else {
@@ -242,16 +234,8 @@ impl TickIndex {
     pub fn fees_below<T: Config>(&self, netuid: NetUid, quote: bool) -> U64F64 {
         let current_tick = Self::current_bounded::<T>(netuid);
 
-        let Some(tick_index) = ActiveTickIndexManager::<T>::find_closest_lower(netuid, *self)
-        else {
-            return U64F64::saturating_from_num(0);
-        };
-
-        let tick = Ticks::<T>::get(netuid, tick_index).unwrap_or_default();
-
-        println!("fees_below tick = {:?}", tick);
-
-        if tick_index <= current_tick {
+        let tick = Ticks::<T>::get(netuid, *self).unwrap_or_default();
+        if *self <= current_tick {
             if quote {
                 tick.fees_out_tao
             } else {

From 79a426940ef6aebe267b30da5a13b457867de93e Mon Sep 17 00:00:00 2001
From: gztensor <166415444+gztensor@users.noreply.github.com>
Date: Mon, 9 Jun 2025 11:04:29 -0700
Subject: [PATCH 259/418] Update pallets/subtensor/src/staking/stake_utils.rs

Co-authored-by: Loris Moulin <45130584+l0r1s@users.noreply.github.com>
---
 pallets/subtensor/src/staking/stake_utils.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pallets/subtensor/src/staking/stake_utils.rs b/pallets/subtensor/src/staking/stake_utils.rs
index e6bbcdcf5e..81a4ab1520 100644
--- a/pallets/subtensor/src/staking/stake_utils.rs
+++ b/pallets/subtensor/src/staking/stake_utils.rs
@@ -663,7 +663,7 @@ impl<T: Config> Pallet<T> {
         }
     }
 
-    /// Swaps a subnet's Alpba token for TAO.
+    /// Swaps a subnet's Alpha token for TAO.
     ///
     /// Updates TaoIn, AlphaIn, and AlphaOut
     pub fn swap_alpha_for_tao(

From 7aa64fdd2bf924142d297c86a92eebfcb69991a2 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Mon, 9 Jun 2025 14:09:18 -0400
Subject: [PATCH 260/418] Rename SubnetTAOProvided to SubnetTaoProvided

---
 pallets/subtensor/src/lib.rs                 |  4 ++--
 pallets/subtensor/src/staking/move_stake.rs  |  4 ++--
 pallets/subtensor/src/staking/stake_utils.rs | 12 ++++++------
 3 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/pallets/subtensor/src/lib.rs b/pallets/subtensor/src/lib.rs
index c9807fc219..f2a7ee1eb3 100644
--- a/pallets/subtensor/src/lib.rs
+++ b/pallets/subtensor/src/lib.rs
@@ -1014,7 +1014,7 @@ pub mod pallet {
     pub type SubnetTAO<T: Config> =
         StorageMap<_, Identity, u16, u64, ValueQuery, DefaultZeroU64<T>>;
     #[pallet::storage] // --- MAP ( netuid ) --> tao_in_user_subnet | Returns the amount of TAO in the subnet reserve provided by users as liquidity.
-    pub type SubnetTAOProvided<T: Config> =
+    pub type SubnetTaoProvided<T: Config> =
         StorageMap<_, Identity, u16, u64, ValueQuery, DefaultZeroU64<T>>;
     #[pallet::storage] // --- MAP ( netuid ) --> alpha_in_emission | Returns the amount of alph in  emission into the pool per block.
     pub type SubnetAlphaInEmission<T: Config> =
@@ -2532,7 +2532,7 @@ impl<T: Config + pallet_balances::Config<Balance = u64>>
 {
     fn tao_reserve(netuid: NetUid) -> u64 {
         SubnetTAO::<T>::get(u16::from(netuid))
-            .saturating_add(SubnetTAOProvided::<T>::get(u16::from(netuid)))
+            .saturating_add(SubnetTaoProvided::<T>::get(u16::from(netuid)))
     }
 
     fn alpha_reserve(netuid: NetUid) -> u64 {
diff --git a/pallets/subtensor/src/staking/move_stake.rs b/pallets/subtensor/src/staking/move_stake.rs
index 4872d3d0b1..62aed9fda1 100644
--- a/pallets/subtensor/src/staking/move_stake.rs
+++ b/pallets/subtensor/src/staking/move_stake.rs
@@ -441,9 +441,9 @@ impl<T: Config> Pallet<T> {
 
         // Corner case: SubnetTAO for any of two subnets is zero
         let subnet_tao_1 = SubnetTAO::<T>::get(origin_netuid)
-            .saturating_add(SubnetTAOProvided::<T>::get(origin_netuid));
+            .saturating_add(SubnetTaoProvided::<T>::get(origin_netuid));
         let subnet_tao_2 = SubnetTAO::<T>::get(destination_netuid)
-            .saturating_add(SubnetTAOProvided::<T>::get(destination_netuid));
+            .saturating_add(SubnetTaoProvided::<T>::get(destination_netuid));
         if (subnet_tao_1 == 0) || (subnet_tao_2 == 0) {
             return Err(Error::ZeroMaxStakeAmount);
         }
diff --git a/pallets/subtensor/src/staking/stake_utils.rs b/pallets/subtensor/src/staking/stake_utils.rs
index 81a4ab1520..f90c4940d9 100644
--- a/pallets/subtensor/src/staking/stake_utils.rs
+++ b/pallets/subtensor/src/staking/stake_utils.rs
@@ -635,7 +635,7 @@ impl<T: Config> Pallet<T> {
             });
 
             // Increase only the protocol TAO reserve. We only use the sum of
-            // (SubnetTAO + SubnetTAOProvided) in tao_reserve(), so it is irrelevant
+            // (SubnetTAO + SubnetTaoProvided) in tao_reserve(), so it is irrelevant
             // which one to increase.
             SubnetTAO::<T>::mutate(netuid, |total| {
                 *total = total.saturating_add(swap_result.tao_reserve_delta as u64);
@@ -1099,22 +1099,22 @@ impl<T: Config> Pallet<T> {
 
     pub fn increase_provided_tao_reserve(netuid: NetUid, tao: u64) {
         let netuid_u16: u16 = netuid.into();
-        SubnetTAOProvided::<T>::mutate(netuid_u16, |total| {
+        SubnetTaoProvided::<T>::mutate(netuid_u16, |total| {
             *total = total.saturating_add(tao);
         });
     }
 
     pub fn decrease_provided_tao_reserve(netuid: NetUid, tao: u64) {
-        // First, decrease SubnetTAOProvided, then deduct the rest from SubnetTAO
+        // First, decrease SubnetTaoProvided, then deduct the rest from SubnetTAO
         let netuid_u16: u16 = netuid.into();
         let subnet_tao = SubnetTAO::<T>::get(netuid_u16);
-        let subnet_tao_provided = SubnetTAOProvided::<T>::get(netuid_u16);
+        let subnet_tao_provided = SubnetTaoProvided::<T>::get(netuid_u16);
         let remainder = subnet_tao_provided.saturating_sub(tao);
         let carry_over = tao.saturating_sub(subnet_tao_provided);
         if carry_over == 0 {
-            SubnetTAOProvided::<T>::set(netuid_u16, remainder);
+            SubnetTaoProvided::<T>::set(netuid_u16, remainder);
         } else {
-            SubnetTAOProvided::<T>::set(netuid_u16, 0_u64);
+            SubnetTaoProvided::<T>::set(netuid_u16, 0_u64);
             SubnetTAO::<T>::set(netuid_u16, subnet_tao.saturating_sub(carry_over));
         }
     }

From 3360db0e7df219ab7f6b7ba02aee1593eb983484 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Mon, 9 Jun 2025 20:10:00 +0200
Subject: [PATCH 261/418] Fix precompiles compilation

---
 Cargo.lock                              |  1 +
 pallets/commitments/Cargo.toml          | 24 ++++---
 pallets/commitments/src/benchmarking.rs |  2 +-
 pallets/commitments/src/lib.rs          | 31 +++++----
 pallets/commitments/src/mock.rs         |  4 +-
 pallets/commitments/src/tests.rs        | 27 +++----
 precompiles/src/metagraph.rs            | 33 ++++-----
 precompiles/src/neuron.rs               | 14 ++--
 precompiles/src/staking.rs              | 30 ++++----
 precompiles/src/subnet.rs               | 93 +++++++++++++------------
 precompiles/src/uid_lookup.rs           |  2 +-
 runtime/src/lib.rs                      |  4 +-
 12 files changed, 136 insertions(+), 129 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index f226ce7e53..6ac93b09c8 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6124,6 +6124,7 @@ dependencies = [
  "sp-runtime",
  "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7)",
  "subtensor-macros",
+ "subtensor-runtime-common",
  "tle",
  "w3f-bls",
 ]
diff --git a/pallets/commitments/Cargo.toml b/pallets/commitments/Cargo.toml
index 7b2f49ace8..efc1a216db 100644
--- a/pallets/commitments/Cargo.toml
+++ b/pallets/commitments/Cargo.toml
@@ -40,6 +40,7 @@ sha2 = { workspace = true }
 log = { workspace = true }
 
 pallet-subtensor = { path = "../subtensor", default-features = false }
+subtensor-runtime-common = { workspace = true }
 
 [dev-dependencies]
 sp-core = { workspace = true }
@@ -49,26 +50,27 @@ pallet-balances = { workspace = true }
 [features]
 default = ["std"]
 std = [
+	"ark-serialize/std",
 	"codec/std",
+	"enumflags2/std",
 	"frame-benchmarking?/std",
 	"frame-support/std",
 	"frame-system/std",
-	"scale-info/std",
-	"sp-std/std",
-	"sp-runtime/std",
-	"enumflags2/std",
+	"hex/std",
+	"log/std",
 	"pallet-balances/std",
+	"pallet-drand/std",
+	"pallet-subtensor/std",
+	"rand_chacha/std",
+	"scale-info/std",
+	"sha2/std",
 	"sp-core/std",
 	"sp-io/std",
-	"ark-serialize/std",
-	"log/std",
-	"pallet-drand/std",
+	"sp-runtime/std",
+	"sp-std/std",
+	"subtensor-runtime-common/std",
 	"tle/std",
 	"w3f-bls/std",
-	"hex/std",
-	"rand_chacha/std",
-	"sha2/std",
-	"pallet-subtensor/std"
 ]
 runtime-benchmarks = [
 	"frame-benchmarking/runtime-benchmarks",
diff --git a/pallets/commitments/src/benchmarking.rs b/pallets/commitments/src/benchmarking.rs
index e66f2a07e8..e8efcc42a7 100644
--- a/pallets/commitments/src/benchmarking.rs
+++ b/pallets/commitments/src/benchmarking.rs
@@ -35,7 +35,7 @@ mod benchmarks {
 
     #[benchmark]
     fn set_commitment() {
-        let netuid = 1;
+        let netuid = NetUid::from(1);
         let caller: T::AccountId = whitelisted_caller();
         let _ = T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
 
diff --git a/pallets/commitments/src/lib.rs b/pallets/commitments/src/lib.rs
index 5b1ff7f3a8..096b259153 100644
--- a/pallets/commitments/src/lib.rs
+++ b/pallets/commitments/src/lib.rs
@@ -27,6 +27,7 @@ use tle::{
     tlock::{TLECiphertext, tld},
 };
 use w3f_bls::EngineBLS;
+use subtensor_runtime_common::NetUid;
 
 type BalanceOf<T> =
     <<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;
@@ -78,7 +79,7 @@ pub mod pallet {
     /// Used to retrieve the given subnet's tempo
     pub trait GetTempoInterface {
         /// Used to retreive the epoch index for the given subnet.
-        fn get_epoch_index(netuid: u16, cur_block: u64) -> u64;
+        fn get_epoch_index(netuid: NetUid, cur_block: u64) -> u64;
     }
 
     #[pallet::event]
@@ -87,14 +88,14 @@ pub mod pallet {
         /// A commitment was set
         Commitment {
             /// The netuid of the commitment
-            netuid: u16,
+            netuid: NetUid,
             /// The account
             who: T::AccountId,
         },
         /// A timelock-encrypted commitment was set
         TimelockCommitment {
             /// The netuid of the commitment
-            netuid: u16,
+            netuid: NetUid,
             /// The account
             who: T::AccountId,
             /// The drand round to reveal
@@ -103,7 +104,7 @@ pub mod pallet {
         /// A timelock-encrypted commitment was auto-revealed
         CommitmentRevealed {
             /// The netuid of the commitment
-            netuid: u16,
+            netuid: NetUid,
             /// The account
             who: T::AccountId,
         },
@@ -125,7 +126,7 @@ pub mod pallet {
     #[pallet::storage]
     #[pallet::getter(fn timelocked_index)]
     pub type TimelockedIndex<T: Config> =
-        StorageValue<_, BTreeSet<(u16, T::AccountId)>, ValueQuery>;
+        StorageValue<_, BTreeSet<(NetUid, T::AccountId)>, ValueQuery>;
 
     /// Identity data by account
     #[pallet::storage]
@@ -133,7 +134,7 @@ pub mod pallet {
     pub(super) type CommitmentOf<T: Config> = StorageDoubleMap<
         _,
         Identity,
-        u16,
+        NetUid,
         Twox64Concat,
         T::AccountId,
         Registration<BalanceOf<T>, T::MaxFields, BlockNumberFor<T>>,
@@ -145,7 +146,7 @@ pub mod pallet {
     pub(super) type LastCommitment<T: Config> = StorageDoubleMap<
         _,
         Identity,
-        u16,
+        NetUid,
         Twox64Concat,
         T::AccountId,
         BlockNumberFor<T>,
@@ -157,7 +158,7 @@ pub mod pallet {
     pub(super) type LastBondsReset<T: Config> = StorageDoubleMap<
         _,
         Identity,
-        u16,
+        NetUid,
         Twox64Concat,
         T::AccountId,
         BlockNumberFor<T>,
@@ -169,7 +170,7 @@ pub mod pallet {
     pub(super) type RevealedCommitments<T: Config> = StorageDoubleMap<
         _,
         Identity,
-        u16,
+        NetUid,
         Twox64Concat,
         T::AccountId,
         Vec<(Vec<u8>, u64)>, // Reveals<(Data, RevealBlock)>
@@ -181,7 +182,7 @@ pub mod pallet {
     #[pallet::storage]
     #[pallet::getter(fn used_space_of)]
     pub type UsedSpaceOf<T: Config> =
-        StorageDoubleMap<_, Identity, u16, Twox64Concat, T::AccountId, UsageTracker, OptionQuery>;
+        StorageDoubleMap<_, Identity, NetUid, Twox64Concat, T::AccountId, UsageTracker, OptionQuery>;
 
     #[pallet::type_value]
     /// The default Maximum Space
@@ -206,7 +207,7 @@ pub mod pallet {
         ))]
         pub fn set_commitment(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             info: Box<CommitmentInfo<T::MaxFields>>,
         ) -> DispatchResult {
             let who = ensure_signed(origin.clone())?;
@@ -366,21 +367,21 @@ pub mod pallet {
 
 // Interfaces to interact with other pallets
 pub trait CanCommit<AccountId> {
-    fn can_commit(netuid: u16, who: &AccountId) -> bool;
+    fn can_commit(netuid: NetUid, who: &AccountId) -> bool;
 }
 
 impl<A> CanCommit<A> for () {
-    fn can_commit(_: u16, _: &A) -> bool {
+    fn can_commit(_: NetUid, _: &A) -> bool {
         false
     }
 }
 
 pub trait OnMetadataCommitment<AccountId> {
-    fn on_metadata_commitment(netuid: u16, account: &AccountId);
+    fn on_metadata_commitment(netuid: NetUid, account: &AccountId);
 }
 
 impl<A> OnMetadataCommitment<A> for () {
-    fn on_metadata_commitment(_: u16, _: &A) {}
+    fn on_metadata_commitment(_: NetUid, _: &A) {}
 }
 
 /************************************************************
diff --git a/pallets/commitments/src/mock.rs b/pallets/commitments/src/mock.rs
index 4e6aa123bd..35831749d1 100644
--- a/pallets/commitments/src/mock.rs
+++ b/pallets/commitments/src/mock.rs
@@ -87,7 +87,7 @@ impl TypeInfo for TestMaxFields {
 
 pub struct TestCanCommit;
 impl pallet_commitments::CanCommit<u64> for TestCanCommit {
-    fn can_commit(_netuid: u16, _who: &u64) -> bool {
+    fn can_commit(_netuid: NetUid, _who: &u64) -> bool {
         true
     }
 }
@@ -106,7 +106,7 @@ impl pallet_commitments::Config for Test {
 
 pub struct MockTempoInterface;
 impl pallet_commitments::GetTempoInterface for MockTempoInterface {
-    fn get_epoch_index(netuid: u16, cur_block: u64) -> u64 {
+    fn get_epoch_index(netuid: NetUid, cur_block: u64) -> u64 {
         let tempo = 360; // TODO: configure SubtensorModule in this mock
         let tempo_plus_one: u64 = tempo.saturating_add(1);
         let netuid_plus_one: u64 = (netuid as u64).saturating_add(1);
diff --git a/pallets/commitments/src/tests.rs b/pallets/commitments/src/tests.rs
index 62e9444b76..37822f7ce3 100644
--- a/pallets/commitments/src/tests.rs
+++ b/pallets/commitments/src/tests.rs
@@ -1,5 +1,6 @@
 use codec::Encode;
 use sp_std::prelude::*;
+use subtensor_runtime_common::NetUid;
 
 #[cfg(test)]
 use crate::{
@@ -126,15 +127,15 @@ fn set_commitment_works() {
 
         assert_ok!(Pallet::<Test>::set_commitment(
             RuntimeOrigin::signed(1),
-            1,
+            1.into(),
             info.clone()
         ));
 
-        let commitment = Pallet::<Test>::commitment_of(1, 1).expect("Expected not to panic");
+        let commitment = Pallet::<Test>::commitment_of(NetUid::from(1), 1).expect("Expected not to panic");
         let initial_deposit: u64 = <Test as Config>::InitialDeposit::get();
         assert_eq!(commitment.deposit, initial_deposit);
         assert_eq!(commitment.block, 1);
-        assert_eq!(Pallet::<Test>::last_commitment(1, 1), Some(1));
+        assert_eq!(Pallet::<Test>::last_commitment(NetUid::from(1), 1), Some(1));
     });
 }
 
@@ -151,7 +152,7 @@ fn set_commitment_too_many_fields_panics() {
         });
 
         // We never get here, because the constructor panics above.
-        let _ = Pallet::<Test>::set_commitment(frame_system::RawOrigin::Signed(1).into(), 1, info);
+        let _ = Pallet::<Test>::set_commitment(frame_system::RawOrigin::Signed(1).into(), 1.into(), info);
     });
 }
 
@@ -170,14 +171,14 @@ fn set_commitment_updates_deposit() {
 
         assert_ok!(Pallet::<Test>::set_commitment(
             RuntimeOrigin::signed(1),
-            1,
+            1.into(),
             info1
         ));
         let initial_deposit: u64 = <Test as Config>::InitialDeposit::get();
         let field_deposit: u64 = <Test as Config>::FieldDeposit::get();
         let expected_deposit1: u64 = initial_deposit + 2u64 * field_deposit;
         assert_eq!(
-            Pallet::<Test>::commitment_of(1, 1)
+            Pallet::<Test>::commitment_of(NetUid::from(1), 1)
                 .expect("Expected not to panic")
                 .deposit,
             expected_deposit1
@@ -185,12 +186,12 @@ fn set_commitment_updates_deposit() {
 
         assert_ok!(Pallet::<Test>::set_commitment(
             RuntimeOrigin::signed(1),
-            1,
+            1.into(),
             info2
         ));
         let expected_deposit2: u64 = initial_deposit + 3u64 * field_deposit;
         assert_eq!(
-            Pallet::<Test>::commitment_of(1, 1)
+            Pallet::<Test>::commitment_of(NetUid::from(1), 1)
                 .expect("Expected not to panic")
                 .deposit,
             expected_deposit2
@@ -208,14 +209,14 @@ fn event_emission_works() {
 
         assert_ok!(Pallet::<Test>::set_commitment(
             RuntimeOrigin::signed(1),
-            1,
+            1.into(),
             info
         ));
 
         let events = System::<Test>::events();
         assert!(events.iter().any(|e| matches!(
             &e.event,
-            RuntimeEvent::Commitments(Event::Commitment { netuid: 1, who: 1 })
+            RuntimeEvent::Commitments(Event::Commitment { netuid: NetUid::from(1), who: 1 })
         )));
     });
 }
@@ -256,7 +257,7 @@ fn happy_path_timelock_commitments() {
         };
 
         let who = 123;
-        let netuid = 42;
+        let netuid = NetUid::from(42);
         System::<Test>::set_block_number(1);
 
         assert_ok!(Pallet::<Test>::set_commitment(
@@ -539,7 +540,7 @@ fn reveal_timelocked_multiple_fields_only_correct_ones_removed() {
 
         // 5) Insert the commitment
         let who = 123;
-        let netuid = 999;
+        let netuid = NetUid::from(999);
         System::<Test>::set_block_number(1);
         assert_ok!(Pallet::<Test>::set_commitment(
             RuntimeOrigin::signed(who),
@@ -1845,7 +1846,7 @@ fn multiple_timelocked_commitments_reveal_works() {
         let netuid = 999;
 
         // -------------------------------------------
-        // 2) Create multiple TLE fields referencing 
+        // 2) Create multiple TLE fields referencing
         //    two known valid Drand rounds: 1000, 2000
         // -------------------------------------------
 
diff --git a/precompiles/src/metagraph.rs b/precompiles/src/metagraph.rs
index 758ce8f8eb..4c8ec4e634 100644
--- a/precompiles/src/metagraph.rs
+++ b/precompiles/src/metagraph.rs
@@ -5,6 +5,7 @@ use fp_evm::{ExitError, PrecompileFailure, PrecompileHandle};
 use pallet_subtensor::AxonInfo as SubtensorModuleAxonInfo;
 use precompile_utils::{EvmResult, solidity::Codec};
 use sp_core::{ByteArray, H256};
+use subtensor_runtime_common::NetUid;
 
 use crate::PrecompileExt;
 
@@ -27,13 +28,13 @@ where
     #[precompile::public("getUidCount(uint16)")]
     #[precompile::view]
     fn get_uid_count(_: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<u16> {
-        Ok(pallet_subtensor::SubnetworkN::<R>::get(netuid))
+        Ok(pallet_subtensor::SubnetworkN::<R>::get(NetUid::from(netuid)))
     }
 
     #[precompile::public("getStake(uint16,uint16)")]
     #[precompile::view]
     fn get_stake(_: &mut impl PrecompileHandle, netuid: u16, uid: u16) -> EvmResult<u64> {
-        let hotkey = pallet_subtensor::Pallet::<R>::get_hotkey_for_net_and_uid(netuid, uid)
+        let hotkey = pallet_subtensor::Pallet::<R>::get_hotkey_for_net_and_uid(netuid.into(), uid)
             .map_err(|_| PrecompileFailure::Error {
                 exit_status: ExitError::InvalidRange,
             })?;
@@ -46,14 +47,14 @@ where
     #[precompile::public("getRank(uint16,uint16)")]
     #[precompile::view]
     fn get_rank(_: &mut impl PrecompileHandle, netuid: u16, uid: u16) -> EvmResult<u16> {
-        Ok(pallet_subtensor::Pallet::<R>::get_rank_for_uid(netuid, uid))
+        Ok(pallet_subtensor::Pallet::<R>::get_rank_for_uid(netuid.into(), uid))
     }
 
     #[precompile::public("getTrust(uint16,uint16)")]
     #[precompile::view]
     fn get_trust(_: &mut impl PrecompileHandle, netuid: u16, uid: u16) -> EvmResult<u16> {
         Ok(pallet_subtensor::Pallet::<R>::get_trust_for_uid(
-            netuid, uid,
+            netuid.into(), uid,
         ))
     }
 
@@ -61,7 +62,7 @@ where
     #[precompile::view]
     fn get_consensus(_: &mut impl PrecompileHandle, netuid: u16, uid: u16) -> EvmResult<u16> {
         Ok(pallet_subtensor::Pallet::<R>::get_consensus_for_uid(
-            netuid, uid,
+            netuid.into(), uid,
         ))
     }
 
@@ -69,7 +70,7 @@ where
     #[precompile::view]
     fn get_incentive(_: &mut impl PrecompileHandle, netuid: u16, uid: u16) -> EvmResult<u16> {
         Ok(pallet_subtensor::Pallet::<R>::get_incentive_for_uid(
-            netuid, uid,
+            netuid.into(), uid,
         ))
     }
 
@@ -77,7 +78,7 @@ where
     #[precompile::view]
     fn get_dividends(_: &mut impl PrecompileHandle, netuid: u16, uid: u16) -> EvmResult<u16> {
         Ok(pallet_subtensor::Pallet::<R>::get_dividends_for_uid(
-            netuid, uid,
+            netuid.into(), uid,
         ))
     }
 
@@ -85,7 +86,7 @@ where
     #[precompile::view]
     fn get_emission(_: &mut impl PrecompileHandle, netuid: u16, uid: u16) -> EvmResult<u64> {
         Ok(pallet_subtensor::Pallet::<R>::get_emission_for_uid(
-            netuid, uid,
+            netuid.into(), uid,
         ))
     }
 
@@ -93,7 +94,7 @@ where
     #[precompile::view]
     fn get_vtrust(_: &mut impl PrecompileHandle, netuid: u16, uid: u16) -> EvmResult<u16> {
         Ok(pallet_subtensor::Pallet::<R>::get_validator_trust_for_uid(
-            netuid, uid,
+            netuid.into(), uid,
         ))
     }
 
@@ -105,7 +106,7 @@ where
         uid: u16,
     ) -> EvmResult<bool> {
         Ok(pallet_subtensor::Pallet::<R>::get_validator_permit_for_uid(
-            netuid, uid,
+            netuid.into(), uid,
         ))
     }
 
@@ -113,7 +114,7 @@ where
     #[precompile::view]
     fn get_last_update(_: &mut impl PrecompileHandle, netuid: u16, uid: u16) -> EvmResult<u64> {
         Ok(pallet_subtensor::Pallet::<R>::get_last_update_for_uid(
-            netuid, uid,
+            netuid.into(), uid,
         ))
     }
 
@@ -121,25 +122,25 @@ where
     #[precompile::view]
     fn get_is_active(_: &mut impl PrecompileHandle, netuid: u16, uid: u16) -> EvmResult<bool> {
         Ok(pallet_subtensor::Pallet::<R>::get_active_for_uid(
-            netuid, uid,
+            netuid.into(), uid,
         ))
     }
 
     #[precompile::public("getAxon(uint16,uint16)")]
     #[precompile::view]
     fn get_axon(_: &mut impl PrecompileHandle, netuid: u16, uid: u16) -> EvmResult<AxonInfo> {
-        let hotkey = pallet_subtensor::Pallet::<R>::get_hotkey_for_net_and_uid(netuid, uid)
+        let hotkey = pallet_subtensor::Pallet::<R>::get_hotkey_for_net_and_uid(netuid.into(), uid)
             .map_err(|_| PrecompileFailure::Error {
                 exit_status: ExitError::Other("hotkey not found".into()),
             })?;
 
-        Ok(pallet_subtensor::Pallet::<R>::get_axon_info(netuid, &hotkey).into())
+        Ok(pallet_subtensor::Pallet::<R>::get_axon_info(netuid.into(), &hotkey).into())
     }
 
     #[precompile::public("getHotkey(uint16,uint16)")]
     #[precompile::view]
     fn get_hotkey(_: &mut impl PrecompileHandle, netuid: u16, uid: u16) -> EvmResult<H256> {
-        pallet_subtensor::Pallet::<R>::get_hotkey_for_net_and_uid(netuid, uid)
+        pallet_subtensor::Pallet::<R>::get_hotkey_for_net_and_uid(netuid.into(), uid)
             .map(|acc| H256::from_slice(acc.as_slice()))
             .map_err(|_| PrecompileFailure::Error {
                 exit_status: ExitError::InvalidRange,
@@ -149,7 +150,7 @@ where
     #[precompile::public("getColdkey(uint16,uint16)")]
     #[precompile::view]
     fn get_coldkey(_: &mut impl PrecompileHandle, netuid: u16, uid: u16) -> EvmResult<H256> {
-        let hotkey = pallet_subtensor::Pallet::<R>::get_hotkey_for_net_and_uid(netuid, uid)
+        let hotkey = pallet_subtensor::Pallet::<R>::get_hotkey_for_net_and_uid(netuid.into(), uid)
             .map_err(|_| PrecompileFailure::Error {
                 exit_status: ExitError::InvalidRange,
             })?;
diff --git a/precompiles/src/neuron.rs b/precompiles/src/neuron.rs
index cedb3a56db..46f8333690 100644
--- a/precompiles/src/neuron.rs
+++ b/precompiles/src/neuron.rs
@@ -44,7 +44,7 @@ where
         version_key: u64,
     ) -> EvmResult<()> {
         let call = pallet_subtensor::Call::<R>::set_weights {
-            netuid,
+            netuid: netuid.into(),
             dests,
             weights,
             version_key,
@@ -64,7 +64,7 @@ where
         commit_hash: H256,
     ) -> EvmResult<()> {
         let call = pallet_subtensor::Call::<R>::commit_weights {
-            netuid,
+            netuid: netuid.into(),
             commit_hash,
         };
 
@@ -85,7 +85,7 @@ where
         version_key: u64,
     ) -> EvmResult<()> {
         let call = pallet_subtensor::Call::<R>::reveal_weights {
-            netuid,
+            netuid: netuid.into(),
             uids,
             values,
             salt,
@@ -107,7 +107,7 @@ where
     ) -> EvmResult<()> {
         let coldkey = handle.caller_account_id::<R>();
         let hotkey = R::AccountId::from(hotkey.0);
-        let call = pallet_subtensor::Call::<R>::burned_register { netuid, hotkey };
+        let call = pallet_subtensor::Call::<R>::burned_register { netuid: netuid.into(), hotkey };
 
         handle.try_dispatch_runtime_call::<R, _>(call, RawOrigin::Signed(coldkey))
     }
@@ -127,7 +127,7 @@ where
         placeholder2: u8,
     ) -> EvmResult<()> {
         let call = pallet_subtensor::Call::<R>::serve_axon {
-            netuid,
+            netuid: netuid.into(),
             version,
             ip,
             port,
@@ -161,7 +161,7 @@ where
         certificate: UnboundedBytes,
     ) -> EvmResult<()> {
         let call = pallet_subtensor::Call::<R>::serve_axon_tls {
-            netuid,
+            netuid: netuid.into(),
             version,
             ip,
             port,
@@ -190,7 +190,7 @@ where
         ip_type: u8,
     ) -> EvmResult<()> {
         let call = pallet_subtensor::Call::<R>::serve_prometheus {
-            netuid,
+            netuid: netuid.into(),
             version,
             ip,
             port,
diff --git a/precompiles/src/staking.rs b/precompiles/src/staking.rs
index 21f50bc917..a996ce7494 100644
--- a/precompiles/src/staking.rs
+++ b/precompiles/src/staking.rs
@@ -37,7 +37,7 @@ use precompile_utils::EvmResult;
 use sp_core::{H256, U256};
 use sp_runtime::traits::{Dispatchable, StaticLookup, UniqueSaturatedInto};
 use sp_std::vec;
-use subtensor_runtime_common::ProxyType;
+use subtensor_runtime_common::{ProxyType, NetUid};
 
 use crate::{PrecompileExt, PrecompileHandleExt};
 
@@ -94,7 +94,7 @@ where
         let netuid = try_u16_from_u256(netuid)?;
         let call = pallet_subtensor::Call::<R>::add_stake {
             hotkey,
-            netuid,
+            netuid: netuid.into(),
             amount_staked,
         };
 
@@ -114,7 +114,7 @@ where
         let amount_unstaked = amount_alpha.unique_saturated_into();
         let call = pallet_subtensor::Call::<R>::remove_stake {
             hotkey,
-            netuid,
+            netuid: netuid.into(),
             amount_unstaked,
         };
 
@@ -139,8 +139,8 @@ where
         let call = pallet_subtensor::Call::<R>::move_stake {
             origin_hotkey,
             destination_hotkey,
-            origin_netuid,
-            destination_netuid,
+            origin_netuid: origin_netuid.into(),
+            destination_netuid: destination_netuid.into(),
             alpha_amount,
         };
 
@@ -165,8 +165,8 @@ where
         let call = pallet_subtensor::Call::<R>::transfer_stake {
             destination_coldkey,
             hotkey,
-            origin_netuid,
-            destination_netuid,
+            origin_netuid: origin_netuid.into(),
+            destination_netuid: destination_netuid.into(),
             alpha_amount,
         };
 
@@ -209,7 +209,7 @@ where
         let coldkey = R::AccountId::from(coldkey.0);
         let netuid = try_u16_from_u256(netuid)?;
         let stake = pallet_subtensor::Pallet::<R>::get_stake_for_hotkey_and_coldkey_on_subnet(
-            &hotkey, &coldkey, netuid,
+            &hotkey, &coldkey, netuid.into(),
         );
 
         Ok(stake.into())
@@ -224,7 +224,7 @@ where
     ) -> EvmResult<Vec<H256>> {
         let hotkey = R::AccountId::from(hotkey.0);
         let mut coldkeys: Vec<H256> = vec![];
-        let netuid = try_u16_from_u256(netuid)?;
+        let netuid = NetUid::from(try_u16_from_u256(netuid)?);
         for ((coldkey, netuid_in_alpha), _) in pallet_subtensor::Alpha::<R>::iter_prefix((hotkey,))
         {
             if netuid == netuid_in_alpha {
@@ -245,7 +245,7 @@ where
     ) -> EvmResult<U256> {
         let hotkey = R::AccountId::from(hotkey.0);
         let netuid = try_u16_from_u256(netuid)?;
-        let stake = pallet_subtensor::Pallet::<R>::get_stake_for_hotkey_on_subnet(&hotkey, netuid);
+        let stake = pallet_subtensor::Pallet::<R>::get_stake_for_hotkey_on_subnet(&hotkey, netuid.into());
 
         Ok(stake.into())
     }
@@ -294,7 +294,7 @@ where
         let netuid = try_u16_from_u256(netuid)?;
         let call = pallet_subtensor::Call::<R>::add_stake_limit {
             hotkey,
-            netuid,
+            netuid: netuid.into(),
             amount_staked,
             limit_price,
             allow_partial,
@@ -319,7 +319,7 @@ where
         let limit_price = limit_price_rao.unique_saturated_into();
         let call = pallet_subtensor::Call::<R>::remove_stake_limit {
             hotkey,
-            netuid,
+            netuid: netuid.into(),
             amount_unstaked,
             limit_price,
             allow_partial,
@@ -385,7 +385,7 @@ where
         let netuid = try_u16_from_u256(netuid)?;
         let call = pallet_subtensor::Call::<R>::add_stake {
             hotkey,
-            netuid,
+            netuid: netuid.into(),
             amount_staked: amount_sub.unique_saturated_into(),
         };
 
@@ -409,7 +409,7 @@ where
                 .ok_or(ExitError::OutOfFund)?;
         let call = pallet_subtensor::Call::<R>::remove_stake {
             hotkey,
-            netuid,
+            netuid: netuid.into(),
             amount_unstaked,
         };
 
@@ -466,7 +466,7 @@ where
         let coldkey = R::AccountId::from(coldkey.0);
         let netuid = try_u16_from_u256(netuid)?;
         let stake = pallet_subtensor::Pallet::<R>::get_stake_for_hotkey_and_coldkey_on_subnet(
-            &hotkey, &coldkey, netuid,
+            &hotkey, &coldkey, netuid.into(),
         );
         let stake: SubstrateBalance = stake.into();
         let stake = <R as pallet_evm::Config>::BalanceConverter::into_evm_balance(stake)
diff --git a/precompiles/src/subnet.rs b/precompiles/src/subnet.rs
index 7d4dd175e3..ce572242bc 100644
--- a/precompiles/src/subnet.rs
+++ b/precompiles/src/subnet.rs
@@ -7,6 +7,7 @@ use pallet_evm::{AddressMapping, PrecompileHandle};
 use precompile_utils::{EvmResult, prelude::BoundedString};
 use sp_core::H256;
 use sp_runtime::traits::Dispatchable;
+use subtensor_runtime_common::NetUid;
 
 use crate::{PrecompileExt, PrecompileHandleExt};
 
@@ -98,7 +99,7 @@ where
     #[precompile::public("getServingRateLimit(uint16)")]
     #[precompile::view]
     fn get_serving_rate_limit(_: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<u64> {
-        Ok(pallet_subtensor::ServingRateLimit::<R>::get(netuid))
+        Ok(pallet_subtensor::ServingRateLimit::<R>::get(NetUid::from(netuid)))
     }
 
     #[precompile::public("setServingRateLimit(uint16,uint64)")]
@@ -109,7 +110,7 @@ where
         serving_rate_limit: u64,
     ) -> EvmResult<()> {
         let call = pallet_admin_utils::Call::<R>::sudo_set_serving_rate_limit {
-            netuid,
+            netuid: netuid.into(),
             serving_rate_limit,
         };
 
@@ -122,7 +123,7 @@ where
     #[precompile::public("getMinDifficulty(uint16)")]
     #[precompile::view]
     fn get_min_difficulty(_: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<u64> {
-        Ok(pallet_subtensor::MinDifficulty::<R>::get(netuid))
+        Ok(pallet_subtensor::MinDifficulty::<R>::get(NetUid::from(netuid)))
     }
 
     #[precompile::public("setMinDifficulty(uint16,uint64)")]
@@ -133,7 +134,7 @@ where
         min_difficulty: u64,
     ) -> EvmResult<()> {
         let call = pallet_admin_utils::Call::<R>::sudo_set_min_difficulty {
-            netuid,
+            netuid: netuid.into(),
             min_difficulty,
         };
 
@@ -146,7 +147,7 @@ where
     #[precompile::public("getMaxDifficulty(uint16)")]
     #[precompile::view]
     fn get_max_difficulty(_: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<u64> {
-        Ok(pallet_subtensor::MaxDifficulty::<R>::get(netuid))
+        Ok(pallet_subtensor::MaxDifficulty::<R>::get(NetUid::from(netuid)))
     }
 
     #[precompile::public("setMaxDifficulty(uint16,uint64)")]
@@ -157,7 +158,7 @@ where
         max_difficulty: u64,
     ) -> EvmResult<()> {
         let call = pallet_admin_utils::Call::<R>::sudo_set_max_difficulty {
-            netuid,
+            netuid: netuid.into(),
             max_difficulty,
         };
 
@@ -170,7 +171,7 @@ where
     #[precompile::public("getWeightsVersionKey(uint16)")]
     #[precompile::view]
     fn get_weights_version_key(_: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<u64> {
-        Ok(pallet_subtensor::WeightsVersionKey::<R>::get(netuid))
+        Ok(pallet_subtensor::WeightsVersionKey::<R>::get(NetUid::from(netuid)))
     }
 
     #[precompile::public("setWeightsVersionKey(uint16,uint64)")]
@@ -181,7 +182,7 @@ where
         weights_version_key: u64,
     ) -> EvmResult<()> {
         let call = pallet_admin_utils::Call::<R>::sudo_set_weights_version_key {
-            netuid,
+            netuid: netuid.into(),
             weights_version_key,
         };
 
@@ -194,7 +195,7 @@ where
     #[precompile::public("getWeightsSetRateLimit(uint16)")]
     #[precompile::view]
     fn get_weights_set_rate_limit(_: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<u64> {
-        Ok(pallet_subtensor::WeightsSetRateLimit::<R>::get(netuid))
+        Ok(pallet_subtensor::WeightsSetRateLimit::<R>::get(NetUid::from(netuid)))
     }
 
     #[precompile::public("setWeightsSetRateLimit(uint16,uint64)")]
@@ -211,7 +212,7 @@ where
     #[precompile::public("getAdjustmentAlpha(uint16)")]
     #[precompile::view]
     fn get_adjustment_alpha(_: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<u64> {
-        Ok(pallet_subtensor::AdjustmentAlpha::<R>::get(netuid))
+        Ok(pallet_subtensor::AdjustmentAlpha::<R>::get(NetUid::from(netuid)))
     }
 
     #[precompile::public("setAdjustmentAlpha(uint16,uint64)")]
@@ -222,7 +223,7 @@ where
         adjustment_alpha: u64,
     ) -> EvmResult<()> {
         let call = pallet_admin_utils::Call::<R>::sudo_set_adjustment_alpha {
-            netuid,
+            netuid: netuid.into(),
             adjustment_alpha,
         };
 
@@ -235,7 +236,7 @@ where
     #[precompile::public("getMaxWeightLimit(uint16)")]
     #[precompile::view]
     fn get_max_weight_limit(_: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<u16> {
-        Ok(pallet_subtensor::MaxWeightsLimit::<R>::get(netuid))
+        Ok(pallet_subtensor::MaxWeightsLimit::<R>::get(NetUid::from(netuid)))
     }
 
     #[precompile::public("setMaxWeightLimit(uint16,uint16)")]
@@ -246,7 +247,7 @@ where
         max_weight_limit: u16,
     ) -> EvmResult<()> {
         let call = pallet_admin_utils::Call::<R>::sudo_set_max_weight_limit {
-            netuid,
+            netuid: netuid.into(),
             max_weight_limit,
         };
 
@@ -259,7 +260,7 @@ where
     #[precompile::public("getImmunityPeriod(uint16)")]
     #[precompile::view]
     fn get_immunity_period(_: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<u16> {
-        Ok(pallet_subtensor::ImmunityPeriod::<R>::get(netuid))
+        Ok(pallet_subtensor::ImmunityPeriod::<R>::get(NetUid::from(netuid)))
     }
 
     #[precompile::public("setImmunityPeriod(uint16,uint16)")]
@@ -270,7 +271,7 @@ where
         immunity_period: u16,
     ) -> EvmResult<()> {
         let call = pallet_admin_utils::Call::<R>::sudo_set_immunity_period {
-            netuid,
+            netuid: netuid.into(),
             immunity_period,
         };
 
@@ -283,7 +284,7 @@ where
     #[precompile::public("getMinAllowedWeights(uint16)")]
     #[precompile::view]
     fn get_min_allowed_weights(_: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<u16> {
-        Ok(pallet_subtensor::MinAllowedWeights::<R>::get(netuid))
+        Ok(pallet_subtensor::MinAllowedWeights::<R>::get(NetUid::from(netuid)))
     }
 
     #[precompile::public("setMinAllowedWeights(uint16,uint16)")]
@@ -294,7 +295,7 @@ where
         min_allowed_weights: u16,
     ) -> EvmResult<()> {
         let call = pallet_admin_utils::Call::<R>::sudo_set_min_allowed_weights {
-            netuid,
+            netuid: netuid.into(),
             min_allowed_weights,
         };
 
@@ -307,13 +308,13 @@ where
     #[precompile::public("getKappa(uint16)")]
     #[precompile::view]
     fn get_kappa(_: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<u16> {
-        Ok(pallet_subtensor::Kappa::<R>::get(netuid))
+        Ok(pallet_subtensor::Kappa::<R>::get(NetUid::from(netuid)))
     }
 
     #[precompile::public("setKappa(uint16,uint16)")]
     #[precompile::payable]
     fn set_kappa(handle: &mut impl PrecompileHandle, netuid: u16, kappa: u16) -> EvmResult<()> {
-        let call = pallet_admin_utils::Call::<R>::sudo_set_kappa { netuid, kappa };
+        let call = pallet_admin_utils::Call::<R>::sudo_set_kappa { netuid: netuid.into(), kappa };
 
         handle.try_dispatch_runtime_call::<R, _>(
             call,
@@ -324,19 +325,19 @@ where
     #[precompile::public("getRho(uint16)")]
     #[precompile::view]
     fn get_rho(_: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<u16> {
-        Ok(pallet_subtensor::Rho::<R>::get(netuid))
+        Ok(pallet_subtensor::Rho::<R>::get(NetUid::from(netuid)))
     }
 
     #[precompile::public("getAlphaSigmoidSteepness(uint16)")]
     #[precompile::view]
     fn get_alpha_sigmoid_steepness(_: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<u16> {
-        Ok(pallet_subtensor::AlphaSigmoidSteepness::<R>::get(netuid))
+        Ok(pallet_subtensor::AlphaSigmoidSteepness::<R>::get(NetUid::from(netuid)))
     }
 
     #[precompile::public("setRho(uint16,uint16)")]
     #[precompile::payable]
     fn set_rho(handle: &mut impl PrecompileHandle, netuid: u16, rho: u16) -> EvmResult<()> {
-        let call = pallet_admin_utils::Call::<R>::sudo_set_rho { netuid, rho };
+        let call = pallet_admin_utils::Call::<R>::sudo_set_rho { netuid: netuid.into(), rho };
 
         handle.try_dispatch_runtime_call::<R, _>(
             call,
@@ -352,7 +353,7 @@ where
         steepness: u16,
     ) -> EvmResult<()> {
         let call =
-            pallet_admin_utils::Call::<R>::sudo_set_alpha_sigmoid_steepness { netuid, steepness };
+            pallet_admin_utils::Call::<R>::sudo_set_alpha_sigmoid_steepness { netuid: netuid.into(), steepness };
 
         handle.try_dispatch_runtime_call::<R, _>(
             call,
@@ -363,7 +364,7 @@ where
     #[precompile::public("getActivityCutoff(uint16)")]
     #[precompile::view]
     fn get_activity_cutoff(_: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<u16> {
-        Ok(pallet_subtensor::ActivityCutoff::<R>::get(netuid))
+        Ok(pallet_subtensor::ActivityCutoff::<R>::get(NetUid::from(netuid)))
     }
 
     #[precompile::public("setActivityCutoff(uint16,uint16)")]
@@ -374,7 +375,7 @@ where
         activity_cutoff: u16,
     ) -> EvmResult<()> {
         let call = pallet_admin_utils::Call::<R>::sudo_set_activity_cutoff {
-            netuid,
+            netuid: netuid.into(),
             activity_cutoff,
         };
 
@@ -391,7 +392,7 @@ where
         netuid: u16,
     ) -> EvmResult<bool> {
         Ok(pallet_subtensor::NetworkRegistrationAllowed::<R>::get(
-            netuid,
+            NetUid::from(netuid),
         ))
     }
 
@@ -403,7 +404,7 @@ where
         registration_allowed: bool,
     ) -> EvmResult<()> {
         let call = pallet_admin_utils::Call::<R>::sudo_set_network_registration_allowed {
-            netuid,
+            netuid: netuid.into(),
             registration_allowed,
         };
 
@@ -420,7 +421,7 @@ where
         netuid: u16,
     ) -> EvmResult<bool> {
         Ok(pallet_subtensor::NetworkPowRegistrationAllowed::<R>::get(
-            netuid,
+            NetUid::from(netuid),
         ))
     }
 
@@ -432,7 +433,7 @@ where
         registration_allowed: bool,
     ) -> EvmResult<()> {
         let call = pallet_admin_utils::Call::<R>::sudo_set_network_pow_registration_allowed {
-            netuid,
+            netuid: netuid.into(),
             registration_allowed,
         };
 
@@ -445,7 +446,7 @@ where
     #[precompile::public("getMinBurn(uint16)")]
     #[precompile::view]
     fn get_min_burn(_: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<u64> {
-        Ok(pallet_subtensor::MinBurn::<R>::get(netuid))
+        Ok(pallet_subtensor::MinBurn::<R>::get(NetUid::from(netuid)))
     }
 
     #[precompile::public("setMinBurn(uint16,uint64)")]
@@ -462,7 +463,7 @@ where
     #[precompile::public("getMaxBurn(uint16)")]
     #[precompile::view]
     fn get_max_burn(_: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<u64> {
-        Ok(pallet_subtensor::MaxBurn::<R>::get(netuid))
+        Ok(pallet_subtensor::MaxBurn::<R>::get(NetUid::from(netuid)))
     }
 
     #[precompile::public("setMaxBurn(uint16,uint64)")]
@@ -479,7 +480,7 @@ where
     #[precompile::public("getDifficulty(uint16)")]
     #[precompile::view]
     fn get_difficulty(_: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<u64> {
-        Ok(pallet_subtensor::Difficulty::<R>::get(netuid))
+        Ok(pallet_subtensor::Difficulty::<R>::get(NetUid::from(netuid)))
     }
 
     #[precompile::public("setDifficulty(uint16,uint64)")]
@@ -489,7 +490,7 @@ where
         netuid: u16,
         difficulty: u64,
     ) -> EvmResult<()> {
-        let call = pallet_admin_utils::Call::<R>::sudo_set_difficulty { netuid, difficulty };
+        let call = pallet_admin_utils::Call::<R>::sudo_set_difficulty { netuid: netuid.into(), difficulty };
 
         handle.try_dispatch_runtime_call::<R, _>(
             call,
@@ -500,7 +501,7 @@ where
     #[precompile::public("getBondsMovingAverage(uint16)")]
     #[precompile::view]
     fn get_bonds_moving_average(_: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<u64> {
-        Ok(pallet_subtensor::BondsMovingAverage::<R>::get(netuid))
+        Ok(pallet_subtensor::BondsMovingAverage::<R>::get(NetUid::from(netuid)))
     }
 
     #[precompile::public("setBondsMovingAverage(uint16,uint64)")]
@@ -511,7 +512,7 @@ where
         bonds_moving_average: u64,
     ) -> EvmResult<()> {
         let call = pallet_admin_utils::Call::<R>::sudo_set_bonds_moving_average {
-            netuid,
+            netuid: netuid.into(),
             bonds_moving_average,
         };
 
@@ -528,7 +529,7 @@ where
         netuid: u16,
     ) -> EvmResult<bool> {
         Ok(pallet_subtensor::CommitRevealWeightsEnabled::<R>::get(
-            netuid,
+            NetUid::from(netuid),
         ))
     }
 
@@ -540,7 +541,7 @@ where
         enabled: bool,
     ) -> EvmResult<()> {
         let call = pallet_admin_utils::Call::<R>::sudo_set_commit_reveal_weights_enabled {
-            netuid,
+            netuid: netuid.into(),
             enabled,
         };
 
@@ -553,7 +554,7 @@ where
     #[precompile::public("getLiquidAlphaEnabled(uint16)")]
     #[precompile::view]
     fn get_liquid_alpha_enabled(_: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<bool> {
-        Ok(pallet_subtensor::LiquidAlphaOn::<R>::get(netuid))
+        Ok(pallet_subtensor::LiquidAlphaOn::<R>::get(NetUid::from(netuid)))
     }
 
     #[precompile::public("setLiquidAlphaEnabled(uint16,bool)")]
@@ -563,7 +564,7 @@ where
         netuid: u16,
         enabled: bool,
     ) -> EvmResult<()> {
-        let call = pallet_admin_utils::Call::<R>::sudo_set_liquid_alpha_enabled { netuid, enabled };
+        let call = pallet_admin_utils::Call::<R>::sudo_set_liquid_alpha_enabled { netuid: netuid.into(), enabled };
 
         handle.try_dispatch_runtime_call::<R, _>(
             call,
@@ -574,7 +575,7 @@ where
     #[precompile::public("getYuma3Enabled(uint16)")]
     #[precompile::view]
     fn get_yuma3_enabled(_: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<bool> {
-        Ok(pallet_subtensor::Yuma3On::<R>::get(netuid))
+        Ok(pallet_subtensor::Yuma3On::<R>::get(NetUid::from(netuid)))
     }
 
     #[precompile::public("setYuma3Enabled(uint16,bool)")]
@@ -584,7 +585,7 @@ where
         netuid: u16,
         enabled: bool,
     ) -> EvmResult<()> {
-        let call = pallet_admin_utils::Call::<R>::sudo_set_yuma3_enabled { netuid, enabled };
+        let call = pallet_admin_utils::Call::<R>::sudo_set_yuma3_enabled { netuid: netuid.into(), enabled };
 
         handle.try_dispatch_runtime_call::<R, _>(
             call,
@@ -595,7 +596,7 @@ where
     #[precompile::public("getAlphaValues(uint16)")]
     #[precompile::view]
     fn get_alpha_values(_: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<(u16, u16)> {
-        Ok(pallet_subtensor::AlphaValues::<R>::get(netuid))
+        Ok(pallet_subtensor::AlphaValues::<R>::get(NetUid::from(netuid)))
     }
 
     #[precompile::public("setAlphaValues(uint16,uint16,uint16)")]
@@ -607,7 +608,7 @@ where
         alpha_high: u16,
     ) -> EvmResult<()> {
         let call = pallet_admin_utils::Call::<R>::sudo_set_alpha_values {
-            netuid,
+            netuid: netuid.into(),
             alpha_low,
             alpha_high,
         };
@@ -624,7 +625,7 @@ where
         _: &mut impl PrecompileHandle,
         netuid: u16,
     ) -> EvmResult<u64> {
-        Ok(pallet_subtensor::RevealPeriodEpochs::<R>::get(netuid))
+        Ok(pallet_subtensor::RevealPeriodEpochs::<R>::get(NetUid::from(netuid)))
     }
 
     #[precompile::public("setCommitRevealWeightsInterval(uint16,uint64)")]
@@ -635,7 +636,7 @@ where
         interval: u64,
     ) -> EvmResult<()> {
         let call = pallet_admin_utils::Call::<R>::sudo_set_commit_reveal_weights_interval {
-            netuid,
+            netuid: netuid.into(),
             interval,
         };
 
@@ -652,7 +653,7 @@ where
         netuid: u16,
         toggle: bool,
     ) -> EvmResult<()> {
-        let call = pallet_admin_utils::Call::<R>::sudo_set_toggle_transfer { netuid, toggle };
+        let call = pallet_admin_utils::Call::<R>::sudo_set_toggle_transfer { netuid: netuid.into(), toggle };
 
         handle.try_dispatch_runtime_call::<R, _>(
             call,
diff --git a/precompiles/src/uid_lookup.rs b/precompiles/src/uid_lookup.rs
index 61fb9d6d7f..be8c803b45 100644
--- a/precompiles/src/uid_lookup.rs
+++ b/precompiles/src/uid_lookup.rs
@@ -45,7 +45,7 @@ where
         limit: u16,
     ) -> EvmResult<Vec<(u16, u64)>> {
         Ok(pallet_subtensor::Pallet::<R>::uid_lookup(
-            netuid,
+            netuid.into(),
             evm_address.0,
             limit,
         ))
diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index 27fed3ec0a..e55f6db4cf 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -1030,13 +1030,13 @@ impl pallet_commitments::Config for Runtime {
 
 pub struct TempoInterface;
 impl pallet_commitments::GetTempoInterface for TempoInterface {
-    fn get_epoch_index(netuid: u16, cur_block: u64) -> u64 {
+    fn get_epoch_index(netuid: NetUid, cur_block: u64) -> u64 {
         SubtensorModule::get_epoch_index(netuid, cur_block)
     }
 }
 
 impl pallet_commitments::GetTempoInterface for Runtime {
-    fn get_epoch_index(netuid: u16, cur_block: u64) -> u64 {
+    fn get_epoch_index(netuid: NetUid, cur_block: u64) -> u64 {
         SubtensorModule::get_epoch_index(netuid, cur_block)
     }
 }

From ddde7d1d1f37f7e62fb09574f2366daf7be49cb0 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Mon, 9 Jun 2025 14:13:48 -0400
Subject: [PATCH 262/418] Update Position comment, make it Rust style

---
 pallets/swap/src/position.rs | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/pallets/swap/src/position.rs b/pallets/swap/src/position.rs
index a5abbb6a00..f97ca0257c 100644
--- a/pallets/swap/src/position.rs
+++ b/pallets/swap/src/position.rs
@@ -15,23 +15,25 @@ use crate::tick::TickIndex;
 ///
 /// Alpha price is expressed in rao units per one 10^9 unit. For example,
 /// price 1_000_000 is equal to 0.001 TAO per Alpha.
-///
-/// tick_low - tick index for lower boundary of price
-/// tick_high - tick index for higher boundary of price
-/// liquidity - position liquidity
-/// fees_tao - fees accrued by the position in quote currency (TAO)
-/// fees_alpha - fees accrued by the position in base currency (Alpha)
 #[freeze_struct("1b4be598fdbdca93")]
 #[derive(Clone, Encode, Decode, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen, Default)]
 #[scale_info(skip_type_params(T))]
 pub struct Position<T: Config> {
+    /// Unique ID of the position
     pub id: PositionId,
+    /// Network identifier
     pub netuid: NetUid,
+    /// Tick index for lower boundary of price
     pub tick_low: TickIndex,
+    /// Tick index for higher boundary of price
     pub tick_high: TickIndex,
+    /// Position liquidity
     pub liquidity: u64,
+    /// Fees accrued by the position in quote currency (TAO)
     pub fees_tao: U64F64,
+    /// Fees accrued by the position in base currency (Alpha)
     pub fees_alpha: U64F64,
+    /// Phantom marker for generic Config type
     pub _phantom: PhantomData<T>,
 }
 

From 6db7de558136073157d83a086ff924f6ebc0dfb6 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Mon, 9 Jun 2025 14:15:18 -0400
Subject: [PATCH 263/418] Remove empty swap README

---
 pallets/swap/README.md | 20 --------------------
 1 file changed, 20 deletions(-)
 delete mode 100644 pallets/swap/README.md

diff --git a/pallets/swap/README.md b/pallets/swap/README.md
deleted file mode 100644
index 2a9ca39ec4..0000000000
--- a/pallets/swap/README.md
+++ /dev/null
@@ -1,20 +0,0 @@
-# Swap pallet
-
-This pallet implements uniswap v3 algorithm. Below is the basic description of it.
-
-## Glossary
-
-### Ticks
-
-### Liquidity Positions
-
-### Active Ticks
-
-### Current Price and Tick
-
-### Current Liquidity
-
-
-
-## Executing Swap 
-

From bcc49d29f657843674d5f4cee9f0550e162ac3f5 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Mon, 9 Jun 2025 14:16:05 -0400
Subject: [PATCH 264/418] Remove forgotten debug comment

---
 pallets/subtensor/src/staking/remove_stake.rs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/pallets/subtensor/src/staking/remove_stake.rs b/pallets/subtensor/src/staking/remove_stake.rs
index fb51b178bc..001e66b091 100644
--- a/pallets/subtensor/src/staking/remove_stake.rs
+++ b/pallets/subtensor/src/staking/remove_stake.rs
@@ -72,8 +72,6 @@ impl<T: Config> Pallet<T> {
             T::SwapInterface::min_price(),
         )?;
 
-        // println!("tao_unstaked = {:?}, alpha_unstaked = {:?}", tao_unstaked, alpha_unstaked);
-
         // 4. We add the balance to the coldkey. If the above fails we will not credit this coldkey.
         Self::add_balance_to_coldkey_account(&coldkey, tao_unstaked);
 

From 1d164694bca77816dbc2b9a09f4ed65e3cec3df8 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Mon, 9 Jun 2025 14:26:07 -0400
Subject: [PATCH 265/418] Fix freeze_struct

---
 pallets/swap/src/position.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pallets/swap/src/position.rs b/pallets/swap/src/position.rs
index f97ca0257c..a2ce000446 100644
--- a/pallets/swap/src/position.rs
+++ b/pallets/swap/src/position.rs
@@ -15,7 +15,7 @@ use crate::tick::TickIndex;
 ///
 /// Alpha price is expressed in rao units per one 10^9 unit. For example,
 /// price 1_000_000 is equal to 0.001 TAO per Alpha.
-#[freeze_struct("1b4be598fdbdca93")]
+#[freeze_struct("64d56db027265714")]
 #[derive(Clone, Encode, Decode, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen, Default)]
 #[scale_info(skip_type_params(T))]
 pub struct Position<T: Config> {

From 6489d6a464e9ee0bd9bd0a26406f6cc0b9d6dee1 Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Mon, 9 Jun 2025 22:11:22 +0200
Subject: [PATCH 266/418] bump frame-metadata version

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index c246c94a4d..1ee75e34d3 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6580,7 +6580,7 @@ dependencies = [
  "fp-self-contained",
  "frame-benchmarking",
  "frame-executive",
- "frame-metadata 16.0.0",
+ "frame-metadata 18.0.0",
  "frame-metadata-hash-extension",
  "frame-support",
  "frame-system",
diff --git a/Cargo.toml b/Cargo.toml
index db7cd8dfec..6785f420c6 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -109,6 +109,7 @@ frame-system = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "
 frame-system-benchmarking = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
 frame-system-rpc-runtime-api = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
 frame-try-runtime = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
+frame-metadata = "18.0.0"
 
 pallet-aura = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
 pallet-balances = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
@@ -245,7 +246,6 @@ sha2 = { version = "0.10.8", default-features = false }
 rand_chacha = { version = "0.3.1", default-features = false }
 tle = { git = "https://github.com/ideal-lab5/timelock", rev = "5416406cfd32799e31e1795393d4916894de4468", default-features = false }
 
-frame-metadata = "16"
 
 [profile.release]
 panic = "unwind"

From c91f4b076190dc8cbf2526033627463678768825 Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Mon, 9 Jun 2025 23:26:40 +0200
Subject: [PATCH 267/418] fix weight field renaming

---
 pallets/collective/src/tests.rs             | 30 ++++++++++-----------
 pallets/subtensor/src/tests/registration.rs |  3 ++-
 pallets/subtensor/src/tests/serving.rs      |  6 +++--
 pallets/subtensor/src/tests/staking.rs      |  6 +++--
 pallets/subtensor/src/tests/staking2.rs     |  2 +-
 5 files changed, 26 insertions(+), 21 deletions(-)

diff --git a/pallets/collective/src/tests.rs b/pallets/collective/src/tests.rs
index ae3ad69c8d..46c10f52e2 100644
--- a/pallets/collective/src/tests.rs
+++ b/pallets/collective/src/tests.rs
@@ -26,12 +26,12 @@ use frame_system::{EnsureRoot, EventRecord, Phase};
 use sp_core::H256;
 use sp_runtime::{
     BuildStorage,
-    testing::Header,
+    testing::{Header, TestXt},
     traits::{BlakeTwo256, IdentityLookup},
 };
 
 pub type Block = sp_runtime::generic::Block<Header, UncheckedExtrinsic>;
-pub type UncheckedExtrinsic = sp_runtime::generic::UncheckedExtrinsic<u32, u64, RuntimeCall, ()>;
+pub type UncheckedExtrinsic = TestXt<RuntimeCall, ()>;
 
 frame_support::construct_runtime!(
     pub enum Test
@@ -285,7 +285,7 @@ fn close_works() {
     new_test_ext().execute_with(|| {
         let proposal = make_proposal(42);
         let proposal_len: u32 = proposal.using_encoded(|p| p.len() as u32);
-        let proposal_weight = proposal.get_dispatch_info().weight;
+        let proposal_weight = proposal.get_dispatch_info().call_weight;
         let hash = BlakeTwo256::hash_of(&proposal);
 
         assert_ok!(Collective::propose(
@@ -355,7 +355,7 @@ fn proposal_weight_limit_works_on_approve() {
             old_count: <MaxMembers as TypedGet>::get(),
         });
         let proposal_len: u32 = proposal.using_encoded(|p| p.len() as u32);
-        let proposal_weight = proposal.get_dispatch_info().weight;
+        let proposal_weight = proposal.get_dispatch_info().call_weight;
         let hash = BlakeTwo256::hash_of(&proposal);
         // Set 1 as prime voter
         Prime::<Test, Instance1>::set(Some(1));
@@ -397,7 +397,7 @@ fn proposal_weight_limit_ignored_on_disapprove() {
             old_count: <MaxMembers as TypedGet>::get(),
         });
         let proposal_len: u32 = proposal.using_encoded(|p| p.len() as u32);
-        let proposal_weight = proposal.get_dispatch_info().weight;
+        let proposal_weight = proposal.get_dispatch_info().call_weight;
         let hash = BlakeTwo256::hash_of(&proposal);
 
         assert_ok!(Collective::propose(
@@ -423,7 +423,7 @@ fn close_with_prime_works() {
     new_test_ext().execute_with(|| {
         let proposal = make_proposal(42);
         let proposal_len: u32 = proposal.using_encoded(|p| p.len() as u32);
-        let proposal_weight = proposal.get_dispatch_info().weight;
+        let proposal_weight = proposal.get_dispatch_info().call_weight;
         let hash = BlakeTwo256::hash_of(&proposal);
         assert_ok!(Collective::set_members(
             RuntimeOrigin::root(),
@@ -483,7 +483,7 @@ fn close_with_voting_prime_works() {
     new_test_ext().execute_with(|| {
         let proposal = make_proposal(42);
         let proposal_len: u32 = proposal.using_encoded(|p| p.len() as u32);
-        let proposal_weight = proposal.get_dispatch_info().weight;
+        let proposal_weight = proposal.get_dispatch_info().call_weight;
         let hash = BlakeTwo256::hash_of(&proposal);
         assert_ok!(Collective::set_members(
             RuntimeOrigin::root(),
@@ -547,7 +547,7 @@ fn close_with_no_prime_but_majority_works() {
     new_test_ext().execute_with(|| {
         let proposal = make_proposal(42);
         let proposal_len: u32 = proposal.using_encoded(|p| p.len() as u32);
-        let proposal_weight = proposal.get_dispatch_info().weight;
+        let proposal_weight = proposal.get_dispatch_info().call_weight;
         let hash = BlakeTwo256::hash_of(&proposal);
         assert_ok!(CollectiveMajority::set_members(
             RuntimeOrigin::root(),
@@ -883,7 +883,7 @@ fn correct_validate_and_get_proposal() {
         ));
 
         let hash = BlakeTwo256::hash_of(&proposal);
-        let weight = proposal.get_dispatch_info().weight;
+        let weight = proposal.get_dispatch_info().call_weight;
         assert_noop!(
             Collective::validate_and_get_proposal(
                 &BlakeTwo256::hash_of(&vec![3; 4]),
@@ -1107,7 +1107,7 @@ fn motions_all_first_vote_free_works() {
 
         // Test close() Extrincis | Check DispatchResultWithPostInfo with Pay Info
 
-        let proposal_weight = proposal.get_dispatch_info().weight;
+        let proposal_weight = proposal.get_dispatch_info().call_weight;
         let close_rval: DispatchResultWithPostInfo = Collective::close(
             RuntimeOrigin::root(),
             hash,
@@ -1135,7 +1135,7 @@ fn motions_reproposing_disapproved_works() {
     new_test_ext().execute_with(|| {
         let proposal = make_proposal(42);
         let proposal_len: u32 = proposal.using_encoded(|p| p.len() as u32);
-        let proposal_weight = proposal.get_dispatch_info().weight;
+        let proposal_weight = proposal.get_dispatch_info().call_weight;
         let hash: H256 = proposal.blake2_256().into();
         assert_ok!(Collective::propose(
             RuntimeOrigin::signed(1),
@@ -1170,7 +1170,7 @@ fn motions_approval_with_enough_votes_and_lower_voting_threshold_works() {
     new_test_ext().execute_with(|| {
         let proposal = RuntimeCall::Democracy(mock_democracy::Call::external_propose_majority {});
         let proposal_len: u32 = proposal.using_encoded(|p| p.len() as u32);
-        let proposal_weight = proposal.get_dispatch_info().weight;
+        let proposal_weight = proposal.get_dispatch_info().call_weight;
         let hash: H256 = proposal.blake2_256().into();
         // The voting threshold is 2, but the required votes for `ExternalMajorityOrigin` is 3.
         // The proposal will be executed regardless of the voting threshold
@@ -1304,7 +1304,7 @@ fn motions_disapproval_works() {
     new_test_ext().execute_with(|| {
         let proposal = make_proposal(42);
         let proposal_len: u32 = proposal.using_encoded(|p| p.len() as u32);
-        let proposal_weight = proposal.get_dispatch_info().weight;
+        let proposal_weight = proposal.get_dispatch_info().call_weight;
         let hash: H256 = proposal.blake2_256().into();
         assert_ok!(Collective::propose(
             RuntimeOrigin::signed(1),
@@ -1363,7 +1363,7 @@ fn motions_approval_works() {
     new_test_ext().execute_with(|| {
         let proposal = make_proposal(42);
         let proposal_len: u32 = proposal.using_encoded(|p| p.len() as u32);
-        let proposal_weight = proposal.get_dispatch_info().weight;
+        let proposal_weight = proposal.get_dispatch_info().call_weight;
         let hash: H256 = proposal.blake2_256().into();
         assert_ok!(Collective::propose(
             RuntimeOrigin::signed(1),
@@ -1426,7 +1426,7 @@ fn motion_with_no_votes_closes_with_disapproval() {
     new_test_ext().execute_with(|| {
         let proposal = make_proposal(42);
         let proposal_len: u32 = proposal.using_encoded(|p| p.len() as u32);
-        let proposal_weight = proposal.get_dispatch_info().weight;
+        let proposal_weight = proposal.get_dispatch_info().call_weight;
         let hash: H256 = proposal.blake2_256().into();
         assert_ok!(Collective::propose(
             RuntimeOrigin::signed(1),
diff --git a/pallets/subtensor/src/tests/registration.rs b/pallets/subtensor/src/tests/registration.rs
index 3a8ce39ba3..c50c103f8b 100644
--- a/pallets/subtensor/src/tests/registration.rs
+++ b/pallets/subtensor/src/tests/registration.rs
@@ -37,7 +37,8 @@ fn test_registration_subscribe_ok_dispatch_info_ok() {
         assert_eq!(
             call.get_dispatch_info(),
             DispatchInfo {
-                weight: frame_support::weights::Weight::from_parts(3_166_200_000, 0),
+                call_weight: frame_support::weights::Weight::from_parts(3_166_200_000, 0),
+                extension_weight: frame_support::weights::Weight::zero(),
                 class: DispatchClass::Normal,
                 pays_fee: Pays::No
             }
diff --git a/pallets/subtensor/src/tests/serving.rs b/pallets/subtensor/src/tests/serving.rs
index 251dde2078..784ddd8a3c 100644
--- a/pallets/subtensor/src/tests/serving.rs
+++ b/pallets/subtensor/src/tests/serving.rs
@@ -53,7 +53,8 @@ fn test_serving_subscribe_ok_dispatch_info_ok() {
         assert_eq!(
             call.get_dispatch_info(),
             DispatchInfo {
-                weight: frame_support::weights::Weight::from_parts(235_670_000, 0),
+                call_weight: frame_support::weights::Weight::from_parts(235_670_000, 0),
+                extension_weight: frame_support::weights::Weight::zero(),
                 class: DispatchClass::Normal,
                 pays_fee: Pays::No
             }
@@ -355,7 +356,8 @@ fn test_prometheus_serving_subscribe_ok_dispatch_info_ok() {
         assert_eq!(
             call.get_dispatch_info(),
             DispatchInfo {
-                weight: frame_support::weights::Weight::from_parts(231_170_000, 0),
+                call_weight: frame_support::weights::Weight::from_parts(231_170_000, 0),
+                extension_weight: frame_support::weights::Weight::zero(),
                 class: DispatchClass::Normal,
                 pays_fee: Pays::No
             }
diff --git a/pallets/subtensor/src/tests/staking.rs b/pallets/subtensor/src/tests/staking.rs
index 9a672676ee..ddc04ea865 100644
--- a/pallets/subtensor/src/tests/staking.rs
+++ b/pallets/subtensor/src/tests/staking.rs
@@ -31,7 +31,8 @@ fn test_add_stake_dispatch_info_ok() {
         assert_eq!(
             call.get_dispatch_info(),
             DispatchInfo {
-                weight: frame_support::weights::Weight::from_parts(1_501_000_000, 0),
+                call_weight: frame_support::weights::Weight::from_parts(1_501_000_000, 0),
+                extension_weight: frame_support::weights::Weight::zero(),
                 class: DispatchClass::Normal,
                 pays_fee: Pays::No
             }
@@ -1210,8 +1211,9 @@ fn test_remove_stake_dispatch_info_ok() {
         assert_eq!(
             call.get_dispatch_info(),
             DispatchInfo {
-                weight: frame_support::weights::Weight::from_parts(1_671_800_000, 0)
+                call_weight: frame_support::weights::Weight::from_parts(1_671_800_000, 0)
                     .add_proof_size(0),
+                extension_weight: frame_support::weights::Weight::zero(),
                 class: DispatchClass::Normal,
                 pays_fee: Pays::No
             }
diff --git a/pallets/subtensor/src/tests/staking2.rs b/pallets/subtensor/src/tests/staking2.rs
index 6fbabf83b2..49bc49cdfd 100644
--- a/pallets/subtensor/src/tests/staking2.rs
+++ b/pallets/subtensor/src/tests/staking2.rs
@@ -594,7 +594,7 @@ fn test_try_associate_hotkey() {
             RuntimeCall::SubtensorModule(crate::Call::try_associate_hotkey { hotkey: hotkey1 });
         let dispatch_info = call.get_dispatch_info();
         // Verify tx weight > 0
-        assert!(dispatch_info.weight.all_gte(Weight::from_all(0)));
+        assert!(dispatch_info.call_weight.all_gte(Weight::from_all(0)));
         // Verify pays Yes is set
         assert_eq!(dispatch_info.pays_fee, Pays::Yes);
 

From 828660c2324ff69b4f4a8462a3a6404fbfe5aa1e Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Mon, 9 Jun 2025 23:28:45 +0200
Subject: [PATCH 268/418] fix benchmark tx extension conversion

---
 node/src/benchmarking.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/node/src/benchmarking.rs b/node/src/benchmarking.rs
index 40031ac1aa..7fabad6b3b 100644
--- a/node/src/benchmarking.rs
+++ b/node/src/benchmarking.rs
@@ -132,11 +132,11 @@ pub fn create_benchmark_extrinsic(
             period,
             best_block.saturated_into(),
         )),
-        check_nonce::CheckNonce::<runtime::Runtime>::from(nonce),
+        check_nonce::CheckNonce::<runtime::Runtime>::from(nonce).into(),
         frame_system::CheckWeight::<runtime::Runtime>::new(),
         pallet_transaction_payment::ChargeTransactionPayment::<runtime::Runtime>::from(0),
-        pallet_subtensor::SubtensorSignedExtension::<runtime::Runtime>::new(),
-        pallet_commitments::CommitmentsSignedExtension::<runtime::Runtime>::new(),
+        pallet_subtensor::SubtensorSignedExtension::<runtime::Runtime>::new().into(),
+        pallet_commitments::CommitmentsSignedExtension::<runtime::Runtime>::new().into(),
         frame_metadata_hash_extension::CheckMetadataHash::<runtime::Runtime>::new(true),
     );
 

From 3b4c7cf87e1d8709b0d37069fa66917125001bbb Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Mon, 9 Jun 2025 23:28:59 +0200
Subject: [PATCH 269/418] fix benchmark command new api params

---
 node/src/command.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/node/src/command.rs b/node/src/command.rs
index aea800596e..e2df46844f 100644
--- a/node/src/command.rs
+++ b/node/src/command.rs
@@ -196,11 +196,12 @@ pub fn run() -> sc_cli::Result<()> {
                         let ext_builder = RemarkBuilder::new(client.clone());
 
                         cmd.run(
-                            config,
+                            config.chain_spec.name().into(),
                             client,
                             inherent_benchmark_data()?,
                             Vec::new(),
                             &ext_builder,
+                            false,
                         )
                     }
                     BenchmarkCmd::Extrinsic(cmd) => {

From e9cf4804527eb7c1355b9171da3d8a411f9f5a17 Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Mon, 9 Jun 2025 23:31:54 +0200
Subject: [PATCH 270/418] start converting from signed extension to transaction
 extension

---
 pallets/admin-utils/src/tests/mock.rs | 46 +++++++++++-------
 pallets/commitments/src/mock.rs       | 50 +++++++++++--------
 pallets/drand/src/lib.rs              |  8 ++--
 pallets/drand/src/mock.rs             | 25 +++++++---
 pallets/subtensor/src/tests/mock.rs   | 50 +++++++++++--------
 runtime/src/lib.rs                    | 69 ++++++++++++++++-----------
 6 files changed, 154 insertions(+), 94 deletions(-)

diff --git a/pallets/admin-utils/src/tests/mock.rs b/pallets/admin-utils/src/tests/mock.rs
index f8b3e6a9b6..21b86d60a4 100644
--- a/pallets/admin-utils/src/tests/mock.rs
+++ b/pallets/admin-utils/src/tests/mock.rs
@@ -2,10 +2,10 @@
 
 use frame_support::{
     assert_ok, derive_impl, parameter_types,
-    traits::{Everything, Hooks, PrivilegeCmp},
+    traits::{Everything, Hooks, InherentBuilder, PrivilegeCmp},
     weights,
 };
-use frame_system as system;
+use frame_system::{self as system, offchain::CreateTransactionBase};
 use frame_system::{EnsureNever, EnsureRoot, limits};
 use sp_consensus_aura::sr25519::AuthorityId as AuraId;
 use sp_consensus_grandpa::AuthorityList as GrandpaAuthorityList;
@@ -68,7 +68,6 @@ pub type Balance = u64;
 pub type BlockNumber = u64;
 
 pub type TestAuthId = test_crypto::TestAuthId;
-pub type Index = u64;
 pub type UncheckedExtrinsic = TestXt<RuntimeCall, ()>;
 
 parameter_types! {
@@ -361,26 +360,37 @@ mod test_crypto {
     }
 }
 
-impl frame_system::offchain::CreateSignedTransaction<pallet_drand::Call<Test>> for Test {
-    fn create_transaction<C: frame_system::offchain::AppCrypto<Self::Public, Self::Signature>>(
-        call: RuntimeCall,
-        _public: Self::Public,
-        _account: Self::AccountId,
-        nonce: Index,
-    ) -> Option<(
-        RuntimeCall,
-        <UncheckedExtrinsic as sp_runtime::traits::Extrinsic>::SignaturePayload,
-    )> {
-        Some((call, (nonce, ())))
+impl<LocalCall> frame_system::offchain::CreateTransactionBase<LocalCall> for Test
+where
+    RuntimeCall: From<LocalCall>,
+{
+    type Extrinsic = UncheckedExtrinsic;
+    type RuntimeCall = RuntimeCall;
+}
+
+impl<LocalCall> frame_system::offchain::CreateInherent<LocalCall> for Test
+where
+    RuntimeCall: From<LocalCall>,
+{
+    fn create_inherent(call: Self::RuntimeCall) -> Self::Extrinsic {
+        UncheckedExtrinsic::new_inherent(call)
     }
 }
 
-impl<C> frame_system::offchain::SendTransactionTypes<C> for Test
+impl<LocalCall> frame_system::offchain::CreateSignedTransaction<LocalCall> for Test
 where
-    RuntimeCall: From<C>,
+    RuntimeCall: From<LocalCall>,
 {
-    type Extrinsic = UncheckedExtrinsic;
-    type OverarchingCall = RuntimeCall;
+    fn create_signed_transaction<
+        C: frame_system::offchain::AppCrypto<Self::Public, Self::Signature>,
+    >(
+        call: <Self as CreateTransactionBase<LocalCall>>::RuntimeCall,
+        _public: Self::Public,
+        _account: Self::AccountId,
+        nonce: Self::Nonce,
+    ) -> Option<Self::Extrinsic> {
+        Some(UncheckedExtrinsic::new_signed(call, nonce, (), ()))
+    }
 }
 
 // Build genesis storage according to the mock runtime.
diff --git a/pallets/commitments/src/mock.rs b/pallets/commitments/src/mock.rs
index 4e6aa123bd..bf57e65ccf 100644
--- a/pallets/commitments/src/mock.rs
+++ b/pallets/commitments/src/mock.rs
@@ -2,8 +2,9 @@ use crate as pallet_commitments;
 use frame_support::{
     derive_impl,
     pallet_prelude::{Get, TypeInfo},
-    traits::{ConstU32, ConstU64},
+    traits::{ConstU32, ConstU64, InherentBuilder},
 };
+use frame_system::offchain::CreateTransactionBase;
 use sp_core::H256;
 use sp_runtime::{
     BuildStorage,
@@ -159,32 +160,43 @@ impl frame_system::offchain::SigningTypes for Test {
     type Signature = test_crypto::Signature;
 }
 
-impl frame_system::offchain::CreateSignedTransaction<pallet_drand::Call<Test>> for Test {
-    fn create_transaction<C: frame_system::offchain::AppCrypto<Self::Public, Self::Signature>>(
-        call: RuntimeCall,
+impl<LocalCall> frame_system::offchain::CreateTransactionBase<LocalCall> for Test
+where
+    RuntimeCall: From<LocalCall>,
+{
+    type Extrinsic = UncheckedExtrinsic;
+    type RuntimeCall = RuntimeCall;
+}
+
+impl<LocalCall> frame_system::offchain::CreateInherent<LocalCall> for Test
+where
+    RuntimeCall: From<LocalCall>,
+{
+    fn create_inherent(call: Self::RuntimeCall) -> Self::Extrinsic {
+        UncheckedExtrinsic::new_inherent(call)
+    }
+}
+
+impl<LocalCall> frame_system::offchain::CreateSignedTransaction<LocalCall> for Test
+where
+    RuntimeCall: From<LocalCall>,
+{
+    fn create_signed_transaction<
+        C: frame_system::offchain::AppCrypto<Self::Public, Self::Signature>,
+    >(
+        call: <Self as CreateTransactionBase<LocalCall>>::RuntimeCall,
         _public: Self::Public,
-        account: Self::AccountId,
-        _nonce: u32,
-    ) -> Option<(
-        RuntimeCall,
-        <UncheckedExtrinsic as sp_runtime::traits::Extrinsic>::SignaturePayload,
-    )> {
+        _account: Self::AccountId,
+        nonce: Self::Nonce,
+    ) -> Option<Self::Extrinsic> {
         // Create a dummy sr25519 signature from a raw byte array
         let dummy_raw = [0u8; 64];
         let dummy_signature = sp_core::sr25519::Signature::from(dummy_raw);
         let signature = test_crypto::Signature::from(dummy_signature);
-        Some((call, (account, signature, ())))
+        Some(UncheckedExtrinsic::new_signed(call, nonce.into(), signature, ()))
     }
 }
 
-impl<C> frame_system::offchain::SendTransactionTypes<C> for Test
-where
-    RuntimeCall: From<C>,
-{
-    type Extrinsic = UncheckedExtrinsic;
-    type OverarchingCall = RuntimeCall;
-}
-
 pub fn new_test_ext() -> sp_io::TestExternalities {
     let t = frame_system::GenesisConfig::<Test>::default()
         .build_storage()
diff --git a/pallets/drand/src/lib.rs b/pallets/drand/src/lib.rs
index dd172befc0..762aa65238 100644
--- a/pallets/drand/src/lib.rs
+++ b/pallets/drand/src/lib.rs
@@ -43,8 +43,8 @@ use codec::Encode;
 use frame_support::{pallet_prelude::*, traits::Randomness};
 use frame_system::{
     offchain::{
-        AppCrypto, CreateSignedTransaction, SendUnsignedTransaction, SignedPayload, Signer,
-        SigningTypes,
+        AppCrypto, CreateInherent, CreateSignedTransaction, SendUnsignedTransaction, SignedPayload,
+        Signer, SigningTypes,
     },
     pallet_prelude::BlockNumberFor,
 };
@@ -155,7 +155,9 @@ pub mod pallet {
     pub struct Pallet<T>(_);
 
     #[pallet::config]
-    pub trait Config: CreateSignedTransaction<Call<Self>> + frame_system::Config {
+    pub trait Config:
+        CreateSignedTransaction<Call<Self>> + CreateInherent<Call<Self>> + frame_system::Config
+    {
         /// The identifier type for an offchain worker.
         type AuthorityId: AppCrypto<Self::Public, Self::Signature>;
         /// The overarching runtime event type.
diff --git a/pallets/drand/src/mock.rs b/pallets/drand/src/mock.rs
index 6ef1f2bf8a..f8c0d9ab4d 100644
--- a/pallets/drand/src/mock.rs
+++ b/pallets/drand/src/mock.rs
@@ -3,14 +3,14 @@ use crate::verifier::*;
 use crate::*;
 use frame_support::{
     derive_impl, parameter_types,
-    traits::{ConstU16, ConstU64},
+    traits::{ConstU16, ConstU64, InherentBuilder},
 };
 use sp_core::{H256, sr25519::Signature};
 use sp_keystore::{KeystoreExt, testing::MemoryKeystore};
 use sp_runtime::{
     BuildStorage,
     testing::TestXt,
-    traits::{BlakeTwo256, Extrinsic as ExtrinsicT, IdentifyAccount, IdentityLookup, Verify},
+    traits::{BlakeTwo256, IdentifyAccount, IdentityLookup, Verify},
 };
 
 type Block = frame_system::mocking::MockBlock<Test>;
@@ -59,25 +59,36 @@ impl frame_system::offchain::SigningTypes for Test {
     type Signature = Signature;
 }
 
-impl<LocalCall> frame_system::offchain::SendTransactionTypes<LocalCall> for Test
+impl<LocalCall> frame_system::offchain::CreateTransactionBase<LocalCall> for Test
 where
     RuntimeCall: From<LocalCall>,
 {
-    type OverarchingCall = RuntimeCall;
+    type RuntimeCall = RuntimeCall;
     type Extrinsic = Extrinsic;
 }
 
+impl<LocalCall> frame_system::offchain::CreateInherent<LocalCall> for Test
+where
+    RuntimeCall: From<LocalCall>,
+{
+    fn create_inherent(call: RuntimeCall) -> Self::Extrinsic {
+        Extrinsic::new_inherent(call)
+    }
+}
+
 impl<LocalCall> frame_system::offchain::CreateSignedTransaction<LocalCall> for Test
 where
     RuntimeCall: From<LocalCall>,
 {
-    fn create_transaction<C: frame_system::offchain::AppCrypto<Self::Public, Self::Signature>>(
+    fn create_signed_transaction<
+        C: frame_system::offchain::AppCrypto<Self::Public, Self::Signature>,
+    >(
         call: RuntimeCall,
         _public: <Signature as Verify>::Signer,
         _account: AccountId,
         nonce: u64,
-    ) -> Option<(RuntimeCall, <Extrinsic as ExtrinsicT>::SignaturePayload)> {
-        Some((call, (nonce, ())))
+    ) -> Option<Self::Extrinsic> {
+        Some(Extrinsic::new_signed(call, nonce, (), ()))
     }
 }
 
diff --git a/pallets/subtensor/src/tests/mock.rs b/pallets/subtensor/src/tests/mock.rs
index 221d802ccd..223ee1d9d2 100644
--- a/pallets/subtensor/src/tests/mock.rs
+++ b/pallets/subtensor/src/tests/mock.rs
@@ -8,8 +8,9 @@ use frame_support::{
     assert_ok, parameter_types,
     traits::{Everything, Hooks, PrivilegeCmp},
 };
+use frame_support::traits::InherentBuilder;
 use frame_system as system;
-use frame_system::{EnsureNever, EnsureRoot, RawOrigin, limits};
+use frame_system::{EnsureNever, EnsureRoot, RawOrigin, limits, offchain::CreateTransactionBase};
 use pallet_collective::MemberCount;
 use sp_core::{ConstU64, Get, H256, U256, offchain::KeyTypeId};
 use sp_runtime::Perbill;
@@ -53,8 +54,6 @@ pub type BalanceCall = pallet_balances::Call<Test>;
 #[allow(dead_code)]
 pub type TestRuntimeCall = frame_system::Call<Test>;
 
-pub type Index = u64;
-
 pub const KEY_TYPE: KeyTypeId = KeyTypeId(*b"test");
 
 #[allow(dead_code)]
@@ -503,14 +502,6 @@ mod test_crypto {
 
 pub type TestAuthId = test_crypto::TestAuthId;
 
-impl<C> frame_system::offchain::SendTransactionTypes<C> for Test
-where
-    RuntimeCall: From<C>,
-{
-    type Extrinsic = UncheckedExtrinsic;
-    type OverarchingCall = RuntimeCall;
-}
-
 impl pallet_drand::Config for Test {
     type RuntimeEvent = RuntimeEvent;
     type AuthorityId = TestAuthId;
@@ -526,17 +517,36 @@ impl frame_system::offchain::SigningTypes for Test {
 
 pub type UncheckedExtrinsic = sp_runtime::testing::TestXt<RuntimeCall, ()>;
 
-impl frame_system::offchain::CreateSignedTransaction<pallet_drand::Call<Test>> for Test {
-    fn create_transaction<C: frame_system::offchain::AppCrypto<Self::Public, Self::Signature>>(
-        call: RuntimeCall,
+impl<LocalCall> frame_system::offchain::CreateTransactionBase<LocalCall> for Test
+where
+    RuntimeCall: From<LocalCall>,
+{
+    type Extrinsic = UncheckedExtrinsic;
+    type RuntimeCall = RuntimeCall;
+}
+
+impl<LocalCall> frame_system::offchain::CreateInherent<LocalCall> for Test
+where
+    RuntimeCall: From<LocalCall>,
+{
+    fn create_inherent(call: Self::RuntimeCall) -> Self::Extrinsic {
+        UncheckedExtrinsic::new_inherent(call)
+    }
+}
+
+impl<LocalCall> frame_system::offchain::CreateSignedTransaction<LocalCall> for Test
+where
+    RuntimeCall: From<LocalCall>,
+{
+    fn create_signed_transaction<
+        C: frame_system::offchain::AppCrypto<Self::Public, Self::Signature>,
+    >(
+        call: <Self as CreateTransactionBase<LocalCall>>::RuntimeCall,
         _public: Self::Public,
         _account: Self::AccountId,
-        nonce: Index,
-    ) -> Option<(
-        RuntimeCall,
-        <UncheckedExtrinsic as sp_runtime::traits::Extrinsic>::SignaturePayload,
-    )> {
-        Some((call, (nonce, ())))
+        nonce: Self::Nonce,
+    ) -> Option<Self::Extrinsic> {
+        Some(UncheckedExtrinsic::new_signed(call, nonce.into(), (), ()))
     }
 }
 
diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index 95b032f9e6..5a877d1534 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -49,6 +49,7 @@ use sp_core::{
 };
 use sp_runtime::generic::Era;
 use sp_runtime::{
+traits::transaction_extension::AsTransactionExtension,
     AccountId32, ApplyExtrinsicResult, ConsensusEngineId, create_runtime_str, generic,
     impl_opaque_keys,
     traits::{
@@ -113,24 +114,29 @@ impl frame_system::offchain::SigningTypes for Runtime {
     type Signature = Signature;
 }
 
-impl<C> frame_system::offchain::SendTransactionTypes<C> for Runtime
+impl<C> frame_system::offchain::CreateTransactionBase<C> for Runtime
 where
     RuntimeCall: From<C>,
 {
     type Extrinsic = UncheckedExtrinsic;
-    type OverarchingCall = RuntimeCall;
+    type RuntimeCall = RuntimeCall;
+}
+
+impl frame_system::offchain::CreateInherent<pallet_drand::Call<Runtime>> for Runtime {
+    fn create_inherent(call: Self::RuntimeCall) -> Self::Extrinsic {
+        UncheckedExtrinsic::new_bare(call)
+    }
 }
 
 impl frame_system::offchain::CreateSignedTransaction<pallet_drand::Call<Runtime>> for Runtime {
-    fn create_transaction<S: frame_system::offchain::AppCrypto<Self::Public, Self::Signature>>(
+    fn create_signed_transaction<
+        S: frame_system::offchain::AppCrypto<Self::Public, Self::Signature>,
+    >(
         call: RuntimeCall,
-        public: <Signature as Verify>::Signer,
-        account: AccountId,
-        index: Index,
-    ) -> Option<(
-        RuntimeCall,
-        <UncheckedExtrinsic as sp_runtime::traits::Extrinsic>::SignaturePayload,
-    )> {
+        public: Self::Public,
+        account: Self::AccountId,
+        nonce: Self::Nonce,
+    ) -> Option<Self::Extrinsic> {
         use sp_runtime::traits::StaticLookup;
 
         let address = <Runtime as frame_system::Config>::Lookup::unlookup(account.clone());
@@ -140,20 +146,20 @@ impl frame_system::offchain::CreateSignedTransaction<pallet_drand::Call<Runtime>
             frame_system::CheckTxVersion::<Runtime>::new(),
             frame_system::CheckGenesis::<Runtime>::new(),
             frame_system::CheckEra::<Runtime>::from(Era::Immortal),
-            check_nonce::CheckNonce::<Runtime>::from(index),
+            check_nonce::CheckNonce::<Runtime>::from(nonce).into(),
             frame_system::CheckWeight::<Runtime>::new(),
             pallet_transaction_payment::ChargeTransactionPayment::<Runtime>::from(0),
-            pallet_subtensor::SubtensorSignedExtension::<Runtime>::new(),
-            pallet_commitments::CommitmentsSignedExtension::<Runtime>::new(),
+            pallet_subtensor::SubtensorSignedExtension::<Runtime>::new().into(),
+            pallet_commitments::CommitmentsSignedExtension::<Runtime>::new().into(),
             frame_metadata_hash_extension::CheckMetadataHash::<Runtime>::new(true),
         );
 
         let raw_payload = SignedPayload::new(call.clone(), extra.clone()).ok()?;
         let signature = raw_payload.using_encoded(|payload| S::sign(payload, public))?;
 
-        let signature_payload = (address, signature, extra);
-
-        Some((call, signature_payload))
+        Some(UncheckedExtrinsic::new_signed(
+            call, address, signature, extra,
+        ))
     }
 }
 
@@ -213,7 +219,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
     impl_version: 1,
     apis: RUNTIME_API_VERSIONS,
     transaction_version: 1,
-    state_version: 1,
+    system_version: 1,
 };
 
 pub const MAXIMUM_BLOCK_WEIGHT: Weight =
@@ -299,6 +305,7 @@ impl frame_system::Config for Runtime {
     type PreInherents = ();
     type PostInherents = ();
     type PostTransactions = ();
+    type ExtensionsWeightInfo = ();
 }
 
 impl pallet_insecure_randomness_collective_flip::Config for Runtime {}
@@ -410,6 +417,7 @@ impl pallet_balances::Config for Runtime {
     type RuntimeFreezeReason = RuntimeFreezeReason;
     type FreezeIdentifier = RuntimeFreezeReason;
     type MaxFreezes = ConstU32<50>;
+    type DoneSlashHandler = ();
 }
 
 pub struct LinearWeightToFee;
@@ -467,6 +475,7 @@ impl pallet_transaction_payment::Config for Runtime {
     type OperationalFeeMultiplier = OperationalFeeMultiplier;
     type LengthToFee = IdentityFee<Balance>;
     type FeeMultiplierUpdate = ConstFeeMultiplier<FeeMultiplier>;
+    type WeightInfo = pallet_transaction_payment::weights::SubstrateWeight<Runtime>;
 }
 
 // Configure collective pallet for council
@@ -1244,7 +1253,6 @@ parameter_types! {
     pub const GasLimitPovSizeRatio: u64 = 0;
     pub PrecompilesValue: Precompiles<Runtime> = Precompiles::<_>::new();
     pub WeightPerGas: Weight = weight_per_gas();
-    pub SuicideQuickClearLimit: u32 = 0;
 }
 
 /// The difference between EVM decimals and Substrate decimals.
@@ -1325,16 +1333,24 @@ impl pallet_evm::Config for Runtime {
     type OnCreate = ();
     type FindAuthor = FindAuthorTruncated<Aura>;
     type GasLimitPovSizeRatio = GasLimitPovSizeRatio;
-    type SuicideQuickClearLimit = SuicideQuickClearLimit;
     type Timestamp = Timestamp;
     type WeightInfo = pallet_evm::weights::SubstrateWeight<Self>;
     type BalanceConverter = SubtensorEvmBalanceConverter;
+    type AccountProvider = pallet_evm::FrameSystemAccountProvider<Self>;
+    type GasLimitStorageGrowthRatio = ();
 }
 
 parameter_types! {
     pub const PostBlockAndTxnHashes: PostLogContent = PostLogContent::BlockAndTxnHashes;
 }
 
+// Required for the IntermediateStateRoot
+impl sp_core::Get<sp_version::RuntimeVersion> for Runtime {
+    fn get() -> sp_version::RuntimeVersion {
+        VERSION
+    }
+}
+
 impl pallet_ethereum::Config for Runtime {
     type RuntimeEvent = RuntimeEvent;
     type StateRoot = pallet_ethereum::IntermediateStateRoot<Self>;
@@ -1383,7 +1399,7 @@ impl<B: BlockT> fp_rpc::ConvertTransaction<<B as BlockT>::Extrinsic> for Transac
         &self,
         transaction: pallet_ethereum::Transaction,
     ) -> <B as BlockT>::Extrinsic {
-        let extrinsic = UncheckedExtrinsic::new_unsigned(
+        let extrinsic = UncheckedExtrinsic::new_bare(
             pallet_ethereum::Call::<Runtime>::transact { transaction }.into(),
         );
         let encoded = extrinsic.encode();
@@ -1536,11 +1552,11 @@ pub type SignedExtra = (
     frame_system::CheckTxVersion<Runtime>,
     frame_system::CheckGenesis<Runtime>,
     frame_system::CheckEra<Runtime>,
-    check_nonce::CheckNonce<Runtime>,
+    AsTransactionExtension<check_nonce::CheckNonce<Runtime>>,
     frame_system::CheckWeight<Runtime>,
     pallet_transaction_payment::ChargeTransactionPayment<Runtime>,
-    pallet_subtensor::SubtensorSignedExtension<Runtime>,
-    pallet_commitments::CommitmentsSignedExtension<Runtime>,
+    AsTransactionExtension<pallet_subtensor::SubtensorSignedExtension<Runtime>>,
+    AsTransactionExtension<pallet_commitments::CommitmentsSignedExtension<Runtime>>,
     frame_metadata_hash_extension::CheckMetadataHash<Runtime>,
 );
 
@@ -1853,9 +1869,8 @@ impl_runtime_apis! {
         }
 
         fn storage_at(address: H160, index: U256) -> H256 {
-            let mut tmp = [0u8; 32];
-            index.to_big_endian(&mut tmp);
-            pallet_evm::AccountStorages::<Runtime>::get(address, H256::from_slice(&tmp[..]))
+            let index_hash = H256::from_slice(&index.to_big_endian());
+            pallet_evm::AccountStorages::<Runtime>::get(address, index_hash)
         }
 
         fn call(
@@ -2081,7 +2096,7 @@ impl_runtime_apis! {
 
     impl fp_rpc::ConvertTransactionRuntimeApi<Block> for Runtime {
         fn convert_transaction(transaction: EthereumTransaction) -> <Block as BlockT>::Extrinsic {
-            UncheckedExtrinsic::new_unsigned(
+            UncheckedExtrinsic::new_bare(
                 pallet_ethereum::Call::<Runtime>::transact { transaction }.into(),
             )
         }

From 3db48139fc7577d4ce0a267466ccc19a8588bb20 Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Mon, 9 Jun 2025 23:37:27 +0200
Subject: [PATCH 271/418] cargo clippy

---
 node/src/service.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/node/src/service.rs b/node/src/service.rs
index d729c0ac6c..1539a33935 100644
--- a/node/src/service.rs
+++ b/node/src/service.rs
@@ -736,9 +736,9 @@ pub async fn build_full(
             new_full::<sc_network::NetworkWorker<_, _>>(config, eth_config, sealing).await
         }
         _ => {
-            return Err(ServiceError::Other(
+            Err(ServiceError::Other(
                 "Network backend not supported".to_string(),
-            ));
+            ))
         }
     }
 }

From 1406f5ea7369c775762c035e32a7f9fd2d601f74 Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Mon, 9 Jun 2025 23:38:13 +0200
Subject: [PATCH 272/418] cargo fmt

---
 node/src/service.rs                 | 8 +++-----
 pallets/commitments/src/mock.rs     | 7 ++++++-
 pallets/subtensor/src/tests/mock.rs | 2 +-
 pallets/utility/src/tests.rs        | 9 +++++++--
 runtime/src/lib.rs                  | 2 +-
 5 files changed, 18 insertions(+), 10 deletions(-)

diff --git a/node/src/service.rs b/node/src/service.rs
index 1539a33935..4b95f6eb5d 100644
--- a/node/src/service.rs
+++ b/node/src/service.rs
@@ -735,11 +735,9 @@ pub async fn build_full(
         Some(sc_network::config::NetworkBackendType::Litep2p) => {
             new_full::<sc_network::NetworkWorker<_, _>>(config, eth_config, sealing).await
         }
-        _ => {
-            Err(ServiceError::Other(
-                "Network backend not supported".to_string(),
-            ))
-        }
+        _ => Err(ServiceError::Other(
+            "Network backend not supported".to_string(),
+        )),
     }
 }
 
diff --git a/pallets/commitments/src/mock.rs b/pallets/commitments/src/mock.rs
index bf57e65ccf..8339f1c232 100644
--- a/pallets/commitments/src/mock.rs
+++ b/pallets/commitments/src/mock.rs
@@ -193,7 +193,12 @@ where
         let dummy_raw = [0u8; 64];
         let dummy_signature = sp_core::sr25519::Signature::from(dummy_raw);
         let signature = test_crypto::Signature::from(dummy_signature);
-        Some(UncheckedExtrinsic::new_signed(call, nonce.into(), signature, ()))
+        Some(UncheckedExtrinsic::new_signed(
+            call,
+            nonce.into(),
+            signature,
+            (),
+        ))
     }
 }
 
diff --git a/pallets/subtensor/src/tests/mock.rs b/pallets/subtensor/src/tests/mock.rs
index 223ee1d9d2..1f4a9eaf74 100644
--- a/pallets/subtensor/src/tests/mock.rs
+++ b/pallets/subtensor/src/tests/mock.rs
@@ -2,13 +2,13 @@
 use crate::utils::rate_limiting::TransactionType;
 use frame_support::derive_impl;
 use frame_support::dispatch::DispatchResultWithPostInfo;
+use frame_support::traits::InherentBuilder;
 use frame_support::weights::Weight;
 use frame_support::weights::constants::RocksDbWeight;
 use frame_support::{
     assert_ok, parameter_types,
     traits::{Everything, Hooks, PrivilegeCmp},
 };
-use frame_support::traits::InherentBuilder;
 use frame_system as system;
 use frame_system::{EnsureNever, EnsureRoot, RawOrigin, limits, offchain::CreateTransactionBase};
 use pallet_collective::MemberCount;
diff --git a/pallets/utility/src/tests.rs b/pallets/utility/src/tests.rs
index d02e2e0faa..f0389187a9 100644
--- a/pallets/utility/src/tests.rs
+++ b/pallets/utility/src/tests.rs
@@ -339,7 +339,10 @@ fn as_derivative_handles_weight_refund() {
         let result = call.dispatch(RuntimeOrigin::signed(1));
         assert_ok!(result);
         // Diff is refunded
-        assert_eq!(extract_actual_weight(&result, &info), info.call_weight - diff);
+        assert_eq!(
+            extract_actual_weight(&result, &info),
+            info.call_weight - diff
+        );
 
         // Full weight when err
         let inner_call = call_foobar(true, start_weight, None);
@@ -729,7 +732,9 @@ fn batch_all_does_not_nest() {
             Utility::batch_all(RuntimeOrigin::signed(1), vec![batch_all.clone()]),
             DispatchErrorWithPostInfo {
                 post_info: PostDispatchInfo {
-                    actual_weight: Some(<Test as Config>::WeightInfo::batch_all(1) + info.call_weight),
+                    actual_weight: Some(
+                        <Test as Config>::WeightInfo::batch_all(1) + info.call_weight
+                    ),
                     pays_fee: Pays::Yes
                 },
                 error: frame_system::Error::<Test>::CallFiltered.into(),
diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index 5a877d1534..891e8c709e 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -49,9 +49,9 @@ use sp_core::{
 };
 use sp_runtime::generic::Era;
 use sp_runtime::{
-traits::transaction_extension::AsTransactionExtension,
     AccountId32, ApplyExtrinsicResult, ConsensusEngineId, create_runtime_str, generic,
     impl_opaque_keys,
+    traits::transaction_extension::AsTransactionExtension,
     traits::{
         AccountIdLookup, BlakeTwo256, Block as BlockT, DispatchInfoOf, Dispatchable, NumberFor,
         One, PostDispatchInfoOf, UniqueSaturatedInto, Verify,

From 484ebc873ff1947621a1c1bb3cdc6008468ec85e Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Mon, 9 Jun 2025 18:14:00 -0400
Subject: [PATCH 273/418] Add test_large_swap

---
 pallets/subtensor/src/tests/staking.rs | 78 ++++++++++++++++++++++++++
 1 file changed, 78 insertions(+)

diff --git a/pallets/subtensor/src/tests/staking.rs b/pallets/subtensor/src/tests/staking.rs
index 5e5ee3a8e1..b48427e1be 100644
--- a/pallets/subtensor/src/tests/staking.rs
+++ b/pallets/subtensor/src/tests/staking.rs
@@ -6,6 +6,7 @@ use frame_support::dispatch::{DispatchClass, DispatchInfo, GetDispatchInfo, Pays
 use frame_support::sp_runtime::DispatchError;
 use frame_support::{assert_err, assert_noop, assert_ok, traits::Currency};
 use frame_system::RawOrigin;
+use pallet_subtensor_swap::Call as SwapCall;
 use pallet_subtensor_swap::tick::TickIndex;
 use safe_math::FixedExt;
 use sp_core::{Get, H256, U256};
@@ -16,6 +17,7 @@ use subtensor_swap_interface::{OrderType, SwapHandler};
 
 use super::mock;
 use super::mock::*;
+use super::mock::{RuntimeCall, RuntimeOrigin};
 use crate::*;
 
 /***********************************************************
@@ -681,6 +683,16 @@ fn test_remove_stake_insufficient_liquidity() {
             SubtensorModule::remove_stake(RuntimeOrigin::signed(coldkey), hotkey, netuid, alpha),
             Error::<Test>::InsufficientLiquidity
         );
+
+        // Mock provided liquidity - remove becomes successful
+        SubnetTaoProvided::<Test>::insert(netuid, amount_staked + 1);
+        SubnetAlphaInProvided::<Test>::insert(netuid, 1);
+        assert_ok!(SubtensorModule::remove_stake(
+            RuntimeOrigin::signed(coldkey),
+            hotkey,
+            netuid,
+            alpha
+        ),);
     });
 }
 
@@ -5183,3 +5195,69 @@ fn test_update_position_fees() {
         });
     });
 }
+
+fn setup_positions(netuid: NetUid) {
+    for (coldkey, hotkey, low_price, high_price, liquidity) in [
+        (2, 12, 0.1, 0.20, 1_000_000_000_000_u64),
+        (3, 13, 0.15, 0.25, 200_000_000_000_u64),
+        (4, 14, 0.25, 0.5, 3_000_000_000_000_u64),
+        (5, 15, 0.3, 0.6, 300_000_000_000_u64),
+        (6, 16, 0.4, 0.7, 8_000_000_000_000_u64),
+        (7, 17, 0.5, 0.8, 600_000_000_000_u64),
+        (8, 18, 0.6, 0.9, 700_000_000_000_u64),
+        (9, 19, 0.7, 1.0, 100_000_000_000_u64),
+        (10, 20, 0.8, 1.1, 300_000_000_000_u64),
+    ] {
+        SubtensorModule::create_account_if_non_existent(&U256::from(coldkey), &U256::from(hotkey));
+        SubtensorModule::add_balance_to_coldkey_account(
+            &U256::from(coldkey),
+            1_000_000_000_000_000,
+        );
+        SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
+            &U256::from(hotkey),
+            &U256::from(coldkey),
+            netuid.into(),
+            1_000_000_000_000_000,
+        );
+
+        let tick_low = price_to_tick(low_price);
+        let tick_high = price_to_tick(high_price);
+        let add_lq_call = SwapCall::<Test>::add_liquidity {
+            hotkey: U256::from(hotkey),
+            netuid: netuid.into(),
+            tick_low,
+            tick_high,
+            liquidity,
+        };
+        assert_ok!(
+            RuntimeCall::Swap(add_lq_call).dispatch(RuntimeOrigin::signed(U256::from(coldkey)))
+        );
+    }
+}
+
+#[test]
+fn test_large_swap() {
+    new_test_ext(1).execute_with(|| {
+        let owner_hotkey = U256::from(1);
+        let owner_coldkey = U256::from(2);
+        let coldkey = U256::from(100);
+
+        // add network
+        let netuid: u16 = add_dynamic_network(&owner_hotkey, &owner_coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, 1_000_000_000_000_000);
+        pallet_subtensor_swap::EnabledUserLiquidity::<Test>::insert(NetUid::from(netuid), true);
+
+        // Force the swap to initialize
+        SubtensorModule::swap_tao_for_alpha(netuid, 0, 1_000_000_000_000).unwrap();
+
+        setup_positions(netuid.into());
+
+        let swap_amount = 100_000_000_000_000;
+        assert_ok!(SubtensorModule::add_stake(
+            RuntimeOrigin::signed(coldkey),
+            owner_hotkey,
+            netuid,
+            swap_amount,
+        ));
+    });
+}

From 8c301b4280d04f5bc27e9af3282e0b1e2bbd58ae Mon Sep 17 00:00:00 2001
From: John Reed <87283488+JohnReedV@users.noreply.github.com>
Date: Mon, 9 Jun 2025 19:24:10 -0700
Subject: [PATCH 274/418] update reads/writes

---
 pallets/subtensor/src/macros/dispatches.rs | 34 +++++++++++-----------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/pallets/subtensor/src/macros/dispatches.rs b/pallets/subtensor/src/macros/dispatches.rs
index f7a9d9c109..7609503f64 100644
--- a/pallets/subtensor/src/macros/dispatches.rs
+++ b/pallets/subtensor/src/macros/dispatches.rs
@@ -586,8 +586,8 @@ mod dispatches {
         ///
         #[pallet::call_index(2)]
         #[pallet::weight((Weight::from_parts(345_500_000, 0)
-		.saturating_add(T::DbWeight::get().reads(24))
-		.saturating_add(T::DbWeight::get().writes(13)), DispatchClass::Normal, Pays::No))]
+		.saturating_add(T::DbWeight::get().reads(26))
+		.saturating_add(T::DbWeight::get().writes(14)), DispatchClass::Normal, Pays::No))]
         pub fn add_stake(
             origin: OriginFor<T>,
             hotkey: T::AccountId,
@@ -925,7 +925,7 @@ mod dispatches {
         /// User register a new subnetwork via burning token
         #[pallet::call_index(7)]
         #[pallet::weight((Weight::from_parts(354_400_000, 0)
-		.saturating_add(T::DbWeight::get().reads(47))
+		.saturating_add(T::DbWeight::get().reads(49))
 		.saturating_add(T::DbWeight::get().writes(43)), DispatchClass::Normal, Pays::No))]
         pub fn burned_register(
             origin: OriginFor<T>,
@@ -1607,8 +1607,8 @@ mod dispatches {
         ///     - Thrown if key has hit transaction rate limit
         #[pallet::call_index(84)]
         #[pallet::weight((Weight::from_parts(369_500_000, 0)
-        .saturating_add(T::DbWeight::get().reads(30))
-        .saturating_add(T::DbWeight::get().writes(15)), DispatchClass::Operational, Pays::No))]
+        .saturating_add(T::DbWeight::get().reads(32))
+        .saturating_add(T::DbWeight::get().writes(16)), DispatchClass::Operational, Pays::No))]
         pub fn unstake_all_alpha(origin: OriginFor<T>, hotkey: T::AccountId) -> DispatchResult {
             Self::do_unstake_all_alpha(origin, hotkey)
         }
@@ -1636,8 +1636,8 @@ mod dispatches {
         ///
         #[pallet::call_index(85)]
         #[pallet::weight((Weight::from_parts(419_500_000, 0)
-        .saturating_add(T::DbWeight::get().reads(29))
-        .saturating_add(T::DbWeight::get().writes(17)), DispatchClass::Operational, Pays::No))]
+        .saturating_add(T::DbWeight::get().reads(31))
+        .saturating_add(T::DbWeight::get().writes(19)), DispatchClass::Operational, Pays::No))]
         pub fn move_stake(
             origin: T::RuntimeOrigin,
             origin_hotkey: T::AccountId,
@@ -1679,8 +1679,8 @@ mod dispatches {
         /// May emit a `StakeTransferred` event on success.
         #[pallet::call_index(86)]
         #[pallet::weight((Weight::from_parts(432_600_000, 0)
-        .saturating_add(T::DbWeight::get().reads(28))
-        .saturating_add(T::DbWeight::get().writes(17)), DispatchClass::Operational, Pays::No))]
+        .saturating_add(T::DbWeight::get().reads(30))
+        .saturating_add(T::DbWeight::get().writes(19)), DispatchClass::Operational, Pays::No))]
         pub fn transfer_stake(
             origin: T::RuntimeOrigin,
             destination_coldkey: T::AccountId,
@@ -1721,8 +1721,8 @@ mod dispatches {
         #[pallet::call_index(87)]
         #[pallet::weight((
             Weight::from_parts(351_300_000, 0)
-            .saturating_add(T::DbWeight::get().reads(29))
-            .saturating_add(T::DbWeight::get().writes(15)),
+            .saturating_add(T::DbWeight::get().reads(31))
+            .saturating_add(T::DbWeight::get().writes(16)),
             DispatchClass::Operational,
             Pays::No
         ))]
@@ -1786,8 +1786,8 @@ mod dispatches {
         ///
         #[pallet::call_index(88)]
         #[pallet::weight((Weight::from_parts(402_800_000, 0)
-		.saturating_add(T::DbWeight::get().reads(23))
-		.saturating_add(T::DbWeight::get().writes(13)), DispatchClass::Normal, Pays::No))]
+		.saturating_add(T::DbWeight::get().reads(25))
+		.saturating_add(T::DbWeight::get().writes(14)), DispatchClass::Normal, Pays::No))]
         pub fn add_stake_limit(
             origin: OriginFor<T>,
             hotkey: T::AccountId,
@@ -1850,8 +1850,8 @@ mod dispatches {
         ///
         #[pallet::call_index(89)]
         #[pallet::weight((Weight::from_parts(403_800_000, 0)
-		.saturating_add(T::DbWeight::get().reads(27))
-		.saturating_add(T::DbWeight::get().writes(13)), DispatchClass::Normal, Pays::No))]
+		.saturating_add(T::DbWeight::get().reads(29))
+		.saturating_add(T::DbWeight::get().writes(14)), DispatchClass::Normal, Pays::No))]
         pub fn remove_stake_limit(
             origin: OriginFor<T>,
             hotkey: T::AccountId,
@@ -1894,8 +1894,8 @@ mod dispatches {
         #[pallet::call_index(90)]
         #[pallet::weight((
             Weight::from_parts(426_500_000, 0)
-            .saturating_add(T::DbWeight::get().reads(29))
-            .saturating_add(T::DbWeight::get().writes(15)),
+            .saturating_add(T::DbWeight::get().reads(31))
+            .saturating_add(T::DbWeight::get().writes(16)),
             DispatchClass::Operational,
             Pays::No
         ))]

From 711edfe1debb63e4979aa90e327e0f647da88048 Mon Sep 17 00:00:00 2001
From: John Reed <87283488+JohnReedV@users.noreply.github.com>
Date: Mon, 9 Jun 2025 19:34:01 -0700
Subject: [PATCH 275/418] fix dispatch test

---
 pallets/subtensor/src/tests/staking.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pallets/subtensor/src/tests/staking.rs b/pallets/subtensor/src/tests/staking.rs
index b48427e1be..88e54d4440 100644
--- a/pallets/subtensor/src/tests/staking.rs
+++ b/pallets/subtensor/src/tests/staking.rs
@@ -38,7 +38,7 @@ fn test_add_stake_dispatch_info_ok() {
         assert_eq!(
             call.get_dispatch_info(),
             DispatchInfo {
-                weight: frame_support::weights::Weight::from_parts(2_245_500_000, 0),
+                weight: frame_support::weights::Weight::from_parts(2_395_500_000, 0),
                 class: DispatchClass::Normal,
                 pays_fee: Pays::No
             }

From 550d6cc8517868160fd9025016cf2d8b691c7059 Mon Sep 17 00:00:00 2001
From: HudsonGraeme <spencer@inferencelabs.com>
Date: Tue, 10 Jun 2025 05:58:16 +0000
Subject: [PATCH 276/418] Add sudo_set_bonds_reset

---
 pallets/admin-utils/src/lib.rs       | 35 +++++++++++++++++++
 pallets/admin-utils/src/tests/mod.rs | 50 ++++++++++++++++++++++++++++
 precompiles/src/solidity/subnet.sol  |  8 +++++
 precompiles/src/subnet.rs            | 21 ++++++++++++
 4 files changed, 114 insertions(+)

diff --git a/pallets/admin-utils/src/lib.rs b/pallets/admin-utils/src/lib.rs
index 2b41539816..5ea88eb76f 100644
--- a/pallets/admin-utils/src/lib.rs
+++ b/pallets/admin-utils/src/lib.rs
@@ -84,6 +84,13 @@ pub mod pallet {
             /// Indicates if the Yuma3 enable was enabled or disabled.
             enabled: bool,
         },
+        /// Event emitted when Bonds Reset is toggled.
+        BondsResetToggled {
+            /// The network identifier.
+            netuid: u16,
+            /// Indicates if the Bonds Reset was enabled or disabled.
+            enabled: bool,
+        },
     }
 
     // Errors inform users that something went wrong.
@@ -1602,6 +1609,34 @@ pub mod pallet {
             Ok(())
         }
 
+        /// Enables or disables Bonds Reset for a given subnet.
+        ///
+        /// # Parameters
+        /// - `origin`: The origin of the call, which must be the root account or subnet owner.
+        /// - `netuid`: The unique identifier for the subnet.
+        /// - `enabled`: A boolean flag to enable or disable Bonds Reset.
+        ///
+        /// # Weight
+        /// This function has a fixed weight of 0 and is classified as an operational transaction that does not incur any fees.
+        #[pallet::call_index(70)]
+        #[pallet::weight((0, DispatchClass::Operational, Pays::No))]
+        pub fn sudo_set_bonds_reset_enabled(
+            origin: OriginFor<T>,
+            netuid: u16,
+            enabled: bool,
+        ) -> DispatchResult {
+            pallet_subtensor::Pallet::<T>::ensure_subnet_owner_or_root(origin, netuid)?;
+            pallet_subtensor::Pallet::<T>::set_bonds_reset(netuid, enabled);
+
+            Self::deposit_event(Event::BondsResetToggled { netuid, enabled });
+            log::debug!(
+                "BondsResetToggled( netuid: {:?} bonds_reset: {:?} ) ",
+                netuid,
+                enabled
+            );
+            Ok(())
+        }
+
         /// Sets or updates the hotkey account associated with the owner of a specific subnet.
         ///
         /// This function allows either the root origin or the current subnet owner to set or update
diff --git a/pallets/admin-utils/src/tests/mod.rs b/pallets/admin-utils/src/tests/mod.rs
index bb813ce117..8e19f8eb60 100644
--- a/pallets/admin-utils/src/tests/mod.rs
+++ b/pallets/admin-utils/src/tests/mod.rs
@@ -1780,3 +1780,53 @@ fn test_set_sn_owner_hotkey_root() {
         assert_eq!(actual_hotkey, hotkey);
     });
 }
+
+#[test]
+fn test_sudo_set_bonds_reset_enabled() {
+    new_test_ext().execute_with(|| {
+        let netuid: u16 = 1;
+        let to_be_set: bool = true;
+        add_network(netuid, 10);
+        let init_value: bool = SubtensorModule::get_bonds_reset(netuid);
+        assert_eq!(
+            AdminUtils::sudo_set_bonds_reset_enabled(
+                <<Test as Config>::RuntimeOrigin>::signed(U256::from(1)),
+                netuid,
+                to_be_set
+            ),
+            Err(DispatchError::BadOrigin)
+        );
+        assert_ok!(AdminUtils::sudo_set_bonds_reset_enabled(
+            <<Test as Config>::RuntimeOrigin>::root(),
+            netuid,
+            to_be_set
+        ));
+        assert_eq!(SubtensorModule::get_bonds_reset(netuid), to_be_set);
+        assert_ne!(SubtensorModule::get_bonds_reset(netuid), init_value);
+    });
+}
+
+#[test]
+fn test_sudo_set_yuma3_enabled() {
+    new_test_ext().execute_with(|| {
+        let netuid: u16 = 1;
+        let to_be_set: bool = true;
+        add_network(netuid, 10);
+        let init_value: bool = SubtensorModule::get_yuma3_enabled(netuid);
+        assert_eq!(
+            AdminUtils::sudo_set_yuma3_enabled(
+                <<Test as Config>::RuntimeOrigin>::signed(U256::from(1)),
+                netuid,
+                to_be_set
+            ),
+            Err(DispatchError::BadOrigin)
+        );
+        assert_ok!(AdminUtils::sudo_set_yuma3_enabled(
+            <<Test as Config>::RuntimeOrigin>::root(),
+            netuid,
+            to_be_set
+        ));
+        assert_eq!(SubtensorModule::get_yuma3_enabled(netuid), to_be_set);
+        assert_ne!(SubtensorModule::get_yuma3_enabled(netuid), init_value);
+    });
+}
diff --git a/precompiles/src/solidity/subnet.sol b/precompiles/src/solidity/subnet.sol
index 2fa9d3f550..b1da53944e 100644
--- a/precompiles/src/solidity/subnet.sol
+++ b/precompiles/src/solidity/subnet.sol
@@ -159,6 +159,14 @@ interface ISubnet {
         bool yuma3Enabled
     ) external payable;
 
+    function getBondsResetEnabled(uint16 netuid) external view returns (bool);
+
+    function setBondsResetEnabled(
+        uint16 netuid, 
+        bool bondsResetEnabled
+    ) external payable;
+
+
     function getAlphaValues(
         uint16 netuid
     ) external view returns (uint16, uint16);
diff --git a/precompiles/src/subnet.rs b/precompiles/src/subnet.rs
index 7d4dd175e3..20abe48b40 100644
--- a/precompiles/src/subnet.rs
+++ b/precompiles/src/subnet.rs
@@ -577,6 +577,12 @@ where
         Ok(pallet_subtensor::Yuma3On::<R>::get(netuid))
     }
 
+    #[precompile::public("getBondsResetEnabled(uint16)")]
+    #[precompile::view]
+    fn get_bonds_reset_enabled(_: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<bool> {
+        Ok(pallet_subtensor::BondsResetOn::<R>::get(netuid))
+    }
+
     #[precompile::public("setYuma3Enabled(uint16,bool)")]
     #[precompile::payable]
     fn set_yuma3_enabled(
@@ -592,6 +598,21 @@ where
         )
     }
 
+    #[precompile::public("setBondsResetEnabled(uint16,bool)")]
+    #[precompile::payable]
+    fn set_bonds_reset_enabled(
+        handle: &mut impl PrecompileHandle,
+        netuid: u16,
+        enabled: bool,
+    ) -> EvmResult<()> {
+        let call = pallet_admin_utils::Call::<R>::sudo_set_bonds_reset_enabled { netuid, enabled };
+
+        handle.try_dispatch_runtime_call::<R, _>(
+            call,
+            RawOrigin::Signed(handle.caller_account_id::<R>()),
+        )
+    }
+
     #[precompile::public("getAlphaValues(uint16)")]
     #[precompile::view]
     fn get_alpha_values(_: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<(u16, u16)> {

From 4c0bfaa3af303485a8500b7fb644d6b07ea1558a Mon Sep 17 00:00:00 2001
From: HudsonGraeme <spencer@inferencelabs.com>
Date: Tue, 10 Jun 2025 06:31:38 +0000
Subject: [PATCH 277/418] Update ABI

---
 precompiles/src/solidity/subnet.abi | 37 +++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/precompiles/src/solidity/subnet.abi b/precompiles/src/solidity/subnet.abi
index a2849a0cbe..35f8a06571 100644
--- a/precompiles/src/solidity/subnet.abi
+++ b/precompiles/src/solidity/subnet.abi
@@ -80,6 +80,25 @@
 		"stateMutability": "view",
 		"type": "function"
 	},
+	{
+		"inputs": [
+			{
+				"internalType": "uint16",
+				"name": "netuid",
+				"type": "uint16"
+			}
+		],
+		"name": "getBondsResetEnabled",
+		"outputs": [
+			{
+				"internalType": "bool",
+				"name": "",
+				"type": "bool"
+			}
+		],
+		"stateMutability": "view",
+		"type": "function"
+	},
 	{
 		"inputs": [
 			{
@@ -579,6 +598,24 @@
 		"stateMutability": "payable",
 		"type": "function"
 	},
+	{
+		"inputs": [
+			{
+				"internalType": "uint16",
+				"name": "netuid",
+				"type": "uint16"
+			},
+			{
+				"internalType": "bool",
+				"name": "bondsResetEnabled",
+				"type": "bool"
+			}
+		],
+		"name": "setBondsResetEnabled",
+		"outputs": [],
+		"stateMutability": "payable",
+		"type": "function"
+	},
 	{
 		"inputs": [
 			{

From 001e12ae4541971666256c9242c66975bf8b575a Mon Sep 17 00:00:00 2001
From: HudsonGraeme <spencer@inferencelabs.com>
Date: Tue, 10 Jun 2025 06:34:52 +0000
Subject: [PATCH 278/418] Test SN owner call in addition to root

---
 pallets/admin-utils/src/tests/mod.rs | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/pallets/admin-utils/src/tests/mod.rs b/pallets/admin-utils/src/tests/mod.rs
index 8e19f8eb60..62fdac223d 100644
--- a/pallets/admin-utils/src/tests/mod.rs
+++ b/pallets/admin-utils/src/tests/mod.rs
@@ -1786,8 +1786,10 @@ fn test_sudo_set_bonds_reset_enabled() {
     new_test_ext().execute_with(|| {
         let netuid: u16 = 1;
         let to_be_set: bool = true;
+        let sn_owner = U256::from(1);
         add_network(netuid, 10);
         let init_value: bool = SubtensorModule::get_bonds_reset(netuid);
+
         assert_eq!(
             AdminUtils::sudo_set_bonds_reset_enabled(
                 <<Test as Config>::RuntimeOrigin>::signed(U256::from(1)),
@@ -1796,6 +1798,7 @@ fn test_sudo_set_bonds_reset_enabled() {
             ),
             Err(DispatchError::BadOrigin)
         );
+
         assert_ok!(AdminUtils::sudo_set_bonds_reset_enabled(
             <<Test as Config>::RuntimeOrigin>::root(),
             netuid,
@@ -1803,6 +1806,15 @@ fn test_sudo_set_bonds_reset_enabled() {
         ));
         assert_eq!(SubtensorModule::get_bonds_reset(netuid), to_be_set);
         assert_ne!(SubtensorModule::get_bonds_reset(netuid), init_value);
+
+        pallet_subtensor::SubnetOwner::<Test>::insert(netuid, sn_owner);
+
+        assert_ok!(AdminUtils::sudo_set_bonds_reset_enabled(
+            <<Test as Config>::RuntimeOrigin>::signed(sn_owner),
+            netuid,
+            !to_be_set
+        ));
+        assert_eq!(SubtensorModule::get_bonds_reset(netuid), !to_be_set);
     });
 }
 
@@ -1811,8 +1823,10 @@ fn test_sudo_set_yuma3_enabled() {
     new_test_ext().execute_with(|| {
         let netuid: u16 = 1;
         let to_be_set: bool = true;
+        let sn_owner = U256::from(1);
         add_network(netuid, 10);
         let init_value: bool = SubtensorModule::get_yuma3_enabled(netuid);
+
         assert_eq!(
             AdminUtils::sudo_set_yuma3_enabled(
                 <<Test as Config>::RuntimeOrigin>::signed(U256::from(1)),
@@ -1821,6 +1835,7 @@ fn test_sudo_set_yuma3_enabled() {
             ),
             Err(DispatchError::BadOrigin)
         );
+
         assert_ok!(AdminUtils::sudo_set_yuma3_enabled(
             <<Test as Config>::RuntimeOrigin>::root(),
             netuid,
@@ -1828,5 +1843,14 @@ fn test_sudo_set_yuma3_enabled() {
         ));
         assert_eq!(SubtensorModule::get_yuma3_enabled(netuid), to_be_set);
         assert_ne!(SubtensorModule::get_yuma3_enabled(netuid), init_value);
+
+        pallet_subtensor::SubnetOwner::<Test>::insert(netuid, sn_owner);
+
+        assert_ok!(AdminUtils::sudo_set_yuma3_enabled(
+            <<Test as Config>::RuntimeOrigin>::signed(sn_owner),
+            netuid,
+            !to_be_set
+        ));
+        assert_eq!(SubtensorModule::get_yuma3_enabled(netuid), !to_be_set);
     });
 }

From 074af6216614b142dd3c335c983bfb0420ad1e94 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Tue, 10 Jun 2025 15:40:36 +0200
Subject: [PATCH 279/418] Fix pallet-commitments compilation

---
 pallets/admin-utils/src/benchmarking.rs | 111 +++++++++++++++++++-----
 pallets/admin-utils/src/lib.rs          |   2 +-
 pallets/commitments/src/lib.rs          |  13 ++-
 pallets/commitments/src/mock.rs         |   2 +-
 pallets/commitments/src/tests.rs        |  90 ++++++++++---------
 pallets/subtensor/src/macros/hooks.rs   |   3 +-
 precompiles/src/metagraph.rs            |  36 +++++---
 precompiles/src/neuron.rs               |   5 +-
 precompiles/src/staking.rs              |  13 ++-
 precompiles/src/subnet.rs               |  96 +++++++++++++++-----
 10 files changed, 259 insertions(+), 112 deletions(-)

diff --git a/pallets/admin-utils/src/benchmarking.rs b/pallets/admin-utils/src/benchmarking.rs
index 20d1e10055..917d9008ba 100644
--- a/pallets/admin-utils/src/benchmarking.rs
+++ b/pallets/admin-utils/src/benchmarking.rs
@@ -62,7 +62,10 @@ mod benchmarks {
 
     #[benchmark]
     fn sudo_set_max_difficulty() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16.into() /*netuid*/, 1u16 /*tempo*/);
+        pallet_subtensor::Pallet::<T>::init_new_network(
+            1u16.into(), /*netuid*/
+            1u16,        /*tempo*/
+        );
 
         #[extrinsic_call]
 		_(RawOrigin::Root, 1u16.into()/*netuid*/, 10000u64/*max_difficulty*/)/*sudo_set_max_difficulty*/;
@@ -70,7 +73,10 @@ mod benchmarks {
 
     #[benchmark]
     fn sudo_set_min_difficulty() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16.into() /*netuid*/, 1u16 /*tempo*/);
+        pallet_subtensor::Pallet::<T>::init_new_network(
+            1u16.into(), /*netuid*/
+            1u16,        /*tempo*/
+        );
 
         #[extrinsic_call]
 		_(RawOrigin::Root, 1u16.into()/*netuid*/, 1000u64/*min_difficulty*/)/*sudo_set_min_difficulty*/;
@@ -78,7 +84,10 @@ mod benchmarks {
 
     #[benchmark]
     fn sudo_set_weights_set_rate_limit() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16.into() /*netuid*/, 1u16 /*tempo*/);
+        pallet_subtensor::Pallet::<T>::init_new_network(
+            1u16.into(), /*netuid*/
+            1u16,        /*tempo*/
+        );
 
         #[extrinsic_call]
 		_(RawOrigin::Root, 1u16.into()/*netuid*/, 3u64/*rate_limit*/)/*sudo_set_weights_set_rate_limit*/;
@@ -86,7 +95,10 @@ mod benchmarks {
 
     #[benchmark]
     fn sudo_set_weights_version_key() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16.into() /*netuid*/, 1u16 /*tempo*/);
+        pallet_subtensor::Pallet::<T>::init_new_network(
+            1u16.into(), /*netuid*/
+            1u16,        /*tempo*/
+        );
 
         #[extrinsic_call]
 		_(RawOrigin::Root, 1u16.into()/*netuid*/, 1u64/*version_key*/)/*sudo_set_weights_version_key*/;
@@ -94,7 +106,10 @@ mod benchmarks {
 
     #[benchmark]
     fn sudo_set_bonds_moving_average() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16.into() /*netuid*/, 1u16 /*tempo*/);
+        pallet_subtensor::Pallet::<T>::init_new_network(
+            1u16.into(), /*netuid*/
+            1u16,        /*tempo*/
+        );
 
         #[extrinsic_call]
 		_(RawOrigin::Root, 1u16.into()/*netuid*/, 100u64/*bonds_moving_average*/)/*sudo_set_bonds_moving_average*/;
@@ -102,7 +117,10 @@ mod benchmarks {
 
     #[benchmark]
     fn sudo_set_bonds_penalty() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16.into() /*netuid*/, 1u16 /*tempo*/);
+        pallet_subtensor::Pallet::<T>::init_new_network(
+            1u16.into(), /*netuid*/
+            1u16,        /*tempo*/
+        );
 
         #[extrinsic_call]
         _(RawOrigin::Root, 1u16.into()/*netuid*/, 100u16/*bonds_penalty*/)/*sudo_set_bonds_penalty*/;
@@ -110,7 +128,10 @@ mod benchmarks {
 
     #[benchmark]
     fn sudo_set_max_allowed_validators() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16.into() /*netuid*/, 1u16 /*tempo*/);
+        pallet_subtensor::Pallet::<T>::init_new_network(
+            1u16.into(), /*netuid*/
+            1u16,        /*tempo*/
+        );
 
         #[extrinsic_call]
 		_(RawOrigin::Root, 1u16.into()/*netuid*/, 10u16/*max_allowed_validators*/)/*sudo_set_max_allowed_validators*/;
@@ -118,7 +139,10 @@ mod benchmarks {
 
     #[benchmark]
     fn sudo_set_difficulty() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16.into() /*netuid*/, 1u16 /*tempo*/);
+        pallet_subtensor::Pallet::<T>::init_new_network(
+            1u16.into(), /*netuid*/
+            1u16,        /*tempo*/
+        );
 
         #[extrinsic_call]
 		_(RawOrigin::Root, 1u16.into()/*netuid*/, 1200000u64/*difficulty*/)/*sudo_set_difficulty*/;
@@ -126,7 +150,10 @@ mod benchmarks {
 
     #[benchmark]
     fn sudo_set_adjustment_interval() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16.into() /*netuid*/, 1u16 /*tempo*/);
+        pallet_subtensor::Pallet::<T>::init_new_network(
+            1u16.into(), /*netuid*/
+            1u16,        /*tempo*/
+        );
 
         #[extrinsic_call]
 		_(RawOrigin::Root, 1u16.into()/*netuid*/, 12u16/*adjustment_interval*/)/*sudo_set_adjustment_interval*/;
@@ -134,7 +161,10 @@ mod benchmarks {
 
     #[benchmark]
     fn sudo_set_target_registrations_per_interval() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16.into() /*netuid*/, 1u16 /*tempo*/);
+        pallet_subtensor::Pallet::<T>::init_new_network(
+            1u16.into(), /*netuid*/
+            1u16,        /*tempo*/
+        );
 
         #[extrinsic_call]
 		_(RawOrigin::Root, 1u16.into()/*netuid*/, 300u16/*target_registrations*/)/*sudo_set_target_registrations_per_interval*/;
@@ -142,7 +172,10 @@ mod benchmarks {
 
     #[benchmark]
     fn sudo_set_activity_cutoff() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16.into() /*netuid*/, 1u16 /*tempo*/);
+        pallet_subtensor::Pallet::<T>::init_new_network(
+            1u16.into(), /*netuid*/
+            1u16,        /*tempo*/
+        );
 
         #[extrinsic_call]
 		_(RawOrigin::Root, 1u16.into()/*netuid*/, 361u16/*activity_cutoff*/)/*sudo_set_activity_cutoff*/;
@@ -150,7 +183,10 @@ mod benchmarks {
 
     #[benchmark]
     fn sudo_set_rho() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16.into() /*netuid*/, 1u16 /*tempo*/);
+        pallet_subtensor::Pallet::<T>::init_new_network(
+            1u16.into(), /*netuid*/
+            1u16,        /*tempo*/
+        );
 
         #[extrinsic_call]
 		_(RawOrigin::Root, 1u16.into()/*netuid*/, 300u16/*rho*/)/*sudo_set_rho*/;
@@ -160,7 +196,7 @@ mod benchmarks {
     fn sudo_set_kappa() {
         pallet_subtensor::Pallet::<T>::init_new_network(
             1u16.into(), /*netuid*/
-            1u16, /*sudo_tempo*/
+            1u16,        /*sudo_tempo*/
         );
 
         #[extrinsic_call]
@@ -169,7 +205,10 @@ mod benchmarks {
 
     #[benchmark]
     fn sudo_set_max_allowed_uids() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16.into() /*netuid*/, 1u16 /*tempo*/);
+        pallet_subtensor::Pallet::<T>::init_new_network(
+            1u16.into(), /*netuid*/
+            1u16,        /*tempo*/
+        );
 
         #[extrinsic_call]
 		_(RawOrigin::Root, 1u16.into()/*netuid*/, 4097u16/*max_allowed_uids*/)/*sudo_set_max_allowed_uids*/;
@@ -177,7 +216,10 @@ mod benchmarks {
 
     #[benchmark]
     fn sudo_set_min_allowed_weights() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16.into() /*netuid*/, 1u16 /*tempo*/);
+        pallet_subtensor::Pallet::<T>::init_new_network(
+            1u16.into(), /*netuid*/
+            1u16,        /*tempo*/
+        );
 
         #[extrinsic_call]
 		_(RawOrigin::Root, 1u16.into()/*netuid*/, 10u16/*max_allowed_uids*/)/*sudo_set_min_allowed_weights*/;
@@ -185,7 +227,10 @@ mod benchmarks {
 
     #[benchmark]
     fn sudo_set_immunity_period() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16.into() /*netuid*/, 1u16 /*tempo*/);
+        pallet_subtensor::Pallet::<T>::init_new_network(
+            1u16.into(), /*netuid*/
+            1u16,        /*tempo*/
+        );
 
         #[extrinsic_call]
 		_(RawOrigin::Root, 1u16.into()/*netuid*/, 100u16/*immunity_period*/)/*sudo_set_immunity_period*/;
@@ -193,7 +238,10 @@ mod benchmarks {
 
     #[benchmark]
     fn sudo_set_max_weight_limit() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16.into() /*netuid*/, 1u16 /*tempo*/);
+        pallet_subtensor::Pallet::<T>::init_new_network(
+            1u16.into(), /*netuid*/
+            1u16,        /*tempo*/
+        );
 
         #[extrinsic_call]
 		_(RawOrigin::Root, 1u16.into()/*netuid*/, 100u16/*max_weight_limit*/)/*sudo_set_max_weight_limit*/;
@@ -201,7 +249,10 @@ mod benchmarks {
 
     #[benchmark]
     fn sudo_set_max_registrations_per_block() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16.into() /*netuid*/, 1u16 /*tempo*/);
+        pallet_subtensor::Pallet::<T>::init_new_network(
+            1u16.into(), /*netuid*/
+            1u16,        /*tempo*/
+        );
 
         #[extrinsic_call]
 		_(RawOrigin::Root, 1u16.into()/*netuid*/, 100u16/*max_registrations*/)/*sudo_set_max_registrations_per_block*/;
@@ -209,7 +260,10 @@ mod benchmarks {
 
     #[benchmark]
     fn sudo_set_max_burn() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16.into() /*netuid*/, 1u16 /*tempo*/);
+        pallet_subtensor::Pallet::<T>::init_new_network(
+            1u16.into(), /*netuid*/
+            1u16,        /*tempo*/
+        );
 
         #[extrinsic_call]
 		_(RawOrigin::Root, 1u16.into()/*netuid*/, 10u64/*max_burn*/)/*sudo_set_max_burn*/;
@@ -217,7 +271,10 @@ mod benchmarks {
 
     #[benchmark]
     fn sudo_set_min_burn() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16.into() /*netuid*/, 1u16 /*tempo*/);
+        pallet_subtensor::Pallet::<T>::init_new_network(
+            1u16.into(), /*netuid*/
+            1u16,        /*tempo*/
+        );
 
         #[extrinsic_call]
 		_(RawOrigin::Root, 1u16.into()/*netuid*/, 10u64/*min_burn*/)/*sudo_set_min_burn*/;
@@ -225,7 +282,10 @@ mod benchmarks {
 
     #[benchmark]
     fn sudo_set_network_registration_allowed() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16.into() /*netuid*/, 1u16 /*tempo*/);
+        pallet_subtensor::Pallet::<T>::init_new_network(
+            1u16.into(), /*netuid*/
+            1u16,        /*tempo*/
+        );
 
         #[extrinsic_call]
 		_(RawOrigin::Root, 1u16.into()/*netuid*/, true/*registration_allowed*/)/*sudo_set_network_registration_allowed*/;
@@ -244,7 +304,10 @@ mod benchmarks {
     */
     #[benchmark]
     fn sudo_set_tempo() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16.into() /*netuid*/, 1u16 /*tempo*/);
+        pallet_subtensor::Pallet::<T>::init_new_network(
+            1u16.into(), /*netuid*/
+            1u16,        /*tempo*/
+        );
 
         #[extrinsic_call]
 		_(RawOrigin::Root, 1u16.into()/*netuid*/, 1u16/*tempo*/)/*sudo_set_tempo*/;
@@ -254,7 +317,7 @@ mod benchmarks {
     fn sudo_set_commit_reveal_weights_interval() {
         pallet_subtensor::Pallet::<T>::init_new_network(
             1u16.into(), /*netuid*/
-            1u16, /*sudo_tempo*/
+            1u16,        /*sudo_tempo*/
         );
 
         #[extrinsic_call]
@@ -265,7 +328,7 @@ mod benchmarks {
     fn sudo_set_commit_reveal_weights_enabled() {
         pallet_subtensor::Pallet::<T>::init_new_network(
             1u16.into(), /*netuid*/
-            1u16, /*sudo_tempo*/
+            1u16,        /*sudo_tempo*/
         );
 
         #[extrinsic_call]
diff --git a/pallets/admin-utils/src/lib.rs b/pallets/admin-utils/src/lib.rs
index 2b9218a7fb..19d751f706 100644
--- a/pallets/admin-utils/src/lib.rs
+++ b/pallets/admin-utils/src/lib.rs
@@ -31,7 +31,7 @@ pub mod pallet {
     use pallet_subtensor::utils::rate_limiting::TransactionType;
     use sp_runtime::BoundedVec;
     use substrate_fixed::types::I96F32;
-	use subtensor_runtime_common::NetUid;
+    use subtensor_runtime_common::NetUid;
 
     /// The main data structure of the module.
     #[pallet::pallet]
diff --git a/pallets/commitments/src/lib.rs b/pallets/commitments/src/lib.rs
index 096b259153..217451a00f 100644
--- a/pallets/commitments/src/lib.rs
+++ b/pallets/commitments/src/lib.rs
@@ -21,13 +21,13 @@ use scale_info::prelude::collections::BTreeSet;
 use sp_runtime::SaturatedConversion;
 use sp_runtime::{Saturating, traits::Zero};
 use sp_std::{boxed::Box, vec::Vec};
+use subtensor_runtime_common::NetUid;
 use tle::{
     curves::drand::TinyBLS381,
     stream_ciphers::AESGCMStreamCipherProvider,
     tlock::{TLECiphertext, tld},
 };
 use w3f_bls::EngineBLS;
-use subtensor_runtime_common::NetUid;
 
 type BalanceOf<T> =
     <<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;
@@ -181,8 +181,15 @@ pub mod pallet {
     /// in the RateLimit window
     #[pallet::storage]
     #[pallet::getter(fn used_space_of)]
-    pub type UsedSpaceOf<T: Config> =
-        StorageDoubleMap<_, Identity, NetUid, Twox64Concat, T::AccountId, UsageTracker, OptionQuery>;
+    pub type UsedSpaceOf<T: Config> = StorageDoubleMap<
+        _,
+        Identity,
+        NetUid,
+        Twox64Concat,
+        T::AccountId,
+        UsageTracker,
+        OptionQuery,
+    >;
 
     #[pallet::type_value]
     /// The default Maximum Space
diff --git a/pallets/commitments/src/mock.rs b/pallets/commitments/src/mock.rs
index 35831749d1..8b8e58150e 100644
--- a/pallets/commitments/src/mock.rs
+++ b/pallets/commitments/src/mock.rs
@@ -109,7 +109,7 @@ impl pallet_commitments::GetTempoInterface for MockTempoInterface {
     fn get_epoch_index(netuid: NetUid, cur_block: u64) -> u64 {
         let tempo = 360; // TODO: configure SubtensorModule in this mock
         let tempo_plus_one: u64 = tempo.saturating_add(1);
-        let netuid_plus_one: u64 = (netuid as u64).saturating_add(1);
+        let netuid_plus_one: u64 = (u16::from(netuid) as u64).saturating_add(1);
         let block_with_offset: u64 = cur_block.saturating_add(netuid_plus_one);
 
         block_with_offset.checked_div(tempo_plus_one).unwrap_or(0)
diff --git a/pallets/commitments/src/tests.rs b/pallets/commitments/src/tests.rs
index 37822f7ce3..431d5e521b 100644
--- a/pallets/commitments/src/tests.rs
+++ b/pallets/commitments/src/tests.rs
@@ -131,7 +131,8 @@ fn set_commitment_works() {
             info.clone()
         ));
 
-        let commitment = Pallet::<Test>::commitment_of(NetUid::from(1), 1).expect("Expected not to panic");
+        let commitment =
+            Pallet::<Test>::commitment_of(NetUid::from(1), 1).expect("Expected not to panic");
         let initial_deposit: u64 = <Test as Config>::InitialDeposit::get();
         assert_eq!(commitment.deposit, initial_deposit);
         assert_eq!(commitment.block, 1);
@@ -152,7 +153,11 @@ fn set_commitment_too_many_fields_panics() {
         });
 
         // We never get here, because the constructor panics above.
-        let _ = Pallet::<Test>::set_commitment(frame_system::RawOrigin::Signed(1).into(), 1.into(), info);
+        let _ = Pallet::<Test>::set_commitment(
+            frame_system::RawOrigin::Signed(1).into(),
+            1.into(),
+            info,
+        );
     });
 }
 
@@ -214,10 +219,11 @@ fn event_emission_works() {
         ));
 
         let events = System::<Test>::events();
-        assert!(events.iter().any(|e| matches!(
-            &e.event,
-            RuntimeEvent::Commitments(Event::Commitment { netuid: NetUid::from(1), who: 1 })
-        )));
+        let expected_event = RuntimeEvent::Commitments(Event::Commitment {
+            netuid: 1.into(),
+            who: 1,
+        });
+        assert!(events.iter().any(|e| e.event == expected_event));
     });
 }
 
@@ -294,7 +300,7 @@ fn happy_path_timelock_commitments() {
 fn reveal_timelocked_commitment_missing_round_does_nothing() {
     new_test_ext().execute_with(|| {
         let who = 1;
-        let netuid = 2;
+        let netuid = NetUid::from(2);
         System::<Test>::set_block_number(5);
         let ciphertext = produce_ciphertext(b"My plaintext", 1000);
         let data = Data::TimelockEncrypted {
@@ -321,7 +327,7 @@ fn reveal_timelocked_commitment_missing_round_does_nothing() {
 fn reveal_timelocked_commitment_cant_deserialize_ciphertext() {
     new_test_ext().execute_with(|| {
         let who = 42;
-        let netuid = 9;
+        let netuid = NetUid::from(9);
         System::<Test>::set_block_number(10);
         let good_ct = produce_ciphertext(b"Some data", 1000);
         let mut corrupted = good_ct.into_inner();
@@ -353,7 +359,7 @@ fn reveal_timelocked_commitment_cant_deserialize_ciphertext() {
 fn reveal_timelocked_commitment_bad_signature_skips_decryption() {
     new_test_ext().execute_with(|| {
         let who = 10;
-        let netuid = 11;
+        let netuid = NetUid::from(11);
         System::<Test>::set_block_number(15);
         let real_ct = produce_ciphertext(b"A valid plaintext", 1000);
         let data = Data::TimelockEncrypted {
@@ -381,7 +387,7 @@ fn reveal_timelocked_commitment_bad_signature_skips_decryption() {
 fn reveal_timelocked_commitment_empty_decrypted_data_is_skipped() {
     new_test_ext().execute_with(|| {
         let who = 2;
-        let netuid = 3;
+        let netuid = NetUid::from(3);
         let commit_block = 100u64;
         System::<Test>::set_block_number(commit_block);
         let reveal_round = 1000;
@@ -440,7 +446,7 @@ fn reveal_timelocked_commitment_single_field_entry_is_removed_after_reveal() {
         };
 
         let who = 555;
-        let netuid = 777;
+        let netuid = NetUid::from(777);
         System::<Test>::set_block_number(1);
         assert_ok!(Pallet::<Test>::set_commitment(
             RuntimeOrigin::signed(who),
@@ -603,7 +609,7 @@ fn reveal_timelocked_multiple_fields_only_correct_ones_removed() {
 #[test]
 fn test_index_lifecycle_no_timelocks_updates_in_out() {
     new_test_ext().execute_with(|| {
-        let netuid = 100;
+        let netuid = NetUid::from(100);
         let who = 999;
 
         //
@@ -668,7 +674,7 @@ fn test_index_lifecycle_no_timelocks_updates_in_out() {
 #[test]
 fn two_timelocks_partial_then_full_reveal() {
     new_test_ext().execute_with(|| {
-        let netuid_a = 1;
+        let netuid_a = NetUid::from(1);
         let who_a = 10;
         let round_1000 = 1000;
         let round_2000 = 2000;
@@ -770,7 +776,7 @@ fn two_timelocks_partial_then_full_reveal() {
 #[test]
 fn single_timelock_reveal_later_round() {
     new_test_ext().execute_with(|| {
-        let netuid_b = 2;
+        let netuid_b = NetUid::from(2);
         let who_b = 20;
         let round_2000 = 2000;
 
@@ -842,7 +848,7 @@ fn single_timelock_reveal_later_round() {
 #[test]
 fn tempo_based_space_limit_accumulates_in_same_window() {
     new_test_ext().execute_with(|| {
-        let netuid = 1;
+        let netuid = NetUid::from(1);
         let who = 100;
         let space_limit = 150;
         MaxSpace::<Test>::set(space_limit);
@@ -875,7 +881,7 @@ fn tempo_based_space_limit_accumulates_in_same_window() {
 #[test]
 fn tempo_based_space_limit_resets_after_tempo() {
     new_test_ext().execute_with(|| {
-        let netuid = 2;
+        let netuid = NetUid::from(2);
         let who = 101;
 
         MaxSpace::<Test>::set(250);
@@ -933,8 +939,8 @@ fn tempo_based_space_limit_resets_after_tempo() {
 #[test]
 fn tempo_based_space_limit_does_not_affect_different_netuid() {
     new_test_ext().execute_with(|| {
-        let netuid_a = 10;
-        let netuid_b = 20;
+        let netuid_a = NetUid::from(10);
+        let netuid_b = NetUid::from(20);
         let who = 111;
         let space_limit = 199;
         MaxSpace::<Test>::set(space_limit);
@@ -983,7 +989,7 @@ fn tempo_based_space_limit_does_not_affect_different_netuid() {
 #[test]
 fn tempo_based_space_limit_does_not_affect_different_user() {
     new_test_ext().execute_with(|| {
-        let netuid = 10;
+        let netuid = NetUid::from(10);
         let user1 = 123;
         let user2 = 456;
         let space_limit = 199;
@@ -1033,7 +1039,7 @@ fn tempo_based_space_limit_does_not_affect_different_user() {
 #[test]
 fn tempo_based_space_limit_sudo_set_max_space() {
     new_test_ext().execute_with(|| {
-        let netuid = 3;
+        let netuid = NetUid::from(3);
         let who = 15;
         MaxSpace::<Test>::set(100);
 
@@ -1070,7 +1076,7 @@ fn tempo_based_space_limit_sudo_set_max_space() {
 fn on_initialize_reveals_matured_timelocks() {
     new_test_ext().execute_with(|| {
         let who = 42;
-        let netuid = 7;
+        let netuid = NetUid::from(7);
         let reveal_round = 1000;
 
         let message_text = b"Timelock test via on_initialize";
@@ -1160,7 +1166,7 @@ fn set_commitment_unreserve_leftover_fails() {
     new_test_ext().execute_with(|| {
         use frame_system::RawOrigin;
 
-        let netuid = 999;
+        let netuid = NetUid::from(999);
         let who = 99;
 
         Balances::make_free_balance_be(&who, 10_000);
@@ -1199,7 +1205,7 @@ fn timelocked_index_complex_scenario_works() {
     new_test_ext().execute_with(|| {
         System::<Test>::set_block_number(1);
 
-        let netuid = 42;
+        let netuid = NetUid::from(42);
         let user_a = 1000;
         let user_b = 2000;
         let user_c = 3000;
@@ -1458,7 +1464,7 @@ fn reveal_timelocked_bad_timelocks_are_removed() {
         // 3) Insert the commitment
         //
         let who = 123;
-        let netuid = 777;
+        let netuid = NetUid::from(777);
         System::<Test>::set_block_number(1);
         assert_ok!(Pallet::<Test>::set_commitment(
             RawOrigin::Signed(who).into(),
@@ -1532,7 +1538,7 @@ fn reveal_timelocked_bad_timelocks_are_removed() {
 #[test]
 fn revealed_commitments_keeps_only_10_items() {
     new_test_ext().execute_with(|| {
-        let netuid = 1;
+        let netuid = NetUid::from(1);
         let who = 2;
         let reveal_round = 1000;
 
@@ -1600,7 +1606,7 @@ fn revealed_commitments_keeps_only_10_items() {
 #[test]
 fn revealed_commitments_keeps_only_10_newest_with_individual_single_field_commits() {
     new_test_ext().execute_with(|| {
-        let netuid = 1;
+        let netuid = NetUid::from(1);
         let who = 2;
         let reveal_round = 1000;
 
@@ -1679,7 +1685,7 @@ fn usage_respects_minimum_of_100_bytes() {
     new_test_ext().execute_with(|| {
         MaxSpace::<Test>::set(1000);
 
-        let netuid = 1;
+        let netuid = NetUid::from(1);
         let who = 99;
 
         System::<Test>::set_block_number(1);
@@ -1768,12 +1774,12 @@ fn set_commitment_works_with_multiple_raw_fields() {
 
         assert_ok!(Pallet::<Test>::set_commitment(
             RuntimeOrigin::signed(12345),
-            99,
+            99.into(),
             Box::new(info_multiple)
         ));
 
         let expected_deposit: BalanceOf<Test> = initial_deposit + 3u64 * field_deposit;
-        let stored = CommitmentOf::<Test>::get(99, 12345).expect("Should be stored");
+        let stored = CommitmentOf::<Test>::get(NetUid::from(99), 12345).expect("Should be stored");
         assert_eq!(
             stored.deposit, expected_deposit,
             "Deposit must equal initial + 3 * field_deposit"
@@ -1781,7 +1787,8 @@ fn set_commitment_works_with_multiple_raw_fields() {
 
         assert_eq!(stored.block, cur_block, "Stored block must match cur_block");
 
-        let usage = UsedSpaceOf::<Test>::get(99, 12345).expect("Expected to not panic");
+        let usage =
+            UsedSpaceOf::<Test>::get(NetUid::from(99), 12345).expect("Expected to not panic");
         assert_eq!(
             usage.used_space, 100,
             "Usage is clamped to 100 when sum of fields is < 100"
@@ -1797,18 +1804,19 @@ fn set_commitment_works_with_multiple_raw_fields() {
 
         assert_ok!(Pallet::<Test>::set_commitment(
             RuntimeOrigin::signed(12345),
-            99,
+            99.into(),
             Box::new(info_two_fields)
         ));
 
         let expected_deposit2: BalanceOf<Test> = initial_deposit + 2u64 * field_deposit;
-        let stored2 = CommitmentOf::<Test>::get(99, 12345).expect("Should be stored");
+        let stored2 = CommitmentOf::<Test>::get(NetUid::from(99), 12345).expect("Should be stored");
         assert_eq!(
             stored2.deposit, expected_deposit2,
             "Deposit must have decreased after removing one field"
         );
 
-        let usage2 = UsedSpaceOf::<Test>::get(99, 12345).expect("Expected to not panic");
+        let usage2 =
+            UsedSpaceOf::<Test>::get(NetUid::from(99), 12345).expect("Expected to not panic");
         let expected_usage2 = 200u64;
         assert_eq!(
             usage2.used_space, expected_usage2,
@@ -1816,15 +1824,11 @@ fn set_commitment_works_with_multiple_raw_fields() {
         );
 
         let events = System::<Test>::events();
-        let found_commitment_event = events.iter().any(|e| {
-            matches!(
-                e.event,
-                RuntimeEvent::Commitments(Event::Commitment {
-                    netuid: 99,
-                    who: 12345
-                })
-            )
+        let expected_event = RuntimeEvent::Commitments(Event::Commitment {
+            netuid: 99.into(),
+            who: 12345,
         });
+        let found_commitment_event = events.iter().any(|e| e.event == expected_event);
         assert!(
             found_commitment_event,
             "Expected at least one Event::Commitment to be emitted"
@@ -1843,7 +1847,7 @@ fn multiple_timelocked_commitments_reveal_works() {
         System::<Test>::set_block_number(cur_block);
 
         let who = 123;
-        let netuid = 999;
+        let netuid = NetUid::from(999);
 
         // -------------------------------------------
         // 2) Create multiple TLE fields referencing
@@ -2023,7 +2027,7 @@ fn mixed_timelocked_and_raw_fields_works() {
         System::<Test>::set_block_number(cur_block);
 
         let who = 77;
-        let netuid = 501;
+        let netuid = NetUid::from(501);
 
         // -------------------------------------------
         // 2) Create raw fields and timelocked fields
diff --git a/pallets/subtensor/src/macros/hooks.rs b/pallets/subtensor/src/macros/hooks.rs
index 2acf3938c6..5e30388735 100644
--- a/pallets/subtensor/src/macros/hooks.rs
+++ b/pallets/subtensor/src/macros/hooks.rs
@@ -147,7 +147,8 @@ mod hooks {
             if let Some(slot) = block_number.checked_rem(hotkey_swap_on_subnet_interval) {
                 // only handle the subnet with the same residue as current block number by HotkeySwapOnSubnetInterval
                 for netuid in netuids.iter().filter(|netuid| {
-                    (u16::from(**netuid) as u64).checked_rem(hotkey_swap_on_subnet_interval) == Some(slot)
+                    (u16::from(**netuid) as u64).checked_rem(hotkey_swap_on_subnet_interval)
+                        == Some(slot)
                 }) {
                     // Iterate over all the coldkeys in the subnet
                     for (coldkey, swap_block_number) in
diff --git a/precompiles/src/metagraph.rs b/precompiles/src/metagraph.rs
index 4c8ec4e634..05f7a5bf79 100644
--- a/precompiles/src/metagraph.rs
+++ b/precompiles/src/metagraph.rs
@@ -28,7 +28,9 @@ where
     #[precompile::public("getUidCount(uint16)")]
     #[precompile::view]
     fn get_uid_count(_: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<u16> {
-        Ok(pallet_subtensor::SubnetworkN::<R>::get(NetUid::from(netuid)))
+        Ok(pallet_subtensor::SubnetworkN::<R>::get(NetUid::from(
+            netuid,
+        )))
     }
 
     #[precompile::public("getStake(uint16,uint16)")]
@@ -47,14 +49,18 @@ where
     #[precompile::public("getRank(uint16,uint16)")]
     #[precompile::view]
     fn get_rank(_: &mut impl PrecompileHandle, netuid: u16, uid: u16) -> EvmResult<u16> {
-        Ok(pallet_subtensor::Pallet::<R>::get_rank_for_uid(netuid.into(), uid))
+        Ok(pallet_subtensor::Pallet::<R>::get_rank_for_uid(
+            netuid.into(),
+            uid,
+        ))
     }
 
     #[precompile::public("getTrust(uint16,uint16)")]
     #[precompile::view]
     fn get_trust(_: &mut impl PrecompileHandle, netuid: u16, uid: u16) -> EvmResult<u16> {
         Ok(pallet_subtensor::Pallet::<R>::get_trust_for_uid(
-            netuid.into(), uid,
+            netuid.into(),
+            uid,
         ))
     }
 
@@ -62,7 +68,8 @@ where
     #[precompile::view]
     fn get_consensus(_: &mut impl PrecompileHandle, netuid: u16, uid: u16) -> EvmResult<u16> {
         Ok(pallet_subtensor::Pallet::<R>::get_consensus_for_uid(
-            netuid.into(), uid,
+            netuid.into(),
+            uid,
         ))
     }
 
@@ -70,7 +77,8 @@ where
     #[precompile::view]
     fn get_incentive(_: &mut impl PrecompileHandle, netuid: u16, uid: u16) -> EvmResult<u16> {
         Ok(pallet_subtensor::Pallet::<R>::get_incentive_for_uid(
-            netuid.into(), uid,
+            netuid.into(),
+            uid,
         ))
     }
 
@@ -78,7 +86,8 @@ where
     #[precompile::view]
     fn get_dividends(_: &mut impl PrecompileHandle, netuid: u16, uid: u16) -> EvmResult<u16> {
         Ok(pallet_subtensor::Pallet::<R>::get_dividends_for_uid(
-            netuid.into(), uid,
+            netuid.into(),
+            uid,
         ))
     }
 
@@ -86,7 +95,8 @@ where
     #[precompile::view]
     fn get_emission(_: &mut impl PrecompileHandle, netuid: u16, uid: u16) -> EvmResult<u64> {
         Ok(pallet_subtensor::Pallet::<R>::get_emission_for_uid(
-            netuid.into(), uid,
+            netuid.into(),
+            uid,
         ))
     }
 
@@ -94,7 +104,8 @@ where
     #[precompile::view]
     fn get_vtrust(_: &mut impl PrecompileHandle, netuid: u16, uid: u16) -> EvmResult<u16> {
         Ok(pallet_subtensor::Pallet::<R>::get_validator_trust_for_uid(
-            netuid.into(), uid,
+            netuid.into(),
+            uid,
         ))
     }
 
@@ -106,7 +117,8 @@ where
         uid: u16,
     ) -> EvmResult<bool> {
         Ok(pallet_subtensor::Pallet::<R>::get_validator_permit_for_uid(
-            netuid.into(), uid,
+            netuid.into(),
+            uid,
         ))
     }
 
@@ -114,7 +126,8 @@ where
     #[precompile::view]
     fn get_last_update(_: &mut impl PrecompileHandle, netuid: u16, uid: u16) -> EvmResult<u64> {
         Ok(pallet_subtensor::Pallet::<R>::get_last_update_for_uid(
-            netuid.into(), uid,
+            netuid.into(),
+            uid,
         ))
     }
 
@@ -122,7 +135,8 @@ where
     #[precompile::view]
     fn get_is_active(_: &mut impl PrecompileHandle, netuid: u16, uid: u16) -> EvmResult<bool> {
         Ok(pallet_subtensor::Pallet::<R>::get_active_for_uid(
-            netuid.into(), uid,
+            netuid.into(),
+            uid,
         ))
     }
 
diff --git a/precompiles/src/neuron.rs b/precompiles/src/neuron.rs
index 46f8333690..3e49387bb3 100644
--- a/precompiles/src/neuron.rs
+++ b/precompiles/src/neuron.rs
@@ -107,7 +107,10 @@ where
     ) -> EvmResult<()> {
         let coldkey = handle.caller_account_id::<R>();
         let hotkey = R::AccountId::from(hotkey.0);
-        let call = pallet_subtensor::Call::<R>::burned_register { netuid: netuid.into(), hotkey };
+        let call = pallet_subtensor::Call::<R>::burned_register {
+            netuid: netuid.into(),
+            hotkey,
+        };
 
         handle.try_dispatch_runtime_call::<R, _>(call, RawOrigin::Signed(coldkey))
     }
diff --git a/precompiles/src/staking.rs b/precompiles/src/staking.rs
index a996ce7494..f26506b14c 100644
--- a/precompiles/src/staking.rs
+++ b/precompiles/src/staking.rs
@@ -37,7 +37,7 @@ use precompile_utils::EvmResult;
 use sp_core::{H256, U256};
 use sp_runtime::traits::{Dispatchable, StaticLookup, UniqueSaturatedInto};
 use sp_std::vec;
-use subtensor_runtime_common::{ProxyType, NetUid};
+use subtensor_runtime_common::{NetUid, ProxyType};
 
 use crate::{PrecompileExt, PrecompileHandleExt};
 
@@ -209,7 +209,9 @@ where
         let coldkey = R::AccountId::from(coldkey.0);
         let netuid = try_u16_from_u256(netuid)?;
         let stake = pallet_subtensor::Pallet::<R>::get_stake_for_hotkey_and_coldkey_on_subnet(
-            &hotkey, &coldkey, netuid.into(),
+            &hotkey,
+            &coldkey,
+            netuid.into(),
         );
 
         Ok(stake.into())
@@ -245,7 +247,8 @@ where
     ) -> EvmResult<U256> {
         let hotkey = R::AccountId::from(hotkey.0);
         let netuid = try_u16_from_u256(netuid)?;
-        let stake = pallet_subtensor::Pallet::<R>::get_stake_for_hotkey_on_subnet(&hotkey, netuid.into());
+        let stake =
+            pallet_subtensor::Pallet::<R>::get_stake_for_hotkey_on_subnet(&hotkey, netuid.into());
 
         Ok(stake.into())
     }
@@ -466,7 +469,9 @@ where
         let coldkey = R::AccountId::from(coldkey.0);
         let netuid = try_u16_from_u256(netuid)?;
         let stake = pallet_subtensor::Pallet::<R>::get_stake_for_hotkey_and_coldkey_on_subnet(
-            &hotkey, &coldkey, netuid.into(),
+            &hotkey,
+            &coldkey,
+            netuid.into(),
         );
         let stake: SubstrateBalance = stake.into();
         let stake = <R as pallet_evm::Config>::BalanceConverter::into_evm_balance(stake)
diff --git a/precompiles/src/subnet.rs b/precompiles/src/subnet.rs
index ce572242bc..7a43d3f4d4 100644
--- a/precompiles/src/subnet.rs
+++ b/precompiles/src/subnet.rs
@@ -99,7 +99,9 @@ where
     #[precompile::public("getServingRateLimit(uint16)")]
     #[precompile::view]
     fn get_serving_rate_limit(_: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<u64> {
-        Ok(pallet_subtensor::ServingRateLimit::<R>::get(NetUid::from(netuid)))
+        Ok(pallet_subtensor::ServingRateLimit::<R>::get(NetUid::from(
+            netuid,
+        )))
     }
 
     #[precompile::public("setServingRateLimit(uint16,uint64)")]
@@ -123,7 +125,9 @@ where
     #[precompile::public("getMinDifficulty(uint16)")]
     #[precompile::view]
     fn get_min_difficulty(_: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<u64> {
-        Ok(pallet_subtensor::MinDifficulty::<R>::get(NetUid::from(netuid)))
+        Ok(pallet_subtensor::MinDifficulty::<R>::get(NetUid::from(
+            netuid,
+        )))
     }
 
     #[precompile::public("setMinDifficulty(uint16,uint64)")]
@@ -147,7 +151,9 @@ where
     #[precompile::public("getMaxDifficulty(uint16)")]
     #[precompile::view]
     fn get_max_difficulty(_: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<u64> {
-        Ok(pallet_subtensor::MaxDifficulty::<R>::get(NetUid::from(netuid)))
+        Ok(pallet_subtensor::MaxDifficulty::<R>::get(NetUid::from(
+            netuid,
+        )))
     }
 
     #[precompile::public("setMaxDifficulty(uint16,uint64)")]
@@ -171,7 +177,9 @@ where
     #[precompile::public("getWeightsVersionKey(uint16)")]
     #[precompile::view]
     fn get_weights_version_key(_: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<u64> {
-        Ok(pallet_subtensor::WeightsVersionKey::<R>::get(NetUid::from(netuid)))
+        Ok(pallet_subtensor::WeightsVersionKey::<R>::get(NetUid::from(
+            netuid,
+        )))
     }
 
     #[precompile::public("setWeightsVersionKey(uint16,uint64)")]
@@ -195,7 +203,9 @@ where
     #[precompile::public("getWeightsSetRateLimit(uint16)")]
     #[precompile::view]
     fn get_weights_set_rate_limit(_: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<u64> {
-        Ok(pallet_subtensor::WeightsSetRateLimit::<R>::get(NetUid::from(netuid)))
+        Ok(pallet_subtensor::WeightsSetRateLimit::<R>::get(
+            NetUid::from(netuid),
+        ))
     }
 
     #[precompile::public("setWeightsSetRateLimit(uint16,uint64)")]
@@ -212,7 +222,9 @@ where
     #[precompile::public("getAdjustmentAlpha(uint16)")]
     #[precompile::view]
     fn get_adjustment_alpha(_: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<u64> {
-        Ok(pallet_subtensor::AdjustmentAlpha::<R>::get(NetUid::from(netuid)))
+        Ok(pallet_subtensor::AdjustmentAlpha::<R>::get(NetUid::from(
+            netuid,
+        )))
     }
 
     #[precompile::public("setAdjustmentAlpha(uint16,uint64)")]
@@ -236,7 +248,9 @@ where
     #[precompile::public("getMaxWeightLimit(uint16)")]
     #[precompile::view]
     fn get_max_weight_limit(_: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<u16> {
-        Ok(pallet_subtensor::MaxWeightsLimit::<R>::get(NetUid::from(netuid)))
+        Ok(pallet_subtensor::MaxWeightsLimit::<R>::get(NetUid::from(
+            netuid,
+        )))
     }
 
     #[precompile::public("setMaxWeightLimit(uint16,uint16)")]
@@ -260,7 +274,9 @@ where
     #[precompile::public("getImmunityPeriod(uint16)")]
     #[precompile::view]
     fn get_immunity_period(_: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<u16> {
-        Ok(pallet_subtensor::ImmunityPeriod::<R>::get(NetUid::from(netuid)))
+        Ok(pallet_subtensor::ImmunityPeriod::<R>::get(NetUid::from(
+            netuid,
+        )))
     }
 
     #[precompile::public("setImmunityPeriod(uint16,uint16)")]
@@ -284,7 +300,9 @@ where
     #[precompile::public("getMinAllowedWeights(uint16)")]
     #[precompile::view]
     fn get_min_allowed_weights(_: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<u16> {
-        Ok(pallet_subtensor::MinAllowedWeights::<R>::get(NetUid::from(netuid)))
+        Ok(pallet_subtensor::MinAllowedWeights::<R>::get(NetUid::from(
+            netuid,
+        )))
     }
 
     #[precompile::public("setMinAllowedWeights(uint16,uint16)")]
@@ -314,7 +332,10 @@ where
     #[precompile::public("setKappa(uint16,uint16)")]
     #[precompile::payable]
     fn set_kappa(handle: &mut impl PrecompileHandle, netuid: u16, kappa: u16) -> EvmResult<()> {
-        let call = pallet_admin_utils::Call::<R>::sudo_set_kappa { netuid: netuid.into(), kappa };
+        let call = pallet_admin_utils::Call::<R>::sudo_set_kappa {
+            netuid: netuid.into(),
+            kappa,
+        };
 
         handle.try_dispatch_runtime_call::<R, _>(
             call,
@@ -331,13 +352,18 @@ where
     #[precompile::public("getAlphaSigmoidSteepness(uint16)")]
     #[precompile::view]
     fn get_alpha_sigmoid_steepness(_: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<u16> {
-        Ok(pallet_subtensor::AlphaSigmoidSteepness::<R>::get(NetUid::from(netuid)))
+        Ok(pallet_subtensor::AlphaSigmoidSteepness::<R>::get(
+            NetUid::from(netuid),
+        ))
     }
 
     #[precompile::public("setRho(uint16,uint16)")]
     #[precompile::payable]
     fn set_rho(handle: &mut impl PrecompileHandle, netuid: u16, rho: u16) -> EvmResult<()> {
-        let call = pallet_admin_utils::Call::<R>::sudo_set_rho { netuid: netuid.into(), rho };
+        let call = pallet_admin_utils::Call::<R>::sudo_set_rho {
+            netuid: netuid.into(),
+            rho,
+        };
 
         handle.try_dispatch_runtime_call::<R, _>(
             call,
@@ -352,8 +378,10 @@ where
         netuid: u16,
         steepness: u16,
     ) -> EvmResult<()> {
-        let call =
-            pallet_admin_utils::Call::<R>::sudo_set_alpha_sigmoid_steepness { netuid: netuid.into(), steepness };
+        let call = pallet_admin_utils::Call::<R>::sudo_set_alpha_sigmoid_steepness {
+            netuid: netuid.into(),
+            steepness,
+        };
 
         handle.try_dispatch_runtime_call::<R, _>(
             call,
@@ -364,7 +392,9 @@ where
     #[precompile::public("getActivityCutoff(uint16)")]
     #[precompile::view]
     fn get_activity_cutoff(_: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<u16> {
-        Ok(pallet_subtensor::ActivityCutoff::<R>::get(NetUid::from(netuid)))
+        Ok(pallet_subtensor::ActivityCutoff::<R>::get(NetUid::from(
+            netuid,
+        )))
     }
 
     #[precompile::public("setActivityCutoff(uint16,uint16)")]
@@ -490,7 +520,10 @@ where
         netuid: u16,
         difficulty: u64,
     ) -> EvmResult<()> {
-        let call = pallet_admin_utils::Call::<R>::sudo_set_difficulty { netuid: netuid.into(), difficulty };
+        let call = pallet_admin_utils::Call::<R>::sudo_set_difficulty {
+            netuid: netuid.into(),
+            difficulty,
+        };
 
         handle.try_dispatch_runtime_call::<R, _>(
             call,
@@ -501,7 +534,9 @@ where
     #[precompile::public("getBondsMovingAverage(uint16)")]
     #[precompile::view]
     fn get_bonds_moving_average(_: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<u64> {
-        Ok(pallet_subtensor::BondsMovingAverage::<R>::get(NetUid::from(netuid)))
+        Ok(pallet_subtensor::BondsMovingAverage::<R>::get(
+            NetUid::from(netuid),
+        ))
     }
 
     #[precompile::public("setBondsMovingAverage(uint16,uint64)")]
@@ -554,7 +589,9 @@ where
     #[precompile::public("getLiquidAlphaEnabled(uint16)")]
     #[precompile::view]
     fn get_liquid_alpha_enabled(_: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<bool> {
-        Ok(pallet_subtensor::LiquidAlphaOn::<R>::get(NetUid::from(netuid)))
+        Ok(pallet_subtensor::LiquidAlphaOn::<R>::get(NetUid::from(
+            netuid,
+        )))
     }
 
     #[precompile::public("setLiquidAlphaEnabled(uint16,bool)")]
@@ -564,7 +601,10 @@ where
         netuid: u16,
         enabled: bool,
     ) -> EvmResult<()> {
-        let call = pallet_admin_utils::Call::<R>::sudo_set_liquid_alpha_enabled { netuid: netuid.into(), enabled };
+        let call = pallet_admin_utils::Call::<R>::sudo_set_liquid_alpha_enabled {
+            netuid: netuid.into(),
+            enabled,
+        };
 
         handle.try_dispatch_runtime_call::<R, _>(
             call,
@@ -585,7 +625,10 @@ where
         netuid: u16,
         enabled: bool,
     ) -> EvmResult<()> {
-        let call = pallet_admin_utils::Call::<R>::sudo_set_yuma3_enabled { netuid: netuid.into(), enabled };
+        let call = pallet_admin_utils::Call::<R>::sudo_set_yuma3_enabled {
+            netuid: netuid.into(),
+            enabled,
+        };
 
         handle.try_dispatch_runtime_call::<R, _>(
             call,
@@ -596,7 +639,9 @@ where
     #[precompile::public("getAlphaValues(uint16)")]
     #[precompile::view]
     fn get_alpha_values(_: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<(u16, u16)> {
-        Ok(pallet_subtensor::AlphaValues::<R>::get(NetUid::from(netuid)))
+        Ok(pallet_subtensor::AlphaValues::<R>::get(NetUid::from(
+            netuid,
+        )))
     }
 
     #[precompile::public("setAlphaValues(uint16,uint16,uint16)")]
@@ -625,7 +670,9 @@ where
         _: &mut impl PrecompileHandle,
         netuid: u16,
     ) -> EvmResult<u64> {
-        Ok(pallet_subtensor::RevealPeriodEpochs::<R>::get(NetUid::from(netuid)))
+        Ok(pallet_subtensor::RevealPeriodEpochs::<R>::get(
+            NetUid::from(netuid),
+        ))
     }
 
     #[precompile::public("setCommitRevealWeightsInterval(uint16,uint64)")]
@@ -653,7 +700,10 @@ where
         netuid: u16,
         toggle: bool,
     ) -> EvmResult<()> {
-        let call = pallet_admin_utils::Call::<R>::sudo_set_toggle_transfer { netuid: netuid.into(), toggle };
+        let call = pallet_admin_utils::Call::<R>::sudo_set_toggle_transfer {
+            netuid: netuid.into(),
+            toggle,
+        };
 
         handle.try_dispatch_runtime_call::<R, _>(
             call,

From 0906bdb02ea7522f5adfe1a8aa0ba3489229c7a7 Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Tue, 10 Jun 2025 15:55:21 +0200
Subject: [PATCH 280/418] bump frontier hash to master

---
 Cargo.lock | 52 ++++++++++++++++++++++++++--------------------------
 Cargo.toml | 50 +++++++++++++++++++++++++-------------------------
 2 files changed, 51 insertions(+), 51 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 1c122c8c15..049d7c747f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2861,7 +2861,7 @@ dependencies = [
 [[package]]
 name = "fc-api"
 version = "1.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
+source = "git+https://github.com/opentensor/frontier?rev=4aeb35e5ce815a2d4998a349d47e773190a3396c#4aeb35e5ce815a2d4998a349d47e773190a3396c"
 dependencies = [
  "async-trait",
  "fp-storage",
@@ -2873,7 +2873,7 @@ dependencies = [
 [[package]]
 name = "fc-aura"
 version = "1.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
+source = "git+https://github.com/opentensor/frontier?rev=4aeb35e5ce815a2d4998a349d47e773190a3396c#4aeb35e5ce815a2d4998a349d47e773190a3396c"
 dependencies = [
  "fc-rpc",
  "fp-storage",
@@ -2889,7 +2889,7 @@ dependencies = [
 [[package]]
 name = "fc-consensus"
 version = "2.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
+source = "git+https://github.com/opentensor/frontier?rev=4aeb35e5ce815a2d4998a349d47e773190a3396c#4aeb35e5ce815a2d4998a349d47e773190a3396c"
 dependencies = [
  "async-trait",
  "fp-consensus",
@@ -2905,7 +2905,7 @@ dependencies = [
 [[package]]
 name = "fc-db"
 version = "2.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
+source = "git+https://github.com/opentensor/frontier?rev=4aeb35e5ce815a2d4998a349d47e773190a3396c#4aeb35e5ce815a2d4998a349d47e773190a3396c"
 dependencies = [
  "async-trait",
  "ethereum",
@@ -2935,7 +2935,7 @@ dependencies = [
 [[package]]
 name = "fc-mapping-sync"
 version = "2.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
+source = "git+https://github.com/opentensor/frontier?rev=4aeb35e5ce815a2d4998a349d47e773190a3396c#4aeb35e5ce815a2d4998a349d47e773190a3396c"
 dependencies = [
  "fc-db",
  "fc-storage",
@@ -2958,7 +2958,7 @@ dependencies = [
 [[package]]
 name = "fc-rpc"
 version = "2.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
+source = "git+https://github.com/opentensor/frontier?rev=4aeb35e5ce815a2d4998a349d47e773190a3396c#4aeb35e5ce815a2d4998a349d47e773190a3396c"
 dependencies = [
  "ethereum",
  "ethereum-types 0.15.1",
@@ -3009,7 +3009,7 @@ dependencies = [
 [[package]]
 name = "fc-rpc-core"
 version = "1.1.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
+source = "git+https://github.com/opentensor/frontier?rev=4aeb35e5ce815a2d4998a349d47e773190a3396c#4aeb35e5ce815a2d4998a349d47e773190a3396c"
 dependencies = [
  "ethereum",
  "ethereum-types 0.15.1",
@@ -3024,7 +3024,7 @@ dependencies = [
 [[package]]
 name = "fc-storage"
 version = "1.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
+source = "git+https://github.com/opentensor/frontier?rev=4aeb35e5ce815a2d4998a349d47e773190a3396c#4aeb35e5ce815a2d4998a349d47e773190a3396c"
 dependencies = [
  "ethereum",
  "ethereum-types 0.15.1",
@@ -3217,7 +3217,7 @@ dependencies = [
 [[package]]
 name = "fp-account"
 version = "1.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
+source = "git+https://github.com/opentensor/frontier?rev=4aeb35e5ce815a2d4998a349d47e773190a3396c#4aeb35e5ce815a2d4998a349d47e773190a3396c"
 dependencies = [
  "hex",
  "impl-serde 0.5.0",
@@ -3236,7 +3236,7 @@ dependencies = [
 [[package]]
 name = "fp-consensus"
 version = "2.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
+source = "git+https://github.com/opentensor/frontier?rev=4aeb35e5ce815a2d4998a349d47e773190a3396c#4aeb35e5ce815a2d4998a349d47e773190a3396c"
 dependencies = [
  "ethereum",
  "parity-scale-codec",
@@ -3247,7 +3247,7 @@ dependencies = [
 [[package]]
 name = "fp-ethereum"
 version = "1.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
+source = "git+https://github.com/opentensor/frontier?rev=4aeb35e5ce815a2d4998a349d47e773190a3396c#4aeb35e5ce815a2d4998a349d47e773190a3396c"
 dependencies = [
  "ethereum",
  "ethereum-types 0.15.1",
@@ -3259,7 +3259,7 @@ dependencies = [
 [[package]]
 name = "fp-evm"
 version = "3.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
+source = "git+https://github.com/opentensor/frontier?rev=4aeb35e5ce815a2d4998a349d47e773190a3396c#4aeb35e5ce815a2d4998a349d47e773190a3396c"
 dependencies = [
  "environmental",
  "evm",
@@ -3275,7 +3275,7 @@ dependencies = [
 [[package]]
 name = "fp-rpc"
 version = "3.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
+source = "git+https://github.com/opentensor/frontier?rev=4aeb35e5ce815a2d4998a349d47e773190a3396c#4aeb35e5ce815a2d4998a349d47e773190a3396c"
 dependencies = [
  "ethereum",
  "ethereum-types 0.15.1",
@@ -3291,7 +3291,7 @@ dependencies = [
 [[package]]
 name = "fp-self-contained"
 version = "1.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
+source = "git+https://github.com/opentensor/frontier?rev=4aeb35e5ce815a2d4998a349d47e773190a3396c#4aeb35e5ce815a2d4998a349d47e773190a3396c"
 dependencies = [
  "frame-support",
  "parity-scale-codec",
@@ -3303,7 +3303,7 @@ dependencies = [
 [[package]]
 name = "fp-storage"
 version = "2.0.0"
-source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
+source = "git+https://github.com/opentensor/frontier?rev=4aeb35e5ce815a2d4998a349d47e773190a3396c#4aeb35e5ce815a2d4998a349d47e773190a3396c"
 dependencies = [
  "parity-scale-codec",
  "serde",
@@ -7055,7 +7055,7 @@ dependencies = [
 [[package]]
 name = "pallet-base-fee"
 version = "1.0.0"
-source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
+source = "git+https://github.com/opentensor/frontier?rev=4aeb35e5ce815a2d4998a349d47e773190a3396c#4aeb35e5ce815a2d4998a349d47e773190a3396c"
 dependencies = [
  "fp-evm",
  "frame-support",
@@ -7165,7 +7165,7 @@ dependencies = [
 [[package]]
 name = "pallet-ethereum"
 version = "4.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
+source = "git+https://github.com/opentensor/frontier?rev=4aeb35e5ce815a2d4998a349d47e773190a3396c#4aeb35e5ce815a2d4998a349d47e773190a3396c"
 dependencies = [
  "ethereum",
  "ethereum-types 0.15.1",
@@ -7188,7 +7188,7 @@ dependencies = [
 [[package]]
 name = "pallet-evm"
 version = "6.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
+source = "git+https://github.com/opentensor/frontier?rev=4aeb35e5ce815a2d4998a349d47e773190a3396c#4aeb35e5ce815a2d4998a349d47e773190a3396c"
 dependencies = [
  "cumulus-primitives-storage-weight-reclaim",
  "environmental",
@@ -7212,7 +7212,7 @@ dependencies = [
 [[package]]
 name = "pallet-evm-chain-id"
 version = "1.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
+source = "git+https://github.com/opentensor/frontier?rev=4aeb35e5ce815a2d4998a349d47e773190a3396c#4aeb35e5ce815a2d4998a349d47e773190a3396c"
 dependencies = [
  "frame-support",
  "frame-system",
@@ -7223,7 +7223,7 @@ dependencies = [
 [[package]]
 name = "pallet-evm-precompile-dispatch"
 version = "2.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=cd6bca14a3#cd6bca14a366cc7cb1c3b1b1d7bc8213667e4126"
+source = "git+https://github.com/opentensor/frontier?rev=4aeb35e5ce815a2d4998a349d47e773190a3396c#4aeb35e5ce815a2d4998a349d47e773190a3396c"
 dependencies = [
  "fp-evm",
  "frame-support",
@@ -7235,7 +7235,7 @@ dependencies = [
 [[package]]
 name = "pallet-evm-precompile-modexp"
 version = "2.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
+source = "git+https://github.com/opentensor/frontier?rev=4aeb35e5ce815a2d4998a349d47e773190a3396c#4aeb35e5ce815a2d4998a349d47e773190a3396c"
 dependencies = [
  "fp-evm",
  "num",
@@ -7244,7 +7244,7 @@ dependencies = [
 [[package]]
 name = "pallet-evm-precompile-sha3fips"
 version = "2.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
+source = "git+https://github.com/opentensor/frontier?rev=4aeb35e5ce815a2d4998a349d47e773190a3396c#4aeb35e5ce815a2d4998a349d47e773190a3396c"
 dependencies = [
  "fp-evm",
  "tiny-keccak",
@@ -7253,7 +7253,7 @@ dependencies = [
 [[package]]
 name = "pallet-evm-precompile-simple"
 version = "2.0.0-dev"
-source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
+source = "git+https://github.com/opentensor/frontier?rev=4aeb35e5ce815a2d4998a349d47e773190a3396c#4aeb35e5ce815a2d4998a349d47e773190a3396c"
 dependencies = [
  "fp-evm",
  "ripemd",
@@ -7285,7 +7285,7 @@ dependencies = [
 [[package]]
 name = "pallet-hotfix-sufficients"
 version = "1.0.0"
-source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
+source = "git+https://github.com/opentensor/frontier?rev=4aeb35e5ce815a2d4998a349d47e773190a3396c#4aeb35e5ce815a2d4998a349d47e773190a3396c"
 dependencies = [
  "frame-benchmarking",
  "frame-support",
@@ -8323,7 +8323,7 @@ dependencies = [
 [[package]]
 name = "precompile-utils"
 version = "0.1.0"
-source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
+source = "git+https://github.com/opentensor/frontier?rev=4aeb35e5ce815a2d4998a349d47e773190a3396c#4aeb35e5ce815a2d4998a349d47e773190a3396c"
 dependencies = [
  "environmental",
  "evm",
@@ -8347,7 +8347,7 @@ dependencies = [
 [[package]]
 name = "precompile-utils-macro"
 version = "0.1.0"
-source = "git+https://github.com/opentensor/frontier?rev=2dec35b654c077d076350a39d3f063dd9b838518#2dec35b654c077d076350a39d3f063dd9b838518"
+source = "git+https://github.com/opentensor/frontier?rev=4aeb35e5ce815a2d4998a349d47e773190a3396c#4aeb35e5ce815a2d4998a349d47e773190a3396c"
 dependencies = [
  "case",
  "num_enum",
diff --git a/Cargo.toml b/Cargo.toml
index 83286e51a3..10f3d4b0b9 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -184,37 +184,37 @@ sc-network-sync = { git = "https://github.com/paritytech/polkadot-sdk.git", tag
 substrate-prometheus-endpoint = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", default-features = false }
 
 # Frontier
-fp-evm = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
-fp-rpc = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
-fp-self-contained = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false, features = [
+fp-evm = { git = "https://github.com/opentensor/frontier", rev = "4aeb35e5ce815a2d4998a349d47e773190a3396c", default-features = false }
+fp-rpc = { git = "https://github.com/opentensor/frontier", rev = "4aeb35e5ce815a2d4998a349d47e773190a3396c", default-features = false }
+fp-self-contained = { git = "https://github.com/opentensor/frontier", rev = "4aeb35e5ce815a2d4998a349d47e773190a3396c", default-features = false, features = [
 	"serde",
 ] }
-fp-account = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
-fc-storage = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
-fc-db = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
-fc-consensus = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
-fp-consensus = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
-fp-dynamic-fee = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
-fc-api = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
-fc-rpc = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false, features = [
+fp-account = { git = "https://github.com/opentensor/frontier", rev = "4aeb35e5ce815a2d4998a349d47e773190a3396c", default-features = false }
+fc-storage = { git = "https://github.com/opentensor/frontier", rev = "4aeb35e5ce815a2d4998a349d47e773190a3396c", default-features = false }
+fc-db = { git = "https://github.com/opentensor/frontier", rev = "4aeb35e5ce815a2d4998a349d47e773190a3396c", default-features = false }
+fc-consensus = { git = "https://github.com/opentensor/frontier", rev = "4aeb35e5ce815a2d4998a349d47e773190a3396c", default-features = false }
+fp-consensus = { git = "https://github.com/opentensor/frontier", rev = "4aeb35e5ce815a2d4998a349d47e773190a3396c", default-features = false }
+fp-dynamic-fee = { git = "https://github.com/opentensor/frontier", rev = "4aeb35e5ce815a2d4998a349d47e773190a3396c", default-features = false }
+fc-api = { git = "https://github.com/opentensor/frontier", rev = "4aeb35e5ce815a2d4998a349d47e773190a3396c", default-features = false }
+fc-rpc = { git = "https://github.com/opentensor/frontier", rev = "4aeb35e5ce815a2d4998a349d47e773190a3396c", default-features = false, features = [
 	"rpc-binary-search-estimate",
 ] }
-fc-rpc-core = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
-fc-aura = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
-fc-mapping-sync = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
-precompile-utils = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
+fc-rpc-core = { git = "https://github.com/opentensor/frontier", rev = "4aeb35e5ce815a2d4998a349d47e773190a3396c", default-features = false }
+fc-aura = { git = "https://github.com/opentensor/frontier", rev = "4aeb35e5ce815a2d4998a349d47e773190a3396c", default-features = false }
+fc-mapping-sync = { git = "https://github.com/opentensor/frontier", rev = "4aeb35e5ce815a2d4998a349d47e773190a3396c", default-features = false }
+precompile-utils = { git = "https://github.com/opentensor/frontier", rev = "4aeb35e5ce815a2d4998a349d47e773190a3396c", default-features = false }
 
 # Frontier FRAME
-pallet-base-fee = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
-pallet-dynamic-fee = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
-pallet-ethereum = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
-pallet-evm = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
-pallet-evm-precompile-dispatch = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
-pallet-evm-chain-id = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
-pallet-evm-precompile-modexp = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
-pallet-evm-precompile-sha3fips = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
-pallet-evm-precompile-simple = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
-pallet-hotfix-sufficients = { git = "https://github.com/opentensor/frontier", rev = "2dec35b654c077d076350a39d3f063dd9b838518", default-features = false }
+pallet-base-fee = { git = "https://github.com/opentensor/frontier", rev = "4aeb35e5ce815a2d4998a349d47e773190a3396c", default-features = false }
+pallet-dynamic-fee = { git = "https://github.com/opentensor/frontier", rev = "4aeb35e5ce815a2d4998a349d47e773190a3396c", default-features = false }
+pallet-ethereum = { git = "https://github.com/opentensor/frontier", rev = "4aeb35e5ce815a2d4998a349d47e773190a3396c", default-features = false }
+pallet-evm = { git = "https://github.com/opentensor/frontier", rev = "4aeb35e5ce815a2d4998a349d47e773190a3396c", default-features = false }
+pallet-evm-precompile-dispatch = { git = "https://github.com/opentensor/frontier", rev = "4aeb35e5ce815a2d4998a349d47e773190a3396c", default-features = false }
+pallet-evm-chain-id = { git = "https://github.com/opentensor/frontier", rev = "4aeb35e5ce815a2d4998a349d47e773190a3396c", default-features = false }
+pallet-evm-precompile-modexp = { git = "https://github.com/opentensor/frontier", rev = "4aeb35e5ce815a2d4998a349d47e773190a3396c", default-features = false }
+pallet-evm-precompile-sha3fips = { git = "https://github.com/opentensor/frontier", rev = "4aeb35e5ce815a2d4998a349d47e773190a3396c", default-features = false }
+pallet-evm-precompile-simple = { git = "https://github.com/opentensor/frontier", rev = "4aeb35e5ce815a2d4998a349d47e773190a3396c", default-features = false }
+pallet-hotfix-sufficients = { git = "https://github.com/opentensor/frontier", rev = "4aeb35e5ce815a2d4998a349d47e773190a3396c", default-features = false }
 
 #DRAND
 pallet-drand = { path = "pallets/drand", default-features = false }

From c277b5cb33b8759f5938e7a9ad2b743ca89e6e1f Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Tue, 10 Jun 2025 23:17:04 +0800
Subject: [PATCH 281/418] fix compilation

---
 precompiles/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/precompiles/src/lib.rs b/precompiles/src/lib.rs
index 89902ec9ee..3e2b874012 100644
--- a/precompiles/src/lib.rs
+++ b/precompiles/src/lib.rs
@@ -130,7 +130,7 @@ where
         + Dispatchable<PostInfo = PostDispatchInfo>
         + Decode,
     <<R as frame_system::Config>::RuntimeCall as Dispatchable>::RuntimeOrigin:
-        From<Option<R::AccountId>>,
+        From<Option<pallet_evm::AccountIdOf<R>>>,
     <R as pallet_evm::Config>::AddressMapping: AddressMapping<R::AccountId>,
     <R as pallet_balances::Config>::Balance: TryFrom<U256>,
     <<R as frame_system::Config>::Lookup as StaticLookup>::Source: From<R::AccountId>,

From c9a3be00ca48b20b2102167363a0840877f30d8d Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Tue, 10 Jun 2025 17:52:00 +0200
Subject: [PATCH 282/418] Fix netuid in rpc

---
 Cargo.lock                               |  3 ++
 common/Cargo.toml                        |  2 +
 common/src/lib.rs                        |  7 ++-
 pallets/subtensor/rpc/Cargo.toml         |  9 ++--
 pallets/subtensor/rpc/src/lib.rs         | 54 ++++++++++++++----------
 pallets/subtensor/runtime-api/Cargo.toml |  8 ++--
 pallets/subtensor/runtime-api/src/lib.rs | 29 +++++++------
 runtime/src/lib.rs                       | 38 ++++++++---------
 runtime/tests/pallet_proxy.rs            | 10 ++---
 9 files changed, 91 insertions(+), 69 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 6ac93b09c8..9554a702d0 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -11039,6 +11039,7 @@ dependencies = [
  "sp-rpc",
  "sp-runtime",
  "subtensor-custom-rpc-runtime-api",
+ "subtensor-runtime-common",
 ]
 
 [[package]]
@@ -11051,6 +11052,7 @@ dependencies = [
  "serde",
  "sp-api",
  "sp-runtime",
+ "subtensor-runtime-common",
 ]
 
 [[package]]
@@ -11107,6 +11109,7 @@ dependencies = [
  "parity-scale-codec",
  "precompile-utils",
  "scale-info",
+ "serde",
  "sp-core",
  "sp-runtime",
  "subtensor-macros",
diff --git a/common/Cargo.toml b/common/Cargo.toml
index de9ea00a02..acbc72897c 100644
--- a/common/Cargo.toml
+++ b/common/Cargo.toml
@@ -15,6 +15,7 @@ codec = { workspace = true }
 frame-support = { workspace = true }
 precompile-utils = { workspace = true }
 scale-info = { workspace = true }
+serde = { workspace = true }
 sp-core = { workspace = true }
 sp-runtime = { workspace = true }
 subtensor-macros = { workspace = true }
@@ -30,6 +31,7 @@ std = [
 	"frame-support/std",
 	"precompile-utils/std",
 	"scale-info/std",
+	"serde/std",
 	"sp-core/std",
 	"sp-runtime/std",
 ]
diff --git a/common/src/lib.rs b/common/src/lib.rs
index f289977217..1e040ffad5 100644
--- a/common/src/lib.rs
+++ b/common/src/lib.rs
@@ -4,6 +4,7 @@ use core::fmt::{self, Display, Formatter};
 use codec::{Compact, CompactAs, Decode, Encode, Error as CodecError, MaxEncodedLen};
 use frame_support::pallet_prelude::*;
 use scale_info::TypeInfo;
+use serde::{Deserialize, Serialize};
 use sp_runtime::{
     MultiSignature,
     traits::{IdentifyAccount, Verify},
@@ -34,16 +35,18 @@ pub type Nonce = u32;
 /// Transfers below SMALL_TRANSFER_LIMIT are considered small transfers
 pub const SMALL_TRANSFER_LIMIT: Balance = 500_000_000; // 0.5 TAO
 
-#[freeze_struct("3a97f3950116ef68")]
+#[freeze_struct("f1746d0b1911967")]
 #[repr(transparent)]
 #[derive(
-    Hash,
+    Deserialize,
+    Serialize,
     Clone,
     Copy,
     Decode,
     Default,
     Encode,
     Eq,
+    Hash,
     MaxEncodedLen,
     Ord,
     PartialEq,
diff --git a/pallets/subtensor/rpc/Cargo.toml b/pallets/subtensor/rpc/Cargo.toml
index 6a2807268d..47b63b9067 100644
--- a/pallets/subtensor/rpc/Cargo.toml
+++ b/pallets/subtensor/rpc/Cargo.toml
@@ -23,18 +23,19 @@ sp-rpc = { workspace = true }
 sp-runtime = { workspace = true }
 
 # local packages
-
+subtensor-runtime-common = { workspace = true }
 subtensor-custom-rpc-runtime-api = { path = "../runtime-api", default-features = false }
 pallet-subtensor = { path = "../../subtensor", default-features = false }
 
 [features]
 default = ["std"]
 std = [
+	"codec/std",
+	"pallet-subtensor/std",
+	"serde/std",
 	"sp-api/std",
 	"sp-runtime/std",
 	"subtensor-custom-rpc-runtime-api/std",
-	"pallet-subtensor/std",
-	"codec/std",
-	"serde/std"
+	"subtensor-runtime-common/std",
 ]
 pow-faucet = []
diff --git a/pallets/subtensor/rpc/src/lib.rs b/pallets/subtensor/rpc/src/lib.rs
index b3b60206dd..b6512c6055 100644
--- a/pallets/subtensor/rpc/src/lib.rs
+++ b/pallets/subtensor/rpc/src/lib.rs
@@ -9,6 +9,7 @@ use jsonrpsee::{
 use sp_blockchain::HeaderBackend;
 use sp_runtime::{AccountId32, traits::Block as BlockT};
 use std::sync::Arc;
+use subtensor_runtime_common::NetUid;
 
 use sp_api::ProvideRuntimeApi;
 
@@ -35,39 +36,44 @@ pub trait SubtensorCustomApi<BlockHash> {
     ) -> RpcResult<Vec<u8>>;
 
     #[method(name = "neuronInfo_getNeuronsLite")]
-    fn get_neurons_lite(&self, netuid: u16, at: Option<BlockHash>) -> RpcResult<Vec<u8>>;
+    fn get_neurons_lite(&self, netuid: NetUid, at: Option<BlockHash>) -> RpcResult<Vec<u8>>;
     #[method(name = "neuronInfo_getNeuronLite")]
-    fn get_neuron_lite(&self, netuid: u16, uid: u16, at: Option<BlockHash>) -> RpcResult<Vec<u8>>;
+    fn get_neuron_lite(
+        &self,
+        netuid: NetUid,
+        uid: u16,
+        at: Option<BlockHash>,
+    ) -> RpcResult<Vec<u8>>;
     #[method(name = "neuronInfo_getNeurons")]
-    fn get_neurons(&self, netuid: u16, at: Option<BlockHash>) -> RpcResult<Vec<u8>>;
+    fn get_neurons(&self, netuid: NetUid, at: Option<BlockHash>) -> RpcResult<Vec<u8>>;
     #[method(name = "neuronInfo_getNeuron")]
-    fn get_neuron(&self, netuid: u16, uid: u16, at: Option<BlockHash>) -> RpcResult<Vec<u8>>;
+    fn get_neuron(&self, netuid: NetUid, uid: u16, at: Option<BlockHash>) -> RpcResult<Vec<u8>>;
     #[method(name = "subnetInfo_getSubnetInfo")]
-    fn get_subnet_info(&self, netuid: u16, at: Option<BlockHash>) -> RpcResult<Vec<u8>>;
+    fn get_subnet_info(&self, netuid: NetUid, at: Option<BlockHash>) -> RpcResult<Vec<u8>>;
     #[method(name = "subnetInfo_getSubnetsInfo")]
     fn get_subnets_info(&self, at: Option<BlockHash>) -> RpcResult<Vec<u8>>;
     #[method(name = "subnetInfo_getSubnetInfo_v2")]
-    fn get_subnet_info_v2(&self, netuid: u16, at: Option<BlockHash>) -> RpcResult<Vec<u8>>;
+    fn get_subnet_info_v2(&self, netuid: NetUid, at: Option<BlockHash>) -> RpcResult<Vec<u8>>;
     #[method(name = "subnetInfo_getSubnetsInf_v2")]
     fn get_subnets_info_v2(&self, at: Option<BlockHash>) -> RpcResult<Vec<u8>>;
     #[method(name = "subnetInfo_getSubnetHyperparams")]
-    fn get_subnet_hyperparams(&self, netuid: u16, at: Option<BlockHash>) -> RpcResult<Vec<u8>>;
+    fn get_subnet_hyperparams(&self, netuid: NetUid, at: Option<BlockHash>) -> RpcResult<Vec<u8>>;
     #[method(name = "subnetInfo_getAllDynamicInfo")]
     fn get_all_dynamic_info(&self, at: Option<BlockHash>) -> RpcResult<Vec<u8>>;
     #[method(name = "subnetInfo_getDynamicInfo")]
-    fn get_dynamic_info(&self, netuid: u16, at: Option<BlockHash>) -> RpcResult<Vec<u8>>;
+    fn get_dynamic_info(&self, netuid: NetUid, at: Option<BlockHash>) -> RpcResult<Vec<u8>>;
     #[method(name = "subnetInfo_getAllMetagraphs")]
     fn get_all_metagraphs(&self, at: Option<BlockHash>) -> RpcResult<Vec<u8>>;
     #[method(name = "subnetInfo_getMetagraph")]
-    fn get_metagraph(&self, netuid: u16, at: Option<BlockHash>) -> RpcResult<Vec<u8>>;
+    fn get_metagraph(&self, netuid: NetUid, at: Option<BlockHash>) -> RpcResult<Vec<u8>>;
     #[method(name = "subnetInfo_getSubnetState")]
-    fn get_subnet_state(&self, netuid: u16, at: Option<BlockHash>) -> RpcResult<Vec<u8>>;
+    fn get_subnet_state(&self, netuid: NetUid, at: Option<BlockHash>) -> RpcResult<Vec<u8>>;
     #[method(name = "subnetInfo_getLockCost")]
     fn get_network_lock_cost(&self, at: Option<BlockHash>) -> RpcResult<u64>;
     #[method(name = "subnetInfo_getSelectiveMetagraph")]
     fn get_selective_metagraph(
         &self,
-        netuid: u16,
+        netuid: NetUid,
         metagraph_index: Vec<u16>,
         at: Option<BlockHash>,
     ) -> RpcResult<Vec<u8>>;
@@ -182,7 +188,7 @@ where
 
     fn get_neurons_lite(
         &self,
-        netuid: u16,
+        netuid: NetUid,
         at: Option<<Block as BlockT>::Hash>,
     ) -> RpcResult<Vec<u8>> {
         let api = self.client.runtime_api();
@@ -198,7 +204,7 @@ where
 
     fn get_neuron_lite(
         &self,
-        netuid: u16,
+        netuid: NetUid,
         uid: u16,
         at: Option<<Block as BlockT>::Hash>,
     ) -> RpcResult<Vec<u8>> {
@@ -213,7 +219,11 @@ where
         }
     }
 
-    fn get_neurons(&self, netuid: u16, at: Option<<Block as BlockT>::Hash>) -> RpcResult<Vec<u8>> {
+    fn get_neurons(
+        &self,
+        netuid: NetUid,
+        at: Option<<Block as BlockT>::Hash>,
+    ) -> RpcResult<Vec<u8>> {
         let api = self.client.runtime_api();
         let at = at.unwrap_or_else(|| self.client.info().best_hash);
 
@@ -227,7 +237,7 @@ where
 
     fn get_neuron(
         &self,
-        netuid: u16,
+        netuid: NetUid,
         uid: u16,
         at: Option<<Block as BlockT>::Hash>,
     ) -> RpcResult<Vec<u8>> {
@@ -244,7 +254,7 @@ where
 
     fn get_subnet_info(
         &self,
-        netuid: u16,
+        netuid: NetUid,
         at: Option<<Block as BlockT>::Hash>,
     ) -> RpcResult<Vec<u8>> {
         let api = self.client.runtime_api();
@@ -260,7 +270,7 @@ where
 
     fn get_subnet_hyperparams(
         &self,
-        netuid: u16,
+        netuid: NetUid,
         at: Option<<Block as BlockT>::Hash>,
     ) -> RpcResult<Vec<u8>> {
         let api = self.client.runtime_api();
@@ -300,7 +310,7 @@ where
 
     fn get_dynamic_info(
         &self,
-        netuid: u16,
+        netuid: NetUid,
         at: Option<<Block as BlockT>::Hash>,
     ) -> RpcResult<Vec<u8>> {
         let api = self.client.runtime_api();
@@ -318,7 +328,7 @@ where
 
     fn get_metagraph(
         &self,
-        netuid: u16,
+        netuid: NetUid,
         at: Option<<Block as BlockT>::Hash>,
     ) -> RpcResult<Vec<u8>> {
         let api = self.client.runtime_api();
@@ -335,7 +345,7 @@ where
 
     fn get_subnet_state(
         &self,
-        netuid: u16,
+        netuid: NetUid,
         at: Option<<Block as BlockT>::Hash>,
     ) -> RpcResult<Vec<u8>> {
         let api = self.client.runtime_api();
@@ -363,7 +373,7 @@ where
 
     fn get_subnet_info_v2(
         &self,
-        netuid: u16,
+        netuid: NetUid,
         at: Option<<Block as BlockT>::Hash>,
     ) -> RpcResult<Vec<u8>> {
         let api = self.client.runtime_api();
@@ -400,7 +410,7 @@ where
 
     fn get_selective_metagraph(
         &self,
-        netuid: u16,
+        netuid: NetUid,
         metagraph_index: Vec<u16>,
         at: Option<<Block as BlockT>::Hash>,
     ) -> RpcResult<Vec<u8>> {
diff --git a/pallets/subtensor/runtime-api/Cargo.toml b/pallets/subtensor/runtime-api/Cargo.toml
index 0812d076d3..1a95b75d16 100644
--- a/pallets/subtensor/runtime-api/Cargo.toml
+++ b/pallets/subtensor/runtime-api/Cargo.toml
@@ -17,17 +17,19 @@ sp-runtime = { workspace = true }
 frame-support = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 codec = { workspace = true }
+subtensor-runtime-common = { workspace = true }
 # local
 pallet-subtensor = { version = "4.0.0-dev", path = "../../subtensor", default-features = false }
 
 [features]
 default = ["std"]
 std = [
-	"sp-api/std",
-	"sp-runtime/std",
+	"codec/std",
 	"frame-support/std",
 	"pallet-subtensor/std",
 	"serde/std",
-	"codec/std"
+	"sp-api/std",
+	"sp-runtime/std",
+	"subtensor-runtime-common/std",
 ]
 pow-faucet = []
diff --git a/pallets/subtensor/runtime-api/src/lib.rs b/pallets/subtensor/runtime-api/src/lib.rs
index 1a2f34aa9e..ac2de7e9d9 100644
--- a/pallets/subtensor/runtime-api/src/lib.rs
+++ b/pallets/subtensor/runtime-api/src/lib.rs
@@ -12,6 +12,7 @@ use pallet_subtensor::rpc_info::{
     subnet_info::{SubnetHyperparams, SubnetInfo, SubnetInfov2},
 };
 use sp_runtime::AccountId32;
+use subtensor_runtime_common::NetUid;
 
 // Here we declare the runtime API. It is implemented it the `impl` block in
 // src/neuron_info.rs, src/subnet_info.rs, and src/delegate_info.rs
@@ -19,35 +20,35 @@ sp_api::decl_runtime_apis! {
     pub trait DelegateInfoRuntimeApi {
         fn get_delegates() -> Vec<DelegateInfo<AccountId32>>;
         fn get_delegate( delegate_account: AccountId32 ) -> Option<DelegateInfo<AccountId32>>;
-        fn get_delegated( delegatee_account: AccountId32 ) -> Vec<(DelegateInfo<AccountId32>, (Compact<u16>, Compact<u64>))>;
+        fn get_delegated( delegatee_account: AccountId32 ) -> Vec<(DelegateInfo<AccountId32>, (Compact<NetUid>, Compact<u64>))>;
     }
 
     pub trait NeuronInfoRuntimeApi {
-        fn get_neurons(netuid: u16) -> Vec<NeuronInfo<AccountId32>>;
-        fn get_neuron(netuid: u16, uid: u16) -> Option<NeuronInfo<AccountId32>>;
-        fn get_neurons_lite(netuid: u16) -> Vec<NeuronInfoLite<AccountId32>>;
-        fn get_neuron_lite(netuid: u16, uid: u16) -> Option<NeuronInfoLite<AccountId32>>;
+        fn get_neurons(netuid: NetUid) -> Vec<NeuronInfo<AccountId32>>;
+        fn get_neuron(netuid: NetUid, uid: u16) -> Option<NeuronInfo<AccountId32>>;
+        fn get_neurons_lite(netuid: NetUid) -> Vec<NeuronInfoLite<AccountId32>>;
+        fn get_neuron_lite(netuid: NetUid, uid: u16) -> Option<NeuronInfoLite<AccountId32>>;
     }
 
     pub trait SubnetInfoRuntimeApi {
-        fn get_subnet_info(netuid: u16) -> Option<SubnetInfo<AccountId32>>;
+        fn get_subnet_info(netuid: NetUid) -> Option<SubnetInfo<AccountId32>>;
         fn get_subnets_info() -> Vec<Option<SubnetInfo<AccountId32>>>;
-        fn get_subnet_info_v2(netuid: u16) -> Option<SubnetInfov2<AccountId32>>;
+        fn get_subnet_info_v2(netuid: NetUid) -> Option<SubnetInfov2<AccountId32>>;
         fn get_subnets_info_v2() -> Vec<Option<SubnetInfov2<AccountId32>>>;
-        fn get_subnet_hyperparams(netuid: u16) -> Option<SubnetHyperparams>;
+        fn get_subnet_hyperparams(netuid: NetUid) -> Option<SubnetHyperparams>;
         fn get_all_dynamic_info() -> Vec<Option<DynamicInfo<AccountId32>>>;
         fn get_all_metagraphs() -> Vec<Option<Metagraph<AccountId32>>>;
-        fn get_metagraph(netuid: u16) -> Option<Metagraph<AccountId32>>;
-        fn get_dynamic_info(netuid: u16) -> Option<DynamicInfo<AccountId32>>;
-        fn get_subnet_state(netuid: u16) -> Option<SubnetState<AccountId32>>;
-        fn get_selective_metagraph(netuid: u16, metagraph_indexes: Vec<u16>) -> Option<SelectiveMetagraph<AccountId32>>;
+        fn get_metagraph(netuid: NetUid) -> Option<Metagraph<AccountId32>>;
+        fn get_dynamic_info(netuid: NetUid) -> Option<DynamicInfo<AccountId32>>;
+        fn get_subnet_state(netuid: NetUid) -> Option<SubnetState<AccountId32>>;
+        fn get_selective_metagraph(netuid: NetUid, metagraph_indexes: Vec<u16>) -> Option<SelectiveMetagraph<AccountId32>>;
     }
 
     pub trait StakeInfoRuntimeApi {
         fn get_stake_info_for_coldkey( coldkey_account: AccountId32 ) -> Vec<StakeInfo<AccountId32>>;
         fn get_stake_info_for_coldkeys( coldkey_accounts: Vec<AccountId32> ) -> Vec<(AccountId32, Vec<StakeInfo<AccountId32>>)>;
-        fn get_stake_info_for_hotkey_coldkey_netuid( hotkey_account: AccountId32, coldkey_account: AccountId32, netuid: u16 ) -> Option<StakeInfo<AccountId32>>;
-        fn get_stake_fee( origin: Option<(AccountId32, u16)>, origin_coldkey_account: AccountId32, destination: Option<(AccountId32, u16)>, destination_coldkey_account: AccountId32, amount: u64 ) -> u64;
+        fn get_stake_info_for_hotkey_coldkey_netuid( hotkey_account: AccountId32, coldkey_account: AccountId32, netuid: NetUid ) -> Option<StakeInfo<AccountId32>>;
+        fn get_stake_fee( origin: Option<(AccountId32, NetUid)>, origin_coldkey_account: AccountId32, destination: Option<(AccountId32, NetUid)>, destination_coldkey_account: AccountId32, amount: u64 ) -> u64;
     }
 
     pub trait SubnetRegistrationRuntimeApi {
diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index e55f6db4cf..299bed5d8c 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -943,7 +943,7 @@ impl CanRegisterIdentity<AccountId> for AllowIdentityReg {
     fn can_register(address: &AccountId, identified: &AccountId) -> bool {
         if address != identified {
             SubtensorModule::coldkey_owns_hotkey(address, identified)
-                && SubtensorModule::is_hotkey_registered_on_network(0, identified)
+                && SubtensorModule::is_hotkey_registered_on_network(NetUid::ROOT, identified)
         } else {
             SubtensorModule::is_subnet_owner(address)
         }
@@ -993,12 +993,12 @@ impl Get<u32> for MaxCommitFields {
 pub struct AllowCommitments;
 impl CanCommit<AccountId> for AllowCommitments {
     #[cfg(not(feature = "runtime-benchmarks"))]
-    fn can_commit(netuid: u16, address: &AccountId) -> bool {
+    fn can_commit(netuid: NetUid, address: &AccountId) -> bool {
         SubtensorModule::is_hotkey_registered_on_network(netuid, address)
     }
 
     #[cfg(feature = "runtime-benchmarks")]
-    fn can_commit(_: u16, _: &AccountId) -> bool {
+    fn can_commit(_: NetUid, _: &AccountId) -> bool {
         true
     }
 }
@@ -1006,12 +1006,12 @@ impl CanCommit<AccountId> for AllowCommitments {
 pub struct ResetBondsOnCommit;
 impl OnMetadataCommitment<AccountId> for ResetBondsOnCommit {
     #[cfg(not(feature = "runtime-benchmarks"))]
-    fn on_metadata_commitment(netuid: u16, address: &AccountId) {
+    fn on_metadata_commitment(netuid: NetUid, address: &AccountId) {
         let _ = SubtensorModule::do_reset_bonds(netuid, address);
     }
 
     #[cfg(feature = "runtime-benchmarks")]
-    fn on_metadata_commitment(_: u16, _: &AccountId) {}
+    fn on_metadata_commitment(_: NetUid, _: &AccountId) {}
 }
 
 impl pallet_commitments::Config for Runtime {
@@ -2190,31 +2190,31 @@ impl_runtime_apis! {
             SubtensorModule::get_delegate(delegate_account)
         }
 
-        fn get_delegated(delegatee_account: AccountId32) -> Vec<(DelegateInfo<AccountId32>, (Compact<u16>, Compact<u64>))> {
+        fn get_delegated(delegatee_account: AccountId32) -> Vec<(DelegateInfo<AccountId32>, (Compact<NetUid>, Compact<u64>))> {
             SubtensorModule::get_delegated(delegatee_account)
         }
     }
 
     impl subtensor_custom_rpc_runtime_api::NeuronInfoRuntimeApi<Block> for Runtime {
-        fn get_neurons_lite(netuid: u16) -> Vec<NeuronInfoLite<AccountId32>> {
+        fn get_neurons_lite(netuid: NetUid) -> Vec<NeuronInfoLite<AccountId32>> {
             SubtensorModule::get_neurons_lite(netuid)
         }
 
-        fn get_neuron_lite(netuid: u16, uid: u16) -> Option<NeuronInfoLite<AccountId32>> {
+        fn get_neuron_lite(netuid: NetUid, uid: u16) -> Option<NeuronInfoLite<AccountId32>> {
             SubtensorModule::get_neuron_lite(netuid, uid)
         }
 
-        fn get_neurons(netuid: u16) -> Vec<NeuronInfo<AccountId32>> {
+        fn get_neurons(netuid: NetUid) -> Vec<NeuronInfo<AccountId32>> {
             SubtensorModule::get_neurons(netuid)
         }
 
-        fn get_neuron(netuid: u16, uid: u16) -> Option<NeuronInfo<AccountId32>> {
+        fn get_neuron(netuid: NetUid, uid: u16) -> Option<NeuronInfo<AccountId32>> {
             SubtensorModule::get_neuron(netuid, uid)
         }
     }
 
     impl subtensor_custom_rpc_runtime_api::SubnetInfoRuntimeApi<Block> for Runtime {
-        fn get_subnet_info(netuid: u16) -> Option<SubnetInfo<AccountId32>> {
+        fn get_subnet_info(netuid: NetUid) -> Option<SubnetInfo<AccountId32>> {
             SubtensorModule::get_subnet_info(netuid)
         }
 
@@ -2222,7 +2222,7 @@ impl_runtime_apis! {
             SubtensorModule::get_subnets_info()
         }
 
-        fn get_subnet_info_v2(netuid: u16) -> Option<SubnetInfov2<AccountId32>> {
+        fn get_subnet_info_v2(netuid: NetUid) -> Option<SubnetInfov2<AccountId32>> {
             SubtensorModule::get_subnet_info_v2(netuid)
         }
 
@@ -2230,19 +2230,19 @@ impl_runtime_apis! {
             SubtensorModule::get_subnets_info_v2()
         }
 
-        fn get_subnet_hyperparams(netuid: u16) -> Option<SubnetHyperparams> {
+        fn get_subnet_hyperparams(netuid: NetUid) -> Option<SubnetHyperparams> {
             SubtensorModule::get_subnet_hyperparams(netuid)
         }
 
-        fn get_dynamic_info(netuid: u16) -> Option<DynamicInfo<AccountId32>> {
+        fn get_dynamic_info(netuid: NetUid) -> Option<DynamicInfo<AccountId32>> {
             SubtensorModule::get_dynamic_info(netuid)
         }
 
-        fn get_metagraph(netuid: u16) -> Option<Metagraph<AccountId32>> {
+        fn get_metagraph(netuid: NetUid) -> Option<Metagraph<AccountId32>> {
             SubtensorModule::get_metagraph(netuid)
         }
 
-        fn get_subnet_state(netuid: u16) -> Option<SubnetState<AccountId32>> {
+        fn get_subnet_state(netuid: NetUid) -> Option<SubnetState<AccountId32>> {
             SubtensorModule::get_subnet_state(netuid)
         }
 
@@ -2254,7 +2254,7 @@ impl_runtime_apis! {
             SubtensorModule::get_all_dynamic_info()
         }
 
-        fn get_selective_metagraph(netuid: u16, metagraph_indexes: Vec<u16>) -> Option<SelectiveMetagraph<AccountId32>> {
+        fn get_selective_metagraph(netuid: NetUid, metagraph_indexes: Vec<u16>) -> Option<SelectiveMetagraph<AccountId32>> {
             SubtensorModule::get_selective_metagraph(netuid, metagraph_indexes)
         }
 
@@ -2269,11 +2269,11 @@ impl_runtime_apis! {
             SubtensorModule::get_stake_info_for_coldkeys( coldkey_accounts )
         }
 
-        fn get_stake_info_for_hotkey_coldkey_netuid( hotkey_account: AccountId32, coldkey_account: AccountId32, netuid: u16 ) -> Option<StakeInfo<AccountId32>> {
+        fn get_stake_info_for_hotkey_coldkey_netuid( hotkey_account: AccountId32, coldkey_account: AccountId32, netuid: NetUid ) -> Option<StakeInfo<AccountId32>> {
             SubtensorModule::get_stake_info_for_hotkey_coldkey_netuid( hotkey_account, coldkey_account, netuid )
         }
 
-        fn get_stake_fee( origin: Option<(AccountId32, u16)>, origin_coldkey_account: AccountId32, destination: Option<(AccountId32, u16)>, destination_coldkey_account: AccountId32, amount: u64 ) -> u64 {
+        fn get_stake_fee( origin: Option<(AccountId32, NetUid)>, origin_coldkey_account: AccountId32, destination: Option<(AccountId32, NetUid)>, destination_coldkey_account: AccountId32, amount: u64 ) -> u64 {
             SubtensorModule::get_stake_fee( origin, origin_coldkey_account, destination, destination_coldkey_account, amount )
         }
     }
diff --git a/runtime/tests/pallet_proxy.rs b/runtime/tests/pallet_proxy.rs
index 1fcb36dec5..088da291e2 100644
--- a/runtime/tests/pallet_proxy.rs
+++ b/runtime/tests/pallet_proxy.rs
@@ -6,7 +6,7 @@ use node_subtensor_runtime::{
     BalancesCall, BuildStorage, Proxy, Runtime, RuntimeCall, RuntimeEvent, RuntimeGenesisConfig,
     RuntimeOrigin, SubtensorModule, System, SystemCall,
 };
-use subtensor_runtime_common::{AccountId, ProxyType};
+use subtensor_runtime_common::{AccountId, NetUid, ProxyType};
 
 const ACCOUNT: [u8; 32] = [1_u8; 32];
 const DELEGATE: [u8; 32] = [2_u8; 32];
@@ -60,7 +60,7 @@ fn call_remark() -> RuntimeCall {
 
 // owner call
 fn call_owner_util() -> RuntimeCall {
-    let netuid = 1;
+    let netuid = NetUid::from(1);
     let serving_rate_limit = 2;
     RuntimeCall::AdminUtils(pallet_admin_utils::Call::sudo_set_serving_rate_limit {
         netuid,
@@ -70,7 +70,7 @@ fn call_owner_util() -> RuntimeCall {
 
 // sn owner hotkey call
 fn call_sn_owner_hotkey() -> RuntimeCall {
-    let netuid = 1;
+    let netuid = NetUid::from(1);
     RuntimeCall::AdminUtils(pallet_admin_utils::Call::sudo_set_sn_owner_hotkey {
         netuid,
         hotkey: AccountId::from(ACCOUNT).into(),
@@ -112,7 +112,7 @@ fn call_senate() -> RuntimeCall {
 
 // staking call
 fn call_add_stake() -> RuntimeCall {
-    let netuid = 1;
+    let netuid = NetUid::from(1);
     let amount_staked = 100;
     RuntimeCall::SubtensorModule(pallet_subtensor::Call::add_stake {
         hotkey: AccountId::from(DELEGATE),
@@ -124,7 +124,7 @@ fn call_add_stake() -> RuntimeCall {
 // register call, account as hotkey, delegate as coldkey
 fn call_register() -> RuntimeCall {
     let block_number: u64 = 1;
-    let netuid: u16 = 2;
+    let netuid = NetUid::from(2);
 
     // lower diff first
     SubtensorModule::set_difficulty(netuid, 100);

From 619ef06546441cf362aa82664e9f55e021751cd1 Mon Sep 17 00:00:00 2001
From: Sam Johnson <sam@durosoft.com>
Date: Tue, 10 Jun 2025 13:06:35 -0400
Subject: [PATCH 283/418] remove subnet exists check on validate_remove_stake

---
 pallets/subtensor/src/staking/stake_utils.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pallets/subtensor/src/staking/stake_utils.rs b/pallets/subtensor/src/staking/stake_utils.rs
index 2f9704a6b9..fe0eff1a05 100644
--- a/pallets/subtensor/src/staking/stake_utils.rs
+++ b/pallets/subtensor/src/staking/stake_utils.rs
@@ -965,7 +965,7 @@ impl<T: Config> Pallet<T> {
         allow_partial: bool,
     ) -> Result<(), Error<T>> {
         // Ensure that the subnet exists.
-        ensure!(Self::if_subnet_exist(netuid), Error::<T>::SubnetNotExists);
+        // ensure!(Self::if_subnet_exist(netuid), Error::<T>::SubnetNotExists);
 
         // Ensure that the subnet is enabled.
         Self::ensure_subtoken_enabled(netuid)?;

From a69315bc5275818f8d89abf3497a3c3ea019d92b Mon Sep 17 00:00:00 2001
From: Sam Johnson <sam@durosoft.com>
Date: Tue, 10 Jun 2025 13:17:04 -0400
Subject: [PATCH 284/418] whoops, wrong line

---
 pallets/subtensor/src/staking/stake_utils.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pallets/subtensor/src/staking/stake_utils.rs b/pallets/subtensor/src/staking/stake_utils.rs
index fe0eff1a05..78f9c245db 100644
--- a/pallets/subtensor/src/staking/stake_utils.rs
+++ b/pallets/subtensor/src/staking/stake_utils.rs
@@ -965,10 +965,10 @@ impl<T: Config> Pallet<T> {
         allow_partial: bool,
     ) -> Result<(), Error<T>> {
         // Ensure that the subnet exists.
-        // ensure!(Self::if_subnet_exist(netuid), Error::<T>::SubnetNotExists);
+        ensure!(Self::if_subnet_exist(netuid), Error::<T>::SubnetNotExists);
 
         // Ensure that the subnet is enabled.
-        Self::ensure_subtoken_enabled(netuid)?;
+        // Self::ensure_subtoken_enabled(netuid)?;
 
         // Ensure that the stake amount to be removed is above the minimum in tao equivalent.
         if let Some(tao_equivalent) = Self::sim_swap_alpha_for_tao(netuid, alpha_unstaked) {

From 315dedcdfb1bc56263e5f4009a74a1cb3e332202 Mon Sep 17 00:00:00 2001
From: Sam Johnson <sam@durosoft.com>
Date: Tue, 10 Jun 2025 13:20:49 -0400
Subject: [PATCH 285/418] fix test

---
 pallets/subtensor/src/tests/subnet.rs | 20 +++++++++-----------
 1 file changed, 9 insertions(+), 11 deletions(-)

diff --git a/pallets/subtensor/src/tests/subnet.rs b/pallets/subtensor/src/tests/subnet.rs
index fdcaa00222..10358076ed 100644
--- a/pallets/subtensor/src/tests/subnet.rs
+++ b/pallets/subtensor/src/tests/subnet.rs
@@ -340,17 +340,15 @@ fn test_subtoken_enable_reject_trading_before_enable() {
             stake_bal
         );
 
-        assert_noop!(
-            SubtensorModule::remove_stake_limit(
-                RuntimeOrigin::signed(coldkey_account_id),
-                hotkey_account_id,
-                netuid,
-                amount,
-                limit_price,
-                false
-            ),
-            Error::<Test>::SubtokenDisabled
-        );
+        SubtensorModule::remove_stake_limit(
+            RuntimeOrigin::signed(coldkey_account_id),
+            hotkey_account_id,
+            netuid,
+            amount,
+            limit_price,
+            false,
+        )
+        .unwrap();
 
         assert_noop!(
             SubtensorModule::remove_stake(

From 5f552ae52d5b96ad9ba0cc23e0daabbc43f3e3a0 Mon Sep 17 00:00:00 2001
From: Sam Johnson <sam@durosoft.com>
Date: Tue, 10 Jun 2025 13:23:00 -0400
Subject: [PATCH 286/418] clippy

---
 pallets/subtensor/src/tests/subnet.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/pallets/subtensor/src/tests/subnet.rs b/pallets/subtensor/src/tests/subnet.rs
index 10358076ed..c95a841736 100644
--- a/pallets/subtensor/src/tests/subnet.rs
+++ b/pallets/subtensor/src/tests/subnet.rs
@@ -239,7 +239,9 @@ fn test_subtoken_enable() {
     });
 }
 
-// cargo test --package pallet-subtensor --lib -- tests::subnet::test_subtoken_enable_reject_trading_before_enable --exact --show-output
+// cargo test --package pallet-subtensor --lib --
+// tests::subnet::test_subtoken_enable_reject_trading_before_enable --exact --show-output
+#[allow(clippy::unwrap_used)]
 #[test]
 fn test_subtoken_enable_reject_trading_before_enable() {
     // ensure_subtoken_enabled

From 75f419c28a1b14579be3f84e45426f219e3e357a Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Tue, 10 Jun 2025 19:54:03 +0200
Subject: [PATCH 287/418] fix unused imports

---
 pallets/subtensor/src/migrations/migrate_delete_subnet_21.rs     | 1 -
 pallets/subtensor/src/migrations/migrate_delete_subnet_3.rs      | 1 -
 .../subtensor/src/migrations/migrate_to_v1_separate_emission.rs  | 1 -
 .../subtensor/src/migrations/migrate_to_v2_fixed_total_stake.rs  | 1 -
 4 files changed, 4 deletions(-)

diff --git a/pallets/subtensor/src/migrations/migrate_delete_subnet_21.rs b/pallets/subtensor/src/migrations/migrate_delete_subnet_21.rs
index d12a58ed37..58360d5c67 100644
--- a/pallets/subtensor/src/migrations/migrate_delete_subnet_21.rs
+++ b/pallets/subtensor/src/migrations/migrate_delete_subnet_21.rs
@@ -1,6 +1,5 @@
 use super::*;
 use frame_support::{
-    pallet_prelude::*,
     storage_alias,
     traits::{Get, GetStorageVersion, StorageVersion},
     weights::Weight,
diff --git a/pallets/subtensor/src/migrations/migrate_delete_subnet_3.rs b/pallets/subtensor/src/migrations/migrate_delete_subnet_3.rs
index 0e85c56554..d553db79d0 100644
--- a/pallets/subtensor/src/migrations/migrate_delete_subnet_3.rs
+++ b/pallets/subtensor/src/migrations/migrate_delete_subnet_3.rs
@@ -1,6 +1,5 @@
 use super::*;
 use frame_support::{
-    pallet_prelude::*,
     storage_alias,
     traits::{Get, GetStorageVersion, StorageVersion},
     weights::Weight,
diff --git a/pallets/subtensor/src/migrations/migrate_to_v1_separate_emission.rs b/pallets/subtensor/src/migrations/migrate_to_v1_separate_emission.rs
index 5d28337dcb..d08b8de07d 100644
--- a/pallets/subtensor/src/migrations/migrate_to_v1_separate_emission.rs
+++ b/pallets/subtensor/src/migrations/migrate_to_v1_separate_emission.rs
@@ -1,6 +1,5 @@
 use super::*;
 use frame_support::{
-    pallet_prelude::*,
     storage_alias,
     traits::{Get, GetStorageVersion, StorageVersion},
     weights::Weight,
diff --git a/pallets/subtensor/src/migrations/migrate_to_v2_fixed_total_stake.rs b/pallets/subtensor/src/migrations/migrate_to_v2_fixed_total_stake.rs
index b0a711ac77..6410f79321 100644
--- a/pallets/subtensor/src/migrations/migrate_to_v2_fixed_total_stake.rs
+++ b/pallets/subtensor/src/migrations/migrate_to_v2_fixed_total_stake.rs
@@ -1,6 +1,5 @@
 use super::*;
 use frame_support::{
-    pallet_prelude::*,
     storage_alias,
     traits::{Get, GetStorageVersion},
     weights::Weight,

From c47144efd5b7fc83cf764b8a1044ae7b1f7e7fe6 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Tue, 10 Jun 2025 19:59:52 +0200
Subject: [PATCH 288/418] Remove nonsensical loops

---
 pallets/subtensor/src/macros/genesis.rs | 111 ++++++++++++------------
 1 file changed, 54 insertions(+), 57 deletions(-)

diff --git a/pallets/subtensor/src/macros/genesis.rs b/pallets/subtensor/src/macros/genesis.rs
index 7040c7fef6..ff8f4864b4 100644
--- a/pallets/subtensor/src/macros/genesis.rs
+++ b/pallets/subtensor/src/macros/genesis.rs
@@ -41,64 +41,61 @@ mod genesis {
             // Set target registrations for validators as 1 per block.
             TargetRegistrationsPerInterval::<T>::insert(NetUid::ROOT, 1);
 
-            for net in 1..2 {
-                let netuid = NetUid::from(net);
-                let hotkey = DefaultAccount::<T>::get();
-                SubnetMechanism::<T>::insert(netuid, 1); // Make dynamic.
-                Owner::<T>::insert(hotkey.clone(), hotkey.clone());
-                SubnetAlphaIn::<T>::insert(netuid, 10_000_000_000);
-                SubnetTAO::<T>::insert(netuid, 10_000_000_000);
-                NetworksAdded::<T>::insert(netuid, true);
-                TotalNetworks::<T>::mutate(|n| *n = n.saturating_add(1));
-                SubnetworkN::<T>::insert(netuid, 0);
-                MaxAllowedUids::<T>::insert(netuid, 256u16);
-                MaxAllowedValidators::<T>::insert(netuid, 64u16);
-                MinAllowedWeights::<T>::insert(netuid, 0);
-                MaxWeightsLimit::<T>::insert(netuid, u16::MAX);
-                Tempo::<T>::insert(netuid, 100);
-                NetworkRegistrationAllowed::<T>::insert(netuid, true);
-                SubnetOwner::<T>::insert(netuid, hotkey.clone());
-                SubnetLocked::<T>::insert(netuid, 1);
-                LargestLocked::<T>::insert(netuid, 1);
-                Alpha::<T>::insert(
-                    // Lock the initial funds making this key the owner.
-                    (hotkey.clone(), hotkey.clone(), netuid),
-                    U64F64::saturating_from_num(1_000_000_000),
-                );
-                TotalHotkeyAlpha::<T>::insert(hotkey.clone(), netuid, 1_000_000_000);
-                TotalHotkeyShares::<T>::insert(
-                    hotkey.clone(),
-                    netuid,
-                    U64F64::saturating_from_num(1_000_000_000),
-                );
-                // TotalColdkeyAlpha::<T>::insert(hotkey.clone(), netuid, 1_000_000_000);
-                SubnetAlphaOut::<T>::insert(netuid, 1_000_000_000);
-                let mut staking_hotkeys = StakingHotkeys::<T>::get(hotkey.clone());
-                if !staking_hotkeys.contains(&hotkey) {
-                    staking_hotkeys.push(hotkey.clone());
-                    StakingHotkeys::<T>::insert(hotkey.clone(), staking_hotkeys.clone());
-                }
-
-                let block_number = Pallet::<T>::get_current_block_as_u64();
-                for next_uid in 0u16..1 {
-                    SubnetworkN::<T>::insert(netuid, next_uid.saturating_add(1));
-                    Rank::<T>::mutate(netuid, |v| v.push(0));
-                    Trust::<T>::mutate(netuid, |v| v.push(0));
-                    Active::<T>::mutate(netuid, |v| v.push(true));
-                    Emission::<T>::mutate(netuid, |v| v.push(0));
-                    Consensus::<T>::mutate(netuid, |v| v.push(0));
-                    Incentive::<T>::mutate(netuid, |v| v.push(0));
-                    Dividends::<T>::mutate(netuid, |v| v.push(0));
-                    LastUpdate::<T>::mutate(netuid, |v| v.push(block_number));
-                    PruningScores::<T>::mutate(netuid, |v| v.push(0));
-                    ValidatorTrust::<T>::mutate(netuid, |v| v.push(0));
-                    ValidatorPermit::<T>::mutate(netuid, |v| v.push(false));
-                    Keys::<T>::insert(netuid, next_uid, hotkey.clone()); // Make hotkey - uid association.
-                    Uids::<T>::insert(netuid, hotkey.clone(), next_uid); // Make uid - hotkey association.
-                    BlockAtRegistration::<T>::insert(netuid, next_uid, block_number); // Fill block at registration.
-                    IsNetworkMember::<T>::insert(hotkey.clone(), netuid, true); // Fill network is member.
-                }
+            let netuid = NetUid::from(1);
+            let hotkey = DefaultAccount::<T>::get();
+            SubnetMechanism::<T>::insert(netuid, 1); // Make dynamic.
+            Owner::<T>::insert(hotkey.clone(), hotkey.clone());
+            SubnetAlphaIn::<T>::insert(netuid, 10_000_000_000);
+            SubnetTAO::<T>::insert(netuid, 10_000_000_000);
+            NetworksAdded::<T>::insert(netuid, true);
+            TotalNetworks::<T>::mutate(|n| *n = n.saturating_add(1));
+            SubnetworkN::<T>::insert(netuid, 0);
+            MaxAllowedUids::<T>::insert(netuid, 256u16);
+            MaxAllowedValidators::<T>::insert(netuid, 64u16);
+            MinAllowedWeights::<T>::insert(netuid, 0);
+            MaxWeightsLimit::<T>::insert(netuid, u16::MAX);
+            Tempo::<T>::insert(netuid, 100);
+            NetworkRegistrationAllowed::<T>::insert(netuid, true);
+            SubnetOwner::<T>::insert(netuid, hotkey.clone());
+            SubnetLocked::<T>::insert(netuid, 1);
+            LargestLocked::<T>::insert(netuid, 1);
+            Alpha::<T>::insert(
+                // Lock the initial funds making this key the owner.
+                (hotkey.clone(), hotkey.clone(), netuid),
+                U64F64::saturating_from_num(1_000_000_000),
+            );
+            TotalHotkeyAlpha::<T>::insert(hotkey.clone(), netuid, 1_000_000_000);
+            TotalHotkeyShares::<T>::insert(
+                hotkey.clone(),
+                netuid,
+                U64F64::saturating_from_num(1_000_000_000),
+            );
+            // TotalColdkeyAlpha::<T>::insert(hotkey.clone(), netuid, 1_000_000_000);
+            SubnetAlphaOut::<T>::insert(netuid, 1_000_000_000);
+            let mut staking_hotkeys = StakingHotkeys::<T>::get(hotkey.clone());
+            if !staking_hotkeys.contains(&hotkey) {
+                staking_hotkeys.push(hotkey.clone());
+                StakingHotkeys::<T>::insert(hotkey.clone(), staking_hotkeys.clone());
             }
+
+            let block_number = Pallet::<T>::get_current_block_as_u64();
+
+            SubnetworkN::<T>::insert(netuid, 1);
+            Rank::<T>::mutate(netuid, |v| v.push(0));
+            Trust::<T>::mutate(netuid, |v| v.push(0));
+            Active::<T>::mutate(netuid, |v| v.push(true));
+            Emission::<T>::mutate(netuid, |v| v.push(0));
+            Consensus::<T>::mutate(netuid, |v| v.push(0));
+            Incentive::<T>::mutate(netuid, |v| v.push(0));
+            Dividends::<T>::mutate(netuid, |v| v.push(0));
+            LastUpdate::<T>::mutate(netuid, |v| v.push(block_number));
+            PruningScores::<T>::mutate(netuid, |v| v.push(0));
+            ValidatorTrust::<T>::mutate(netuid, |v| v.push(0));
+            ValidatorPermit::<T>::mutate(netuid, |v| v.push(false));
+            Keys::<T>::insert(netuid, 0, hotkey.clone()); // Make hotkey - uid association.
+            Uids::<T>::insert(netuid, hotkey.clone(), 0); // Make uid - hotkey association.
+            BlockAtRegistration::<T>::insert(netuid, 0, block_number); // Fill block at registration.
+            IsNetworkMember::<T>::insert(hotkey.clone(), netuid, true); // Fill network is member.
         }
     }
 }

From 848e71e2fbca1f20d5041094d38000f3cfd964a1 Mon Sep 17 00:00:00 2001
From: John Reed <87283488+JohnReedV@users.noreply.github.com>
Date: Tue, 10 Jun 2025 12:47:16 -0700
Subject: [PATCH 289/418] impl hyperparams_v2

includes yuma3_enabled
---
 pallets/subtensor/rpc/src/lib.rs              | 18 ++++
 pallets/subtensor/runtime-api/src/lib.rs      |  3 +-
 pallets/subtensor/src/rpc_info/subnet_info.rs | 98 +++++++++++++++++++
 runtime/src/lib.rs                            |  6 +-
 4 files changed, 123 insertions(+), 2 deletions(-)

diff --git a/pallets/subtensor/rpc/src/lib.rs b/pallets/subtensor/rpc/src/lib.rs
index b3b60206dd..95211b067f 100644
--- a/pallets/subtensor/rpc/src/lib.rs
+++ b/pallets/subtensor/rpc/src/lib.rs
@@ -52,6 +52,8 @@ pub trait SubtensorCustomApi<BlockHash> {
     fn get_subnets_info_v2(&self, at: Option<BlockHash>) -> RpcResult<Vec<u8>>;
     #[method(name = "subnetInfo_getSubnetHyperparams")]
     fn get_subnet_hyperparams(&self, netuid: u16, at: Option<BlockHash>) -> RpcResult<Vec<u8>>;
+    #[method(name = "subnetInfo_getSubnetHyperparamsV2")]
+    fn get_subnet_hyperparams_v2(&self, netuid: u16, at: Option<BlockHash>) -> RpcResult<Vec<u8>>;
     #[method(name = "subnetInfo_getAllDynamicInfo")]
     fn get_all_dynamic_info(&self, at: Option<BlockHash>) -> RpcResult<Vec<u8>>;
     #[method(name = "subnetInfo_getDynamicInfo")]
@@ -274,6 +276,22 @@ where
         }
     }
 
+    fn get_subnet_hyperparams_v2(
+        &self,
+        netuid: u16,
+        at: Option<<Block as BlockT>::Hash>,
+    ) -> RpcResult<Vec<u8>> {
+        let api = self.client.runtime_api();
+        let at = at.unwrap_or_else(|| self.client.info().best_hash);
+
+        match api.get_subnet_hyperparams_v2(at, netuid) {
+            Ok(result) => Ok(result.encode()),
+            Err(e) => {
+                Err(Error::RuntimeError(format!("Unable to get subnet info: {:?}", e)).into())
+            }
+        }
+    }
+
     fn get_all_dynamic_info(&self, at: Option<<Block as BlockT>::Hash>) -> RpcResult<Vec<u8>> {
         let api = self.client.runtime_api();
         let at = at.unwrap_or_else(|| self.client.info().best_hash);
diff --git a/pallets/subtensor/runtime-api/src/lib.rs b/pallets/subtensor/runtime-api/src/lib.rs
index 1a2f34aa9e..f577fdb37d 100644
--- a/pallets/subtensor/runtime-api/src/lib.rs
+++ b/pallets/subtensor/runtime-api/src/lib.rs
@@ -9,7 +9,7 @@ use pallet_subtensor::rpc_info::{
     neuron_info::{NeuronInfo, NeuronInfoLite},
     show_subnet::SubnetState,
     stake_info::StakeInfo,
-    subnet_info::{SubnetHyperparams, SubnetInfo, SubnetInfov2},
+    subnet_info::{SubnetHyperparams, SubnetHyperparamsV2, SubnetInfo, SubnetInfov2},
 };
 use sp_runtime::AccountId32;
 
@@ -35,6 +35,7 @@ sp_api::decl_runtime_apis! {
         fn get_subnet_info_v2(netuid: u16) -> Option<SubnetInfov2<AccountId32>>;
         fn get_subnets_info_v2() -> Vec<Option<SubnetInfov2<AccountId32>>>;
         fn get_subnet_hyperparams(netuid: u16) -> Option<SubnetHyperparams>;
+        fn get_subnet_hyperparams_v2(netuid: u16) -> Option<SubnetHyperparamsV2>;
         fn get_all_dynamic_info() -> Vec<Option<DynamicInfo<AccountId32>>>;
         fn get_all_metagraphs() -> Vec<Option<Metagraph<AccountId32>>>;
         fn get_metagraph(netuid: u16) -> Option<Metagraph<AccountId32>>;
diff --git a/pallets/subtensor/src/rpc_info/subnet_info.rs b/pallets/subtensor/src/rpc_info/subnet_info.rs
index 6e9e722295..17e47f4f5b 100644
--- a/pallets/subtensor/src/rpc_info/subnet_info.rs
+++ b/pallets/subtensor/src/rpc_info/subnet_info.rs
@@ -83,6 +83,39 @@ pub struct SubnetHyperparams {
     liquid_alpha_enabled: bool,
 }
 
+#[freeze_struct("7dfa98f279500b4b")]
+#[derive(Decode, Encode, PartialEq, Eq, Clone, Debug, TypeInfo)]
+pub struct SubnetHyperparamsV2 {
+    rho: Compact<u16>,
+    kappa: Compact<u16>,
+    immunity_period: Compact<u16>,
+    min_allowed_weights: Compact<u16>,
+    max_weights_limit: Compact<u16>,
+    tempo: Compact<u16>,
+    min_difficulty: Compact<u64>,
+    max_difficulty: Compact<u64>,
+    weights_version: Compact<u64>,
+    weights_rate_limit: Compact<u64>,
+    adjustment_interval: Compact<u16>,
+    activity_cutoff: Compact<u16>,
+    pub registration_allowed: bool,
+    target_regs_per_interval: Compact<u16>,
+    min_burn: Compact<u64>,
+    max_burn: Compact<u64>,
+    bonds_moving_avg: Compact<u64>,
+    max_regs_per_block: Compact<u16>,
+    serving_rate_limit: Compact<u64>,
+    max_validators: Compact<u16>,
+    adjustment_alpha: Compact<u64>,
+    difficulty: Compact<u64>,
+    commit_reveal_period: Compact<u64>,
+    commit_reveal_weights_enabled: bool,
+    alpha_high: Compact<u16>,
+    alpha_low: Compact<u16>,
+    liquid_alpha_enabled: bool,
+    yuma3_enabled: bool,
+}
+
 impl<T: Config> Pallet<T> {
     pub fn get_subnet_info(netuid: u16) -> Option<SubnetInfo<T::AccountId>> {
         if !Self::if_subnet_exist(netuid) {
@@ -287,4 +320,69 @@ impl<T: Config> Pallet<T> {
             liquid_alpha_enabled,
         })
     }
+
+    pub fn get_subnet_hyperparams_v2(netuid: u16) -> Option<SubnetHyperparamsV2> {
+        if !Self::if_subnet_exist(netuid) {
+            return None;
+        }
+
+        let rho = Self::get_rho(netuid);
+        let kappa = Self::get_kappa(netuid);
+        let immunity_period = Self::get_immunity_period(netuid);
+        let min_allowed_weights = Self::get_min_allowed_weights(netuid);
+        let max_weights_limit = Self::get_max_weight_limit(netuid);
+        let tempo = Self::get_tempo(netuid);
+        let min_difficulty = Self::get_min_difficulty(netuid);
+        let max_difficulty = Self::get_max_difficulty(netuid);
+        let weights_version = Self::get_weights_version_key(netuid);
+        let weights_rate_limit = Self::get_weights_set_rate_limit(netuid);
+        let adjustment_interval = Self::get_adjustment_interval(netuid);
+        let activity_cutoff = Self::get_activity_cutoff(netuid);
+        let registration_allowed = Self::get_network_registration_allowed(netuid);
+        let target_regs_per_interval = Self::get_target_registrations_per_interval(netuid);
+        let min_burn = Self::get_min_burn_as_u64(netuid);
+        let max_burn = Self::get_max_burn_as_u64(netuid);
+        let bonds_moving_avg = Self::get_bonds_moving_average(netuid);
+        let max_regs_per_block = Self::get_max_registrations_per_block(netuid);
+        let serving_rate_limit = Self::get_serving_rate_limit(netuid);
+        let max_validators = Self::get_max_allowed_validators(netuid);
+        let adjustment_alpha = Self::get_adjustment_alpha(netuid);
+        let difficulty = Self::get_difficulty_as_u64(netuid);
+        let commit_reveal_period = Self::get_reveal_period(netuid);
+        let commit_reveal_weights_enabled = Self::get_commit_reveal_weights_enabled(netuid);
+        let liquid_alpha_enabled = Self::get_liquid_alpha_enabled(netuid);
+        let (alpha_low, alpha_high): (u16, u16) = Self::get_alpha_values(netuid);
+        let yuma3_enabled = Self::get_yuma3_enabled(netuid);
+
+        Some(SubnetHyperparamsV2 {
+            rho: rho.into(),
+            kappa: kappa.into(),
+            immunity_period: immunity_period.into(),
+            min_allowed_weights: min_allowed_weights.into(),
+            max_weights_limit: max_weights_limit.into(),
+            tempo: tempo.into(),
+            min_difficulty: min_difficulty.into(),
+            max_difficulty: max_difficulty.into(),
+            weights_version: weights_version.into(),
+            weights_rate_limit: weights_rate_limit.into(),
+            adjustment_interval: adjustment_interval.into(),
+            activity_cutoff: activity_cutoff.into(),
+            registration_allowed,
+            target_regs_per_interval: target_regs_per_interval.into(),
+            min_burn: min_burn.into(),
+            max_burn: max_burn.into(),
+            bonds_moving_avg: bonds_moving_avg.into(),
+            max_regs_per_block: max_regs_per_block.into(),
+            serving_rate_limit: serving_rate_limit.into(),
+            max_validators: max_validators.into(),
+            adjustment_alpha: adjustment_alpha.into(),
+            difficulty: difficulty.into(),
+            commit_reveal_period: commit_reveal_period.into(),
+            commit_reveal_weights_enabled,
+            alpha_high: alpha_high.into(),
+            alpha_low: alpha_low.into(),
+            liquid_alpha_enabled,
+            yuma3_enabled,
+        })
+    }
 }
diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index 27fed3ec0a..4f248071ef 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -38,7 +38,7 @@ use pallet_subtensor::rpc_info::{
     neuron_info::{NeuronInfo, NeuronInfoLite},
     show_subnet::SubnetState,
     stake_info::StakeInfo,
-    subnet_info::{SubnetHyperparams, SubnetInfo, SubnetInfov2},
+    subnet_info::{SubnetHyperparams, SubnetHyperparamsV2, SubnetInfo, SubnetInfov2},
 };
 use smallvec::smallvec;
 use sp_api::impl_runtime_apis;
@@ -2234,6 +2234,10 @@ impl_runtime_apis! {
             SubtensorModule::get_subnet_hyperparams(netuid)
         }
 
+        fn get_subnet_hyperparams_v2(netuid: u16) -> Option<SubnetHyperparamsV2> {
+            SubtensorModule::get_subnet_hyperparams_v2(netuid)
+        }
+
         fn get_dynamic_info(netuid: u16) -> Option<DynamicInfo<AccountId32>> {
             SubtensorModule::get_dynamic_info(netuid)
         }

From 7323aa7dbc2e2d666c9e4da449509108e7004ea7 Mon Sep 17 00:00:00 2001
From: John Reed <87283488+JohnReedV@users.noreply.github.com>
Date: Tue, 10 Jun 2025 12:56:17 -0700
Subject: [PATCH 290/418] yuma3_enabled => yuma_version

---
 pallets/subtensor/src/rpc_info/subnet_info.rs | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/pallets/subtensor/src/rpc_info/subnet_info.rs b/pallets/subtensor/src/rpc_info/subnet_info.rs
index 17e47f4f5b..e5f18ce36b 100644
--- a/pallets/subtensor/src/rpc_info/subnet_info.rs
+++ b/pallets/subtensor/src/rpc_info/subnet_info.rs
@@ -83,7 +83,7 @@ pub struct SubnetHyperparams {
     liquid_alpha_enabled: bool,
 }
 
-#[freeze_struct("7dfa98f279500b4b")]
+#[freeze_struct("cb67d7ada314398e")]
 #[derive(Decode, Encode, PartialEq, Eq, Clone, Debug, TypeInfo)]
 pub struct SubnetHyperparamsV2 {
     rho: Compact<u16>,
@@ -113,7 +113,7 @@ pub struct SubnetHyperparamsV2 {
     alpha_high: Compact<u16>,
     alpha_low: Compact<u16>,
     liquid_alpha_enabled: bool,
-    yuma3_enabled: bool,
+    yuma_version: Compact<u16>,
 }
 
 impl<T: Config> Pallet<T> {
@@ -352,7 +352,10 @@ impl<T: Config> Pallet<T> {
         let commit_reveal_weights_enabled = Self::get_commit_reveal_weights_enabled(netuid);
         let liquid_alpha_enabled = Self::get_liquid_alpha_enabled(netuid);
         let (alpha_low, alpha_high): (u16, u16) = Self::get_alpha_values(netuid);
-        let yuma3_enabled = Self::get_yuma3_enabled(netuid);
+        let yuma_version: u16 = match Self::get_yuma3_enabled(netuid) {
+            true => 3u16,
+            false => 2u16,
+        };
 
         Some(SubnetHyperparamsV2 {
             rho: rho.into(),
@@ -382,7 +385,7 @@ impl<T: Config> Pallet<T> {
             alpha_high: alpha_high.into(),
             alpha_low: alpha_low.into(),
             liquid_alpha_enabled,
-            yuma3_enabled,
+            yuma_version: yuma_version.into(),
         })
     }
 }

From cb5db2bba9e2173be58ad76c8712bb8633870625 Mon Sep 17 00:00:00 2001
From: John Reed <87283488+JohnReedV@users.noreply.github.com>
Date: Tue, 10 Jun 2025 13:01:38 -0700
Subject: [PATCH 291/418] update reads

---
 pallets/subtensor/src/macros/dispatches.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pallets/subtensor/src/macros/dispatches.rs b/pallets/subtensor/src/macros/dispatches.rs
index 5d8c78526d..d1a6f36884 100644
--- a/pallets/subtensor/src/macros/dispatches.rs
+++ b/pallets/subtensor/src/macros/dispatches.rs
@@ -1786,7 +1786,7 @@ mod dispatches {
         ///
         #[pallet::call_index(88)]
         #[pallet::weight((Weight::from_parts(159_200_000, 0)
-		.saturating_add(T::DbWeight::get().reads(13))
+		.saturating_add(T::DbWeight::get().reads(14))
 		.saturating_add(T::DbWeight::get().writes(10)), DispatchClass::Normal, Pays::No))]
         pub fn add_stake_limit(
             origin: OriginFor<T>,

From 468d102485679a8533faba938e3811814483bb80 Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Wed, 11 Jun 2025 02:08:15 +0200
Subject: [PATCH 292/418] convert subtensor signed ext to tx ext

---
 pallets/subtensor/src/lib.rs | 417 +++++++++++++++--------------------
 runtime/src/lib.rs           |   4 +-
 2 files changed, 180 insertions(+), 241 deletions(-)

diff --git a/pallets/subtensor/src/lib.rs b/pallets/subtensor/src/lib.rs
index ec9d9c7ed9..7ab6d0bf71 100644
--- a/pallets/subtensor/src/lib.rs
+++ b/pallets/subtensor/src/lib.rs
@@ -12,10 +12,11 @@ use frame_support::{
     dispatch::{self, DispatchInfo, DispatchResult, DispatchResultWithPostInfo, PostDispatchInfo},
     ensure,
     pallet_macros::import_section,
+    pallet_prelude::*,
     traits::{IsSubType, tokens::fungible},
 };
 
-use codec::{Decode, Encode};
+use codec::{Decode, DecodeWithMemTracking, Encode};
 use frame_support::sp_runtime::transaction_validity::InvalidTransaction;
 use frame_support::sp_runtime::transaction_validity::ValidTransaction;
 use pallet_balances::Call as BalancesCall;
@@ -24,7 +25,10 @@ use scale_info::TypeInfo;
 use sp_core::Get;
 use sp_runtime::{
     DispatchError,
-    traits::{DispatchInfoOf, Dispatchable, PostDispatchInfoOf, SignedExtension},
+    traits::{
+        AsSystemOriginSigner, DispatchInfoOf, Dispatchable, Implication, PostDispatchInfoOf,
+        TransactionExtension, ValidateResult,
+    },
     transaction_validity::{TransactionValidity, TransactionValidityError},
 };
 use sp_std::marker::PhantomData;
@@ -1783,22 +1787,23 @@ impl From<CustomTransactionError> for u8 {
     }
 }
 
-#[freeze_struct("61e2b893d5ce6701")]
-#[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]
-pub struct SubtensorSignedExtension<T: Config + Send + Sync + TypeInfo>(pub PhantomData<T>);
+impl From<CustomTransactionError> for TransactionValidityError {
+    fn from(variant: CustomTransactionError) -> Self {
+        TransactionValidityError::Invalid(InvalidTransaction::Custom(variant.into()))
+    }
+}
 
-impl<T: Config + Send + Sync + TypeInfo> Default for SubtensorSignedExtension<T>
-where
-    <T as frame_system::Config>::RuntimeCall:
-        Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,
-    <T as frame_system::Config>::RuntimeCall: IsSubType<Call<T>>,
-{
-    fn default() -> Self {
-        Self::new()
+#[freeze_struct("2e02eb32e5cb25d3")]
+#[derive(Default, Encode, Decode, DecodeWithMemTracking, Clone, Eq, PartialEq, TypeInfo)]
+pub struct SubtensorTransactionExtension<T: Config + Send + Sync + TypeInfo>(pub PhantomData<T>);
+
+impl<T: Config + Send + Sync + TypeInfo> sp_std::fmt::Debug for SubtensorTransactionExtension<T> {
+    fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+        write!(f, "SubtensorTransactionExtension")
     }
 }
 
-impl<T: Config + Send + Sync + TypeInfo> SubtensorSignedExtension<T>
+impl<T: Config + Send + Sync + TypeInfo> SubtensorTransactionExtension<T>
 where
     <T as frame_system::Config>::RuntimeCall:
         Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,
@@ -1832,59 +1837,31 @@ where
 
     pub fn result_to_validity(result: Result<(), Error<T>>, priority: u64) -> TransactionValidity {
         if let Err(err) = result {
-            match err {
-                Error::<T>::AmountTooLow => Err(InvalidTransaction::Custom(
-                    CustomTransactionError::StakeAmountTooLow.into(),
-                )
-                .into()),
-                Error::<T>::SubnetNotExists => Err(InvalidTransaction::Custom(
-                    CustomTransactionError::SubnetDoesntExist.into(),
-                )
-                .into()),
-                Error::<T>::NotEnoughBalanceToStake => Err(InvalidTransaction::Custom(
-                    CustomTransactionError::BalanceTooLow.into(),
-                )
-                .into()),
-                Error::<T>::HotKeyAccountNotExists => Err(InvalidTransaction::Custom(
-                    CustomTransactionError::HotkeyAccountDoesntExist.into(),
-                )
-                .into()),
-                Error::<T>::NotEnoughStakeToWithdraw => Err(InvalidTransaction::Custom(
-                    CustomTransactionError::NotEnoughStakeToWithdraw.into(),
-                )
-                .into()),
-                Error::<T>::InsufficientLiquidity => Err(InvalidTransaction::Custom(
-                    CustomTransactionError::InsufficientLiquidity.into(),
-                )
-                .into()),
-                Error::<T>::SlippageTooHigh => Err(InvalidTransaction::Custom(
-                    CustomTransactionError::SlippageTooHigh.into(),
-                )
-                .into()),
-                Error::<T>::TransferDisallowed => Err(InvalidTransaction::Custom(
-                    CustomTransactionError::TransferDisallowed.into(),
-                )
-                .into()),
-                Error::<T>::HotKeyNotRegisteredInNetwork => Err(InvalidTransaction::Custom(
-                    CustomTransactionError::HotKeyNotRegisteredInNetwork.into(),
-                )
-                .into()),
-                Error::<T>::InvalidIpAddress => Err(InvalidTransaction::Custom(
-                    CustomTransactionError::InvalidIpAddress.into(),
-                )
-                .into()),
-                Error::<T>::ServingRateLimitExceeded => Err(InvalidTransaction::Custom(
-                    CustomTransactionError::ServingRateLimitExceeded.into(),
-                )
-                .into()),
-                Error::<T>::InvalidPort => Err(InvalidTransaction::Custom(
-                    CustomTransactionError::InvalidPort.into(),
-                )
-                .into()),
-                _ => Err(
-                    InvalidTransaction::Custom(CustomTransactionError::BadRequest.into()).into(),
-                ),
-            }
+            Err(match err {
+                Error::<T>::AmountTooLow => CustomTransactionError::StakeAmountTooLow.into(),
+                Error::<T>::SubnetNotExists => CustomTransactionError::SubnetDoesntExist.into(),
+                Error::<T>::NotEnoughBalanceToStake => CustomTransactionError::BalanceTooLow.into(),
+                Error::<T>::HotKeyAccountNotExists => {
+                    CustomTransactionError::HotkeyAccountDoesntExist.into()
+                }
+                Error::<T>::NotEnoughStakeToWithdraw => {
+                    CustomTransactionError::NotEnoughStakeToWithdraw.into()
+                }
+                Error::<T>::InsufficientLiquidity => {
+                    CustomTransactionError::InsufficientLiquidity.into()
+                }
+                Error::<T>::SlippageTooHigh => CustomTransactionError::SlippageTooHigh.into(),
+                Error::<T>::TransferDisallowed => CustomTransactionError::TransferDisallowed.into(),
+                Error::<T>::HotKeyNotRegisteredInNetwork => {
+                    CustomTransactionError::HotKeyNotRegisteredInNetwork.into()
+                }
+                Error::<T>::InvalidIpAddress => CustomTransactionError::InvalidIpAddress.into(),
+                Error::<T>::ServingRateLimitExceeded => {
+                    CustomTransactionError::ServingRateLimitExceeded.into()
+                }
+                Error::<T>::InvalidPort => CustomTransactionError::InvalidPort.into(),
+                _ => CustomTransactionError::BadRequest.into(),
+            })
         } else {
             Ok(ValidTransaction {
                 priority,
@@ -1894,127 +1871,118 @@ where
     }
 }
 
-impl<T: Config + Send + Sync + TypeInfo> sp_std::fmt::Debug for SubtensorSignedExtension<T> {
-    fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
-        write!(f, "SubtensorSignedExtension")
-    }
-}
-
-impl<T: Config + Send + Sync + TypeInfo + pallet_balances::Config> SignedExtension
-    for SubtensorSignedExtension<T>
+impl<T: Config + Send + Sync + TypeInfo + pallet_balances::Config>
+    TransactionExtension<<T as frame_system::Config>::RuntimeCall>
+    for SubtensorTransactionExtension<T>
 where
     <T as frame_system::Config>::RuntimeCall:
         Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,
+    <T as frame_system::Config>::RuntimeOrigin: AsSystemOriginSigner<T::AccountId> + Clone,
     <T as frame_system::Config>::RuntimeCall: IsSubType<Call<T>>,
     <T as frame_system::Config>::RuntimeCall: IsSubType<BalancesCall<T>>,
 {
-    const IDENTIFIER: &'static str = "SubtensorSignedExtension";
+    const IDENTIFIER: &'static str = "SubtensorTransactionExtension";
 
-    type AccountId = T::AccountId;
-    type Call = <T as frame_system::Config>::RuntimeCall;
-    type AdditionalSigned = ();
-    type Pre = (CallType, u64, Self::AccountId);
+    type Implicit = ();
+    type Val = Option<T::AccountId>;
+    type Pre = Option<CallType>;
 
-    fn additional_signed(&self) -> Result<Self::AdditionalSigned, TransactionValidityError> {
-        Ok(())
+    fn weight(&self, _call: &<T as frame_system::Config>::RuntimeCall) -> Weight {
+        // TODO: benchmark transaction extension
+        Weight::zero()
     }
 
     fn validate(
         &self,
-        who: &Self::AccountId,
-        call: &Self::Call,
-        _info: &DispatchInfoOf<Self::Call>,
+        origin: <T as frame_system::Config>::RuntimeOrigin,
+        call: &<T as frame_system::Config>::RuntimeCall,
+        _info: &DispatchInfoOf<<T as frame_system::Config>::RuntimeCall>,
         _len: usize,
-    ) -> TransactionValidity {
+        _self_implicit: Self::Implicit,
+        _inherited_implication: &impl Implication,
+        _source: TransactionSource,
+    ) -> ValidateResult<Self::Val, <T as frame_system::Config>::RuntimeCall> {
+        let Some(who) = origin.as_system_origin_signer() else {
+            return Ok((Default::default(), None, origin));
+        };
+
         match call.is_sub_type() {
             Some(Call::commit_weights { netuid, .. }) => {
                 if Self::check_weights_min_stake(who, *netuid) {
                     let priority: u64 = Self::get_priority_set_weights(who, *netuid);
-                    Ok(ValidTransaction {
+                    let validity = ValidTransaction {
                         priority,
                         longevity: 1,
                         ..Default::default()
-                    })
+                    };
+                    Ok((validity, Some(who.clone()), origin))
                 } else {
-                    Err(InvalidTransaction::Custom(
-                        CustomTransactionError::StakeAmountTooLow.into(),
-                    )
-                    .into())
+                    Err(CustomTransactionError::StakeAmountTooLow.into())
                 }
             }
             Some(Call::reveal_weights { netuid, .. }) => {
                 if Self::check_weights_min_stake(who, *netuid) {
                     let priority: u64 = Self::get_priority_set_weights(who, *netuid);
-                    Ok(ValidTransaction {
+                    let validity = ValidTransaction {
                         priority,
                         longevity: 1,
                         ..Default::default()
-                    })
+                    };
+                    Ok((validity, Some(who.clone()), origin))
                 } else {
-                    Err(InvalidTransaction::Custom(
-                        CustomTransactionError::StakeAmountTooLow.into(),
-                    )
-                    .into())
+                    Err(CustomTransactionError::StakeAmountTooLow.into())
                 }
             }
             Some(Call::batch_reveal_weights { netuid, .. }) => {
                 if Self::check_weights_min_stake(who, *netuid) {
                     let priority: u64 = Self::get_priority_set_weights(who, *netuid);
-                    Ok(ValidTransaction {
+                    let validity = ValidTransaction {
                         priority,
                         longevity: 1,
                         ..Default::default()
-                    })
+                    };
+                    Ok((validity, Some(who.clone()), origin))
                 } else {
-                    Err(InvalidTransaction::Custom(
-                        CustomTransactionError::StakeAmountTooLow.into(),
-                    )
-                    .into())
+                    Err(CustomTransactionError::StakeAmountTooLow.into())
                 }
             }
             Some(Call::set_weights { netuid, .. }) => {
                 if Self::check_weights_min_stake(who, *netuid) {
                     let priority: u64 = Self::get_priority_set_weights(who, *netuid);
-                    Ok(ValidTransaction {
+                    let validity = ValidTransaction {
                         priority,
                         longevity: 1,
                         ..Default::default()
-                    })
+                    };
+                    Ok((validity, Some(who.clone()), origin))
                 } else {
-                    Err(InvalidTransaction::Custom(
-                        CustomTransactionError::StakeAmountTooLow.into(),
-                    )
-                    .into())
+                    Err(CustomTransactionError::StakeAmountTooLow.into())
                 }
             }
             Some(Call::set_tao_weights { netuid, hotkey, .. }) => {
                 if Self::check_weights_min_stake(hotkey, *netuid) {
                     let priority: u64 = Self::get_priority_set_weights(hotkey, *netuid);
-                    Ok(ValidTransaction {
+                    let validity = ValidTransaction {
                         priority,
                         longevity: 1,
                         ..Default::default()
-                    })
+                    };
+                    Ok((validity, Some(who.clone()), origin))
                 } else {
-                    Err(InvalidTransaction::Custom(
-                        CustomTransactionError::StakeAmountTooLow.into(),
-                    )
-                    .into())
+                    Err(CustomTransactionError::StakeAmountTooLow.into())
                 }
             }
             Some(Call::commit_crv3_weights { netuid, .. }) => {
                 if Self::check_weights_min_stake(who, *netuid) {
                     let priority: u64 = Pallet::<T>::get_priority_set_weights(who, *netuid);
-                    Ok(ValidTransaction {
+                    let validity = ValidTransaction {
                         priority,
                         longevity: 1,
                         ..Default::default()
-                    })
+                    };
+                    Ok((validity, Some(who.clone()), origin))
                 } else {
-                    Err(InvalidTransaction::Custom(
-                        CustomTransactionError::StakeAmountTooLow.into(),
-                    )
-                    .into())
+                    Err(CustomTransactionError::StakeAmountTooLow.into())
                 }
             }
             Some(Call::add_stake {
@@ -2023,11 +1991,9 @@ where
                 amount_staked,
             }) => {
                 if ColdkeySwapScheduled::<T>::contains_key(who) {
-                    return InvalidTransaction::Custom(
-                        CustomTransactionError::ColdkeyInSwapSchedule.into(),
-                    )
-                    .into();
+                    return Err(CustomTransactionError::ColdkeyInSwapSchedule.into());
                 }
+
                 // Fully validate the user input
                 Self::result_to_validity(
                     Pallet::<T>::validate_add_stake(
@@ -2039,7 +2005,7 @@ where
                         false,
                     ),
                     Self::get_priority_staking(who, hotkey, *amount_staked),
-                )
+                ).map(|validity| (validity, Some(who.clone()), origin.clone()))
             }
             Some(Call::add_stake_limit {
                 hotkey,
@@ -2049,18 +2015,12 @@ where
                 allow_partial,
             }) => {
                 if ColdkeySwapScheduled::<T>::contains_key(who) {
-                    return InvalidTransaction::Custom(
-                        CustomTransactionError::ColdkeyInSwapSchedule.into(),
-                    )
-                    .into();
+                    return Err(CustomTransactionError::ColdkeyInSwapSchedule.into());
                 }
 
                 // Calculate the maximum amount that can be executed with price limit
                 let Ok(max_amount) = Pallet::<T>::get_max_amount_add(*netuid, *limit_price) else {
-                    return InvalidTransaction::Custom(
-                        CustomTransactionError::ZeroMaxAmount.into(),
-                    )
-                    .into();
+                    return Err(CustomTransactionError::ZeroMaxAmount.into());
                 };
 
                 // Fully validate the user input
@@ -2074,7 +2034,7 @@ where
                         *allow_partial,
                     ),
                     Self::get_priority_staking(who, hotkey, *amount_staked),
-                )
+                ).map(|validity| (validity, Some(who.clone()), origin.clone()))
             }
             Some(Call::remove_stake {
                 hotkey,
@@ -2092,7 +2052,7 @@ where
                         false,
                     ),
                     Self::get_priority_staking(who, hotkey, *amount_unstaked),
-                )
+                ).map(|validity| (validity, Some(who.clone()), origin.clone()))
             }
             Some(Call::remove_stake_limit {
                 hotkey,
@@ -2104,10 +2064,7 @@ where
                 // Calculate the maximum amount that can be executed with price limit
                 let Ok(max_amount) = Pallet::<T>::get_max_amount_remove(*netuid, *limit_price)
                 else {
-                    return InvalidTransaction::Custom(
-                        CustomTransactionError::ZeroMaxAmount.into(),
-                    )
-                    .into();
+                    return Err(CustomTransactionError::ZeroMaxAmount.into());
                 };
 
                 // Fully validate the user input
@@ -2121,21 +2078,21 @@ where
                         *allow_partial,
                     ),
                     Self::get_priority_staking(who, hotkey, *amount_unstaked),
-                )
+                ).map(|validity| (validity, Some(who.clone()), origin.clone()))
             }
             Some(Call::unstake_all { hotkey }) => {
                 // Fully validate the user input
                 Self::result_to_validity(
                     Pallet::<T>::validate_unstake_all(who, hotkey, false),
                     Self::get_priority_vanilla(),
-                )
+                ).map(|validity| (validity, Some(who.clone()), origin.clone()))
             }
             Some(Call::unstake_all_alpha { hotkey }) => {
                 // Fully validate the user input
                 Self::result_to_validity(
                     Pallet::<T>::validate_unstake_all(who, hotkey, true),
                     Self::get_priority_vanilla(),
-                )
+                ).map(|validity| (validity, Some(who.clone()), origin.clone()))
             }
             Some(Call::move_stake {
                 origin_hotkey,
@@ -2145,10 +2102,7 @@ where
                 alpha_amount,
             }) => {
                 if ColdkeySwapScheduled::<T>::contains_key(who) {
-                    return InvalidTransaction::Custom(
-                        CustomTransactionError::ColdkeyInSwapSchedule.into(),
-                    )
-                    .into();
+                    return Err(CustomTransactionError::ColdkeyInSwapSchedule.into());
                 }
 
                 // Fully validate the user input
@@ -2166,7 +2120,7 @@ where
                         false,
                     ),
                     Self::get_priority_staking(who, origin_hotkey, *alpha_amount),
-                )
+                ).map(|validity| (validity, Some(who.clone()), origin.clone()))
             }
             Some(Call::transfer_stake {
                 destination_coldkey,
@@ -2176,10 +2130,7 @@ where
                 alpha_amount,
             }) => {
                 if ColdkeySwapScheduled::<T>::contains_key(who) {
-                    return InvalidTransaction::Custom(
-                        CustomTransactionError::ColdkeyInSwapSchedule.into(),
-                    )
-                    .into();
+                    return Err(CustomTransactionError::ColdkeyInSwapSchedule.into());
                 }
 
                 // Fully validate the user input
@@ -2197,7 +2148,7 @@ where
                         true,
                     ),
                     Self::get_priority_staking(who, hotkey, *alpha_amount),
-                )
+                ).map(|validity| (validity, Some(who.clone()), origin.clone()))
             }
             Some(Call::swap_stake {
                 hotkey,
@@ -2206,10 +2157,7 @@ where
                 alpha_amount,
             }) => {
                 if ColdkeySwapScheduled::<T>::contains_key(who) {
-                    return InvalidTransaction::Custom(
-                        CustomTransactionError::ColdkeyInSwapSchedule.into(),
-                    )
-                    .into();
+                    return Err(CustomTransactionError::ColdkeyInSwapSchedule.into());
                 }
 
                 // Fully validate the user input
@@ -2227,7 +2175,7 @@ where
                         false,
                     ),
                     Self::get_priority_staking(who, hotkey, *alpha_amount),
-                )
+                ).map(|validity| (validity, Some(who.clone()), origin.clone()))
             }
             Some(Call::swap_stake_limit {
                 hotkey,
@@ -2238,10 +2186,7 @@ where
                 allow_partial,
             }) => {
                 if ColdkeySwapScheduled::<T>::contains_key(who) {
-                    return InvalidTransaction::Custom(
-                        CustomTransactionError::ColdkeyInSwapSchedule.into(),
-                    )
-                    .into();
+                    return Err(CustomTransactionError::ColdkeyInSwapSchedule.into());
                 }
 
                 // Get the max amount possible to exchange
@@ -2250,10 +2195,7 @@ where
                     *destination_netuid,
                     *limit_price,
                 ) else {
-                    return InvalidTransaction::Custom(
-                        CustomTransactionError::ZeroMaxAmount.into(),
-                    )
-                    .into();
+                    return Err(CustomTransactionError::ZeroMaxAmount.into());
                 };
 
                 // Fully validate the user input
@@ -2271,14 +2213,11 @@ where
                         false,
                     ),
                     Self::get_priority_staking(who, hotkey, *alpha_amount),
-                )
+                ).map(|validity| (validity, Some(who.clone()), origin.clone()))
             }
             Some(Call::register { netuid, .. } | Call::burned_register { netuid, .. }) => {
                 if ColdkeySwapScheduled::<T>::contains_key(who) {
-                    return InvalidTransaction::Custom(
-                        CustomTransactionError::ColdkeyInSwapSchedule.into(),
-                    )
-                    .into();
+                    return Err(CustomTransactionError::ColdkeyInSwapSchedule.into());
                 }
 
                 let registrations_this_interval =
@@ -2288,29 +2227,31 @@ where
                 if registrations_this_interval >= (max_registrations_per_interval.saturating_mul(3))
                 {
                     // If the registration limit for the interval is exceeded, reject the transaction
-                    return Err(InvalidTransaction::Custom(
-                        CustomTransactionError::RateLimitExceeded.into(),
-                    )
-                    .into());
+                    return Err(CustomTransactionError::RateLimitExceeded.into());
                 }
-                Ok(ValidTransaction {
+                let validity = ValidTransaction {
                     priority: Self::get_priority_vanilla(),
                     ..Default::default()
-                })
+                };
+                Ok((validity, Some(who.clone()), origin))
+            }
+            Some(Call::register_network { .. }) => {
+                let validity = ValidTransaction {
+                    priority: Self::get_priority_vanilla(),
+                    ..Default::default()
+                };
+
+                Ok((validity, Some(who.clone()), origin))
             }
-            Some(Call::register_network { .. }) => Ok(ValidTransaction {
-                priority: Self::get_priority_vanilla(),
-                ..Default::default()
-            }),
             Some(Call::dissolve_network { .. }) => {
                 if ColdkeySwapScheduled::<T>::contains_key(who) {
-                    InvalidTransaction::Custom(CustomTransactionError::ColdkeyInSwapSchedule.into())
-                        .into()
+                    return Err(CustomTransactionError::ColdkeyInSwapSchedule.into());
                 } else {
-                    Ok(ValidTransaction {
+                    let validity = ValidTransaction {
                         priority: Self::get_priority_vanilla(),
                         ..Default::default()
-                    })
+                    };
+                    Ok((validity, Some(who.clone()), origin))
                 }
             }
             Some(Call::serve_axon {
@@ -2337,7 +2278,7 @@ where
                         *placeholder2,
                     ),
                     Self::get_priority_vanilla(),
-                )
+                ).map(|validity| (validity, Some(who.clone()), origin.clone()))
             }
             _ => {
                 if let Some(
@@ -2347,102 +2288,100 @@ where
                 ) = call.is_sub_type()
                 {
                     if ColdkeySwapScheduled::<T>::contains_key(who) {
-                        return InvalidTransaction::Custom(
-                            CustomTransactionError::ColdkeyInSwapSchedule.into(),
-                        )
-                        .into();
+                        return Err(CustomTransactionError::ColdkeyInSwapSchedule.into());
                     }
                 }
-                Ok(ValidTransaction {
+                let validity = ValidTransaction {
                     priority: Self::get_priority_vanilla(),
                     ..Default::default()
-                })
+                };
+                Ok((validity, Some(who.clone()), origin))
             }
         }
     }
 
     // NOTE: Add later when we put in a pre and post dispatch step.
-    fn pre_dispatch(
+    fn prepare(
         self,
-        who: &Self::AccountId,
-        call: &Self::Call,
-        info: &DispatchInfoOf<Self::Call>,
-        len: usize,
+        val: Self::Val,
+        _origin: &<T as frame_system::Config>::RuntimeOrigin,
+        call: &<T as frame_system::Config>::RuntimeCall,
+        _info: &DispatchInfoOf<<T as frame_system::Config>::RuntimeCall>,
+        _len: usize,
     ) -> Result<Self::Pre, TransactionValidityError> {
+        let who = match val {
+            Some(who) => who,
+            None => return Ok(None),
+        };
+
         // We need to perform same checks as Self::validate so that
         // the validation is performed during Executive::apply_extrinsic as well.
         // this prevents inclusion of invalid tx in a block by malicious block author.
-        self.validate(who, call, info, len)?;
+        // self.validate(who, call, info, len)?;
         match call.is_sub_type() {
             Some(Call::add_stake { .. }) => {
-                let transaction_fee = 100000;
-                Ok((CallType::AddStake, transaction_fee, who.clone()))
+                Ok(Some(CallType::AddStake))
             }
             Some(Call::remove_stake { .. }) => {
-                let transaction_fee = 0;
-                Ok((CallType::RemoveStake, transaction_fee, who.clone()))
+                Ok(Some(CallType::RemoveStake))
             }
             Some(Call::set_weights { .. }) => {
-                let transaction_fee = 0;
-                Ok((CallType::SetWeights, transaction_fee, who.clone()))
+                Ok(Some(CallType::SetWeights))
             }
             Some(Call::commit_weights { .. }) => {
-                let transaction_fee = 0;
-                Ok((CallType::SetWeights, transaction_fee, who.clone()))
+                Ok(Some(CallType::SetWeights))
             }
             Some(Call::reveal_weights { .. }) => {
-                let transaction_fee = 0;
-                Ok((CallType::SetWeights, transaction_fee, who.clone()))
+                Ok(Some(CallType::SetWeights))
             }
             Some(Call::register { .. }) => {
-                let transaction_fee = 0;
-                Ok((CallType::Register, transaction_fee, who.clone()))
+                Ok(Some(CallType::Register))
             }
             Some(Call::serve_axon { .. }) => {
-                let transaction_fee = 0;
-                Ok((CallType::Serve, transaction_fee, who.clone()))
+                Ok(Some(CallType::Serve))
             }
             Some(Call::serve_axon_tls { .. }) => {
-                let transaction_fee = 0;
-                Ok((CallType::Serve, transaction_fee, who.clone()))
+                Ok(Some(CallType::Serve))
             }
             Some(Call::register_network { .. }) => {
-                let transaction_fee = 0;
-                Ok((CallType::RegisterNetwork, transaction_fee, who.clone()))
+                Ok(Some(CallType::RegisterNetwork))
             }
             _ => {
-                let transaction_fee = 0;
-                Ok((CallType::Other, transaction_fee, who.clone()))
+                Ok(Some(CallType::Other))
             }
         }
     }
 
     fn post_dispatch(
-        maybe_pre: Option<Self::Pre>,
-        _info: &DispatchInfoOf<Self::Call>,
-        _post_info: &PostDispatchInfoOf<Self::Call>,
+        pre: Self::Pre,
+        _info: &DispatchInfoOf<<T as frame_system::Config>::RuntimeCall>,
+        _post_info: &mut PostDispatchInfoOf<<T as frame_system::Config>::RuntimeCall>,
         _len: usize,
         _result: &dispatch::DispatchResult,
     ) -> Result<(), TransactionValidityError> {
-        if let Some((call_type, _transaction_fee, _who)) = maybe_pre {
-            match call_type {
-                CallType::SetWeights => {
-                    log::debug!("Not Implemented!");
-                }
-                CallType::AddStake => {
-                    log::debug!("Not Implemented! Need to add potential transaction fees here.");
-                }
-                CallType::RemoveStake => {
-                    log::debug!("Not Implemented! Need to add potential transaction fees here.");
-                }
-                CallType::Register => {
-                    log::debug!("Not Implemented!");
-                }
-                _ => {
-                    log::debug!("Not Implemented!");
-                }
+        let call_type = match pre {
+            Some(call_type) => call_type,
+            None => return Ok(()),
+        };
+
+        match call_type {
+            CallType::SetWeights => {
+                log::debug!("Not Implemented!");
+            }
+            CallType::AddStake => {
+                log::debug!("Not Implemented! Need to add potential transaction fees here.");
+            }
+            CallType::RemoveStake => {
+                log::debug!("Not Implemented! Need to add potential transaction fees here.");
+            }
+            CallType::Register => {
+                log::debug!("Not Implemented!");
+            }
+            _ => {
+                log::debug!("Not Implemented!");
             }
         }
+
         Ok(())
     }
 }
diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index cfc594a966..76cba1503b 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -149,7 +149,7 @@ impl frame_system::offchain::CreateSignedTransaction<pallet_drand::Call<Runtime>
             check_nonce::CheckNonce::<Runtime>::from(nonce).into(),
             frame_system::CheckWeight::<Runtime>::new(),
             pallet_transaction_payment::ChargeTransactionPayment::<Runtime>::from(0),
-            pallet_subtensor::SubtensorSignedExtension::<Runtime>::new().into(),
+            pallet_subtensor::SubtensorTransactionExtension::<Runtime>::new(),
             pallet_commitments::CommitmentsSignedExtension::<Runtime>::new().into(),
             frame_metadata_hash_extension::CheckMetadataHash::<Runtime>::new(true),
         );
@@ -1581,7 +1581,7 @@ pub type SignedExtra = (
     AsTransactionExtension<check_nonce::CheckNonce<Runtime>>,
     frame_system::CheckWeight<Runtime>,
     pallet_transaction_payment::ChargeTransactionPayment<Runtime>,
-    AsTransactionExtension<pallet_subtensor::SubtensorSignedExtension<Runtime>>,
+    pallet_subtensor::SubtensorTransactionExtension<Runtime>,
     AsTransactionExtension<pallet_commitments::CommitmentsSignedExtension<Runtime>>,
     frame_metadata_hash_extension::CheckMetadataHash<Runtime>,
 );

From 21c31bcb3ec6c0172d5851b1a8087971cade91d2 Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Wed, 11 Jun 2025 02:12:01 +0200
Subject: [PATCH 293/418] addd comment

---
 pallets/subtensor/src/lib.rs | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/pallets/subtensor/src/lib.rs b/pallets/subtensor/src/lib.rs
index 7ab6d0bf71..9214ca2396 100644
--- a/pallets/subtensor/src/lib.rs
+++ b/pallets/subtensor/src/lib.rs
@@ -1902,6 +1902,7 @@ where
         _inherited_implication: &impl Implication,
         _source: TransactionSource,
     ) -> ValidateResult<Self::Val, <T as frame_system::Config>::RuntimeCall> {
+        // Ensure the transaction is signed, else we just skip the extension.
         let Some(who) = origin.as_system_origin_signer() else {
             return Ok((Default::default(), None, origin));
         };
@@ -2309,15 +2310,11 @@ where
         _info: &DispatchInfoOf<<T as frame_system::Config>::RuntimeCall>,
         _len: usize,
     ) -> Result<Self::Pre, TransactionValidityError> {
-        let who = match val {
-            Some(who) => who,
-            None => return Ok(None),
-        };
+        // The transaction is not signed, given val is None, so we just skip this step.
+        if let None = val {
+            return Ok(None);
+        }
 
-        // We need to perform same checks as Self::validate so that
-        // the validation is performed during Executive::apply_extrinsic as well.
-        // this prevents inclusion of invalid tx in a block by malicious block author.
-        // self.validate(who, call, info, len)?;
         match call.is_sub_type() {
             Some(Call::add_stake { .. }) => {
                 Ok(Some(CallType::AddStake))
@@ -2359,6 +2356,7 @@ where
         _len: usize,
         _result: &dispatch::DispatchResult,
     ) -> Result<(), TransactionValidityError> {
+        // Skip this step if the transaction is not signed, meaning pre is None.
         let call_type = match pre {
             Some(call_type) => call_type,
             None => return Ok(()),

From 26fbbef9372ee68c4e3249e03e99e00708689932 Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Wed, 11 Jun 2025 02:20:23 +0200
Subject: [PATCH 294/418] fix deprecated macro for runtime str

---
 runtime/src/lib.rs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index 76cba1503b..668e7344a2 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -13,6 +13,7 @@ mod migrations;
 
 use codec::{Compact, Decode, Encode};
 use frame_support::traits::{Imbalance, InsideBoth};
+use sp_runtime::Cow;
 use frame_support::{
     PalletId,
     dispatch::DispatchResultWithPostInfo,
@@ -49,7 +50,7 @@ use sp_core::{
 };
 use sp_runtime::generic::Era;
 use sp_runtime::{
-    AccountId32, ApplyExtrinsicResult, ConsensusEngineId, create_runtime_str, generic,
+    AccountId32, ApplyExtrinsicResult, ConsensusEngineId, generic,
     impl_opaque_keys,
     traits::transaction_extension::AsTransactionExtension,
     traits::{
@@ -207,8 +208,8 @@ pub mod opaque {
 // https://docs.substrate.io/main-docs/build/upgrade#runtime-versioning
 #[sp_version::runtime_version]
 pub const VERSION: RuntimeVersion = RuntimeVersion {
-    spec_name: create_runtime_str!("node-subtensor"),
-    impl_name: create_runtime_str!("node-subtensor"),
+    spec_name: Cow::Borrowed("node-subtensor"),
+    impl_name: Cow::Borrowed("node-subtensor"),
     authoring_version: 1,
     // The version of the runtime specification. A full node will not attempt to use its native
     //   runtime in substitute for the on-chain Wasm runtime unless all of `spec_name`,

From 636d21b18c74e2422423aefbca7054447ebfeca6 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Wed, 11 Jun 2025 09:29:07 +0800
Subject: [PATCH 295/418] update doc for toggle transfer function

---
 pallets/subtensor/src/staking/move_stake.rs | 32 ++++++++++++++-------
 1 file changed, 22 insertions(+), 10 deletions(-)

diff --git a/pallets/subtensor/src/staking/move_stake.rs b/pallets/subtensor/src/staking/move_stake.rs
index ef576f3607..a7af8af206 100644
--- a/pallets/subtensor/src/staking/move_stake.rs
+++ b/pallets/subtensor/src/staking/move_stake.rs
@@ -72,6 +72,28 @@ impl<T: Config> Pallet<T> {
         Ok(())
     }
 
+    /// Toggles the stake moving functionality for a specific subnet.
+    ///
+    /// # Arguments
+    /// * `netuid` - The network ID (subnet) for which the transfer functionality is being toggled.
+    /// * `toggle` - A boolean value indicating whether to enable (true) or disable (false) transfers.
+    ///
+    /// # Returns
+    /// * `DispatchResult` - Indicates success or failure of the operation.
+    ///
+    /// # Events
+    /// Emits a `TransferToggle` event upon successful completion.
+    pub fn toggle_transfer(netuid: u16, toggle: bool) -> dispatch::DispatchResult {
+        TransferToggle::<T>::insert(netuid, toggle);
+        log::debug!(
+            "TransferToggle( netuid: {:?}, toggle: {:?} ) ",
+            netuid,
+            toggle
+        );
+        Self::deposit_event(Event::TransferToggle(netuid, toggle));
+        Ok(())
+    }
+
     /// Transfers stake from one coldkey to another, optionally moving from one subnet to another,
     /// while keeping the same hotkey.
     ///
@@ -97,16 +119,6 @@ impl<T: Config> Pallet<T> {
     ///
     /// # Events
     /// Emits a `StakeTransferred` event upon successful completion of the transfer.
-    pub fn toggle_transfer(netuid: u16, toggle: bool) -> dispatch::DispatchResult {
-        TransferToggle::<T>::insert(netuid, toggle);
-        log::debug!(
-            "TransferToggle( netuid: {:?}, toggle: {:?} ) ",
-            netuid,
-            toggle
-        );
-        Self::deposit_event(Event::TransferToggle(netuid, toggle));
-        Ok(())
-    }
     pub fn do_transfer_stake(
         origin: T::RuntimeOrigin,
         destination_coldkey: T::AccountId,

From d38f635c1bcdcbd282e9041f8ac841ab2da54c0c Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Wed, 11 Jun 2025 09:30:01 +0800
Subject: [PATCH 296/418] update doc

---
 pallets/admin-utils/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pallets/admin-utils/src/lib.rs b/pallets/admin-utils/src/lib.rs
index 2b41539816..feac8a5560 100644
--- a/pallets/admin-utils/src/lib.rs
+++ b/pallets/admin-utils/src/lib.rs
@@ -1415,7 +1415,7 @@ pub mod pallet {
             T::Grandpa::schedule_change(next_authorities, in_blocks, forced)
         }
 
-        /// Enables or disables Liquid Alpha for a given subnet.
+        /// Enables or disables all stake moving related extrinsics for a given subnet.
         ///
         /// # Parameters
         /// - `origin`: The origin of the call, which must be the root account or subnet owner.

From 074916e5d594f98d4fa54359416a9e804f3b6a12 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Wed, 11 Jun 2025 09:45:52 +0800
Subject: [PATCH 297/418] update doc

---
 pallets/admin-utils/src/lib.rs              | 2 +-
 pallets/subtensor/src/staking/move_stake.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/pallets/admin-utils/src/lib.rs b/pallets/admin-utils/src/lib.rs
index feac8a5560..ec71e2faa4 100644
--- a/pallets/admin-utils/src/lib.rs
+++ b/pallets/admin-utils/src/lib.rs
@@ -1415,7 +1415,7 @@ pub mod pallet {
             T::Grandpa::schedule_change(next_authorities, in_blocks, forced)
         }
 
-        /// Enables or disables all stake moving related extrinsics for a given subnet.
+        /// Enable or disable atomic alpha transfers for a given subnet.
         ///
         /// # Parameters
         /// - `origin`: The origin of the call, which must be the root account or subnet owner.
diff --git a/pallets/subtensor/src/staking/move_stake.rs b/pallets/subtensor/src/staking/move_stake.rs
index a7af8af206..d743fb7a18 100644
--- a/pallets/subtensor/src/staking/move_stake.rs
+++ b/pallets/subtensor/src/staking/move_stake.rs
@@ -72,7 +72,7 @@ impl<T: Config> Pallet<T> {
         Ok(())
     }
 
-    /// Toggles the stake moving functionality for a specific subnet.
+    /// Toggles the atomic alpha transfers for a specific subnet.
     ///
     /// # Arguments
     /// * `netuid` - The network ID (subnet) for which the transfer functionality is being toggled.

From 220742fa407ed22d742d29df1527abb648e00245 Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Wed, 11 Jun 2025 14:55:20 +0200
Subject: [PATCH 298/418] fix tests

---
 node/src/benchmarking.rs                    |   2 +-
 pallets/subtensor/src/tests/move_stake.rs   |  69 ++++--
 pallets/subtensor/src/tests/registration.rs |  80 +++++--
 pallets/subtensor/src/tests/serving.rs      |  35 ++-
 pallets/subtensor/src/tests/staking.rs      | 150 ++++++++-----
 pallets/subtensor/src/tests/swap_coldkey.rs | 230 +++++++++++++-------
 pallets/subtensor/src/tests/weights.rs      | 151 ++++++++++---
 7 files changed, 507 insertions(+), 210 deletions(-)

diff --git a/node/src/benchmarking.rs b/node/src/benchmarking.rs
index 7fabad6b3b..5476e22266 100644
--- a/node/src/benchmarking.rs
+++ b/node/src/benchmarking.rs
@@ -135,7 +135,7 @@ pub fn create_benchmark_extrinsic(
         check_nonce::CheckNonce::<runtime::Runtime>::from(nonce).into(),
         frame_system::CheckWeight::<runtime::Runtime>::new(),
         pallet_transaction_payment::ChargeTransactionPayment::<runtime::Runtime>::from(0),
-        pallet_subtensor::SubtensorSignedExtension::<runtime::Runtime>::new().into(),
+        pallet_subtensor::SubtensorTransactionExtension::<runtime::Runtime>::new().into(),
         pallet_commitments::CommitmentsSignedExtension::<runtime::Runtime>::new().into(),
         frame_metadata_hash_extension::CheckMetadataHash::<runtime::Runtime>::new(true),
     );
diff --git a/pallets/subtensor/src/tests/move_stake.rs b/pallets/subtensor/src/tests/move_stake.rs
index dd85ab9075..ebfbc6b405 100644
--- a/pallets/subtensor/src/tests/move_stake.rs
+++ b/pallets/subtensor/src/tests/move_stake.rs
@@ -2,6 +2,8 @@ use super::mock::*;
 use crate::*;
 use approx::assert_abs_diff_eq;
 use frame_support::{assert_err, assert_noop, assert_ok};
+use frame_system::RawOrigin;
+use sp_runtime::traits::TxBaseImplication;
 use sp_core::{Get, U256};
 use substrate_fixed::types::{U64F64, U96F32};
 
@@ -1562,16 +1564,21 @@ fn test_swap_stake_limit_validate() {
         let info: crate::DispatchInfo =
             crate::DispatchInfoOf::<<Test as frame_system::Config>::RuntimeCall>::default();
 
-        let extension = crate::SubtensorSignedExtension::<Test>::new();
+        let extension = crate::SubtensorTransactionExtension::<Test>::new();
         // Submit to the signed extension validate function
-        let result_no_stake = extension.validate(&coldkey, &call.clone(), &info, 10);
+        let result_no_stake = extension.validate(
+            RawOrigin::Signed(coldkey).into(), &call.clone(), 
+            &info, 
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
 
         // Should fail due to slippage
-        assert_err!(
-            result_no_stake,
-            crate::TransactionValidityError::Invalid(crate::InvalidTransaction::Custom(
-                CustomTransactionError::SlippageTooHigh.into()
-            ))
+        assert_eq!(
+            result_no_stake.unwrap_err(),
+            CustomTransactionError::SlippageTooHigh.into()
         );
     });
 }
@@ -1608,19 +1615,25 @@ fn test_stake_transfers_disabled_validate() {
         let info: crate::DispatchInfo =
             crate::DispatchInfoOf::<<Test as frame_system::Config>::RuntimeCall>::default();
 
-        let extension = crate::SubtensorSignedExtension::<Test>::new();
+        let extension = crate::SubtensorTransactionExtension::<Test>::new();
 
         // Disable transfers in origin subnet
         TransferToggle::<Test>::insert(origin_netuid, false);
         TransferToggle::<Test>::insert(destination_netuid, true);
 
         // Submit to the signed extension validate function
-        let result1 = extension.validate(&coldkey, &call.clone(), &info, 10);
-        assert_err!(
-            result1,
-            crate::TransactionValidityError::Invalid(crate::InvalidTransaction::Custom(
-                CustomTransactionError::TransferDisallowed.into()
-            ))
+        let result1 = extension.validate(
+            RawOrigin::Signed(coldkey).into(), 
+            &call.clone(), 
+            &info, 
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
+        assert_eq!(
+            result1.unwrap_err(),
+            CustomTransactionError::TransferDisallowed.into()
         );
 
         // Disable transfers in destination subnet
@@ -1628,12 +1641,18 @@ fn test_stake_transfers_disabled_validate() {
         TransferToggle::<Test>::insert(destination_netuid, false);
 
         // Submit to the signed extension validate function
-        let result2 = extension.validate(&coldkey, &call.clone(), &info, 10);
-        assert_err!(
-            result2,
-            crate::TransactionValidityError::Invalid(crate::InvalidTransaction::Custom(
-                CustomTransactionError::TransferDisallowed.into()
-            ))
+        let result2 = extension.validate(
+            RawOrigin::Signed(coldkey).into(), 
+            &call.clone(), 
+            &info, 
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
+        assert_eq!(
+            result2.unwrap_err(),
+            CustomTransactionError::TransferDisallowed.into()
         );
 
         // Enable transfers
@@ -1641,7 +1660,15 @@ fn test_stake_transfers_disabled_validate() {
         TransferToggle::<Test>::insert(destination_netuid, true);
 
         // Submit to the signed extension validate function
-        let result3 = extension.validate(&coldkey, &call.clone(), &info, 10);
+        let result3 = extension.validate(
+            RawOrigin::Signed(coldkey).into(), 
+            &call.clone(), 
+            &info, 
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
         assert_ok!(result3);
     });
 }
diff --git a/pallets/subtensor/src/tests/registration.rs b/pallets/subtensor/src/tests/registration.rs
index c50c103f8b..34842005df 100644
--- a/pallets/subtensor/src/tests/registration.rs
+++ b/pallets/subtensor/src/tests/registration.rs
@@ -4,13 +4,13 @@ use approx::assert_abs_diff_eq;
 use frame_support::traits::Currency;
 
 use super::mock::*;
-use crate::{AxonInfoOf, CustomTransactionError, Error, SubtensorSignedExtension};
+use crate::{AxonInfoOf, CustomTransactionError, Error, SubtensorTransactionExtension};
 use frame_support::dispatch::{DispatchClass, DispatchInfo, GetDispatchInfo, Pays};
-use frame_support::sp_runtime::{DispatchError, transaction_validity::InvalidTransaction};
+use frame_support::sp_runtime::{DispatchError, transaction_validity::TransactionSource};
 use frame_support::{assert_err, assert_noop, assert_ok};
-use frame_system::Config;
+use frame_system::{Config, RawOrigin};
 use sp_core::U256;
-use sp_runtime::traits::{DispatchInfoOf, SignedExtension};
+use sp_runtime::traits::{DispatchInfoOf, TxBaseImplication, TransactionExtension};
 
 /********************************************
     subscribing::subscribe() tests
@@ -219,9 +219,17 @@ fn test_registration_under_limit() {
         };
         let info: DispatchInfo =
             DispatchInfoOf::<<Test as frame_system::Config>::RuntimeCall>::default();
-        let extension = SubtensorSignedExtension::<Test>::new();
+        let extension = SubtensorTransactionExtension::<Test>::new();
         //does not actually call register
-        let result = extension.validate(&who, &call.into(), &info, 10);
+        let result = extension.validate(
+            RawOrigin::Signed(who).into(), 
+            &call.into(), 
+            &info, 
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
         assert_ok!(result);
 
         //actually call register
@@ -272,13 +280,21 @@ fn test_registration_rate_limit_exceeded() {
         };
         let info: DispatchInfo =
             DispatchInfoOf::<<Test as frame_system::Config>::RuntimeCall>::default();
-        let extension = SubtensorSignedExtension::<Test>::new();
-        let result = extension.validate(&who, &call.into(), &info, 10);
+        let extension = SubtensorTransactionExtension::<Test>::new();
+        let result = extension.validate(
+            RawOrigin::Signed(who).into(), 
+            &call.into(), 
+            &info, 
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
 
         // Expectation: The transaction should be rejected
-        assert_err!(
-            result,
-            InvalidTransaction::Custom(CustomTransactionError::RateLimitExceeded.into())
+        assert_eq!(
+            result.unwrap_err(),
+            CustomTransactionError::RateLimitExceeded.into()
         );
 
         let current_registrants = SubtensorModule::get_registrations_this_interval(netuid);
@@ -316,10 +332,18 @@ fn test_burned_registration_under_limit() {
 
         let info: DispatchInfo =
             DispatchInfoOf::<<Test as frame_system::Config>::RuntimeCall>::default();
-        let extension = SubtensorSignedExtension::<Test>::new();
+        let extension = SubtensorTransactionExtension::<Test>::new();
         //does not actually call register
         let burned_register_result =
-            extension.validate(&who, &call_burned_register.into(), &info, 10);
+            extension.validate(
+                RawOrigin::Signed(who).into(), 
+                &call_burned_register.into(), 
+                &info, 
+                10,
+                (),
+                &TxBaseImplication(()),
+                TransactionSource::External,
+            );
         assert_ok!(burned_register_result);
 
         //actually call register
@@ -356,14 +380,22 @@ fn test_burned_registration_rate_limit_exceeded() {
 
         let info: DispatchInfo =
             DispatchInfoOf::<<Test as frame_system::Config>::RuntimeCall>::default();
-        let extension = SubtensorSignedExtension::<Test>::new();
+        let extension = SubtensorTransactionExtension::<Test>::new();
         let burned_register_result =
-            extension.validate(&who, &call_burned_register.into(), &info, 10);
+            extension.validate(
+                RawOrigin::Signed(who).into(), 
+                &call_burned_register.into(), 
+                &info, 
+                10,
+                (),
+                &TxBaseImplication(()),
+                TransactionSource::External,
+            );
 
         // Expectation: The transaction should be rejected
-        assert_err!(
-            burned_register_result,
-            InvalidTransaction::Custom(CustomTransactionError::RateLimitExceeded.into())
+        assert_eq!(
+            burned_register_result.unwrap_err(),
+            CustomTransactionError::RateLimitExceeded.into()
         );
 
         let current_registrants = SubtensorModule::get_registrations_this_interval(netuid);
@@ -401,10 +433,18 @@ fn test_burned_registration_rate_allows_burn_adjustment() {
 
         let info: DispatchInfo =
             DispatchInfoOf::<<Test as frame_system::Config>::RuntimeCall>::default();
-        let extension = SubtensorSignedExtension::<Test>::new();
+        let extension = SubtensorTransactionExtension::<Test>::new();
         //does not actually call register
         let burned_register_result =
-            extension.validate(&who, &call_burned_register.into(), &info, 10);
+            extension.validate(
+                RawOrigin::Signed(who).into(), 
+                &call_burned_register.into(), 
+                &info, 
+                10,
+                (),
+                &TxBaseImplication(()),
+                TransactionSource::External,
+            );
         assert_ok!(burned_register_result);
 
         //actually call register
diff --git a/pallets/subtensor/src/tests/serving.rs b/pallets/subtensor/src/tests/serving.rs
index d01d6e5536..260ee0c6c9 100644
--- a/pallets/subtensor/src/tests/serving.rs
+++ b/pallets/subtensor/src/tests/serving.rs
@@ -3,13 +3,14 @@ use super::mock::*;
 use crate::Error;
 use crate::*;
 use frame_support::pallet_prelude::Weight;
-use frame_support::{assert_err, assert_noop};
+use frame_support::assert_noop;
 use frame_support::{
     assert_ok,
     dispatch::{DispatchClass, DispatchInfo, GetDispatchInfo, Pays},
 };
-use frame_system::Config;
+use frame_system::{Config, RawOrigin};
 use sp_core::U256;
+use sp_runtime::traits::TxBaseImplication;
 
 mod test {
     use std::net::{Ipv4Addr, Ipv6Addr};
@@ -1336,16 +1337,22 @@ fn test_serve_axon_validate() {
         let info: crate::DispatchInfo =
             crate::DispatchInfoOf::<<Test as frame_system::Config>::RuntimeCall>::default();
 
-        let extension = crate::SubtensorSignedExtension::<Test>::new();
+        let extension = crate::SubtensorTransactionExtension::<Test>::new();
         // Submit to the signed extension validate function
-        let result_bad = extension.validate(&hotkey, &call.clone(), &info, 10);
+        let result_bad = extension.validate(
+            RawOrigin::Signed(hotkey).into(), 
+            &call.clone(), 
+            &info, 
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
 
         // Should fail due to insufficient stake
-        assert_err!(
-            result_bad,
-            crate::TransactionValidityError::Invalid(crate::InvalidTransaction::Custom(
-                CustomTransactionError::HotKeyNotRegisteredInNetwork.into()
-            ))
+        assert_eq!(
+            result_bad.unwrap_err(),
+            CustomTransactionError::HotKeyNotRegisteredInNetwork.into()
         );
 
         // Register the hotkey in the subnet and try again
@@ -1354,7 +1361,15 @@ fn test_serve_axon_validate() {
         register_ok_neuron(netuid, hotkey, coldkey, 0);
 
         // Submit to the signed extension validate function
-        let result_ok = extension.validate(&hotkey, &call.clone(), &info, 10);
+        let result_ok = extension.validate(
+            RawOrigin::Signed(hotkey).into(), 
+            &call.clone(), 
+            &info, 
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
 
         // Now the call passes
         assert_ok!(result_ok);
diff --git a/pallets/subtensor/src/tests/staking.rs b/pallets/subtensor/src/tests/staking.rs
index a030f243d4..a09bb47754 100644
--- a/pallets/subtensor/src/tests/staking.rs
+++ b/pallets/subtensor/src/tests/staking.rs
@@ -10,7 +10,7 @@ use super::mock::*;
 use crate::*;
 use approx::assert_abs_diff_eq;
 use frame_support::dispatch::{DispatchClass, DispatchInfo, GetDispatchInfo, Pays};
-use frame_support::sp_runtime::DispatchError;
+use frame_support::sp_runtime::{DispatchError, transaction_validity::TransactionSource, traits::TxBaseImplication};
 use sp_core::{Get, H256, U256};
 use substrate_fixed::types::{I96F32, I110F18, U64F64, U96F32};
 /***********************************************************
@@ -2532,16 +2532,22 @@ fn test_stake_below_min_validate() {
         let info: DispatchInfo =
             DispatchInfoOf::<<Test as frame_system::Config>::RuntimeCall>::default();
 
-        let extension = SubtensorSignedExtension::<Test>::new();
+        let extension = SubtensorTransactionExtension::<Test>::new();
         // Submit to the signed extension validate function
-        let result_no_stake = extension.validate(&coldkey, &call.clone(), &info, 10);
+        let result_no_stake = extension.validate(
+            RawOrigin::Signed(coldkey).into(), 
+            &call.clone(), 
+            &info, 
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
 
         // Should fail due to insufficient stake
-        assert_err!(
-            result_no_stake,
-            TransactionValidityError::Invalid(InvalidTransaction::Custom(
-                CustomTransactionError::StakeAmountTooLow.into()
-            ))
+        assert_eq!(
+            result_no_stake.unwrap_err(),
+            CustomTransactionError::StakeAmountTooLow.into()
         );
 
         // Increase the stake to be equal to the minimum, but leave the balance low
@@ -2553,21 +2559,35 @@ fn test_stake_below_min_validate() {
         });
 
         // Submit to the signed extension validate function
-        let result_low_balance = extension.validate(&coldkey, &call_2.clone(), &info, 10);
+        let result_low_balance = extension.validate(
+            RawOrigin::Signed(coldkey).into(), 
+            &call_2.clone(), 
+            &info, 
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
 
         // Still doesn't pass, but with a different reason (balance too low)
-        assert_err!(
-            result_low_balance,
-            TransactionValidityError::Invalid(InvalidTransaction::Custom(
-                CustomTransactionError::BalanceTooLow.into()
-            ))
+        assert_eq!(
+            result_low_balance.unwrap_err(),
+            CustomTransactionError::BalanceTooLow.into()
         );
 
         // Increase the coldkey balance to match the minimum
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, 1);
 
         // Submit to the signed extension validate function
-        let result_min_stake = extension.validate(&coldkey, &call_2.clone(), &info, 10);
+        let result_min_stake = extension.validate(
+            RawOrigin::Signed(coldkey).into(), 
+            &call_2.clone(), 
+            &info, 
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
 
         // Now the call passes
         assert_ok!(result_min_stake);
@@ -2615,16 +2635,22 @@ fn test_add_stake_limit_validate() {
         let info: DispatchInfo =
             DispatchInfoOf::<<Test as frame_system::Config>::RuntimeCall>::default();
 
-        let extension = SubtensorSignedExtension::<Test>::new();
+        let extension = SubtensorTransactionExtension::<Test>::new();
         // Submit to the signed extension validate function
-        let result_no_stake = extension.validate(&coldkey, &call.clone(), &info, 10);
+        let result_no_stake = extension.validate(
+            RawOrigin::Signed(coldkey).into(), 
+            &call.clone(), 
+            &info, 
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
 
         // Should fail due to slippage
-        assert_err!(
-            result_no_stake,
-            TransactionValidityError::Invalid(InvalidTransaction::Custom(
-                CustomTransactionError::SlippageTooHigh.into()
-            ))
+        assert_eq!(
+            result_no_stake.unwrap_err(),
+            CustomTransactionError::SlippageTooHigh.into()
         );
     });
 }
@@ -2675,16 +2701,22 @@ fn test_remove_stake_limit_validate() {
         let info: DispatchInfo =
             DispatchInfoOf::<<Test as frame_system::Config>::RuntimeCall>::default();
 
-        let extension = SubtensorSignedExtension::<Test>::new();
+        let extension = SubtensorTransactionExtension::<Test>::new();
         // Submit to the signed extension validate function
-        let result_no_stake = extension.validate(&coldkey, &call.clone(), &info, 10);
+        let result_no_stake = extension.validate(
+            RawOrigin::Signed(coldkey).into(), 
+            &call.clone(), 
+            &info, 
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
 
         // Should fail due to slippage
-        assert_err!(
-            result_no_stake,
-            TransactionValidityError::Invalid(InvalidTransaction::Custom(
-                CustomTransactionError::SlippageTooHigh.into()
-            ))
+        assert_eq!(
+            result_no_stake.unwrap_err(),
+            CustomTransactionError::SlippageTooHigh.into()
         );
     });
 }
@@ -2768,16 +2800,22 @@ fn test_stake_low_liquidity_validate() {
         let info: DispatchInfo =
             DispatchInfoOf::<<Test as frame_system::Config>::RuntimeCall>::default();
 
-        let extension = SubtensorSignedExtension::<Test>::new();
+        let extension = SubtensorTransactionExtension::<Test>::new();
         // Submit to the signed extension validate function
-        let result_no_stake = extension.validate(&coldkey, &call.clone(), &info, 10);
+        let result_no_stake = extension.validate(
+            RawOrigin::Signed(coldkey).into(), 
+            &call.clone(), 
+            &info, 
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
 
         // Should fail due to insufficient stake
-        assert_err!(
-            result_no_stake,
-            TransactionValidityError::Invalid(InvalidTransaction::Custom(
-                CustomTransactionError::InsufficientLiquidity.into()
-            ))
+        assert_eq!(
+            result_no_stake.unwrap_err(),
+            CustomTransactionError::InsufficientLiquidity.into()
         );
     });
 }
@@ -2823,16 +2861,22 @@ fn test_unstake_low_liquidity_validate() {
         let info: DispatchInfo =
             DispatchInfoOf::<<Test as frame_system::Config>::RuntimeCall>::default();
 
-        let extension = SubtensorSignedExtension::<Test>::new();
+        let extension = SubtensorTransactionExtension::<Test>::new();
         // Submit to the signed extension validate function
-        let result_no_stake = extension.validate(&coldkey, &call.clone(), &info, 10);
+        let result_no_stake = extension.validate(
+            RawOrigin::Signed(coldkey).into(), 
+            &call.clone(), 
+            &info, 
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
 
         // Should fail due to insufficient stake
-        assert_err!(
-            result_no_stake,
-            TransactionValidityError::Invalid(InvalidTransaction::Custom(
-                CustomTransactionError::InsufficientLiquidity.into()
-            ))
+        assert_eq!(
+            result_no_stake.unwrap_err(),
+            CustomTransactionError::InsufficientLiquidity.into()
         );
     });
 }
@@ -2874,16 +2918,22 @@ fn test_unstake_all_validate() {
         let info: DispatchInfo =
             DispatchInfoOf::<<Test as frame_system::Config>::RuntimeCall>::default();
 
-        let extension = SubtensorSignedExtension::<Test>::new();
+        let extension = SubtensorTransactionExtension::<Test>::new();
         // Submit to the signed extension validate function
-        let result_no_stake = extension.validate(&coldkey, &call.clone(), &info, 10);
+        let result_no_stake = extension.validate(
+            RawOrigin::Signed(coldkey).into(), 
+            &call.clone(), 
+            &info, 
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
 
         // Should fail due to insufficient stake
-        assert_err!(
-            result_no_stake,
-            TransactionValidityError::Invalid(InvalidTransaction::Custom(
-                CustomTransactionError::StakeAmountTooLow.into()
-            ))
+        assert_eq!(
+            result_no_stake.unwrap_err(),
+            CustomTransactionError::StakeAmountTooLow.into()
         );
     });
 }
diff --git a/pallets/subtensor/src/tests/swap_coldkey.rs b/pallets/subtensor/src/tests/swap_coldkey.rs
index 385830904c..efea978eb9 100644
--- a/pallets/subtensor/src/tests/swap_coldkey.rs
+++ b/pallets/subtensor/src/tests/swap_coldkey.rs
@@ -13,7 +13,7 @@ use frame_support::traits::OnInitialize;
 use frame_support::traits::schedule::DispatchTime;
 use frame_support::traits::schedule::v3::Named as ScheduleNamed;
 use sp_core::{Get, H256, U256};
-use sp_runtime::DispatchError;
+use sp_runtime::{DispatchError, traits::TxBaseImplication};
 use substrate_fixed::types::U96F32;
 
 // // SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_coldkey -- test_swap_total_hotkey_coldkey_stakes_this_interval --exact --nocapture
@@ -1799,7 +1799,7 @@ fn test_schedule_swap_coldkey_execution() {
         run_to_block(execution_block);
 
         // Run on_initialize for the execution block
-        SubtensorModule::on_initialize(execution_block);
+        <SubtensorModule as OnInitialize<BlockNumber>>::on_initialize(execution_block);
 
         // Also run Scheduler's on_initialize
         <pallet_scheduler::Pallet<Test> as OnInitialize<BlockNumber>>::on_initialize(
@@ -2168,7 +2168,7 @@ fn test_coldkey_in_swap_schedule_prevents_funds_usage() {
         // Setup the extension
         let info: crate::DispatchInfo =
             crate::DispatchInfoOf::<<Test as frame_system::Config>::RuntimeCall>::default();
-        let extension = crate::SubtensorSignedExtension::<Test>::new();
+        let extension = crate::SubtensorTransactionExtension::<Test>::new();
 
         // Try each call
 
@@ -2178,15 +2178,21 @@ fn test_coldkey_in_swap_schedule_prevents_funds_usage() {
             netuid,
             amount_staked: 100_000_000_000,
         });
-        let result: Result<ValidTransaction, TransactionValidityError> =
-            extension.validate(&who, &call.clone(), &info, 10);
+        let result =
+            extension.validate(
+                RawOrigin::Signed(who).into(), 
+                &call.clone(), 
+                &info, 
+                10,
+                (),
+                &TxBaseImplication(()),
+                TransactionSource::External,
+            );
         // Should fail
-        assert_err!(
+        assert_eq!(
             // Should get an invalid transaction error
-            result,
-            crate::TransactionValidityError::Invalid(crate::InvalidTransaction::Custom(
-                CustomTransactionError::ColdkeyInSwapSchedule.into()
-            ))
+            result.unwrap_err(),
+            CustomTransactionError::ColdkeyInSwapSchedule.into()
         );
 
         // Add stake limit
@@ -2197,14 +2203,20 @@ fn test_coldkey_in_swap_schedule_prevents_funds_usage() {
             limit_price: 100_000_000_000,
             allow_partial: false,
         });
-        let result = extension.validate(&who, &call.clone(), &info, 10);
+        let result = extension.validate(
+            RawOrigin::Signed(who).into(), 
+            &call.clone(), 
+            &info, 
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
         // Should fail
-        assert_err!(
+        assert_eq!(
             // Should get an invalid transaction error
-            result,
-            crate::TransactionValidityError::Invalid(crate::InvalidTransaction::Custom(
-                CustomTransactionError::ColdkeyInSwapSchedule.into()
-            ))
+            result.unwrap_err(),
+            CustomTransactionError::ColdkeyInSwapSchedule.into()
         );
 
         // Swap stake
@@ -2214,14 +2226,20 @@ fn test_coldkey_in_swap_schedule_prevents_funds_usage() {
             destination_netuid: netuid,
             alpha_amount: 100_000_000_000,
         });
-        let result = extension.validate(&who, &call.clone(), &info, 10);
+        let result = extension.validate(
+            RawOrigin::Signed(who).into(), 
+            &call.clone(), 
+            &info, 
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
         // Should fail
-        assert_err!(
+        assert_eq!(
             // Should get an invalid transaction error
-            result,
-            crate::TransactionValidityError::Invalid(crate::InvalidTransaction::Custom(
-                CustomTransactionError::ColdkeyInSwapSchedule.into()
-            ))
+            result.unwrap_err(),
+            CustomTransactionError::ColdkeyInSwapSchedule.into()
         );
 
         // Swap stake limit
@@ -2233,14 +2251,20 @@ fn test_coldkey_in_swap_schedule_prevents_funds_usage() {
             limit_price: 100_000_000_000,
             allow_partial: false,
         });
-        let result = extension.validate(&who, &call.clone(), &info, 10);
+        let result = extension.validate(
+            RawOrigin::Signed(who).into(), 
+            &call.clone(), 
+            &info, 
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
         // Should fail
-        assert_err!(
+        assert_eq!(
             // Should get an invalid transaction error
-            result,
-            crate::TransactionValidityError::Invalid(crate::InvalidTransaction::Custom(
-                CustomTransactionError::ColdkeyInSwapSchedule.into()
-            ))
+            result.unwrap_err(),
+            CustomTransactionError::ColdkeyInSwapSchedule.into()
         );
 
         // Move stake
@@ -2251,14 +2275,20 @@ fn test_coldkey_in_swap_schedule_prevents_funds_usage() {
             destination_netuid: netuid,
             alpha_amount: 100_000_000_000,
         });
-        let result = extension.validate(&who, &call.clone(), &info, 10);
+        let result = extension.validate(
+            RawOrigin::Signed(who).into(), 
+            &call.clone(), 
+            &info, 
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
         // Should fail
-        assert_err!(
+        assert_eq!(
             // Should get an invalid transaction error
-            result,
-            crate::TransactionValidityError::Invalid(crate::InvalidTransaction::Custom(
-                CustomTransactionError::ColdkeyInSwapSchedule.into()
-            ))
+            result.unwrap_err(),
+            CustomTransactionError::ColdkeyInSwapSchedule.into()
         );
 
         // Transfer stake
@@ -2269,14 +2299,20 @@ fn test_coldkey_in_swap_schedule_prevents_funds_usage() {
             destination_netuid: netuid,
             alpha_amount: 100_000_000_000,
         });
-        let result = extension.validate(&who, &call.clone(), &info, 10);
+        let result = extension.validate(
+            RawOrigin::Signed(who).into(), 
+            &call.clone(), 
+            &info, 
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
         // Should fail
-        assert_err!(
+        assert_eq!(
             // Should get an invalid transaction error
-            result,
-            crate::TransactionValidityError::Invalid(crate::InvalidTransaction::Custom(
-                CustomTransactionError::ColdkeyInSwapSchedule.into()
-            ))
+            result.unwrap_err(),
+            CustomTransactionError::ColdkeyInSwapSchedule.into()
         );
 
         // Transfer all
@@ -2284,14 +2320,20 @@ fn test_coldkey_in_swap_schedule_prevents_funds_usage() {
             dest: new_coldkey,
             keep_alive: false,
         });
-        let result = extension.validate(&who, &call.clone(), &info, 10);
+        let result = extension.validate(
+            RawOrigin::Signed(who).into(), 
+            &call.clone(), 
+            &info, 
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
         // Should fail
-        assert_err!(
+        assert_eq!(
             // Should get an invalid transaction error
-            result,
-            crate::TransactionValidityError::Invalid(crate::InvalidTransaction::Custom(
-                CustomTransactionError::ColdkeyInSwapSchedule.into()
-            ))
+            result.unwrap_err(),
+            CustomTransactionError::ColdkeyInSwapSchedule.into()
         );
 
         // Transfer keep alive
@@ -2299,14 +2341,20 @@ fn test_coldkey_in_swap_schedule_prevents_funds_usage() {
             dest: new_coldkey,
             value: 100_000_000_000,
         });
-        let result = extension.validate(&who, &call.clone(), &info, 10);
+        let result = extension.validate(
+            RawOrigin::Signed(who).into(), 
+            &call.clone(), 
+            &info, 
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
         // Should fail
-        assert_err!(
+        assert_eq!(
             // Should get an invalid transaction error
-            result,
-            crate::TransactionValidityError::Invalid(crate::InvalidTransaction::Custom(
-                CustomTransactionError::ColdkeyInSwapSchedule.into()
-            ))
+            result.unwrap_err(),
+            CustomTransactionError::ColdkeyInSwapSchedule.into()
         );
 
         // Transfer allow death
@@ -2314,26 +2362,38 @@ fn test_coldkey_in_swap_schedule_prevents_funds_usage() {
             dest: new_coldkey,
             value: 100_000_000_000,
         });
-        let result = extension.validate(&who, &call.clone(), &info, 10);
+        let result = extension.validate(
+            RawOrigin::Signed(who).into(), 
+            &call.clone(), 
+            &info, 
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
         // Should fail
-        assert_err!(
+        assert_eq!(
             // Should get an invalid transaction error
-            result,
-            crate::TransactionValidityError::Invalid(crate::InvalidTransaction::Custom(
-                CustomTransactionError::ColdkeyInSwapSchedule.into()
-            ))
+            result.unwrap_err(),
+            CustomTransactionError::ColdkeyInSwapSchedule.into()
         );
 
         // Burned register
         let call = RuntimeCall::SubtensorModule(SubtensorCall::burned_register { netuid, hotkey });
-        let result = extension.validate(&who, &call.clone(), &info, 10);
+        let result = extension.validate(
+            RawOrigin::Signed(who).into(), 
+            &call.clone(), 
+            &info, 
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
         // Should fail
-        assert_err!(
+        assert_eq!(
             // Should get an invalid transaction error
-            result,
-            crate::TransactionValidityError::Invalid(crate::InvalidTransaction::Custom(
-                CustomTransactionError::ColdkeyInSwapSchedule.into()
-            ))
+            result.unwrap_err(),
+            CustomTransactionError::ColdkeyInSwapSchedule.into()
         );
 
         // Remove stake
@@ -2342,7 +2402,15 @@ fn test_coldkey_in_swap_schedule_prevents_funds_usage() {
             netuid,
             amount_unstaked: 1_000_000,
         });
-        let result = extension.validate(&who, &call.clone(), &info, 10);
+        let result = extension.validate(
+            RawOrigin::Signed(who).into(), 
+            &call.clone(), 
+            &info, 
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
         // Should pass, not in list.
         assert_ok!(result);
 
@@ -2354,7 +2422,15 @@ fn test_coldkey_in_swap_schedule_prevents_funds_usage() {
             limit_price: 123456789, // should be low enough
             allow_partial: true,
         });
-        let result = extension.validate(&who, &call.clone(), &info, 10);
+        let result = extension.validate(
+            RawOrigin::Signed(who).into(), 
+            &call.clone(), 
+            &info, 
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
         // Should pass, not in list.
         assert_ok!(result);
     });
@@ -2410,22 +2486,28 @@ fn test_coldkey_in_swap_schedule_prevents_critical_calls() {
         // Setup the extension
         let info: crate::DispatchInfo =
             crate::DispatchInfoOf::<<Test as frame_system::Config>::RuntimeCall>::default();
-        let extension = crate::SubtensorSignedExtension::<Test>::new();
+        let extension = crate::SubtensorTransactionExtension::<Test>::new();
 
         // Try each call
 
         // Dissolve network
         let call =
             RuntimeCall::SubtensorModule(SubtensorCall::dissolve_network { netuid, coldkey });
-        let result: Result<ValidTransaction, TransactionValidityError> =
-            extension.validate(&who, &call.clone(), &info, 10);
+        let result =
+            extension.validate(
+                RawOrigin::Signed(who).into(), 
+                &call.clone(), 
+                &info, 
+                10,
+                (),
+                &TxBaseImplication(()),
+                TransactionSource::External,
+            );
         // Should fail
-        assert_err!(
+        assert_eq!(
             // Should get an invalid transaction error
-            result,
-            crate::TransactionValidityError::Invalid(crate::InvalidTransaction::Custom(
-                CustomTransactionError::ColdkeyInSwapSchedule.into()
-            ))
+            result.unwrap_err(),
+            CustomTransactionError::ColdkeyInSwapSchedule.into()
         );
     });
 }
diff --git a/pallets/subtensor/src/tests/weights.rs b/pallets/subtensor/src/tests/weights.rs
index 3d240750cf..22f89ccce7 100644
--- a/pallets/subtensor/src/tests/weights.rs
+++ b/pallets/subtensor/src/tests/weights.rs
@@ -8,13 +8,14 @@ use frame_support::{
     assert_err, assert_ok,
     dispatch::{DispatchClass, DispatchResult, GetDispatchInfo, Pays},
 };
+use frame_system::RawOrigin;
 use rand_chacha::{ChaCha20Rng, rand_core::SeedableRng};
 use scale_info::prelude::collections::HashMap;
 use sha2::Digest;
 use sp_core::{Get, H256, U256};
 use sp_runtime::{
     BoundedVec, DispatchError,
-    traits::{BlakeTwo256, ConstU32, Hash, SignedExtension},
+    traits::{BlakeTwo256, ConstU32, Hash, TxBaseImplication},
 };
 use sp_std::collections::vec_deque::VecDeque;
 use substrate_fixed::types::I32F32;
@@ -98,16 +99,22 @@ fn test_set_rootweights_validate() {
         let info: crate::DispatchInfo =
             crate::DispatchInfoOf::<<Test as frame_system::Config>::RuntimeCall>::default();
 
-        let extension = crate::SubtensorSignedExtension::<Test>::new();
+        let extension = crate::SubtensorTransactionExtension::<Test>::new();
         // Submit to the signed extension validate function
-        let result_no_stake = extension.validate(&who, &call.clone(), &info, 10);
+        let result_no_stake = extension.validate(
+            RawOrigin::Signed(who).into(), 
+            &call.clone(), 
+            &info, 
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
         // Should fail
-        assert_err!(
+        assert_eq!(
             // Should get an invalid transaction error
-            result_no_stake,
-            crate::TransactionValidityError::Invalid(crate::InvalidTransaction::Custom(
-                CustomTransactionError::StakeAmountTooLow.into()
-            ))
+            result_no_stake.unwrap_err(),
+            CustomTransactionError::StakeAmountTooLow.into()
         );
 
         // Increase the stake to be equal to the minimum
@@ -125,7 +132,15 @@ fn test_set_rootweights_validate() {
         );
 
         // Submit to the signed extension validate function
-        let result_min_stake = extension.validate(&who, &call.clone(), &info, 10);
+        let result_min_stake = extension.validate(
+            RawOrigin::Signed(who).into(), 
+            &call.clone(), 
+            &info, 
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
         // Now the call should pass
         assert_ok!(result_min_stake);
 
@@ -140,7 +155,15 @@ fn test_set_rootweights_validate() {
         // Verify stake is more than minimum
         assert!(SubtensorModule::get_total_stake_for_hotkey(&hotkey) > min_stake);
 
-        let result_more_stake = extension.validate(&who, &call.clone(), &info, 10);
+        let result_more_stake = extension.validate(
+            RawOrigin::Signed(who).into(), 
+            &call.clone(), 
+            &info, 
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
         // The call should still pass
         assert_ok!(result_more_stake);
     });
@@ -215,14 +238,22 @@ fn test_commit_weights_validate() {
         let info: crate::DispatchInfo =
             crate::DispatchInfoOf::<<Test as frame_system::Config>::RuntimeCall>::default();
 
-        let extension = crate::SubtensorSignedExtension::<Test>::new();
+        let extension = crate::SubtensorTransactionExtension::<Test>::new();
         // Submit to the signed extension validate function
-        let result_no_stake = extension.validate(&who, &call.clone(), &info, 10);
+        let result_no_stake = extension.validate(
+            RawOrigin::Signed(who).into(), 
+            &call.clone(), 
+            &info, 
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
         // Should fail
-        assert_err!(
+        assert_eq!(
             // Should get an invalid transaction error
-            result_no_stake,
-            crate::TransactionValidityError::Invalid(crate::InvalidTransaction::Custom(1))
+            result_no_stake.unwrap_err(),
+            CustomTransactionError::StakeAmountTooLow.into()
         );
 
         // Increase the stake to be equal to the minimum
@@ -240,7 +271,15 @@ fn test_commit_weights_validate() {
         );
 
         // Submit to the signed extension validate function
-        let result_min_stake = extension.validate(&who, &call.clone(), &info, 10);
+        let result_min_stake = extension.validate(
+            RawOrigin::Signed(who).into(), 
+            &call.clone(), 
+            &info, 
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
         // Now the call should pass
         assert_ok!(result_min_stake);
 
@@ -255,7 +294,15 @@ fn test_commit_weights_validate() {
         // Verify stake is more than minimum
         assert!(SubtensorModule::get_total_stake_for_hotkey(&hotkey) > min_stake);
 
-        let result_more_stake = extension.validate(&who, &call.clone(), &info, 10);
+        let result_more_stake = extension.validate(
+            RawOrigin::Signed(who).into(), 
+            &call.clone(), 
+            &info, 
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
         // The call should still pass
         assert_ok!(result_more_stake);
     });
@@ -324,15 +371,21 @@ fn test_set_weights_validate() {
         let info: crate::DispatchInfo =
             crate::DispatchInfoOf::<<Test as frame_system::Config>::RuntimeCall>::default();
 
-        let extension = crate::SubtensorSignedExtension::<Test>::new();
+        let extension = crate::SubtensorTransactionExtension::<Test>::new();
         // Submit to the signed extension validate function
-        let result_no_stake = extension.validate(&who, &call.clone(), &info, 10);
+        let result_no_stake = extension.validate(
+            RawOrigin::Signed(who).into(), 
+            &call.clone(), 
+            &info, 
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
         // Should fail due to insufficient stake
-        assert_err!(
-            result_no_stake,
-            crate::TransactionValidityError::Invalid(crate::InvalidTransaction::Custom(
-                CustomTransactionError::StakeAmountTooLow.into()
-            ))
+        assert_eq!(
+            result_no_stake.unwrap_err(),
+            CustomTransactionError::StakeAmountTooLow.into()
         );
 
         // Increase the stake to be equal to the minimum
@@ -350,7 +403,15 @@ fn test_set_weights_validate() {
         );
 
         // Submit to the signed extension validate function
-        let result_min_stake = extension.validate(&who, &call.clone(), &info, 10);
+        let result_min_stake = extension.validate(
+            RawOrigin::Signed(who).into(), 
+            &call.clone(), 
+            &info, 
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
         // Now the call should pass
         assert_ok!(result_min_stake);
     });
@@ -399,16 +460,22 @@ fn test_reveal_weights_validate() {
         let info: crate::DispatchInfo =
             crate::DispatchInfoOf::<<Test as frame_system::Config>::RuntimeCall>::default();
 
-        let extension = crate::SubtensorSignedExtension::<Test>::new();
+        let extension = crate::SubtensorTransactionExtension::<Test>::new();
         // Submit to the signed extension validate function
-        let result_no_stake = extension.validate(&who, &call.clone(), &info, 10);
+        let result_no_stake = extension.validate(
+            RawOrigin::Signed(who).into(), 
+            &call.clone(), 
+            &info, 
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
         // Should fail
-        assert_err!(
+        assert_eq!(
             // Should get an invalid transaction error
-            result_no_stake,
-            crate::TransactionValidityError::Invalid(crate::InvalidTransaction::Custom(
-                CustomTransactionError::StakeAmountTooLow.into()
-            ))
+            result_no_stake.unwrap_err(),
+            CustomTransactionError::StakeAmountTooLow.into()
         );
 
         // Increase the stake to be equal to the minimum
@@ -426,7 +493,15 @@ fn test_reveal_weights_validate() {
         );
 
         // Submit to the signed extension validate function
-        let result_min_stake = extension.validate(&who, &call.clone(), &info, 10);
+        let result_min_stake = extension.validate(
+            RawOrigin::Signed(who).into(), 
+            &call.clone(), 
+            &info, 
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
         // Now the call should pass
         assert_ok!(result_min_stake);
 
@@ -441,7 +516,15 @@ fn test_reveal_weights_validate() {
         // Verify stake is more than minimum
         assert!(SubtensorModule::get_total_stake_for_hotkey(&hotkey) > min_stake);
 
-        let result_more_stake = extension.validate(&who, &call.clone(), &info, 10);
+        let result_more_stake = extension.validate(
+            RawOrigin::Signed(who).into(), 
+            &call.clone(), 
+            &info, 
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
         // The call should still pass
         assert_ok!(result_more_stake);
     });

From 34741c0e8744a0515f9b633d6359f34d7e130d10 Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Wed, 11 Jun 2025 16:16:15 +0200
Subject: [PATCH 299/418] remove unused CommitmentsSignedExtension

---
 node/src/benchmarking.rs       |   1 -
 pallets/commitments/src/lib.rs | 113 +--------------------------------
 runtime/src/lib.rs             |   2 -
 3 files changed, 1 insertion(+), 115 deletions(-)

diff --git a/node/src/benchmarking.rs b/node/src/benchmarking.rs
index 5476e22266..16d46ff136 100644
--- a/node/src/benchmarking.rs
+++ b/node/src/benchmarking.rs
@@ -136,7 +136,6 @@ pub fn create_benchmark_extrinsic(
         frame_system::CheckWeight::<runtime::Runtime>::new(),
         pallet_transaction_payment::ChargeTransactionPayment::<runtime::Runtime>::from(0),
         pallet_subtensor::SubtensorTransactionExtension::<runtime::Runtime>::new().into(),
-        pallet_commitments::CommitmentsSignedExtension::<runtime::Runtime>::new().into(),
         frame_metadata_hash_extension::CheckMetadataHash::<runtime::Runtime>::new(true),
     );
 
diff --git a/pallets/commitments/src/lib.rs b/pallets/commitments/src/lib.rs
index 8331e76991..51f2d7fd5b 100644
--- a/pallets/commitments/src/lib.rs
+++ b/pallets/commitments/src/lib.rs
@@ -11,7 +11,6 @@ pub mod types;
 pub mod weights;
 
 pub use pallet::*;
-use subtensor_macros::freeze_struct;
 pub use types::*;
 pub use weights::WeightInfo;
 
@@ -393,117 +392,7 @@ pub enum CallType {
     Other,
 }
 
-use {
-    frame_support::{
-        dispatch::{DispatchInfo, DispatchResult, PostDispatchInfo},
-        pallet_prelude::{Decode, Encode, PhantomData, TypeInfo},
-        traits::IsSubType,
-    },
-    sp_runtime::{
-        traits::{DispatchInfoOf, Dispatchable, PostDispatchInfoOf, SignedExtension},
-        transaction_validity::{TransactionValidity, TransactionValidityError, ValidTransaction},
-    },
-};
-
-#[freeze_struct("6a00398e14a8a984")]
-#[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]
-pub struct CommitmentsSignedExtension<T: Config + Send + Sync + TypeInfo>(pub PhantomData<T>);
-
-impl<T: Config + Send + Sync + TypeInfo> Default for CommitmentsSignedExtension<T>
-where
-    <T as frame_system::Config>::RuntimeCall:
-        Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,
-    <T as frame_system::Config>::RuntimeCall: IsSubType<Call<T>>,
-{
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl<T: Config + Send + Sync + TypeInfo> CommitmentsSignedExtension<T>
-where
-    <T as frame_system::Config>::RuntimeCall:
-        Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,
-    <T as frame_system::Config>::RuntimeCall: IsSubType<Call<T>>,
-{
-    pub fn new() -> Self {
-        Self(Default::default())
-    }
-
-    pub fn get_priority_vanilla() -> u64 {
-        // Return high priority so that every extrinsic except set_weights function will
-        // have a higher priority than the set_weights call
-        u64::MAX
-    }
-}
-
-impl<T: Config + Send + Sync + TypeInfo> sp_std::fmt::Debug for CommitmentsSignedExtension<T> {
-    fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
-        write!(f, "SignedExtension")
-    }
-}
-
-impl<T: Config + Send + Sync + TypeInfo> SignedExtension for CommitmentsSignedExtension<T>
-where
-    <T as frame_system::Config>::RuntimeCall:
-        Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,
-    <T as frame_system::Config>::RuntimeCall: IsSubType<Call<T>>,
-{
-    const IDENTIFIER: &'static str = "CommitmentsSignedExtension";
-
-    type AccountId = T::AccountId;
-    type Call = <T as frame_system::Config>::RuntimeCall;
-    type AdditionalSigned = ();
-    type Pre = (CallType, u64, Self::AccountId);
-
-    fn additional_signed(&self) -> Result<Self::AdditionalSigned, TransactionValidityError> {
-        Ok(())
-    }
-
-    fn validate(
-        &self,
-        _: &Self::AccountId,
-        call: &Self::Call,
-        _info: &DispatchInfoOf<Self::Call>,
-        _len: usize,
-    ) -> TransactionValidity {
-        call.is_sub_type();
-        Ok(ValidTransaction {
-            priority: Self::get_priority_vanilla(),
-            ..Default::default()
-        })
-    }
-
-    // NOTE: Add later when we put in a pre and post dispatch step.
-    fn pre_dispatch(
-        self,
-        who: &Self::AccountId,
-        call: &Self::Call,
-        _info: &DispatchInfoOf<Self::Call>,
-        _len: usize,
-    ) -> Result<Self::Pre, TransactionValidityError> {
-        match call.is_sub_type() {
-            Some(Call::set_commitment { .. }) => {
-                let transaction_fee = 0;
-                Ok((CallType::SetCommitment, transaction_fee, who.clone()))
-            }
-            _ => {
-                let transaction_fee = 0;
-                Ok((CallType::Other, transaction_fee, who.clone()))
-            }
-        }
-    }
-
-    fn post_dispatch(
-        _maybe_pre: Option<Self::Pre>,
-        _info: &DispatchInfoOf<Self::Call>,
-        _post_info: &PostDispatchInfoOf<Self::Call>,
-        _len: usize,
-        _result: &DispatchResult,
-    ) -> Result<(), TransactionValidityError> {
-        Ok(())
-    }
-}
+use frame_support::{dispatch::DispatchResult, pallet_prelude::TypeInfo};
 
 impl<T: Config> Pallet<T> {
     pub fn reveal_timelocked_commitments() -> DispatchResult {
diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index 668e7344a2..1eb782bc35 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -151,7 +151,6 @@ impl frame_system::offchain::CreateSignedTransaction<pallet_drand::Call<Runtime>
             frame_system::CheckWeight::<Runtime>::new(),
             pallet_transaction_payment::ChargeTransactionPayment::<Runtime>::from(0),
             pallet_subtensor::SubtensorTransactionExtension::<Runtime>::new(),
-            pallet_commitments::CommitmentsSignedExtension::<Runtime>::new().into(),
             frame_metadata_hash_extension::CheckMetadataHash::<Runtime>::new(true),
         );
 
@@ -1583,7 +1582,6 @@ pub type SignedExtra = (
     frame_system::CheckWeight<Runtime>,
     pallet_transaction_payment::ChargeTransactionPayment<Runtime>,
     pallet_subtensor::SubtensorTransactionExtension<Runtime>,
-    AsTransactionExtension<pallet_commitments::CommitmentsSignedExtension<Runtime>>,
     frame_metadata_hash_extension::CheckMetadataHash<Runtime>,
 );
 

From 4ebd8e1fdddf1587674b79e1682e9dfbd1c5217c Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Wed, 11 Jun 2025 17:11:22 +0200
Subject: [PATCH 300/418] Address PR comments

---
 pallets/subtensor/src/macros/errors.rs | 4 ++--
 runtime/src/lib.rs                     | 3 ++-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/pallets/subtensor/src/macros/errors.rs b/pallets/subtensor/src/macros/errors.rs
index cde3290d14..fd7bc12e16 100644
--- a/pallets/subtensor/src/macros/errors.rs
+++ b/pallets/subtensor/src/macros/errors.rs
@@ -208,8 +208,6 @@ mod errors {
         UnableToRecoverPublicKey,
         /// Recovered public key is invalid.
         InvalidRecoveredPublicKey,
-        /// The caller does not have enough balance for the operation.
-        InsufficientBalance,
         /// SubToken disabled now
         SubtokenDisabled,
         /// Too frequent hotkey swap on subnet
@@ -218,5 +216,7 @@ mod errors {
         ZeroMaxStakeAmount,
         /// Invalid netuid duplication
         SameNetuid,
+        /// The caller does not have enough balance for the operation.
+        InsufficientBalance,
     }
 }
diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index cc4c39f68a..12654fd0a2 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -1214,7 +1214,8 @@ impl pallet_subtensor_swap::Config for Runtime {
     type MaxPositions = SwapMaxPositions;
     type MinimumLiquidity = SwapMinimumLiquidity;
     type MinimumReserve = SwapMinimumReserve;
-    type WeightInfo = ();
+    // TODO: set measured weights when the pallet been benchmarked and the type is generated
+    type WeightInfo = pallet_subtensor_swap::weights::DefaultWeight<Runtime>;
 }
 
 use sp_runtime::BoundedVec;

From 192e871bc59835c854ef4a43519296d35cbd26eb Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Wed, 11 Jun 2025 17:16:45 +0200
Subject: [PATCH 301/418] update check_nonce tx extension

---
 node/src/benchmarking.rs   |   6 +-
 runtime/src/check_nonce.rs | 204 ++++++++++++++++++++++---------------
 runtime/src/lib.rs         |  15 ++-
 3 files changed, 130 insertions(+), 95 deletions(-)

diff --git a/node/src/benchmarking.rs b/node/src/benchmarking.rs
index 16d46ff136..354acadae5 100644
--- a/node/src/benchmarking.rs
+++ b/node/src/benchmarking.rs
@@ -123,7 +123,7 @@ pub fn create_benchmark_extrinsic(
         .checked_next_power_of_two()
         .map(|c| c / 2)
         .unwrap_or(2) as u64;
-    let extra: runtime::SignedExtra = (
+    let extra: runtime::TransactionExtensions = (
         frame_system::CheckNonZeroSender::<runtime::Runtime>::new(),
         frame_system::CheckSpecVersion::<runtime::Runtime>::new(),
         frame_system::CheckTxVersion::<runtime::Runtime>::new(),
@@ -132,10 +132,10 @@ pub fn create_benchmark_extrinsic(
             period,
             best_block.saturated_into(),
         )),
-        check_nonce::CheckNonce::<runtime::Runtime>::from(nonce).into(),
+        check_nonce::CheckNonce::<runtime::Runtime>::from(nonce),
         frame_system::CheckWeight::<runtime::Runtime>::new(),
         pallet_transaction_payment::ChargeTransactionPayment::<runtime::Runtime>::from(0),
-        pallet_subtensor::SubtensorTransactionExtension::<runtime::Runtime>::new().into(),
+        pallet_subtensor::SubtensorTransactionExtension::<runtime::Runtime>::new(),
         frame_metadata_hash_extension::CheckMetadataHash::<runtime::Runtime>::new(true),
     );
 
diff --git a/runtime/src/check_nonce.rs b/runtime/src/check_nonce.rs
index 94c06c6480..37d0e97cb7 100644
--- a/runtime/src/check_nonce.rs
+++ b/runtime/src/check_nonce.rs
@@ -1,12 +1,18 @@
+// Customized from the original implementation in the Polkadot SDK.
+// https://github.com/paritytech/polkadot-sdk/blob/b600af050d6b6c8da59ae2a2a793ee2d8827ab1e/substrate/frame/system/src/extensions/check_nonce.rs
+
 use codec::{Decode, Encode};
-use frame_support::dispatch::{DispatchInfo, Pays};
+use frame_support::{dispatch::{DispatchInfo, Pays}, RuntimeDebugNoBound};
 use frame_system::Config;
 use scale_info::TypeInfo;
 use sp_runtime::{
+    DispatchResult,
+    Weight,
     Saturating,
-    traits::{DispatchInfoOf, Dispatchable, One, SignedExtension, Zero},
+    traits::{DispatchInfoOf, Dispatchable, One, Zero, TransactionExtension, AsSystemOriginSigner, ValidateResult, PostDispatchInfoOf},
     transaction_validity::{
-        InvalidTransaction, TransactionLongevity, TransactionValidity, TransactionValidityError,
+        TransactionSource,
+        InvalidTransaction, TransactionLongevity,TransactionValidityError,
         ValidTransaction,
     },
 };
@@ -18,9 +24,14 @@ use subtensor_macros::freeze_struct;
 /// # Transaction Validity
 ///
 /// This extension affects `requires` and `provides` tags of validity, but DOES NOT
-/// set the `priority` field. Make sure that AT LEAST one of the signed extension sets
+/// set the `priority` field. Make sure that AT LEAST one of the transaction extension sets
 /// some kind of priority upon validating transactions.
-#[freeze_struct("610b76f62cdb521e")]
+///
+/// The preparation step assumes that the nonce information has not changed since the validation
+/// step. This means that other extensions ahead of `CheckNonce` in the pipeline must not alter the
+/// nonce during their own preparation step, or else the transaction may be rejected during dispatch
+/// or lead to an inconsistent account state..
+#[freeze_struct("feac7c9db94d39ac")]
 #[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]
 #[scale_info(skip_type_params(T))]
 pub struct CheckNonce<T: Config>(#[codec(compact)] pub T::Nonce);
@@ -44,87 +55,112 @@ impl<T: Config> sp_std::fmt::Debug for CheckNonce<T> {
     }
 }
 
-impl<T: Config> SignedExtension for CheckNonce<T>
+/// Operation to perform from `validate` to `prepare` in [`CheckNonce`] transaction extension.
+#[derive(RuntimeDebugNoBound)]
+pub enum Val<T: Config> {
+	/// Account and its nonce to check for.
+	CheckNonce((T::AccountId, T::Nonce)),
+	/// Weight to refund.
+	Refund(Weight),
+}
+
+/// Operation to perform from `prepare` to `post_dispatch_details` in [`CheckNonce`] transaction
+/// extension.
+#[derive(RuntimeDebugNoBound)]
+pub enum Pre {
+	/// The transaction extension weight should not be refunded.
+	NonceChecked,
+	/// The transaction extension weight should be refunded.
+	Refund(Weight),
+}
+
+impl<T: Config> TransactionExtension<T::RuntimeCall> for CheckNonce<T>
 where
-    T::RuntimeCall: Dispatchable<Info = DispatchInfo>,
+	T::RuntimeCall: Dispatchable<Info = DispatchInfo>,
+	<T::RuntimeCall as Dispatchable>::RuntimeOrigin: AsSystemOriginSigner<T::AccountId> + Clone,
 {
-    type AccountId = T::AccountId;
-    type Call = T::RuntimeCall;
-    type AdditionalSigned = ();
-    type Pre = ();
-    const IDENTIFIER: &'static str = "CheckNonce";
+	const IDENTIFIER: &'static str = "CheckNonce";
+	type Implicit = ();
+	type Val = Val<T>;
+	type Pre = Pre;
 
-    fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {
-        Ok(())
-    }
+	fn weight(&self, _: &T::RuntimeCall) -> Weight {
+        // TODO: benchmark transaction extension
+        Weight::zero()
+	}
 
-    fn pre_dispatch(
-        self,
-        who: &Self::AccountId,
-        _call: &Self::Call,
-        info: &DispatchInfoOf<Self::Call>,
-        _len: usize,
-    ) -> Result<(), TransactionValidityError> {
-        let mut account = frame_system::Account::<T>::get(who);
-        match info.pays_fee {
-            Pays::Yes => {
-                if account.providers.is_zero() && account.sufficients.is_zero() {
-                    // Nonce storage not paid for
-                    return Err(InvalidTransaction::Payment.into());
-                }
-            }
-            // not check providers and sufficients for Pays::No extrinsic
-            Pays::No => {}
-        }
-
-        if self.0 != account.nonce {
-            return Err(if self.0 < account.nonce {
-                InvalidTransaction::Stale
-            } else {
-                InvalidTransaction::Future
-            }
-            .into());
-        }
-        account.nonce.saturating_inc();
-        frame_system::Account::<T>::insert(who, account);
-        Ok(())
-    }
+	fn validate(
+		&self,
+		origin: <T as Config>::RuntimeOrigin,
+		call: &T::RuntimeCall,
+		info: &DispatchInfoOf<T::RuntimeCall>,
+		_len: usize,
+		_self_implicit: Self::Implicit,
+		_inherited_implication: &impl Encode,
+        _source: TransactionSource,
+	) -> ValidateResult<Self::Val, T::RuntimeCall> {
+		let Some(who) = origin.as_system_origin_signer() else {
+			return Ok((Default::default(), Val::Refund(self.weight(call)), origin))
+		};
+		let account = frame_system::Account::<T>::get(who);
+		if info.pays_fee == Pays::Yes && account.providers.is_zero() && account.sufficients.is_zero() {
+			// Nonce storage not paid for
+			return Err(InvalidTransaction::Payment.into())
+		}
+		if self.0 < account.nonce {
+			return Err(InvalidTransaction::Stale.into())
+		}
 
-    fn validate(
-        &self,
-        who: &Self::AccountId,
-        _call: &Self::Call,
-        info: &DispatchInfoOf<Self::Call>,
-        _len: usize,
-    ) -> TransactionValidity {
-        let account = frame_system::Account::<T>::get(who);
-        match info.pays_fee {
-            Pays::Yes => {
-                if account.providers.is_zero() && account.sufficients.is_zero() {
-                    // Nonce storage not paid for
-                    return Err(InvalidTransaction::Payment.into());
-                }
-            }
-            // not check providers and sufficients for Pays::No extrinsic
-            Pays::No => {}
-        }
-        if self.0 < account.nonce {
-            return InvalidTransaction::Stale.into();
-        }
-
-        let provides = vec![Encode::encode(&(who, self.0))];
-        let requires = if account.nonce < self.0 {
-            vec![Encode::encode(&(who, self.0.saturating_sub(One::one())))]
-        } else {
-            vec![]
-        };
-
-        Ok(ValidTransaction {
-            priority: 0,
-            requires,
-            provides,
-            longevity: TransactionLongevity::MAX,
-            propagate: true,
-        })
-    }
-}
+		let provides = vec![Encode::encode(&(&who, self.0))];
+		let requires = if account.nonce < self.0 {
+			vec![Encode::encode(&(&who, self.0.saturating_sub(One::one())))]
+		} else {
+			vec![]
+		};
+
+		let validity = ValidTransaction {
+			priority: 0,
+			requires,
+			provides,
+			longevity: TransactionLongevity::max_value(),
+			propagate: true,
+		};
+
+		Ok((validity, Val::CheckNonce((who.clone(), account.nonce)), origin))
+	}
+
+	fn prepare(
+		self,
+		val: Self::Val,
+		_origin: &T::RuntimeOrigin,
+		_call: &T::RuntimeCall,
+		_info: &DispatchInfoOf<T::RuntimeCall>,
+		_len: usize,
+	) -> Result<Self::Pre, TransactionValidityError> {
+		let (who, mut nonce) = match val {
+			Val::CheckNonce((who, nonce)) => (who, nonce),
+			Val::Refund(weight) => return Ok(Pre::Refund(weight)),
+		};
+
+		// `self.0 < nonce` already checked in `validate`.
+		if self.0 > nonce {
+			return Err(InvalidTransaction::Future.into())
+		}
+		nonce += T::Nonce::one();
+		frame_system::Account::<T>::mutate(who, |account| account.nonce = nonce);
+		Ok(Pre::NonceChecked)
+	}
+
+	fn post_dispatch_details(
+		pre: Self::Pre,
+		_info: &DispatchInfo,
+		_post_info: &PostDispatchInfoOf<T::RuntimeCall>,
+		_len: usize,
+		_result: &DispatchResult,
+	) -> Result<Weight, TransactionValidityError> {
+		match pre {
+			Pre::NonceChecked => Ok(Weight::zero()),
+			Pre::Refund(weight) => Ok(weight),
+		}
+	}
+}
\ No newline at end of file
diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index 1eb782bc35..e2e689bb28 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -52,7 +52,6 @@ use sp_runtime::generic::Era;
 use sp_runtime::{
     AccountId32, ApplyExtrinsicResult, ConsensusEngineId, generic,
     impl_opaque_keys,
-    traits::transaction_extension::AsTransactionExtension,
     traits::{
         AccountIdLookup, BlakeTwo256, Block as BlockT, DispatchInfoOf, Dispatchable, NumberFor,
         One, PostDispatchInfoOf, UniqueSaturatedInto, Verify,
@@ -141,7 +140,7 @@ impl frame_system::offchain::CreateSignedTransaction<pallet_drand::Call<Runtime>
         use sp_runtime::traits::StaticLookup;
 
         let address = <Runtime as frame_system::Config>::Lookup::unlookup(account.clone());
-        let extra: SignedExtra = (
+        let extra: TransactionExtensions = (
             frame_system::CheckNonZeroSender::<Runtime>::new(),
             frame_system::CheckSpecVersion::<Runtime>::new(),
             frame_system::CheckTxVersion::<Runtime>::new(),
@@ -1571,14 +1570,14 @@ pub type Address = sp_runtime::MultiAddress<AccountId, ()>;
 pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
 // Block type as expected by this runtime.
 pub type Block = generic::Block<Header, UncheckedExtrinsic>;
-// The SignedExtension to the basic transaction logic.
-pub type SignedExtra = (
+// The extensions to the basic transaction logic.
+pub type TransactionExtensions = (
     frame_system::CheckNonZeroSender<Runtime>,
     frame_system::CheckSpecVersion<Runtime>,
     frame_system::CheckTxVersion<Runtime>,
     frame_system::CheckGenesis<Runtime>,
     frame_system::CheckEra<Runtime>,
-    AsTransactionExtension<check_nonce::CheckNonce<Runtime>>,
+    check_nonce::CheckNonce<Runtime>,
     frame_system::CheckWeight<Runtime>,
     pallet_transaction_payment::ChargeTransactionPayment<Runtime>,
     pallet_subtensor::SubtensorTransactionExtension<Runtime>,
@@ -1595,14 +1594,14 @@ type Migrations = (
 
 // Unchecked extrinsic type as expected by this runtime.
 pub type UncheckedExtrinsic =
-    fp_self_contained::UncheckedExtrinsic<Address, RuntimeCall, Signature, SignedExtra>;
+    fp_self_contained::UncheckedExtrinsic<Address, RuntimeCall, Signature, TransactionExtensions>;
 
 /// Extrinsic type that has already been checked.
 pub type CheckedExtrinsic =
-    fp_self_contained::CheckedExtrinsic<AccountId, RuntimeCall, SignedExtra, H160>;
+    fp_self_contained::CheckedExtrinsic<AccountId, RuntimeCall, TransactionExtensions, H160>;
 
 // The payload being signed in transactions.
-pub type SignedPayload = generic::SignedPayload<RuntimeCall, SignedExtra>;
+pub type SignedPayload = generic::SignedPayload<RuntimeCall, TransactionExtensions>;
 // Executive: handles dispatch to the various modules.
 pub type Executive = frame_executive::Executive<
     Runtime,

From fba3eaca0277a33ef808f4d419b2f9f21eacac82 Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Wed, 11 Jun 2025 17:21:54 +0200
Subject: [PATCH 302/418] commit Cargo.lock

---
 pallets/subtensor/src/lib.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pallets/subtensor/src/lib.rs b/pallets/subtensor/src/lib.rs
index 9214ca2396..3451f896f0 100644
--- a/pallets/subtensor/src/lib.rs
+++ b/pallets/subtensor/src/lib.rs
@@ -2246,7 +2246,7 @@ where
             }
             Some(Call::dissolve_network { .. }) => {
                 if ColdkeySwapScheduled::<T>::contains_key(who) {
-                    return Err(CustomTransactionError::ColdkeyInSwapSchedule.into());
+                    Err(CustomTransactionError::ColdkeyInSwapSchedule.into())
                 } else {
                     let validity = ValidTransaction {
                         priority: Self::get_priority_vanilla(),
@@ -2311,7 +2311,7 @@ where
         _len: usize,
     ) -> Result<Self::Pre, TransactionValidityError> {
         // The transaction is not signed, given val is None, so we just skip this step.
-        if let None = val {
+        if val.is_none() {
             return Ok(None);
         }
 

From 64e9571f0598badfc3479409d32770385cf47315 Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Wed, 11 Jun 2025 17:30:54 +0200
Subject: [PATCH 303/418] commit Cargo.lock

---
 node/src/benchmarking.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/node/src/benchmarking.rs b/node/src/benchmarking.rs
index 354acadae5..4f68d439e4 100644
--- a/node/src/benchmarking.rs
+++ b/node/src/benchmarking.rs
@@ -153,7 +153,6 @@ pub fn create_benchmark_extrinsic(
             (),
             (),
             (),
-            None,
         ),
     );
     let signature = raw_payload.using_encoded(|e| sender.sign(e));

From 9d880338abd0ab8c4f11b6a2b3490ee41afdd334 Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Wed, 11 Jun 2025 17:32:52 +0200
Subject: [PATCH 304/418] commit Cargo.lock

---
 node/src/benchmarking.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/node/src/benchmarking.rs b/node/src/benchmarking.rs
index 4f68d439e4..1590422c08 100644
--- a/node/src/benchmarking.rs
+++ b/node/src/benchmarking.rs
@@ -152,7 +152,7 @@ pub fn create_benchmark_extrinsic(
             (),
             (),
             (),
-            (),
+            None,
         ),
     );
     let signature = raw_payload.using_encoded(|e| sender.sign(e));

From c3c2baad8f1af56db82933785b6e002bd5188567 Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Wed, 11 Jun 2025 17:34:08 +0200
Subject: [PATCH 305/418] cargo fmt

---
 pallets/subtensor/src/lib.rs                |  73 +++----
 pallets/subtensor/src/tests/move_stake.rs   |  25 +--
 pallets/subtensor/src/tests/registration.rs |  71 ++++---
 pallets/subtensor/src/tests/serving.rs      |  14 +-
 pallets/subtensor/src/tests/staking.rs      |  52 ++---
 pallets/subtensor/src/tests/swap_coldkey.rs | 104 +++++-----
 pallets/subtensor/src/tests/weights.rs      |  66 +++----
 runtime/src/check_nonce.rs                  | 206 ++++++++++----------
 runtime/src/lib.rs                          |   5 +-
 9 files changed, 307 insertions(+), 309 deletions(-)

diff --git a/pallets/subtensor/src/lib.rs b/pallets/subtensor/src/lib.rs
index 3451f896f0..288630be18 100644
--- a/pallets/subtensor/src/lib.rs
+++ b/pallets/subtensor/src/lib.rs
@@ -2006,7 +2006,8 @@ where
                         false,
                     ),
                     Self::get_priority_staking(who, hotkey, *amount_staked),
-                ).map(|validity| (validity, Some(who.clone()), origin.clone()))
+                )
+                .map(|validity| (validity, Some(who.clone()), origin.clone()))
             }
             Some(Call::add_stake_limit {
                 hotkey,
@@ -2035,7 +2036,8 @@ where
                         *allow_partial,
                     ),
                     Self::get_priority_staking(who, hotkey, *amount_staked),
-                ).map(|validity| (validity, Some(who.clone()), origin.clone()))
+                )
+                .map(|validity| (validity, Some(who.clone()), origin.clone()))
             }
             Some(Call::remove_stake {
                 hotkey,
@@ -2053,7 +2055,8 @@ where
                         false,
                     ),
                     Self::get_priority_staking(who, hotkey, *amount_unstaked),
-                ).map(|validity| (validity, Some(who.clone()), origin.clone()))
+                )
+                .map(|validity| (validity, Some(who.clone()), origin.clone()))
             }
             Some(Call::remove_stake_limit {
                 hotkey,
@@ -2079,21 +2082,24 @@ where
                         *allow_partial,
                     ),
                     Self::get_priority_staking(who, hotkey, *amount_unstaked),
-                ).map(|validity| (validity, Some(who.clone()), origin.clone()))
+                )
+                .map(|validity| (validity, Some(who.clone()), origin.clone()))
             }
             Some(Call::unstake_all { hotkey }) => {
                 // Fully validate the user input
                 Self::result_to_validity(
                     Pallet::<T>::validate_unstake_all(who, hotkey, false),
                     Self::get_priority_vanilla(),
-                ).map(|validity| (validity, Some(who.clone()), origin.clone()))
+                )
+                .map(|validity| (validity, Some(who.clone()), origin.clone()))
             }
             Some(Call::unstake_all_alpha { hotkey }) => {
                 // Fully validate the user input
                 Self::result_to_validity(
                     Pallet::<T>::validate_unstake_all(who, hotkey, true),
                     Self::get_priority_vanilla(),
-                ).map(|validity| (validity, Some(who.clone()), origin.clone()))
+                )
+                .map(|validity| (validity, Some(who.clone()), origin.clone()))
             }
             Some(Call::move_stake {
                 origin_hotkey,
@@ -2121,7 +2127,8 @@ where
                         false,
                     ),
                     Self::get_priority_staking(who, origin_hotkey, *alpha_amount),
-                ).map(|validity| (validity, Some(who.clone()), origin.clone()))
+                )
+                .map(|validity| (validity, Some(who.clone()), origin.clone()))
             }
             Some(Call::transfer_stake {
                 destination_coldkey,
@@ -2149,7 +2156,8 @@ where
                         true,
                     ),
                     Self::get_priority_staking(who, hotkey, *alpha_amount),
-                ).map(|validity| (validity, Some(who.clone()), origin.clone()))
+                )
+                .map(|validity| (validity, Some(who.clone()), origin.clone()))
             }
             Some(Call::swap_stake {
                 hotkey,
@@ -2176,7 +2184,8 @@ where
                         false,
                     ),
                     Self::get_priority_staking(who, hotkey, *alpha_amount),
-                ).map(|validity| (validity, Some(who.clone()), origin.clone()))
+                )
+                .map(|validity| (validity, Some(who.clone()), origin.clone()))
             }
             Some(Call::swap_stake_limit {
                 hotkey,
@@ -2214,7 +2223,8 @@ where
                         false,
                     ),
                     Self::get_priority_staking(who, hotkey, *alpha_amount),
-                ).map(|validity| (validity, Some(who.clone()), origin.clone()))
+                )
+                .map(|validity| (validity, Some(who.clone()), origin.clone()))
             }
             Some(Call::register { netuid, .. } | Call::burned_register { netuid, .. }) => {
                 if ColdkeySwapScheduled::<T>::contains_key(who) {
@@ -2279,7 +2289,8 @@ where
                         *placeholder2,
                     ),
                     Self::get_priority_vanilla(),
-                ).map(|validity| (validity, Some(who.clone()), origin.clone()))
+                )
+                .map(|validity| (validity, Some(who.clone()), origin.clone()))
             }
             _ => {
                 if let Some(
@@ -2316,36 +2327,16 @@ where
         }
 
         match call.is_sub_type() {
-            Some(Call::add_stake { .. }) => {
-                Ok(Some(CallType::AddStake))
-            }
-            Some(Call::remove_stake { .. }) => {
-                Ok(Some(CallType::RemoveStake))
-            }
-            Some(Call::set_weights { .. }) => {
-                Ok(Some(CallType::SetWeights))
-            }
-            Some(Call::commit_weights { .. }) => {
-                Ok(Some(CallType::SetWeights))
-            }
-            Some(Call::reveal_weights { .. }) => {
-                Ok(Some(CallType::SetWeights))
-            }
-            Some(Call::register { .. }) => {
-                Ok(Some(CallType::Register))
-            }
-            Some(Call::serve_axon { .. }) => {
-                Ok(Some(CallType::Serve))
-            }
-            Some(Call::serve_axon_tls { .. }) => {
-                Ok(Some(CallType::Serve))
-            }
-            Some(Call::register_network { .. }) => {
-                Ok(Some(CallType::RegisterNetwork))
-            }
-            _ => {
-                Ok(Some(CallType::Other))
-            }
+            Some(Call::add_stake { .. }) => Ok(Some(CallType::AddStake)),
+            Some(Call::remove_stake { .. }) => Ok(Some(CallType::RemoveStake)),
+            Some(Call::set_weights { .. }) => Ok(Some(CallType::SetWeights)),
+            Some(Call::commit_weights { .. }) => Ok(Some(CallType::SetWeights)),
+            Some(Call::reveal_weights { .. }) => Ok(Some(CallType::SetWeights)),
+            Some(Call::register { .. }) => Ok(Some(CallType::Register)),
+            Some(Call::serve_axon { .. }) => Ok(Some(CallType::Serve)),
+            Some(Call::serve_axon_tls { .. }) => Ok(Some(CallType::Serve)),
+            Some(Call::register_network { .. }) => Ok(Some(CallType::RegisterNetwork)),
+            _ => Ok(Some(CallType::Other)),
         }
     }
 
diff --git a/pallets/subtensor/src/tests/move_stake.rs b/pallets/subtensor/src/tests/move_stake.rs
index ebfbc6b405..64713e5c2f 100644
--- a/pallets/subtensor/src/tests/move_stake.rs
+++ b/pallets/subtensor/src/tests/move_stake.rs
@@ -3,8 +3,8 @@ use crate::*;
 use approx::assert_abs_diff_eq;
 use frame_support::{assert_err, assert_noop, assert_ok};
 use frame_system::RawOrigin;
-use sp_runtime::traits::TxBaseImplication;
 use sp_core::{Get, U256};
+use sp_runtime::traits::TxBaseImplication;
 use substrate_fixed::types::{U64F64, U96F32};
 
 // 1. test_do_move_success
@@ -1567,8 +1567,9 @@ fn test_swap_stake_limit_validate() {
         let extension = crate::SubtensorTransactionExtension::<Test>::new();
         // Submit to the signed extension validate function
         let result_no_stake = extension.validate(
-            RawOrigin::Signed(coldkey).into(), &call.clone(), 
-            &info, 
+            RawOrigin::Signed(coldkey).into(),
+            &call.clone(),
+            &info,
             10,
             (),
             &TxBaseImplication(()),
@@ -1623,9 +1624,9 @@ fn test_stake_transfers_disabled_validate() {
 
         // Submit to the signed extension validate function
         let result1 = extension.validate(
-            RawOrigin::Signed(coldkey).into(), 
-            &call.clone(), 
-            &info, 
+            RawOrigin::Signed(coldkey).into(),
+            &call.clone(),
+            &info,
             10,
             (),
             &TxBaseImplication(()),
@@ -1642,9 +1643,9 @@ fn test_stake_transfers_disabled_validate() {
 
         // Submit to the signed extension validate function
         let result2 = extension.validate(
-            RawOrigin::Signed(coldkey).into(), 
-            &call.clone(), 
-            &info, 
+            RawOrigin::Signed(coldkey).into(),
+            &call.clone(),
+            &info,
             10,
             (),
             &TxBaseImplication(()),
@@ -1661,9 +1662,9 @@ fn test_stake_transfers_disabled_validate() {
 
         // Submit to the signed extension validate function
         let result3 = extension.validate(
-            RawOrigin::Signed(coldkey).into(), 
-            &call.clone(), 
-            &info, 
+            RawOrigin::Signed(coldkey).into(),
+            &call.clone(),
+            &info,
             10,
             (),
             &TxBaseImplication(()),
diff --git a/pallets/subtensor/src/tests/registration.rs b/pallets/subtensor/src/tests/registration.rs
index 34842005df..0d534cda95 100644
--- a/pallets/subtensor/src/tests/registration.rs
+++ b/pallets/subtensor/src/tests/registration.rs
@@ -10,7 +10,7 @@ use frame_support::sp_runtime::{DispatchError, transaction_validity::Transaction
 use frame_support::{assert_err, assert_noop, assert_ok};
 use frame_system::{Config, RawOrigin};
 use sp_core::U256;
-use sp_runtime::traits::{DispatchInfoOf, TxBaseImplication, TransactionExtension};
+use sp_runtime::traits::{DispatchInfoOf, TransactionExtension, TxBaseImplication};
 
 /********************************************
     subscribing::subscribe() tests
@@ -222,9 +222,9 @@ fn test_registration_under_limit() {
         let extension = SubtensorTransactionExtension::<Test>::new();
         //does not actually call register
         let result = extension.validate(
-            RawOrigin::Signed(who).into(), 
-            &call.into(), 
-            &info, 
+            RawOrigin::Signed(who).into(),
+            &call.into(),
+            &info,
             10,
             (),
             &TxBaseImplication(()),
@@ -282,9 +282,9 @@ fn test_registration_rate_limit_exceeded() {
             DispatchInfoOf::<<Test as frame_system::Config>::RuntimeCall>::default();
         let extension = SubtensorTransactionExtension::<Test>::new();
         let result = extension.validate(
-            RawOrigin::Signed(who).into(), 
-            &call.into(), 
-            &info, 
+            RawOrigin::Signed(who).into(),
+            &call.into(),
+            &info,
             10,
             (),
             &TxBaseImplication(()),
@@ -334,16 +334,15 @@ fn test_burned_registration_under_limit() {
             DispatchInfoOf::<<Test as frame_system::Config>::RuntimeCall>::default();
         let extension = SubtensorTransactionExtension::<Test>::new();
         //does not actually call register
-        let burned_register_result =
-            extension.validate(
-                RawOrigin::Signed(who).into(), 
-                &call_burned_register.into(), 
-                &info, 
-                10,
-                (),
-                &TxBaseImplication(()),
-                TransactionSource::External,
-            );
+        let burned_register_result = extension.validate(
+            RawOrigin::Signed(who).into(),
+            &call_burned_register.into(),
+            &info,
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
         assert_ok!(burned_register_result);
 
         //actually call register
@@ -381,16 +380,15 @@ fn test_burned_registration_rate_limit_exceeded() {
         let info: DispatchInfo =
             DispatchInfoOf::<<Test as frame_system::Config>::RuntimeCall>::default();
         let extension = SubtensorTransactionExtension::<Test>::new();
-        let burned_register_result =
-            extension.validate(
-                RawOrigin::Signed(who).into(), 
-                &call_burned_register.into(), 
-                &info, 
-                10,
-                (),
-                &TxBaseImplication(()),
-                TransactionSource::External,
-            );
+        let burned_register_result = extension.validate(
+            RawOrigin::Signed(who).into(),
+            &call_burned_register.into(),
+            &info,
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
 
         // Expectation: The transaction should be rejected
         assert_eq!(
@@ -435,16 +433,15 @@ fn test_burned_registration_rate_allows_burn_adjustment() {
             DispatchInfoOf::<<Test as frame_system::Config>::RuntimeCall>::default();
         let extension = SubtensorTransactionExtension::<Test>::new();
         //does not actually call register
-        let burned_register_result =
-            extension.validate(
-                RawOrigin::Signed(who).into(), 
-                &call_burned_register.into(), 
-                &info, 
-                10,
-                (),
-                &TxBaseImplication(()),
-                TransactionSource::External,
-            );
+        let burned_register_result = extension.validate(
+            RawOrigin::Signed(who).into(),
+            &call_burned_register.into(),
+            &info,
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
         assert_ok!(burned_register_result);
 
         //actually call register
diff --git a/pallets/subtensor/src/tests/serving.rs b/pallets/subtensor/src/tests/serving.rs
index 260ee0c6c9..b0ee838d28 100644
--- a/pallets/subtensor/src/tests/serving.rs
+++ b/pallets/subtensor/src/tests/serving.rs
@@ -2,8 +2,8 @@ use super::mock::*;
 
 use crate::Error;
 use crate::*;
-use frame_support::pallet_prelude::Weight;
 use frame_support::assert_noop;
+use frame_support::pallet_prelude::Weight;
 use frame_support::{
     assert_ok,
     dispatch::{DispatchClass, DispatchInfo, GetDispatchInfo, Pays},
@@ -1340,9 +1340,9 @@ fn test_serve_axon_validate() {
         let extension = crate::SubtensorTransactionExtension::<Test>::new();
         // Submit to the signed extension validate function
         let result_bad = extension.validate(
-            RawOrigin::Signed(hotkey).into(), 
-            &call.clone(), 
-            &info, 
+            RawOrigin::Signed(hotkey).into(),
+            &call.clone(),
+            &info,
             10,
             (),
             &TxBaseImplication(()),
@@ -1362,9 +1362,9 @@ fn test_serve_axon_validate() {
 
         // Submit to the signed extension validate function
         let result_ok = extension.validate(
-            RawOrigin::Signed(hotkey).into(), 
-            &call.clone(), 
-            &info, 
+            RawOrigin::Signed(hotkey).into(),
+            &call.clone(),
+            &info,
             10,
             (),
             &TxBaseImplication(()),
diff --git a/pallets/subtensor/src/tests/staking.rs b/pallets/subtensor/src/tests/staking.rs
index a09bb47754..1911d6ef5f 100644
--- a/pallets/subtensor/src/tests/staking.rs
+++ b/pallets/subtensor/src/tests/staking.rs
@@ -10,7 +10,9 @@ use super::mock::*;
 use crate::*;
 use approx::assert_abs_diff_eq;
 use frame_support::dispatch::{DispatchClass, DispatchInfo, GetDispatchInfo, Pays};
-use frame_support::sp_runtime::{DispatchError, transaction_validity::TransactionSource, traits::TxBaseImplication};
+use frame_support::sp_runtime::{
+    DispatchError, traits::TxBaseImplication, transaction_validity::TransactionSource,
+};
 use sp_core::{Get, H256, U256};
 use substrate_fixed::types::{I96F32, I110F18, U64F64, U96F32};
 /***********************************************************
@@ -2535,9 +2537,9 @@ fn test_stake_below_min_validate() {
         let extension = SubtensorTransactionExtension::<Test>::new();
         // Submit to the signed extension validate function
         let result_no_stake = extension.validate(
-            RawOrigin::Signed(coldkey).into(), 
-            &call.clone(), 
-            &info, 
+            RawOrigin::Signed(coldkey).into(),
+            &call.clone(),
+            &info,
             10,
             (),
             &TxBaseImplication(()),
@@ -2560,9 +2562,9 @@ fn test_stake_below_min_validate() {
 
         // Submit to the signed extension validate function
         let result_low_balance = extension.validate(
-            RawOrigin::Signed(coldkey).into(), 
-            &call_2.clone(), 
-            &info, 
+            RawOrigin::Signed(coldkey).into(),
+            &call_2.clone(),
+            &info,
             10,
             (),
             &TxBaseImplication(()),
@@ -2580,9 +2582,9 @@ fn test_stake_below_min_validate() {
 
         // Submit to the signed extension validate function
         let result_min_stake = extension.validate(
-            RawOrigin::Signed(coldkey).into(), 
-            &call_2.clone(), 
-            &info, 
+            RawOrigin::Signed(coldkey).into(),
+            &call_2.clone(),
+            &info,
             10,
             (),
             &TxBaseImplication(()),
@@ -2638,9 +2640,9 @@ fn test_add_stake_limit_validate() {
         let extension = SubtensorTransactionExtension::<Test>::new();
         // Submit to the signed extension validate function
         let result_no_stake = extension.validate(
-            RawOrigin::Signed(coldkey).into(), 
-            &call.clone(), 
-            &info, 
+            RawOrigin::Signed(coldkey).into(),
+            &call.clone(),
+            &info,
             10,
             (),
             &TxBaseImplication(()),
@@ -2704,9 +2706,9 @@ fn test_remove_stake_limit_validate() {
         let extension = SubtensorTransactionExtension::<Test>::new();
         // Submit to the signed extension validate function
         let result_no_stake = extension.validate(
-            RawOrigin::Signed(coldkey).into(), 
-            &call.clone(), 
-            &info, 
+            RawOrigin::Signed(coldkey).into(),
+            &call.clone(),
+            &info,
             10,
             (),
             &TxBaseImplication(()),
@@ -2803,9 +2805,9 @@ fn test_stake_low_liquidity_validate() {
         let extension = SubtensorTransactionExtension::<Test>::new();
         // Submit to the signed extension validate function
         let result_no_stake = extension.validate(
-            RawOrigin::Signed(coldkey).into(), 
-            &call.clone(), 
-            &info, 
+            RawOrigin::Signed(coldkey).into(),
+            &call.clone(),
+            &info,
             10,
             (),
             &TxBaseImplication(()),
@@ -2864,9 +2866,9 @@ fn test_unstake_low_liquidity_validate() {
         let extension = SubtensorTransactionExtension::<Test>::new();
         // Submit to the signed extension validate function
         let result_no_stake = extension.validate(
-            RawOrigin::Signed(coldkey).into(), 
-            &call.clone(), 
-            &info, 
+            RawOrigin::Signed(coldkey).into(),
+            &call.clone(),
+            &info,
             10,
             (),
             &TxBaseImplication(()),
@@ -2921,9 +2923,9 @@ fn test_unstake_all_validate() {
         let extension = SubtensorTransactionExtension::<Test>::new();
         // Submit to the signed extension validate function
         let result_no_stake = extension.validate(
-            RawOrigin::Signed(coldkey).into(), 
-            &call.clone(), 
-            &info, 
+            RawOrigin::Signed(coldkey).into(),
+            &call.clone(),
+            &info,
             10,
             (),
             &TxBaseImplication(()),
diff --git a/pallets/subtensor/src/tests/swap_coldkey.rs b/pallets/subtensor/src/tests/swap_coldkey.rs
index efea978eb9..f273e1d292 100644
--- a/pallets/subtensor/src/tests/swap_coldkey.rs
+++ b/pallets/subtensor/src/tests/swap_coldkey.rs
@@ -2178,16 +2178,15 @@ fn test_coldkey_in_swap_schedule_prevents_funds_usage() {
             netuid,
             amount_staked: 100_000_000_000,
         });
-        let result =
-            extension.validate(
-                RawOrigin::Signed(who).into(), 
-                &call.clone(), 
-                &info, 
-                10,
-                (),
-                &TxBaseImplication(()),
-                TransactionSource::External,
-            );
+        let result = extension.validate(
+            RawOrigin::Signed(who).into(),
+            &call.clone(),
+            &info,
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
         // Should fail
         assert_eq!(
             // Should get an invalid transaction error
@@ -2204,9 +2203,9 @@ fn test_coldkey_in_swap_schedule_prevents_funds_usage() {
             allow_partial: false,
         });
         let result = extension.validate(
-            RawOrigin::Signed(who).into(), 
-            &call.clone(), 
-            &info, 
+            RawOrigin::Signed(who).into(),
+            &call.clone(),
+            &info,
             10,
             (),
             &TxBaseImplication(()),
@@ -2227,9 +2226,9 @@ fn test_coldkey_in_swap_schedule_prevents_funds_usage() {
             alpha_amount: 100_000_000_000,
         });
         let result = extension.validate(
-            RawOrigin::Signed(who).into(), 
-            &call.clone(), 
-            &info, 
+            RawOrigin::Signed(who).into(),
+            &call.clone(),
+            &info,
             10,
             (),
             &TxBaseImplication(()),
@@ -2252,9 +2251,9 @@ fn test_coldkey_in_swap_schedule_prevents_funds_usage() {
             allow_partial: false,
         });
         let result = extension.validate(
-            RawOrigin::Signed(who).into(), 
-            &call.clone(), 
-            &info, 
+            RawOrigin::Signed(who).into(),
+            &call.clone(),
+            &info,
             10,
             (),
             &TxBaseImplication(()),
@@ -2276,9 +2275,9 @@ fn test_coldkey_in_swap_schedule_prevents_funds_usage() {
             alpha_amount: 100_000_000_000,
         });
         let result = extension.validate(
-            RawOrigin::Signed(who).into(), 
-            &call.clone(), 
-            &info, 
+            RawOrigin::Signed(who).into(),
+            &call.clone(),
+            &info,
             10,
             (),
             &TxBaseImplication(()),
@@ -2300,9 +2299,9 @@ fn test_coldkey_in_swap_schedule_prevents_funds_usage() {
             alpha_amount: 100_000_000_000,
         });
         let result = extension.validate(
-            RawOrigin::Signed(who).into(), 
-            &call.clone(), 
-            &info, 
+            RawOrigin::Signed(who).into(),
+            &call.clone(),
+            &info,
             10,
             (),
             &TxBaseImplication(()),
@@ -2321,9 +2320,9 @@ fn test_coldkey_in_swap_schedule_prevents_funds_usage() {
             keep_alive: false,
         });
         let result = extension.validate(
-            RawOrigin::Signed(who).into(), 
-            &call.clone(), 
-            &info, 
+            RawOrigin::Signed(who).into(),
+            &call.clone(),
+            &info,
             10,
             (),
             &TxBaseImplication(()),
@@ -2342,9 +2341,9 @@ fn test_coldkey_in_swap_schedule_prevents_funds_usage() {
             value: 100_000_000_000,
         });
         let result = extension.validate(
-            RawOrigin::Signed(who).into(), 
-            &call.clone(), 
-            &info, 
+            RawOrigin::Signed(who).into(),
+            &call.clone(),
+            &info,
             10,
             (),
             &TxBaseImplication(()),
@@ -2363,9 +2362,9 @@ fn test_coldkey_in_swap_schedule_prevents_funds_usage() {
             value: 100_000_000_000,
         });
         let result = extension.validate(
-            RawOrigin::Signed(who).into(), 
-            &call.clone(), 
-            &info, 
+            RawOrigin::Signed(who).into(),
+            &call.clone(),
+            &info,
             10,
             (),
             &TxBaseImplication(()),
@@ -2381,9 +2380,9 @@ fn test_coldkey_in_swap_schedule_prevents_funds_usage() {
         // Burned register
         let call = RuntimeCall::SubtensorModule(SubtensorCall::burned_register { netuid, hotkey });
         let result = extension.validate(
-            RawOrigin::Signed(who).into(), 
-            &call.clone(), 
-            &info, 
+            RawOrigin::Signed(who).into(),
+            &call.clone(),
+            &info,
             10,
             (),
             &TxBaseImplication(()),
@@ -2403,9 +2402,9 @@ fn test_coldkey_in_swap_schedule_prevents_funds_usage() {
             amount_unstaked: 1_000_000,
         });
         let result = extension.validate(
-            RawOrigin::Signed(who).into(), 
-            &call.clone(), 
-            &info, 
+            RawOrigin::Signed(who).into(),
+            &call.clone(),
+            &info,
             10,
             (),
             &TxBaseImplication(()),
@@ -2423,9 +2422,9 @@ fn test_coldkey_in_swap_schedule_prevents_funds_usage() {
             allow_partial: true,
         });
         let result = extension.validate(
-            RawOrigin::Signed(who).into(), 
-            &call.clone(), 
-            &info, 
+            RawOrigin::Signed(who).into(),
+            &call.clone(),
+            &info,
             10,
             (),
             &TxBaseImplication(()),
@@ -2493,16 +2492,15 @@ fn test_coldkey_in_swap_schedule_prevents_critical_calls() {
         // Dissolve network
         let call =
             RuntimeCall::SubtensorModule(SubtensorCall::dissolve_network { netuid, coldkey });
-        let result =
-            extension.validate(
-                RawOrigin::Signed(who).into(), 
-                &call.clone(), 
-                &info, 
-                10,
-                (),
-                &TxBaseImplication(()),
-                TransactionSource::External,
-            );
+        let result = extension.validate(
+            RawOrigin::Signed(who).into(),
+            &call.clone(),
+            &info,
+            10,
+            (),
+            &TxBaseImplication(()),
+            TransactionSource::External,
+        );
         // Should fail
         assert_eq!(
             // Should get an invalid transaction error
diff --git a/pallets/subtensor/src/tests/weights.rs b/pallets/subtensor/src/tests/weights.rs
index 22f89ccce7..0b26755c7a 100644
--- a/pallets/subtensor/src/tests/weights.rs
+++ b/pallets/subtensor/src/tests/weights.rs
@@ -102,9 +102,9 @@ fn test_set_rootweights_validate() {
         let extension = crate::SubtensorTransactionExtension::<Test>::new();
         // Submit to the signed extension validate function
         let result_no_stake = extension.validate(
-            RawOrigin::Signed(who).into(), 
-            &call.clone(), 
-            &info, 
+            RawOrigin::Signed(who).into(),
+            &call.clone(),
+            &info,
             10,
             (),
             &TxBaseImplication(()),
@@ -133,9 +133,9 @@ fn test_set_rootweights_validate() {
 
         // Submit to the signed extension validate function
         let result_min_stake = extension.validate(
-            RawOrigin::Signed(who).into(), 
-            &call.clone(), 
-            &info, 
+            RawOrigin::Signed(who).into(),
+            &call.clone(),
+            &info,
             10,
             (),
             &TxBaseImplication(()),
@@ -156,9 +156,9 @@ fn test_set_rootweights_validate() {
         assert!(SubtensorModule::get_total_stake_for_hotkey(&hotkey) > min_stake);
 
         let result_more_stake = extension.validate(
-            RawOrigin::Signed(who).into(), 
-            &call.clone(), 
-            &info, 
+            RawOrigin::Signed(who).into(),
+            &call.clone(),
+            &info,
             10,
             (),
             &TxBaseImplication(()),
@@ -241,9 +241,9 @@ fn test_commit_weights_validate() {
         let extension = crate::SubtensorTransactionExtension::<Test>::new();
         // Submit to the signed extension validate function
         let result_no_stake = extension.validate(
-            RawOrigin::Signed(who).into(), 
-            &call.clone(), 
-            &info, 
+            RawOrigin::Signed(who).into(),
+            &call.clone(),
+            &info,
             10,
             (),
             &TxBaseImplication(()),
@@ -272,9 +272,9 @@ fn test_commit_weights_validate() {
 
         // Submit to the signed extension validate function
         let result_min_stake = extension.validate(
-            RawOrigin::Signed(who).into(), 
-            &call.clone(), 
-            &info, 
+            RawOrigin::Signed(who).into(),
+            &call.clone(),
+            &info,
             10,
             (),
             &TxBaseImplication(()),
@@ -295,9 +295,9 @@ fn test_commit_weights_validate() {
         assert!(SubtensorModule::get_total_stake_for_hotkey(&hotkey) > min_stake);
 
         let result_more_stake = extension.validate(
-            RawOrigin::Signed(who).into(), 
-            &call.clone(), 
-            &info, 
+            RawOrigin::Signed(who).into(),
+            &call.clone(),
+            &info,
             10,
             (),
             &TxBaseImplication(()),
@@ -374,9 +374,9 @@ fn test_set_weights_validate() {
         let extension = crate::SubtensorTransactionExtension::<Test>::new();
         // Submit to the signed extension validate function
         let result_no_stake = extension.validate(
-            RawOrigin::Signed(who).into(), 
-            &call.clone(), 
-            &info, 
+            RawOrigin::Signed(who).into(),
+            &call.clone(),
+            &info,
             10,
             (),
             &TxBaseImplication(()),
@@ -404,9 +404,9 @@ fn test_set_weights_validate() {
 
         // Submit to the signed extension validate function
         let result_min_stake = extension.validate(
-            RawOrigin::Signed(who).into(), 
-            &call.clone(), 
-            &info, 
+            RawOrigin::Signed(who).into(),
+            &call.clone(),
+            &info,
             10,
             (),
             &TxBaseImplication(()),
@@ -463,9 +463,9 @@ fn test_reveal_weights_validate() {
         let extension = crate::SubtensorTransactionExtension::<Test>::new();
         // Submit to the signed extension validate function
         let result_no_stake = extension.validate(
-            RawOrigin::Signed(who).into(), 
-            &call.clone(), 
-            &info, 
+            RawOrigin::Signed(who).into(),
+            &call.clone(),
+            &info,
             10,
             (),
             &TxBaseImplication(()),
@@ -494,9 +494,9 @@ fn test_reveal_weights_validate() {
 
         // Submit to the signed extension validate function
         let result_min_stake = extension.validate(
-            RawOrigin::Signed(who).into(), 
-            &call.clone(), 
-            &info, 
+            RawOrigin::Signed(who).into(),
+            &call.clone(),
+            &info,
             10,
             (),
             &TxBaseImplication(()),
@@ -517,9 +517,9 @@ fn test_reveal_weights_validate() {
         assert!(SubtensorModule::get_total_stake_for_hotkey(&hotkey) > min_stake);
 
         let result_more_stake = extension.validate(
-            RawOrigin::Signed(who).into(), 
-            &call.clone(), 
-            &info, 
+            RawOrigin::Signed(who).into(),
+            &call.clone(),
+            &info,
             10,
             (),
             &TxBaseImplication(()),
diff --git a/runtime/src/check_nonce.rs b/runtime/src/check_nonce.rs
index 37d0e97cb7..d8688f4beb 100644
--- a/runtime/src/check_nonce.rs
+++ b/runtime/src/check_nonce.rs
@@ -2,17 +2,20 @@
 // https://github.com/paritytech/polkadot-sdk/blob/b600af050d6b6c8da59ae2a2a793ee2d8827ab1e/substrate/frame/system/src/extensions/check_nonce.rs
 
 use codec::{Decode, Encode};
-use frame_support::{dispatch::{DispatchInfo, Pays}, RuntimeDebugNoBound};
+use frame_support::{
+    RuntimeDebugNoBound,
+    dispatch::{DispatchInfo, Pays},
+};
 use frame_system::Config;
 use scale_info::TypeInfo;
 use sp_runtime::{
-    DispatchResult,
-    Weight,
-    Saturating,
-    traits::{DispatchInfoOf, Dispatchable, One, Zero, TransactionExtension, AsSystemOriginSigner, ValidateResult, PostDispatchInfoOf},
+    DispatchResult, Saturating, Weight,
+    traits::{
+        AsSystemOriginSigner, DispatchInfoOf, Dispatchable, One, PostDispatchInfoOf,
+        TransactionExtension, ValidateResult, Zero,
+    },
     transaction_validity::{
-        TransactionSource,
-        InvalidTransaction, TransactionLongevity,TransactionValidityError,
+        InvalidTransaction, TransactionLongevity, TransactionSource, TransactionValidityError,
         ValidTransaction,
     },
 };
@@ -58,109 +61,116 @@ impl<T: Config> sp_std::fmt::Debug for CheckNonce<T> {
 /// Operation to perform from `validate` to `prepare` in [`CheckNonce`] transaction extension.
 #[derive(RuntimeDebugNoBound)]
 pub enum Val<T: Config> {
-	/// Account and its nonce to check for.
-	CheckNonce((T::AccountId, T::Nonce)),
-	/// Weight to refund.
-	Refund(Weight),
+    /// Account and its nonce to check for.
+    CheckNonce((T::AccountId, T::Nonce)),
+    /// Weight to refund.
+    Refund(Weight),
 }
 
 /// Operation to perform from `prepare` to `post_dispatch_details` in [`CheckNonce`] transaction
 /// extension.
 #[derive(RuntimeDebugNoBound)]
 pub enum Pre {
-	/// The transaction extension weight should not be refunded.
-	NonceChecked,
-	/// The transaction extension weight should be refunded.
-	Refund(Weight),
+    /// The transaction extension weight should not be refunded.
+    NonceChecked,
+    /// The transaction extension weight should be refunded.
+    Refund(Weight),
 }
 
 impl<T: Config> TransactionExtension<T::RuntimeCall> for CheckNonce<T>
 where
-	T::RuntimeCall: Dispatchable<Info = DispatchInfo>,
-	<T::RuntimeCall as Dispatchable>::RuntimeOrigin: AsSystemOriginSigner<T::AccountId> + Clone,
+    T::RuntimeCall: Dispatchable<Info = DispatchInfo>,
+    <T::RuntimeCall as Dispatchable>::RuntimeOrigin: AsSystemOriginSigner<T::AccountId> + Clone,
 {
-	const IDENTIFIER: &'static str = "CheckNonce";
-	type Implicit = ();
-	type Val = Val<T>;
-	type Pre = Pre;
+    const IDENTIFIER: &'static str = "CheckNonce";
+    type Implicit = ();
+    type Val = Val<T>;
+    type Pre = Pre;
 
-	fn weight(&self, _: &T::RuntimeCall) -> Weight {
+    fn weight(&self, _: &T::RuntimeCall) -> Weight {
         // TODO: benchmark transaction extension
         Weight::zero()
-	}
-
-	fn validate(
-		&self,
-		origin: <T as Config>::RuntimeOrigin,
-		call: &T::RuntimeCall,
-		info: &DispatchInfoOf<T::RuntimeCall>,
-		_len: usize,
-		_self_implicit: Self::Implicit,
-		_inherited_implication: &impl Encode,
+    }
+
+    fn validate(
+        &self,
+        origin: <T as Config>::RuntimeOrigin,
+        call: &T::RuntimeCall,
+        info: &DispatchInfoOf<T::RuntimeCall>,
+        _len: usize,
+        _self_implicit: Self::Implicit,
+        _inherited_implication: &impl Encode,
         _source: TransactionSource,
-	) -> ValidateResult<Self::Val, T::RuntimeCall> {
-		let Some(who) = origin.as_system_origin_signer() else {
-			return Ok((Default::default(), Val::Refund(self.weight(call)), origin))
-		};
-		let account = frame_system::Account::<T>::get(who);
-		if info.pays_fee == Pays::Yes && account.providers.is_zero() && account.sufficients.is_zero() {
-			// Nonce storage not paid for
-			return Err(InvalidTransaction::Payment.into())
-		}
-		if self.0 < account.nonce {
-			return Err(InvalidTransaction::Stale.into())
-		}
-
-		let provides = vec![Encode::encode(&(&who, self.0))];
-		let requires = if account.nonce < self.0 {
-			vec![Encode::encode(&(&who, self.0.saturating_sub(One::one())))]
-		} else {
-			vec![]
-		};
-
-		let validity = ValidTransaction {
-			priority: 0,
-			requires,
-			provides,
-			longevity: TransactionLongevity::max_value(),
-			propagate: true,
-		};
-
-		Ok((validity, Val::CheckNonce((who.clone(), account.nonce)), origin))
-	}
-
-	fn prepare(
-		self,
-		val: Self::Val,
-		_origin: &T::RuntimeOrigin,
-		_call: &T::RuntimeCall,
-		_info: &DispatchInfoOf<T::RuntimeCall>,
-		_len: usize,
-	) -> Result<Self::Pre, TransactionValidityError> {
-		let (who, mut nonce) = match val {
-			Val::CheckNonce((who, nonce)) => (who, nonce),
-			Val::Refund(weight) => return Ok(Pre::Refund(weight)),
-		};
-
-		// `self.0 < nonce` already checked in `validate`.
-		if self.0 > nonce {
-			return Err(InvalidTransaction::Future.into())
-		}
-		nonce += T::Nonce::one();
-		frame_system::Account::<T>::mutate(who, |account| account.nonce = nonce);
-		Ok(Pre::NonceChecked)
-	}
-
-	fn post_dispatch_details(
-		pre: Self::Pre,
-		_info: &DispatchInfo,
-		_post_info: &PostDispatchInfoOf<T::RuntimeCall>,
-		_len: usize,
-		_result: &DispatchResult,
-	) -> Result<Weight, TransactionValidityError> {
-		match pre {
-			Pre::NonceChecked => Ok(Weight::zero()),
-			Pre::Refund(weight) => Ok(weight),
-		}
-	}
-}
\ No newline at end of file
+    ) -> ValidateResult<Self::Val, T::RuntimeCall> {
+        let Some(who) = origin.as_system_origin_signer() else {
+            return Ok((Default::default(), Val::Refund(self.weight(call)), origin));
+        };
+        let account = frame_system::Account::<T>::get(who);
+        if info.pays_fee == Pays::Yes
+            && account.providers.is_zero()
+            && account.sufficients.is_zero()
+        {
+            // Nonce storage not paid for
+            return Err(InvalidTransaction::Payment.into());
+        }
+        if self.0 < account.nonce {
+            return Err(InvalidTransaction::Stale.into());
+        }
+
+        let provides = vec![Encode::encode(&(&who, self.0))];
+        let requires = if account.nonce < self.0 {
+            vec![Encode::encode(&(&who, self.0.saturating_sub(One::one())))]
+        } else {
+            vec![]
+        };
+
+        let validity = ValidTransaction {
+            priority: 0,
+            requires,
+            provides,
+            longevity: TransactionLongevity::max_value(),
+            propagate: true,
+        };
+
+        Ok((
+            validity,
+            Val::CheckNonce((who.clone(), account.nonce)),
+            origin,
+        ))
+    }
+
+    fn prepare(
+        self,
+        val: Self::Val,
+        _origin: &T::RuntimeOrigin,
+        _call: &T::RuntimeCall,
+        _info: &DispatchInfoOf<T::RuntimeCall>,
+        _len: usize,
+    ) -> Result<Self::Pre, TransactionValidityError> {
+        let (who, mut nonce) = match val {
+            Val::CheckNonce((who, nonce)) => (who, nonce),
+            Val::Refund(weight) => return Ok(Pre::Refund(weight)),
+        };
+
+        // `self.0 < nonce` already checked in `validate`.
+        if self.0 > nonce {
+            return Err(InvalidTransaction::Future.into());
+        }
+        nonce += T::Nonce::one();
+        frame_system::Account::<T>::mutate(who, |account| account.nonce = nonce);
+        Ok(Pre::NonceChecked)
+    }
+
+    fn post_dispatch_details(
+        pre: Self::Pre,
+        _info: &DispatchInfo,
+        _post_info: &PostDispatchInfoOf<T::RuntimeCall>,
+        _len: usize,
+        _result: &DispatchResult,
+    ) -> Result<Weight, TransactionValidityError> {
+        match pre {
+            Pre::NonceChecked => Ok(Weight::zero()),
+            Pre::Refund(weight) => Ok(weight),
+        }
+    }
+}
diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index e2e689bb28..36ccf07d7f 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -13,7 +13,6 @@ mod migrations;
 
 use codec::{Compact, Decode, Encode};
 use frame_support::traits::{Imbalance, InsideBoth};
-use sp_runtime::Cow;
 use frame_support::{
     PalletId,
     dispatch::DispatchResultWithPostInfo,
@@ -48,10 +47,10 @@ use sp_core::{
     H160, H256, OpaqueMetadata, U256,
     crypto::{ByteArray, KeyTypeId},
 };
+use sp_runtime::Cow;
 use sp_runtime::generic::Era;
 use sp_runtime::{
-    AccountId32, ApplyExtrinsicResult, ConsensusEngineId, generic,
-    impl_opaque_keys,
+    AccountId32, ApplyExtrinsicResult, ConsensusEngineId, generic, impl_opaque_keys,
     traits::{
         AccountIdLookup, BlakeTwo256, Block as BlockT, DispatchInfoOf, Dispatchable, NumberFor,
         One, PostDispatchInfoOf, UniqueSaturatedInto, Verify,

From f048f13d5fe5204c239a7838ba5bc7e3ecbed6fb Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Wed, 11 Jun 2025 17:37:37 +0200
Subject: [PATCH 306/418] commit Cargo.lock

---
 runtime/src/check_nonce.rs | 2 +-
 runtime/src/lib.rs         | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/runtime/src/check_nonce.rs b/runtime/src/check_nonce.rs
index d8688f4beb..2e05c63867 100644
--- a/runtime/src/check_nonce.rs
+++ b/runtime/src/check_nonce.rs
@@ -128,7 +128,7 @@ where
             priority: 0,
             requires,
             provides,
-            longevity: TransactionLongevity::max_value(),
+            longevity: TransactionLongevity::MAX,
             propagate: true,
         };
 
diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index 36ccf07d7f..6a155b65f7 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -2146,7 +2146,7 @@ impl_runtime_apis! {
 
         fn dispatch_benchmark(
             config: frame_benchmarking::BenchmarkConfig
-        ) -> Result<Vec<frame_benchmarking::BenchmarkBatch>, sp_runtime::RuntimeString> {
+        ) -> Result<Vec<frame_benchmarking::BenchmarkBatch>, Cow<'static, str>> {
             use frame_benchmarking::{baseline, Benchmarking, BenchmarkBatch};
             use sp_storage::TrackedStorageKey;
 

From 053c2675d7378aefbe24a6d34aeff41999616aa8 Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Wed, 11 Jun 2025 17:38:50 +0200
Subject: [PATCH 307/418] commit Cargo.lock

---
 runtime/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index 6a155b65f7..05fc5df3dc 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -2146,7 +2146,7 @@ impl_runtime_apis! {
 
         fn dispatch_benchmark(
             config: frame_benchmarking::BenchmarkConfig
-        ) -> Result<Vec<frame_benchmarking::BenchmarkBatch>, Cow<'static, str>> {
+        ) -> Result<Vec<frame_benchmarking::BenchmarkBatch>, parity_scale_codec::alloc::string::String> {
             use frame_benchmarking::{baseline, Benchmarking, BenchmarkBatch};
             use sp_storage::TrackedStorageKey;
 

From 4eb2946ec83e51148f33f4e23eb704e313b4f483 Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Wed, 11 Jun 2025 17:40:21 +0200
Subject: [PATCH 308/418] commit Cargo.lock

---
 runtime/src/lib.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index 05fc5df3dc..da7894eb51 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -90,7 +90,7 @@ pub use sp_runtime::{Perbill, Permill};
 
 use core::marker::PhantomData;
 
-use scale_info::TypeInfo;
+use scale_info::{TypeInfo, prelude::string};
 
 // Frontier
 use fp_rpc::TransactionStatus;
@@ -2146,7 +2146,7 @@ impl_runtime_apis! {
 
         fn dispatch_benchmark(
             config: frame_benchmarking::BenchmarkConfig
-        ) -> Result<Vec<frame_benchmarking::BenchmarkBatch>, parity_scale_codec::alloc::string::String> {
+        ) -> Result<Vec<frame_benchmarking::BenchmarkBatch>, string::String> {
             use frame_benchmarking::{baseline, Benchmarking, BenchmarkBatch};
             use sp_storage::TrackedStorageKey;
 

From 20c9dabf75381f1df7f07ae584c9b497d45e2778 Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Wed, 11 Jun 2025 17:42:16 +0200
Subject: [PATCH 309/418] commit Cargo.lock

---
 pallets/subtensor/src/tests/move_stake.rs | 2 ++
 runtime/src/lib.rs                        | 2 +-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/pallets/subtensor/src/tests/move_stake.rs b/pallets/subtensor/src/tests/move_stake.rs
index 64713e5c2f..f2139fd760 100644
--- a/pallets/subtensor/src/tests/move_stake.rs
+++ b/pallets/subtensor/src/tests/move_stake.rs
@@ -1,3 +1,5 @@
+#![allow(clippy::unwrap-used)]
+
 use super::mock::*;
 use crate::*;
 use approx::assert_abs_diff_eq;
diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index da7894eb51..639879efd3 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -90,7 +90,7 @@ pub use sp_runtime::{Perbill, Permill};
 
 use core::marker::PhantomData;
 
-use scale_info::{TypeInfo, prelude::string};
+use scale_info::TypeInfo;
 
 // Frontier
 use fp_rpc::TransactionStatus;

From 07787d6e9d9757e2e7a67701ef8fb81737104682 Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Wed, 11 Jun 2025 17:42:56 +0200
Subject: [PATCH 310/418] commit Cargo.lock

---
 pallets/subtensor/src/tests/move_stake.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pallets/subtensor/src/tests/move_stake.rs b/pallets/subtensor/src/tests/move_stake.rs
index f2139fd760..c10e924ef7 100644
--- a/pallets/subtensor/src/tests/move_stake.rs
+++ b/pallets/subtensor/src/tests/move_stake.rs
@@ -1,4 +1,4 @@
-#![allow(clippy::unwrap-used)]
+#![allow(clippy::unwrap_used)]
 
 use super::mock::*;
 use crate::*;

From b2dc9b0c1e425df9012d724fe9450173e1d47480 Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Wed, 11 Jun 2025 17:44:12 +0200
Subject: [PATCH 311/418] commit Cargo.lock

---
 pallets/subtensor/src/tests/weights.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pallets/subtensor/src/tests/weights.rs b/pallets/subtensor/src/tests/weights.rs
index 0b26755c7a..64a45151ff 100644
--- a/pallets/subtensor/src/tests/weights.rs
+++ b/pallets/subtensor/src/tests/weights.rs
@@ -1,4 +1,4 @@
-#![allow(clippy::indexing_slicing)]
+#![allow(clippy::indexing_slicing, clippy::unwrap_used)]
 
 use super::mock::*;
 use crate::coinbase::run_coinbase::WeightsTlockPayload;

From f9512f8f33a72043d5f0e489377e299fe86ed6d3 Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Wed, 11 Jun 2025 17:45:20 +0200
Subject: [PATCH 312/418] commit Cargo.lock

---
 runtime/src/lib.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index 639879efd3..2ffeb6e8b2 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -12,6 +12,7 @@ pub mod check_nonce;
 mod migrations;
 
 use codec::{Compact, Decode, Encode};
+use scale_info::prelude::string;
 use frame_support::traits::{Imbalance, InsideBoth};
 use frame_support::{
     PalletId,

From 1501629c125ec2c747efd1c8dce6db41efa3e619 Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Wed, 11 Jun 2025 17:46:35 +0200
Subject: [PATCH 313/418] cargo fmt

---
 runtime/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index 2ffeb6e8b2..6dca5c6be0 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -12,7 +12,6 @@ pub mod check_nonce;
 mod migrations;
 
 use codec::{Compact, Decode, Encode};
-use scale_info::prelude::string;
 use frame_support::traits::{Imbalance, InsideBoth};
 use frame_support::{
     PalletId,
@@ -41,6 +40,7 @@ use pallet_subtensor::rpc_info::{
     stake_info::StakeInfo,
     subnet_info::{SubnetHyperparams, SubnetInfo, SubnetInfov2},
 };
+use scale_info::prelude::string;
 use smallvec::smallvec;
 use sp_api::impl_runtime_apis;
 use sp_consensus_aura::sr25519::AuthorityId as AuraId;

From e15ee92568e811075ac0224eb291e65b68ac01c8 Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Wed, 11 Jun 2025 17:47:23 +0200
Subject: [PATCH 314/418] commit Cargo.lock

---
 pallets/subtensor/src/tests/serving.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/pallets/subtensor/src/tests/serving.rs b/pallets/subtensor/src/tests/serving.rs
index b0ee838d28..d3dea89ea6 100644
--- a/pallets/subtensor/src/tests/serving.rs
+++ b/pallets/subtensor/src/tests/serving.rs
@@ -1,3 +1,4 @@
+#![allow(clippy::unwrap_used)]
 use super::mock::*;
 
 use crate::Error;

From b9efc5a8aa395674a7ea1f077348a13f0270f7cb Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Wed, 11 Jun 2025 17:48:03 +0200
Subject: [PATCH 315/418] cargo clippy

---
 runtime/src/lib.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index 6dca5c6be0..639879efd3 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -40,7 +40,6 @@ use pallet_subtensor::rpc_info::{
     stake_info::StakeInfo,
     subnet_info::{SubnetHyperparams, SubnetInfo, SubnetInfov2},
 };
-use scale_info::prelude::string;
 use smallvec::smallvec;
 use sp_api::impl_runtime_apis;
 use sp_consensus_aura::sr25519::AuthorityId as AuraId;

From b158e64bd8cde8898c722a60d7f245b5dfb15d50 Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Wed, 11 Jun 2025 17:50:20 +0200
Subject: [PATCH 316/418] commit Cargo.lock

---
 runtime/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index 639879efd3..1a50cf2314 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -2146,7 +2146,7 @@ impl_runtime_apis! {
 
         fn dispatch_benchmark(
             config: frame_benchmarking::BenchmarkConfig
-        ) -> Result<Vec<frame_benchmarking::BenchmarkBatch>, string::String> {
+        ) -> Result<Vec<frame_benchmarking::BenchmarkBatch>, alloc::string::String> {
             use frame_benchmarking::{baseline, Benchmarking, BenchmarkBatch};
             use sp_storage::TrackedStorageKey;
 

From 308aeffedefda5d51b67b12fcb46abf76b00d216 Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Wed, 11 Jun 2025 17:51:08 +0200
Subject: [PATCH 317/418] commit Cargo.lock

---
 runtime/src/lib.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index 1a50cf2314..cc90a796c9 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -11,6 +11,8 @@ include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));
 pub mod check_nonce;
 mod migrations;
 
+extern crate alloc;
+
 use codec::{Compact, Decode, Encode};
 use frame_support::traits::{Imbalance, InsideBoth};
 use frame_support::{

From da4fab7c24eb943ef2960db30825a3c052df29f5 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Wed, 11 Jun 2025 13:26:36 -0400
Subject: [PATCH 318/418] Rename variables in to_token_amounts to more human
 friendly

---
 pallets/swap/src/position.rs | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/pallets/swap/src/position.rs b/pallets/swap/src/position.rs
index a2ce000446..bd3a534afc 100644
--- a/pallets/swap/src/position.rs
+++ b/pallets/swap/src/position.rs
@@ -56,39 +56,39 @@ impl<T: Config> Position<T> {
     pub fn to_token_amounts(&self, sqrt_price_curr: SqrtPrice) -> Result<(u64, u64), Error<T>> {
         let one = U64F64::saturating_from_num(1);
 
-        let sqrt_pa = self
+        let sqrt_price_low = self
             .tick_low
             .try_to_sqrt_price()
             .map_err(|_| Error::<T>::InvalidTickRange)?;
-        let sqrt_pb = self
+        let sqrt_price_high = self
             .tick_high
             .try_to_sqrt_price()
             .map_err(|_| Error::<T>::InvalidTickRange)?;
         let liquidity_fixed = U64F64::saturating_from_num(self.liquidity);
 
-        Ok(if sqrt_price_curr < sqrt_pa {
+        Ok(if sqrt_price_curr < sqrt_price_low {
             (
                 0,
                 liquidity_fixed
-                    .saturating_mul(one.safe_div(sqrt_pa).saturating_sub(one.safe_div(sqrt_pb)))
+                    .saturating_mul(one.safe_div(sqrt_price_low).saturating_sub(one.safe_div(sqrt_price_high)))
                     .saturating_to_num::<u64>(),
             )
-        } else if sqrt_price_curr > sqrt_pb {
+        } else if sqrt_price_curr > sqrt_price_high {
             (
                 liquidity_fixed
-                    .saturating_mul(sqrt_pb.saturating_sub(sqrt_pa))
+                    .saturating_mul(sqrt_price_high.saturating_sub(sqrt_price_low))
                     .saturating_to_num::<u64>(),
                 0,
             )
         } else {
             (
                 liquidity_fixed
-                    .saturating_mul(sqrt_price_curr.saturating_sub(sqrt_pa))
+                    .saturating_mul(sqrt_price_curr.saturating_sub(sqrt_price_low))
                     .saturating_to_num::<u64>(),
                 liquidity_fixed
                     .saturating_mul(
                         one.safe_div(sqrt_price_curr)
-                            .saturating_sub(one.safe_div(sqrt_pb)),
+                            .saturating_sub(one.safe_div(sqrt_price_high)),
                     )
                     .saturating_to_num::<u64>(),
             )

From 44ac1831fed97ff372d8a624a1aea884dcbcc57a Mon Sep 17 00:00:00 2001
From: John Reed <87283488+JohnReedV@users.noreply.github.com>
Date: Wed, 11 Jun 2025 11:11:06 -0700
Subject: [PATCH 319/418] add more parameters to v2

---
 pallets/subtensor/src/rpc_info/subnet_info.rs | 15 ++++++++++++++-
 pallets/subtensor/src/utils/misc.rs           |  8 ++++++++
 2 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/pallets/subtensor/src/rpc_info/subnet_info.rs b/pallets/subtensor/src/rpc_info/subnet_info.rs
index e5f18ce36b..9643f815ee 100644
--- a/pallets/subtensor/src/rpc_info/subnet_info.rs
+++ b/pallets/subtensor/src/rpc_info/subnet_info.rs
@@ -3,6 +3,7 @@ use frame_support::pallet_prelude::{Decode, Encode};
 use frame_support::storage::IterableStorageMap;
 extern crate alloc;
 use codec::Compact;
+use substrate_fixed::types::I32F32;
 
 #[freeze_struct("1eee6f3911800c6b")]
 #[derive(Decode, Encode, PartialEq, Eq, Clone, Debug, TypeInfo)]
@@ -83,7 +84,7 @@ pub struct SubnetHyperparams {
     liquid_alpha_enabled: bool,
 }
 
-#[freeze_struct("cb67d7ada314398e")]
+#[freeze_struct("34ec2962181256c6")]
 #[derive(Decode, Encode, PartialEq, Eq, Clone, Debug, TypeInfo)]
 pub struct SubnetHyperparamsV2 {
     rho: Compact<u16>,
@@ -113,7 +114,11 @@ pub struct SubnetHyperparamsV2 {
     alpha_high: Compact<u16>,
     alpha_low: Compact<u16>,
     liquid_alpha_enabled: bool,
+    alpha_sigmoid_steepness: I32F32,
     yuma_version: Compact<u16>,
+    subnet_token_enabled: bool,
+    transfers_enabled: bool,
+    bonds_reset_enabled: bool,
 }
 
 impl<T: Config> Pallet<T> {
@@ -352,10 +357,14 @@ impl<T: Config> Pallet<T> {
         let commit_reveal_weights_enabled = Self::get_commit_reveal_weights_enabled(netuid);
         let liquid_alpha_enabled = Self::get_liquid_alpha_enabled(netuid);
         let (alpha_low, alpha_high): (u16, u16) = Self::get_alpha_values(netuid);
+        let alpha_sigmoid_steepness = Self::get_alpha_sigmoid_steepness(netuid);
         let yuma_version: u16 = match Self::get_yuma3_enabled(netuid) {
             true => 3u16,
             false => 2u16,
         };
+        let subnet_token_enabled = Self::get_subtoken_enabled(netuid);
+        let transfers_enabled = Self::get_transfer_toggle(netuid);
+        let bonds_reset = Self::get_bonds_reset(netuid);
 
         Some(SubnetHyperparamsV2 {
             rho: rho.into(),
@@ -385,7 +394,11 @@ impl<T: Config> Pallet<T> {
             alpha_high: alpha_high.into(),
             alpha_low: alpha_low.into(),
             liquid_alpha_enabled,
+            alpha_sigmoid_steepness: alpha_sigmoid_steepness,
             yuma_version: yuma_version.into(),
+            subnet_token_enabled: subnet_token_enabled,
+            transfers_enabled: transfers_enabled,
+            bonds_reset_enabled: bonds_reset,
         })
     }
 }
diff --git a/pallets/subtensor/src/utils/misc.rs b/pallets/subtensor/src/utils/misc.rs
index 899fa83646..7c69d2d7bd 100644
--- a/pallets/subtensor/src/utils/misc.rs
+++ b/pallets/subtensor/src/utils/misc.rs
@@ -719,6 +719,14 @@ impl<T: Config> Pallet<T> {
         Yuma3On::<T>::get(netuid)
     }
 
+    pub fn get_subtoken_enabled(netuid: u16) -> bool {
+        SubtokenEnabled::<T>::get(netuid)
+    }
+
+    pub fn get_transfer_toggle(netuid: u16) -> bool {
+        TransferToggle::<T>::get(netuid)
+    }
+
     /// Set the duration for coldkey swap
     ///
     /// # Arguments

From b6d95454b1fa93a534419a32f9100964b113be6c Mon Sep 17 00:00:00 2001
From: John Reed <87283488+JohnReedV@users.noreply.github.com>
Date: Wed, 11 Jun 2025 11:15:31 -0700
Subject: [PATCH 320/418] clippy

---
 pallets/subtensor/src/rpc_info/subnet_info.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/pallets/subtensor/src/rpc_info/subnet_info.rs b/pallets/subtensor/src/rpc_info/subnet_info.rs
index 9643f815ee..24ba8afa2d 100644
--- a/pallets/subtensor/src/rpc_info/subnet_info.rs
+++ b/pallets/subtensor/src/rpc_info/subnet_info.rs
@@ -394,10 +394,10 @@ impl<T: Config> Pallet<T> {
             alpha_high: alpha_high.into(),
             alpha_low: alpha_low.into(),
             liquid_alpha_enabled,
-            alpha_sigmoid_steepness: alpha_sigmoid_steepness,
+            alpha_sigmoid_steepness,
             yuma_version: yuma_version.into(),
-            subnet_token_enabled: subnet_token_enabled,
-            transfers_enabled: transfers_enabled,
+            subnet_token_enabled,
+            transfers_enabled,
             bonds_reset_enabled: bonds_reset,
         })
     }

From 44208853b64a3bb86de0869d28b5987c35a62ea4 Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Wed, 11 Jun 2025 20:33:39 +0200
Subject: [PATCH 321/418] fix runtime integrity test for admin-utils

---
 pallets/admin-utils/src/tests/mock.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/pallets/admin-utils/src/tests/mock.rs b/pallets/admin-utils/src/tests/mock.rs
index f3ddccb39c..fe38553e2d 100644
--- a/pallets/admin-utils/src/tests/mock.rs
+++ b/pallets/admin-utils/src/tests/mock.rs
@@ -3,7 +3,6 @@
 use frame_support::{
     assert_ok, derive_impl, parameter_types,
     traits::{Everything, Hooks, InherentBuilder, PrivilegeCmp},
-    weights,
 };
 use frame_system::{self as system, offchain::CreateTransactionBase};
 use frame_system::{EnsureNever, EnsureRoot, limits};
@@ -74,7 +73,10 @@ parameter_types! {
     pub const InitialMinAllowedWeights: u16 = 0;
     pub const InitialEmissionValue: u16 = 0;
     pub const InitialMaxWeightsLimit: u16 = u16::MAX;
-    pub BlockWeights: limits::BlockWeights = limits::BlockWeights::simple_max(weights::Weight::from_parts(1024, 0));
+    pub BlockWeights: limits::BlockWeights = limits::BlockWeights::with_sensible_defaults(
+        Weight::from_parts(2_000_000_000_000, u64::MAX),
+        Perbill::from_percent(75),
+    );
     pub const ExistentialDeposit: Balance = 1;
     pub const TransactionByteFee: Balance = 100;
     pub const SDebug:u64 = 1;

From f1c164304e4d81810f79b971456437e7fc546ce9 Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Wed, 11 Jun 2025 21:05:46 +0200
Subject: [PATCH 322/418] fix build

---
 pallets/admin-utils/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pallets/admin-utils/src/lib.rs b/pallets/admin-utils/src/lib.rs
index 91e3942156..ef28b56bca 100644
--- a/pallets/admin-utils/src/lib.rs
+++ b/pallets/admin-utils/src/lib.rs
@@ -1625,7 +1625,7 @@ pub mod pallet {
         #[pallet::weight((0, DispatchClass::Operational, Pays::No))]
         pub fn sudo_set_bonds_reset_enabled(
             origin: OriginFor<T>,
-            netuid: u16,
+            netuid: NetUid,
             enabled: bool,
         ) -> DispatchResult {
             pallet_subtensor::Pallet::<T>::ensure_subnet_owner_or_root(origin, netuid)?;

From 60b137c3daab07ed4fb02215853dc622a593124c Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Wed, 11 Jun 2025 21:07:23 +0200
Subject: [PATCH 323/418] fix build 2

---
 pallets/admin-utils/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pallets/admin-utils/src/lib.rs b/pallets/admin-utils/src/lib.rs
index ef28b56bca..b4bd58364f 100644
--- a/pallets/admin-utils/src/lib.rs
+++ b/pallets/admin-utils/src/lib.rs
@@ -88,7 +88,7 @@ pub mod pallet {
         /// Event emitted when Bonds Reset is toggled.
         BondsResetToggled {
             /// The network identifier.
-            netuid: u16,
+            netuid: NetUid,
             /// Indicates if the Bonds Reset was enabled or disabled.
             enabled: bool,
         },

From f5f21c37de345ea164b3acb520f0c75379c05dd9 Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Wed, 11 Jun 2025 21:11:18 +0200
Subject: [PATCH 324/418] fix build 3

---
 precompiles/src/subnet.rs | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/precompiles/src/subnet.rs b/precompiles/src/subnet.rs
index dc9e0cb0c3..0448433f0d 100644
--- a/precompiles/src/subnet.rs
+++ b/precompiles/src/subnet.rs
@@ -621,7 +621,7 @@ where
     #[precompile::public("getBondsResetEnabled(uint16)")]
     #[precompile::view]
     fn get_bonds_reset_enabled(_: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<bool> {
-        Ok(pallet_subtensor::BondsResetOn::<R>::get(netuid))
+        Ok(pallet_subtensor::BondsResetOn::<R>::get(NetUid::from(netuid)))
     }
 
     #[precompile::public("setYuma3Enabled(uint16,bool)")]
@@ -649,7 +649,10 @@ where
         netuid: u16,
         enabled: bool,
     ) -> EvmResult<()> {
-        let call = pallet_admin_utils::Call::<R>::sudo_set_bonds_reset_enabled { netuid, enabled };
+        let call = pallet_admin_utils::Call::<R>::sudo_set_bonds_reset_enabled {
+            netuid: netuid.into(),
+            enabled,
+        };
 
         handle.try_dispatch_runtime_call::<R, _>(
             call,

From 4085a7c415f53ac5a7cf7a14e456e3cb7e2e9954 Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Wed, 11 Jun 2025 21:23:11 +0200
Subject: [PATCH 325/418] fix tests

---
 pallets/admin-utils/src/tests/mod.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pallets/admin-utils/src/tests/mod.rs b/pallets/admin-utils/src/tests/mod.rs
index d8620af873..9e70858566 100644
--- a/pallets/admin-utils/src/tests/mod.rs
+++ b/pallets/admin-utils/src/tests/mod.rs
@@ -1785,7 +1785,7 @@ fn test_set_sn_owner_hotkey_root() {
 #[test]
 fn test_sudo_set_bonds_reset_enabled() {
     new_test_ext().execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let to_be_set: bool = true;
         let sn_owner = U256::from(1);
         add_network(netuid, 10);
@@ -1822,7 +1822,7 @@ fn test_sudo_set_bonds_reset_enabled() {
 #[test]
 fn test_sudo_set_yuma3_enabled() {
     new_test_ext().execute_with(|| {
-        let netuid: u16 = 1;
+        let netuid = NetUid::from(1);
         let to_be_set: bool = true;
         let sn_owner = U256::from(1);
         add_network(netuid, 10);

From de7c10dce3186368c02bef2aaa35be0a2486fa41 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Wed, 11 Jun 2025 21:28:06 +0200
Subject: [PATCH 326/418] Reformat

---
 precompiles/src/subnet.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/precompiles/src/subnet.rs b/precompiles/src/subnet.rs
index 0448433f0d..7eecb5d095 100644
--- a/precompiles/src/subnet.rs
+++ b/precompiles/src/subnet.rs
@@ -621,7 +621,9 @@ where
     #[precompile::public("getBondsResetEnabled(uint16)")]
     #[precompile::view]
     fn get_bonds_reset_enabled(_: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<bool> {
-        Ok(pallet_subtensor::BondsResetOn::<R>::get(NetUid::from(netuid)))
+        Ok(pallet_subtensor::BondsResetOn::<R>::get(NetUid::from(
+            netuid,
+        )))
     }
 
     #[precompile::public("setYuma3Enabled(uint16,bool)")]

From a6aebe36cbdfa312ed70638e0bfef5d484c983f9 Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Wed, 11 Jun 2025 21:31:10 +0200
Subject: [PATCH 327/418] enable workflows to run on forks

---
 .github/workflows/require-clean-merges.yml | 28 +++++++++++++++++-----
 .github/workflows/run-benchmarks.yml       | 18 +++++++-------
 2 files changed, 32 insertions(+), 14 deletions(-)

diff --git a/.github/workflows/require-clean-merges.yml b/.github/workflows/require-clean-merges.yml
index c00a4b47e2..ac0a5f31fe 100644
--- a/.github/workflows/require-clean-merges.yml
+++ b/.github/workflows/require-clean-merges.yml
@@ -34,6 +34,14 @@ jobs:
           else
             echo "MERGE_BRANCHES=devnet-ready devnet testnet main" >> $GITHUB_ENV
           fi
+          
+      - name: Add Fork Remote and Fetch PR Branch
+        if: github.event.pull_request.head.repo.fork == true
+        run: |
+          PR_BRANCH="${{ github.event.pull_request.head.ref }}"
+          PR_FORK="${{ github.event.pull_request.head.repo.clone_url }}"
+          git remote add fork $PR_FORK
+          git fetch --no-tags --prune fork $PR_BRANCH
 
       - name: Check Merge Cleanliness
         run: |
@@ -42,25 +50,33 @@ jobs:
           echo "Fetching all branches..."
           git fetch --all --prune
 
+          if [[ "${{github.event.pull_request.head.repo.fork}}" == "true" ]]; then
+            PR_BRANCH_REF="fork/$PR_BRANCH"
+            echo "Using fork reference: $PR_BRANCH_REF"
+          else
+            PR_BRANCH_REF="origin/$PR_BRANCH"
+            echo "Using origin reference: $PR_BRANCH_REF"
+          fi
+
           echo "Checking out PR branch: $PR_BRANCH"
-          git checkout $PR_BRANCH
-          git reset --hard origin/$PR_BRANCH
+          git checkout $PR_BRANCH_REF
+          git reset --hard $PR_BRANCH_REF
 
           # Configure a temporary Git identity to allow merging
           git config --local user.email "github-actions@github.com"
           git config --local user.name "GitHub Actions"
 
           for branch in $MERGE_BRANCHES; do
-            echo "Checking merge from $branch into $PR_BRANCH..."
+            echo "Checking merge from $branch into $PR_BRANCH_REF..."
             
             # Ensure PR branch is up to date
-            git reset --hard origin/$PR_BRANCH
+            git reset --hard $PR_BRANCH_REF
 
             # Merge without committing to check for conflicts
             if git merge --no-commit --no-ff origin/$branch; then
-              echo "✅ Merge from $branch into $PR_BRANCH is clean."
+              echo "✅ Merge from $branch into $PR_BRANCH_REF is clean."
             else
-              echo "❌ Merge conflict detected when merging $branch into $PR_BRANCH"
+              echo "❌ Merge conflict detected when merging $branch into $PR_BRANCH_REF"
               exit 1
             fi
             
diff --git a/.github/workflows/run-benchmarks.yml b/.github/workflows/run-benchmarks.yml
index 6040485eca..7d4cb9c2a7 100644
--- a/.github/workflows/run-benchmarks.yml
+++ b/.github/workflows/run-benchmarks.yml
@@ -24,18 +24,20 @@ jobs:
         if: ${{ env.SKIP_BENCHMARKS != '1' }}
         uses: actions/checkout@v4
         with:
-          ref: ${{ github.head_ref }}
+          repository: ${{ github.event.pull_request.head.repo.full_name }}
+          ref: ${{ github.event.pull_request.head.ref }}
           fetch-depth: 0
 
       - name: Install GitHub CLI
-        if: ${{ env.SKIP_BENCHMARKS != '1' }}
+        # We disallow skipping benchmarks for PRs from forks to avoid exposing secrets
+        if: ${{ github.event.pull_request.head.repo.full_name == github.repository && env.SKIP_BENCHMARKS != '1' }}
         run: |
           sudo apt-get update
           sudo apt-get install -y gh
           echo "${{ secrets.GITHUB_TOKEN }}" | gh auth login --with-token
 
       - name: Check skip label
-        if: ${{ env.SKIP_BENCHMARKS != '1' }}
+        if: ${{ github.event.pull_request.head.repo.full_name == github.repository && env.SKIP_BENCHMARKS != '1' }}
         run: |
           labels=$(gh pr view ${{ github.event.pull_request.number }} --json labels --jq '.labels[].name')
           if echo "$labels" | grep -q "skip-validate-benchmarks"; then
@@ -50,7 +52,7 @@ jobs:
           sudo apt-get install -y clang curl libssl-dev llvm libudev-dev protobuf-compiler
 
       - name: Check skip label
-        if: ${{ env.SKIP_BENCHMARKS != '1' }}
+        if: ${{ github.event.pull_request.head.repo.full_name == github.repository && env.SKIP_BENCHMARKS != '1' }}
         run: |
           labels=$(gh pr view ${{ github.event.pull_request.number }} --json labels --jq '.labels[].name')
           if echo "$labels" | grep -q "skip-validate-benchmarks"; then
@@ -66,7 +68,7 @@ jobs:
           toolchain: stable
 
       - name: Check skip label
-        if: ${{ env.SKIP_BENCHMARKS != '1' }}
+        if: ${{ github.event.pull_request.head.repo.full_name == github.repository && env.SKIP_BENCHMARKS != '1' }}
         run: |
           labels=$(gh pr view ${{ github.event.pull_request.number }} --json labels --jq '.labels[].name')
           if echo "$labels" | grep -q "skip-validate-benchmarks"; then
@@ -81,7 +83,7 @@ jobs:
           key: bench-${{ hashFiles('**/Cargo.lock') }}
 
       - name: Check skip label
-        if: ${{ env.SKIP_BENCHMARKS != '1' }}
+        if: ${{ github.event.pull_request.head.repo.full_name == github.repository && env.SKIP_BENCHMARKS != '1' }}
         run: |
           labels=$(gh pr view ${{ github.event.pull_request.number }} --json labels --jq '.labels[].name')
           if echo "$labels" | grep -q "skip-validate-benchmarks"; then
@@ -95,7 +97,7 @@ jobs:
           cargo build --profile production -p node-subtensor --features runtime-benchmarks
 
       - name: Check skip label
-        if: ${{ env.SKIP_BENCHMARKS != '1' }}
+        if: ${{ github.event.pull_request.head.repo.full_name == github.repository && env.SKIP_BENCHMARKS != '1' }}
         run: |
           labels=$(gh pr view ${{ github.event.pull_request.number }} --json labels --jq '.labels[].name')
           if echo "$labels" | grep -q "skip-validate-benchmarks"; then
@@ -110,7 +112,7 @@ jobs:
           ./scripts/benchmark_action.sh
 
       - name: Check skip label after run
-        if: ${{ env.SKIP_BENCHMARKS != '1' }}
+        if: ${{ github.event.pull_request.head.repo.full_name == github.repository && env.SKIP_BENCHMARKS != '1' }}
         run: |
           labels=$(gh pr view ${{ github.event.pull_request.number }} --json labels --jq '.labels[].name')
           if echo "$labels" | grep -q "skip-validate-benchmarks"; then

From 44fdb0c520b5b48b00284ce3110f0385cb1ad751 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Thu, 12 Jun 2025 08:31:08 +0800
Subject: [PATCH 328/418] fix the error from code merge

---
 precompiles/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/precompiles/src/lib.rs b/precompiles/src/lib.rs
index 1a5d666099..c88f1e4b91 100644
--- a/precompiles/src/lib.rs
+++ b/precompiles/src/lib.rs
@@ -96,7 +96,7 @@ where
         Self(Default::default())
     }
 
-    pub fn used_addresses() -> [H160; 18] {
+    pub fn used_addresses() -> [H160; 19] {
         [
             hash(1),
             hash(2),

From f443adad77a519788ff3b0ca3343e17f97114409 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Thu, 12 Jun 2025 08:45:10 +0800
Subject: [PATCH 329/418] update runtime version

---
 runtime/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index 18fc4dbd11..581e3d2252 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -209,7 +209,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
     //   `spec_version`, and `authoring_version` are the same between Wasm and native.
     // This value is set to 100 to notify Polkadot-JS App (https://polkadot.js.org/apps) to use
     //   the compatible custom types.
-    spec_version: 275,
+    spec_version: 276,
     impl_version: 1,
     apis: RUNTIME_API_VERSIONS,
     transaction_version: 1,

From 91d80b1c9fbd91a37dd378516345383cf8dce84c Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Thu, 12 Jun 2025 14:46:56 +0200
Subject: [PATCH 330/418] fix zepter

---
 node/Cargo.toml              | 1 +
 pallets/subtensor/Cargo.toml | 1 +
 runtime/Cargo.toml           | 1 +
 3 files changed, 3 insertions(+)

diff --git a/node/Cargo.toml b/node/Cargo.toml
index 52ccf20de3..7f4b44efbd 100644
--- a/node/Cargo.toml
+++ b/node/Cargo.toml
@@ -136,6 +136,7 @@ runtime-benchmarks = [
 	"sp-runtime/runtime-benchmarks",
 	"pallet-commitments/runtime-benchmarks",
 	"pallet-drand/runtime-benchmarks",
+	"pallet-transaction-payment/runtime-benchmarks",
 ]
 pow-faucet = []
 
diff --git a/pallets/subtensor/Cargo.toml b/pallets/subtensor/Cargo.toml
index cd9cf258c1..e3ea29d75f 100644
--- a/pallets/subtensor/Cargo.toml
+++ b/pallets/subtensor/Cargo.toml
@@ -127,6 +127,7 @@ runtime-benchmarks = [
 	"pallet-preimage/runtime-benchmarks",
 	"pallet-scheduler/runtime-benchmarks",
 	"pallet-drand/runtime-benchmarks",
+	"pallet-transaction-payment/runtime-benchmarks",
 ]
 try-runtime = [
 	"frame-support/try-runtime",
diff --git a/runtime/Cargo.toml b/runtime/Cargo.toml
index f417a18afc..c9f3fce0a5 100644
--- a/runtime/Cargo.toml
+++ b/runtime/Cargo.toml
@@ -226,6 +226,7 @@ runtime-benchmarks = [
 	"pallet-balances/runtime-benchmarks",
 	"pallet-grandpa/runtime-benchmarks",
 	"pallet-timestamp/runtime-benchmarks",
+	"pallet-transaction-payment/runtime-benchmarks",
 	"pallet-utility/runtime-benchmarks",
 	"sp-runtime/runtime-benchmarks",
 	"pallet-safe-mode/runtime-benchmarks",

From 0b1a8e1c4e5da0b405022466eca9bac38a583c12 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Thu, 12 Jun 2025 10:16:38 -0400
Subject: [PATCH 331/418] Fix test_subtoken_enable_reject_trading_before_enable

---
 pallets/subtensor/src/staking/remove_stake.rs |  2 +-
 pallets/subtensor/src/tests/subnet.rs         | 18 ++++++++----------
 2 files changed, 9 insertions(+), 11 deletions(-)

diff --git a/pallets/subtensor/src/staking/remove_stake.rs b/pallets/subtensor/src/staking/remove_stake.rs
index 5f54a7449b..6d747148be 100644
--- a/pallets/subtensor/src/staking/remove_stake.rs
+++ b/pallets/subtensor/src/staking/remove_stake.rs
@@ -268,7 +268,7 @@ impl<T: Config> Pallet<T> {
             }
         }
 
-        // Stake into root.
+        // Stake into root. Ignore AmountTooLow error here.
         Self::stake_into_subnet(
             &hotkey,
             &coldkey,
diff --git a/pallets/subtensor/src/tests/subnet.rs b/pallets/subtensor/src/tests/subnet.rs
index 5e32fa7f84..f147a049e4 100644
--- a/pallets/subtensor/src/tests/subnet.rs
+++ b/pallets/subtensor/src/tests/subnet.rs
@@ -340,15 +340,12 @@ fn test_subtoken_enable_reject_trading_before_enable() {
             Error::<Test>::SubtokenDisabled
         );
 
-        // For unstake_all and unstake_all_alpha, the result is Ok, but the
+        // For unstake_all the result is Ok, but the
         // operation is not performed.
-        assert_ok!(
-            SubtensorModule::unstake_all(
-                RuntimeOrigin::signed(coldkey_account_id),
-                hotkey_account_id
-            ),
-            ()
-        );
+        assert_ok!(SubtensorModule::unstake_all(
+            RuntimeOrigin::signed(coldkey_account_id),
+            hotkey_account_id
+        ));
         // Check that the stake is still the same
         assert_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
@@ -359,12 +356,13 @@ fn test_subtoken_enable_reject_trading_before_enable() {
             stake_bal
         );
 
-        assert_ok!(
+        // For unstake_all_alpha, the result is AmountTooLow because no re-staking happens.
+        assert_noop!(
             SubtensorModule::unstake_all_alpha(
                 RuntimeOrigin::signed(coldkey_account_id),
                 hotkey_account_id
             ),
-            ()
+            Error::<Test>::AmountTooLow
         );
         // Check that the stake is still the same
         assert_eq!(

From bbf8bbd1730b059132d1bb379307a956c9767f01 Mon Sep 17 00:00:00 2001
From: John Reed <87283488+JohnReedV@users.noreply.github.com>
Date: Thu, 12 Jun 2025 07:54:06 -0700
Subject: [PATCH 332/418] add a read

---
 pallets/subtensor/src/macros/dispatches.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pallets/subtensor/src/macros/dispatches.rs b/pallets/subtensor/src/macros/dispatches.rs
index d78d167a1b..5a0e00e65f 100644
--- a/pallets/subtensor/src/macros/dispatches.rs
+++ b/pallets/subtensor/src/macros/dispatches.rs
@@ -1786,7 +1786,7 @@ mod dispatches {
         ///
         #[pallet::call_index(88)]
         #[pallet::weight((Weight::from_parts(402_800_000, 0)
-		.saturating_add(T::DbWeight::get().reads(25))
+		.saturating_add(T::DbWeight::get().reads(26))
 		.saturating_add(T::DbWeight::get().writes(14)), DispatchClass::Normal, Pays::No))]
         pub fn add_stake_limit(
             origin: OriginFor<T>,

From 1ba3d0bb93b721fcc03decffab3b4523289789ce Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Thu, 12 Jun 2025 11:28:18 -0400
Subject: [PATCH 333/418] Fix current liquidity in swap step and tests

---
 pallets/subtensor/src/tests/staking.rs | 30 ++++++++++----------------
 pallets/swap/src/pallet/impls.rs       |  2 +-
 2 files changed, 12 insertions(+), 20 deletions(-)

diff --git a/pallets/subtensor/src/tests/staking.rs b/pallets/subtensor/src/tests/staking.rs
index 014c644865..0667a5b72a 100644
--- a/pallets/subtensor/src/tests/staking.rs
+++ b/pallets/subtensor/src/tests/staking.rs
@@ -2966,19 +2966,9 @@ fn test_max_amount_add_dynamic() {
             Err(Error::<Test>::ZeroMaxStakeAmount),
         ),
         // Low bounds
-        (
-            100,
-            100,
-            1_100_000_000,
-            Err(Error::<Test>::ZeroMaxStakeAmount),
-        ),
-        (
-            1_000,
-            1_000,
-            1_100_000_000,
-            Err(Error::<Test>::ZeroMaxStakeAmount),
-        ),
-        (10_000, 10_000, 1_100_000_000, Ok(440)),
+        (100, 100, 1_100_000_000, Ok(4)),
+        (1_000, 1_000, 1_100_000_000, Ok(48)),
+        (10_000, 10_000, 1_100_000_000, Ok(489)),
         // Basic math
         (1_000_000, 1_000_000, 4_000_000_000, Ok(1_000_000)),
         (1_000_000, 1_000_000, 9_000_000_000, Ok(2_000_000)),
@@ -3050,7 +3040,7 @@ fn test_max_amount_add_dynamic() {
             }
 
             match expected_max_swappable {
-                Err(e) => assert_err!(SubtensorModule::get_max_amount_add(netuid, limit_price), e,),
+                Err(e) => assert_err!(SubtensorModule::get_max_amount_add(netuid, limit_price), e),
                 Ok(v) => assert_abs_diff_eq!(
                     SubtensorModule::get_max_amount_add(netuid, limit_price).unwrap(),
                     v,
@@ -3166,11 +3156,13 @@ fn test_max_amount_remove_dynamic() {
             (10_000_000_000, 10_000_000_000, 0, Ok(u64::MAX)),
             // Low bounds (numbers are empirical, it is only important that result
             // is sharply decreasing when limit price increases)
-            (1_000, 1_000, 0, Err(Error::<Test>::ZeroMaxStakeAmount)),
-            (1_001, 1_001, 0, Ok(4_307_770_117)),
-            (1_001, 1_001, 1, Ok(31_715)),
-            (1_001, 1_001, 2, Ok(22_426)),
-            (1_001, 1_001, 1_001, Ok(1_000)),
+            (1_000, 1_000, 0, Ok(4_308_000_000_000)),
+            (1_001, 1_001, 0, Ok(4_310_000_000_000)),
+            (1_001, 1_001, 1, Ok(31_750_000)),
+            (1_001, 1_001, 2, Ok(22_500_000)),
+            (1_001, 1_001, 1_001, Ok(1_000_000)),
+            (1_001, 1_001, 10_000, Ok(316_000)),
+            (1_001, 1_001, 100_000, Ok(100_000)),
             // Basic math
             (1_000_000, 1_000_000, 250_000_000, Ok(1_000_000)),
             (1_000_000, 1_000_000, 62_500_000, Ok(3_000_000)),
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 66a850279b..ec7f2766e9 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -64,7 +64,7 @@ impl<T: Config> SwapStep<T> {
         let possible_delta_in = amount_remaining.saturating_sub(fee);
 
         // Target price and quantities
-        let current_liquidity = Pallet::<T>::current_liquidity_safe(netuid);
+        let current_liquidity = U64F64::saturating_from_num(CurrentLiquidity::<T>::get(netuid));
         let target_sqrt_price = Pallet::<T>::sqrt_price_target(
             order_type,
             current_liquidity,

From a48508c418a4fae5e498ca61f6778e63ecca3f92 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Thu, 12 Jun 2025 18:38:24 +0200
Subject: [PATCH 334/418] Trigger CI


From 867abe4f3d36c6322bb7700e1bf55a4a0d067308 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Thu, 12 Jun 2025 13:17:26 -0400
Subject: [PATCH 335/418] Only pay refud in unstake_from_subnet if it is above
 zero

---
 pallets/subtensor/src/staking/stake_utils.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/pallets/subtensor/src/staking/stake_utils.rs b/pallets/subtensor/src/staking/stake_utils.rs
index 10aadccfb8..cc1a1ad148 100644
--- a/pallets/subtensor/src/staking/stake_utils.rs
+++ b/pallets/subtensor/src/staking/stake_utils.rs
@@ -747,7 +747,9 @@ impl<T: Config> Pallet<T> {
                 .amount_paid_in
                 .saturating_add(swap_result.fee_paid),
         );
-        Self::increase_stake_for_hotkey_and_coldkey_on_subnet(hotkey, coldkey, netuid, refund);
+        if refund > 0 {
+            Self::increase_stake_for_hotkey_and_coldkey_on_subnet(hotkey, coldkey, netuid, refund);
+        }
 
         // Step 3: Update StakingHotkeys if the hotkey's total alpha, across all subnets, is zero
         // TODO const: fix.

From fee8b2ac8c20db798ddbcd141f2b8bb5ab9069b8 Mon Sep 17 00:00:00 2001
From: John Reed <87283488+JohnReedV@users.noreply.github.com>
Date: Thu, 12 Jun 2025 10:53:34 -0700
Subject: [PATCH 336/418] add new host function

---
 Cargo.lock         | 1 +
 Cargo.toml         | 1 +
 node/Cargo.toml    | 1 +
 node/src/client.rs | 2 ++
 4 files changed, 5 insertions(+)

diff --git a/Cargo.lock b/Cargo.lock
index d5669f4d2c..16a8ebe935 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6492,6 +6492,7 @@ version = "4.0.0-dev"
 dependencies = [
  "async-trait",
  "clap",
+ "cumulus-primitives-proof-size-hostfunction",
  "fc-api",
  "fc-aura",
  "fc-consensus",
diff --git a/Cargo.toml b/Cargo.toml
index 10f3d4b0b9..0672367647 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -248,6 +248,7 @@ sha2 = { version = "0.10.8", default-features = false }
 rand_chacha = { version = "0.3.1", default-features = false }
 tle = { git = "https://github.com/ideal-lab5/timelock", rev = "5416406cfd32799e31e1795393d4916894de4468", default-features = false }
 
+cumulus-primitives-proof-size-hostfunction = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2412-6", package = "cumulus-primitives-proof-size-hostfunction", default-features = false }
 
 [profile.release]
 panic = "unwind"
diff --git a/node/Cargo.toml b/node/Cargo.toml
index 7f4b44efbd..3c816cbff4 100644
--- a/node/Cargo.toml
+++ b/node/Cargo.toml
@@ -67,6 +67,7 @@ pallet-commitments = { path = "../pallets/commitments" }
 pallet-drand = { workspace = true }
 sp-crypto-ec-utils = { workspace = true }
 sp-keystore = { workspace = true, default-features = false }
+cumulus-primitives-proof-size-hostfunction =  { workspace = true, default-features =  false }
 
 
 # These dependencies are used for the subtensor's RPCs
diff --git a/node/src/client.rs b/node/src/client.rs
index 1c2503f21b..59f6470a5b 100644
--- a/node/src/client.rs
+++ b/node/src/client.rs
@@ -1,3 +1,4 @@
+use cumulus_primitives_proof_size_hostfunction::storage_proof_size::HostFunctions as ProofSize;
 use node_subtensor_runtime::{RuntimeApi, opaque::Block};
 use sc_executor::WasmExecutor;
 
@@ -14,5 +15,6 @@ pub type HostFunctions = (
     sp_io::SubstrateHostFunctions,
     frame_benchmarking::benchmarking::HostFunctions,
     sp_crypto_ec_utils::bls12_381::host_calls::HostFunctions,
+    ProofSize,
 );
 pub type RuntimeExecutor = WasmExecutor<HostFunctions>;

From 0d924bf7dd7ac33189a241ce16b84c9674182605 Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Thu, 12 Jun 2025 19:48:58 +0200
Subject: [PATCH 337/418] Make NetUid type metadata transparent

---
 common/src/lib.rs | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/common/src/lib.rs b/common/src/lib.rs
index 1e040ffad5..369140abb6 100644
--- a/common/src/lib.rs
+++ b/common/src/lib.rs
@@ -35,7 +35,7 @@ pub type Nonce = u32;
 /// Transfers below SMALL_TRANSFER_LIMIT are considered small transfers
 pub const SMALL_TRANSFER_LIMIT: Balance = 500_000_000; // 0.5 TAO
 
-#[freeze_struct("f1746d0b1911967")]
+#[freeze_struct("9b6be98fb98e9b17")]
 #[repr(transparent)]
 #[derive(
     Deserialize,
@@ -52,8 +52,8 @@ pub const SMALL_TRANSFER_LIMIT: Balance = 500_000_000; // 0.5 TAO
     PartialEq,
     PartialOrd,
     RuntimeDebug,
-    TypeInfo,
 )]
+#[serde(transparent)]
 pub struct NetUid(u16);
 
 impl NetUid {
@@ -104,6 +104,13 @@ impl From<u16> for NetUid {
     }
 }
 
+impl TypeInfo for NetUid {
+    type Identity = <u16 as TypeInfo>::Identity;
+    fn type_info() -> scale_info::Type {
+        <u16 as TypeInfo>::type_info()
+    }
+}
+
 #[derive(
     Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Encode, Decode, Debug, MaxEncodedLen, TypeInfo,
 )]

From 16488f4a46828741315841ea599a8704e49ff3bd Mon Sep 17 00:00:00 2001
From: Aliaksandr Tsurko <ales@opentensor.dev>
Date: Thu, 12 Jun 2025 21:21:52 +0200
Subject: [PATCH 338/418] Add test

---
 common/src/lib.rs | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/common/src/lib.rs b/common/src/lib.rs
index 369140abb6..6e2f2900eb 100644
--- a/common/src/lib.rs
+++ b/common/src/lib.rs
@@ -164,3 +164,13 @@ pub mod time {
     pub const HOURS: BlockNumber = MINUTES * 60;
     pub const DAYS: BlockNumber = HOURS * 24;
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn netuid_has_u16_bin_repr() {
+        assert_eq!(NetUid(5).encode(), 5u16.encode());
+    }
+}

From e929d6adadfc2505353233702ff08d3c09421238 Mon Sep 17 00:00:00 2001
From: John Reed <87283488+JohnReedV@users.noreply.github.com>
Date: Thu, 12 Jun 2025 13:23:02 -0700
Subject: [PATCH 339/418] update weight

---
 pallets/subtensor/src/macros/dispatches.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pallets/subtensor/src/macros/dispatches.rs b/pallets/subtensor/src/macros/dispatches.rs
index ad76d90ae2..40deabf19d 100644
--- a/pallets/subtensor/src/macros/dispatches.rs
+++ b/pallets/subtensor/src/macros/dispatches.rs
@@ -454,7 +454,7 @@ mod dispatches {
         /// 	- The hotkey we are delegating is not owned by the calling coldket.
         ///
         #[pallet::call_index(1)]
-        #[pallet::weight((Weight::from_parts(4_709_000, 0)
+        #[pallet::weight((Weight::from_parts(3_657_000, 0)
 		.saturating_add(T::DbWeight::get().reads(0))
 		.saturating_add(T::DbWeight::get().writes(0)), DispatchClass::Normal, Pays::No))]
         pub fn become_delegate(_origin: OriginFor<T>, _hotkey: T::AccountId) -> DispatchResult {

From 8bcfa2ae99a87ce6e7340c8dd651d0655c1bcb46 Mon Sep 17 00:00:00 2001
From: Ben Mason <ben@wattmason.co.uk>
Date: Thu, 12 Jun 2025 21:31:08 +0100
Subject: [PATCH 340/418] feat: add logo_url to subnet identities

---
 pallets/subtensor/src/benchmarks.rs           |  2 +-
 pallets/subtensor/src/coinbase/root.rs        | 57 +----------
 pallets/subtensor/src/lib.rs                  | 34 ++++++-
 pallets/subtensor/src/macros/dispatches.rs    |  4 +-
 .../migrate_subnet_identities_to_v3.rs        | 66 +++++++++++++
 pallets/subtensor/src/migrations/mod.rs       |  1 +
 .../subtensor/src/rpc_info/dynamic_info.rs    |  6 +-
 pallets/subtensor/src/rpc_info/metagraph.rs   | 12 +--
 pallets/subtensor/src/rpc_info/subnet_info.rs |  6 +-
 pallets/subtensor/src/subnets/subnet.rs       |  6 +-
 pallets/subtensor/src/subnets/symbols.rs      |  2 +-
 pallets/subtensor/src/tests/serving.rs        | 95 +++++++++++++++++--
 pallets/subtensor/src/utils/identity.rs       | 18 ++--
 precompiles/src/subnet.rs                     |  6 +-
 14 files changed, 222 insertions(+), 93 deletions(-)
 create mode 100644 pallets/subtensor/src/migrations/migrate_subnet_identities_to_v3.rs

diff --git a/pallets/subtensor/src/benchmarks.rs b/pallets/subtensor/src/benchmarks.rs
index f1c7fc4625..73c827556d 100644
--- a/pallets/subtensor/src/benchmarks.rs
+++ b/pallets/subtensor/src/benchmarks.rs
@@ -1131,7 +1131,7 @@ mod pallet_benchmarks {
     fn register_network_with_identity() {
         let coldkey: T::AccountId = whitelisted_caller();
         let hotkey: T::AccountId = account("Alice", 0, 1);
-        let identity: Option<SubnetIdentityOfV2> = None;
+        let identity: Option<SubnetIdentityOfV3> = None;
 
         Subtensor::<T>::set_network_registration_allowed(1.into(), true);
         Subtensor::<T>::set_network_rate_limit(1);
diff --git a/pallets/subtensor/src/coinbase/root.rs b/pallets/subtensor/src/coinbase/root.rs
index 32ead349a2..add7ae3d8f 100644
--- a/pallets/subtensor/src/coinbase/root.rs
+++ b/pallets/subtensor/src/coinbase/root.rs
@@ -21,7 +21,6 @@ use frame_support::storage::IterableStorageDoubleMap;
 use frame_support::weights::Weight;
 use safe_math::*;
 use sp_core::Get;
-use sp_std::vec;
 use substrate_fixed::types::I64F64;
 use subtensor_runtime_common::NetUid;
 
@@ -71,56 +70,6 @@ impl<T: Config> Pallet<T> {
         false
     }
 
-    /// Retrieves weight matrix associated with the root network.
-    ///  Weights represent the preferences for each subnetwork.
-    ///
-    /// # Returns:
-    /// A 2D vector ('Vec<Vec<I32F32>>') where each entry [i][j] represents the weight of subnetwork
-    /// 'j' with according to the preferences of key. Validator 'i' within the root network.
-    ///
-    pub fn get_root_weights() -> Vec<Vec<I64F64>> {
-        // --- 0. The number of validators on the root network.
-        let n = Self::get_num_root_validators() as usize;
-
-        // --- 1 The number of subnets to validate.
-        log::debug!("subnet size before cast: {:?}", Self::get_num_subnets());
-        let k = Self::get_num_subnets() as usize;
-        log::debug!("n: {:?} k: {:?}", n, k);
-
-        // --- 2. Initialize a 2D vector with zeros to store the weights. The dimensions are determined
-        // by `n` (number of validators) and `k` (total number of subnets).
-        let mut weights: Vec<Vec<I64F64>> = vec![vec![I64F64::saturating_from_num(0.0); k]; n];
-        log::debug!("weights:\n{:?}\n", weights);
-
-        let subnet_list = Self::get_all_subnet_netuids();
-
-        // --- 3. Iterate over stored weights and fill the matrix.
-        for (uid_i, weights_i) in
-            <Weights<T> as IterableStorageDoubleMap<NetUid, u16, Vec<(u16, u16)>>>::iter_prefix(
-                NetUid::ROOT,
-            )
-        {
-            // --- 4. Iterate over each weight entry in `weights_i` to update the corresponding value in the
-            // initialized `weights` 2D vector. Here, `uid_j` represents a subnet, and `weight_ij` is the
-            // weight of `uid_i` with respect to `uid_j`.
-            for (netuid, weight_ij) in &weights_i {
-                let idx = uid_i as usize;
-                if let Some(weight) = weights.get_mut(idx) {
-                    if let Some((w, _)) = weight
-                        .iter_mut()
-                        .zip(&subnet_list)
-                        .find(|(_, subnet)| *subnet == &NetUid::from(*netuid))
-                    {
-                        *w = I64F64::saturating_from_num(*weight_ij);
-                    }
-                }
-            }
-        }
-
-        // --- 5. Return the filled weights matrix.
-        weights
-    }
-
     /// Registers a user's hotkey to the root network.
     ///
     /// This function is responsible for registering the hotkey of a user.
@@ -448,7 +397,7 @@ impl<T: Config> Pallet<T> {
         );
 
         // --- 4. Remove the subnet identity if it exists.
-        if SubnetIdentitiesV2::<T>::take(netuid).is_some() {
+        if SubnetIdentitiesV3::<T>::take(netuid).is_some() {
             Self::deposit_event(Event::SubnetIdentityRemoved(netuid));
         }
 
@@ -558,8 +507,8 @@ impl<T: Config> Pallet<T> {
         SubnetOwner::<T>::remove(netuid);
 
         // --- 13. Remove subnet identity if it exists.
-        if SubnetIdentitiesV2::<T>::contains_key(netuid) {
-            SubnetIdentitiesV2::<T>::remove(netuid);
+        if SubnetIdentitiesV3::<T>::contains_key(netuid) {
+            SubnetIdentitiesV3::<T>::remove(netuid);
             Self::deposit_event(Event::SubnetIdentityRemoved(netuid));
         }
     }
diff --git a/pallets/subtensor/src/lib.rs b/pallets/subtensor/src/lib.rs
index 0f728fea1c..1a48024bb0 100644
--- a/pallets/subtensor/src/lib.rs
+++ b/pallets/subtensor/src/lib.rs
@@ -250,9 +250,9 @@ pub mod pallet {
         pub subnet_contact: Vec<u8>,
     }
 
-    ///  Struct for SubnetIdentitiesV2.
+    ///  Struct for SubnetIdentitiesV2. (DEPRECATED for V3)
     pub type SubnetIdentityOfV2 = SubnetIdentityV2;
-    /// Data structure for Subnet Identities
+    /// Data structure for Subnet Identities (DEPRECATED for V3)
     #[crate::freeze_struct("e002be4cd05d7b3e")]
     #[derive(Encode, Decode, Default, TypeInfo, Clone, PartialEq, Eq, Debug)]
     pub struct SubnetIdentityV2 {
@@ -272,6 +272,30 @@ pub mod pallet {
         pub additional: Vec<u8>,
     }
 
+    ///  Struct for SubnetIdentitiesV3.
+    pub type SubnetIdentityOfV3 = SubnetIdentityV3;
+    /// Data structure for Subnet Identities
+    #[crate::freeze_struct("3618af6beb882a23")]
+    #[derive(Encode, Decode, Default, TypeInfo, Clone, PartialEq, Eq, Debug)]
+    pub struct SubnetIdentityV3 {
+        /// The name of the subnet
+        pub subnet_name: Vec<u8>,
+        /// The github repository associated with the subnet
+        pub github_repo: Vec<u8>,
+        /// The subnet's contact
+        pub subnet_contact: Vec<u8>,
+        /// The subnet's website
+        pub subnet_url: Vec<u8>,
+        /// The subnet's discord
+        pub discord: Vec<u8>,
+        /// The subnet's description
+        pub description: Vec<u8>,
+        /// The subnet's logo
+        pub logo_url: Vec<u8>,
+        /// Additional information about the subnet
+        pub additional: Vec<u8>,
+    }
+
     /// ============================
     /// ==== Staking + Accounts ====
     /// ============================
@@ -1567,10 +1591,14 @@ pub mod pallet {
     pub type SubnetIdentities<T: Config> =
         StorageMap<_, Blake2_128Concat, NetUid, SubnetIdentityOf, OptionQuery>;
 
-    #[pallet::storage] // --- MAP ( netuid ) --> identityV2
+    #[pallet::storage] // --- MAP ( netuid ) --> identityV2 (DEPRECATED for V3)
     pub type SubnetIdentitiesV2<T: Config> =
         StorageMap<_, Blake2_128Concat, NetUid, SubnetIdentityOfV2, OptionQuery>;
 
+    #[pallet::storage] // --- MAP ( netuid ) --> SubnetIdentityOfV3
+    pub type SubnetIdentitiesV3<T: Config> =
+        StorageMap<_, Blake2_128Concat, NetUid, SubnetIdentityOfV3, OptionQuery>;
+
     /// =================================
     /// ==== Axon / Promo Endpoints =====
     /// =================================
diff --git a/pallets/subtensor/src/macros/dispatches.rs b/pallets/subtensor/src/macros/dispatches.rs
index ad76d90ae2..7f07c5e29e 100644
--- a/pallets/subtensor/src/macros/dispatches.rs
+++ b/pallets/subtensor/src/macros/dispatches.rs
@@ -1519,6 +1519,7 @@ mod dispatches {
             subnet_url: Vec<u8>,
             discord: Vec<u8>,
             description: Vec<u8>,
+            logo_url: Vec<u8>,
             additional: Vec<u8>,
         ) -> DispatchResult {
             Self::do_set_subnet_identity(
@@ -1530,6 +1531,7 @@ mod dispatches {
                 subnet_url,
                 discord,
                 description,
+                logo_url,
                 additional,
             )
         }
@@ -1542,7 +1544,7 @@ mod dispatches {
         pub fn register_network_with_identity(
             origin: OriginFor<T>,
             hotkey: T::AccountId,
-            identity: Option<SubnetIdentityOfV2>,
+            identity: Option<SubnetIdentityOfV3>,
         ) -> DispatchResult {
             Self::do_register_network(origin, &hotkey, 1, identity)
         }
diff --git a/pallets/subtensor/src/migrations/migrate_subnet_identities_to_v3.rs b/pallets/subtensor/src/migrations/migrate_subnet_identities_to_v3.rs
new file mode 100644
index 0000000000..b101227787
--- /dev/null
+++ b/pallets/subtensor/src/migrations/migrate_subnet_identities_to_v3.rs
@@ -0,0 +1,66 @@
+use super::*;
+use frame_support::weights::Weight;
+use log;
+use scale_info::prelude::{string::String, vec::Vec};
+
+pub fn migrate_subnet_identities_to_v3<T: Config>() -> Weight {
+    use frame_support::traits::Get;
+    let migration_name = b"migrate_subnet_identities_to_v3".to_vec();
+
+    // Start counting weight
+    let mut weight = T::DbWeight::get().reads(1);
+
+    // Check if we already ran this migration
+    if HasMigrationRun::<T>::get(&migration_name) {
+        log::info!(
+            target: "runtime",
+            "Migration '{:?}' has already run. Skipping.",
+            String::from_utf8_lossy(&migration_name)
+        );
+        return weight;
+    }
+
+    log::info!(
+        target: "runtime",
+        "Running migration '{}'",
+        String::from_utf8_lossy(&migration_name)
+    );
+    // -----------------------------
+    // 1) Migrate Subnet Identities
+    // -----------------------------
+    let old_subnet_identities = SubnetIdentitiesV2::<T>::iter().collect::<Vec<_>>();
+    for (netuid, old_subnet_identity) in old_subnet_identities.clone() {
+        let new_subnet_identity = SubnetIdentityV3 {
+            subnet_name: old_subnet_identity.subnet_name,
+            github_repo: old_subnet_identity.github_repo,
+            subnet_contact: old_subnet_identity.subnet_contact,
+            subnet_url: Vec::new(),
+            discord: Vec::new(),
+            description: Vec::new(),
+            logo_url: Vec::new(),
+            additional: Vec::new(),
+        };
+
+        // Insert into the new storage map
+        SubnetIdentitiesV3::<T>::insert(netuid, &new_subnet_identity);
+        weight = weight.saturating_add(T::DbWeight::get().writes(1));
+
+        SubnetIdentitiesV2::<T>::remove(netuid);
+        weight = weight.saturating_add(T::DbWeight::get().writes(1));
+    }
+    weight = weight.saturating_add(T::DbWeight::get().reads(old_subnet_identities.len() as u64));
+
+    // -----------------------------
+    // Mark the migration as done
+    // -----------------------------
+    HasMigrationRun::<T>::insert(&migration_name, true);
+    weight = weight.saturating_add(T::DbWeight::get().writes(1));
+
+    log::info!(
+        target: "runtime",
+        "Migration '{}' completed successfully.",
+        String::from_utf8_lossy(&migration_name)
+    );
+
+    weight
+}
diff --git a/pallets/subtensor/src/migrations/mod.rs b/pallets/subtensor/src/migrations/mod.rs
index 5c6347034f..ea2cff1458 100644
--- a/pallets/subtensor/src/migrations/mod.rs
+++ b/pallets/subtensor/src/migrations/mod.rs
@@ -27,6 +27,7 @@ pub mod migrate_set_min_burn;
 pub mod migrate_set_min_difficulty;
 pub mod migrate_set_subtoken_enabled;
 pub mod migrate_stake_threshold;
+pub mod migrate_subnet_identities_to_v3;
 pub mod migrate_subnet_volume;
 pub mod migrate_to_v1_separate_emission;
 pub mod migrate_to_v2_fixed_total_stake;
diff --git a/pallets/subtensor/src/rpc_info/dynamic_info.rs b/pallets/subtensor/src/rpc_info/dynamic_info.rs
index 4e5400aba0..e6838404d4 100644
--- a/pallets/subtensor/src/rpc_info/dynamic_info.rs
+++ b/pallets/subtensor/src/rpc_info/dynamic_info.rs
@@ -6,7 +6,7 @@ use substrate_fixed::types::I96F32;
 use subtensor_macros::freeze_struct;
 use subtensor_runtime_common::NetUid;
 
-#[freeze_struct("d813a7696ae616af")]
+#[freeze_struct("ddf2c1fdd5bb7e7")]
 #[derive(Decode, Encode, PartialEq, Eq, Clone, Debug, TypeInfo)]
 pub struct DynamicInfo<AccountId: TypeInfo + Encode + Decode> {
     netuid: Compact<NetUid>,
@@ -28,7 +28,7 @@ pub struct DynamicInfo<AccountId: TypeInfo + Encode + Decode> {
     pending_root_emission: Compact<u64>,
     subnet_volume: Compact<u128>,
     network_registered_at: Compact<u64>,
-    subnet_identity: Option<SubnetIdentityV2>,
+    subnet_identity: Option<SubnetIdentityV3>,
     moving_price: I96F32,
 }
 
@@ -66,7 +66,7 @@ impl<T: Config> Pallet<T> {
             pending_root_emission: PendingRootDivs::<T>::get(netuid).into(),
             subnet_volume: SubnetVolume::<T>::get(netuid).into(),
             network_registered_at: NetworkRegisteredAt::<T>::get(netuid).into(),
-            subnet_identity: SubnetIdentitiesV2::<T>::get(netuid),
+            subnet_identity: SubnetIdentitiesV3::<T>::get(netuid),
             moving_price: SubnetMovingPrice::<T>::get(netuid),
         })
     }
diff --git a/pallets/subtensor/src/rpc_info/metagraph.rs b/pallets/subtensor/src/rpc_info/metagraph.rs
index b6839290a5..d910bbaff5 100644
--- a/pallets/subtensor/src/rpc_info/metagraph.rs
+++ b/pallets/subtensor/src/rpc_info/metagraph.rs
@@ -9,7 +9,7 @@ use substrate_fixed::types::I96F32;
 use subtensor_macros::freeze_struct;
 use subtensor_runtime_common::NetUid;
 
-#[freeze_struct("ea9ff0b8daeaa5ed")]
+#[freeze_struct("140374b562d8498b")]
 #[derive(Decode, Encode, PartialEq, Eq, Clone, Debug, TypeInfo)]
 pub struct Metagraph<AccountId: TypeInfo + Encode + Decode> {
     // Subnet index
@@ -18,7 +18,7 @@ pub struct Metagraph<AccountId: TypeInfo + Encode + Decode> {
     // Name and symbol
     name: Vec<Compact<u8>>,              // name
     symbol: Vec<Compact<u8>>,            // token symbol
-    identity: Option<SubnetIdentityV2>,  // identity information.
+    identity: Option<SubnetIdentityV3>,  // identity information.
     network_registered_at: Compact<u64>, // block at registration
 
     // Keys for owner.
@@ -109,7 +109,7 @@ pub struct Metagraph<AccountId: TypeInfo + Encode + Decode> {
     alpha_dividends_per_hotkey: Vec<(AccountId, Compact<u64>)>, // List of dividend payout in alpha via subnet.
 }
 
-#[freeze_struct("d21755f360424f37")]
+#[freeze_struct("55ca82be1558e748")]
 #[derive(Decode, Encode, PartialEq, Eq, Clone, Debug, TypeInfo)]
 pub struct SelectiveMetagraph<AccountId: TypeInfo + Encode + Decode + Clone> {
     // Subnet index
@@ -118,7 +118,7 @@ pub struct SelectiveMetagraph<AccountId: TypeInfo + Encode + Decode + Clone> {
     // Name and symbol
     name: Option<Vec<Compact<u8>>>,              // name
     symbol: Option<Vec<Compact<u8>>>,            // token symbol
-    identity: Option<Option<SubnetIdentityV2>>,  // identity information.
+    identity: Option<Option<SubnetIdentityV3>>,  // identity information.
     network_registered_at: Option<Compact<u64>>, // block at registration
 
     // Keys for owner.
@@ -663,7 +663,7 @@ impl<T: Config> Pallet<T> {
                 .into_iter()
                 .map(Compact)
                 .collect(), // Symbol.
-            identity: SubnetIdentitiesV2::<T>::get(netuid), // identity information.
+            identity: SubnetIdentitiesV3::<T>::get(netuid), // identity information.
             network_registered_at: NetworkRegisteredAt::<T>::get(netuid).into(), // block at registration
 
             // Keys for owner.
@@ -844,7 +844,7 @@ impl<T: Config> Pallet<T> {
             },
             Some(SelectiveMetagraphIndex::Identity) => SelectiveMetagraph {
                 netuid: netuid.into(),
-                identity: Some(SubnetIdentitiesV2::<T>::get(netuid)),
+                identity: Some(SubnetIdentitiesV3::<T>::get(netuid)),
                 ..Default::default()
             },
             Some(SelectiveMetagraphIndex::NetworkRegisteredAt) => SelectiveMetagraph {
diff --git a/pallets/subtensor/src/rpc_info/subnet_info.rs b/pallets/subtensor/src/rpc_info/subnet_info.rs
index 636b72899b..02ebb35b3c 100644
--- a/pallets/subtensor/src/rpc_info/subnet_info.rs
+++ b/pallets/subtensor/src/rpc_info/subnet_info.rs
@@ -28,7 +28,7 @@ pub struct SubnetInfo<AccountId: TypeInfo + Encode + Decode> {
     owner: AccountId,
 }
 
-#[freeze_struct("42d9a1f1761c3b31")]
+#[freeze_struct("4e60a45245fc2ad1")]
 #[derive(Decode, Encode, PartialEq, Eq, Clone, Debug, TypeInfo)]
 pub struct SubnetInfov2<AccountId: TypeInfo + Encode + Decode> {
     netuid: Compact<NetUid>,
@@ -49,7 +49,7 @@ pub struct SubnetInfov2<AccountId: TypeInfo + Encode + Decode> {
     emission_value: Compact<u64>,
     burn: Compact<u64>,
     owner: AccountId,
-    identity: Option<SubnetIdentityV2>,
+    identity: Option<SubnetIdentityV3>,
 }
 
 #[freeze_struct("7b506df55bd44646")]
@@ -173,7 +173,7 @@ impl<T: Config> Pallet<T> {
         let tempo = Self::get_tempo(netuid);
         let network_modality = <NetworkModality<T>>::get(netuid);
         let burn: Compact<u64> = Self::get_burn_as_u64(netuid).into();
-        let identity: Option<SubnetIdentityV2> = SubnetIdentitiesV2::<T>::get(netuid);
+        let identity: Option<SubnetIdentityV3> = SubnetIdentitiesV3::<T>::get(netuid);
 
         // DEPRECATED
         let network_connect: Vec<[u16; 2]> = Vec::<[u16; 2]>::new();
diff --git a/pallets/subtensor/src/subnets/subnet.rs b/pallets/subtensor/src/subnets/subnet.rs
index ff9762353c..db3e319959 100644
--- a/pallets/subtensor/src/subnets/subnet.rs
+++ b/pallets/subtensor/src/subnets/subnet.rs
@@ -102,7 +102,7 @@ impl<T: Config> Pallet<T> {
     ///
     /// # Args:
     /// * 'origin': ('T::RuntimeOrigin'): The calling origin. Must be signed.
-    /// * `identity` (`Option<SubnetIdentityOf>`): Optional identity to be associated with the new subnetwork.
+    /// * `identity` (`Option<SubnetIdentityOfV3>`): Optional identity to be associated with the new subnetwork.
     ///
     /// # Event:
     /// * 'NetworkAdded': Emitted when a new network is successfully added.
@@ -118,7 +118,7 @@ impl<T: Config> Pallet<T> {
         origin: T::RuntimeOrigin,
         hotkey: &T::AccountId,
         mechid: u16,
-        identity: Option<SubnetIdentityOfV2>,
+        identity: Option<SubnetIdentityOfV3>,
     ) -> DispatchResult {
         // --- 1. Ensure the caller is a signed user.
         let coldkey = ensure_signed(origin)?;
@@ -217,7 +217,7 @@ impl<T: Config> Pallet<T> {
                 Error::<T>::InvalidIdentity
             );
 
-            SubnetIdentitiesV2::<T>::insert(netuid_to_register, identity_value);
+            SubnetIdentitiesV3::<T>::insert(netuid_to_register, identity_value);
             Self::deposit_event(Event::SubnetIdentitySet(netuid_to_register));
         }
 
diff --git a/pallets/subtensor/src/subnets/symbols.rs b/pallets/subtensor/src/subnets/symbols.rs
index b06d4807f5..bd88839a6b 100644
--- a/pallets/subtensor/src/subnets/symbols.rs
+++ b/pallets/subtensor/src/subnets/symbols.rs
@@ -4,7 +4,7 @@ use subtensor_runtime_common::NetUid;
 /// Returns the Unicode symbol as a Vec<u8> for a given netuid.
 impl<T: Config> Pallet<T> {
     pub fn get_name_for_subnet(netuid: NetUid) -> Vec<u8> {
-        SubnetIdentitiesV2::<T>::try_get(netuid)
+        SubnetIdentitiesV3::<T>::try_get(netuid)
             .and_then(|identity| {
                 if !identity.subnet_name.is_empty() {
                     Ok(identity.subnet_name)
diff --git a/pallets/subtensor/src/tests/serving.rs b/pallets/subtensor/src/tests/serving.rs
index faf68b2e81..4bf4bf2689 100644
--- a/pallets/subtensor/src/tests/serving.rs
+++ b/pallets/subtensor/src/tests/serving.rs
@@ -1055,7 +1055,67 @@ fn test_migrate_identities_to_v2() {
     });
 }
 
-// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test serving -- test_do_set_subnet_identity --exact --nocapture
+// SKIP_WASM_BUILD=1 RUST_LOG=DEBUG cargo test --release -p pallet-subtensor test_migrate_subnet_identities_to_v3 -- --nocapture
+#[test]
+fn test_migrate_subnet_identities_to_v3() {
+    new_test_ext(1).execute_with(|| {
+        let old_subnet_name = b"SubnetExample".to_vec();
+        let old_github_repo = b"https://github.com/org/repo".to_vec();
+        let old_subnet_contact = b"subnet@example".to_vec();
+
+        SubnetIdentitiesV2::<Test>::insert(
+            NetUid::from(16),
+            SubnetIdentityV2 {
+                subnet_name: old_subnet_name.clone(),
+                github_repo: old_github_repo.clone(),
+                subnet_contact: old_subnet_contact.clone(),
+                subnet_url: b"".to_vec(),
+                discord: b"".to_vec(),
+                description: b"".to_vec(),
+                additional: b"".to_vec(),
+            },
+        );
+
+        assert!(SubnetIdentitiesV2::<Test>::get(NetUid::from(16)).is_some());
+        assert!(!HasMigrationRun::<Test>::get(
+            b"migrate_subnet_identities_to_v3".to_vec()
+        ));
+
+        let weight =
+            crate::migrations::migrate_subnet_identities_to_v3::migrate_subnet_identities_to_v3::<
+                Test,
+            >();
+
+        assert!(
+            HasMigrationRun::<Test>::get(b"migrate_subnet_identities_to_v3".to_vec()),
+            "Expected HasMigrationRun to be true after migration"
+        );
+        assert!(SubnetIdentitiesV2::<Test>::get(NetUid::from(16)).is_none());
+
+        let new_subnet_identity = SubnetIdentitiesV3::<Test>::get(NetUid::from(16))
+            .expect("SubnetExample should be migrated to SubnetIdentitiesV3");
+
+        let expected_subnet_url = b"".to_vec();
+        let expected_discord = b"".to_vec();
+        let expected_description = b"".to_vec();
+        let expected_additional = b"".to_vec();
+
+        assert_eq!(new_subnet_identity.subnet_name, old_subnet_name);
+        assert_eq!(new_subnet_identity.github_repo, old_github_repo);
+        assert_eq!(new_subnet_identity.subnet_contact, old_subnet_contact);
+        assert_eq!(new_subnet_identity.subnet_url, expected_subnet_url);
+        assert_eq!(new_subnet_identity.discord, expected_discord);
+        assert_eq!(new_subnet_identity.description, expected_description);
+        assert_eq!(new_subnet_identity.additional, expected_additional);
+
+        assert!(
+            weight != Weight::zero(),
+            "Migration weight should be non-zero"
+        );
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=DEBUG cargo test --release -p pallet-subtensor test_do_set_subnet_identity -- --nocapture
 #[test]
 fn test_do_set_subnet_identity() {
     new_test_ext(1).execute_with(|| {
@@ -1077,6 +1137,7 @@ fn test_do_set_subnet_identity() {
         let subnet_url = b"subnet.com".to_vec();
         let discord = b"discord.com".to_vec();
         let description = b"I am the describer".to_vec();
+        let logo_url = b"https://testsubnet.com/logo.png".to_vec();
         let additional = b"tao foreva".to_vec();
 
         // Set subnet identity
@@ -1089,15 +1150,17 @@ fn test_do_set_subnet_identity() {
             subnet_url.clone(),
             discord.clone(),
             description.clone(),
+            logo_url.clone(),
             additional.clone(),
         ));
 
         // Check if subnet identity is set correctly
         let stored_identity =
-            SubnetIdentitiesV2::<Test>::get(netuid).expect("Subnet identity should be set");
+            SubnetIdentitiesV3::<Test>::get(netuid).expect("Subnet identity should be set");
         assert_eq!(stored_identity.subnet_name, subnet_name);
         assert_eq!(stored_identity.github_repo, github_repo);
         assert_eq!(stored_identity.subnet_contact, subnet_contact);
+        assert_eq!(stored_identity.logo_url, logo_url);
 
         // Test setting subnet identity by non-owner
         let non_owner_coldkey = U256::from(2);
@@ -1111,6 +1174,7 @@ fn test_do_set_subnet_identity() {
                 subnet_url.clone(),
                 discord.clone(),
                 description.clone(),
+                logo_url.clone(),
                 additional.clone(),
             ),
             Error::<Test>::NotSubnetOwner
@@ -1128,13 +1192,15 @@ fn test_do_set_subnet_identity() {
             subnet_url.clone(),
             discord.clone(),
             description.clone(),
+            logo_url.clone(),
             additional.clone(),
         ));
 
         let updated_identity =
-            SubnetIdentitiesV2::<Test>::get(netuid).expect("Updated subnet identity should be set");
+            SubnetIdentitiesV3::<Test>::get(netuid).expect("Updated subnet identity should be set");
         assert_eq!(updated_identity.subnet_name, new_subnet_name);
         assert_eq!(updated_identity.github_repo, new_github_repo);
+        assert_eq!(updated_identity.logo_url, logo_url);
 
         // Test setting subnet identity with invalid data (exceeding 1024 bytes total)
         let long_data = vec![0; 1025];
@@ -1149,6 +1215,7 @@ fn test_do_set_subnet_identity() {
                 long_data.clone(),
                 long_data.clone(),
                 long_data.clone(),
+                long_data.clone(),
             ),
             Error::<Test>::InvalidIdentity
         );
@@ -1160,25 +1227,27 @@ fn test_do_set_subnet_identity() {
 fn test_is_valid_subnet_identity() {
     new_test_ext(1).execute_with(|| {
         // Test valid subnet identity
-        let valid_identity = SubnetIdentityV2 {
+        let valid_identity = SubnetIdentityV3 {
             subnet_name: vec![0; 256],
             github_repo: vec![0; 1024],
             subnet_contact: vec![0; 1024],
             subnet_url: vec![0; 1024],
             discord: vec![0; 256],
             description: vec![0; 1024],
+            logo_url: vec![0; 1024],
             additional: vec![0; 1024],
         };
         assert!(SubtensorModule::is_valid_subnet_identity(&valid_identity));
 
         // Test subnet identity with total length exactly at the maximum
-        let max_length_identity = SubnetIdentityV2 {
+        let max_length_identity = SubnetIdentityV3 {
             subnet_name: vec![0; 256],
             github_repo: vec![0; 1024],
             subnet_contact: vec![0; 1024],
             subnet_url: vec![0; 1024],
             discord: vec![0; 256],
             description: vec![0; 1024],
+            logo_url: vec![0; 1024],
             additional: vec![0; 1024],
         };
         assert!(SubtensorModule::is_valid_subnet_identity(
@@ -1186,13 +1255,14 @@ fn test_is_valid_subnet_identity() {
         ));
 
         // Test subnet identity with total length exceeding the maximum
-        let invalid_length_identity = SubnetIdentityV2 {
+        let invalid_length_identity = SubnetIdentityV3 {
             subnet_name: vec![0; 257],
             github_repo: vec![0; 1024],
             subnet_contact: vec![0; 1024],
             subnet_url: vec![0; 1024],
             discord: vec![0; 256],
             description: vec![0; 1024],
+            logo_url: vec![0; 1024],
             additional: vec![0; 1024],
         };
         assert!(!SubtensorModule::is_valid_subnet_identity(
@@ -1200,13 +1270,14 @@ fn test_is_valid_subnet_identity() {
         ));
 
         // Test subnet identity with one field exceeding its maximum
-        let invalid_field_identity = SubnetIdentityV2 {
+        let invalid_field_identity = SubnetIdentityV3 {
             subnet_name: vec![0; 257],
             github_repo: vec![0; 1024],
             subnet_contact: vec![0; 1024],
             subnet_url: vec![0; 1024],
             discord: vec![0; 256],
             description: vec![0; 1024],
+            logo_url: vec![0; 1024],
             additional: vec![0; 1024],
         };
         assert!(!SubtensorModule::is_valid_subnet_identity(
@@ -1214,25 +1285,27 @@ fn test_is_valid_subnet_identity() {
         ));
 
         // Test subnet identity with empty fields
-        let empty_identity = SubnetIdentityV2 {
+        let empty_identity = SubnetIdentityV3 {
             subnet_name: vec![],
             github_repo: vec![],
             subnet_contact: vec![],
             subnet_url: vec![],
             discord: vec![],
             description: vec![],
+            logo_url: vec![],
             additional: vec![],
         };
         assert!(SubtensorModule::is_valid_subnet_identity(&empty_identity));
 
         // Test subnet identity with some empty and some filled fields
-        let mixed_identity = SubnetIdentityV2 {
+        let mixed_identity = SubnetIdentityV3 {
             subnet_name: b"Test Subnet".to_vec(),
             github_repo: vec![],
             subnet_contact: b"contact@testsubnet.com".to_vec(),
             subnet_url: b"https://testsubnet.com".to_vec(),
             discord: vec![],
             description: b"A description".to_vec(),
+            logo_url: vec![],
             additional: vec![],
         };
         assert!(SubtensorModule::is_valid_subnet_identity(&mixed_identity));
@@ -1252,6 +1325,7 @@ fn test_set_identity_for_non_existent_subnet() {
         let subnet_url = b"subnet.com".to_vec();
         let discord = b"discord.com".to_vec();
         let description = b"I am the describer".to_vec();
+        let logo_url = b"https://testsubnet.com/logo.png".to_vec();
         let additional = b"tao foreva".to_vec();
 
         // Attempt to set identity for a non-existent subnet
@@ -1265,6 +1339,7 @@ fn test_set_identity_for_non_existent_subnet() {
                 subnet_url.clone(),
                 discord.clone(),
                 description.clone(),
+                logo_url.clone(),
                 additional.clone(),
             ),
             Error::<Test>::NotSubnetOwner // Since there's no owner, it should fail
@@ -1282,6 +1357,7 @@ fn test_set_subnet_identity_dispatch_info_ok() {
         let subnet_url = b"subnet.com".to_vec();
         let discord = b"discord.com".to_vec();
         let description = b"I am the describer".to_vec();
+        let logo_url = b"https://testsubnet.com/logo.png".to_vec();
         let additional = b"tao foreva".to_vec();
 
         let call: RuntimeCall = RuntimeCall::SubtensorModule(SubtensorCall::set_subnet_identity {
@@ -1292,6 +1368,7 @@ fn test_set_subnet_identity_dispatch_info_ok() {
             subnet_url,
             discord,
             description,
+            logo_url,
             additional,
         });
 
diff --git a/pallets/subtensor/src/utils/identity.rs b/pallets/subtensor/src/utils/identity.rs
index 287c45a543..059fe2a7a2 100644
--- a/pallets/subtensor/src/utils/identity.rs
+++ b/pallets/subtensor/src/utils/identity.rs
@@ -104,6 +104,7 @@ impl<T: Config> Pallet<T> {
         subnet_url: Vec<u8>,
         discord: Vec<u8>,
         description: Vec<u8>,
+        logo_url: Vec<u8>,
         additional: Vec<u8>,
     ) -> dispatch::DispatchResult {
         // Ensure the call is signed and get the signer's (coldkey) account
@@ -116,13 +117,14 @@ impl<T: Config> Pallet<T> {
         );
 
         // Create the identity struct with the provided information
-        let identity: SubnetIdentityOfV2 = SubnetIdentityOfV2 {
+        let identity: SubnetIdentityOfV3 = SubnetIdentityOfV3 {
             subnet_name,
             github_repo,
             subnet_contact,
             subnet_url,
             discord,
             description,
+            logo_url,
             additional,
         };
 
@@ -133,7 +135,7 @@ impl<T: Config> Pallet<T> {
         );
 
         // Store the validated identity in the blockchain state
-        SubnetIdentitiesV2::<T>::insert(netuid, identity.clone());
+        SubnetIdentitiesV3::<T>::insert(netuid, identity.clone());
 
         // Log the identity set event
         log::debug!("SubnetIdentitySet( netuid:{:?} ) ", netuid);
@@ -186,20 +188,20 @@ impl<T: Config> Pallet<T> {
             && identity.additional.len() <= 1024
     }
 
-    /// Validates the given SubnetIdentityOf struct.
+    /// Validates the given SubnetIdentityOfV3 struct.
     ///
-    /// This function checks if the total length of all fields in the SubnetIdentityOf struct
+    /// This function checks if the total length of all fields in the SubnetIdentityOfV3 struct
     /// is less than or equal to 2304 bytes, and if each individual field is also
     /// within its respective maximum byte limit.
     ///
     /// # Arguments
     ///
-    /// * `identity` - A reference to the SubnetIdentityOf struct to be validated.
+    /// * `identity` - A reference to the SubnetIdentityOfV3 struct to be validated.
     ///
     /// # Returns
     ///
-    /// * `bool` - Returns true if the SubnetIdentity is valid, false otherwise.
-    pub fn is_valid_subnet_identity(identity: &SubnetIdentityOfV2) -> bool {
+    /// * `bool` - Returns true if the SubnetIdentityV3 is valid, false otherwise.
+    pub fn is_valid_subnet_identity(identity: &SubnetIdentityOfV3) -> bool {
         let total_length = identity
             .subnet_name
             .len()
@@ -212,6 +214,7 @@ impl<T: Config> Pallet<T> {
             .saturating_add(1024)
             .saturating_add(256)
             .saturating_add(1024)
+            .saturating_add(1024)
             .saturating_add(1024);
 
         total_length <= max_length
@@ -221,6 +224,7 @@ impl<T: Config> Pallet<T> {
             && identity.subnet_url.len() <= 1024
             && identity.discord.len() <= 256
             && identity.description.len() <= 1024
+            && identity.logo_url.len() <= 1024
             && identity.additional.len() <= 1024
     }
 }
diff --git a/precompiles/src/subnet.rs b/precompiles/src/subnet.rs
index 7eecb5d095..8c11cdba40 100644
--- a/precompiles/src/subnet.rs
+++ b/precompiles/src/subnet.rs
@@ -59,7 +59,7 @@ where
     }
 
     #[precompile::public(
-        "registerNetwork(bytes32,string,string,string,string,string,string,string)"
+        "registerNetwork(bytes32,string,string,string,string,string,string,string,string)"
     )]
     #[precompile::payable]
     #[allow(clippy::too_many_arguments)]
@@ -73,15 +73,17 @@ where
         discord: BoundedString<ConstU32<256>>,
         description: BoundedString<ConstU32<1024>>,
         additional: BoundedString<ConstU32<1024>>,
+        logo_url: BoundedString<ConstU32<1024>>,
     ) -> EvmResult<()> {
         let hotkey = R::AccountId::from(hotkey.0);
-        let identity = pallet_subtensor::SubnetIdentityOfV2 {
+        let identity = pallet_subtensor::SubnetIdentityOfV3 {
             subnet_name: subnet_name.into(),
             github_repo: github_repo.into(),
             subnet_contact: subnet_contact.into(),
             subnet_url: subnet_url.into(),
             discord: discord.into(),
             description: description.into(),
+            logo_url: logo_url.into(),
             additional: additional.into(),
         };
 

From 981ee8037f1e802cb0f997a3f4102b8abb22366d Mon Sep 17 00:00:00 2001
From: Ben Mason <ben@wattmason.co.uk>
Date: Thu, 12 Jun 2025 21:55:32 +0100
Subject: [PATCH 341/418] fix: undo precompile edit and add new method

---
 precompiles/src/subnet.rs | 41 ++++++++++++++++++++++++++++++++++++++-
 1 file changed, 40 insertions(+), 1 deletion(-)

diff --git a/precompiles/src/subnet.rs b/precompiles/src/subnet.rs
index 8c11cdba40..fb204375c8 100644
--- a/precompiles/src/subnet.rs
+++ b/precompiles/src/subnet.rs
@@ -59,7 +59,7 @@ where
     }
 
     #[precompile::public(
-        "registerNetwork(bytes32,string,string,string,string,string,string,string,string)"
+        "registerNetwork(bytes32,string,string,string,string,string,string,string)"
     )]
     #[precompile::payable]
     #[allow(clippy::too_many_arguments)]
@@ -73,6 +73,45 @@ where
         discord: BoundedString<ConstU32<256>>,
         description: BoundedString<ConstU32<1024>>,
         additional: BoundedString<ConstU32<1024>>,
+    ) -> EvmResult<()> {
+        let hotkey = R::AccountId::from(hotkey.0);
+        let identity = pallet_subtensor::SubnetIdentityOfV3 {
+            subnet_name: subnet_name.into(),
+            github_repo: github_repo.into(),
+            subnet_contact: subnet_contact.into(),
+            subnet_url: subnet_url.into(),
+            discord: discord.into(),
+            description: description.into(),
+            logo_url: vec![],
+            additional: additional.into(),
+        };
+
+        let call = pallet_subtensor::Call::<R>::register_network_with_identity {
+            hotkey,
+            identity: Some(identity),
+        };
+
+        handle.try_dispatch_runtime_call::<R, _>(
+            call,
+            RawOrigin::Signed(handle.caller_account_id::<R>()),
+        )
+    }
+
+    #[precompile::public(
+        "registerNetwork(bytes32,string,string,string,string,string,string,string,string)"
+    )]
+    #[precompile::payable]
+    #[allow(clippy::too_many_arguments)]
+    fn register_network_with_identity_v2(
+        handle: &mut impl PrecompileHandle,
+        hotkey: H256,
+        subnet_name: BoundedString<ConstU32<256>>,
+        github_repo: BoundedString<ConstU32<1024>>,
+        subnet_contact: BoundedString<ConstU32<1024>>,
+        subnet_url: BoundedString<ConstU32<1024>>,
+        discord: BoundedString<ConstU32<256>>,
+        description: BoundedString<ConstU32<1024>>,
+        additional: BoundedString<ConstU32<1024>>,
         logo_url: BoundedString<ConstU32<1024>>,
     ) -> EvmResult<()> {
         let hotkey = R::AccountId::from(hotkey.0);

From cbf60e4f577166534f94ec31d11d6f79be6de370 Mon Sep 17 00:00:00 2001
From: Ben Mason <ben@wattmason.co.uk>
Date: Thu, 12 Jun 2025 22:04:11 +0100
Subject: [PATCH 342/418] fix: import vec

---
 precompiles/src/subnet.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/precompiles/src/subnet.rs b/precompiles/src/subnet.rs
index fb204375c8..03b2fa56ac 100644
--- a/precompiles/src/subnet.rs
+++ b/precompiles/src/subnet.rs
@@ -7,6 +7,7 @@ use pallet_evm::{AddressMapping, PrecompileHandle};
 use precompile_utils::{EvmResult, prelude::BoundedString};
 use sp_core::H256;
 use sp_runtime::traits::Dispatchable;
+use sp_std::vec;
 use subtensor_runtime_common::NetUid;
 
 use crate::{PrecompileExt, PrecompileHandleExt};

From e9762efc4652063f87395f101402fd31600af96c Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Thu, 12 Jun 2025 23:44:41 +0200
Subject: [PATCH 343/418] fix admin utils benchmarks

---
 pallets/admin-utils/src/lib.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/pallets/admin-utils/src/lib.rs b/pallets/admin-utils/src/lib.rs
index b1481600b3..0f544b504d 100644
--- a/pallets/admin-utils/src/lib.rs
+++ b/pallets/admin-utils/src/lib.rs
@@ -149,9 +149,9 @@ pub mod pallet {
         /// It is only callable by the root account.
         /// The extrinsic will call the Aura pallet to change the authorities.
         #[pallet::call_index(0)]
-        #[pallet::weight(Weight::from_parts(6_265_000, 0)
-        .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(1_u64))
-        .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(2_u64)))]
+        #[pallet::weight(Weight::from_parts(5_062_000, 0)
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(0_u64))
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1_u64)))]
         pub fn swap_authorities(
             origin: OriginFor<T>,
             new_authorities: BoundedVec<<T as Config>::AuthorityId, T::MaxAuthorities>,
@@ -1411,7 +1411,7 @@ pub mod pallet {
         /// No change should be signaled while any change is pending. Returns an error if a change
         /// is already pending.
         #[pallet::call_index(59)]
-        #[pallet::weight(Weight::from_parts(11_550_000, 0)
+        #[pallet::weight(Weight::from_parts(9_060_000, 0)
         .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(1_u64))
         .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1_u64)))]
         pub fn schedule_grandpa_change(

From d8b95f6b483aa7de14d58fb15503abe54dc3d9fa Mon Sep 17 00:00:00 2001
From: Ben Mason <ben@wattmason.co.uk>
Date: Thu, 12 Jun 2025 23:01:57 +0100
Subject: [PATCH 344/418] fix: add new precompile method to ABI & solidity file

---
 precompiles/src/solidity/subnet.abi | 53 +++++++++++++++++++++++++++++
 precompiles/src/solidity/subnet.sol | 12 +++++++
 2 files changed, 65 insertions(+)

diff --git a/precompiles/src/solidity/subnet.abi b/precompiles/src/solidity/subnet.abi
index 35f8a06571..b853a6f94c 100644
--- a/precompiles/src/solidity/subnet.abi
+++ b/precompiles/src/solidity/subnet.abi
@@ -521,6 +521,59 @@
 		"stateMutability": "payable",
 		"type": "function"
 	},
+	{
+		"inputs": [
+			{
+				"internalType": "bytes32",
+				"name": "hotkey",
+				"type": "bytes32"
+			},
+			{
+				"internalType": "string",
+				"name": "subnetName",
+				"type": "string"
+			},
+			{
+				"internalType": "string",
+				"name": "githubRepo",
+				"type": "string"
+			},
+			{
+				"internalType": "string",
+				"name": "subnetContact",
+				"type": "string"
+			},
+			{
+				"internalType": "string",
+				"name": "subnetUrl",
+				"type": "string"
+			},
+			{
+				"internalType": "string",
+				"name": "discord",
+				"type": "string"
+			},
+			{
+				"internalType": "string",
+				"name": "description",
+				"type": "string"
+			},
+			{
+				"internalType": "string",
+				"name": "logoUrl",
+				"type": "string"
+			},
+			{
+				"internalType": "string",
+				"name": "additional",
+				"type": "string"
+			}
+		],
+		"name": "registerNetwork",
+		"outputs": [],
+		"stateMutability": "payable",
+		"type": "function"
+	},
 	{
 		"inputs": [
 			{
diff --git a/precompiles/src/solidity/subnet.sol b/precompiles/src/solidity/subnet.sol
index b1da53944e..a6086759bb 100644
--- a/precompiles/src/solidity/subnet.sol
+++ b/precompiles/src/solidity/subnet.sol
@@ -16,6 +16,18 @@ interface ISubnet {
         string memory description,
         string memory additional
     ) external payable;
+    /// Registers a new network with specified subnet name, GitHub repository, contact information, and logo URL.
+    function registerNetwork(
+        bytes32 hotkey,
+        string memory subnetName,
+        string memory githubRepo,
+        string memory subnetContact,
+        string memory subnetUrl,
+        string memory discord,
+        string memory description,
+        string memory logoUrl,
+        string memory additional
+    ) external payable;
 
     function getServingRateLimit(uint16 netuid) external view returns (uint64);
 

From 09288aaa34d895adc5d6fa162e1ec362990174f9 Mon Sep 17 00:00:00 2001
From: Ben Mason <ben@wattmason.co.uk>
Date: Thu, 12 Jun 2025 23:26:16 +0100
Subject: [PATCH 345/418] fix: update args for set_subnet_identity benchmark

---
 pallets/subtensor/src/benchmarks.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/pallets/subtensor/src/benchmarks.rs b/pallets/subtensor/src/benchmarks.rs
index 73c827556d..b6a8f903be 100644
--- a/pallets/subtensor/src/benchmarks.rs
+++ b/pallets/subtensor/src/benchmarks.rs
@@ -1235,6 +1235,7 @@ mod pallet_benchmarks {
         let url = vec![];
         let disc = vec![];
         let descr = vec![];
+        let logo_url = vec![];
         let add = vec![];
 
         SubnetOwner::<T>::insert(netuid, coldkey.clone());
@@ -1250,6 +1251,7 @@ mod pallet_benchmarks {
             url.clone(),
             disc.clone(),
             descr.clone(),
+            logo_url.clone(),
             add.clone(),
         );
     }

From 984ea2cd61332080c4677e350e236d92bbab36e5 Mon Sep 17 00:00:00 2001
From: John Reed <87283488+JohnReedV@users.noreply.github.com>
Date: Thu, 12 Jun 2025 16:19:44 -0700
Subject: [PATCH 346/418] update commitments weight

---
 pallets/commitments/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pallets/commitments/src/lib.rs b/pallets/commitments/src/lib.rs
index 9e782baa06..527a00b13a 100644
--- a/pallets/commitments/src/lib.rs
+++ b/pallets/commitments/src/lib.rs
@@ -343,7 +343,7 @@ pub mod pallet {
         /// Sudo-set MaxSpace
         #[pallet::call_index(2)]
         #[pallet::weight((
-            Weight::from_parts(3_556_000, 0)
+            Weight::from_parts(2_965_000, 0)
 			.saturating_add(T::DbWeight::get().reads(0_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64)),
             DispatchClass::Operational,

From e0e5a7a455f5daca09621bd0ef9bbc6186165285 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Fri, 13 Jun 2025 15:26:19 +0800
Subject: [PATCH 347/418] avoid keep running after node exit

---
 evm-tests/run-ci.sh | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/evm-tests/run-ci.sh b/evm-tests/run-ci.sh
index cd7acb14af..363b1c52cc 100755
--- a/evm-tests/run-ci.sh
+++ b/evm-tests/run-ci.sh
@@ -19,6 +19,13 @@ if [ "$i" -eq 1000 ]; then
     exit 1
 fi
 
+sleep 5
+
+if ! nc -z localhost 9944; then
+    echo "node subtensor exit, port not available"
+    exit 1
+fi
+
 cd evm-tests
 
 yarn

From 69d1e67922c86e4968126605845d74f6932f16fc Mon Sep 17 00:00:00 2001
From: Ben Mason <ben@wattmason.co.uk>
Date: Fri, 13 Jun 2025 09:30:52 +0100
Subject: [PATCH 348/418] fix: make evm-tests/get-metadata.sh executable

---
 evm-tests/get-metadata.sh | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 mode change 100644 => 100755 evm-tests/get-metadata.sh

diff --git a/evm-tests/get-metadata.sh b/evm-tests/get-metadata.sh
old mode 100644
new mode 100755

From 3a009a2a42f876d502c1fcc0d34cc5aa3473dfb6 Mon Sep 17 00:00:00 2001
From: Ben Mason <ben@wattmason.co.uk>
Date: Fri, 13 Jun 2025 09:32:40 +0100
Subject: [PATCH 349/418] fix: allow yarn.lock to be visible in git

---
 .gitignore | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.gitignore b/.gitignore
index 5921b6b937..f6a9e635e2 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,6 +5,7 @@
 **/*.rs.bk
 
 **/*.lock
+!evm-tests/yarn.lock
 
 *.ipynb
 

From ab1e395bab3f460419be81769716878251da1f87 Mon Sep 17 00:00:00 2001
From: Ben Mason <ben@wattmason.co.uk>
Date: Fri, 13 Jun 2025 09:34:24 +0100
Subject: [PATCH 350/418] fix: use same node package manager as CI (npm ->
 yarn)

---
 evm-tests/package-lock.json | 5917 -----------------------------------
 evm-tests/yarn.lock         | 3225 +++++++++++++++++++
 2 files changed, 3225 insertions(+), 5917 deletions(-)
 delete mode 100644 evm-tests/package-lock.json
 create mode 100644 evm-tests/yarn.lock

diff --git a/evm-tests/package-lock.json b/evm-tests/package-lock.json
deleted file mode 100644
index 9e318e9a24..0000000000
--- a/evm-tests/package-lock.json
+++ /dev/null
@@ -1,5917 +0,0 @@
-{
-  "name": "evm-tests",
-  "lockfileVersion": 3,
-  "requires": true,
-  "packages": {
-    "": {
-      "license": "ISC",
-      "dependencies": {
-        "@polkadot-api/descriptors": "file:.papi/descriptors",
-        "@polkadot-labs/hdkd": "^0.0.10",
-        "@polkadot-labs/hdkd-helpers": "^0.0.11",
-        "@polkadot/api": "15.1.1",
-        "@types/mocha": "^10.0.10",
-        "crypto": "^1.0.1",
-        "dotenv": "16.4.7",
-        "ethers": "^6.13.5",
-        "mocha": "^11.1.0",
-        "polkadot-api": "^1.9.5",
-        "scale-ts": "^1.6.1",
-        "viem": "2.23.4",
-        "ws": "^8.18.2"
-      },
-      "devDependencies": {
-        "@types/bun": "^1.1.13",
-        "@types/chai": "^5.0.1",
-        "assert": "^2.1.0",
-        "chai": "^5.2.0",
-        "prettier": "^3.3.3",
-        "ts-node": "^10.9.2",
-        "typescript": "^5.7.2",
-        "vite": "^5.4.8"
-      }
-    },
-    ".papi/descriptors": {
-      "name": "@polkadot-api/descriptors",
-      "version": "0.1.0-autogenerated.3055518094912556806",
-      "peerDependencies": {
-        "polkadot-api": ">=1.11.2"
-      }
-    },
-    "node_modules/@adraffy/ens-normalize": {
-      "version": "1.10.1",
-      "resolved": "https://registry.npmjs.org/@adraffy/ens-normalize/-/ens-normalize-1.10.1.tgz",
-      "integrity": "sha512-96Z2IP3mYmF1Xg2cDm8f1gWGf/HUVedQ3FMifV4kG/PQ4yEP51xDtRAEfhVNt5f/uzpNkZHwWQuUcu6D6K+Ekw==",
-      "license": "MIT"
-    },
-    "node_modules/@babel/code-frame": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.27.1.tgz",
-      "integrity": "sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==",
-      "license": "MIT",
-      "dependencies": {
-        "@babel/helper-validator-identifier": "^7.27.1",
-        "js-tokens": "^4.0.0",
-        "picocolors": "^1.1.1"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/helper-validator-identifier": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.27.1.tgz",
-      "integrity": "sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@commander-js/extra-typings": {
-      "version": "13.1.0",
-      "resolved": "https://registry.npmjs.org/@commander-js/extra-typings/-/extra-typings-13.1.0.tgz",
-      "integrity": "sha512-q5P52BYb1hwVWE6dtID7VvuJWrlfbCv4klj7BjUUOqMz4jbSZD4C9fJ9lRjL2jnBGTg+gDDlaXN51rkWcLk4fg==",
-      "license": "MIT",
-      "peerDependencies": {
-        "commander": "~13.1.0"
-      }
-    },
-    "node_modules/@cspotcode/source-map-support": {
-      "version": "0.8.1",
-      "resolved": "https://registry.npmjs.org/@cspotcode/source-map-support/-/source-map-support-0.8.1.tgz",
-      "integrity": "sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jridgewell/trace-mapping": "0.3.9"
-      },
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/aix-ppc64": {
-      "version": "0.25.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.5.tgz",
-      "integrity": "sha512-9o3TMmpmftaCMepOdA5k/yDw8SfInyzWWTjYTFCX3kPSDJMROQTb8jg+h9Cnwnmm1vOzvxN7gIfB5V2ewpjtGA==",
-      "cpu": [
-        "ppc64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "aix"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/android-arm": {
-      "version": "0.25.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.5.tgz",
-      "integrity": "sha512-AdJKSPeEHgi7/ZhuIPtcQKr5RQdo6OO2IL87JkianiMYMPbCtot9fxPbrMiBADOWWm3T2si9stAiVsGbTQFkbA==",
-      "cpu": [
-        "arm"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/android-arm64": {
-      "version": "0.25.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.5.tgz",
-      "integrity": "sha512-VGzGhj4lJO+TVGV1v8ntCZWJktV7SGCs3Pn1GRWI1SBFtRALoomm8k5E9Pmwg3HOAal2VDc2F9+PM/rEY6oIDg==",
-      "cpu": [
-        "arm64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/android-x64": {
-      "version": "0.25.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.5.tgz",
-      "integrity": "sha512-D2GyJT1kjvO//drbRT3Hib9XPwQeWd9vZoBJn+bu/lVsOZ13cqNdDeqIF/xQ5/VmWvMduP6AmXvylO/PIc2isw==",
-      "cpu": [
-        "x64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/darwin-arm64": {
-      "version": "0.25.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.5.tgz",
-      "integrity": "sha512-GtaBgammVvdF7aPIgH2jxMDdivezgFu6iKpmT+48+F8Hhg5J/sfnDieg0aeG/jfSvkYQU2/pceFPDKlqZzwnfQ==",
-      "cpu": [
-        "arm64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/darwin-x64": {
-      "version": "0.25.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.5.tgz",
-      "integrity": "sha512-1iT4FVL0dJ76/q1wd7XDsXrSW+oLoquptvh4CLR4kITDtqi2e/xwXwdCVH8hVHU43wgJdsq7Gxuzcs6Iq/7bxQ==",
-      "cpu": [
-        "x64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/freebsd-arm64": {
-      "version": "0.25.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.5.tgz",
-      "integrity": "sha512-nk4tGP3JThz4La38Uy/gzyXtpkPW8zSAmoUhK9xKKXdBCzKODMc2adkB2+8om9BDYugz+uGV7sLmpTYzvmz6Sw==",
-      "cpu": [
-        "arm64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/freebsd-x64": {
-      "version": "0.25.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.5.tgz",
-      "integrity": "sha512-PrikaNjiXdR2laW6OIjlbeuCPrPaAl0IwPIaRv+SMV8CiM8i2LqVUHFC1+8eORgWyY7yhQY+2U2fA55mBzReaw==",
-      "cpu": [
-        "x64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-arm": {
-      "version": "0.25.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.5.tgz",
-      "integrity": "sha512-cPzojwW2okgh7ZlRpcBEtsX7WBuqbLrNXqLU89GxWbNt6uIg78ET82qifUy3W6OVww6ZWobWub5oqZOVtwolfw==",
-      "cpu": [
-        "arm"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-arm64": {
-      "version": "0.25.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.5.tgz",
-      "integrity": "sha512-Z9kfb1v6ZlGbWj8EJk9T6czVEjjq2ntSYLY2cw6pAZl4oKtfgQuS4HOq41M/BcoLPzrUbNd+R4BXFyH//nHxVg==",
-      "cpu": [
-        "arm64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-ia32": {
-      "version": "0.25.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.5.tgz",
-      "integrity": "sha512-sQ7l00M8bSv36GLV95BVAdhJ2QsIbCuCjh/uYrWiMQSUuV+LpXwIqhgJDcvMTj+VsQmqAHL2yYaasENvJ7CDKA==",
-      "cpu": [
-        "ia32"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-loong64": {
-      "version": "0.25.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.5.tgz",
-      "integrity": "sha512-0ur7ae16hDUC4OL5iEnDb0tZHDxYmuQyhKhsPBV8f99f6Z9KQM02g33f93rNH5A30agMS46u2HP6qTdEt6Q1kg==",
-      "cpu": [
-        "loong64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-mips64el": {
-      "version": "0.25.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.5.tgz",
-      "integrity": "sha512-kB/66P1OsHO5zLz0i6X0RxlQ+3cu0mkxS3TKFvkb5lin6uwZ/ttOkP3Z8lfR9mJOBk14ZwZ9182SIIWFGNmqmg==",
-      "cpu": [
-        "mips64el"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-ppc64": {
-      "version": "0.25.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.5.tgz",
-      "integrity": "sha512-UZCmJ7r9X2fe2D6jBmkLBMQetXPXIsZjQJCjgwpVDz+YMcS6oFR27alkgGv3Oqkv07bxdvw7fyB71/olceJhkQ==",
-      "cpu": [
-        "ppc64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-riscv64": {
-      "version": "0.25.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.5.tgz",
-      "integrity": "sha512-kTxwu4mLyeOlsVIFPfQo+fQJAV9mh24xL+y+Bm6ej067sYANjyEw1dNHmvoqxJUCMnkBdKpvOn0Ahql6+4VyeA==",
-      "cpu": [
-        "riscv64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-s390x": {
-      "version": "0.25.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.5.tgz",
-      "integrity": "sha512-K2dSKTKfmdh78uJ3NcWFiqyRrimfdinS5ErLSn3vluHNeHVnBAFWC8a4X5N+7FgVE1EjXS1QDZbpqZBjfrqMTQ==",
-      "cpu": [
-        "s390x"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-x64": {
-      "version": "0.25.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.5.tgz",
-      "integrity": "sha512-uhj8N2obKTE6pSZ+aMUbqq+1nXxNjZIIjCjGLfsWvVpy7gKCOL6rsY1MhRh9zLtUtAI7vpgLMK6DxjO8Qm9lJw==",
-      "cpu": [
-        "x64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/netbsd-arm64": {
-      "version": "0.25.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.5.tgz",
-      "integrity": "sha512-pwHtMP9viAy1oHPvgxtOv+OkduK5ugofNTVDilIzBLpoWAM16r7b/mxBvfpuQDpRQFMfuVr5aLcn4yveGvBZvw==",
-      "cpu": [
-        "arm64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "netbsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/netbsd-x64": {
-      "version": "0.25.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.5.tgz",
-      "integrity": "sha512-WOb5fKrvVTRMfWFNCroYWWklbnXH0Q5rZppjq0vQIdlsQKuw6mdSihwSo4RV/YdQ5UCKKvBy7/0ZZYLBZKIbwQ==",
-      "cpu": [
-        "x64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "netbsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/openbsd-arm64": {
-      "version": "0.25.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.5.tgz",
-      "integrity": "sha512-7A208+uQKgTxHd0G0uqZO8UjK2R0DDb4fDmERtARjSHWxqMTye4Erz4zZafx7Di9Cv+lNHYuncAkiGFySoD+Mw==",
-      "cpu": [
-        "arm64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "openbsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/openbsd-x64": {
-      "version": "0.25.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.5.tgz",
-      "integrity": "sha512-G4hE405ErTWraiZ8UiSoesH8DaCsMm0Cay4fsFWOOUcz8b8rC6uCvnagr+gnioEjWn0wC+o1/TAHt+It+MpIMg==",
-      "cpu": [
-        "x64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "openbsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/sunos-x64": {
-      "version": "0.25.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.5.tgz",
-      "integrity": "sha512-l+azKShMy7FxzY0Rj4RCt5VD/q8mG/e+mDivgspo+yL8zW7qEwctQ6YqKX34DTEleFAvCIUviCFX1SDZRSyMQA==",
-      "cpu": [
-        "x64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "sunos"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/win32-arm64": {
-      "version": "0.25.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.5.tgz",
-      "integrity": "sha512-O2S7SNZzdcFG7eFKgvwUEZ2VG9D/sn/eIiz8XRZ1Q/DO5a3s76Xv0mdBzVM5j5R639lXQmPmSo0iRpHqUUrsxw==",
-      "cpu": [
-        "arm64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/win32-ia32": {
-      "version": "0.25.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.5.tgz",
-      "integrity": "sha512-onOJ02pqs9h1iMJ1PQphR+VZv8qBMQ77Klcsqv9CNW2w6yLqoURLcgERAIurY6QE63bbLuqgP9ATqajFLK5AMQ==",
-      "cpu": [
-        "ia32"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/win32-x64": {
-      "version": "0.25.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.5.tgz",
-      "integrity": "sha512-TXv6YnJ8ZMVdX+SXWVBo/0p8LTcrUYngpWjvm91TMjjBQii7Oz11Lw5lbDV5Y0TzuhSJHwiH4hEtC1I42mMS0g==",
-      "cpu": [
-        "x64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@isaacs/cliui": {
-      "version": "8.0.2",
-      "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-8.0.2.tgz",
-      "integrity": "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==",
-      "license": "ISC",
-      "dependencies": {
-        "string-width": "^5.1.2",
-        "string-width-cjs": "npm:string-width@^4.2.0",
-        "strip-ansi": "^7.0.1",
-        "strip-ansi-cjs": "npm:strip-ansi@^6.0.1",
-        "wrap-ansi": "^8.1.0",
-        "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0"
-      },
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@isaacs/cliui/node_modules/ansi-regex": {
-      "version": "6.1.0",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.1.0.tgz",
-      "integrity": "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-regex?sponsor=1"
-      }
-    },
-    "node_modules/@isaacs/cliui/node_modules/ansi-styles": {
-      "version": "6.2.1",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.1.tgz",
-      "integrity": "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
-      }
-    },
-    "node_modules/@isaacs/cliui/node_modules/emoji-regex": {
-      "version": "9.2.2",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz",
-      "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==",
-      "license": "MIT"
-    },
-    "node_modules/@isaacs/cliui/node_modules/string-width": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz",
-      "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==",
-      "license": "MIT",
-      "dependencies": {
-        "eastasianwidth": "^0.2.0",
-        "emoji-regex": "^9.2.2",
-        "strip-ansi": "^7.0.1"
-      },
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/@isaacs/cliui/node_modules/strip-ansi": {
-      "version": "7.1.0",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz",
-      "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==",
-      "license": "MIT",
-      "dependencies": {
-        "ansi-regex": "^6.0.1"
-      },
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/strip-ansi?sponsor=1"
-      }
-    },
-    "node_modules/@isaacs/cliui/node_modules/wrap-ansi": {
-      "version": "8.1.0",
-      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-8.1.0.tgz",
-      "integrity": "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==",
-      "license": "MIT",
-      "dependencies": {
-        "ansi-styles": "^6.1.0",
-        "string-width": "^5.0.1",
-        "strip-ansi": "^7.0.1"
-      },
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
-      }
-    },
-    "node_modules/@jridgewell/gen-mapping": {
-      "version": "0.3.8",
-      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.8.tgz",
-      "integrity": "sha512-imAbBGkb+ebQyxKgzv5Hu2nmROxoDOXHh80evxdoXNOrvAnVx7zimzc1Oo5h9RlfV4vPXaE2iM5pOFbvOCClWA==",
-      "license": "MIT",
-      "dependencies": {
-        "@jridgewell/set-array": "^1.2.1",
-        "@jridgewell/sourcemap-codec": "^1.4.10",
-        "@jridgewell/trace-mapping": "^0.3.24"
-      },
-      "engines": {
-        "node": ">=6.0.0"
-      }
-    },
-    "node_modules/@jridgewell/gen-mapping/node_modules/@jridgewell/trace-mapping": {
-      "version": "0.3.25",
-      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.25.tgz",
-      "integrity": "sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==",
-      "license": "MIT",
-      "dependencies": {
-        "@jridgewell/resolve-uri": "^3.1.0",
-        "@jridgewell/sourcemap-codec": "^1.4.14"
-      }
-    },
-    "node_modules/@jridgewell/resolve-uri": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
-      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.0.0"
-      }
-    },
-    "node_modules/@jridgewell/set-array": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.2.1.tgz",
-      "integrity": "sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.0.0"
-      }
-    },
-    "node_modules/@jridgewell/sourcemap-codec": {
-      "version": "1.5.0",
-      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.0.tgz",
-      "integrity": "sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ==",
-      "license": "MIT"
-    },
-    "node_modules/@jridgewell/trace-mapping": {
-      "version": "0.3.9",
-      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.9.tgz",
-      "integrity": "sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jridgewell/resolve-uri": "^3.0.3",
-        "@jridgewell/sourcemap-codec": "^1.4.10"
-      }
-    },
-    "node_modules/@noble/curves": {
-      "version": "1.8.1",
-      "resolved": "https://registry.npmjs.org/@noble/curves/-/curves-1.8.1.tgz",
-      "integrity": "sha512-warwspo+UYUPep0Q+vtdVB4Ugn8GGQj8iyB3gnRWsztmUHTI3S1nhdiWNsPUGL0vud7JlRRk1XEu7Lq1KGTnMQ==",
-      "license": "MIT",
-      "dependencies": {
-        "@noble/hashes": "1.7.1"
-      },
-      "engines": {
-        "node": "^14.21.3 || >=16"
-      },
-      "funding": {
-        "url": "https://paulmillr.com/funding/"
-      }
-    },
-    "node_modules/@noble/hashes": {
-      "version": "1.7.1",
-      "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.7.1.tgz",
-      "integrity": "sha512-B8XBPsn4vT/KJAGqDzbwztd+6Yte3P4V7iafm24bxgDe/mlRuK6xmWPuCNrKt2vDafZ8MfJLlchDG/vYafQEjQ==",
-      "license": "MIT",
-      "engines": {
-        "node": "^14.21.3 || >=16"
-      },
-      "funding": {
-        "url": "https://paulmillr.com/funding/"
-      }
-    },
-    "node_modules/@pkgjs/parseargs": {
-      "version": "0.11.0",
-      "resolved": "https://registry.npmjs.org/@pkgjs/parseargs/-/parseargs-0.11.0.tgz",
-      "integrity": "sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==",
-      "license": "MIT",
-      "optional": true,
-      "engines": {
-        "node": ">=14"
-      }
-    },
-    "node_modules/@polkadot-api/cli": {
-      "version": "0.13.0",
-      "resolved": "https://registry.npmjs.org/@polkadot-api/cli/-/cli-0.13.0.tgz",
-      "integrity": "sha512-uumqacO1+YxuhHYOr75czxvV0KmRxm3DaZtRKzxIf2zpICnj/QnBTpJwlxU56g+pQDU5P/hTR0Thh0vrnUTNVw==",
-      "license": "MIT",
-      "dependencies": {
-        "@commander-js/extra-typings": "^13.1.0",
-        "@polkadot-api/codegen": "0.16.0",
-        "@polkadot-api/ink-contracts": "0.3.2",
-        "@polkadot-api/json-rpc-provider": "0.0.4",
-        "@polkadot-api/known-chains": "0.7.6",
-        "@polkadot-api/metadata-compatibility": "0.2.3",
-        "@polkadot-api/observable-client": "0.11.0",
-        "@polkadot-api/polkadot-sdk-compat": "2.3.2",
-        "@polkadot-api/sm-provider": "0.1.7",
-        "@polkadot-api/smoldot": "0.3.8",
-        "@polkadot-api/substrate-bindings": "0.13.0",
-        "@polkadot-api/substrate-client": "0.3.0",
-        "@polkadot-api/utils": "0.1.2",
-        "@polkadot-api/wasm-executor": "^0.1.2",
-        "@polkadot-api/ws-provider": "0.4.0",
-        "@types/node": "^22.15.18",
-        "commander": "^13.1.0",
-        "execa": "^9.5.3",
-        "fs.promises.exists": "^1.1.4",
-        "ora": "^8.2.0",
-        "read-pkg": "^9.0.1",
-        "rxjs": "^7.8.2",
-        "tsc-prog": "^2.3.0",
-        "tsup": "^8.4.0",
-        "typescript": "^5.8.3",
-        "write-package": "^7.1.0"
-      },
-      "bin": {
-        "papi": "dist/main.js",
-        "polkadot-api": "dist/main.js"
-      }
-    },
-    "node_modules/@polkadot-api/codegen": {
-      "version": "0.16.0",
-      "resolved": "https://registry.npmjs.org/@polkadot-api/codegen/-/codegen-0.16.0.tgz",
-      "integrity": "sha512-2Sq/fkB7a9Oi3t7nGc0EbTt1Nd8Pb8XGiKKS9i/wwFAdCLN2oXd33DxmRQTX0Hm2/nrBzXYh1zBuyxRUb9+Sdw==",
-      "license": "MIT",
-      "dependencies": {
-        "@polkadot-api/ink-contracts": "0.3.2",
-        "@polkadot-api/metadata-builders": "0.12.1",
-        "@polkadot-api/metadata-compatibility": "0.2.3",
-        "@polkadot-api/substrate-bindings": "0.13.0",
-        "@polkadot-api/utils": "0.1.2"
-      }
-    },
-    "node_modules/@polkadot-api/descriptors": {
-      "resolved": ".papi/descriptors",
-      "link": true
-    },
-    "node_modules/@polkadot-api/ink-contracts": {
-      "version": "0.3.2",
-      "resolved": "https://registry.npmjs.org/@polkadot-api/ink-contracts/-/ink-contracts-0.3.2.tgz",
-      "integrity": "sha512-ipWuClaySrPI7XHIomiswXhIZfU4q/EmHmLFIwLdn9iNhLd7YLuUtGF6kacSQu76YtWd3tkLe2rGx4cRRaLjOA==",
-      "license": "MIT",
-      "dependencies": {
-        "@polkadot-api/metadata-builders": "0.12.1",
-        "@polkadot-api/substrate-bindings": "0.13.0",
-        "@polkadot-api/utils": "0.1.2"
-      }
-    },
-    "node_modules/@polkadot-api/json-rpc-provider": {
-      "version": "0.0.4",
-      "resolved": "https://registry.npmjs.org/@polkadot-api/json-rpc-provider/-/json-rpc-provider-0.0.4.tgz",
-      "integrity": "sha512-9cDijLIxzHOBuq6yHqpqjJ9jBmXrctjc1OFqU+tQrS96adQze3mTIH6DTgfb/0LMrqxzxffz1HQGrIlEH00WrA==",
-      "license": "MIT"
-    },
-    "node_modules/@polkadot-api/json-rpc-provider-proxy": {
-      "version": "0.2.4",
-      "resolved": "https://registry.npmjs.org/@polkadot-api/json-rpc-provider-proxy/-/json-rpc-provider-proxy-0.2.4.tgz",
-      "integrity": "sha512-nuGoY9QpBAiRU7xmXN3nugFvPcnSu3IxTLm1OWcNTGlZ1LW5bvdQHz3JLk56+Jlyb3GJ971hqdg2DJsMXkKCOg==",
-      "license": "MIT"
-    },
-    "node_modules/@polkadot-api/known-chains": {
-      "version": "0.7.6",
-      "resolved": "https://registry.npmjs.org/@polkadot-api/known-chains/-/known-chains-0.7.6.tgz",
-      "integrity": "sha512-em+p9AVfTYulC4U10I+nO42wdczN9ZSAEyb5ppQsxxsKAxaJVPVe4xsDkWzlhheheEN6OBojNHnoYNBVG6X2bg==",
-      "license": "MIT"
-    },
-    "node_modules/@polkadot-api/logs-provider": {
-      "version": "0.0.6",
-      "resolved": "https://registry.npmjs.org/@polkadot-api/logs-provider/-/logs-provider-0.0.6.tgz",
-      "integrity": "sha512-4WgHlvy+xee1ADaaVf6+MlK/+jGMtsMgAzvbQOJZnP4PfQuagoTqaeayk8HYKxXGphogLlPbD06tANxcb+nvAg==",
-      "license": "MIT",
-      "dependencies": {
-        "@polkadot-api/json-rpc-provider": "0.0.4"
-      }
-    },
-    "node_modules/@polkadot-api/merkleize-metadata": {
-      "version": "1.1.17",
-      "resolved": "https://registry.npmjs.org/@polkadot-api/merkleize-metadata/-/merkleize-metadata-1.1.17.tgz",
-      "integrity": "sha512-3wlLrYjpBluN5l8M1H9zgXlFHfJhqIXYvSVXTvkBYcEVKxZt0PO0f43Zgskeabg29Lx83OiPINcEHFWF8ndAzg==",
-      "license": "MIT",
-      "dependencies": {
-        "@polkadot-api/metadata-builders": "0.12.1",
-        "@polkadot-api/substrate-bindings": "0.13.0",
-        "@polkadot-api/utils": "0.1.2"
-      }
-    },
-    "node_modules/@polkadot-api/metadata-builders": {
-      "version": "0.12.1",
-      "resolved": "https://registry.npmjs.org/@polkadot-api/metadata-builders/-/metadata-builders-0.12.1.tgz",
-      "integrity": "sha512-heGt+WgcxrS1CqMm9XwD2DC+fI6azMKJf2ToMP+H12yw6FAy++nijASDZ3MlV/0ZpA/QGZpuZmgQmxKh6jbxVg==",
-      "license": "MIT",
-      "dependencies": {
-        "@polkadot-api/substrate-bindings": "0.13.0",
-        "@polkadot-api/utils": "0.1.2"
-      }
-    },
-    "node_modules/@polkadot-api/metadata-compatibility": {
-      "version": "0.2.3",
-      "resolved": "https://registry.npmjs.org/@polkadot-api/metadata-compatibility/-/metadata-compatibility-0.2.3.tgz",
-      "integrity": "sha512-rtym491RA2yl8qGdEDJVujiCya+DK0CW5AwB6InSo85Um04/WWMq7oboRiXQZmspwLkfm2vYBusl/Q9k4Rxshw==",
-      "license": "MIT",
-      "dependencies": {
-        "@polkadot-api/metadata-builders": "0.12.1",
-        "@polkadot-api/substrate-bindings": "0.13.0"
-      }
-    },
-    "node_modules/@polkadot-api/observable-client": {
-      "version": "0.11.0",
-      "resolved": "https://registry.npmjs.org/@polkadot-api/observable-client/-/observable-client-0.11.0.tgz",
-      "integrity": "sha512-cyXyih+RI73vPcUQ6GxyMelm1Z3bGDvBIow8W3MqBdpUy4mZ87QGQXGpyBC0Op/qnIxrUFP1cLyT38fUe0i6KQ==",
-      "license": "MIT",
-      "dependencies": {
-        "@polkadot-api/metadata-builders": "0.12.1",
-        "@polkadot-api/substrate-bindings": "0.13.0",
-        "@polkadot-api/utils": "0.1.2"
-      },
-      "peerDependencies": {
-        "@polkadot-api/substrate-client": "0.3.0",
-        "rxjs": ">=7.8.0"
-      }
-    },
-    "node_modules/@polkadot-api/pjs-signer": {
-      "version": "0.6.8",
-      "resolved": "https://registry.npmjs.org/@polkadot-api/pjs-signer/-/pjs-signer-0.6.8.tgz",
-      "integrity": "sha512-YBp+uF2mPZFH4VjT5xgIU462EXbdLrFz09D6vY4SgoS2FRbPV7ktnqiNK2BykKJPGV4TiqpEjNB4OtX6ZLzafg==",
-      "license": "MIT",
-      "dependencies": {
-        "@polkadot-api/metadata-builders": "0.12.1",
-        "@polkadot-api/polkadot-signer": "0.1.6",
-        "@polkadot-api/signers-common": "0.1.9",
-        "@polkadot-api/substrate-bindings": "0.13.0",
-        "@polkadot-api/utils": "0.1.2"
-      }
-    },
-    "node_modules/@polkadot-api/polkadot-sdk-compat": {
-      "version": "2.3.2",
-      "resolved": "https://registry.npmjs.org/@polkadot-api/polkadot-sdk-compat/-/polkadot-sdk-compat-2.3.2.tgz",
-      "integrity": "sha512-rLCveP3a6Xd0r218yRqVY34lJ8bXVmE12cArbU4JFp9p8e8Jbb6xdqOdu7bQtjlZUsahhcmfIHYQSXKziST7PA==",
-      "license": "MIT",
-      "dependencies": {
-        "@polkadot-api/json-rpc-provider": "0.0.4"
-      }
-    },
-    "node_modules/@polkadot-api/polkadot-signer": {
-      "version": "0.1.6",
-      "resolved": "https://registry.npmjs.org/@polkadot-api/polkadot-signer/-/polkadot-signer-0.1.6.tgz",
-      "integrity": "sha512-X7ghAa4r7doETtjAPTb50IpfGtrBmy3BJM5WCfNKa1saK04VFY9w+vDn+hwEcM4p0PcDHt66Ts74hzvHq54d9A==",
-      "license": "MIT"
-    },
-    "node_modules/@polkadot-api/signer": {
-      "version": "0.2.1",
-      "resolved": "https://registry.npmjs.org/@polkadot-api/signer/-/signer-0.2.1.tgz",
-      "integrity": "sha512-z3BPDIglLh/hghQExQVVHR3xgIijjEVcIA2P+xLan5vO4cglGm4U6vIBXgKBuU2oxKlG494ixH8BkXSv5F79zw==",
-      "license": "MIT",
-      "dependencies": {
-        "@noble/hashes": "^1.8.0",
-        "@polkadot-api/merkleize-metadata": "1.1.17",
-        "@polkadot-api/polkadot-signer": "0.1.6",
-        "@polkadot-api/signers-common": "0.1.9",
-        "@polkadot-api/substrate-bindings": "0.13.0",
-        "@polkadot-api/utils": "0.1.2"
-      }
-    },
-    "node_modules/@polkadot-api/signer/node_modules/@noble/hashes": {
-      "version": "1.8.0",
-      "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.8.0.tgz",
-      "integrity": "sha512-jCs9ldd7NwzpgXDIf6P3+NrHh9/sD6CQdxHyjQI+h/6rDNo88ypBxxz45UDuZHz9r3tNz7N/VInSVoVdtXEI4A==",
-      "license": "MIT",
-      "engines": {
-        "node": "^14.21.3 || >=16"
-      },
-      "funding": {
-        "url": "https://paulmillr.com/funding/"
-      }
-    },
-    "node_modules/@polkadot-api/signers-common": {
-      "version": "0.1.9",
-      "resolved": "https://registry.npmjs.org/@polkadot-api/signers-common/-/signers-common-0.1.9.tgz",
-      "integrity": "sha512-eOAPfnNpa0kJrtM/OPHOt+jlFP97c4CWZmzfcPzOqfrLUgyyLzVCFzgBipffpzPXNPQsToM6FM+7DQEgQmoDuA==",
-      "license": "MIT",
-      "dependencies": {
-        "@polkadot-api/metadata-builders": "0.12.1",
-        "@polkadot-api/polkadot-signer": "0.1.6",
-        "@polkadot-api/substrate-bindings": "0.13.0",
-        "@polkadot-api/utils": "0.1.2"
-      }
-    },
-    "node_modules/@polkadot-api/sm-provider": {
-      "version": "0.1.7",
-      "resolved": "https://registry.npmjs.org/@polkadot-api/sm-provider/-/sm-provider-0.1.7.tgz",
-      "integrity": "sha512-BhNKVeIFZdawpPVadXszLl8IP4EDjcLHe/GchfRRFkvoNFuwS2nNv/npYIqCviXV+dd2R8VnEELxwScsf380Og==",
-      "license": "MIT",
-      "dependencies": {
-        "@polkadot-api/json-rpc-provider": "0.0.4",
-        "@polkadot-api/json-rpc-provider-proxy": "0.2.4"
-      },
-      "peerDependencies": {
-        "@polkadot-api/smoldot": ">=0.3"
-      }
-    },
-    "node_modules/@polkadot-api/smoldot": {
-      "version": "0.3.8",
-      "resolved": "https://registry.npmjs.org/@polkadot-api/smoldot/-/smoldot-0.3.8.tgz",
-      "integrity": "sha512-dbJSMRFtELDW+rZIWRwKE/K8oy7+gYaGl+DvaOjARoBW2n80rJ7RAMOCCu+b5h2zgl3elftFBwMNAuAWgHT/Zg==",
-      "license": "MIT",
-      "dependencies": {
-        "@types/node": "^22.9.0",
-        "smoldot": "2.0.34"
-      }
-    },
-    "node_modules/@polkadot-api/smoldot/node_modules/smoldot": {
-      "version": "2.0.34",
-      "resolved": "https://registry.npmjs.org/smoldot/-/smoldot-2.0.34.tgz",
-      "integrity": "sha512-mw9tCbGEhEp0koMqLL0jBEixVY1MIN/xI3pE6ZY1TuOPU+LnYy8FloODVyzkvzQPaBYrETXJdRlmA/+k6g3gow==",
-      "license": "GPL-3.0-or-later WITH Classpath-exception-2.0",
-      "dependencies": {
-        "ws": "^8.8.1"
-      }
-    },
-    "node_modules/@polkadot-api/substrate-bindings": {
-      "version": "0.13.0",
-      "resolved": "https://registry.npmjs.org/@polkadot-api/substrate-bindings/-/substrate-bindings-0.13.0.tgz",
-      "integrity": "sha512-M/60lXtHr4flwx4K7L4xv2jLk44EhD8UB4jvah+jbZM195I89nZGXKo2JOkgyR5DHoLj//TAoBkLedZmaaAiaQ==",
-      "license": "MIT",
-      "dependencies": {
-        "@noble/hashes": "^1.8.0",
-        "@polkadot-api/utils": "0.1.2",
-        "@scure/base": "^1.2.5",
-        "scale-ts": "^1.6.1"
-      }
-    },
-    "node_modules/@polkadot-api/substrate-bindings/node_modules/@noble/hashes": {
-      "version": "1.8.0",
-      "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.8.0.tgz",
-      "integrity": "sha512-jCs9ldd7NwzpgXDIf6P3+NrHh9/sD6CQdxHyjQI+h/6rDNo88ypBxxz45UDuZHz9r3tNz7N/VInSVoVdtXEI4A==",
-      "license": "MIT",
-      "engines": {
-        "node": "^14.21.3 || >=16"
-      },
-      "funding": {
-        "url": "https://paulmillr.com/funding/"
-      }
-    },
-    "node_modules/@polkadot-api/substrate-client": {
-      "version": "0.3.0",
-      "resolved": "https://registry.npmjs.org/@polkadot-api/substrate-client/-/substrate-client-0.3.0.tgz",
-      "integrity": "sha512-0hEvQLKH2zhaFzE8DPkWehvJilec8u2O2wbIEUStm0OJ8jIFtJ40MFjXQfB01dXBWUz1KaVBqS6xd3sZA90Dpw==",
-      "license": "MIT",
-      "dependencies": {
-        "@polkadot-api/json-rpc-provider": "0.0.4",
-        "@polkadot-api/utils": "0.1.2"
-      }
-    },
-    "node_modules/@polkadot-api/utils": {
-      "version": "0.1.2",
-      "resolved": "https://registry.npmjs.org/@polkadot-api/utils/-/utils-0.1.2.tgz",
-      "integrity": "sha512-yhs5k2a8N1SBJcz7EthZoazzLQUkZxbf+0271Xzu42C5AEM9K9uFLbsB+ojzHEM72O5X8lPtSwGKNmS7WQyDyg==",
-      "license": "MIT"
-    },
-    "node_modules/@polkadot-api/wasm-executor": {
-      "version": "0.1.2",
-      "resolved": "https://registry.npmjs.org/@polkadot-api/wasm-executor/-/wasm-executor-0.1.2.tgz",
-      "integrity": "sha512-a5wGenltB3EFPdf72u8ewi6HsUg2qubUAf3ekJprZf24lTK3+w8a/GUF/y6r08LJF35MALZ32SAtLqtVTIOGnQ==",
-      "license": "MIT"
-    },
-    "node_modules/@polkadot-api/ws-provider": {
-      "version": "0.4.0",
-      "resolved": "https://registry.npmjs.org/@polkadot-api/ws-provider/-/ws-provider-0.4.0.tgz",
-      "integrity": "sha512-ZurjUHHAlQ1Ux8HiZz7mtkg1qjq6LmqxcHljcZxne0U7foCZrXdWHsohwlV8kUQUir5kXuDsNvdZN/MFCUMaVw==",
-      "license": "MIT",
-      "dependencies": {
-        "@polkadot-api/json-rpc-provider": "0.0.4",
-        "@polkadot-api/json-rpc-provider-proxy": "0.2.4",
-        "ws": "^8.18.1"
-      }
-    },
-    "node_modules/@polkadot-labs/hdkd": {
-      "version": "0.0.10",
-      "resolved": "https://registry.npmjs.org/@polkadot-labs/hdkd/-/hdkd-0.0.10.tgz",
-      "integrity": "sha512-jD8l+Ls/kZjvZja4T2Y0G6Be3rfGn0qNs3hvcNeV2CmOMtI7yRkkWPXI7WiJ8AyEoBwBuZt0rm6yzGla6o2HXQ==",
-      "license": "MIT",
-      "dependencies": {
-        "@polkadot-labs/hdkd-helpers": "0.0.10"
-      }
-    },
-    "node_modules/@polkadot-labs/hdkd-helpers": {
-      "version": "0.0.11",
-      "resolved": "https://registry.npmjs.org/@polkadot-labs/hdkd-helpers/-/hdkd-helpers-0.0.11.tgz",
-      "integrity": "sha512-qPlWqC3NNV/2NYc5GEy+Ovi4UBAgkMGvMfyiYuj2BQN4lW59Q1T9coNx0Yp6XzsnJ1ddaF9PWaUtxj3LdM0IDw==",
-      "license": "MIT",
-      "dependencies": {
-        "@noble/curves": "^1.8.1",
-        "@noble/hashes": "^1.7.1",
-        "@scure/base": "^1.2.4",
-        "micro-sr25519": "^0.1.0",
-        "scale-ts": "^1.6.1"
-      }
-    },
-    "node_modules/@polkadot-labs/hdkd/node_modules/@polkadot-labs/hdkd-helpers": {
-      "version": "0.0.10",
-      "resolved": "https://registry.npmjs.org/@polkadot-labs/hdkd-helpers/-/hdkd-helpers-0.0.10.tgz",
-      "integrity": "sha512-wBKenhN7TjNiMXxBvQWzFf+su8xTaRGqyOKAlAfpyY9oWTOt3G05yMvDHEZ4g/NRLoE4P3fQYQ0bdcMKl7KkDw==",
-      "license": "MIT",
-      "dependencies": {
-        "@noble/curves": "^1.7.0",
-        "@noble/hashes": "^1.6.1",
-        "@scure/base": "^1.2.1",
-        "micro-sr25519": "^0.1.0",
-        "scale-ts": "^1.6.1"
-      }
-    },
-    "node_modules/@polkadot/api": {
-      "version": "15.1.1",
-      "resolved": "https://registry.npmjs.org/@polkadot/api/-/api-15.1.1.tgz",
-      "integrity": "sha512-n3QeQ1CXlzjqyh2eFbEQPcnkXO3J4QYNTIj0Lnz/XFUpzKimHPDA2iUfaXuy5dXjnzS21jFANGSUFoZ+XKi/8g==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@polkadot/api-augment": "15.1.1",
-        "@polkadot/api-base": "15.1.1",
-        "@polkadot/api-derive": "15.1.1",
-        "@polkadot/keyring": "^13.2.3",
-        "@polkadot/rpc-augment": "15.1.1",
-        "@polkadot/rpc-core": "15.1.1",
-        "@polkadot/rpc-provider": "15.1.1",
-        "@polkadot/types": "15.1.1",
-        "@polkadot/types-augment": "15.1.1",
-        "@polkadot/types-codec": "15.1.1",
-        "@polkadot/types-create": "15.1.1",
-        "@polkadot/types-known": "15.1.1",
-        "@polkadot/util": "^13.2.3",
-        "@polkadot/util-crypto": "^13.2.3",
-        "eventemitter3": "^5.0.1",
-        "rxjs": "^7.8.1",
-        "tslib": "^2.8.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@polkadot/api-augment": {
-      "version": "15.1.1",
-      "resolved": "https://registry.npmjs.org/@polkadot/api-augment/-/api-augment-15.1.1.tgz",
-      "integrity": "sha512-tYASON7vVLz7FGcXVX9dWSd/9pR6FckayEkc08Z6RyjH7HfjtCZ3/Dz7MlGRNql4SnPi4+xpjSD6rwrZcETU1g==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@polkadot/api-base": "15.1.1",
-        "@polkadot/rpc-augment": "15.1.1",
-        "@polkadot/types": "15.1.1",
-        "@polkadot/types-augment": "15.1.1",
-        "@polkadot/types-codec": "15.1.1",
-        "@polkadot/util": "^13.2.3",
-        "tslib": "^2.8.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@polkadot/api-base": {
-      "version": "15.1.1",
-      "resolved": "https://registry.npmjs.org/@polkadot/api-base/-/api-base-15.1.1.tgz",
-      "integrity": "sha512-OXLZ7/k2RXLIA8hKA8oyii6o8MuGlqujIDcLVaMdtWnQsBg26h8pv/mujT2YSz2OguLxrfdvD+lUGtwZC8kw4A==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@polkadot/rpc-core": "15.1.1",
-        "@polkadot/types": "15.1.1",
-        "@polkadot/util": "^13.2.3",
-        "rxjs": "^7.8.1",
-        "tslib": "^2.8.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@polkadot/api-derive": {
-      "version": "15.1.1",
-      "resolved": "https://registry.npmjs.org/@polkadot/api-derive/-/api-derive-15.1.1.tgz",
-      "integrity": "sha512-UPcKr9FplfYKPaP7FYEF917Sm1rKnQFX4AzQJn3f8ySp7DDf6EYiHrNICtGifPEAoANTSW+YHlSchhtnvfSIhw==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@polkadot/api": "15.1.1",
-        "@polkadot/api-augment": "15.1.1",
-        "@polkadot/api-base": "15.1.1",
-        "@polkadot/rpc-core": "15.1.1",
-        "@polkadot/types": "15.1.1",
-        "@polkadot/types-codec": "15.1.1",
-        "@polkadot/util": "^13.2.3",
-        "@polkadot/util-crypto": "^13.2.3",
-        "rxjs": "^7.8.1",
-        "tslib": "^2.8.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@polkadot/keyring": {
-      "version": "13.4.3",
-      "resolved": "https://registry.npmjs.org/@polkadot/keyring/-/keyring-13.4.3.tgz",
-      "integrity": "sha512-2ePNcvBTznDN2luKbZM5fdxgAnj7V8m276qSTgrHlqKVvg9FsQpRCR6CAU+AjhnHzpe7uiZO+UH+jlXWefI3AA==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@polkadot/util": "13.4.3",
-        "@polkadot/util-crypto": "13.4.3",
-        "tslib": "^2.8.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "@polkadot/util": "13.4.3",
-        "@polkadot/util-crypto": "13.4.3"
-      }
-    },
-    "node_modules/@polkadot/networks": {
-      "version": "13.4.3",
-      "resolved": "https://registry.npmjs.org/@polkadot/networks/-/networks-13.4.3.tgz",
-      "integrity": "sha512-Z+YZkltBt//CtkVH8ZYJ1z66qYxdI0yPamzkzZAqw6gj3gjgSxKtxB4baA/rcAw05QTvN2R3dLkkmKr2mnHovQ==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@polkadot/util": "13.4.3",
-        "@substrate/ss58-registry": "^1.51.0",
-        "tslib": "^2.8.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@polkadot/rpc-augment": {
-      "version": "15.1.1",
-      "resolved": "https://registry.npmjs.org/@polkadot/rpc-augment/-/rpc-augment-15.1.1.tgz",
-      "integrity": "sha512-s6i4nTy7/1Q5svIMT4TR55GLRv9asG7xbJcntHEsQ2nDs8zZV/mvPWfEUxgup0xVO8sDgyrf6KTTVRKJjySjUg==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@polkadot/rpc-core": "15.1.1",
-        "@polkadot/types": "15.1.1",
-        "@polkadot/types-codec": "15.1.1",
-        "@polkadot/util": "^13.2.3",
-        "tslib": "^2.8.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@polkadot/rpc-core": {
-      "version": "15.1.1",
-      "resolved": "https://registry.npmjs.org/@polkadot/rpc-core/-/rpc-core-15.1.1.tgz",
-      "integrity": "sha512-KErbVgPChps7NsxcGch5JCArZHNqs81fDEzs+XoHnD05nzuxcO38v4Yu+M04lHLax2m8ky8K6o3gurBglJENlA==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@polkadot/rpc-augment": "15.1.1",
-        "@polkadot/rpc-provider": "15.1.1",
-        "@polkadot/types": "15.1.1",
-        "@polkadot/util": "^13.2.3",
-        "rxjs": "^7.8.1",
-        "tslib": "^2.8.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@polkadot/rpc-provider": {
-      "version": "15.1.1",
-      "resolved": "https://registry.npmjs.org/@polkadot/rpc-provider/-/rpc-provider-15.1.1.tgz",
-      "integrity": "sha512-9OWV1dyX+vmAbKkhMU8J7Q0sCaovPrkwZqo2ejmEpZ/Lr12Hw5JAk4gdvB869QEVP7zj0gH3HuYVajmsxesYKg==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@polkadot/keyring": "^13.2.3",
-        "@polkadot/types": "15.1.1",
-        "@polkadot/types-support": "15.1.1",
-        "@polkadot/util": "^13.2.3",
-        "@polkadot/util-crypto": "^13.2.3",
-        "@polkadot/x-fetch": "^13.2.3",
-        "@polkadot/x-global": "^13.2.3",
-        "@polkadot/x-ws": "^13.2.3",
-        "eventemitter3": "^5.0.1",
-        "mock-socket": "^9.3.1",
-        "nock": "^13.5.5",
-        "tslib": "^2.8.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "optionalDependencies": {
-        "@substrate/connect": "0.8.11"
-      }
-    },
-    "node_modules/@polkadot/types": {
-      "version": "15.1.1",
-      "resolved": "https://registry.npmjs.org/@polkadot/types/-/types-15.1.1.tgz",
-      "integrity": "sha512-n6lg/quhLp3Zmt/6gHAg2uoSmMmXk3NR19I7qCyeDJ30pP1UhOjtmuWOQDl6SwSEwuHtudLp3p2nCJsymXjgsw==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@polkadot/keyring": "^13.2.3",
-        "@polkadot/types-augment": "15.1.1",
-        "@polkadot/types-codec": "15.1.1",
-        "@polkadot/types-create": "15.1.1",
-        "@polkadot/util": "^13.2.3",
-        "@polkadot/util-crypto": "^13.2.3",
-        "rxjs": "^7.8.1",
-        "tslib": "^2.8.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@polkadot/types-augment": {
-      "version": "15.1.1",
-      "resolved": "https://registry.npmjs.org/@polkadot/types-augment/-/types-augment-15.1.1.tgz",
-      "integrity": "sha512-6v/FsN/JYCupyGYW+MbS0iOCiWvf6PXJ5+m8ORYYYDPFgQqaQPxKMKWJpnO0s9cCR33QcyNYhErPGuZ62UMJjw==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@polkadot/types": "15.1.1",
-        "@polkadot/types-codec": "15.1.1",
-        "@polkadot/util": "^13.2.3",
-        "tslib": "^2.8.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@polkadot/types-codec": {
-      "version": "15.1.1",
-      "resolved": "https://registry.npmjs.org/@polkadot/types-codec/-/types-codec-15.1.1.tgz",
-      "integrity": "sha512-cm99CFvDf4UXmw7DeMkRqa/hf7wEgjJZoZZW/B12Js0ObwRmSXMk/gDbyiT6hqPnQ81sU726E72p39DolaEatQ==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@polkadot/util": "^13.2.3",
-        "@polkadot/x-bigint": "^13.2.3",
-        "tslib": "^2.8.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@polkadot/types-create": {
-      "version": "15.1.1",
-      "resolved": "https://registry.npmjs.org/@polkadot/types-create/-/types-create-15.1.1.tgz",
-      "integrity": "sha512-AOgz+UsUqsGSENrc+p/dHyXH2TC9qVtUTAxlqaHfOnwqjMWfEqc78mc5a1mk0a+RqxmIHw8nQNSdBdhv+UdtyQ==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@polkadot/types-codec": "15.1.1",
-        "@polkadot/util": "^13.2.3",
-        "tslib": "^2.8.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@polkadot/types-known": {
-      "version": "15.1.1",
-      "resolved": "https://registry.npmjs.org/@polkadot/types-known/-/types-known-15.1.1.tgz",
-      "integrity": "sha512-L934pYxXdHB3GHlVu57ihO6llhxuggSuQZuJ9kHunG0I6tezXLIgAhwaPgACMVbmBYlkJPqm4Nr6pC3kpIsGow==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@polkadot/networks": "^13.2.3",
-        "@polkadot/types": "15.1.1",
-        "@polkadot/types-codec": "15.1.1",
-        "@polkadot/types-create": "15.1.1",
-        "@polkadot/util": "^13.2.3",
-        "tslib": "^2.8.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@polkadot/types-support": {
-      "version": "15.1.1",
-      "resolved": "https://registry.npmjs.org/@polkadot/types-support/-/types-support-15.1.1.tgz",
-      "integrity": "sha512-uyn5N7XERHosVq0+aCpEwYnkUroOr7OX8B8/00UkgmfVOXskp/cukEVcGlmI/YGAS+9+V2BZN2GBX7Lz0eeKmw==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@polkadot/util": "^13.2.3",
-        "tslib": "^2.8.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@polkadot/util": {
-      "version": "13.4.3",
-      "resolved": "https://registry.npmjs.org/@polkadot/util/-/util-13.4.3.tgz",
-      "integrity": "sha512-6v2zvg8l7W22XvjYf7qv9tPQdYl2E6aXY94M4TZKsXZxmlS5BoG+A9Aq0+Gw8zBUjupjEmUkA6Y//msO8Zisug==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@polkadot/x-bigint": "13.4.3",
-        "@polkadot/x-global": "13.4.3",
-        "@polkadot/x-textdecoder": "13.4.3",
-        "@polkadot/x-textencoder": "13.4.3",
-        "@types/bn.js": "^5.1.6",
-        "bn.js": "^5.2.1",
-        "tslib": "^2.8.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@polkadot/util-crypto": {
-      "version": "13.4.3",
-      "resolved": "https://registry.npmjs.org/@polkadot/util-crypto/-/util-crypto-13.4.3.tgz",
-      "integrity": "sha512-Ml0mjhKVetMrRCIosmVNMa6lbFPa3fSAeOggf34NsDIIQOKt9FL644iGz1ZSMOnBwN9qk2qHYmcFMTDXX2yKVQ==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@noble/curves": "^1.3.0",
-        "@noble/hashes": "^1.3.3",
-        "@polkadot/networks": "13.4.3",
-        "@polkadot/util": "13.4.3",
-        "@polkadot/wasm-crypto": "^7.4.1",
-        "@polkadot/wasm-util": "^7.4.1",
-        "@polkadot/x-bigint": "13.4.3",
-        "@polkadot/x-randomvalues": "13.4.3",
-        "@scure/base": "^1.1.7",
-        "tslib": "^2.8.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "@polkadot/util": "13.4.3"
-      }
-    },
-    "node_modules/@polkadot/wasm-bridge": {
-      "version": "7.4.1",
-      "resolved": "https://registry.npmjs.org/@polkadot/wasm-bridge/-/wasm-bridge-7.4.1.tgz",
-      "integrity": "sha512-tdkJaV453tezBxhF39r4oeG0A39sPKGDJmN81LYLf+Fihb7astzwju+u75BRmDrHZjZIv00un3razJEWCxze6g==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@polkadot/wasm-util": "7.4.1",
-        "tslib": "^2.7.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "@polkadot/util": "*",
-        "@polkadot/x-randomvalues": "*"
-      }
-    },
-    "node_modules/@polkadot/wasm-crypto": {
-      "version": "7.4.1",
-      "resolved": "https://registry.npmjs.org/@polkadot/wasm-crypto/-/wasm-crypto-7.4.1.tgz",
-      "integrity": "sha512-kHN/kF7hYxm1y0WeFLWeWir6oTzvcFmR4N8fJJokR+ajYbdmrafPN+6iLgQVbhZnDdxyv9jWDuRRsDnBx8tPMQ==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@polkadot/wasm-bridge": "7.4.1",
-        "@polkadot/wasm-crypto-asmjs": "7.4.1",
-        "@polkadot/wasm-crypto-init": "7.4.1",
-        "@polkadot/wasm-crypto-wasm": "7.4.1",
-        "@polkadot/wasm-util": "7.4.1",
-        "tslib": "^2.7.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "@polkadot/util": "*",
-        "@polkadot/x-randomvalues": "*"
-      }
-    },
-    "node_modules/@polkadot/wasm-crypto-asmjs": {
-      "version": "7.4.1",
-      "resolved": "https://registry.npmjs.org/@polkadot/wasm-crypto-asmjs/-/wasm-crypto-asmjs-7.4.1.tgz",
-      "integrity": "sha512-pwU8QXhUW7IberyHJIQr37IhbB6DPkCG5FhozCiNTq4vFBsFPjm9q8aZh7oX1QHQaiAZa2m2/VjIVE+FHGbvHQ==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "tslib": "^2.7.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "@polkadot/util": "*"
-      }
-    },
-    "node_modules/@polkadot/wasm-crypto-init": {
-      "version": "7.4.1",
-      "resolved": "https://registry.npmjs.org/@polkadot/wasm-crypto-init/-/wasm-crypto-init-7.4.1.tgz",
-      "integrity": "sha512-AVka33+f7MvXEEIGq5U0dhaA2SaXMXnxVCQyhJTaCnJ5bRDj0Xlm3ijwDEQUiaDql7EikbkkRtmlvs95eSUWYQ==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@polkadot/wasm-bridge": "7.4.1",
-        "@polkadot/wasm-crypto-asmjs": "7.4.1",
-        "@polkadot/wasm-crypto-wasm": "7.4.1",
-        "@polkadot/wasm-util": "7.4.1",
-        "tslib": "^2.7.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "@polkadot/util": "*",
-        "@polkadot/x-randomvalues": "*"
-      }
-    },
-    "node_modules/@polkadot/wasm-crypto-wasm": {
-      "version": "7.4.1",
-      "resolved": "https://registry.npmjs.org/@polkadot/wasm-crypto-wasm/-/wasm-crypto-wasm-7.4.1.tgz",
-      "integrity": "sha512-PE1OAoupFR0ZOV2O8tr7D1FEUAwaggzxtfs3Aa5gr+yxlSOaWUKeqsOYe1KdrcjmZVV3iINEAXxgrbzCmiuONg==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@polkadot/wasm-util": "7.4.1",
-        "tslib": "^2.7.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "@polkadot/util": "*"
-      }
-    },
-    "node_modules/@polkadot/wasm-util": {
-      "version": "7.4.1",
-      "resolved": "https://registry.npmjs.org/@polkadot/wasm-util/-/wasm-util-7.4.1.tgz",
-      "integrity": "sha512-RAcxNFf3zzpkr+LX/ItAsvj+QyM56TomJ0xjUMo4wKkHjwsxkz4dWJtx5knIgQz/OthqSDMR59VNEycQeNuXzA==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "tslib": "^2.7.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "@polkadot/util": "*"
-      }
-    },
-    "node_modules/@polkadot/x-bigint": {
-      "version": "13.4.3",
-      "resolved": "https://registry.npmjs.org/@polkadot/x-bigint/-/x-bigint-13.4.3.tgz",
-      "integrity": "sha512-8NbjF5Q+5lflhvDFve58wULjCVcvXa932LKFtI5zL2gx5VDhMgyfkNcYRjHB18Ecl21963JuGzvGVTZNkh/i6g==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@polkadot/x-global": "13.4.3",
-        "tslib": "^2.8.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@polkadot/x-fetch": {
-      "version": "13.4.3",
-      "resolved": "https://registry.npmjs.org/@polkadot/x-fetch/-/x-fetch-13.4.3.tgz",
-      "integrity": "sha512-EwhcwROqWa7mvNTbLVNH71Hbyp5PW5j9lV2UpII5MZzRO95eYwV4oP/xgtTxC+60nC8lrvzAw0JxEHrmNzmtlg==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@polkadot/x-global": "13.4.3",
-        "node-fetch": "^3.3.2",
-        "tslib": "^2.8.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@polkadot/x-global": {
-      "version": "13.4.3",
-      "resolved": "https://registry.npmjs.org/@polkadot/x-global/-/x-global-13.4.3.tgz",
-      "integrity": "sha512-6c98kxZdoGRct3ua9Dz6/qz8wb3XFRUkaY+4+RzIgehKMPhu19pGWTrzmbJSyY9FtIpThuWKuDaBEvd5KgSxjA==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "tslib": "^2.8.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@polkadot/x-randomvalues": {
-      "version": "13.4.3",
-      "resolved": "https://registry.npmjs.org/@polkadot/x-randomvalues/-/x-randomvalues-13.4.3.tgz",
-      "integrity": "sha512-pskXP/S2jROZ6aASExsUFlNp7GbJvQikKogvyvMMCzNIbUYLxpLuquLRa3MOORx2c0SNsENg90cx/zHT+IjPRQ==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@polkadot/x-global": "13.4.3",
-        "tslib": "^2.8.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "@polkadot/util": "13.4.3",
-        "@polkadot/wasm-util": "*"
-      }
-    },
-    "node_modules/@polkadot/x-textdecoder": {
-      "version": "13.4.3",
-      "resolved": "https://registry.npmjs.org/@polkadot/x-textdecoder/-/x-textdecoder-13.4.3.tgz",
-      "integrity": "sha512-k7Wg6csAPxfNtpBt3k5yUuPHYmRl/nl7H2OMr40upMjbZXbQ1RJW9Z3GBkLmQczG7NwwfAXHwQE9FYOMUtbuRQ==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@polkadot/x-global": "13.4.3",
-        "tslib": "^2.8.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@polkadot/x-textencoder": {
-      "version": "13.4.3",
-      "resolved": "https://registry.npmjs.org/@polkadot/x-textencoder/-/x-textencoder-13.4.3.tgz",
-      "integrity": "sha512-byl2LbN1rnEXKmnsCzEDaIjSIHAr+1ciSe2yj3M0K+oWEEcaFZEovJaf/uoyzkcjn+/l8rDv3nget6mPuQ/DSw==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@polkadot/x-global": "13.4.3",
-        "tslib": "^2.8.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@polkadot/x-ws": {
-      "version": "13.4.3",
-      "resolved": "https://registry.npmjs.org/@polkadot/x-ws/-/x-ws-13.4.3.tgz",
-      "integrity": "sha512-GS0I6MYLD/xNAAjODZi/pbG7Ba0e/5sbvDIrT01iKH3SPGN+PZoyAsc04t2IOXA6QmPa1OBHnaU3N4K8gGmJ+w==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@polkadot/x-global": "13.4.3",
-        "tslib": "^2.8.0",
-        "ws": "^8.18.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@rollup/rollup-linux-x64-gnu": {
-      "version": "4.34.8",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.34.8.tgz",
-      "integrity": "sha512-8y7ED8gjxITUltTUEJLQdgpbPh1sUQ0kMTmufRF/Ns5tI9TNMNlhWtmPKKHCU0SilX+3MJkZ0zERYYGIVBYHIA==",
-      "cpu": [
-        "x64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-x64-musl": {
-      "version": "4.34.8",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.34.8.tgz",
-      "integrity": "sha512-SCXcP0ZpGFIe7Ge+McxY5zKxiEI5ra+GT3QRxL0pMMtxPfpyLAKleZODi1zdRHkz5/BhueUrYtYVgubqe9JBNQ==",
-      "cpu": [
-        "x64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rx-state/core": {
-      "version": "0.1.4",
-      "resolved": "https://registry.npmjs.org/@rx-state/core/-/core-0.1.4.tgz",
-      "integrity": "sha512-Z+3hjU2xh1HisLxt+W5hlYX/eGSDaXXP+ns82gq/PLZpkXLu0uwcNUh9RLY3Clq4zT+hSsA3vcpIGt6+UAb8rQ==",
-      "license": "MIT",
-      "peerDependencies": {
-        "rxjs": ">=7"
-      }
-    },
-    "node_modules/@scure/base": {
-      "version": "1.2.5",
-      "resolved": "https://registry.npmjs.org/@scure/base/-/base-1.2.5.tgz",
-      "integrity": "sha512-9rE6EOVeIQzt5TSu4v+K523F8u6DhBsoZWPGKlnCshhlDhy0kJzUX4V+tr2dWmzF1GdekvThABoEQBGBQI7xZw==",
-      "license": "MIT",
-      "funding": {
-        "url": "https://paulmillr.com/funding/"
-      }
-    },
-    "node_modules/@scure/bip32": {
-      "version": "1.6.2",
-      "resolved": "https://registry.npmjs.org/@scure/bip32/-/bip32-1.6.2.tgz",
-      "integrity": "sha512-t96EPDMbtGgtb7onKKqxRLfE5g05k7uHnHRM2xdE6BP/ZmxaLtPek4J4KfVn/90IQNrU1IOAqMgiDtUdtbe3nw==",
-      "license": "MIT",
-      "dependencies": {
-        "@noble/curves": "~1.8.1",
-        "@noble/hashes": "~1.7.1",
-        "@scure/base": "~1.2.2"
-      },
-      "funding": {
-        "url": "https://paulmillr.com/funding/"
-      }
-    },
-    "node_modules/@scure/bip39": {
-      "version": "1.5.4",
-      "resolved": "https://registry.npmjs.org/@scure/bip39/-/bip39-1.5.4.tgz",
-      "integrity": "sha512-TFM4ni0vKvCfBpohoh+/lY05i9gRbSwXWngAsF4CABQxoaOHijxuaZ2R6cStDQ5CHtHO9aGJTr4ksVJASRRyMA==",
-      "license": "MIT",
-      "dependencies": {
-        "@noble/hashes": "~1.7.1",
-        "@scure/base": "~1.2.4"
-      },
-      "funding": {
-        "url": "https://paulmillr.com/funding/"
-      }
-    },
-    "node_modules/@sec-ant/readable-stream": {
-      "version": "0.4.1",
-      "resolved": "https://registry.npmjs.org/@sec-ant/readable-stream/-/readable-stream-0.4.1.tgz",
-      "integrity": "sha512-831qok9r2t8AlxLko40y2ebgSDhenenCatLVeW/uBtnHPyhHOvG0C7TvfgecV+wHzIm5KUICgzmVpWS+IMEAeg==",
-      "license": "MIT"
-    },
-    "node_modules/@sindresorhus/merge-streams": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/@sindresorhus/merge-streams/-/merge-streams-4.0.0.tgz",
-      "integrity": "sha512-tlqY9xq5ukxTUZBmoOp+m61cqwQD5pHJtFY3Mn8CA8ps6yghLH/Hw8UPdqg4OLmFW3IFlcXnQNmo/dh8HzXYIQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/@substrate/connect": {
-      "version": "0.8.11",
-      "resolved": "https://registry.npmjs.org/@substrate/connect/-/connect-0.8.11.tgz",
-      "integrity": "sha512-ofLs1PAO9AtDdPbdyTYj217Pe+lBfTLltdHDs3ds8no0BseoLeAGxpz1mHfi7zB4IxI3YyAiLjH6U8cw4pj4Nw==",
-      "license": "GPL-3.0-only",
-      "optional": true,
-      "dependencies": {
-        "@substrate/connect-extension-protocol": "^2.0.0",
-        "@substrate/connect-known-chains": "^1.1.5",
-        "@substrate/light-client-extension-helpers": "^1.0.0",
-        "smoldot": "2.0.26"
-      }
-    },
-    "node_modules/@substrate/connect-extension-protocol": {
-      "version": "2.2.2",
-      "resolved": "https://registry.npmjs.org/@substrate/connect-extension-protocol/-/connect-extension-protocol-2.2.2.tgz",
-      "integrity": "sha512-t66jwrXA0s5Goq82ZtjagLNd7DPGCNjHeehRlE/gcJmJ+G56C0W+2plqOMRicJ8XGR1/YFnUSEqUFiSNbjGrAA==",
-      "license": "GPL-3.0-only",
-      "optional": true
-    },
-    "node_modules/@substrate/connect-known-chains": {
-      "version": "1.9.2",
-      "resolved": "https://registry.npmjs.org/@substrate/connect-known-chains/-/connect-known-chains-1.9.2.tgz",
-      "integrity": "sha512-uEmm+rKJQQhhbforvmcg74TsDHKFVBkstjPwblGT1RdHMxUKR7Gq7F8vbkGnr5ce9tMK2Ylil760Z7vtX013hw==",
-      "license": "GPL-3.0-only",
-      "optional": true
-    },
-    "node_modules/@substrate/light-client-extension-helpers": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/@substrate/light-client-extension-helpers/-/light-client-extension-helpers-1.0.0.tgz",
-      "integrity": "sha512-TdKlni1mBBZptOaeVrKnusMg/UBpWUORNDv5fdCaJklP4RJiFOzBCrzC+CyVI5kQzsXBisZ+2pXm+rIjS38kHg==",
-      "license": "MIT",
-      "optional": true,
-      "dependencies": {
-        "@polkadot-api/json-rpc-provider": "^0.0.1",
-        "@polkadot-api/json-rpc-provider-proxy": "^0.1.0",
-        "@polkadot-api/observable-client": "^0.3.0",
-        "@polkadot-api/substrate-client": "^0.1.2",
-        "@substrate/connect-extension-protocol": "^2.0.0",
-        "@substrate/connect-known-chains": "^1.1.5",
-        "rxjs": "^7.8.1"
-      },
-      "peerDependencies": {
-        "smoldot": "2.x"
-      }
-    },
-    "node_modules/@substrate/light-client-extension-helpers/node_modules/@polkadot-api/json-rpc-provider": {
-      "version": "0.0.1",
-      "resolved": "https://registry.npmjs.org/@polkadot-api/json-rpc-provider/-/json-rpc-provider-0.0.1.tgz",
-      "integrity": "sha512-/SMC/l7foRjpykLTUTacIH05H3mr9ip8b5xxfwXlVezXrNVLp3Cv0GX6uItkKd+ZjzVPf3PFrDF2B2/HLSNESA==",
-      "license": "MIT",
-      "optional": true
-    },
-    "node_modules/@substrate/light-client-extension-helpers/node_modules/@polkadot-api/json-rpc-provider-proxy": {
-      "version": "0.1.0",
-      "resolved": "https://registry.npmjs.org/@polkadot-api/json-rpc-provider-proxy/-/json-rpc-provider-proxy-0.1.0.tgz",
-      "integrity": "sha512-8GSFE5+EF73MCuLQm8tjrbCqlgclcHBSRaswvXziJ0ZW7iw3UEMsKkkKvELayWyBuOPa2T5i1nj6gFOeIsqvrg==",
-      "license": "MIT",
-      "optional": true
-    },
-    "node_modules/@substrate/light-client-extension-helpers/node_modules/@polkadot-api/metadata-builders": {
-      "version": "0.3.2",
-      "resolved": "https://registry.npmjs.org/@polkadot-api/metadata-builders/-/metadata-builders-0.3.2.tgz",
-      "integrity": "sha512-TKpfoT6vTb+513KDzMBTfCb/ORdgRnsS3TDFpOhAhZ08ikvK+hjHMt5plPiAX/OWkm1Wc9I3+K6W0hX5Ab7MVg==",
-      "license": "MIT",
-      "optional": true,
-      "dependencies": {
-        "@polkadot-api/substrate-bindings": "0.6.0",
-        "@polkadot-api/utils": "0.1.0"
-      }
-    },
-    "node_modules/@substrate/light-client-extension-helpers/node_modules/@polkadot-api/observable-client": {
-      "version": "0.3.2",
-      "resolved": "https://registry.npmjs.org/@polkadot-api/observable-client/-/observable-client-0.3.2.tgz",
-      "integrity": "sha512-HGgqWgEutVyOBXoGOPp4+IAq6CNdK/3MfQJmhCJb8YaJiaK4W6aRGrdQuQSTPHfERHCARt9BrOmEvTXAT257Ug==",
-      "license": "MIT",
-      "optional": true,
-      "dependencies": {
-        "@polkadot-api/metadata-builders": "0.3.2",
-        "@polkadot-api/substrate-bindings": "0.6.0",
-        "@polkadot-api/utils": "0.1.0"
-      },
-      "peerDependencies": {
-        "@polkadot-api/substrate-client": "0.1.4",
-        "rxjs": ">=7.8.0"
-      }
-    },
-    "node_modules/@substrate/light-client-extension-helpers/node_modules/@polkadot-api/substrate-bindings": {
-      "version": "0.6.0",
-      "resolved": "https://registry.npmjs.org/@polkadot-api/substrate-bindings/-/substrate-bindings-0.6.0.tgz",
-      "integrity": "sha512-lGuhE74NA1/PqdN7fKFdE5C1gNYX357j1tWzdlPXI0kQ7h3kN0zfxNOpPUN7dIrPcOFZ6C0tRRVrBylXkI6xPw==",
-      "license": "MIT",
-      "optional": true,
-      "dependencies": {
-        "@noble/hashes": "^1.3.1",
-        "@polkadot-api/utils": "0.1.0",
-        "@scure/base": "^1.1.1",
-        "scale-ts": "^1.6.0"
-      }
-    },
-    "node_modules/@substrate/light-client-extension-helpers/node_modules/@polkadot-api/substrate-client": {
-      "version": "0.1.4",
-      "resolved": "https://registry.npmjs.org/@polkadot-api/substrate-client/-/substrate-client-0.1.4.tgz",
-      "integrity": "sha512-MljrPobN0ZWTpn++da9vOvt+Ex+NlqTlr/XT7zi9sqPtDJiQcYl+d29hFAgpaeTqbeQKZwz3WDE9xcEfLE8c5A==",
-      "license": "MIT",
-      "optional": true,
-      "dependencies": {
-        "@polkadot-api/json-rpc-provider": "0.0.1",
-        "@polkadot-api/utils": "0.1.0"
-      }
-    },
-    "node_modules/@substrate/light-client-extension-helpers/node_modules/@polkadot-api/utils": {
-      "version": "0.1.0",
-      "resolved": "https://registry.npmjs.org/@polkadot-api/utils/-/utils-0.1.0.tgz",
-      "integrity": "sha512-MXzWZeuGxKizPx2Xf/47wx9sr/uxKw39bVJUptTJdsaQn/TGq+z310mHzf1RCGvC1diHM8f593KrnDgc9oNbJA==",
-      "license": "MIT",
-      "optional": true
-    },
-    "node_modules/@substrate/ss58-registry": {
-      "version": "1.51.0",
-      "resolved": "https://registry.npmjs.org/@substrate/ss58-registry/-/ss58-registry-1.51.0.tgz",
-      "integrity": "sha512-TWDurLiPxndFgKjVavCniytBIw+t4ViOi7TYp9h/D0NMmkEc9klFTo+827eyEJ0lELpqO207Ey7uGxUa+BS1jQ==",
-      "license": "Apache-2.0"
-    },
-    "node_modules/@tsconfig/node10": {
-      "version": "1.0.11",
-      "resolved": "https://registry.npmjs.org/@tsconfig/node10/-/node10-1.0.11.tgz",
-      "integrity": "sha512-DcRjDCujK/kCk/cUe8Xz8ZSpm8mS3mNNpta+jGCA6USEDfktlNvm1+IuZ9eTcDbNk41BHwpHHeW+N1lKCz4zOw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@tsconfig/node12": {
-      "version": "1.0.11",
-      "resolved": "https://registry.npmjs.org/@tsconfig/node12/-/node12-1.0.11.tgz",
-      "integrity": "sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@tsconfig/node14": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/@tsconfig/node14/-/node14-1.0.3.tgz",
-      "integrity": "sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@tsconfig/node16": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/@tsconfig/node16/-/node16-1.0.4.tgz",
-      "integrity": "sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/bn.js": {
-      "version": "5.1.6",
-      "resolved": "https://registry.npmjs.org/@types/bn.js/-/bn.js-5.1.6.tgz",
-      "integrity": "sha512-Xh8vSwUeMKeYYrj3cX4lGQgFSF/N03r+tv4AiLl1SucqV+uTQpxRcnM8AkXKHwYP9ZPXOYXRr2KPXpVlIvqh9w==",
-      "license": "MIT",
-      "dependencies": {
-        "@types/node": "*"
-      }
-    },
-    "node_modules/@types/bun": {
-      "version": "1.2.3",
-      "resolved": "https://registry.npmjs.org/@types/bun/-/bun-1.2.3.tgz",
-      "integrity": "sha512-054h79ipETRfjtsCW9qJK8Ipof67Pw9bodFWmkfkaUaRiIQ1dIV2VTlheshlBx3mpKr0KeK8VqnMMCtgN9rQtw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "bun-types": "1.2.3"
-      }
-    },
-    "node_modules/@types/chai": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/@types/chai/-/chai-5.0.1.tgz",
-      "integrity": "sha512-5T8ajsg3M/FOncpLYW7sdOcD6yf4+722sze/tc4KQV0P8Z2rAr3SAuHCIkYmYpt8VbcQlnz8SxlOlPQYefe4cA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/deep-eql": "*"
-      }
-    },
-    "node_modules/@types/deep-eql": {
-      "version": "4.0.2",
-      "resolved": "https://registry.npmjs.org/@types/deep-eql/-/deep-eql-4.0.2.tgz",
-      "integrity": "sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/estree": {
-      "version": "1.0.6",
-      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.6.tgz",
-      "integrity": "sha512-AYnb1nQyY49te+VRAVgmzfcgjYS91mY5P0TKUDCLEM+gNnA+3T6rWITXRLYCpahpqSQbN5cE+gHpnPyXjHWxcw==",
-      "license": "MIT"
-    },
-    "node_modules/@types/mocha": {
-      "version": "10.0.10",
-      "resolved": "https://registry.npmjs.org/@types/mocha/-/mocha-10.0.10.tgz",
-      "integrity": "sha512-xPyYSz1cMPnJQhl0CLMH68j3gprKZaTjG3s5Vi+fDgx+uhG9NOXwbVt52eFS8ECyXhyKcjDLCBEqBExKuiZb7Q==",
-      "license": "MIT"
-    },
-    "node_modules/@types/node": {
-      "version": "22.15.21",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-22.15.21.tgz",
-      "integrity": "sha512-EV/37Td6c+MgKAbkcLG6vqZ2zEYHD7bvSrzqqs2RIhbA6w3x+Dqz8MZM3sP6kGTeLrdoOgKZe+Xja7tUB2DNkQ==",
-      "license": "MIT",
-      "dependencies": {
-        "undici-types": "~6.21.0"
-      }
-    },
-    "node_modules/@types/normalize-package-data": {
-      "version": "2.4.4",
-      "resolved": "https://registry.npmjs.org/@types/normalize-package-data/-/normalize-package-data-2.4.4.tgz",
-      "integrity": "sha512-37i+OaWTh9qeK4LSHPsyRC7NahnGotNuZvjLSgcPzblpHB3rrCJxAOgI5gCdKm7coonsaX1Of0ILiTcnZjbfxA==",
-      "license": "MIT"
-    },
-    "node_modules/@types/ws": {
-      "version": "8.5.14",
-      "resolved": "https://registry.npmjs.org/@types/ws/-/ws-8.5.14.tgz",
-      "integrity": "sha512-bd/YFLW+URhBzMXurx7lWByOu+xzU9+kb3RboOteXYDfW+tr+JZa99OyNmPINEGB/ahzKrEuc8rcv4gnpJmxTw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/node": "*"
-      }
-    },
-    "node_modules/abitype": {
-      "version": "1.0.8",
-      "resolved": "https://registry.npmjs.org/abitype/-/abitype-1.0.8.tgz",
-      "integrity": "sha512-ZeiI6h3GnW06uYDLx0etQtX/p8E24UaHHBj57RSjK7YBFe7iuVn07EDpOeP451D06sF27VOz9JJPlIKJmXgkEg==",
-      "license": "MIT",
-      "funding": {
-        "url": "https://github.com/sponsors/wevm"
-      },
-      "peerDependencies": {
-        "typescript": ">=5.0.4",
-        "zod": "^3 >=3.22.0"
-      },
-      "peerDependenciesMeta": {
-        "typescript": {
-          "optional": true
-        },
-        "zod": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/acorn": {
-      "version": "8.14.0",
-      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.14.0.tgz",
-      "integrity": "sha512-cl669nCJTZBsL97OF4kUQm5g5hC2uihk0NxY3WENAC0TYdILVkAyHymAntgxGkl7K+t0cXIrH5siy5S4XkFycA==",
-      "license": "MIT",
-      "bin": {
-        "acorn": "bin/acorn"
-      },
-      "engines": {
-        "node": ">=0.4.0"
-      }
-    },
-    "node_modules/acorn-walk": {
-      "version": "8.3.4",
-      "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.3.4.tgz",
-      "integrity": "sha512-ueEepnujpqee2o5aIYnvHU6C0A42MNdsIDeqy5BydrkuC5R1ZuUFnm27EeFJGoEHJQgn3uleRvmTXaJgfXbt4g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "acorn": "^8.11.0"
-      },
-      "engines": {
-        "node": ">=0.4.0"
-      }
-    },
-    "node_modules/aes-js": {
-      "version": "4.0.0-beta.5",
-      "resolved": "https://registry.npmjs.org/aes-js/-/aes-js-4.0.0-beta.5.tgz",
-      "integrity": "sha512-G965FqalsNyrPqgEGON7nIx1e/OVENSgiEIzyC63haUMuvNnwIgIjMs52hlTCKhkBny7A2ORNlfY9Zu+jmGk1Q==",
-      "license": "MIT"
-    },
-    "node_modules/ansi-colors": {
-      "version": "4.1.3",
-      "resolved": "https://registry.npmjs.org/ansi-colors/-/ansi-colors-4.1.3.tgz",
-      "integrity": "sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/ansi-regex": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
-      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/ansi-styles": {
-      "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
-      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
-      "license": "MIT",
-      "dependencies": {
-        "color-convert": "^2.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
-      }
-    },
-    "node_modules/any-promise": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/any-promise/-/any-promise-1.3.0.tgz",
-      "integrity": "sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A==",
-      "license": "MIT"
-    },
-    "node_modules/anymatch": {
-      "version": "3.1.3",
-      "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz",
-      "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==",
-      "license": "ISC",
-      "dependencies": {
-        "normalize-path": "^3.0.0",
-        "picomatch": "^2.0.4"
-      },
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/arg": {
-      "version": "4.1.3",
-      "resolved": "https://registry.npmjs.org/arg/-/arg-4.1.3.tgz",
-      "integrity": "sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/argparse": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
-      "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
-      "license": "Python-2.0"
-    },
-    "node_modules/assert": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/assert/-/assert-2.1.0.tgz",
-      "integrity": "sha512-eLHpSK/Y4nhMJ07gDaAzoX/XAKS8PSaojml3M0DM4JpV1LAi5JOJ/p6H/XWrl8L+DzVEvVCW1z3vWAaB9oTsQw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.2",
-        "is-nan": "^1.3.2",
-        "object-is": "^1.1.5",
-        "object.assign": "^4.1.4",
-        "util": "^0.12.5"
-      }
-    },
-    "node_modules/assertion-error": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz",
-      "integrity": "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/available-typed-arrays": {
-      "version": "1.0.7",
-      "resolved": "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.7.tgz",
-      "integrity": "sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "possible-typed-array-names": "^1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/balanced-match": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
-      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
-      "license": "MIT"
-    },
-    "node_modules/binary-extensions": {
-      "version": "2.3.0",
-      "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.3.0.tgz",
-      "integrity": "sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/bn.js": {
-      "version": "5.2.1",
-      "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-5.2.1.tgz",
-      "integrity": "sha512-eXRvHzWyYPBuB4NBy0cmYQjGitUrtqwbvlzP3G6VFnNRbsZQIxQ10PbKKHt8gZ/HW/D/747aDl+QkDqg3KQLMQ==",
-      "license": "MIT"
-    },
-    "node_modules/brace-expansion": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz",
-      "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==",
-      "license": "MIT",
-      "dependencies": {
-        "balanced-match": "^1.0.0"
-      }
-    },
-    "node_modules/braces": {
-      "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
-      "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
-      "license": "MIT",
-      "dependencies": {
-        "fill-range": "^7.1.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/browser-stdout": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/browser-stdout/-/browser-stdout-1.3.1.tgz",
-      "integrity": "sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw==",
-      "license": "ISC"
-    },
-    "node_modules/bun-types": {
-      "version": "1.2.3",
-      "resolved": "https://registry.npmjs.org/bun-types/-/bun-types-1.2.3.tgz",
-      "integrity": "sha512-P7AeyTseLKAvgaZqQrvp3RqFM3yN9PlcLuSTe7SoJOfZkER73mLdT2vEQi8U64S1YvM/ldcNiQjn0Sn7H9lGgg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/node": "*",
-        "@types/ws": "~8.5.10"
-      }
-    },
-    "node_modules/bundle-require": {
-      "version": "5.1.0",
-      "resolved": "https://registry.npmjs.org/bundle-require/-/bundle-require-5.1.0.tgz",
-      "integrity": "sha512-3WrrOuZiyaaZPWiEt4G3+IffISVC9HYlWueJEBWED4ZH4aIAC2PnkdnuRrR94M+w6yGWn4AglWtJtBI8YqvgoA==",
-      "license": "MIT",
-      "dependencies": {
-        "load-tsconfig": "^0.2.3"
-      },
-      "engines": {
-        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
-      },
-      "peerDependencies": {
-        "esbuild": ">=0.18"
-      }
-    },
-    "node_modules/cac": {
-      "version": "6.7.14",
-      "resolved": "https://registry.npmjs.org/cac/-/cac-6.7.14.tgz",
-      "integrity": "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/call-bind": {
-      "version": "1.0.8",
-      "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.8.tgz",
-      "integrity": "sha512-oKlSFMcMwpUg2ednkhQ454wfWiU/ul3CkJe/PEHcTKuiX6RpbehUiFMXu13HalGZxfUwCQzZG747YXBn1im9ww==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind-apply-helpers": "^1.0.0",
-        "es-define-property": "^1.0.0",
-        "get-intrinsic": "^1.2.4",
-        "set-function-length": "^1.2.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/call-bind-apply-helpers": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
-      "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0",
-        "function-bind": "^1.1.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/call-bound": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.3.tgz",
-      "integrity": "sha512-YTd+6wGlNlPxSuri7Y6X8tY2dmm12UMH66RpKMhiX6rsk5wXXnYgbUcOt8kiS31/AjfoTOvCsE+w8nZQLQnzHA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind-apply-helpers": "^1.0.1",
-        "get-intrinsic": "^1.2.6"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/camelcase": {
-      "version": "6.3.0",
-      "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz",
-      "integrity": "sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/chai": {
-      "version": "5.2.0",
-      "resolved": "https://registry.npmjs.org/chai/-/chai-5.2.0.tgz",
-      "integrity": "sha512-mCuXncKXk5iCLhfhwTc0izo0gtEmpz5CtG2y8GiOINBlMVS6v8TMRc5TaLWKS6692m9+dVVfzgeVxR5UxWHTYw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "assertion-error": "^2.0.1",
-        "check-error": "^2.1.1",
-        "deep-eql": "^5.0.1",
-        "loupe": "^3.1.0",
-        "pathval": "^2.0.0"
-      },
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/chalk": {
-      "version": "5.4.1",
-      "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.4.1.tgz",
-      "integrity": "sha512-zgVZuo2WcZgfUEmsn6eO3kINexW8RAE4maiQ8QNs8CtpPCSyMiYsULR3HQYkm3w8FIA3SberyMJMSldGsW+U3w==",
-      "license": "MIT",
-      "engines": {
-        "node": "^12.17.0 || ^14.13 || >=16.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/chalk?sponsor=1"
-      }
-    },
-    "node_modules/check-error": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/check-error/-/check-error-2.1.1.tgz",
-      "integrity": "sha512-OAlb+T7V4Op9OwdkjmguYRqncdlx5JiofwOAUkmTF+jNdHwzTaTs4sRAGpzLF3oOz5xAyDGrPgeIDFQmDOTiJw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 16"
-      }
-    },
-    "node_modules/chokidar": {
-      "version": "3.6.0",
-      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.6.0.tgz",
-      "integrity": "sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==",
-      "license": "MIT",
-      "dependencies": {
-        "anymatch": "~3.1.2",
-        "braces": "~3.0.2",
-        "glob-parent": "~5.1.2",
-        "is-binary-path": "~2.1.0",
-        "is-glob": "~4.0.1",
-        "normalize-path": "~3.0.0",
-        "readdirp": "~3.6.0"
-      },
-      "engines": {
-        "node": ">= 8.10.0"
-      },
-      "funding": {
-        "url": "https://paulmillr.com/funding/"
-      },
-      "optionalDependencies": {
-        "fsevents": "~2.3.2"
-      }
-    },
-    "node_modules/cli-cursor": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-5.0.0.tgz",
-      "integrity": "sha512-aCj4O5wKyszjMmDT4tZj93kxyydN/K5zPWSCe6/0AV/AA1pqe5ZBIw0a2ZfPQV7lL5/yb5HsUreJ6UFAF1tEQw==",
-      "license": "MIT",
-      "dependencies": {
-        "restore-cursor": "^5.0.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/cli-spinners": {
-      "version": "2.9.2",
-      "resolved": "https://registry.npmjs.org/cli-spinners/-/cli-spinners-2.9.2.tgz",
-      "integrity": "sha512-ywqV+5MmyL4E7ybXgKys4DugZbX0FC6LnwrhjuykIjnK9k8OQacQ7axGKnjDXWNhns0xot3bZI5h55H8yo9cJg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/cliui": {
-      "version": "8.0.1",
-      "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz",
-      "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==",
-      "license": "ISC",
-      "dependencies": {
-        "string-width": "^4.2.0",
-        "strip-ansi": "^6.0.1",
-        "wrap-ansi": "^7.0.0"
-      },
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/color-convert": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
-      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
-      "license": "MIT",
-      "dependencies": {
-        "color-name": "~1.1.4"
-      },
-      "engines": {
-        "node": ">=7.0.0"
-      }
-    },
-    "node_modules/color-name": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
-      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
-      "license": "MIT"
-    },
-    "node_modules/commander": {
-      "version": "13.1.0",
-      "resolved": "https://registry.npmjs.org/commander/-/commander-13.1.0.tgz",
-      "integrity": "sha512-/rFeCpNJQbhSZjGVwO9RFV3xPqbnERS8MmIQzCtD/zl6gpJuV/bMLuN92oG3F7d8oDEHHRrujSXNUr8fpjntKw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/confbox": {
-      "version": "0.1.8",
-      "resolved": "https://registry.npmjs.org/confbox/-/confbox-0.1.8.tgz",
-      "integrity": "sha512-RMtmw0iFkeR4YV+fUOSucriAQNb9g8zFR52MWCtl+cCZOFRNL6zeB395vPzFhEjjn4fMxXudmELnl/KF/WrK6w==",
-      "license": "MIT"
-    },
-    "node_modules/consola": {
-      "version": "3.4.2",
-      "resolved": "https://registry.npmjs.org/consola/-/consola-3.4.2.tgz",
-      "integrity": "sha512-5IKcdX0nnYavi6G7TtOhwkYzyjfJlatbjMjuLSfE2kYT5pMDOilZ4OvMhi637CcDICTmz3wARPoyhqyX1Y+XvA==",
-      "license": "MIT",
-      "engines": {
-        "node": "^14.18.0 || >=16.10.0"
-      }
-    },
-    "node_modules/create-require": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/create-require/-/create-require-1.1.1.tgz",
-      "integrity": "sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/cross-spawn": {
-      "version": "7.0.6",
-      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
-      "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
-      "license": "MIT",
-      "dependencies": {
-        "path-key": "^3.1.0",
-        "shebang-command": "^2.0.0",
-        "which": "^2.0.1"
-      },
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/crypto": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/crypto/-/crypto-1.0.1.tgz",
-      "integrity": "sha512-VxBKmeNcqQdiUQUW2Tzq0t377b54N2bMtXO/qiLa+6eRRmmC4qT3D4OnTGoT/U6O9aklQ/jTwbOtRMTTY8G0Ig==",
-      "license": "ISC"
-    },
-    "node_modules/data-uri-to-buffer": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/data-uri-to-buffer/-/data-uri-to-buffer-4.0.1.tgz",
-      "integrity": "sha512-0R9ikRb668HB7QDxT1vkpuUBtqc53YyAwMwGeUFKRojY/NWKvdZ+9UYtRfGmhqNbRkTSVpMbmyhXipFFv2cb/A==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 12"
-      }
-    },
-    "node_modules/debug": {
-      "version": "4.4.0",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.0.tgz",
-      "integrity": "sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==",
-      "license": "MIT",
-      "dependencies": {
-        "ms": "^2.1.3"
-      },
-      "engines": {
-        "node": ">=6.0"
-      },
-      "peerDependenciesMeta": {
-        "supports-color": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/decamelize": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-4.0.0.tgz",
-      "integrity": "sha512-9iE1PgSik9HeIIw2JO94IidnE3eBoQrFJ3w7sFuzSX4DpmZ3v5sZpUiV5Swcf6mQEF+Y0ru8Neo+p+nyh2J+hQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/deep-eql": {
-      "version": "5.0.2",
-      "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-5.0.2.tgz",
-      "integrity": "sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/deepmerge-ts": {
-      "version": "7.1.5",
-      "resolved": "https://registry.npmjs.org/deepmerge-ts/-/deepmerge-ts-7.1.5.tgz",
-      "integrity": "sha512-HOJkrhaYsweh+W+e74Yn7YStZOilkoPb6fycpwNLKzSPtruFs48nYis0zy5yJz1+ktUhHxoRDJ27RQAWLIJVJw==",
-      "license": "BSD-3-Clause",
-      "engines": {
-        "node": ">=16.0.0"
-      }
-    },
-    "node_modules/define-data-property": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.4.tgz",
-      "integrity": "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "es-define-property": "^1.0.0",
-        "es-errors": "^1.3.0",
-        "gopd": "^1.0.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/define-properties": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.2.1.tgz",
-      "integrity": "sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "define-data-property": "^1.0.1",
-        "has-property-descriptors": "^1.0.0",
-        "object-keys": "^1.1.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/detect-indent": {
-      "version": "7.0.1",
-      "resolved": "https://registry.npmjs.org/detect-indent/-/detect-indent-7.0.1.tgz",
-      "integrity": "sha512-Mc7QhQ8s+cLrnUfU/Ji94vG/r8M26m8f++vyres4ZoojaRDpZ1eSIh/EpzLNwlWuvzSZ3UbDFspjFvTDXe6e/g==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=12.20"
-      }
-    },
-    "node_modules/diff": {
-      "version": "4.0.2",
-      "resolved": "https://registry.npmjs.org/diff/-/diff-4.0.2.tgz",
-      "integrity": "sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==",
-      "dev": true,
-      "license": "BSD-3-Clause",
-      "engines": {
-        "node": ">=0.3.1"
-      }
-    },
-    "node_modules/dotenv": {
-      "version": "16.4.7",
-      "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.4.7.tgz",
-      "integrity": "sha512-47qPchRCykZC03FhkYAhrvwU4xDBFIj1QPqaarj6mdM/hgUzfPHcpkHJOn3mJAufFeeAxAzeGsr5X0M4k6fLZQ==",
-      "license": "BSD-2-Clause",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://dotenvx.com"
-      }
-    },
-    "node_modules/dunder-proto": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
-      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind-apply-helpers": "^1.0.1",
-        "es-errors": "^1.3.0",
-        "gopd": "^1.2.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/eastasianwidth": {
-      "version": "0.2.0",
-      "resolved": "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz",
-      "integrity": "sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==",
-      "license": "MIT"
-    },
-    "node_modules/emoji-regex": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
-      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
-      "license": "MIT"
-    },
-    "node_modules/es-define-property": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
-      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/es-errors": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
-      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/es-object-atoms": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
-      "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/esbuild": {
-      "version": "0.25.5",
-      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.5.tgz",
-      "integrity": "sha512-P8OtKZRv/5J5hhz0cUAdu/cLuPIKXpQl1R9pZtvmHWQvrAUVd0UNIPT4IB4W3rNOqVO0rlqHmCIbSwxh/c9yUQ==",
-      "hasInstallScript": true,
-      "license": "MIT",
-      "bin": {
-        "esbuild": "bin/esbuild"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "optionalDependencies": {
-        "@esbuild/aix-ppc64": "0.25.5",
-        "@esbuild/android-arm": "0.25.5",
-        "@esbuild/android-arm64": "0.25.5",
-        "@esbuild/android-x64": "0.25.5",
-        "@esbuild/darwin-arm64": "0.25.5",
-        "@esbuild/darwin-x64": "0.25.5",
-        "@esbuild/freebsd-arm64": "0.25.5",
-        "@esbuild/freebsd-x64": "0.25.5",
-        "@esbuild/linux-arm": "0.25.5",
-        "@esbuild/linux-arm64": "0.25.5",
-        "@esbuild/linux-ia32": "0.25.5",
-        "@esbuild/linux-loong64": "0.25.5",
-        "@esbuild/linux-mips64el": "0.25.5",
-        "@esbuild/linux-ppc64": "0.25.5",
-        "@esbuild/linux-riscv64": "0.25.5",
-        "@esbuild/linux-s390x": "0.25.5",
-        "@esbuild/linux-x64": "0.25.5",
-        "@esbuild/netbsd-arm64": "0.25.5",
-        "@esbuild/netbsd-x64": "0.25.5",
-        "@esbuild/openbsd-arm64": "0.25.5",
-        "@esbuild/openbsd-x64": "0.25.5",
-        "@esbuild/sunos-x64": "0.25.5",
-        "@esbuild/win32-arm64": "0.25.5",
-        "@esbuild/win32-ia32": "0.25.5",
-        "@esbuild/win32-x64": "0.25.5"
-      }
-    },
-    "node_modules/escalade": {
-      "version": "3.2.0",
-      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
-      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/escape-string-regexp": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
-      "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/ethers": {
-      "version": "6.13.5",
-      "resolved": "https://registry.npmjs.org/ethers/-/ethers-6.13.5.tgz",
-      "integrity": "sha512-+knKNieu5EKRThQJWwqaJ10a6HE9sSehGeqWN65//wE7j47ZpFhKAnHB/JJFibwwg61I/koxaPsXbXpD/skNOQ==",
-      "funding": [
-        {
-          "type": "individual",
-          "url": "https://github.com/sponsors/ethers-io/"
-        },
-        {
-          "type": "individual",
-          "url": "https://www.buymeacoffee.com/ricmoo"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "@adraffy/ens-normalize": "1.10.1",
-        "@noble/curves": "1.2.0",
-        "@noble/hashes": "1.3.2",
-        "@types/node": "22.7.5",
-        "aes-js": "4.0.0-beta.5",
-        "tslib": "2.7.0",
-        "ws": "8.17.1"
-      },
-      "engines": {
-        "node": ">=14.0.0"
-      }
-    },
-    "node_modules/ethers/node_modules/@noble/curves": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/@noble/curves/-/curves-1.2.0.tgz",
-      "integrity": "sha512-oYclrNgRaM9SsBUBVbb8M6DTV7ZHRTKugureoYEncY5c65HOmRzvSiTE3y5CYaPYJA/GVkrhXEoF0M3Ya9PMnw==",
-      "license": "MIT",
-      "dependencies": {
-        "@noble/hashes": "1.3.2"
-      },
-      "funding": {
-        "url": "https://paulmillr.com/funding/"
-      }
-    },
-    "node_modules/ethers/node_modules/@noble/hashes": {
-      "version": "1.3.2",
-      "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.3.2.tgz",
-      "integrity": "sha512-MVC8EAQp7MvEcm30KWENFjgR+Mkmf+D189XJTkFIlwohU5hcBbn1ZkKq7KVTi2Hme3PMGF390DaL52beVrIihQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 16"
-      },
-      "funding": {
-        "url": "https://paulmillr.com/funding/"
-      }
-    },
-    "node_modules/ethers/node_modules/@types/node": {
-      "version": "22.7.5",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-22.7.5.tgz",
-      "integrity": "sha512-jML7s2NAzMWc//QSJ1a3prpk78cOPchGvXJsC3C6R6PSMoooztvRVQEz89gmBTBY1SPMaqo5teB4uNHPdetShQ==",
-      "license": "MIT",
-      "dependencies": {
-        "undici-types": "~6.19.2"
-      }
-    },
-    "node_modules/ethers/node_modules/tslib": {
-      "version": "2.7.0",
-      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.7.0.tgz",
-      "integrity": "sha512-gLXCKdN1/j47AiHiOkJN69hJmcbGTHI0ImLmbYLHykhgeN0jVGola9yVjFgzCUklsZQMW55o+dW7IXv3RCXDzA==",
-      "license": "0BSD"
-    },
-    "node_modules/ethers/node_modules/undici-types": {
-      "version": "6.19.8",
-      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.19.8.tgz",
-      "integrity": "sha512-ve2KP6f/JnbPBFyobGHuerC9g1FYGn/F8n1LWTwNxCEzd6IfqTwUQcNXgEtmmQ6DlRrC1hrSrBnCZPokRrDHjw==",
-      "license": "MIT"
-    },
-    "node_modules/ethers/node_modules/ws": {
-      "version": "8.17.1",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-8.17.1.tgz",
-      "integrity": "sha512-6XQFvXTkbfUOZOKKILFG1PDK2NDQs4azKQl26T0YS5CxqWLgXajbPZ+h4gZekJyRqFU8pvnbAbbs/3TgRPy+GQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=10.0.0"
-      },
-      "peerDependencies": {
-        "bufferutil": "^4.0.1",
-        "utf-8-validate": ">=5.0.2"
-      },
-      "peerDependenciesMeta": {
-        "bufferutil": {
-          "optional": true
-        },
-        "utf-8-validate": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/eventemitter3": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-5.0.1.tgz",
-      "integrity": "sha512-GWkBvjiSZK87ELrYOSESUYeVIc9mvLLf/nXalMOS5dYrgZq9o5OVkbZAVM06CVxYsCwH9BDZFPlQTlPA1j4ahA==",
-      "license": "MIT"
-    },
-    "node_modules/execa": {
-      "version": "9.6.0",
-      "resolved": "https://registry.npmjs.org/execa/-/execa-9.6.0.tgz",
-      "integrity": "sha512-jpWzZ1ZhwUmeWRhS7Qv3mhpOhLfwI+uAX4e5fOcXqwMR7EcJ0pj2kV1CVzHVMX/LphnKWD3LObjZCoJ71lKpHw==",
-      "license": "MIT",
-      "dependencies": {
-        "@sindresorhus/merge-streams": "^4.0.0",
-        "cross-spawn": "^7.0.6",
-        "figures": "^6.1.0",
-        "get-stream": "^9.0.0",
-        "human-signals": "^8.0.1",
-        "is-plain-obj": "^4.1.0",
-        "is-stream": "^4.0.1",
-        "npm-run-path": "^6.0.0",
-        "pretty-ms": "^9.2.0",
-        "signal-exit": "^4.1.0",
-        "strip-final-newline": "^4.0.0",
-        "yoctocolors": "^2.1.1"
-      },
-      "engines": {
-        "node": "^18.19.0 || >=20.5.0"
-      },
-      "funding": {
-        "url": "https://github.com/sindresorhus/execa?sponsor=1"
-      }
-    },
-    "node_modules/fetch-blob": {
-      "version": "3.2.0",
-      "resolved": "https://registry.npmjs.org/fetch-blob/-/fetch-blob-3.2.0.tgz",
-      "integrity": "sha512-7yAQpD2UMJzLi1Dqv7qFYnPbaPx7ZfFK6PiIxQ4PfkGPyNyl2Ugx+a/umUonmKqjhM4DnfbMvdX6otXq83soQQ==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/jimmywarting"
-        },
-        {
-          "type": "paypal",
-          "url": "https://paypal.me/jimmywarting"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "node-domexception": "^1.0.0",
-        "web-streams-polyfill": "^3.0.3"
-      },
-      "engines": {
-        "node": "^12.20 || >= 14.13"
-      }
-    },
-    "node_modules/figures": {
-      "version": "6.1.0",
-      "resolved": "https://registry.npmjs.org/figures/-/figures-6.1.0.tgz",
-      "integrity": "sha512-d+l3qxjSesT4V7v2fh+QnmFnUWv9lSpjarhShNTgBOfA0ttejbQUAlHLitbjkoRiDulW0OPoQPYIGhIC8ohejg==",
-      "license": "MIT",
-      "dependencies": {
-        "is-unicode-supported": "^2.0.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/fill-range": {
-      "version": "7.1.1",
-      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
-      "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
-      "license": "MIT",
-      "dependencies": {
-        "to-regex-range": "^5.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/find-up": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz",
-      "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==",
-      "license": "MIT",
-      "dependencies": {
-        "locate-path": "^6.0.0",
-        "path-exists": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/fix-dts-default-cjs-exports": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/fix-dts-default-cjs-exports/-/fix-dts-default-cjs-exports-1.0.1.tgz",
-      "integrity": "sha512-pVIECanWFC61Hzl2+oOCtoJ3F17kglZC/6N94eRWycFgBH35hHx0Li604ZIzhseh97mf2p0cv7vVrOZGoqhlEg==",
-      "license": "MIT",
-      "dependencies": {
-        "magic-string": "^0.30.17",
-        "mlly": "^1.7.4",
-        "rollup": "^4.34.8"
-      }
-    },
-    "node_modules/flat": {
-      "version": "5.0.2",
-      "resolved": "https://registry.npmjs.org/flat/-/flat-5.0.2.tgz",
-      "integrity": "sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==",
-      "license": "BSD-3-Clause",
-      "bin": {
-        "flat": "cli.js"
-      }
-    },
-    "node_modules/for-each": {
-      "version": "0.3.5",
-      "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.5.tgz",
-      "integrity": "sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-callable": "^1.2.7"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/foreground-child": {
-      "version": "3.3.1",
-      "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.1.tgz",
-      "integrity": "sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==",
-      "license": "ISC",
-      "dependencies": {
-        "cross-spawn": "^7.0.6",
-        "signal-exit": "^4.0.1"
-      },
-      "engines": {
-        "node": ">=14"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
-    "node_modules/formdata-polyfill": {
-      "version": "4.0.10",
-      "resolved": "https://registry.npmjs.org/formdata-polyfill/-/formdata-polyfill-4.0.10.tgz",
-      "integrity": "sha512-buewHzMvYL29jdeQTVILecSaZKnt/RJWjoZCF5OW60Z67/GmSLBkOFM7qh1PI3zFNtJbaZL5eQu1vLfazOwj4g==",
-      "license": "MIT",
-      "dependencies": {
-        "fetch-blob": "^3.1.2"
-      },
-      "engines": {
-        "node": ">=12.20.0"
-      }
-    },
-    "node_modules/fs.promises.exists": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/fs.promises.exists/-/fs.promises.exists-1.1.4.tgz",
-      "integrity": "sha512-lJzUGWbZn8vhGWBedA+RYjB/BeJ+3458ljUfmplqhIeb6ewzTFWNPCR1HCiYCkXV9zxcHz9zXkJzMsEgDLzh3Q==",
-      "license": "MIT",
-      "funding": {
-        "url": "https://github.com/privatenumber/fs.promises.exists?sponsor=1"
-      }
-    },
-    "node_modules/function-bind": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
-      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
-      "dev": true,
-      "license": "MIT",
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/get-caller-file": {
-      "version": "2.0.5",
-      "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
-      "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
-      "license": "ISC",
-      "engines": {
-        "node": "6.* || 8.* || >= 10.*"
-      }
-    },
-    "node_modules/get-east-asian-width": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/get-east-asian-width/-/get-east-asian-width-1.3.0.tgz",
-      "integrity": "sha512-vpeMIQKxczTD/0s2CdEWHcb0eeJe6TFjxb+J5xgX7hScxqrGuyjmv4c1D4A/gelKfyox0gJJwIHF+fLjeaM8kQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/get-intrinsic": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
-      "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind-apply-helpers": "^1.0.2",
-        "es-define-property": "^1.0.1",
-        "es-errors": "^1.3.0",
-        "es-object-atoms": "^1.1.1",
-        "function-bind": "^1.1.2",
-        "get-proto": "^1.0.1",
-        "gopd": "^1.2.0",
-        "has-symbols": "^1.1.0",
-        "hasown": "^2.0.2",
-        "math-intrinsics": "^1.1.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/get-proto": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
-      "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "dunder-proto": "^1.0.1",
-        "es-object-atoms": "^1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/get-stream": {
-      "version": "9.0.1",
-      "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-9.0.1.tgz",
-      "integrity": "sha512-kVCxPF3vQM/N0B1PmoqVUqgHP+EeVjmZSQn+1oCRPxd2P21P2F19lIgbR3HBosbB1PUhOAoctJnfEn2GbN2eZA==",
-      "license": "MIT",
-      "dependencies": {
-        "@sec-ant/readable-stream": "^0.4.1",
-        "is-stream": "^4.0.1"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/glob": {
-      "version": "10.4.5",
-      "resolved": "https://registry.npmjs.org/glob/-/glob-10.4.5.tgz",
-      "integrity": "sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==",
-      "license": "ISC",
-      "dependencies": {
-        "foreground-child": "^3.1.0",
-        "jackspeak": "^3.1.2",
-        "minimatch": "^9.0.4",
-        "minipass": "^7.1.2",
-        "package-json-from-dist": "^1.0.0",
-        "path-scurry": "^1.11.1"
-      },
-      "bin": {
-        "glob": "dist/esm/bin.mjs"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
-    "node_modules/glob-parent": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
-      "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
-      "license": "ISC",
-      "dependencies": {
-        "is-glob": "^4.0.1"
-      },
-      "engines": {
-        "node": ">= 6"
-      }
-    },
-    "node_modules/glob/node_modules/minimatch": {
-      "version": "9.0.5",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz",
-      "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==",
-      "license": "ISC",
-      "dependencies": {
-        "brace-expansion": "^2.0.1"
-      },
-      "engines": {
-        "node": ">=16 || 14 >=14.17"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
-    "node_modules/gopd": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
-      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/has-flag": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
-      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/has-property-descriptors": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz",
-      "integrity": "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "es-define-property": "^1.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/has-symbols": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
-      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/has-tostringtag": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
-      "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "has-symbols": "^1.0.3"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/hasown": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
-      "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "function-bind": "^1.1.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/he": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/he/-/he-1.2.0.tgz",
-      "integrity": "sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==",
-      "license": "MIT",
-      "bin": {
-        "he": "bin/he"
-      }
-    },
-    "node_modules/hosted-git-info": {
-      "version": "7.0.2",
-      "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-7.0.2.tgz",
-      "integrity": "sha512-puUZAUKT5m8Zzvs72XWy3HtvVbTWljRE66cP60bxJzAqf2DgICo7lYTY2IHUmLnNpjYvw5bvmoHvPc0QO2a62w==",
-      "license": "ISC",
-      "dependencies": {
-        "lru-cache": "^10.0.1"
-      },
-      "engines": {
-        "node": "^16.14.0 || >=18.0.0"
-      }
-    },
-    "node_modules/human-signals": {
-      "version": "8.0.1",
-      "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-8.0.1.tgz",
-      "integrity": "sha512-eKCa6bwnJhvxj14kZk5NCPc6Hb6BdsU9DZcOnmQKSnO1VKrfV0zCvtttPZUsBvjmNDn8rpcJfpwSYnHBjc95MQ==",
-      "license": "Apache-2.0",
-      "engines": {
-        "node": ">=18.18.0"
-      }
-    },
-    "node_modules/imurmurhash": {
-      "version": "0.1.4",
-      "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz",
-      "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.8.19"
-      }
-    },
-    "node_modules/index-to-position": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/index-to-position/-/index-to-position-1.1.0.tgz",
-      "integrity": "sha512-XPdx9Dq4t9Qk1mTMbWONJqU7boCoumEH7fRET37HX5+khDUl3J2W6PdALxhILYlIYx2amlwYcRPp28p0tSiojg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/inherits": {
-      "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
-      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/is-arguments": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/is-arguments/-/is-arguments-1.2.0.tgz",
-      "integrity": "sha512-7bVbi0huj/wrIAOzb8U1aszg9kdi3KN/CyU19CTI7tAoZYEZoL9yCDXpbXN+uPsuWnP02cyug1gleqq+TU+YCA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.2",
-        "has-tostringtag": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-binary-path": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz",
-      "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==",
-      "license": "MIT",
-      "dependencies": {
-        "binary-extensions": "^2.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/is-callable": {
-      "version": "1.2.7",
-      "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.2.7.tgz",
-      "integrity": "sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-extglob": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
-      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/is-fullwidth-code-point": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
-      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/is-generator-function": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/is-generator-function/-/is-generator-function-1.1.0.tgz",
-      "integrity": "sha512-nPUB5km40q9e8UfN/Zc24eLlzdSf9OfKByBw9CIdw4H1giPMeA0OIJvbchsCu4npfI2QcMVBsGEBHKZ7wLTWmQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3",
-        "get-proto": "^1.0.0",
-        "has-tostringtag": "^1.0.2",
-        "safe-regex-test": "^1.1.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-glob": {
-      "version": "4.0.3",
-      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
-      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
-      "license": "MIT",
-      "dependencies": {
-        "is-extglob": "^2.1.1"
-      },
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/is-interactive": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/is-interactive/-/is-interactive-2.0.0.tgz",
-      "integrity": "sha512-qP1vozQRI+BMOPcjFzrjXuQvdak2pHNUMZoeG2eRbiSqyvbEf/wQtEOTOX1guk6E3t36RkaqiSt8A/6YElNxLQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/is-nan": {
-      "version": "1.3.2",
-      "resolved": "https://registry.npmjs.org/is-nan/-/is-nan-1.3.2.tgz",
-      "integrity": "sha512-E+zBKpQ2t6MEo1VsonYmluk9NxGrbzpeeLC2xIViuO2EjU2xsXsBPwTr3Ykv9l08UYEVEdWeRZNouaZqF6RN0w==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.0",
-        "define-properties": "^1.1.3"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-number": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
-      "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.12.0"
-      }
-    },
-    "node_modules/is-plain-obj": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-4.1.0.tgz",
-      "integrity": "sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/is-regex": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.2.1.tgz",
-      "integrity": "sha512-MjYsKHO5O7mCsmRGxWcLWheFqN9DJ/2TmngvjKXihe6efViPqc274+Fx/4fYj/r03+ESvBdTXK0V6tA3rgez1g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.2",
-        "gopd": "^1.2.0",
-        "has-tostringtag": "^1.0.2",
-        "hasown": "^2.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-stream": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-4.0.1.tgz",
-      "integrity": "sha512-Dnz92NInDqYckGEUJv689RbRiTSEHCQ7wOVeALbkOz999YpqT46yMRIGtSNl2iCL1waAZSx40+h59NV/EwzV/A==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/is-typed-array": {
-      "version": "1.1.15",
-      "resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.15.tgz",
-      "integrity": "sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "which-typed-array": "^1.1.16"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-unicode-supported": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-2.1.0.tgz",
-      "integrity": "sha512-mE00Gnza5EEB3Ds0HfMyllZzbBrmLOX3vfWoj9A9PEnTfratQ/BcaJOuMhnkhjXvb2+FkY3VuHqtAGpTPmglFQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/isexe": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
-      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
-      "license": "ISC"
-    },
-    "node_modules/isows": {
-      "version": "1.0.6",
-      "resolved": "https://registry.npmjs.org/isows/-/isows-1.0.6.tgz",
-      "integrity": "sha512-lPHCayd40oW98/I0uvgaHKWCSvkzY27LjWLbtzOm64yQ+G3Q5npjjbdppU65iZXkK1Zt+kH9pfegli0AYfwYYw==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/wevm"
-        }
-      ],
-      "license": "MIT",
-      "peerDependencies": {
-        "ws": "*"
-      }
-    },
-    "node_modules/jackspeak": {
-      "version": "3.4.3",
-      "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-3.4.3.tgz",
-      "integrity": "sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==",
-      "license": "BlueOak-1.0.0",
-      "dependencies": {
-        "@isaacs/cliui": "^8.0.2"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      },
-      "optionalDependencies": {
-        "@pkgjs/parseargs": "^0.11.0"
-      }
-    },
-    "node_modules/joycon": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/joycon/-/joycon-3.1.1.tgz",
-      "integrity": "sha512-34wB/Y7MW7bzjKRjUKTa46I2Z7eV62Rkhva+KkopW7Qvv/OSWBqvkSY7vusOPrNuZcUG3tApvdVgNB8POj3SPw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/js-tokens": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
-      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
-      "license": "MIT"
-    },
-    "node_modules/js-yaml": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
-      "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==",
-      "license": "MIT",
-      "dependencies": {
-        "argparse": "^2.0.1"
-      },
-      "bin": {
-        "js-yaml": "bin/js-yaml.js"
-      }
-    },
-    "node_modules/json-stringify-safe": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz",
-      "integrity": "sha512-ZClg6AaYvamvYEE82d3Iyd3vSSIjQ+odgjaTzRuO3s7toCdFKczob2i0zCh7JE8kWn17yvAWhUVxvqGwUalsRA==",
-      "license": "ISC"
-    },
-    "node_modules/lilconfig": {
-      "version": "3.1.3",
-      "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-3.1.3.tgz",
-      "integrity": "sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=14"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/antonk52"
-      }
-    },
-    "node_modules/lines-and-columns": {
-      "version": "1.2.4",
-      "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz",
-      "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==",
-      "license": "MIT"
-    },
-    "node_modules/load-tsconfig": {
-      "version": "0.2.5",
-      "resolved": "https://registry.npmjs.org/load-tsconfig/-/load-tsconfig-0.2.5.tgz",
-      "integrity": "sha512-IXO6OCs9yg8tMKzfPZ1YmheJbZCiEsnBdcB03l0OcfK9prKnJb96siuHCr5Fl37/yo9DnKU+TLpxzTUspw9shg==",
-      "license": "MIT",
-      "engines": {
-        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
-      }
-    },
-    "node_modules/locate-path": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
-      "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==",
-      "license": "MIT",
-      "dependencies": {
-        "p-locate": "^5.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/lodash.sortby": {
-      "version": "4.7.0",
-      "resolved": "https://registry.npmjs.org/lodash.sortby/-/lodash.sortby-4.7.0.tgz",
-      "integrity": "sha512-HDWXG8isMntAyRF5vZ7xKuEvOhT4AhlRt/3czTSjvGUxjYCBVRQY48ViDHyfYz9VIoBkW4TMGQNapx+l3RUwdA==",
-      "license": "MIT"
-    },
-    "node_modules/log-symbols": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-4.1.0.tgz",
-      "integrity": "sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg==",
-      "license": "MIT",
-      "dependencies": {
-        "chalk": "^4.1.0",
-        "is-unicode-supported": "^0.1.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/log-symbols/node_modules/chalk": {
-      "version": "4.1.2",
-      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
-      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
-      "license": "MIT",
-      "dependencies": {
-        "ansi-styles": "^4.1.0",
-        "supports-color": "^7.1.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/chalk?sponsor=1"
-      }
-    },
-    "node_modules/log-symbols/node_modules/is-unicode-supported": {
-      "version": "0.1.0",
-      "resolved": "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-0.1.0.tgz",
-      "integrity": "sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/log-symbols/node_modules/supports-color": {
-      "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
-      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
-      "license": "MIT",
-      "dependencies": {
-        "has-flag": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/loupe": {
-      "version": "3.1.3",
-      "resolved": "https://registry.npmjs.org/loupe/-/loupe-3.1.3.tgz",
-      "integrity": "sha512-kkIp7XSkP78ZxJEsSxW3712C6teJVoeHHwgo9zJ380de7IYyJ2ISlxojcH2pC5OFLewESmnRi/+XCDIEEVyoug==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/lru-cache": {
-      "version": "10.4.3",
-      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz",
-      "integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==",
-      "license": "ISC"
-    },
-    "node_modules/magic-string": {
-      "version": "0.30.17",
-      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.17.tgz",
-      "integrity": "sha512-sNPKHvyjVf7gyjwS4xGTaW/mCnF8wnjtifKBEhxfZ7E/S8tQ0rssrwGNn6q8JH/ohItJfSQp9mBtQYuTlH5QnA==",
-      "license": "MIT",
-      "dependencies": {
-        "@jridgewell/sourcemap-codec": "^1.5.0"
-      }
-    },
-    "node_modules/make-error": {
-      "version": "1.3.6",
-      "resolved": "https://registry.npmjs.org/make-error/-/make-error-1.3.6.tgz",
-      "integrity": "sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/math-intrinsics": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
-      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/micro-sr25519": {
-      "version": "0.1.0",
-      "resolved": "https://registry.npmjs.org/micro-sr25519/-/micro-sr25519-0.1.0.tgz",
-      "integrity": "sha512-at5zfxiKNhh07v4GPb8Sc6wCW+jd18FMMgPM0ACIQMcgvMfB9a34mfOlXr5B04J4yFZ6imlvJfRaFbOxMA7ytw==",
-      "license": "MIT",
-      "dependencies": {
-        "@noble/curves": "~1.7.0",
-        "@noble/hashes": "~1.6.0"
-      },
-      "funding": {
-        "url": "https://paulmillr.com/funding/"
-      }
-    },
-    "node_modules/micro-sr25519/node_modules/@noble/curves": {
-      "version": "1.7.0",
-      "resolved": "https://registry.npmjs.org/@noble/curves/-/curves-1.7.0.tgz",
-      "integrity": "sha512-UTMhXK9SeDhFJVrHeUJ5uZlI6ajXg10O6Ddocf9S6GjbSBVZsJo88HzKwXznNfGpMTRDyJkqMjNDPYgf0qFWnw==",
-      "license": "MIT",
-      "dependencies": {
-        "@noble/hashes": "1.6.0"
-      },
-      "engines": {
-        "node": "^14.21.3 || >=16"
-      },
-      "funding": {
-        "url": "https://paulmillr.com/funding/"
-      }
-    },
-    "node_modules/micro-sr25519/node_modules/@noble/curves/node_modules/@noble/hashes": {
-      "version": "1.6.0",
-      "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.6.0.tgz",
-      "integrity": "sha512-YUULf0Uk4/mAA89w+k3+yUYh6NrEvxZa5T6SY3wlMvE2chHkxFUUIDI8/XW1QSC357iA5pSnqt7XEhvFOqmDyQ==",
-      "license": "MIT",
-      "engines": {
-        "node": "^14.21.3 || >=16"
-      },
-      "funding": {
-        "url": "https://paulmillr.com/funding/"
-      }
-    },
-    "node_modules/micro-sr25519/node_modules/@noble/hashes": {
-      "version": "1.6.1",
-      "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.6.1.tgz",
-      "integrity": "sha512-pq5D8h10hHBjyqX+cfBm0i8JUXJ0UhczFc4r74zbuT9XgewFo2E3J1cOaGtdZynILNmQ685YWGzGE1Zv6io50w==",
-      "license": "MIT",
-      "engines": {
-        "node": "^14.21.3 || >=16"
-      },
-      "funding": {
-        "url": "https://paulmillr.com/funding/"
-      }
-    },
-    "node_modules/mimic-function": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/mimic-function/-/mimic-function-5.0.1.tgz",
-      "integrity": "sha512-VP79XUPxV2CigYP3jWwAUFSku2aKqBH7uTAapFWCBqutsbmDo96KY5o8uh6U+/YSIn5OxJnXp73beVkpqMIGhA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/minimatch": {
-      "version": "5.1.6",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.6.tgz",
-      "integrity": "sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==",
-      "license": "ISC",
-      "dependencies": {
-        "brace-expansion": "^2.0.1"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/minipass": {
-      "version": "7.1.2",
-      "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.2.tgz",
-      "integrity": "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==",
-      "license": "ISC",
-      "engines": {
-        "node": ">=16 || 14 >=14.17"
-      }
-    },
-    "node_modules/mlly": {
-      "version": "1.7.4",
-      "resolved": "https://registry.npmjs.org/mlly/-/mlly-1.7.4.tgz",
-      "integrity": "sha512-qmdSIPC4bDJXgZTCR7XosJiNKySV7O215tsPtDN9iEO/7q/76b/ijtgRu/+epFXSJhijtTCCGp3DWS549P3xKw==",
-      "license": "MIT",
-      "dependencies": {
-        "acorn": "^8.14.0",
-        "pathe": "^2.0.1",
-        "pkg-types": "^1.3.0",
-        "ufo": "^1.5.4"
-      }
-    },
-    "node_modules/mocha": {
-      "version": "11.1.0",
-      "resolved": "https://registry.npmjs.org/mocha/-/mocha-11.1.0.tgz",
-      "integrity": "sha512-8uJR5RTC2NgpY3GrYcgpZrsEd9zKbPDpob1RezyR2upGHRQtHWofmzTMzTMSV6dru3tj5Ukt0+Vnq1qhFEEwAg==",
-      "license": "MIT",
-      "dependencies": {
-        "ansi-colors": "^4.1.3",
-        "browser-stdout": "^1.3.1",
-        "chokidar": "^3.5.3",
-        "debug": "^4.3.5",
-        "diff": "^5.2.0",
-        "escape-string-regexp": "^4.0.0",
-        "find-up": "^5.0.0",
-        "glob": "^10.4.5",
-        "he": "^1.2.0",
-        "js-yaml": "^4.1.0",
-        "log-symbols": "^4.1.0",
-        "minimatch": "^5.1.6",
-        "ms": "^2.1.3",
-        "serialize-javascript": "^6.0.2",
-        "strip-json-comments": "^3.1.1",
-        "supports-color": "^8.1.1",
-        "workerpool": "^6.5.1",
-        "yargs": "^17.7.2",
-        "yargs-parser": "^21.1.1",
-        "yargs-unparser": "^2.0.0"
-      },
-      "bin": {
-        "_mocha": "bin/_mocha",
-        "mocha": "bin/mocha.js"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      }
-    },
-    "node_modules/mocha/node_modules/diff": {
-      "version": "5.2.0",
-      "resolved": "https://registry.npmjs.org/diff/-/diff-5.2.0.tgz",
-      "integrity": "sha512-uIFDxqpRZGZ6ThOk84hEfqWoHx2devRFvpTZcTHur85vImfaxUbTW9Ryh4CpCuDnToOP1CEtXKIgytHBPVff5A==",
-      "license": "BSD-3-Clause",
-      "engines": {
-        "node": ">=0.3.1"
-      }
-    },
-    "node_modules/mock-socket": {
-      "version": "9.3.1",
-      "resolved": "https://registry.npmjs.org/mock-socket/-/mock-socket-9.3.1.tgz",
-      "integrity": "sha512-qxBgB7Qa2sEQgHFjj0dSigq7fX4k6Saisd5Nelwp2q8mlbAFh5dHV9JTTlF8viYJLSSWgMCZFUom8PJcMNBoJw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/ms": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
-      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
-      "license": "MIT"
-    },
-    "node_modules/mz": {
-      "version": "2.7.0",
-      "resolved": "https://registry.npmjs.org/mz/-/mz-2.7.0.tgz",
-      "integrity": "sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==",
-      "license": "MIT",
-      "dependencies": {
-        "any-promise": "^1.0.0",
-        "object-assign": "^4.0.1",
-        "thenify-all": "^1.0.0"
-      }
-    },
-    "node_modules/nanoid": {
-      "version": "3.3.8",
-      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.8.tgz",
-      "integrity": "sha512-WNLf5Sd8oZxOm+TzppcYk8gVOgP+l58xNy58D0nbUnOxOWRWvlcCV4kUF7ltmI6PsrLl/BgKEyS4mqsGChFN0w==",
-      "devOptional": true,
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/ai"
-        }
-      ],
-      "license": "MIT",
-      "bin": {
-        "nanoid": "bin/nanoid.cjs"
-      },
-      "engines": {
-        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
-      }
-    },
-    "node_modules/nock": {
-      "version": "13.5.6",
-      "resolved": "https://registry.npmjs.org/nock/-/nock-13.5.6.tgz",
-      "integrity": "sha512-o2zOYiCpzRqSzPj0Zt/dQ/DqZeYoaQ7TUonc/xUPjCGl9WeHpNbxgVvOquXYAaJzI0M9BXV3HTzG0p8IUAbBTQ==",
-      "license": "MIT",
-      "dependencies": {
-        "debug": "^4.1.0",
-        "json-stringify-safe": "^5.0.1",
-        "propagate": "^2.0.0"
-      },
-      "engines": {
-        "node": ">= 10.13"
-      }
-    },
-    "node_modules/node-domexception": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/node-domexception/-/node-domexception-1.0.0.tgz",
-      "integrity": "sha512-/jKZoMpw0F8GRwl4/eLROPA3cfcXtLApP0QzLmUT/HuPCZWyB7IY9ZrMeKw2O/nFIqPQB3PVM9aYm0F312AXDQ==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/jimmywarting"
-        },
-        {
-          "type": "github",
-          "url": "https://paypal.me/jimmywarting"
-        }
-      ],
-      "license": "MIT",
-      "engines": {
-        "node": ">=10.5.0"
-      }
-    },
-    "node_modules/node-fetch": {
-      "version": "3.3.2",
-      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-3.3.2.tgz",
-      "integrity": "sha512-dRB78srN/l6gqWulah9SrxeYnxeddIG30+GOqK/9OlLVyLg3HPnr6SqOWTWOXKRwC2eGYCkZ59NNuSgvSrpgOA==",
-      "license": "MIT",
-      "dependencies": {
-        "data-uri-to-buffer": "^4.0.0",
-        "fetch-blob": "^3.1.4",
-        "formdata-polyfill": "^4.0.10"
-      },
-      "engines": {
-        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/node-fetch"
-      }
-    },
-    "node_modules/normalize-package-data": {
-      "version": "6.0.2",
-      "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-6.0.2.tgz",
-      "integrity": "sha512-V6gygoYb/5EmNI+MEGrWkC+e6+Rr7mTmfHrxDbLzxQogBkgzo76rkok0Am6thgSF7Mv2nLOajAJj5vDJZEFn7g==",
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "hosted-git-info": "^7.0.0",
-        "semver": "^7.3.5",
-        "validate-npm-package-license": "^3.0.4"
-      },
-      "engines": {
-        "node": "^16.14.0 || >=18.0.0"
-      }
-    },
-    "node_modules/normalize-path": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
-      "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/npm-run-path": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-6.0.0.tgz",
-      "integrity": "sha512-9qny7Z9DsQU8Ou39ERsPU4OZQlSTP47ShQzuKZ6PRXpYLtIFgl/DEBYEXKlvcEa+9tHVcK8CF81Y2V72qaZhWA==",
-      "license": "MIT",
-      "dependencies": {
-        "path-key": "^4.0.0",
-        "unicorn-magic": "^0.3.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/npm-run-path/node_modules/path-key": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/path-key/-/path-key-4.0.0.tgz",
-      "integrity": "sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/object-assign": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
-      "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/object-is": {
-      "version": "1.1.6",
-      "resolved": "https://registry.npmjs.org/object-is/-/object-is-1.1.6.tgz",
-      "integrity": "sha512-F8cZ+KfGlSGi09lJT7/Nd6KJZ9ygtvYC0/UYYLI9nmQKLMnydpB9yvbv9K1uSkEu7FU9vYPmVwLg328tX+ot3Q==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.7",
-        "define-properties": "^1.2.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/object-keys": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz",
-      "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/object.assign": {
-      "version": "4.1.7",
-      "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.7.tgz",
-      "integrity": "sha512-nK28WOo+QIjBkDduTINE4JkF/UJJKyf2EJxvJKfblDpyg0Q+pkOHNTL0Qwy6NP6FhE/EnzV73BxxqcJaXY9anw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.8",
-        "call-bound": "^1.0.3",
-        "define-properties": "^1.2.1",
-        "es-object-atoms": "^1.0.0",
-        "has-symbols": "^1.1.0",
-        "object-keys": "^1.1.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/onetime": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/onetime/-/onetime-7.0.0.tgz",
-      "integrity": "sha512-VXJjc87FScF88uafS3JllDgvAm+c/Slfz06lorj2uAY34rlUu0Nt+v8wreiImcrgAjjIHp1rXpTDlLOGw29WwQ==",
-      "license": "MIT",
-      "dependencies": {
-        "mimic-function": "^5.0.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/ora": {
-      "version": "8.2.0",
-      "resolved": "https://registry.npmjs.org/ora/-/ora-8.2.0.tgz",
-      "integrity": "sha512-weP+BZ8MVNnlCm8c0Qdc1WSWq4Qn7I+9CJGm7Qali6g44e/PUzbjNqJX5NJ9ljlNMosfJvg1fKEGILklK9cwnw==",
-      "license": "MIT",
-      "dependencies": {
-        "chalk": "^5.3.0",
-        "cli-cursor": "^5.0.0",
-        "cli-spinners": "^2.9.2",
-        "is-interactive": "^2.0.0",
-        "is-unicode-supported": "^2.0.0",
-        "log-symbols": "^6.0.0",
-        "stdin-discarder": "^0.2.2",
-        "string-width": "^7.2.0",
-        "strip-ansi": "^7.1.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/ora/node_modules/ansi-regex": {
-      "version": "6.1.0",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.1.0.tgz",
-      "integrity": "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-regex?sponsor=1"
-      }
-    },
-    "node_modules/ora/node_modules/emoji-regex": {
-      "version": "10.4.0",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-10.4.0.tgz",
-      "integrity": "sha512-EC+0oUMY1Rqm4O6LLrgjtYDvcVYTy7chDnM4Q7030tP4Kwj3u/pR6gP9ygnp2CJMK5Gq+9Q2oqmrFJAz01DXjw==",
-      "license": "MIT"
-    },
-    "node_modules/ora/node_modules/log-symbols": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-6.0.0.tgz",
-      "integrity": "sha512-i24m8rpwhmPIS4zscNzK6MSEhk0DUWa/8iYQWxhffV8jkI4Phvs3F+quL5xvS0gdQR0FyTCMMH33Y78dDTzzIw==",
-      "license": "MIT",
-      "dependencies": {
-        "chalk": "^5.3.0",
-        "is-unicode-supported": "^1.3.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/ora/node_modules/log-symbols/node_modules/is-unicode-supported": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-1.3.0.tgz",
-      "integrity": "sha512-43r2mRvz+8JRIKnWJ+3j8JtjRKZ6GmjzfaE/qiBJnikNnYv/6bagRJ1kUhNk8R5EX/GkobD+r+sfxCPJsiKBLQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/ora/node_modules/string-width": {
-      "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-7.2.0.tgz",
-      "integrity": "sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ==",
-      "license": "MIT",
-      "dependencies": {
-        "emoji-regex": "^10.3.0",
-        "get-east-asian-width": "^1.0.0",
-        "strip-ansi": "^7.1.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/ora/node_modules/strip-ansi": {
-      "version": "7.1.0",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz",
-      "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==",
-      "license": "MIT",
-      "dependencies": {
-        "ansi-regex": "^6.0.1"
-      },
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/strip-ansi?sponsor=1"
-      }
-    },
-    "node_modules/ox": {
-      "version": "0.6.7",
-      "resolved": "https://registry.npmjs.org/ox/-/ox-0.6.7.tgz",
-      "integrity": "sha512-17Gk/eFsFRAZ80p5eKqv89a57uXjd3NgIf1CaXojATPBuujVc/fQSVhBeAU9JCRB+k7J50WQAyWTxK19T9GgbA==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/wevm"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "@adraffy/ens-normalize": "^1.10.1",
-        "@noble/curves": "^1.6.0",
-        "@noble/hashes": "^1.5.0",
-        "@scure/bip32": "^1.5.0",
-        "@scure/bip39": "^1.4.0",
-        "abitype": "^1.0.6",
-        "eventemitter3": "5.0.1"
-      },
-      "peerDependencies": {
-        "typescript": ">=5.4.0"
-      },
-      "peerDependenciesMeta": {
-        "typescript": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/ox/node_modules/@adraffy/ens-normalize": {
-      "version": "1.11.0",
-      "resolved": "https://registry.npmjs.org/@adraffy/ens-normalize/-/ens-normalize-1.11.0.tgz",
-      "integrity": "sha512-/3DDPKHqqIqxUULp8yP4zODUY1i+2xvVWsv8A79xGWdCAG+8sb0hRh0Rk2QyOJUnnbyPUAZYcpBuRe3nS2OIUg==",
-      "license": "MIT"
-    },
-    "node_modules/p-limit": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",
-      "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
-      "license": "MIT",
-      "dependencies": {
-        "yocto-queue": "^0.1.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/p-locate": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz",
-      "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==",
-      "license": "MIT",
-      "dependencies": {
-        "p-limit": "^3.0.2"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/package-json-from-dist": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/package-json-from-dist/-/package-json-from-dist-1.0.1.tgz",
-      "integrity": "sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==",
-      "license": "BlueOak-1.0.0"
-    },
-    "node_modules/parse-json": {
-      "version": "8.3.0",
-      "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-8.3.0.tgz",
-      "integrity": "sha512-ybiGyvspI+fAoRQbIPRddCcSTV9/LsJbf0e/S85VLowVGzRmokfneg2kwVW/KU5rOXrPSbF1qAKPMgNTqqROQQ==",
-      "license": "MIT",
-      "dependencies": {
-        "@babel/code-frame": "^7.26.2",
-        "index-to-position": "^1.1.0",
-        "type-fest": "^4.39.1"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/parse-ms": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/parse-ms/-/parse-ms-4.0.0.tgz",
-      "integrity": "sha512-TXfryirbmq34y8QBwgqCVLi+8oA3oWx2eAnSn62ITyEhEYaWRlVZ2DvMM9eZbMs/RfxPu/PK/aBLyGj4IrqMHw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/path-exists": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
-      "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/path-key": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
-      "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/path-scurry": {
-      "version": "1.11.1",
-      "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-1.11.1.tgz",
-      "integrity": "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==",
-      "license": "BlueOak-1.0.0",
-      "dependencies": {
-        "lru-cache": "^10.2.0",
-        "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0"
-      },
-      "engines": {
-        "node": ">=16 || 14 >=14.18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
-    "node_modules/pathe": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz",
-      "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==",
-      "license": "MIT"
-    },
-    "node_modules/pathval": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/pathval/-/pathval-2.0.0.tgz",
-      "integrity": "sha512-vE7JKRyES09KiunauX7nd2Q9/L7lhok4smP9RZTDeD4MVs72Dp2qNFVz39Nz5a0FVEW0BJR6C0DYrq6unoziZA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 14.16"
-      }
-    },
-    "node_modules/picocolors": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
-      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
-      "license": "ISC"
-    },
-    "node_modules/picomatch": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
-      "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=8.6"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/jonschlinkert"
-      }
-    },
-    "node_modules/pirates": {
-      "version": "4.0.7",
-      "resolved": "https://registry.npmjs.org/pirates/-/pirates-4.0.7.tgz",
-      "integrity": "sha512-TfySrs/5nm8fQJDcBDuUng3VOUKsd7S+zqvbOTiGXHfxX4wK31ard+hoNuvkicM/2YFzlpDgABOevKSsB4G/FA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 6"
-      }
-    },
-    "node_modules/pkg-types": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/pkg-types/-/pkg-types-1.3.1.tgz",
-      "integrity": "sha512-/Jm5M4RvtBFVkKWRu2BLUTNP8/M2a+UwuAX+ae4770q1qVGtfjG+WTCupoZixokjmHiry8uI+dlY8KXYV5HVVQ==",
-      "license": "MIT",
-      "dependencies": {
-        "confbox": "^0.1.8",
-        "mlly": "^1.7.4",
-        "pathe": "^2.0.1"
-      }
-    },
-    "node_modules/polkadot-api": {
-      "version": "1.12.0",
-      "resolved": "https://registry.npmjs.org/polkadot-api/-/polkadot-api-1.12.0.tgz",
-      "integrity": "sha512-CstKp0ySE3JRVnG4nzl6hDhYLf4Qs/XpVk1xJrypYMqVbTu8FwjBK3l3j4pHhEttVudlEjK2hoVzQ1MdxMLeEg==",
-      "license": "MIT",
-      "dependencies": {
-        "@polkadot-api/cli": "0.13.0",
-        "@polkadot-api/ink-contracts": "0.3.2",
-        "@polkadot-api/json-rpc-provider": "0.0.4",
-        "@polkadot-api/known-chains": "0.7.6",
-        "@polkadot-api/logs-provider": "0.0.6",
-        "@polkadot-api/metadata-builders": "0.12.1",
-        "@polkadot-api/metadata-compatibility": "0.2.3",
-        "@polkadot-api/observable-client": "0.11.0",
-        "@polkadot-api/pjs-signer": "0.6.8",
-        "@polkadot-api/polkadot-sdk-compat": "2.3.2",
-        "@polkadot-api/polkadot-signer": "0.1.6",
-        "@polkadot-api/signer": "0.2.1",
-        "@polkadot-api/sm-provider": "0.1.7",
-        "@polkadot-api/smoldot": "0.3.8",
-        "@polkadot-api/substrate-bindings": "0.13.0",
-        "@polkadot-api/substrate-client": "0.3.0",
-        "@polkadot-api/utils": "0.1.2",
-        "@polkadot-api/ws-provider": "0.4.0",
-        "@rx-state/core": "^0.1.4"
-      },
-      "bin": {
-        "papi": "bin/cli.mjs",
-        "polkadot-api": "bin/cli.mjs"
-      },
-      "peerDependencies": {
-        "rxjs": ">=7.8.0"
-      }
-    },
-    "node_modules/possible-typed-array-names": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/possible-typed-array-names/-/possible-typed-array-names-1.1.0.tgz",
-      "integrity": "sha512-/+5VFTchJDoVj3bhoqi6UeymcD00DAwb1nJwamzPvHEszJ4FpF6SNNbUbOS8yI56qHzdV8eK0qEfOSiodkTdxg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/postcss": {
-      "version": "8.5.3",
-      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.3.tgz",
-      "integrity": "sha512-dle9A3yYxlBSrt8Fu+IpjGT8SY8hN0mlaA6GY8t0P5PjIOZemULz/E2Bnm/2dcUOena75OTNkHI76uZBNUUq3A==",
-      "devOptional": true,
-      "funding": [
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/postcss/"
-        },
-        {
-          "type": "tidelift",
-          "url": "https://tidelift.com/funding/github/npm/postcss"
-        },
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/ai"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "nanoid": "^3.3.8",
-        "picocolors": "^1.1.1",
-        "source-map-js": "^1.2.1"
-      },
-      "engines": {
-        "node": "^10 || ^12 || >=14"
-      }
-    },
-    "node_modules/postcss-load-config": {
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/postcss-load-config/-/postcss-load-config-6.0.1.tgz",
-      "integrity": "sha512-oPtTM4oerL+UXmx+93ytZVN82RrlY/wPUV8IeDxFrzIjXOLF1pN+EmKPLbubvKHT2HC20xXsCAH2Z+CKV6Oz/g==",
-      "funding": [
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/postcss/"
-        },
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/ai"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "lilconfig": "^3.1.1"
-      },
-      "engines": {
-        "node": ">= 18"
-      },
-      "peerDependencies": {
-        "jiti": ">=1.21.0",
-        "postcss": ">=8.0.9",
-        "tsx": "^4.8.1",
-        "yaml": "^2.4.2"
-      },
-      "peerDependenciesMeta": {
-        "jiti": {
-          "optional": true
-        },
-        "postcss": {
-          "optional": true
-        },
-        "tsx": {
-          "optional": true
-        },
-        "yaml": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/prettier": {
-      "version": "3.5.2",
-      "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.5.2.tgz",
-      "integrity": "sha512-lc6npv5PH7hVqozBR7lkBNOGXV9vMwROAPlumdBkX0wTbbzPu/U1hk5yL8p2pt4Xoc+2mkT8t/sow2YrV/M5qg==",
-      "dev": true,
-      "license": "MIT",
-      "bin": {
-        "prettier": "bin/prettier.cjs"
-      },
-      "engines": {
-        "node": ">=14"
-      },
-      "funding": {
-        "url": "https://github.com/prettier/prettier?sponsor=1"
-      }
-    },
-    "node_modules/pretty-ms": {
-      "version": "9.2.0",
-      "resolved": "https://registry.npmjs.org/pretty-ms/-/pretty-ms-9.2.0.tgz",
-      "integrity": "sha512-4yf0QO/sllf/1zbZWYnvWw3NxCQwLXKzIj0G849LSufP15BXKM0rbD2Z3wVnkMfjdn/CB0Dpp444gYAACdsplg==",
-      "license": "MIT",
-      "dependencies": {
-        "parse-ms": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/propagate": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/propagate/-/propagate-2.0.1.tgz",
-      "integrity": "sha512-vGrhOavPSTz4QVNuBNdcNXePNdNMaO1xj9yBeH1ScQPjk/rhg9sSlCXPhMkFuaNNW/syTvYqsnbIJxMBfRbbag==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/punycode": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
-      "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/randombytes": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz",
-      "integrity": "sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==",
-      "license": "MIT",
-      "dependencies": {
-        "safe-buffer": "^5.1.0"
-      }
-    },
-    "node_modules/read-pkg": {
-      "version": "9.0.1",
-      "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-9.0.1.tgz",
-      "integrity": "sha512-9viLL4/n1BJUCT1NXVTdS1jtm80yDEgR5T4yCelII49Mbj0v1rZdKqj7zCiYdbB0CuCgdrvHcNogAKTFPBocFA==",
-      "license": "MIT",
-      "dependencies": {
-        "@types/normalize-package-data": "^2.4.3",
-        "normalize-package-data": "^6.0.0",
-        "parse-json": "^8.0.0",
-        "type-fest": "^4.6.0",
-        "unicorn-magic": "^0.1.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/read-pkg/node_modules/unicorn-magic": {
-      "version": "0.1.0",
-      "resolved": "https://registry.npmjs.org/unicorn-magic/-/unicorn-magic-0.1.0.tgz",
-      "integrity": "sha512-lRfVq8fE8gz6QMBuDM6a+LO3IAzTi05H6gCVaUpir2E1Rwpo4ZUog45KpNXKC/Mn3Yb9UDuHumeFTo9iV/D9FQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/readdirp": {
-      "version": "3.6.0",
-      "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz",
-      "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==",
-      "license": "MIT",
-      "dependencies": {
-        "picomatch": "^2.2.1"
-      },
-      "engines": {
-        "node": ">=8.10.0"
-      }
-    },
-    "node_modules/require-directory": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
-      "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/resolve-from": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz",
-      "integrity": "sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/restore-cursor": {
-      "version": "5.1.0",
-      "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-5.1.0.tgz",
-      "integrity": "sha512-oMA2dcrw6u0YfxJQXm342bFKX/E4sG9rbTzO9ptUcR/e8A33cHuvStiYOwH7fszkZlZ1z/ta9AAoPk2F4qIOHA==",
-      "license": "MIT",
-      "dependencies": {
-        "onetime": "^7.0.0",
-        "signal-exit": "^4.1.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/rollup": {
-      "version": "4.34.8",
-      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.34.8.tgz",
-      "integrity": "sha512-489gTVMzAYdiZHFVA/ig/iYFllCcWFHMvUHI1rpFmkoUtRlQxqh6/yiNqnYibjMZ2b/+FUQwldG+aLsEt6bglQ==",
-      "license": "MIT",
-      "dependencies": {
-        "@types/estree": "1.0.6"
-      },
-      "bin": {
-        "rollup": "dist/bin/rollup"
-      },
-      "engines": {
-        "node": ">=18.0.0",
-        "npm": ">=8.0.0"
-      },
-      "optionalDependencies": {
-        "@rollup/rollup-android-arm-eabi": "4.34.8",
-        "@rollup/rollup-android-arm64": "4.34.8",
-        "@rollup/rollup-darwin-arm64": "4.34.8",
-        "@rollup/rollup-darwin-x64": "4.34.8",
-        "@rollup/rollup-freebsd-arm64": "4.34.8",
-        "@rollup/rollup-freebsd-x64": "4.34.8",
-        "@rollup/rollup-linux-arm-gnueabihf": "4.34.8",
-        "@rollup/rollup-linux-arm-musleabihf": "4.34.8",
-        "@rollup/rollup-linux-arm64-gnu": "4.34.8",
-        "@rollup/rollup-linux-arm64-musl": "4.34.8",
-        "@rollup/rollup-linux-loongarch64-gnu": "4.34.8",
-        "@rollup/rollup-linux-powerpc64le-gnu": "4.34.8",
-        "@rollup/rollup-linux-riscv64-gnu": "4.34.8",
-        "@rollup/rollup-linux-s390x-gnu": "4.34.8",
-        "@rollup/rollup-linux-x64-gnu": "4.34.8",
-        "@rollup/rollup-linux-x64-musl": "4.34.8",
-        "@rollup/rollup-win32-arm64-msvc": "4.34.8",
-        "@rollup/rollup-win32-ia32-msvc": "4.34.8",
-        "@rollup/rollup-win32-x64-msvc": "4.34.8",
-        "fsevents": "~2.3.2"
-      }
-    },
-    "node_modules/rxjs": {
-      "version": "7.8.2",
-      "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-7.8.2.tgz",
-      "integrity": "sha512-dhKf903U/PQZY6boNNtAGdWbG85WAbjT/1xYoZIC7FAY0yWapOBQVsVrDl58W86//e1VpMNBtRV4MaXfdMySFA==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "tslib": "^2.1.0"
-      }
-    },
-    "node_modules/safe-buffer": {
-      "version": "5.2.1",
-      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
-      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/feross"
-        },
-        {
-          "type": "patreon",
-          "url": "https://www.patreon.com/feross"
-        },
-        {
-          "type": "consulting",
-          "url": "https://feross.org/support"
-        }
-      ],
-      "license": "MIT"
-    },
-    "node_modules/safe-regex-test": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/safe-regex-test/-/safe-regex-test-1.1.0.tgz",
-      "integrity": "sha512-x/+Cz4YrimQxQccJf5mKEbIa1NzeCRNI5Ecl/ekmlYaampdNLPalVyIcCZNNH3MvmqBugV5TMYZXv0ljslUlaw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.2",
-        "es-errors": "^1.3.0",
-        "is-regex": "^1.2.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/scale-ts": {
-      "version": "1.6.1",
-      "resolved": "https://registry.npmjs.org/scale-ts/-/scale-ts-1.6.1.tgz",
-      "integrity": "sha512-PBMc2AWc6wSEqJYBDPcyCLUj9/tMKnLX70jLOSndMtcUoLQucP/DM0vnQo1wJAYjTrQiq8iG9rD0q6wFzgjH7g==",
-      "license": "MIT"
-    },
-    "node_modules/semver": {
-      "version": "7.7.2",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.2.tgz",
-      "integrity": "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==",
-      "license": "ISC",
-      "bin": {
-        "semver": "bin/semver.js"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/serialize-javascript": {
-      "version": "6.0.2",
-      "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.2.tgz",
-      "integrity": "sha512-Saa1xPByTTq2gdeFZYLLo+RFE35NHZkAbqZeWNd3BpzppeVisAqpDjcp8dyf6uIvEqJRd46jemmyA4iFIeVk8g==",
-      "license": "BSD-3-Clause",
-      "dependencies": {
-        "randombytes": "^2.1.0"
-      }
-    },
-    "node_modules/set-function-length": {
-      "version": "1.2.2",
-      "resolved": "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.2.tgz",
-      "integrity": "sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "define-data-property": "^1.1.4",
-        "es-errors": "^1.3.0",
-        "function-bind": "^1.1.2",
-        "get-intrinsic": "^1.2.4",
-        "gopd": "^1.0.1",
-        "has-property-descriptors": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/shebang-command": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
-      "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
-      "license": "MIT",
-      "dependencies": {
-        "shebang-regex": "^3.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/shebang-regex": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
-      "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/signal-exit": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz",
-      "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==",
-      "license": "ISC",
-      "engines": {
-        "node": ">=14"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
-    "node_modules/smoldot": {
-      "version": "2.0.26",
-      "resolved": "https://registry.npmjs.org/smoldot/-/smoldot-2.0.26.tgz",
-      "integrity": "sha512-F+qYmH4z2s2FK+CxGj8moYcd1ekSIKH8ywkdqlOz88Dat35iB1DIYL11aILN46YSGMzQW/lbJNS307zBSDN5Ig==",
-      "license": "GPL-3.0-or-later WITH Classpath-exception-2.0",
-      "optional": true,
-      "dependencies": {
-        "ws": "^8.8.1"
-      }
-    },
-    "node_modules/sort-keys": {
-      "version": "5.1.0",
-      "resolved": "https://registry.npmjs.org/sort-keys/-/sort-keys-5.1.0.tgz",
-      "integrity": "sha512-aSbHV0DaBcr7u0PVHXzM6NbZNAtrr9sF6+Qfs9UUVG7Ll3jQ6hHi8F/xqIIcn2rvIVbr0v/2zyjSdwSV47AgLQ==",
-      "license": "MIT",
-      "dependencies": {
-        "is-plain-obj": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/source-map": {
-      "version": "0.8.0-beta.0",
-      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.8.0-beta.0.tgz",
-      "integrity": "sha512-2ymg6oRBpebeZi9UUNsgQ89bhx01TcTkmNTGnNO88imTmbSgy4nfujrgVEFKWpMTEGA11EDkTt7mqObTPdigIA==",
-      "license": "BSD-3-Clause",
-      "dependencies": {
-        "whatwg-url": "^7.0.0"
-      },
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/source-map-js": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
-      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
-      "devOptional": true,
-      "license": "BSD-3-Clause",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/spdx-correct": {
-      "version": "3.2.0",
-      "resolved": "https://registry.npmjs.org/spdx-correct/-/spdx-correct-3.2.0.tgz",
-      "integrity": "sha512-kN9dJbvnySHULIluDHy32WHRUu3Og7B9sbY7tsFLctQkIqnMh3hErYgdMjTYuqmcXX+lK5T1lnUt3G7zNswmZA==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "spdx-expression-parse": "^3.0.0",
-        "spdx-license-ids": "^3.0.0"
-      }
-    },
-    "node_modules/spdx-exceptions": {
-      "version": "2.5.0",
-      "resolved": "https://registry.npmjs.org/spdx-exceptions/-/spdx-exceptions-2.5.0.tgz",
-      "integrity": "sha512-PiU42r+xO4UbUS1buo3LPJkjlO7430Xn5SVAhdpzzsPHsjbYVflnnFdATgabnLude+Cqu25p6N+g2lw/PFsa4w==",
-      "license": "CC-BY-3.0"
-    },
-    "node_modules/spdx-expression-parse": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-3.0.1.tgz",
-      "integrity": "sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==",
-      "license": "MIT",
-      "dependencies": {
-        "spdx-exceptions": "^2.1.0",
-        "spdx-license-ids": "^3.0.0"
-      }
-    },
-    "node_modules/spdx-license-ids": {
-      "version": "3.0.21",
-      "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.21.tgz",
-      "integrity": "sha512-Bvg/8F5XephndSK3JffaRqdT+gyhfqIPwDHpX80tJrF8QQRYMo8sNMeaZ2Dp5+jhwKnUmIOyFFQfHRkjJm5nXg==",
-      "license": "CC0-1.0"
-    },
-    "node_modules/stdin-discarder": {
-      "version": "0.2.2",
-      "resolved": "https://registry.npmjs.org/stdin-discarder/-/stdin-discarder-0.2.2.tgz",
-      "integrity": "sha512-UhDfHmA92YAlNnCfhmq0VeNL5bDbiZGg7sZ2IvPsXubGkiNa9EC+tUTsjBRsYUAz87btI6/1wf4XoVvQ3uRnmQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/string-width": {
-      "version": "4.2.3",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
-      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
-      "license": "MIT",
-      "dependencies": {
-        "emoji-regex": "^8.0.0",
-        "is-fullwidth-code-point": "^3.0.0",
-        "strip-ansi": "^6.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/string-width-cjs": {
-      "name": "string-width",
-      "version": "4.2.3",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
-      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
-      "license": "MIT",
-      "dependencies": {
-        "emoji-regex": "^8.0.0",
-        "is-fullwidth-code-point": "^3.0.0",
-        "strip-ansi": "^6.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/strip-ansi": {
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
-      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
-      "license": "MIT",
-      "dependencies": {
-        "ansi-regex": "^5.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/strip-ansi-cjs": {
-      "name": "strip-ansi",
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
-      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
-      "license": "MIT",
-      "dependencies": {
-        "ansi-regex": "^5.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/strip-final-newline": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-4.0.0.tgz",
-      "integrity": "sha512-aulFJcD6YK8V1G7iRB5tigAP4TsHBZZrOV8pjV++zdUwmeV8uzbY7yn6h9MswN62adStNZFuCIx4haBnRuMDaw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/strip-json-comments": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
-      "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/sucrase": {
-      "version": "3.35.0",
-      "resolved": "https://registry.npmjs.org/sucrase/-/sucrase-3.35.0.tgz",
-      "integrity": "sha512-8EbVDiu9iN/nESwxeSxDKe0dunta1GOlHufmSSXxMD2z2/tMZpDMpvXQGsc+ajGo8y2uYUmixaSRUc/QPoQ0GA==",
-      "license": "MIT",
-      "dependencies": {
-        "@jridgewell/gen-mapping": "^0.3.2",
-        "commander": "^4.0.0",
-        "glob": "^10.3.10",
-        "lines-and-columns": "^1.1.6",
-        "mz": "^2.7.0",
-        "pirates": "^4.0.1",
-        "ts-interface-checker": "^0.1.9"
-      },
-      "bin": {
-        "sucrase": "bin/sucrase",
-        "sucrase-node": "bin/sucrase-node"
-      },
-      "engines": {
-        "node": ">=16 || 14 >=14.17"
-      }
-    },
-    "node_modules/sucrase/node_modules/commander": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/commander/-/commander-4.1.1.tgz",
-      "integrity": "sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 6"
-      }
-    },
-    "node_modules/supports-color": {
-      "version": "8.1.1",
-      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz",
-      "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==",
-      "license": "MIT",
-      "dependencies": {
-        "has-flag": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/supports-color?sponsor=1"
-      }
-    },
-    "node_modules/thenify": {
-      "version": "3.3.1",
-      "resolved": "https://registry.npmjs.org/thenify/-/thenify-3.3.1.tgz",
-      "integrity": "sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw==",
-      "license": "MIT",
-      "dependencies": {
-        "any-promise": "^1.0.0"
-      }
-    },
-    "node_modules/thenify-all": {
-      "version": "1.6.0",
-      "resolved": "https://registry.npmjs.org/thenify-all/-/thenify-all-1.6.0.tgz",
-      "integrity": "sha512-RNxQH/qI8/t3thXJDwcstUO4zeqo64+Uy/+sNVRBx4Xn2OX+OZ9oP+iJnNFqplFra2ZUVeKCSa2oVWi3T4uVmA==",
-      "license": "MIT",
-      "dependencies": {
-        "thenify": ">= 3.1.0 < 4"
-      },
-      "engines": {
-        "node": ">=0.8"
-      }
-    },
-    "node_modules/tinyexec": {
-      "version": "0.3.2",
-      "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-0.3.2.tgz",
-      "integrity": "sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==",
-      "license": "MIT"
-    },
-    "node_modules/tinyglobby": {
-      "version": "0.2.14",
-      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.14.tgz",
-      "integrity": "sha512-tX5e7OM1HnYr2+a2C/4V0htOcSQcoSTH9KgJnVvNm5zm/cyEWKJ7j7YutsH9CxMdtOkkLFy2AHrMci9IM8IPZQ==",
-      "license": "MIT",
-      "dependencies": {
-        "fdir": "^6.4.4",
-        "picomatch": "^4.0.2"
-      },
-      "engines": {
-        "node": ">=12.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/SuperchupuDev"
-      }
-    },
-    "node_modules/tinyglobby/node_modules/fdir": {
-      "version": "6.4.4",
-      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.4.4.tgz",
-      "integrity": "sha512-1NZP+GK4GfuAv3PqKvxQRDMjdSRZjnkq7KfhlNrCNNlZ0ygQFpebfrnfnq/W7fpUnAv9aGWmY1zKx7FYL3gwhg==",
-      "license": "MIT",
-      "peerDependencies": {
-        "picomatch": "^3 || ^4"
-      },
-      "peerDependenciesMeta": {
-        "picomatch": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/tinyglobby/node_modules/picomatch": {
-      "version": "4.0.2",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.2.tgz",
-      "integrity": "sha512-M7BAV6Rlcy5u+m6oPhAPFgJTzAioX/6B0DxyvDlo9l8+T3nLKbrczg2WLUyzd45L8RqfUMyGPzekbMvX2Ldkwg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/jonschlinkert"
-      }
-    },
-    "node_modules/to-regex-range": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
-      "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
-      "license": "MIT",
-      "dependencies": {
-        "is-number": "^7.0.0"
-      },
-      "engines": {
-        "node": ">=8.0"
-      }
-    },
-    "node_modules/tr46": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/tr46/-/tr46-1.0.1.tgz",
-      "integrity": "sha512-dTpowEjclQ7Kgx5SdBkqRzVhERQXov8/l9Ft9dVM9fmg0W0KQSVaXX9T4i6twCPNtYiZM53lpSSUAwJbFPOHxA==",
-      "license": "MIT",
-      "dependencies": {
-        "punycode": "^2.1.0"
-      }
-    },
-    "node_modules/tree-kill": {
-      "version": "1.2.2",
-      "resolved": "https://registry.npmjs.org/tree-kill/-/tree-kill-1.2.2.tgz",
-      "integrity": "sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A==",
-      "license": "MIT",
-      "bin": {
-        "tree-kill": "cli.js"
-      }
-    },
-    "node_modules/ts-interface-checker": {
-      "version": "0.1.13",
-      "resolved": "https://registry.npmjs.org/ts-interface-checker/-/ts-interface-checker-0.1.13.tgz",
-      "integrity": "sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA==",
-      "license": "Apache-2.0"
-    },
-    "node_modules/ts-node": {
-      "version": "10.9.2",
-      "resolved": "https://registry.npmjs.org/ts-node/-/ts-node-10.9.2.tgz",
-      "integrity": "sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@cspotcode/source-map-support": "^0.8.0",
-        "@tsconfig/node10": "^1.0.7",
-        "@tsconfig/node12": "^1.0.7",
-        "@tsconfig/node14": "^1.0.0",
-        "@tsconfig/node16": "^1.0.2",
-        "acorn": "^8.4.1",
-        "acorn-walk": "^8.1.1",
-        "arg": "^4.1.0",
-        "create-require": "^1.1.0",
-        "diff": "^4.0.1",
-        "make-error": "^1.1.1",
-        "v8-compile-cache-lib": "^3.0.1",
-        "yn": "3.1.1"
-      },
-      "bin": {
-        "ts-node": "dist/bin.js",
-        "ts-node-cwd": "dist/bin-cwd.js",
-        "ts-node-esm": "dist/bin-esm.js",
-        "ts-node-script": "dist/bin-script.js",
-        "ts-node-transpile-only": "dist/bin-transpile.js",
-        "ts-script": "dist/bin-script-deprecated.js"
-      },
-      "peerDependencies": {
-        "@swc/core": ">=1.2.50",
-        "@swc/wasm": ">=1.2.50",
-        "@types/node": "*",
-        "typescript": ">=2.7"
-      },
-      "peerDependenciesMeta": {
-        "@swc/core": {
-          "optional": true
-        },
-        "@swc/wasm": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/tsc-prog": {
-      "version": "2.3.0",
-      "resolved": "https://registry.npmjs.org/tsc-prog/-/tsc-prog-2.3.0.tgz",
-      "integrity": "sha512-ycET2d75EgcX7y8EmG4KiZkLAwUzbY4xRhA6NU0uVbHkY4ZjrAAuzTMxXI85kOwATqPnBI5C/7y7rlpY0xdqHA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "peerDependencies": {
-        "typescript": ">=4"
-      }
-    },
-    "node_modules/tslib": {
-      "version": "2.8.1",
-      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
-      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
-      "license": "0BSD"
-    },
-    "node_modules/tsup": {
-      "version": "8.5.0",
-      "resolved": "https://registry.npmjs.org/tsup/-/tsup-8.5.0.tgz",
-      "integrity": "sha512-VmBp77lWNQq6PfuMqCHD3xWl22vEoWsKajkF8t+yMBawlUS8JzEI+vOVMeuNZIuMML8qXRizFKi9oD5glKQVcQ==",
-      "license": "MIT",
-      "dependencies": {
-        "bundle-require": "^5.1.0",
-        "cac": "^6.7.14",
-        "chokidar": "^4.0.3",
-        "consola": "^3.4.0",
-        "debug": "^4.4.0",
-        "esbuild": "^0.25.0",
-        "fix-dts-default-cjs-exports": "^1.0.0",
-        "joycon": "^3.1.1",
-        "picocolors": "^1.1.1",
-        "postcss-load-config": "^6.0.1",
-        "resolve-from": "^5.0.0",
-        "rollup": "^4.34.8",
-        "source-map": "0.8.0-beta.0",
-        "sucrase": "^3.35.0",
-        "tinyexec": "^0.3.2",
-        "tinyglobby": "^0.2.11",
-        "tree-kill": "^1.2.2"
-      },
-      "bin": {
-        "tsup": "dist/cli-default.js",
-        "tsup-node": "dist/cli-node.js"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "@microsoft/api-extractor": "^7.36.0",
-        "@swc/core": "^1",
-        "postcss": "^8.4.12",
-        "typescript": ">=4.5.0"
-      },
-      "peerDependenciesMeta": {
-        "@microsoft/api-extractor": {
-          "optional": true
-        },
-        "@swc/core": {
-          "optional": true
-        },
-        "postcss": {
-          "optional": true
-        },
-        "typescript": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/tsup/node_modules/chokidar": {
-      "version": "4.0.3",
-      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-4.0.3.tgz",
-      "integrity": "sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA==",
-      "license": "MIT",
-      "dependencies": {
-        "readdirp": "^4.0.1"
-      },
-      "engines": {
-        "node": ">= 14.16.0"
-      },
-      "funding": {
-        "url": "https://paulmillr.com/funding/"
-      }
-    },
-    "node_modules/tsup/node_modules/readdirp": {
-      "version": "4.1.2",
-      "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-4.1.2.tgz",
-      "integrity": "sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 14.18.0"
-      },
-      "funding": {
-        "type": "individual",
-        "url": "https://paulmillr.com/funding/"
-      }
-    },
-    "node_modules/type-fest": {
-      "version": "4.41.0",
-      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-4.41.0.tgz",
-      "integrity": "sha512-TeTSQ6H5YHvpqVwBRcnLDCBnDOHWYu7IvGbHT6N8AOymcr9PJGjc1GTtiWZTYg0NCgYwvnYWEkVChQAr9bjfwA==",
-      "license": "(MIT OR CC0-1.0)",
-      "engines": {
-        "node": ">=16"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/typescript": {
-      "version": "5.8.3",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.8.3.tgz",
-      "integrity": "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ==",
-      "license": "Apache-2.0",
-      "bin": {
-        "tsc": "bin/tsc",
-        "tsserver": "bin/tsserver"
-      },
-      "engines": {
-        "node": ">=14.17"
-      }
-    },
-    "node_modules/ufo": {
-      "version": "1.6.1",
-      "resolved": "https://registry.npmjs.org/ufo/-/ufo-1.6.1.tgz",
-      "integrity": "sha512-9a4/uxlTWJ4+a5i0ooc1rU7C7YOw3wT+UGqdeNNHWnOF9qcMBgLRS+4IYUqbczewFx4mLEig6gawh7X6mFlEkA==",
-      "license": "MIT"
-    },
-    "node_modules/undici-types": {
-      "version": "6.21.0",
-      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
-      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
-      "license": "MIT"
-    },
-    "node_modules/unicorn-magic": {
-      "version": "0.3.0",
-      "resolved": "https://registry.npmjs.org/unicorn-magic/-/unicorn-magic-0.3.0.tgz",
-      "integrity": "sha512-+QBBXBCvifc56fsbuxZQ6Sic3wqqc3WWaqxs58gvJrcOuN83HGTCwz3oS5phzU9LthRNE9VrJCFCLUgHeeFnfA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/util": {
-      "version": "0.12.5",
-      "resolved": "https://registry.npmjs.org/util/-/util-0.12.5.tgz",
-      "integrity": "sha512-kZf/K6hEIrWHI6XqOFUiiMa+79wE/D8Q+NCNAWclkyg3b4d2k7s0QGepNjiABc+aR3N1PAyHL7p6UcLY6LmrnA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "inherits": "^2.0.3",
-        "is-arguments": "^1.0.4",
-        "is-generator-function": "^1.0.7",
-        "is-typed-array": "^1.1.3",
-        "which-typed-array": "^1.1.2"
-      }
-    },
-    "node_modules/v8-compile-cache-lib": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/v8-compile-cache-lib/-/v8-compile-cache-lib-3.0.1.tgz",
-      "integrity": "sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/validate-npm-package-license": {
-      "version": "3.0.4",
-      "resolved": "https://registry.npmjs.org/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz",
-      "integrity": "sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "spdx-correct": "^3.0.0",
-        "spdx-expression-parse": "^3.0.0"
-      }
-    },
-    "node_modules/viem": {
-      "version": "2.23.4",
-      "resolved": "https://registry.npmjs.org/viem/-/viem-2.23.4.tgz",
-      "integrity": "sha512-UQquuolKlS1w5H5e0Fd1KKoUlIPJryIEBzY5AUhGyV1ka+9O6+3uYVhUzj6RbvGK0PtsMKn2ddwPZFwjNDVU/A==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/wevm"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "@noble/curves": "1.8.1",
-        "@noble/hashes": "1.7.1",
-        "@scure/bip32": "1.6.2",
-        "@scure/bip39": "1.5.4",
-        "abitype": "1.0.8",
-        "isows": "1.0.6",
-        "ox": "0.6.7",
-        "ws": "8.18.0"
-      },
-      "peerDependencies": {
-        "typescript": ">=5.0.4"
-      },
-      "peerDependenciesMeta": {
-        "typescript": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/viem/node_modules/ws": {
-      "version": "8.18.0",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.0.tgz",
-      "integrity": "sha512-8VbfWfHLbbwu3+N6OKsOMpBdT4kXPDDB9cJk2bJ6mh9ucxdlnNvH1e+roYkKmN9Nxw2yjz7VzeO9oOz2zJ04Pw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=10.0.0"
-      },
-      "peerDependencies": {
-        "bufferutil": "^4.0.1",
-        "utf-8-validate": ">=5.0.2"
-      },
-      "peerDependenciesMeta": {
-        "bufferutil": {
-          "optional": true
-        },
-        "utf-8-validate": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/vite": {
-      "version": "5.4.14",
-      "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.14.tgz",
-      "integrity": "sha512-EK5cY7Q1D8JNhSaPKVK4pwBFvaTmZxEnoKXLG/U9gmdDcihQGNzFlgIvaxezFR4glP1LsuiedwMBqCXH3wZccA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "esbuild": "^0.21.3",
-        "postcss": "^8.4.43",
-        "rollup": "^4.20.0"
-      },
-      "bin": {
-        "vite": "bin/vite.js"
-      },
-      "engines": {
-        "node": "^18.0.0 || >=20.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/vitejs/vite?sponsor=1"
-      },
-      "optionalDependencies": {
-        "fsevents": "~2.3.3"
-      },
-      "peerDependencies": {
-        "@types/node": "^18.0.0 || >=20.0.0",
-        "less": "*",
-        "lightningcss": "^1.21.0",
-        "sass": "*",
-        "sass-embedded": "*",
-        "stylus": "*",
-        "sugarss": "*",
-        "terser": "^5.4.0"
-      },
-      "peerDependenciesMeta": {
-        "@types/node": {
-          "optional": true
-        },
-        "less": {
-          "optional": true
-        },
-        "lightningcss": {
-          "optional": true
-        },
-        "sass": {
-          "optional": true
-        },
-        "sass-embedded": {
-          "optional": true
-        },
-        "stylus": {
-          "optional": true
-        },
-        "sugarss": {
-          "optional": true
-        },
-        "terser": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/vite/node_modules/@esbuild/aix-ppc64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz",
-      "integrity": "sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==",
-      "cpu": [
-        "ppc64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "aix"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite/node_modules/@esbuild/android-arm": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.21.5.tgz",
-      "integrity": "sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite/node_modules/@esbuild/android-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz",
-      "integrity": "sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite/node_modules/@esbuild/android-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.21.5.tgz",
-      "integrity": "sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite/node_modules/@esbuild/darwin-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz",
-      "integrity": "sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite/node_modules/@esbuild/darwin-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz",
-      "integrity": "sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite/node_modules/@esbuild/freebsd-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz",
-      "integrity": "sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite/node_modules/@esbuild/freebsd-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz",
-      "integrity": "sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite/node_modules/@esbuild/linux-arm": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz",
-      "integrity": "sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite/node_modules/@esbuild/linux-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz",
-      "integrity": "sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite/node_modules/@esbuild/linux-ia32": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz",
-      "integrity": "sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==",
-      "cpu": [
-        "ia32"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite/node_modules/@esbuild/linux-loong64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz",
-      "integrity": "sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==",
-      "cpu": [
-        "loong64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite/node_modules/@esbuild/linux-mips64el": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz",
-      "integrity": "sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==",
-      "cpu": [
-        "mips64el"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite/node_modules/@esbuild/linux-ppc64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz",
-      "integrity": "sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==",
-      "cpu": [
-        "ppc64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite/node_modules/@esbuild/linux-riscv64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz",
-      "integrity": "sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==",
-      "cpu": [
-        "riscv64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite/node_modules/@esbuild/linux-s390x": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz",
-      "integrity": "sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==",
-      "cpu": [
-        "s390x"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite/node_modules/@esbuild/linux-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz",
-      "integrity": "sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite/node_modules/@esbuild/netbsd-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz",
-      "integrity": "sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "netbsd"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite/node_modules/@esbuild/openbsd-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz",
-      "integrity": "sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "openbsd"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite/node_modules/@esbuild/sunos-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz",
-      "integrity": "sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "sunos"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite/node_modules/@esbuild/win32-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz",
-      "integrity": "sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite/node_modules/@esbuild/win32-ia32": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz",
-      "integrity": "sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==",
-      "cpu": [
-        "ia32"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite/node_modules/@esbuild/win32-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz",
-      "integrity": "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vite/node_modules/esbuild": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz",
-      "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==",
-      "dev": true,
-      "hasInstallScript": true,
-      "license": "MIT",
-      "bin": {
-        "esbuild": "bin/esbuild"
-      },
-      "engines": {
-        "node": ">=12"
-      },
-      "optionalDependencies": {
-        "@esbuild/aix-ppc64": "0.21.5",
-        "@esbuild/android-arm": "0.21.5",
-        "@esbuild/android-arm64": "0.21.5",
-        "@esbuild/android-x64": "0.21.5",
-        "@esbuild/darwin-arm64": "0.21.5",
-        "@esbuild/darwin-x64": "0.21.5",
-        "@esbuild/freebsd-arm64": "0.21.5",
-        "@esbuild/freebsd-x64": "0.21.5",
-        "@esbuild/linux-arm": "0.21.5",
-        "@esbuild/linux-arm64": "0.21.5",
-        "@esbuild/linux-ia32": "0.21.5",
-        "@esbuild/linux-loong64": "0.21.5",
-        "@esbuild/linux-mips64el": "0.21.5",
-        "@esbuild/linux-ppc64": "0.21.5",
-        "@esbuild/linux-riscv64": "0.21.5",
-        "@esbuild/linux-s390x": "0.21.5",
-        "@esbuild/linux-x64": "0.21.5",
-        "@esbuild/netbsd-x64": "0.21.5",
-        "@esbuild/openbsd-x64": "0.21.5",
-        "@esbuild/sunos-x64": "0.21.5",
-        "@esbuild/win32-arm64": "0.21.5",
-        "@esbuild/win32-ia32": "0.21.5",
-        "@esbuild/win32-x64": "0.21.5"
-      }
-    },
-    "node_modules/web-streams-polyfill": {
-      "version": "3.3.3",
-      "resolved": "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-3.3.3.tgz",
-      "integrity": "sha512-d2JWLCivmZYTSIoge9MsgFCZrt571BikcWGYkjC1khllbTeDlGqZ2D8vD8E/lJa8WGWbb7Plm8/XJYV7IJHZZw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/webidl-conversions": {
-      "version": "4.0.2",
-      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-4.0.2.tgz",
-      "integrity": "sha512-YQ+BmxuTgd6UXZW3+ICGfyqRyHXVlD5GtQr5+qjiNW7bF0cqrzX500HVXPBOvgXb5YnzDd+h0zqyv61KUD7+Sg==",
-      "license": "BSD-2-Clause"
-    },
-    "node_modules/whatwg-url": {
-      "version": "7.1.0",
-      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-7.1.0.tgz",
-      "integrity": "sha512-WUu7Rg1DroM7oQvGWfOiAK21n74Gg+T4elXEQYkOhtyLeWiJFoOGLXPKI/9gzIie9CtwVLm8wtw6YJdKyxSjeg==",
-      "license": "MIT",
-      "dependencies": {
-        "lodash.sortby": "^4.7.0",
-        "tr46": "^1.0.1",
-        "webidl-conversions": "^4.0.2"
-      }
-    },
-    "node_modules/which": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
-      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
-      "license": "ISC",
-      "dependencies": {
-        "isexe": "^2.0.0"
-      },
-      "bin": {
-        "node-which": "bin/node-which"
-      },
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/which-typed-array": {
-      "version": "1.1.18",
-      "resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.18.tgz",
-      "integrity": "sha512-qEcY+KJYlWyLH9vNbsr6/5j59AXk5ni5aakf8ldzBvGde6Iz4sxZGkJyWSAueTG7QhOvNRYb1lDdFmL5Td0QKA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "available-typed-arrays": "^1.0.7",
-        "call-bind": "^1.0.8",
-        "call-bound": "^1.0.3",
-        "for-each": "^0.3.3",
-        "gopd": "^1.2.0",
-        "has-tostringtag": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/workerpool": {
-      "version": "6.5.1",
-      "resolved": "https://registry.npmjs.org/workerpool/-/workerpool-6.5.1.tgz",
-      "integrity": "sha512-Fs4dNYcsdpYSAfVxhnl1L5zTksjvOJxtC5hzMNl+1t9B8hTJTdKDyZ5ju7ztgPy+ft9tBFXoOlDNiOT9WUXZlA==",
-      "license": "Apache-2.0"
-    },
-    "node_modules/wrap-ansi": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
-      "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
-      "license": "MIT",
-      "dependencies": {
-        "ansi-styles": "^4.0.0",
-        "string-width": "^4.1.0",
-        "strip-ansi": "^6.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
-      }
-    },
-    "node_modules/wrap-ansi-cjs": {
-      "name": "wrap-ansi",
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
-      "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
-      "license": "MIT",
-      "dependencies": {
-        "ansi-styles": "^4.0.0",
-        "string-width": "^4.1.0",
-        "strip-ansi": "^6.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
-      }
-    },
-    "node_modules/write-file-atomic": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/write-file-atomic/-/write-file-atomic-5.0.1.tgz",
-      "integrity": "sha512-+QU2zd6OTD8XWIJCbffaiQeH9U73qIqafo1x6V1snCWYGJf6cVE0cDR4D8xRzcEnfI21IFrUPzPGtcPf8AC+Rw==",
-      "license": "ISC",
-      "dependencies": {
-        "imurmurhash": "^0.1.4",
-        "signal-exit": "^4.0.1"
-      },
-      "engines": {
-        "node": "^14.17.0 || ^16.13.0 || >=18.0.0"
-      }
-    },
-    "node_modules/write-json-file": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/write-json-file/-/write-json-file-6.0.0.tgz",
-      "integrity": "sha512-MNHcU3f9WxnNyR6MxsYSj64Jz0+dwIpisWKWq9gqLj/GwmA9INg3BZ3vt70/HB3GEwrnDQWr4RPrywnhNzmUFA==",
-      "license": "MIT",
-      "dependencies": {
-        "detect-indent": "^7.0.1",
-        "is-plain-obj": "^4.1.0",
-        "sort-keys": "^5.0.0",
-        "write-file-atomic": "^5.0.1"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/write-package": {
-      "version": "7.1.0",
-      "resolved": "https://registry.npmjs.org/write-package/-/write-package-7.1.0.tgz",
-      "integrity": "sha512-DqUx8GI3r9BFWwU2DPKddL1E7xWfbFED82mLVhGXKlFEPe8IkBftzO7WfNwHtk7oGDHDeuH/o8VMpzzfMwmLUA==",
-      "license": "MIT",
-      "dependencies": {
-        "deepmerge-ts": "^7.1.0",
-        "read-pkg": "^9.0.1",
-        "sort-keys": "^5.0.0",
-        "type-fest": "^4.23.0",
-        "write-json-file": "^6.0.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/ws": {
-      "version": "8.18.2",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.2.tgz",
-      "integrity": "sha512-DMricUmwGZUVr++AEAe2uiVM7UoO9MAVZMDu05UQOaUII0lp+zOzLLU4Xqh/JvTqklB1T4uELaaPBKyjE1r4fQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=10.0.0"
-      },
-      "peerDependencies": {
-        "bufferutil": "^4.0.1",
-        "utf-8-validate": ">=5.0.2"
-      },
-      "peerDependenciesMeta": {
-        "bufferutil": {
-          "optional": true
-        },
-        "utf-8-validate": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/y18n": {
-      "version": "5.0.8",
-      "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
-      "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==",
-      "license": "ISC",
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/yargs": {
-      "version": "17.7.2",
-      "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz",
-      "integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==",
-      "license": "MIT",
-      "dependencies": {
-        "cliui": "^8.0.1",
-        "escalade": "^3.1.1",
-        "get-caller-file": "^2.0.5",
-        "require-directory": "^2.1.1",
-        "string-width": "^4.2.3",
-        "y18n": "^5.0.5",
-        "yargs-parser": "^21.1.1"
-      },
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/yargs-parser": {
-      "version": "21.1.1",
-      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz",
-      "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==",
-      "license": "ISC",
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/yargs-unparser": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/yargs-unparser/-/yargs-unparser-2.0.0.tgz",
-      "integrity": "sha512-7pRTIA9Qc1caZ0bZ6RYRGbHJthJWuakf+WmHK0rVeLkNrrGhfoabBNdue6kdINI6r4if7ocq9aD/n7xwKOdzOA==",
-      "license": "MIT",
-      "dependencies": {
-        "camelcase": "^6.0.0",
-        "decamelize": "^4.0.0",
-        "flat": "^5.0.2",
-        "is-plain-obj": "^2.1.0"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/yargs-unparser/node_modules/is-plain-obj": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-2.1.0.tgz",
-      "integrity": "sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/yn": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/yn/-/yn-3.1.1.tgz",
-      "integrity": "sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/yocto-queue": {
-      "version": "0.1.0",
-      "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz",
-      "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/yoctocolors": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/yoctocolors/-/yoctocolors-2.1.1.tgz",
-      "integrity": "sha512-GQHQqAopRhwU8Kt1DDM8NjibDXHC8eoh1erhGAJPEyveY9qqVeXvVikNKrDz69sHowPMorbPUrH/mx8c50eiBQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    }
-  }
-}
diff --git a/evm-tests/yarn.lock b/evm-tests/yarn.lock
new file mode 100644
index 0000000000..043a97f2ef
--- /dev/null
+++ b/evm-tests/yarn.lock
@@ -0,0 +1,3225 @@
+# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+# yarn lockfile v1
+
+
+"@adraffy/ens-normalize@1.10.1":
+  version "1.10.1"
+  resolved "https://registry.npmjs.org/@adraffy/ens-normalize/-/ens-normalize-1.10.1.tgz"
+  integrity sha512-96Z2IP3mYmF1Xg2cDm8f1gWGf/HUVedQ3FMifV4kG/PQ4yEP51xDtRAEfhVNt5f/uzpNkZHwWQuUcu6D6K+Ekw==
+
+"@adraffy/ens-normalize@^1.10.1":
+  version "1.11.0"
+  resolved "https://registry.npmjs.org/@adraffy/ens-normalize/-/ens-normalize-1.11.0.tgz"
+  integrity sha512-/3DDPKHqqIqxUULp8yP4zODUY1i+2xvVWsv8A79xGWdCAG+8sb0hRh0Rk2QyOJUnnbyPUAZYcpBuRe3nS2OIUg==
+
+"@babel/code-frame@^7.26.2":
+  version "7.27.1"
+  resolved "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.27.1.tgz"
+  integrity sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==
+  dependencies:
+    "@babel/helper-validator-identifier" "^7.27.1"
+    js-tokens "^4.0.0"
+    picocolors "^1.1.1"
+
+"@babel/helper-validator-identifier@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.27.1.tgz"
+  integrity sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow==
+
+"@commander-js/extra-typings@^13.1.0":
+  version "13.1.0"
+  resolved "https://registry.npmjs.org/@commander-js/extra-typings/-/extra-typings-13.1.0.tgz"
+  integrity sha512-q5P52BYb1hwVWE6dtID7VvuJWrlfbCv4klj7BjUUOqMz4jbSZD4C9fJ9lRjL2jnBGTg+gDDlaXN51rkWcLk4fg==
+
+"@cspotcode/source-map-support@^0.8.0":
+  version "0.8.1"
+  resolved "https://registry.npmjs.org/@cspotcode/source-map-support/-/source-map-support-0.8.1.tgz"
+  integrity sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==
+  dependencies:
+    "@jridgewell/trace-mapping" "0.3.9"
+
+"@esbuild/aix-ppc64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz#c7184a326533fcdf1b8ee0733e21c713b975575f"
+  integrity sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==
+
+"@esbuild/aix-ppc64@0.25.5":
+  version "0.25.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/aix-ppc64/-/aix-ppc64-0.25.5.tgz#4e0f91776c2b340e75558f60552195f6fad09f18"
+  integrity sha512-9o3TMmpmftaCMepOdA5k/yDw8SfInyzWWTjYTFCX3kPSDJMROQTb8jg+h9Cnwnmm1vOzvxN7gIfB5V2ewpjtGA==
+
+"@esbuild/android-arm64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz#09d9b4357780da9ea3a7dfb833a1f1ff439b4052"
+  integrity sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==
+
+"@esbuild/android-arm64@0.25.5":
+  version "0.25.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/android-arm64/-/android-arm64-0.25.5.tgz#bc766407f1718923f6b8079c8c61bf86ac3a6a4f"
+  integrity sha512-VGzGhj4lJO+TVGV1v8ntCZWJktV7SGCs3Pn1GRWI1SBFtRALoomm8k5E9Pmwg3HOAal2VDc2F9+PM/rEY6oIDg==
+
+"@esbuild/android-arm@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/android-arm/-/android-arm-0.21.5.tgz#9b04384fb771926dfa6d7ad04324ecb2ab9b2e28"
+  integrity sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==
+
+"@esbuild/android-arm@0.25.5":
+  version "0.25.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/android-arm/-/android-arm-0.25.5.tgz#4290d6d3407bae3883ad2cded1081a234473ce26"
+  integrity sha512-AdJKSPeEHgi7/ZhuIPtcQKr5RQdo6OO2IL87JkianiMYMPbCtot9fxPbrMiBADOWWm3T2si9stAiVsGbTQFkbA==
+
+"@esbuild/android-x64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/android-x64/-/android-x64-0.21.5.tgz#29918ec2db754cedcb6c1b04de8cd6547af6461e"
+  integrity sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==
+
+"@esbuild/android-x64@0.25.5":
+  version "0.25.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/android-x64/-/android-x64-0.25.5.tgz#40c11d9cbca4f2406548c8a9895d321bc3b35eff"
+  integrity sha512-D2GyJT1kjvO//drbRT3Hib9XPwQeWd9vZoBJn+bu/lVsOZ13cqNdDeqIF/xQ5/VmWvMduP6AmXvylO/PIc2isw==
+
+"@esbuild/darwin-arm64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz"
+  integrity sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==
+
+"@esbuild/darwin-arm64@0.25.5":
+  version "0.25.5"
+  resolved "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.5.tgz"
+  integrity sha512-GtaBgammVvdF7aPIgH2jxMDdivezgFu6iKpmT+48+F8Hhg5J/sfnDieg0aeG/jfSvkYQU2/pceFPDKlqZzwnfQ==
+
+"@esbuild/darwin-x64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz#c13838fa57372839abdddc91d71542ceea2e1e22"
+  integrity sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==
+
+"@esbuild/darwin-x64@0.25.5":
+  version "0.25.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/darwin-x64/-/darwin-x64-0.25.5.tgz#e27a5d92a14886ef1d492fd50fc61a2d4d87e418"
+  integrity sha512-1iT4FVL0dJ76/q1wd7XDsXrSW+oLoquptvh4CLR4kITDtqi2e/xwXwdCVH8hVHU43wgJdsq7Gxuzcs6Iq/7bxQ==
+
+"@esbuild/freebsd-arm64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz#646b989aa20bf89fd071dd5dbfad69a3542e550e"
+  integrity sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==
+
+"@esbuild/freebsd-arm64@0.25.5":
+  version "0.25.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.5.tgz#97cede59d638840ca104e605cdb9f1b118ba0b1c"
+  integrity sha512-nk4tGP3JThz4La38Uy/gzyXtpkPW8zSAmoUhK9xKKXdBCzKODMc2adkB2+8om9BDYugz+uGV7sLmpTYzvmz6Sw==
+
+"@esbuild/freebsd-x64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz#aa615cfc80af954d3458906e38ca22c18cf5c261"
+  integrity sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==
+
+"@esbuild/freebsd-x64@0.25.5":
+  version "0.25.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/freebsd-x64/-/freebsd-x64-0.25.5.tgz#71c77812042a1a8190c3d581e140d15b876b9c6f"
+  integrity sha512-PrikaNjiXdR2laW6OIjlbeuCPrPaAl0IwPIaRv+SMV8CiM8i2LqVUHFC1+8eORgWyY7yhQY+2U2fA55mBzReaw==
+
+"@esbuild/linux-arm64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz#70ac6fa14f5cb7e1f7f887bcffb680ad09922b5b"
+  integrity sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==
+
+"@esbuild/linux-arm64@0.25.5":
+  version "0.25.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-arm64/-/linux-arm64-0.25.5.tgz#f7b7c8f97eff8ffd2e47f6c67eb5c9765f2181b8"
+  integrity sha512-Z9kfb1v6ZlGbWj8EJk9T6czVEjjq2ntSYLY2cw6pAZl4oKtfgQuS4HOq41M/BcoLPzrUbNd+R4BXFyH//nHxVg==
+
+"@esbuild/linux-arm@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz#fc6fd11a8aca56c1f6f3894f2bea0479f8f626b9"
+  integrity sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==
+
+"@esbuild/linux-arm@0.25.5":
+  version "0.25.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-arm/-/linux-arm-0.25.5.tgz#2a0be71b6cd8201fa559aea45598dffabc05d911"
+  integrity sha512-cPzojwW2okgh7ZlRpcBEtsX7WBuqbLrNXqLU89GxWbNt6uIg78ET82qifUy3W6OVww6ZWobWub5oqZOVtwolfw==
+
+"@esbuild/linux-ia32@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz#3271f53b3f93e3d093d518d1649d6d68d346ede2"
+  integrity sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==
+
+"@esbuild/linux-ia32@0.25.5":
+  version "0.25.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-ia32/-/linux-ia32-0.25.5.tgz#763414463cd9ea6fa1f96555d2762f9f84c61783"
+  integrity sha512-sQ7l00M8bSv36GLV95BVAdhJ2QsIbCuCjh/uYrWiMQSUuV+LpXwIqhgJDcvMTj+VsQmqAHL2yYaasENvJ7CDKA==
+
+"@esbuild/linux-loong64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz#ed62e04238c57026aea831c5a130b73c0f9f26df"
+  integrity sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==
+
+"@esbuild/linux-loong64@0.25.5":
+  version "0.25.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-loong64/-/linux-loong64-0.25.5.tgz#428cf2213ff786a502a52c96cf29d1fcf1eb8506"
+  integrity sha512-0ur7ae16hDUC4OL5iEnDb0tZHDxYmuQyhKhsPBV8f99f6Z9KQM02g33f93rNH5A30agMS46u2HP6qTdEt6Q1kg==
+
+"@esbuild/linux-mips64el@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz#e79b8eb48bf3b106fadec1ac8240fb97b4e64cbe"
+  integrity sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==
+
+"@esbuild/linux-mips64el@0.25.5":
+  version "0.25.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-mips64el/-/linux-mips64el-0.25.5.tgz#5cbcc7fd841b4cd53358afd33527cd394e325d96"
+  integrity sha512-kB/66P1OsHO5zLz0i6X0RxlQ+3cu0mkxS3TKFvkb5lin6uwZ/ttOkP3Z8lfR9mJOBk14ZwZ9182SIIWFGNmqmg==
+
+"@esbuild/linux-ppc64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz#5f2203860a143b9919d383ef7573521fb154c3e4"
+  integrity sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==
+
+"@esbuild/linux-ppc64@0.25.5":
+  version "0.25.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-ppc64/-/linux-ppc64-0.25.5.tgz#0d954ab39ce4f5e50f00c4f8c4fd38f976c13ad9"
+  integrity sha512-UZCmJ7r9X2fe2D6jBmkLBMQetXPXIsZjQJCjgwpVDz+YMcS6oFR27alkgGv3Oqkv07bxdvw7fyB71/olceJhkQ==
+
+"@esbuild/linux-riscv64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz#07bcafd99322d5af62f618cb9e6a9b7f4bb825dc"
+  integrity sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==
+
+"@esbuild/linux-riscv64@0.25.5":
+  version "0.25.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-riscv64/-/linux-riscv64-0.25.5.tgz#0e7dd30730505abd8088321e8497e94b547bfb1e"
+  integrity sha512-kTxwu4mLyeOlsVIFPfQo+fQJAV9mh24xL+y+Bm6ej067sYANjyEw1dNHmvoqxJUCMnkBdKpvOn0Ahql6+4VyeA==
+
+"@esbuild/linux-s390x@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz#b7ccf686751d6a3e44b8627ababc8be3ef62d8de"
+  integrity sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==
+
+"@esbuild/linux-s390x@0.25.5":
+  version "0.25.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-s390x/-/linux-s390x-0.25.5.tgz#5669af81327a398a336d7e40e320b5bbd6e6e72d"
+  integrity sha512-K2dSKTKfmdh78uJ3NcWFiqyRrimfdinS5ErLSn3vluHNeHVnBAFWC8a4X5N+7FgVE1EjXS1QDZbpqZBjfrqMTQ==
+
+"@esbuild/linux-x64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz#6d8f0c768e070e64309af8004bb94e68ab2bb3b0"
+  integrity sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==
+
+"@esbuild/linux-x64@0.25.5":
+  version "0.25.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-x64/-/linux-x64-0.25.5.tgz#b2357dd153aa49038967ddc1ffd90c68a9d2a0d4"
+  integrity sha512-uhj8N2obKTE6pSZ+aMUbqq+1nXxNjZIIjCjGLfsWvVpy7gKCOL6rsY1MhRh9zLtUtAI7vpgLMK6DxjO8Qm9lJw==
+
+"@esbuild/netbsd-arm64@0.25.5":
+  version "0.25.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.5.tgz#53b4dfb8fe1cee93777c9e366893bd3daa6ba63d"
+  integrity sha512-pwHtMP9viAy1oHPvgxtOv+OkduK5ugofNTVDilIzBLpoWAM16r7b/mxBvfpuQDpRQFMfuVr5aLcn4yveGvBZvw==
+
+"@esbuild/netbsd-x64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz#bbe430f60d378ecb88decb219c602667387a6047"
+  integrity sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==
+
+"@esbuild/netbsd-x64@0.25.5":
+  version "0.25.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/netbsd-x64/-/netbsd-x64-0.25.5.tgz#a0206f6314ce7dc8713b7732703d0f58de1d1e79"
+  integrity sha512-WOb5fKrvVTRMfWFNCroYWWklbnXH0Q5rZppjq0vQIdlsQKuw6mdSihwSo4RV/YdQ5UCKKvBy7/0ZZYLBZKIbwQ==
+
+"@esbuild/openbsd-arm64@0.25.5":
+  version "0.25.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.5.tgz#2a796c87c44e8de78001d808c77d948a21ec22fd"
+  integrity sha512-7A208+uQKgTxHd0G0uqZO8UjK2R0DDb4fDmERtARjSHWxqMTye4Erz4zZafx7Di9Cv+lNHYuncAkiGFySoD+Mw==
+
+"@esbuild/openbsd-x64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz#99d1cf2937279560d2104821f5ccce220cb2af70"
+  integrity sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==
+
+"@esbuild/openbsd-x64@0.25.5":
+  version "0.25.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/openbsd-x64/-/openbsd-x64-0.25.5.tgz#28d0cd8909b7fa3953af998f2b2ed34f576728f0"
+  integrity sha512-G4hE405ErTWraiZ8UiSoesH8DaCsMm0Cay4fsFWOOUcz8b8rC6uCvnagr+gnioEjWn0wC+o1/TAHt+It+MpIMg==
+
+"@esbuild/sunos-x64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz#08741512c10d529566baba837b4fe052c8f3487b"
+  integrity sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==
+
+"@esbuild/sunos-x64@0.25.5":
+  version "0.25.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/sunos-x64/-/sunos-x64-0.25.5.tgz#a28164f5b997e8247d407e36c90d3fd5ddbe0dc5"
+  integrity sha512-l+azKShMy7FxzY0Rj4RCt5VD/q8mG/e+mDivgspo+yL8zW7qEwctQ6YqKX34DTEleFAvCIUviCFX1SDZRSyMQA==
+
+"@esbuild/win32-arm64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz#675b7385398411240735016144ab2e99a60fc75d"
+  integrity sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==
+
+"@esbuild/win32-arm64@0.25.5":
+  version "0.25.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/win32-arm64/-/win32-arm64-0.25.5.tgz#6eadbead38e8bd12f633a5190e45eff80e24007e"
+  integrity sha512-O2S7SNZzdcFG7eFKgvwUEZ2VG9D/sn/eIiz8XRZ1Q/DO5a3s76Xv0mdBzVM5j5R639lXQmPmSo0iRpHqUUrsxw==
+
+"@esbuild/win32-ia32@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz#1bfc3ce98aa6ca9a0969e4d2af72144c59c1193b"
+  integrity sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==
+
+"@esbuild/win32-ia32@0.25.5":
+  version "0.25.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/win32-ia32/-/win32-ia32-0.25.5.tgz#bab6288005482f9ed2adb9ded7e88eba9a62cc0d"
+  integrity sha512-onOJ02pqs9h1iMJ1PQphR+VZv8qBMQ77Klcsqv9CNW2w6yLqoURLcgERAIurY6QE63bbLuqgP9ATqajFLK5AMQ==
+
+"@esbuild/win32-x64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz#acad351d582d157bb145535db2a6ff53dd514b5c"
+  integrity sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==
+
+"@esbuild/win32-x64@0.25.5":
+  version "0.25.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/win32-x64/-/win32-x64-0.25.5.tgz#7fc114af5f6563f19f73324b5d5ff36ece0803d1"
+  integrity sha512-TXv6YnJ8ZMVdX+SXWVBo/0p8LTcrUYngpWjvm91TMjjBQii7Oz11Lw5lbDV5Y0TzuhSJHwiH4hEtC1I42mMS0g==
+
+"@isaacs/cliui@^8.0.2":
+  version "8.0.2"
+  resolved "https://registry.npmjs.org/@isaacs/cliui/-/cliui-8.0.2.tgz"
+  integrity sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==
+  dependencies:
+    string-width "^5.1.2"
+    string-width-cjs "npm:string-width@^4.2.0"
+    strip-ansi "^7.0.1"
+    strip-ansi-cjs "npm:strip-ansi@^6.0.1"
+    wrap-ansi "^8.1.0"
+    wrap-ansi-cjs "npm:wrap-ansi@^7.0.0"
+
+"@jridgewell/gen-mapping@^0.3.2":
+  version "0.3.8"
+  resolved "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.8.tgz"
+  integrity sha512-imAbBGkb+ebQyxKgzv5Hu2nmROxoDOXHh80evxdoXNOrvAnVx7zimzc1Oo5h9RlfV4vPXaE2iM5pOFbvOCClWA==
+  dependencies:
+    "@jridgewell/set-array" "^1.2.1"
+    "@jridgewell/sourcemap-codec" "^1.4.10"
+    "@jridgewell/trace-mapping" "^0.3.24"
+
+"@jridgewell/resolve-uri@^3.0.3", "@jridgewell/resolve-uri@^3.1.0":
+  version "3.1.2"
+  resolved "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz"
+  integrity sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==
+
+"@jridgewell/set-array@^1.2.1":
+  version "1.2.1"
+  resolved "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.2.1.tgz"
+  integrity sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==
+
+"@jridgewell/sourcemap-codec@^1.4.10", "@jridgewell/sourcemap-codec@^1.4.14", "@jridgewell/sourcemap-codec@^1.5.0":
+  version "1.5.0"
+  resolved "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.0.tgz"
+  integrity sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ==
+
+"@jridgewell/trace-mapping@0.3.9":
+  version "0.3.9"
+  resolved "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.9.tgz"
+  integrity sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==
+  dependencies:
+    "@jridgewell/resolve-uri" "^3.0.3"
+    "@jridgewell/sourcemap-codec" "^1.4.10"
+
+"@jridgewell/trace-mapping@^0.3.24":
+  version "0.3.25"
+  resolved "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.25.tgz"
+  integrity sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==
+  dependencies:
+    "@jridgewell/resolve-uri" "^3.1.0"
+    "@jridgewell/sourcemap-codec" "^1.4.14"
+
+"@noble/curves@1.2.0":
+  version "1.2.0"
+  resolved "https://registry.npmjs.org/@noble/curves/-/curves-1.2.0.tgz"
+  integrity sha512-oYclrNgRaM9SsBUBVbb8M6DTV7ZHRTKugureoYEncY5c65HOmRzvSiTE3y5CYaPYJA/GVkrhXEoF0M3Ya9PMnw==
+  dependencies:
+    "@noble/hashes" "1.3.2"
+
+"@noble/curves@1.8.1", "@noble/curves@^1.3.0", "@noble/curves@^1.6.0", "@noble/curves@^1.7.0", "@noble/curves@^1.8.1", "@noble/curves@~1.8.1":
+  version "1.8.1"
+  resolved "https://registry.npmjs.org/@noble/curves/-/curves-1.8.1.tgz"
+  integrity sha512-warwspo+UYUPep0Q+vtdVB4Ugn8GGQj8iyB3gnRWsztmUHTI3S1nhdiWNsPUGL0vud7JlRRk1XEu7Lq1KGTnMQ==
+  dependencies:
+    "@noble/hashes" "1.7.1"
+
+"@noble/curves@~1.7.0":
+  version "1.7.0"
+  resolved "https://registry.npmjs.org/@noble/curves/-/curves-1.7.0.tgz"
+  integrity sha512-UTMhXK9SeDhFJVrHeUJ5uZlI6ajXg10O6Ddocf9S6GjbSBVZsJo88HzKwXznNfGpMTRDyJkqMjNDPYgf0qFWnw==
+  dependencies:
+    "@noble/hashes" "1.6.0"
+
+"@noble/hashes@1.3.2":
+  version "1.3.2"
+  resolved "https://registry.npmjs.org/@noble/hashes/-/hashes-1.3.2.tgz"
+  integrity sha512-MVC8EAQp7MvEcm30KWENFjgR+Mkmf+D189XJTkFIlwohU5hcBbn1ZkKq7KVTi2Hme3PMGF390DaL52beVrIihQ==
+
+"@noble/hashes@1.6.0":
+  version "1.6.0"
+  resolved "https://registry.npmjs.org/@noble/hashes/-/hashes-1.6.0.tgz"
+  integrity sha512-YUULf0Uk4/mAA89w+k3+yUYh6NrEvxZa5T6SY3wlMvE2chHkxFUUIDI8/XW1QSC357iA5pSnqt7XEhvFOqmDyQ==
+
+"@noble/hashes@1.7.1", "@noble/hashes@^1.3.1", "@noble/hashes@^1.3.3", "@noble/hashes@^1.5.0", "@noble/hashes@^1.6.1", "@noble/hashes@^1.7.1", "@noble/hashes@~1.7.1":
+  version "1.7.1"
+  resolved "https://registry.npmjs.org/@noble/hashes/-/hashes-1.7.1.tgz"
+  integrity sha512-B8XBPsn4vT/KJAGqDzbwztd+6Yte3P4V7iafm24bxgDe/mlRuK6xmWPuCNrKt2vDafZ8MfJLlchDG/vYafQEjQ==
+
+"@noble/hashes@^1.8.0":
+  version "1.8.0"
+  resolved "https://registry.npmjs.org/@noble/hashes/-/hashes-1.8.0.tgz"
+  integrity sha512-jCs9ldd7NwzpgXDIf6P3+NrHh9/sD6CQdxHyjQI+h/6rDNo88ypBxxz45UDuZHz9r3tNz7N/VInSVoVdtXEI4A==
+
+"@noble/hashes@~1.6.0":
+  version "1.6.1"
+  resolved "https://registry.npmjs.org/@noble/hashes/-/hashes-1.6.1.tgz"
+  integrity sha512-pq5D8h10hHBjyqX+cfBm0i8JUXJ0UhczFc4r74zbuT9XgewFo2E3J1cOaGtdZynILNmQ685YWGzGE1Zv6io50w==
+
+"@pkgjs/parseargs@^0.11.0":
+  version "0.11.0"
+  resolved "https://registry.npmjs.org/@pkgjs/parseargs/-/parseargs-0.11.0.tgz"
+  integrity sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==
+
+"@polkadot-api/cli@0.13.0":
+  version "0.13.0"
+  resolved "https://registry.npmjs.org/@polkadot-api/cli/-/cli-0.13.0.tgz"
+  integrity sha512-uumqacO1+YxuhHYOr75czxvV0KmRxm3DaZtRKzxIf2zpICnj/QnBTpJwlxU56g+pQDU5P/hTR0Thh0vrnUTNVw==
+  dependencies:
+    "@commander-js/extra-typings" "^13.1.0"
+    "@polkadot-api/codegen" "0.16.0"
+    "@polkadot-api/ink-contracts" "0.3.2"
+    "@polkadot-api/json-rpc-provider" "0.0.4"
+    "@polkadot-api/known-chains" "0.7.6"
+    "@polkadot-api/metadata-compatibility" "0.2.3"
+    "@polkadot-api/observable-client" "0.11.0"
+    "@polkadot-api/polkadot-sdk-compat" "2.3.2"
+    "@polkadot-api/sm-provider" "0.1.7"
+    "@polkadot-api/smoldot" "0.3.8"
+    "@polkadot-api/substrate-bindings" "0.13.0"
+    "@polkadot-api/substrate-client" "0.3.0"
+    "@polkadot-api/utils" "0.1.2"
+    "@polkadot-api/wasm-executor" "^0.1.2"
+    "@polkadot-api/ws-provider" "0.4.0"
+    "@types/node" "^22.15.18"
+    commander "^13.1.0"
+    execa "^9.5.3"
+    fs.promises.exists "^1.1.4"
+    ora "^8.2.0"
+    read-pkg "^9.0.1"
+    rxjs "^7.8.2"
+    tsc-prog "^2.3.0"
+    tsup "^8.4.0"
+    typescript "^5.8.3"
+    write-package "^7.1.0"
+
+"@polkadot-api/codegen@0.16.0":
+  version "0.16.0"
+  resolved "https://registry.npmjs.org/@polkadot-api/codegen/-/codegen-0.16.0.tgz"
+  integrity sha512-2Sq/fkB7a9Oi3t7nGc0EbTt1Nd8Pb8XGiKKS9i/wwFAdCLN2oXd33DxmRQTX0Hm2/nrBzXYh1zBuyxRUb9+Sdw==
+  dependencies:
+    "@polkadot-api/ink-contracts" "0.3.2"
+    "@polkadot-api/metadata-builders" "0.12.1"
+    "@polkadot-api/metadata-compatibility" "0.2.3"
+    "@polkadot-api/substrate-bindings" "0.13.0"
+    "@polkadot-api/utils" "0.1.2"
+
+"@polkadot-api/descriptors@file:.papi/descriptors":
+  version "0.1.0-autogenerated.9294084971075542043"
+
+"@polkadot-api/ink-contracts@0.3.2":
+  version "0.3.2"
+  resolved "https://registry.npmjs.org/@polkadot-api/ink-contracts/-/ink-contracts-0.3.2.tgz"
+  integrity sha512-ipWuClaySrPI7XHIomiswXhIZfU4q/EmHmLFIwLdn9iNhLd7YLuUtGF6kacSQu76YtWd3tkLe2rGx4cRRaLjOA==
+  dependencies:
+    "@polkadot-api/metadata-builders" "0.12.1"
+    "@polkadot-api/substrate-bindings" "0.13.0"
+    "@polkadot-api/utils" "0.1.2"
+
+"@polkadot-api/json-rpc-provider-proxy@0.2.4":
+  version "0.2.4"
+  resolved "https://registry.npmjs.org/@polkadot-api/json-rpc-provider-proxy/-/json-rpc-provider-proxy-0.2.4.tgz"
+  integrity sha512-nuGoY9QpBAiRU7xmXN3nugFvPcnSu3IxTLm1OWcNTGlZ1LW5bvdQHz3JLk56+Jlyb3GJ971hqdg2DJsMXkKCOg==
+
+"@polkadot-api/json-rpc-provider-proxy@^0.1.0":
+  version "0.1.0"
+  resolved "https://registry.npmjs.org/@polkadot-api/json-rpc-provider-proxy/-/json-rpc-provider-proxy-0.1.0.tgz"
+  integrity sha512-8GSFE5+EF73MCuLQm8tjrbCqlgclcHBSRaswvXziJ0ZW7iw3UEMsKkkKvELayWyBuOPa2T5i1nj6gFOeIsqvrg==
+
+"@polkadot-api/json-rpc-provider@0.0.1", "@polkadot-api/json-rpc-provider@^0.0.1":
+  version "0.0.1"
+  resolved "https://registry.npmjs.org/@polkadot-api/json-rpc-provider/-/json-rpc-provider-0.0.1.tgz"
+  integrity sha512-/SMC/l7foRjpykLTUTacIH05H3mr9ip8b5xxfwXlVezXrNVLp3Cv0GX6uItkKd+ZjzVPf3PFrDF2B2/HLSNESA==
+
+"@polkadot-api/json-rpc-provider@0.0.4":
+  version "0.0.4"
+  resolved "https://registry.npmjs.org/@polkadot-api/json-rpc-provider/-/json-rpc-provider-0.0.4.tgz"
+  integrity sha512-9cDijLIxzHOBuq6yHqpqjJ9jBmXrctjc1OFqU+tQrS96adQze3mTIH6DTgfb/0LMrqxzxffz1HQGrIlEH00WrA==
+
+"@polkadot-api/known-chains@0.7.6":
+  version "0.7.6"
+  resolved "https://registry.npmjs.org/@polkadot-api/known-chains/-/known-chains-0.7.6.tgz"
+  integrity sha512-em+p9AVfTYulC4U10I+nO42wdczN9ZSAEyb5ppQsxxsKAxaJVPVe4xsDkWzlhheheEN6OBojNHnoYNBVG6X2bg==
+
+"@polkadot-api/logs-provider@0.0.6":
+  version "0.0.6"
+  resolved "https://registry.npmjs.org/@polkadot-api/logs-provider/-/logs-provider-0.0.6.tgz"
+  integrity sha512-4WgHlvy+xee1ADaaVf6+MlK/+jGMtsMgAzvbQOJZnP4PfQuagoTqaeayk8HYKxXGphogLlPbD06tANxcb+nvAg==
+  dependencies:
+    "@polkadot-api/json-rpc-provider" "0.0.4"
+
+"@polkadot-api/merkleize-metadata@1.1.17":
+  version "1.1.17"
+  resolved "https://registry.npmjs.org/@polkadot-api/merkleize-metadata/-/merkleize-metadata-1.1.17.tgz"
+  integrity sha512-3wlLrYjpBluN5l8M1H9zgXlFHfJhqIXYvSVXTvkBYcEVKxZt0PO0f43Zgskeabg29Lx83OiPINcEHFWF8ndAzg==
+  dependencies:
+    "@polkadot-api/metadata-builders" "0.12.1"
+    "@polkadot-api/substrate-bindings" "0.13.0"
+    "@polkadot-api/utils" "0.1.2"
+
+"@polkadot-api/metadata-builders@0.12.1":
+  version "0.12.1"
+  resolved "https://registry.npmjs.org/@polkadot-api/metadata-builders/-/metadata-builders-0.12.1.tgz"
+  integrity sha512-heGt+WgcxrS1CqMm9XwD2DC+fI6azMKJf2ToMP+H12yw6FAy++nijASDZ3MlV/0ZpA/QGZpuZmgQmxKh6jbxVg==
+  dependencies:
+    "@polkadot-api/substrate-bindings" "0.13.0"
+    "@polkadot-api/utils" "0.1.2"
+
+"@polkadot-api/metadata-builders@0.3.2":
+  version "0.3.2"
+  resolved "https://registry.npmjs.org/@polkadot-api/metadata-builders/-/metadata-builders-0.3.2.tgz"
+  integrity sha512-TKpfoT6vTb+513KDzMBTfCb/ORdgRnsS3TDFpOhAhZ08ikvK+hjHMt5plPiAX/OWkm1Wc9I3+K6W0hX5Ab7MVg==
+  dependencies:
+    "@polkadot-api/substrate-bindings" "0.6.0"
+    "@polkadot-api/utils" "0.1.0"
+
+"@polkadot-api/metadata-compatibility@0.2.3":
+  version "0.2.3"
+  resolved "https://registry.npmjs.org/@polkadot-api/metadata-compatibility/-/metadata-compatibility-0.2.3.tgz"
+  integrity sha512-rtym491RA2yl8qGdEDJVujiCya+DK0CW5AwB6InSo85Um04/WWMq7oboRiXQZmspwLkfm2vYBusl/Q9k4Rxshw==
+  dependencies:
+    "@polkadot-api/metadata-builders" "0.12.1"
+    "@polkadot-api/substrate-bindings" "0.13.0"
+
+"@polkadot-api/observable-client@0.11.0":
+  version "0.11.0"
+  resolved "https://registry.npmjs.org/@polkadot-api/observable-client/-/observable-client-0.11.0.tgz"
+  integrity sha512-cyXyih+RI73vPcUQ6GxyMelm1Z3bGDvBIow8W3MqBdpUy4mZ87QGQXGpyBC0Op/qnIxrUFP1cLyT38fUe0i6KQ==
+  dependencies:
+    "@polkadot-api/metadata-builders" "0.12.1"
+    "@polkadot-api/substrate-bindings" "0.13.0"
+    "@polkadot-api/utils" "0.1.2"
+
+"@polkadot-api/observable-client@^0.3.0":
+  version "0.3.2"
+  resolved "https://registry.npmjs.org/@polkadot-api/observable-client/-/observable-client-0.3.2.tgz"
+  integrity sha512-HGgqWgEutVyOBXoGOPp4+IAq6CNdK/3MfQJmhCJb8YaJiaK4W6aRGrdQuQSTPHfERHCARt9BrOmEvTXAT257Ug==
+  dependencies:
+    "@polkadot-api/metadata-builders" "0.3.2"
+    "@polkadot-api/substrate-bindings" "0.6.0"
+    "@polkadot-api/utils" "0.1.0"
+
+"@polkadot-api/pjs-signer@0.6.8":
+  version "0.6.8"
+  resolved "https://registry.npmjs.org/@polkadot-api/pjs-signer/-/pjs-signer-0.6.8.tgz"
+  integrity sha512-YBp+uF2mPZFH4VjT5xgIU462EXbdLrFz09D6vY4SgoS2FRbPV7ktnqiNK2BykKJPGV4TiqpEjNB4OtX6ZLzafg==
+  dependencies:
+    "@polkadot-api/metadata-builders" "0.12.1"
+    "@polkadot-api/polkadot-signer" "0.1.6"
+    "@polkadot-api/signers-common" "0.1.9"
+    "@polkadot-api/substrate-bindings" "0.13.0"
+    "@polkadot-api/utils" "0.1.2"
+
+"@polkadot-api/polkadot-sdk-compat@2.3.2":
+  version "2.3.2"
+  resolved "https://registry.npmjs.org/@polkadot-api/polkadot-sdk-compat/-/polkadot-sdk-compat-2.3.2.tgz"
+  integrity sha512-rLCveP3a6Xd0r218yRqVY34lJ8bXVmE12cArbU4JFp9p8e8Jbb6xdqOdu7bQtjlZUsahhcmfIHYQSXKziST7PA==
+  dependencies:
+    "@polkadot-api/json-rpc-provider" "0.0.4"
+
+"@polkadot-api/polkadot-signer@0.1.6":
+  version "0.1.6"
+  resolved "https://registry.npmjs.org/@polkadot-api/polkadot-signer/-/polkadot-signer-0.1.6.tgz"
+  integrity sha512-X7ghAa4r7doETtjAPTb50IpfGtrBmy3BJM5WCfNKa1saK04VFY9w+vDn+hwEcM4p0PcDHt66Ts74hzvHq54d9A==
+
+"@polkadot-api/signer@0.2.1":
+  version "0.2.1"
+  resolved "https://registry.npmjs.org/@polkadot-api/signer/-/signer-0.2.1.tgz"
+  integrity sha512-z3BPDIglLh/hghQExQVVHR3xgIijjEVcIA2P+xLan5vO4cglGm4U6vIBXgKBuU2oxKlG494ixH8BkXSv5F79zw==
+  dependencies:
+    "@noble/hashes" "^1.8.0"
+    "@polkadot-api/merkleize-metadata" "1.1.17"
+    "@polkadot-api/polkadot-signer" "0.1.6"
+    "@polkadot-api/signers-common" "0.1.9"
+    "@polkadot-api/substrate-bindings" "0.13.0"
+    "@polkadot-api/utils" "0.1.2"
+
+"@polkadot-api/signers-common@0.1.9":
+  version "0.1.9"
+  resolved "https://registry.npmjs.org/@polkadot-api/signers-common/-/signers-common-0.1.9.tgz"
+  integrity sha512-eOAPfnNpa0kJrtM/OPHOt+jlFP97c4CWZmzfcPzOqfrLUgyyLzVCFzgBipffpzPXNPQsToM6FM+7DQEgQmoDuA==
+  dependencies:
+    "@polkadot-api/metadata-builders" "0.12.1"
+    "@polkadot-api/polkadot-signer" "0.1.6"
+    "@polkadot-api/substrate-bindings" "0.13.0"
+    "@polkadot-api/utils" "0.1.2"
+
+"@polkadot-api/sm-provider@0.1.7":
+  version "0.1.7"
+  resolved "https://registry.npmjs.org/@polkadot-api/sm-provider/-/sm-provider-0.1.7.tgz"
+  integrity sha512-BhNKVeIFZdawpPVadXszLl8IP4EDjcLHe/GchfRRFkvoNFuwS2nNv/npYIqCviXV+dd2R8VnEELxwScsf380Og==
+  dependencies:
+    "@polkadot-api/json-rpc-provider" "0.0.4"
+    "@polkadot-api/json-rpc-provider-proxy" "0.2.4"
+
+"@polkadot-api/smoldot@0.3.8":
+  version "0.3.8"
+  resolved "https://registry.npmjs.org/@polkadot-api/smoldot/-/smoldot-0.3.8.tgz"
+  integrity sha512-dbJSMRFtELDW+rZIWRwKE/K8oy7+gYaGl+DvaOjARoBW2n80rJ7RAMOCCu+b5h2zgl3elftFBwMNAuAWgHT/Zg==
+  dependencies:
+    "@types/node" "^22.9.0"
+    smoldot "2.0.34"
+
+"@polkadot-api/substrate-bindings@0.13.0":
+  version "0.13.0"
+  resolved "https://registry.npmjs.org/@polkadot-api/substrate-bindings/-/substrate-bindings-0.13.0.tgz"
+  integrity sha512-M/60lXtHr4flwx4K7L4xv2jLk44EhD8UB4jvah+jbZM195I89nZGXKo2JOkgyR5DHoLj//TAoBkLedZmaaAiaQ==
+  dependencies:
+    "@noble/hashes" "^1.8.0"
+    "@polkadot-api/utils" "0.1.2"
+    "@scure/base" "^1.2.5"
+    scale-ts "^1.6.1"
+
+"@polkadot-api/substrate-bindings@0.6.0":
+  version "0.6.0"
+  resolved "https://registry.npmjs.org/@polkadot-api/substrate-bindings/-/substrate-bindings-0.6.0.tgz"
+  integrity sha512-lGuhE74NA1/PqdN7fKFdE5C1gNYX357j1tWzdlPXI0kQ7h3kN0zfxNOpPUN7dIrPcOFZ6C0tRRVrBylXkI6xPw==
+  dependencies:
+    "@noble/hashes" "^1.3.1"
+    "@polkadot-api/utils" "0.1.0"
+    "@scure/base" "^1.1.1"
+    scale-ts "^1.6.0"
+
+"@polkadot-api/substrate-client@0.3.0":
+  version "0.3.0"
+  resolved "https://registry.npmjs.org/@polkadot-api/substrate-client/-/substrate-client-0.3.0.tgz"
+  integrity sha512-0hEvQLKH2zhaFzE8DPkWehvJilec8u2O2wbIEUStm0OJ8jIFtJ40MFjXQfB01dXBWUz1KaVBqS6xd3sZA90Dpw==
+  dependencies:
+    "@polkadot-api/json-rpc-provider" "0.0.4"
+    "@polkadot-api/utils" "0.1.2"
+
+"@polkadot-api/substrate-client@^0.1.2":
+  version "0.1.4"
+  resolved "https://registry.npmjs.org/@polkadot-api/substrate-client/-/substrate-client-0.1.4.tgz"
+  integrity sha512-MljrPobN0ZWTpn++da9vOvt+Ex+NlqTlr/XT7zi9sqPtDJiQcYl+d29hFAgpaeTqbeQKZwz3WDE9xcEfLE8c5A==
+  dependencies:
+    "@polkadot-api/json-rpc-provider" "0.0.1"
+    "@polkadot-api/utils" "0.1.0"
+
+"@polkadot-api/utils@0.1.0":
+  version "0.1.0"
+  resolved "https://registry.npmjs.org/@polkadot-api/utils/-/utils-0.1.0.tgz"
+  integrity sha512-MXzWZeuGxKizPx2Xf/47wx9sr/uxKw39bVJUptTJdsaQn/TGq+z310mHzf1RCGvC1diHM8f593KrnDgc9oNbJA==
+
+"@polkadot-api/utils@0.1.2":
+  version "0.1.2"
+  resolved "https://registry.npmjs.org/@polkadot-api/utils/-/utils-0.1.2.tgz"
+  integrity sha512-yhs5k2a8N1SBJcz7EthZoazzLQUkZxbf+0271Xzu42C5AEM9K9uFLbsB+ojzHEM72O5X8lPtSwGKNmS7WQyDyg==
+
+"@polkadot-api/wasm-executor@^0.1.2":
+  version "0.1.2"
+  resolved "https://registry.npmjs.org/@polkadot-api/wasm-executor/-/wasm-executor-0.1.2.tgz"
+  integrity sha512-a5wGenltB3EFPdf72u8ewi6HsUg2qubUAf3ekJprZf24lTK3+w8a/GUF/y6r08LJF35MALZ32SAtLqtVTIOGnQ==
+
+"@polkadot-api/ws-provider@0.4.0":
+  version "0.4.0"
+  resolved "https://registry.npmjs.org/@polkadot-api/ws-provider/-/ws-provider-0.4.0.tgz"
+  integrity sha512-ZurjUHHAlQ1Ux8HiZz7mtkg1qjq6LmqxcHljcZxne0U7foCZrXdWHsohwlV8kUQUir5kXuDsNvdZN/MFCUMaVw==
+  dependencies:
+    "@polkadot-api/json-rpc-provider" "0.0.4"
+    "@polkadot-api/json-rpc-provider-proxy" "0.2.4"
+    ws "^8.18.1"
+
+"@polkadot-labs/hdkd-helpers@0.0.10":
+  version "0.0.10"
+  resolved "https://registry.npmjs.org/@polkadot-labs/hdkd-helpers/-/hdkd-helpers-0.0.10.tgz"
+  integrity sha512-wBKenhN7TjNiMXxBvQWzFf+su8xTaRGqyOKAlAfpyY9oWTOt3G05yMvDHEZ4g/NRLoE4P3fQYQ0bdcMKl7KkDw==
+  dependencies:
+    "@noble/curves" "^1.7.0"
+    "@noble/hashes" "^1.6.1"
+    "@scure/base" "^1.2.1"
+    micro-sr25519 "^0.1.0"
+    scale-ts "^1.6.1"
+
+"@polkadot-labs/hdkd-helpers@^0.0.11":
+  version "0.0.11"
+  resolved "https://registry.npmjs.org/@polkadot-labs/hdkd-helpers/-/hdkd-helpers-0.0.11.tgz"
+  integrity sha512-qPlWqC3NNV/2NYc5GEy+Ovi4UBAgkMGvMfyiYuj2BQN4lW59Q1T9coNx0Yp6XzsnJ1ddaF9PWaUtxj3LdM0IDw==
+  dependencies:
+    "@noble/curves" "^1.8.1"
+    "@noble/hashes" "^1.7.1"
+    "@scure/base" "^1.2.4"
+    micro-sr25519 "^0.1.0"
+    scale-ts "^1.6.1"
+
+"@polkadot-labs/hdkd@^0.0.10":
+  version "0.0.10"
+  resolved "https://registry.npmjs.org/@polkadot-labs/hdkd/-/hdkd-0.0.10.tgz"
+  integrity sha512-jD8l+Ls/kZjvZja4T2Y0G6Be3rfGn0qNs3hvcNeV2CmOMtI7yRkkWPXI7WiJ8AyEoBwBuZt0rm6yzGla6o2HXQ==
+  dependencies:
+    "@polkadot-labs/hdkd-helpers" "0.0.10"
+
+"@polkadot/api-augment@15.1.1":
+  version "15.1.1"
+  resolved "https://registry.npmjs.org/@polkadot/api-augment/-/api-augment-15.1.1.tgz"
+  integrity sha512-tYASON7vVLz7FGcXVX9dWSd/9pR6FckayEkc08Z6RyjH7HfjtCZ3/Dz7MlGRNql4SnPi4+xpjSD6rwrZcETU1g==
+  dependencies:
+    "@polkadot/api-base" "15.1.1"
+    "@polkadot/rpc-augment" "15.1.1"
+    "@polkadot/types" "15.1.1"
+    "@polkadot/types-augment" "15.1.1"
+    "@polkadot/types-codec" "15.1.1"
+    "@polkadot/util" "^13.2.3"
+    tslib "^2.8.0"
+
+"@polkadot/api-base@15.1.1":
+  version "15.1.1"
+  resolved "https://registry.npmjs.org/@polkadot/api-base/-/api-base-15.1.1.tgz"
+  integrity sha512-OXLZ7/k2RXLIA8hKA8oyii6o8MuGlqujIDcLVaMdtWnQsBg26h8pv/mujT2YSz2OguLxrfdvD+lUGtwZC8kw4A==
+  dependencies:
+    "@polkadot/rpc-core" "15.1.1"
+    "@polkadot/types" "15.1.1"
+    "@polkadot/util" "^13.2.3"
+    rxjs "^7.8.1"
+    tslib "^2.8.0"
+
+"@polkadot/api-derive@15.1.1":
+  version "15.1.1"
+  resolved "https://registry.npmjs.org/@polkadot/api-derive/-/api-derive-15.1.1.tgz"
+  integrity sha512-UPcKr9FplfYKPaP7FYEF917Sm1rKnQFX4AzQJn3f8ySp7DDf6EYiHrNICtGifPEAoANTSW+YHlSchhtnvfSIhw==
+  dependencies:
+    "@polkadot/api" "15.1.1"
+    "@polkadot/api-augment" "15.1.1"
+    "@polkadot/api-base" "15.1.1"
+    "@polkadot/rpc-core" "15.1.1"
+    "@polkadot/types" "15.1.1"
+    "@polkadot/types-codec" "15.1.1"
+    "@polkadot/util" "^13.2.3"
+    "@polkadot/util-crypto" "^13.2.3"
+    rxjs "^7.8.1"
+    tslib "^2.8.0"
+
+"@polkadot/api@15.1.1":
+  version "15.1.1"
+  resolved "https://registry.npmjs.org/@polkadot/api/-/api-15.1.1.tgz"
+  integrity sha512-n3QeQ1CXlzjqyh2eFbEQPcnkXO3J4QYNTIj0Lnz/XFUpzKimHPDA2iUfaXuy5dXjnzS21jFANGSUFoZ+XKi/8g==
+  dependencies:
+    "@polkadot/api-augment" "15.1.1"
+    "@polkadot/api-base" "15.1.1"
+    "@polkadot/api-derive" "15.1.1"
+    "@polkadot/keyring" "^13.2.3"
+    "@polkadot/rpc-augment" "15.1.1"
+    "@polkadot/rpc-core" "15.1.1"
+    "@polkadot/rpc-provider" "15.1.1"
+    "@polkadot/types" "15.1.1"
+    "@polkadot/types-augment" "15.1.1"
+    "@polkadot/types-codec" "15.1.1"
+    "@polkadot/types-create" "15.1.1"
+    "@polkadot/types-known" "15.1.1"
+    "@polkadot/util" "^13.2.3"
+    "@polkadot/util-crypto" "^13.2.3"
+    eventemitter3 "^5.0.1"
+    rxjs "^7.8.1"
+    tslib "^2.8.0"
+
+"@polkadot/keyring@^13.2.3":
+  version "13.4.3"
+  resolved "https://registry.npmjs.org/@polkadot/keyring/-/keyring-13.4.3.tgz"
+  integrity sha512-2ePNcvBTznDN2luKbZM5fdxgAnj7V8m276qSTgrHlqKVvg9FsQpRCR6CAU+AjhnHzpe7uiZO+UH+jlXWefI3AA==
+  dependencies:
+    "@polkadot/util" "13.4.3"
+    "@polkadot/util-crypto" "13.4.3"
+    tslib "^2.8.0"
+
+"@polkadot/networks@13.4.3", "@polkadot/networks@^13.2.3":
+  version "13.4.3"
+  resolved "https://registry.npmjs.org/@polkadot/networks/-/networks-13.4.3.tgz"
+  integrity sha512-Z+YZkltBt//CtkVH8ZYJ1z66qYxdI0yPamzkzZAqw6gj3gjgSxKtxB4baA/rcAw05QTvN2R3dLkkmKr2mnHovQ==
+  dependencies:
+    "@polkadot/util" "13.4.3"
+    "@substrate/ss58-registry" "^1.51.0"
+    tslib "^2.8.0"
+
+"@polkadot/rpc-augment@15.1.1":
+  version "15.1.1"
+  resolved "https://registry.npmjs.org/@polkadot/rpc-augment/-/rpc-augment-15.1.1.tgz"
+  integrity sha512-s6i4nTy7/1Q5svIMT4TR55GLRv9asG7xbJcntHEsQ2nDs8zZV/mvPWfEUxgup0xVO8sDgyrf6KTTVRKJjySjUg==
+  dependencies:
+    "@polkadot/rpc-core" "15.1.1"
+    "@polkadot/types" "15.1.1"
+    "@polkadot/types-codec" "15.1.1"
+    "@polkadot/util" "^13.2.3"
+    tslib "^2.8.0"
+
+"@polkadot/rpc-core@15.1.1":
+  version "15.1.1"
+  resolved "https://registry.npmjs.org/@polkadot/rpc-core/-/rpc-core-15.1.1.tgz"
+  integrity sha512-KErbVgPChps7NsxcGch5JCArZHNqs81fDEzs+XoHnD05nzuxcO38v4Yu+M04lHLax2m8ky8K6o3gurBglJENlA==
+  dependencies:
+    "@polkadot/rpc-augment" "15.1.1"
+    "@polkadot/rpc-provider" "15.1.1"
+    "@polkadot/types" "15.1.1"
+    "@polkadot/util" "^13.2.3"
+    rxjs "^7.8.1"
+    tslib "^2.8.0"
+
+"@polkadot/rpc-provider@15.1.1":
+  version "15.1.1"
+  resolved "https://registry.npmjs.org/@polkadot/rpc-provider/-/rpc-provider-15.1.1.tgz"
+  integrity sha512-9OWV1dyX+vmAbKkhMU8J7Q0sCaovPrkwZqo2ejmEpZ/Lr12Hw5JAk4gdvB869QEVP7zj0gH3HuYVajmsxesYKg==
+  dependencies:
+    "@polkadot/keyring" "^13.2.3"
+    "@polkadot/types" "15.1.1"
+    "@polkadot/types-support" "15.1.1"
+    "@polkadot/util" "^13.2.3"
+    "@polkadot/util-crypto" "^13.2.3"
+    "@polkadot/x-fetch" "^13.2.3"
+    "@polkadot/x-global" "^13.2.3"
+    "@polkadot/x-ws" "^13.2.3"
+    eventemitter3 "^5.0.1"
+    mock-socket "^9.3.1"
+    nock "^13.5.5"
+    tslib "^2.8.0"
+  optionalDependencies:
+    "@substrate/connect" "0.8.11"
+
+"@polkadot/types-augment@15.1.1":
+  version "15.1.1"
+  resolved "https://registry.npmjs.org/@polkadot/types-augment/-/types-augment-15.1.1.tgz"
+  integrity sha512-6v/FsN/JYCupyGYW+MbS0iOCiWvf6PXJ5+m8ORYYYDPFgQqaQPxKMKWJpnO0s9cCR33QcyNYhErPGuZ62UMJjw==
+  dependencies:
+    "@polkadot/types" "15.1.1"
+    "@polkadot/types-codec" "15.1.1"
+    "@polkadot/util" "^13.2.3"
+    tslib "^2.8.0"
+
+"@polkadot/types-codec@15.1.1":
+  version "15.1.1"
+  resolved "https://registry.npmjs.org/@polkadot/types-codec/-/types-codec-15.1.1.tgz"
+  integrity sha512-cm99CFvDf4UXmw7DeMkRqa/hf7wEgjJZoZZW/B12Js0ObwRmSXMk/gDbyiT6hqPnQ81sU726E72p39DolaEatQ==
+  dependencies:
+    "@polkadot/util" "^13.2.3"
+    "@polkadot/x-bigint" "^13.2.3"
+    tslib "^2.8.0"
+
+"@polkadot/types-create@15.1.1":
+  version "15.1.1"
+  resolved "https://registry.npmjs.org/@polkadot/types-create/-/types-create-15.1.1.tgz"
+  integrity sha512-AOgz+UsUqsGSENrc+p/dHyXH2TC9qVtUTAxlqaHfOnwqjMWfEqc78mc5a1mk0a+RqxmIHw8nQNSdBdhv+UdtyQ==
+  dependencies:
+    "@polkadot/types-codec" "15.1.1"
+    "@polkadot/util" "^13.2.3"
+    tslib "^2.8.0"
+
+"@polkadot/types-known@15.1.1":
+  version "15.1.1"
+  resolved "https://registry.npmjs.org/@polkadot/types-known/-/types-known-15.1.1.tgz"
+  integrity sha512-L934pYxXdHB3GHlVu57ihO6llhxuggSuQZuJ9kHunG0I6tezXLIgAhwaPgACMVbmBYlkJPqm4Nr6pC3kpIsGow==
+  dependencies:
+    "@polkadot/networks" "^13.2.3"
+    "@polkadot/types" "15.1.1"
+    "@polkadot/types-codec" "15.1.1"
+    "@polkadot/types-create" "15.1.1"
+    "@polkadot/util" "^13.2.3"
+    tslib "^2.8.0"
+
+"@polkadot/types-support@15.1.1":
+  version "15.1.1"
+  resolved "https://registry.npmjs.org/@polkadot/types-support/-/types-support-15.1.1.tgz"
+  integrity sha512-uyn5N7XERHosVq0+aCpEwYnkUroOr7OX8B8/00UkgmfVOXskp/cukEVcGlmI/YGAS+9+V2BZN2GBX7Lz0eeKmw==
+  dependencies:
+    "@polkadot/util" "^13.2.3"
+    tslib "^2.8.0"
+
+"@polkadot/types@15.1.1":
+  version "15.1.1"
+  resolved "https://registry.npmjs.org/@polkadot/types/-/types-15.1.1.tgz"
+  integrity sha512-n6lg/quhLp3Zmt/6gHAg2uoSmMmXk3NR19I7qCyeDJ30pP1UhOjtmuWOQDl6SwSEwuHtudLp3p2nCJsymXjgsw==
+  dependencies:
+    "@polkadot/keyring" "^13.2.3"
+    "@polkadot/types-augment" "15.1.1"
+    "@polkadot/types-codec" "15.1.1"
+    "@polkadot/types-create" "15.1.1"
+    "@polkadot/util" "^13.2.3"
+    "@polkadot/util-crypto" "^13.2.3"
+    rxjs "^7.8.1"
+    tslib "^2.8.0"
+
+"@polkadot/util-crypto@13.4.3", "@polkadot/util-crypto@^13.2.3":
+  version "13.4.3"
+  resolved "https://registry.npmjs.org/@polkadot/util-crypto/-/util-crypto-13.4.3.tgz"
+  integrity sha512-Ml0mjhKVetMrRCIosmVNMa6lbFPa3fSAeOggf34NsDIIQOKt9FL644iGz1ZSMOnBwN9qk2qHYmcFMTDXX2yKVQ==
+  dependencies:
+    "@noble/curves" "^1.3.0"
+    "@noble/hashes" "^1.3.3"
+    "@polkadot/networks" "13.4.3"
+    "@polkadot/util" "13.4.3"
+    "@polkadot/wasm-crypto" "^7.4.1"
+    "@polkadot/wasm-util" "^7.4.1"
+    "@polkadot/x-bigint" "13.4.3"
+    "@polkadot/x-randomvalues" "13.4.3"
+    "@scure/base" "^1.1.7"
+    tslib "^2.8.0"
+
+"@polkadot/util@13.4.3", "@polkadot/util@^13.2.3":
+  version "13.4.3"
+  resolved "https://registry.npmjs.org/@polkadot/util/-/util-13.4.3.tgz"
+  integrity sha512-6v2zvg8l7W22XvjYf7qv9tPQdYl2E6aXY94M4TZKsXZxmlS5BoG+A9Aq0+Gw8zBUjupjEmUkA6Y//msO8Zisug==
+  dependencies:
+    "@polkadot/x-bigint" "13.4.3"
+    "@polkadot/x-global" "13.4.3"
+    "@polkadot/x-textdecoder" "13.4.3"
+    "@polkadot/x-textencoder" "13.4.3"
+    "@types/bn.js" "^5.1.6"
+    bn.js "^5.2.1"
+    tslib "^2.8.0"
+
+"@polkadot/wasm-bridge@7.4.1":
+  version "7.4.1"
+  resolved "https://registry.npmjs.org/@polkadot/wasm-bridge/-/wasm-bridge-7.4.1.tgz"
+  integrity sha512-tdkJaV453tezBxhF39r4oeG0A39sPKGDJmN81LYLf+Fihb7astzwju+u75BRmDrHZjZIv00un3razJEWCxze6g==
+  dependencies:
+    "@polkadot/wasm-util" "7.4.1"
+    tslib "^2.7.0"
+
+"@polkadot/wasm-crypto-asmjs@7.4.1":
+  version "7.4.1"
+  resolved "https://registry.npmjs.org/@polkadot/wasm-crypto-asmjs/-/wasm-crypto-asmjs-7.4.1.tgz"
+  integrity sha512-pwU8QXhUW7IberyHJIQr37IhbB6DPkCG5FhozCiNTq4vFBsFPjm9q8aZh7oX1QHQaiAZa2m2/VjIVE+FHGbvHQ==
+  dependencies:
+    tslib "^2.7.0"
+
+"@polkadot/wasm-crypto-init@7.4.1":
+  version "7.4.1"
+  resolved "https://registry.npmjs.org/@polkadot/wasm-crypto-init/-/wasm-crypto-init-7.4.1.tgz"
+  integrity sha512-AVka33+f7MvXEEIGq5U0dhaA2SaXMXnxVCQyhJTaCnJ5bRDj0Xlm3ijwDEQUiaDql7EikbkkRtmlvs95eSUWYQ==
+  dependencies:
+    "@polkadot/wasm-bridge" "7.4.1"
+    "@polkadot/wasm-crypto-asmjs" "7.4.1"
+    "@polkadot/wasm-crypto-wasm" "7.4.1"
+    "@polkadot/wasm-util" "7.4.1"
+    tslib "^2.7.0"
+
+"@polkadot/wasm-crypto-wasm@7.4.1":
+  version "7.4.1"
+  resolved "https://registry.npmjs.org/@polkadot/wasm-crypto-wasm/-/wasm-crypto-wasm-7.4.1.tgz"
+  integrity sha512-PE1OAoupFR0ZOV2O8tr7D1FEUAwaggzxtfs3Aa5gr+yxlSOaWUKeqsOYe1KdrcjmZVV3iINEAXxgrbzCmiuONg==
+  dependencies:
+    "@polkadot/wasm-util" "7.4.1"
+    tslib "^2.7.0"
+
+"@polkadot/wasm-crypto@^7.4.1":
+  version "7.4.1"
+  resolved "https://registry.npmjs.org/@polkadot/wasm-crypto/-/wasm-crypto-7.4.1.tgz"
+  integrity sha512-kHN/kF7hYxm1y0WeFLWeWir6oTzvcFmR4N8fJJokR+ajYbdmrafPN+6iLgQVbhZnDdxyv9jWDuRRsDnBx8tPMQ==
+  dependencies:
+    "@polkadot/wasm-bridge" "7.4.1"
+    "@polkadot/wasm-crypto-asmjs" "7.4.1"
+    "@polkadot/wasm-crypto-init" "7.4.1"
+    "@polkadot/wasm-crypto-wasm" "7.4.1"
+    "@polkadot/wasm-util" "7.4.1"
+    tslib "^2.7.0"
+
+"@polkadot/wasm-util@7.4.1", "@polkadot/wasm-util@^7.4.1":
+  version "7.4.1"
+  resolved "https://registry.npmjs.org/@polkadot/wasm-util/-/wasm-util-7.4.1.tgz"
+  integrity sha512-RAcxNFf3zzpkr+LX/ItAsvj+QyM56TomJ0xjUMo4wKkHjwsxkz4dWJtx5knIgQz/OthqSDMR59VNEycQeNuXzA==
+  dependencies:
+    tslib "^2.7.0"
+
+"@polkadot/x-bigint@13.4.3", "@polkadot/x-bigint@^13.2.3":
+  version "13.4.3"
+  resolved "https://registry.npmjs.org/@polkadot/x-bigint/-/x-bigint-13.4.3.tgz"
+  integrity sha512-8NbjF5Q+5lflhvDFve58wULjCVcvXa932LKFtI5zL2gx5VDhMgyfkNcYRjHB18Ecl21963JuGzvGVTZNkh/i6g==
+  dependencies:
+    "@polkadot/x-global" "13.4.3"
+    tslib "^2.8.0"
+
+"@polkadot/x-fetch@^13.2.3":
+  version "13.4.3"
+  resolved "https://registry.npmjs.org/@polkadot/x-fetch/-/x-fetch-13.4.3.tgz"
+  integrity sha512-EwhcwROqWa7mvNTbLVNH71Hbyp5PW5j9lV2UpII5MZzRO95eYwV4oP/xgtTxC+60nC8lrvzAw0JxEHrmNzmtlg==
+  dependencies:
+    "@polkadot/x-global" "13.4.3"
+    node-fetch "^3.3.2"
+    tslib "^2.8.0"
+
+"@polkadot/x-global@13.4.3", "@polkadot/x-global@^13.2.3":
+  version "13.4.3"
+  resolved "https://registry.npmjs.org/@polkadot/x-global/-/x-global-13.4.3.tgz"
+  integrity sha512-6c98kxZdoGRct3ua9Dz6/qz8wb3XFRUkaY+4+RzIgehKMPhu19pGWTrzmbJSyY9FtIpThuWKuDaBEvd5KgSxjA==
+  dependencies:
+    tslib "^2.8.0"
+
+"@polkadot/x-randomvalues@13.4.3":
+  version "13.4.3"
+  resolved "https://registry.npmjs.org/@polkadot/x-randomvalues/-/x-randomvalues-13.4.3.tgz"
+  integrity sha512-pskXP/S2jROZ6aASExsUFlNp7GbJvQikKogvyvMMCzNIbUYLxpLuquLRa3MOORx2c0SNsENg90cx/zHT+IjPRQ==
+  dependencies:
+    "@polkadot/x-global" "13.4.3"
+    tslib "^2.8.0"
+
+"@polkadot/x-textdecoder@13.4.3":
+  version "13.4.3"
+  resolved "https://registry.npmjs.org/@polkadot/x-textdecoder/-/x-textdecoder-13.4.3.tgz"
+  integrity sha512-k7Wg6csAPxfNtpBt3k5yUuPHYmRl/nl7H2OMr40upMjbZXbQ1RJW9Z3GBkLmQczG7NwwfAXHwQE9FYOMUtbuRQ==
+  dependencies:
+    "@polkadot/x-global" "13.4.3"
+    tslib "^2.8.0"
+
+"@polkadot/x-textencoder@13.4.3":
+  version "13.4.3"
+  resolved "https://registry.npmjs.org/@polkadot/x-textencoder/-/x-textencoder-13.4.3.tgz"
+  integrity sha512-byl2LbN1rnEXKmnsCzEDaIjSIHAr+1ciSe2yj3M0K+oWEEcaFZEovJaf/uoyzkcjn+/l8rDv3nget6mPuQ/DSw==
+  dependencies:
+    "@polkadot/x-global" "13.4.3"
+    tslib "^2.8.0"
+
+"@polkadot/x-ws@^13.2.3":
+  version "13.4.3"
+  resolved "https://registry.npmjs.org/@polkadot/x-ws/-/x-ws-13.4.3.tgz"
+  integrity sha512-GS0I6MYLD/xNAAjODZi/pbG7Ba0e/5sbvDIrT01iKH3SPGN+PZoyAsc04t2IOXA6QmPa1OBHnaU3N4K8gGmJ+w==
+  dependencies:
+    "@polkadot/x-global" "13.4.3"
+    tslib "^2.8.0"
+    ws "^8.18.0"
+
+"@rollup/rollup-android-arm-eabi@4.34.8":
+  version "4.34.8"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.34.8.tgz#731df27dfdb77189547bcef96ada7bf166bbb2fb"
+  integrity sha512-q217OSE8DTp8AFHuNHXo0Y86e1wtlfVrXiAlwkIvGRQv9zbc6mE3sjIVfwI8sYUyNxwOg0j/Vm1RKM04JcWLJw==
+
+"@rollup/rollup-android-arm64@4.34.8":
+  version "4.34.8"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.34.8.tgz#4bea6db78e1f6927405df7fe0faf2f5095e01343"
+  integrity sha512-Gigjz7mNWaOL9wCggvoK3jEIUUbGul656opstjaUSGC3eT0BM7PofdAJaBfPFWWkXNVAXbaQtC99OCg4sJv70Q==
+
+"@rollup/rollup-darwin-arm64@4.34.8":
+  version "4.34.8"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.34.8.tgz#a7aab77d44be3c44a20f946e10160f84e5450e7f"
+  integrity sha512-02rVdZ5tgdUNRxIUrFdcMBZQoaPMrxtwSb+/hOfBdqkatYHR3lZ2A2EGyHq2sGOd0Owk80oV3snlDASC24He3Q==
+
+"@rollup/rollup-darwin-x64@4.34.8":
+  version "4.34.8"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.34.8.tgz#c572c024b57ee8ddd1b0851703ace9eb6cc0dd82"
+  integrity sha512-qIP/elwR/tq/dYRx3lgwK31jkZvMiD6qUtOycLhTzCvrjbZ3LjQnEM9rNhSGpbLXVJYQ3rq39A6Re0h9tU2ynw==
+
+"@rollup/rollup-freebsd-arm64@4.34.8":
+  version "4.34.8"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.34.8.tgz#cf74f8113b5a83098a5c026c165742277cbfb88b"
+  integrity sha512-IQNVXL9iY6NniYbTaOKdrlVP3XIqazBgJOVkddzJlqnCpRi/yAeSOa8PLcECFSQochzqApIOE1GHNu3pCz+BDA==
+
+"@rollup/rollup-freebsd-x64@4.34.8":
+  version "4.34.8"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.34.8.tgz#39561f3a2f201a4ad6a01425b1ff5928154ecd7c"
+  integrity sha512-TYXcHghgnCqYFiE3FT5QwXtOZqDj5GmaFNTNt3jNC+vh22dc/ukG2cG+pi75QO4kACohZzidsq7yKTKwq/Jq7Q==
+
+"@rollup/rollup-linux-arm-gnueabihf@4.34.8":
+  version "4.34.8"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.34.8.tgz#980d6061e373bfdaeb67925c46d2f8f9b3de537f"
+  integrity sha512-A4iphFGNkWRd+5m3VIGuqHnG3MVnqKe7Al57u9mwgbyZ2/xF9Jio72MaY7xxh+Y87VAHmGQr73qoKL9HPbXj1g==
+
+"@rollup/rollup-linux-arm-musleabihf@4.34.8":
+  version "4.34.8"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.34.8.tgz#f91a90f30dc00d5a64ac2d9bbedc829cd3cfaa78"
+  integrity sha512-S0lqKLfTm5u+QTxlFiAnb2J/2dgQqRy/XvziPtDd1rKZFXHTyYLoVL58M/XFwDI01AQCDIevGLbQrMAtdyanpA==
+
+"@rollup/rollup-linux-arm64-gnu@4.34.8":
+  version "4.34.8"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.34.8.tgz#fac700fa5c38bc13a0d5d34463133093da4c92a0"
+  integrity sha512-jpz9YOuPiSkL4G4pqKrus0pn9aYwpImGkosRKwNi+sJSkz+WU3anZe6hi73StLOQdfXYXC7hUfsQlTnjMd3s1A==
+
+"@rollup/rollup-linux-arm64-musl@4.34.8":
+  version "4.34.8"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.34.8.tgz#f50ecccf8c78841ff6df1706bc4782d7f62bf9c3"
+  integrity sha512-KdSfaROOUJXgTVxJNAZ3KwkRc5nggDk+06P6lgi1HLv1hskgvxHUKZ4xtwHkVYJ1Rep4GNo+uEfycCRRxht7+Q==
+
+"@rollup/rollup-linux-loongarch64-gnu@4.34.8":
+  version "4.34.8"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-loongarch64-gnu/-/rollup-linux-loongarch64-gnu-4.34.8.tgz#5869dc0b28242da6553e2b52af41374f4038cd6e"
+  integrity sha512-NyF4gcxwkMFRjgXBM6g2lkT58OWztZvw5KkV2K0qqSnUEqCVcqdh2jN4gQrTn/YUpAcNKyFHfoOZEer9nwo6uQ==
+
+"@rollup/rollup-linux-powerpc64le-gnu@4.34.8":
+  version "4.34.8"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-powerpc64le-gnu/-/rollup-linux-powerpc64le-gnu-4.34.8.tgz#5cdd9f851ce1bea33d6844a69f9574de335f20b1"
+  integrity sha512-LMJc999GkhGvktHU85zNTDImZVUCJ1z/MbAJTnviiWmmjyckP5aQsHtcujMjpNdMZPT2rQEDBlJfubhs3jsMfw==
+
+"@rollup/rollup-linux-riscv64-gnu@4.34.8":
+  version "4.34.8"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.34.8.tgz#ef5dc37f4388f5253f0def43e1440ec012af204d"
+  integrity sha512-xAQCAHPj8nJq1PI3z8CIZzXuXCstquz7cIOL73HHdXiRcKk8Ywwqtx2wrIy23EcTn4aZ2fLJNBB8d0tQENPCmw==
+
+"@rollup/rollup-linux-s390x-gnu@4.34.8":
+  version "4.34.8"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.34.8.tgz#7dbc3ccbcbcfb3e65be74538dfb6e8dd16178fde"
+  integrity sha512-DdePVk1NDEuc3fOe3dPPTb+rjMtuFw89gw6gVWxQFAuEqqSdDKnrwzZHrUYdac7A7dXl9Q2Vflxpme15gUWQFA==
+
+"@rollup/rollup-linux-x64-gnu@4.34.8":
+  version "4.34.8"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.34.8.tgz#5783fc0adcab7dc069692056e8ca8d83709855ce"
+  integrity sha512-8y7ED8gjxITUltTUEJLQdgpbPh1sUQ0kMTmufRF/Ns5tI9TNMNlhWtmPKKHCU0SilX+3MJkZ0zERYYGIVBYHIA==
+
+"@rollup/rollup-linux-x64-musl@4.34.8":
+  version "4.34.8"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.34.8.tgz#00b6c29b298197a384e3c659910b47943003a678"
+  integrity sha512-SCXcP0ZpGFIe7Ge+McxY5zKxiEI5ra+GT3QRxL0pMMtxPfpyLAKleZODi1zdRHkz5/BhueUrYtYVgubqe9JBNQ==
+
+"@rollup/rollup-win32-arm64-msvc@4.34.8":
+  version "4.34.8"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.34.8.tgz#cbfee01f1fe73791c35191a05397838520ca3cdd"
+  integrity sha512-YHYsgzZgFJzTRbth4h7Or0m5O74Yda+hLin0irAIobkLQFRQd1qWmnoVfwmKm9TXIZVAD0nZ+GEb2ICicLyCnQ==
+
+"@rollup/rollup-win32-ia32-msvc@4.34.8":
+  version "4.34.8"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.34.8.tgz#95cdbdff48fe6c948abcf6a1d500b2bd5ce33f62"
+  integrity sha512-r3NRQrXkHr4uWy5TOjTpTYojR9XmF0j/RYgKCef+Ag46FWUTltm5ziticv8LdNsDMehjJ543x/+TJAek/xBA2w==
+
+"@rollup/rollup-win32-x64-msvc@4.34.8":
+  version "4.34.8"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.34.8.tgz#4cdb2cfae69cdb7b1a3cc58778e820408075e928"
+  integrity sha512-U0FaE5O1BCpZSeE6gBl3c5ObhePQSfk9vDRToMmTkbhCOgW4jqvtS5LGyQ76L1fH8sM0keRp4uDTsbjiUyjk0g==
+
+"@rx-state/core@^0.1.4":
+  version "0.1.4"
+  resolved "https://registry.npmjs.org/@rx-state/core/-/core-0.1.4.tgz"
+  integrity sha512-Z+3hjU2xh1HisLxt+W5hlYX/eGSDaXXP+ns82gq/PLZpkXLu0uwcNUh9RLY3Clq4zT+hSsA3vcpIGt6+UAb8rQ==
+
+"@scure/base@^1.1.1", "@scure/base@^1.1.7", "@scure/base@^1.2.1", "@scure/base@^1.2.4", "@scure/base@^1.2.5", "@scure/base@~1.2.2", "@scure/base@~1.2.4":
+  version "1.2.5"
+  resolved "https://registry.npmjs.org/@scure/base/-/base-1.2.5.tgz"
+  integrity sha512-9rE6EOVeIQzt5TSu4v+K523F8u6DhBsoZWPGKlnCshhlDhy0kJzUX4V+tr2dWmzF1GdekvThABoEQBGBQI7xZw==
+
+"@scure/bip32@1.6.2", "@scure/bip32@^1.5.0":
+  version "1.6.2"
+  resolved "https://registry.npmjs.org/@scure/bip32/-/bip32-1.6.2.tgz"
+  integrity sha512-t96EPDMbtGgtb7onKKqxRLfE5g05k7uHnHRM2xdE6BP/ZmxaLtPek4J4KfVn/90IQNrU1IOAqMgiDtUdtbe3nw==
+  dependencies:
+    "@noble/curves" "~1.8.1"
+    "@noble/hashes" "~1.7.1"
+    "@scure/base" "~1.2.2"
+
+"@scure/bip39@1.5.4", "@scure/bip39@^1.4.0":
+  version "1.5.4"
+  resolved "https://registry.npmjs.org/@scure/bip39/-/bip39-1.5.4.tgz"
+  integrity sha512-TFM4ni0vKvCfBpohoh+/lY05i9gRbSwXWngAsF4CABQxoaOHijxuaZ2R6cStDQ5CHtHO9aGJTr4ksVJASRRyMA==
+  dependencies:
+    "@noble/hashes" "~1.7.1"
+    "@scure/base" "~1.2.4"
+
+"@sec-ant/readable-stream@^0.4.1":
+  version "0.4.1"
+  resolved "https://registry.npmjs.org/@sec-ant/readable-stream/-/readable-stream-0.4.1.tgz"
+  integrity sha512-831qok9r2t8AlxLko40y2ebgSDhenenCatLVeW/uBtnHPyhHOvG0C7TvfgecV+wHzIm5KUICgzmVpWS+IMEAeg==
+
+"@sindresorhus/merge-streams@^4.0.0":
+  version "4.0.0"
+  resolved "https://registry.npmjs.org/@sindresorhus/merge-streams/-/merge-streams-4.0.0.tgz"
+  integrity sha512-tlqY9xq5ukxTUZBmoOp+m61cqwQD5pHJtFY3Mn8CA8ps6yghLH/Hw8UPdqg4OLmFW3IFlcXnQNmo/dh8HzXYIQ==
+
+"@substrate/connect-extension-protocol@^2.0.0":
+  version "2.2.2"
+  resolved "https://registry.npmjs.org/@substrate/connect-extension-protocol/-/connect-extension-protocol-2.2.2.tgz"
+  integrity sha512-t66jwrXA0s5Goq82ZtjagLNd7DPGCNjHeehRlE/gcJmJ+G56C0W+2plqOMRicJ8XGR1/YFnUSEqUFiSNbjGrAA==
+
+"@substrate/connect-known-chains@^1.1.5":
+  version "1.9.2"
+  resolved "https://registry.npmjs.org/@substrate/connect-known-chains/-/connect-known-chains-1.9.2.tgz"
+  integrity sha512-uEmm+rKJQQhhbforvmcg74TsDHKFVBkstjPwblGT1RdHMxUKR7Gq7F8vbkGnr5ce9tMK2Ylil760Z7vtX013hw==
+
+"@substrate/connect@0.8.11":
+  version "0.8.11"
+  resolved "https://registry.npmjs.org/@substrate/connect/-/connect-0.8.11.tgz"
+  integrity sha512-ofLs1PAO9AtDdPbdyTYj217Pe+lBfTLltdHDs3ds8no0BseoLeAGxpz1mHfi7zB4IxI3YyAiLjH6U8cw4pj4Nw==
+  dependencies:
+    "@substrate/connect-extension-protocol" "^2.0.0"
+    "@substrate/connect-known-chains" "^1.1.5"
+    "@substrate/light-client-extension-helpers" "^1.0.0"
+    smoldot "2.0.26"
+
+"@substrate/light-client-extension-helpers@^1.0.0":
+  version "1.0.0"
+  resolved "https://registry.npmjs.org/@substrate/light-client-extension-helpers/-/light-client-extension-helpers-1.0.0.tgz"
+  integrity sha512-TdKlni1mBBZptOaeVrKnusMg/UBpWUORNDv5fdCaJklP4RJiFOzBCrzC+CyVI5kQzsXBisZ+2pXm+rIjS38kHg==
+  dependencies:
+    "@polkadot-api/json-rpc-provider" "^0.0.1"
+    "@polkadot-api/json-rpc-provider-proxy" "^0.1.0"
+    "@polkadot-api/observable-client" "^0.3.0"
+    "@polkadot-api/substrate-client" "^0.1.2"
+    "@substrate/connect-extension-protocol" "^2.0.0"
+    "@substrate/connect-known-chains" "^1.1.5"
+    rxjs "^7.8.1"
+
+"@substrate/ss58-registry@^1.51.0":
+  version "1.51.0"
+  resolved "https://registry.npmjs.org/@substrate/ss58-registry/-/ss58-registry-1.51.0.tgz"
+  integrity sha512-TWDurLiPxndFgKjVavCniytBIw+t4ViOi7TYp9h/D0NMmkEc9klFTo+827eyEJ0lELpqO207Ey7uGxUa+BS1jQ==
+
+"@tsconfig/node10@^1.0.7":
+  version "1.0.11"
+  resolved "https://registry.npmjs.org/@tsconfig/node10/-/node10-1.0.11.tgz"
+  integrity sha512-DcRjDCujK/kCk/cUe8Xz8ZSpm8mS3mNNpta+jGCA6USEDfktlNvm1+IuZ9eTcDbNk41BHwpHHeW+N1lKCz4zOw==
+
+"@tsconfig/node12@^1.0.7":
+  version "1.0.11"
+  resolved "https://registry.npmjs.org/@tsconfig/node12/-/node12-1.0.11.tgz"
+  integrity sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag==
+
+"@tsconfig/node14@^1.0.0":
+  version "1.0.3"
+  resolved "https://registry.npmjs.org/@tsconfig/node14/-/node14-1.0.3.tgz"
+  integrity sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow==
+
+"@tsconfig/node16@^1.0.2":
+  version "1.0.4"
+  resolved "https://registry.npmjs.org/@tsconfig/node16/-/node16-1.0.4.tgz"
+  integrity sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA==
+
+"@types/bn.js@^5.1.6":
+  version "5.1.6"
+  resolved "https://registry.npmjs.org/@types/bn.js/-/bn.js-5.1.6.tgz"
+  integrity sha512-Xh8vSwUeMKeYYrj3cX4lGQgFSF/N03r+tv4AiLl1SucqV+uTQpxRcnM8AkXKHwYP9ZPXOYXRr2KPXpVlIvqh9w==
+  dependencies:
+    "@types/node" "*"
+
+"@types/bun@^1.1.13":
+  version "1.2.3"
+  resolved "https://registry.npmjs.org/@types/bun/-/bun-1.2.3.tgz"
+  integrity sha512-054h79ipETRfjtsCW9qJK8Ipof67Pw9bodFWmkfkaUaRiIQ1dIV2VTlheshlBx3mpKr0KeK8VqnMMCtgN9rQtw==
+  dependencies:
+    bun-types "1.2.3"
+
+"@types/chai@^5.0.1":
+  version "5.0.1"
+  resolved "https://registry.npmjs.org/@types/chai/-/chai-5.0.1.tgz"
+  integrity sha512-5T8ajsg3M/FOncpLYW7sdOcD6yf4+722sze/tc4KQV0P8Z2rAr3SAuHCIkYmYpt8VbcQlnz8SxlOlPQYefe4cA==
+  dependencies:
+    "@types/deep-eql" "*"
+
+"@types/deep-eql@*":
+  version "4.0.2"
+  resolved "https://registry.npmjs.org/@types/deep-eql/-/deep-eql-4.0.2.tgz"
+  integrity sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==
+
+"@types/estree@1.0.6":
+  version "1.0.6"
+  resolved "https://registry.npmjs.org/@types/estree/-/estree-1.0.6.tgz"
+  integrity sha512-AYnb1nQyY49te+VRAVgmzfcgjYS91mY5P0TKUDCLEM+gNnA+3T6rWITXRLYCpahpqSQbN5cE+gHpnPyXjHWxcw==
+
+"@types/mocha@^10.0.10":
+  version "10.0.10"
+  resolved "https://registry.npmjs.org/@types/mocha/-/mocha-10.0.10.tgz"
+  integrity sha512-xPyYSz1cMPnJQhl0CLMH68j3gprKZaTjG3s5Vi+fDgx+uhG9NOXwbVt52eFS8ECyXhyKcjDLCBEqBExKuiZb7Q==
+
+"@types/node@*", "@types/node@^22.15.18", "@types/node@^22.9.0":
+  version "22.15.21"
+  resolved "https://registry.npmjs.org/@types/node/-/node-22.15.21.tgz"
+  integrity sha512-EV/37Td6c+MgKAbkcLG6vqZ2zEYHD7bvSrzqqs2RIhbA6w3x+Dqz8MZM3sP6kGTeLrdoOgKZe+Xja7tUB2DNkQ==
+  dependencies:
+    undici-types "~6.21.0"
+
+"@types/node@22.7.5":
+  version "22.7.5"
+  resolved "https://registry.npmjs.org/@types/node/-/node-22.7.5.tgz"
+  integrity sha512-jML7s2NAzMWc//QSJ1a3prpk78cOPchGvXJsC3C6R6PSMoooztvRVQEz89gmBTBY1SPMaqo5teB4uNHPdetShQ==
+  dependencies:
+    undici-types "~6.19.2"
+
+"@types/normalize-package-data@^2.4.3":
+  version "2.4.4"
+  resolved "https://registry.npmjs.org/@types/normalize-package-data/-/normalize-package-data-2.4.4.tgz"
+  integrity sha512-37i+OaWTh9qeK4LSHPsyRC7NahnGotNuZvjLSgcPzblpHB3rrCJxAOgI5gCdKm7coonsaX1Of0ILiTcnZjbfxA==
+
+"@types/ws@~8.5.10":
+  version "8.5.14"
+  resolved "https://registry.npmjs.org/@types/ws/-/ws-8.5.14.tgz"
+  integrity sha512-bd/YFLW+URhBzMXurx7lWByOu+xzU9+kb3RboOteXYDfW+tr+JZa99OyNmPINEGB/ahzKrEuc8rcv4gnpJmxTw==
+  dependencies:
+    "@types/node" "*"
+
+abitype@1.0.8, abitype@^1.0.6:
+  version "1.0.8"
+  resolved "https://registry.npmjs.org/abitype/-/abitype-1.0.8.tgz"
+  integrity sha512-ZeiI6h3GnW06uYDLx0etQtX/p8E24UaHHBj57RSjK7YBFe7iuVn07EDpOeP451D06sF27VOz9JJPlIKJmXgkEg==
+
+acorn-walk@^8.1.1:
+  version "8.3.4"
+  resolved "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.3.4.tgz"
+  integrity sha512-ueEepnujpqee2o5aIYnvHU6C0A42MNdsIDeqy5BydrkuC5R1ZuUFnm27EeFJGoEHJQgn3uleRvmTXaJgfXbt4g==
+  dependencies:
+    acorn "^8.11.0"
+
+acorn@^8.11.0, acorn@^8.14.0, acorn@^8.4.1:
+  version "8.14.0"
+  resolved "https://registry.npmjs.org/acorn/-/acorn-8.14.0.tgz"
+  integrity sha512-cl669nCJTZBsL97OF4kUQm5g5hC2uihk0NxY3WENAC0TYdILVkAyHymAntgxGkl7K+t0cXIrH5siy5S4XkFycA==
+
+aes-js@4.0.0-beta.5:
+  version "4.0.0-beta.5"
+  resolved "https://registry.npmjs.org/aes-js/-/aes-js-4.0.0-beta.5.tgz"
+  integrity sha512-G965FqalsNyrPqgEGON7nIx1e/OVENSgiEIzyC63haUMuvNnwIgIjMs52hlTCKhkBny7A2ORNlfY9Zu+jmGk1Q==
+
+ansi-colors@^4.1.3:
+  version "4.1.3"
+  resolved "https://registry.npmjs.org/ansi-colors/-/ansi-colors-4.1.3.tgz"
+  integrity sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw==
+
+ansi-regex@^5.0.1:
+  version "5.0.1"
+  resolved "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz"
+  integrity sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==
+
+ansi-regex@^6.0.1:
+  version "6.1.0"
+  resolved "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.1.0.tgz"
+  integrity sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==
+
+ansi-styles@^4.0.0, ansi-styles@^4.1.0:
+  version "4.3.0"
+  resolved "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz"
+  integrity sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==
+  dependencies:
+    color-convert "^2.0.1"
+
+ansi-styles@^6.1.0:
+  version "6.2.1"
+  resolved "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.1.tgz"
+  integrity sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==
+
+any-promise@^1.0.0:
+  version "1.3.0"
+  resolved "https://registry.npmjs.org/any-promise/-/any-promise-1.3.0.tgz"
+  integrity sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A==
+
+anymatch@~3.1.2:
+  version "3.1.3"
+  resolved "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz"
+  integrity sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==
+  dependencies:
+    normalize-path "^3.0.0"
+    picomatch "^2.0.4"
+
+arg@^4.1.0:
+  version "4.1.3"
+  resolved "https://registry.npmjs.org/arg/-/arg-4.1.3.tgz"
+  integrity sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==
+
+argparse@^2.0.1:
+  version "2.0.1"
+  resolved "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz"
+  integrity sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==
+
+assert@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.npmjs.org/assert/-/assert-2.1.0.tgz"
+  integrity sha512-eLHpSK/Y4nhMJ07gDaAzoX/XAKS8PSaojml3M0DM4JpV1LAi5JOJ/p6H/XWrl8L+DzVEvVCW1z3vWAaB9oTsQw==
+  dependencies:
+    call-bind "^1.0.2"
+    is-nan "^1.3.2"
+    object-is "^1.1.5"
+    object.assign "^4.1.4"
+    util "^0.12.5"
+
+assertion-error@^2.0.1:
+  version "2.0.1"
+  resolved "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz"
+  integrity sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==
+
+available-typed-arrays@^1.0.7:
+  version "1.0.7"
+  resolved "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.7.tgz"
+  integrity sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==
+  dependencies:
+    possible-typed-array-names "^1.0.0"
+
+balanced-match@^1.0.0:
+  version "1.0.2"
+  resolved "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz"
+  integrity sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==
+
+binary-extensions@^2.0.0:
+  version "2.3.0"
+  resolved "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.3.0.tgz"
+  integrity sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==
+
+bn.js@^5.2.1:
+  version "5.2.1"
+  resolved "https://registry.npmjs.org/bn.js/-/bn.js-5.2.1.tgz"
+  integrity sha512-eXRvHzWyYPBuB4NBy0cmYQjGitUrtqwbvlzP3G6VFnNRbsZQIxQ10PbKKHt8gZ/HW/D/747aDl+QkDqg3KQLMQ==
+
+brace-expansion@^2.0.1:
+  version "2.0.1"
+  resolved "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz"
+  integrity sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==
+  dependencies:
+    balanced-match "^1.0.0"
+
+braces@~3.0.2:
+  version "3.0.3"
+  resolved "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz"
+  integrity sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==
+  dependencies:
+    fill-range "^7.1.1"
+
+browser-stdout@^1.3.1:
+  version "1.3.1"
+  resolved "https://registry.npmjs.org/browser-stdout/-/browser-stdout-1.3.1.tgz"
+  integrity sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw==
+
+bun-types@1.2.3:
+  version "1.2.3"
+  resolved "https://registry.npmjs.org/bun-types/-/bun-types-1.2.3.tgz"
+  integrity sha512-P7AeyTseLKAvgaZqQrvp3RqFM3yN9PlcLuSTe7SoJOfZkER73mLdT2vEQi8U64S1YvM/ldcNiQjn0Sn7H9lGgg==
+  dependencies:
+    "@types/node" "*"
+    "@types/ws" "~8.5.10"
+
+bundle-require@^5.1.0:
+  version "5.1.0"
+  resolved "https://registry.npmjs.org/bundle-require/-/bundle-require-5.1.0.tgz"
+  integrity sha512-3WrrOuZiyaaZPWiEt4G3+IffISVC9HYlWueJEBWED4ZH4aIAC2PnkdnuRrR94M+w6yGWn4AglWtJtBI8YqvgoA==
+  dependencies:
+    load-tsconfig "^0.2.3"
+
+cac@^6.7.14:
+  version "6.7.14"
+  resolved "https://registry.npmjs.org/cac/-/cac-6.7.14.tgz"
+  integrity sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==
+
+call-bind-apply-helpers@^1.0.0, call-bind-apply-helpers@^1.0.1, call-bind-apply-helpers@^1.0.2:
+  version "1.0.2"
+  resolved "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz"
+  integrity sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==
+  dependencies:
+    es-errors "^1.3.0"
+    function-bind "^1.1.2"
+
+call-bind@^1.0.0, call-bind@^1.0.2, call-bind@^1.0.7, call-bind@^1.0.8:
+  version "1.0.8"
+  resolved "https://registry.npmjs.org/call-bind/-/call-bind-1.0.8.tgz"
+  integrity sha512-oKlSFMcMwpUg2ednkhQ454wfWiU/ul3CkJe/PEHcTKuiX6RpbehUiFMXu13HalGZxfUwCQzZG747YXBn1im9ww==
+  dependencies:
+    call-bind-apply-helpers "^1.0.0"
+    es-define-property "^1.0.0"
+    get-intrinsic "^1.2.4"
+    set-function-length "^1.2.2"
+
+call-bound@^1.0.2, call-bound@^1.0.3:
+  version "1.0.3"
+  resolved "https://registry.npmjs.org/call-bound/-/call-bound-1.0.3.tgz"
+  integrity sha512-YTd+6wGlNlPxSuri7Y6X8tY2dmm12UMH66RpKMhiX6rsk5wXXnYgbUcOt8kiS31/AjfoTOvCsE+w8nZQLQnzHA==
+  dependencies:
+    call-bind-apply-helpers "^1.0.1"
+    get-intrinsic "^1.2.6"
+
+camelcase@^6.0.0:
+  version "6.3.0"
+  resolved "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz"
+  integrity sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==
+
+chai@^5.2.0:
+  version "5.2.0"
+  resolved "https://registry.npmjs.org/chai/-/chai-5.2.0.tgz"
+  integrity sha512-mCuXncKXk5iCLhfhwTc0izo0gtEmpz5CtG2y8GiOINBlMVS6v8TMRc5TaLWKS6692m9+dVVfzgeVxR5UxWHTYw==
+  dependencies:
+    assertion-error "^2.0.1"
+    check-error "^2.1.1"
+    deep-eql "^5.0.1"
+    loupe "^3.1.0"
+    pathval "^2.0.0"
+
+chalk@^4.1.0:
+  version "4.1.2"
+  resolved "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz"
+  integrity sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==
+  dependencies:
+    ansi-styles "^4.1.0"
+    supports-color "^7.1.0"
+
+chalk@^5.3.0:
+  version "5.4.1"
+  resolved "https://registry.npmjs.org/chalk/-/chalk-5.4.1.tgz"
+  integrity sha512-zgVZuo2WcZgfUEmsn6eO3kINexW8RAE4maiQ8QNs8CtpPCSyMiYsULR3HQYkm3w8FIA3SberyMJMSldGsW+U3w==
+
+check-error@^2.1.1:
+  version "2.1.1"
+  resolved "https://registry.npmjs.org/check-error/-/check-error-2.1.1.tgz"
+  integrity sha512-OAlb+T7V4Op9OwdkjmguYRqncdlx5JiofwOAUkmTF+jNdHwzTaTs4sRAGpzLF3oOz5xAyDGrPgeIDFQmDOTiJw==
+
+chokidar@^3.5.3:
+  version "3.6.0"
+  resolved "https://registry.npmjs.org/chokidar/-/chokidar-3.6.0.tgz"
+  integrity sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==
+  dependencies:
+    anymatch "~3.1.2"
+    braces "~3.0.2"
+    glob-parent "~5.1.2"
+    is-binary-path "~2.1.0"
+    is-glob "~4.0.1"
+    normalize-path "~3.0.0"
+    readdirp "~3.6.0"
+  optionalDependencies:
+    fsevents "~2.3.2"
+
+chokidar@^4.0.3:
+  version "4.0.3"
+  resolved "https://registry.npmjs.org/chokidar/-/chokidar-4.0.3.tgz"
+  integrity sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA==
+  dependencies:
+    readdirp "^4.0.1"
+
+cli-cursor@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.npmjs.org/cli-cursor/-/cli-cursor-5.0.0.tgz"
+  integrity sha512-aCj4O5wKyszjMmDT4tZj93kxyydN/K5zPWSCe6/0AV/AA1pqe5ZBIw0a2ZfPQV7lL5/yb5HsUreJ6UFAF1tEQw==
+  dependencies:
+    restore-cursor "^5.0.0"
+
+cli-spinners@^2.9.2:
+  version "2.9.2"
+  resolved "https://registry.npmjs.org/cli-spinners/-/cli-spinners-2.9.2.tgz"
+  integrity sha512-ywqV+5MmyL4E7ybXgKys4DugZbX0FC6LnwrhjuykIjnK9k8OQacQ7axGKnjDXWNhns0xot3bZI5h55H8yo9cJg==
+
+cliui@^8.0.1:
+  version "8.0.1"
+  resolved "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz"
+  integrity sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==
+  dependencies:
+    string-width "^4.2.0"
+    strip-ansi "^6.0.1"
+    wrap-ansi "^7.0.0"
+
+color-convert@^2.0.1:
+  version "2.0.1"
+  resolved "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz"
+  integrity sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==
+  dependencies:
+    color-name "~1.1.4"
+
+color-name@~1.1.4:
+  version "1.1.4"
+  resolved "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz"
+  integrity sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==
+
+commander@^13.1.0:
+  version "13.1.0"
+  resolved "https://registry.npmjs.org/commander/-/commander-13.1.0.tgz"
+  integrity sha512-/rFeCpNJQbhSZjGVwO9RFV3xPqbnERS8MmIQzCtD/zl6gpJuV/bMLuN92oG3F7d8oDEHHRrujSXNUr8fpjntKw==
+
+commander@^4.0.0:
+  version "4.1.1"
+  resolved "https://registry.npmjs.org/commander/-/commander-4.1.1.tgz"
+  integrity sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA==
+
+confbox@^0.1.8:
+  version "0.1.8"
+  resolved "https://registry.npmjs.org/confbox/-/confbox-0.1.8.tgz"
+  integrity sha512-RMtmw0iFkeR4YV+fUOSucriAQNb9g8zFR52MWCtl+cCZOFRNL6zeB395vPzFhEjjn4fMxXudmELnl/KF/WrK6w==
+
+consola@^3.4.0:
+  version "3.4.2"
+  resolved "https://registry.npmjs.org/consola/-/consola-3.4.2.tgz"
+  integrity sha512-5IKcdX0nnYavi6G7TtOhwkYzyjfJlatbjMjuLSfE2kYT5pMDOilZ4OvMhi637CcDICTmz3wARPoyhqyX1Y+XvA==
+
+create-require@^1.1.0:
+  version "1.1.1"
+  resolved "https://registry.npmjs.org/create-require/-/create-require-1.1.1.tgz"
+  integrity sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==
+
+cross-spawn@^7.0.6:
+  version "7.0.6"
+  resolved "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz"
+  integrity sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==
+  dependencies:
+    path-key "^3.1.0"
+    shebang-command "^2.0.0"
+    which "^2.0.1"
+
+crypto@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.npmjs.org/crypto/-/crypto-1.0.1.tgz"
+  integrity sha512-VxBKmeNcqQdiUQUW2Tzq0t377b54N2bMtXO/qiLa+6eRRmmC4qT3D4OnTGoT/U6O9aklQ/jTwbOtRMTTY8G0Ig==
+
+data-uri-to-buffer@^4.0.0:
+  version "4.0.1"
+  resolved "https://registry.npmjs.org/data-uri-to-buffer/-/data-uri-to-buffer-4.0.1.tgz"
+  integrity sha512-0R9ikRb668HB7QDxT1vkpuUBtqc53YyAwMwGeUFKRojY/NWKvdZ+9UYtRfGmhqNbRkTSVpMbmyhXipFFv2cb/A==
+
+debug@^4.1.0, debug@^4.3.5, debug@^4.4.0:
+  version "4.4.0"
+  resolved "https://registry.npmjs.org/debug/-/debug-4.4.0.tgz"
+  integrity sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==
+  dependencies:
+    ms "^2.1.3"
+
+decamelize@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.npmjs.org/decamelize/-/decamelize-4.0.0.tgz"
+  integrity sha512-9iE1PgSik9HeIIw2JO94IidnE3eBoQrFJ3w7sFuzSX4DpmZ3v5sZpUiV5Swcf6mQEF+Y0ru8Neo+p+nyh2J+hQ==
+
+deep-eql@^5.0.1:
+  version "5.0.2"
+  resolved "https://registry.npmjs.org/deep-eql/-/deep-eql-5.0.2.tgz"
+  integrity sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q==
+
+deepmerge-ts@^7.1.0:
+  version "7.1.5"
+  resolved "https://registry.npmjs.org/deepmerge-ts/-/deepmerge-ts-7.1.5.tgz"
+  integrity sha512-HOJkrhaYsweh+W+e74Yn7YStZOilkoPb6fycpwNLKzSPtruFs48nYis0zy5yJz1+ktUhHxoRDJ27RQAWLIJVJw==
+
+define-data-property@^1.0.1, define-data-property@^1.1.4:
+  version "1.1.4"
+  resolved "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.4.tgz"
+  integrity sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==
+  dependencies:
+    es-define-property "^1.0.0"
+    es-errors "^1.3.0"
+    gopd "^1.0.1"
+
+define-properties@^1.1.3, define-properties@^1.2.1:
+  version "1.2.1"
+  resolved "https://registry.npmjs.org/define-properties/-/define-properties-1.2.1.tgz"
+  integrity sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==
+  dependencies:
+    define-data-property "^1.0.1"
+    has-property-descriptors "^1.0.0"
+    object-keys "^1.1.1"
+
+detect-indent@^7.0.1:
+  version "7.0.1"
+  resolved "https://registry.npmjs.org/detect-indent/-/detect-indent-7.0.1.tgz"
+  integrity sha512-Mc7QhQ8s+cLrnUfU/Ji94vG/r8M26m8f++vyres4ZoojaRDpZ1eSIh/EpzLNwlWuvzSZ3UbDFspjFvTDXe6e/g==
+
+diff@^4.0.1:
+  version "4.0.2"
+  resolved "https://registry.npmjs.org/diff/-/diff-4.0.2.tgz"
+  integrity sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==
+
+diff@^5.2.0:
+  version "5.2.0"
+  resolved "https://registry.npmjs.org/diff/-/diff-5.2.0.tgz"
+  integrity sha512-uIFDxqpRZGZ6ThOk84hEfqWoHx2devRFvpTZcTHur85vImfaxUbTW9Ryh4CpCuDnToOP1CEtXKIgytHBPVff5A==
+
+dotenv@16.4.7:
+  version "16.4.7"
+  resolved "https://registry.npmjs.org/dotenv/-/dotenv-16.4.7.tgz"
+  integrity sha512-47qPchRCykZC03FhkYAhrvwU4xDBFIj1QPqaarj6mdM/hgUzfPHcpkHJOn3mJAufFeeAxAzeGsr5X0M4k6fLZQ==
+
+dunder-proto@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz"
+  integrity sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==
+  dependencies:
+    call-bind-apply-helpers "^1.0.1"
+    es-errors "^1.3.0"
+    gopd "^1.2.0"
+
+eastasianwidth@^0.2.0:
+  version "0.2.0"
+  resolved "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz"
+  integrity sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==
+
+emoji-regex@^10.3.0:
+  version "10.4.0"
+  resolved "https://registry.npmjs.org/emoji-regex/-/emoji-regex-10.4.0.tgz"
+  integrity sha512-EC+0oUMY1Rqm4O6LLrgjtYDvcVYTy7chDnM4Q7030tP4Kwj3u/pR6gP9ygnp2CJMK5Gq+9Q2oqmrFJAz01DXjw==
+
+emoji-regex@^8.0.0:
+  version "8.0.0"
+  resolved "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz"
+  integrity sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==
+
+emoji-regex@^9.2.2:
+  version "9.2.2"
+  resolved "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz"
+  integrity sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==
+
+es-define-property@^1.0.0, es-define-property@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz"
+  integrity sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==
+
+es-errors@^1.3.0:
+  version "1.3.0"
+  resolved "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz"
+  integrity sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==
+
+es-object-atoms@^1.0.0, es-object-atoms@^1.1.1:
+  version "1.1.1"
+  resolved "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz"
+  integrity sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==
+  dependencies:
+    es-errors "^1.3.0"
+
+esbuild@^0.21.3:
+  version "0.21.5"
+  resolved "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz"
+  integrity sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==
+  optionalDependencies:
+    "@esbuild/aix-ppc64" "0.21.5"
+    "@esbuild/android-arm" "0.21.5"
+    "@esbuild/android-arm64" "0.21.5"
+    "@esbuild/android-x64" "0.21.5"
+    "@esbuild/darwin-arm64" "0.21.5"
+    "@esbuild/darwin-x64" "0.21.5"
+    "@esbuild/freebsd-arm64" "0.21.5"
+    "@esbuild/freebsd-x64" "0.21.5"
+    "@esbuild/linux-arm" "0.21.5"
+    "@esbuild/linux-arm64" "0.21.5"
+    "@esbuild/linux-ia32" "0.21.5"
+    "@esbuild/linux-loong64" "0.21.5"
+    "@esbuild/linux-mips64el" "0.21.5"
+    "@esbuild/linux-ppc64" "0.21.5"
+    "@esbuild/linux-riscv64" "0.21.5"
+    "@esbuild/linux-s390x" "0.21.5"
+    "@esbuild/linux-x64" "0.21.5"
+    "@esbuild/netbsd-x64" "0.21.5"
+    "@esbuild/openbsd-x64" "0.21.5"
+    "@esbuild/sunos-x64" "0.21.5"
+    "@esbuild/win32-arm64" "0.21.5"
+    "@esbuild/win32-ia32" "0.21.5"
+    "@esbuild/win32-x64" "0.21.5"
+
+esbuild@^0.25.0:
+  version "0.25.5"
+  resolved "https://registry.npmjs.org/esbuild/-/esbuild-0.25.5.tgz"
+  integrity sha512-P8OtKZRv/5J5hhz0cUAdu/cLuPIKXpQl1R9pZtvmHWQvrAUVd0UNIPT4IB4W3rNOqVO0rlqHmCIbSwxh/c9yUQ==
+  optionalDependencies:
+    "@esbuild/aix-ppc64" "0.25.5"
+    "@esbuild/android-arm" "0.25.5"
+    "@esbuild/android-arm64" "0.25.5"
+    "@esbuild/android-x64" "0.25.5"
+    "@esbuild/darwin-arm64" "0.25.5"
+    "@esbuild/darwin-x64" "0.25.5"
+    "@esbuild/freebsd-arm64" "0.25.5"
+    "@esbuild/freebsd-x64" "0.25.5"
+    "@esbuild/linux-arm" "0.25.5"
+    "@esbuild/linux-arm64" "0.25.5"
+    "@esbuild/linux-ia32" "0.25.5"
+    "@esbuild/linux-loong64" "0.25.5"
+    "@esbuild/linux-mips64el" "0.25.5"
+    "@esbuild/linux-ppc64" "0.25.5"
+    "@esbuild/linux-riscv64" "0.25.5"
+    "@esbuild/linux-s390x" "0.25.5"
+    "@esbuild/linux-x64" "0.25.5"
+    "@esbuild/netbsd-arm64" "0.25.5"
+    "@esbuild/netbsd-x64" "0.25.5"
+    "@esbuild/openbsd-arm64" "0.25.5"
+    "@esbuild/openbsd-x64" "0.25.5"
+    "@esbuild/sunos-x64" "0.25.5"
+    "@esbuild/win32-arm64" "0.25.5"
+    "@esbuild/win32-ia32" "0.25.5"
+    "@esbuild/win32-x64" "0.25.5"
+
+escalade@^3.1.1:
+  version "3.2.0"
+  resolved "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz"
+  integrity sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==
+
+escape-string-regexp@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz"
+  integrity sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==
+
+ethers@^6.13.5:
+  version "6.13.5"
+  resolved "https://registry.npmjs.org/ethers/-/ethers-6.13.5.tgz"
+  integrity sha512-+knKNieu5EKRThQJWwqaJ10a6HE9sSehGeqWN65//wE7j47ZpFhKAnHB/JJFibwwg61I/koxaPsXbXpD/skNOQ==
+  dependencies:
+    "@adraffy/ens-normalize" "1.10.1"
+    "@noble/curves" "1.2.0"
+    "@noble/hashes" "1.3.2"
+    "@types/node" "22.7.5"
+    aes-js "4.0.0-beta.5"
+    tslib "2.7.0"
+    ws "8.17.1"
+
+eventemitter3@5.0.1, eventemitter3@^5.0.1:
+  version "5.0.1"
+  resolved "https://registry.npmjs.org/eventemitter3/-/eventemitter3-5.0.1.tgz"
+  integrity sha512-GWkBvjiSZK87ELrYOSESUYeVIc9mvLLf/nXalMOS5dYrgZq9o5OVkbZAVM06CVxYsCwH9BDZFPlQTlPA1j4ahA==
+
+execa@^9.5.3:
+  version "9.6.0"
+  resolved "https://registry.npmjs.org/execa/-/execa-9.6.0.tgz"
+  integrity sha512-jpWzZ1ZhwUmeWRhS7Qv3mhpOhLfwI+uAX4e5fOcXqwMR7EcJ0pj2kV1CVzHVMX/LphnKWD3LObjZCoJ71lKpHw==
+  dependencies:
+    "@sindresorhus/merge-streams" "^4.0.0"
+    cross-spawn "^7.0.6"
+    figures "^6.1.0"
+    get-stream "^9.0.0"
+    human-signals "^8.0.1"
+    is-plain-obj "^4.1.0"
+    is-stream "^4.0.1"
+    npm-run-path "^6.0.0"
+    pretty-ms "^9.2.0"
+    signal-exit "^4.1.0"
+    strip-final-newline "^4.0.0"
+    yoctocolors "^2.1.1"
+
+fdir@^6.4.4:
+  version "6.4.4"
+  resolved "https://registry.npmjs.org/fdir/-/fdir-6.4.4.tgz"
+  integrity sha512-1NZP+GK4GfuAv3PqKvxQRDMjdSRZjnkq7KfhlNrCNNlZ0ygQFpebfrnfnq/W7fpUnAv9aGWmY1zKx7FYL3gwhg==
+
+fetch-blob@^3.1.2, fetch-blob@^3.1.4:
+  version "3.2.0"
+  resolved "https://registry.npmjs.org/fetch-blob/-/fetch-blob-3.2.0.tgz"
+  integrity sha512-7yAQpD2UMJzLi1Dqv7qFYnPbaPx7ZfFK6PiIxQ4PfkGPyNyl2Ugx+a/umUonmKqjhM4DnfbMvdX6otXq83soQQ==
+  dependencies:
+    node-domexception "^1.0.0"
+    web-streams-polyfill "^3.0.3"
+
+figures@^6.1.0:
+  version "6.1.0"
+  resolved "https://registry.npmjs.org/figures/-/figures-6.1.0.tgz"
+  integrity sha512-d+l3qxjSesT4V7v2fh+QnmFnUWv9lSpjarhShNTgBOfA0ttejbQUAlHLitbjkoRiDulW0OPoQPYIGhIC8ohejg==
+  dependencies:
+    is-unicode-supported "^2.0.0"
+
+fill-range@^7.1.1:
+  version "7.1.1"
+  resolved "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz"
+  integrity sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==
+  dependencies:
+    to-regex-range "^5.0.1"
+
+find-up@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz"
+  integrity sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==
+  dependencies:
+    locate-path "^6.0.0"
+    path-exists "^4.0.0"
+
+fix-dts-default-cjs-exports@^1.0.0:
+  version "1.0.1"
+  resolved "https://registry.npmjs.org/fix-dts-default-cjs-exports/-/fix-dts-default-cjs-exports-1.0.1.tgz"
+  integrity sha512-pVIECanWFC61Hzl2+oOCtoJ3F17kglZC/6N94eRWycFgBH35hHx0Li604ZIzhseh97mf2p0cv7vVrOZGoqhlEg==
+  dependencies:
+    magic-string "^0.30.17"
+    mlly "^1.7.4"
+    rollup "^4.34.8"
+
+flat@^5.0.2:
+  version "5.0.2"
+  resolved "https://registry.npmjs.org/flat/-/flat-5.0.2.tgz"
+  integrity sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==
+
+for-each@^0.3.3:
+  version "0.3.5"
+  resolved "https://registry.npmjs.org/for-each/-/for-each-0.3.5.tgz"
+  integrity sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg==
+  dependencies:
+    is-callable "^1.2.7"
+
+foreground-child@^3.1.0:
+  version "3.3.1"
+  resolved "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.1.tgz"
+  integrity sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==
+  dependencies:
+    cross-spawn "^7.0.6"
+    signal-exit "^4.0.1"
+
+formdata-polyfill@^4.0.10:
+  version "4.0.10"
+  resolved "https://registry.npmjs.org/formdata-polyfill/-/formdata-polyfill-4.0.10.tgz"
+  integrity sha512-buewHzMvYL29jdeQTVILecSaZKnt/RJWjoZCF5OW60Z67/GmSLBkOFM7qh1PI3zFNtJbaZL5eQu1vLfazOwj4g==
+  dependencies:
+    fetch-blob "^3.1.2"
+
+fs.promises.exists@^1.1.4:
+  version "1.1.4"
+  resolved "https://registry.npmjs.org/fs.promises.exists/-/fs.promises.exists-1.1.4.tgz"
+  integrity sha512-lJzUGWbZn8vhGWBedA+RYjB/BeJ+3458ljUfmplqhIeb6ewzTFWNPCR1HCiYCkXV9zxcHz9zXkJzMsEgDLzh3Q==
+
+fsevents@~2.3.2, fsevents@~2.3.3:
+  version "2.3.3"
+  resolved "https://registry.yarnpkg.com/fsevents/-/fsevents-2.3.3.tgz#cac6407785d03675a2a5e1a5305c697b347d90d6"
+  integrity sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==
+
+function-bind@^1.1.2:
+  version "1.1.2"
+  resolved "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz"
+  integrity sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==
+
+get-caller-file@^2.0.5:
+  version "2.0.5"
+  resolved "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz"
+  integrity sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==
+
+get-east-asian-width@^1.0.0:
+  version "1.3.0"
+  resolved "https://registry.npmjs.org/get-east-asian-width/-/get-east-asian-width-1.3.0.tgz"
+  integrity sha512-vpeMIQKxczTD/0s2CdEWHcb0eeJe6TFjxb+J5xgX7hScxqrGuyjmv4c1D4A/gelKfyox0gJJwIHF+fLjeaM8kQ==
+
+get-intrinsic@^1.2.4, get-intrinsic@^1.2.6:
+  version "1.3.0"
+  resolved "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz"
+  integrity sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==
+  dependencies:
+    call-bind-apply-helpers "^1.0.2"
+    es-define-property "^1.0.1"
+    es-errors "^1.3.0"
+    es-object-atoms "^1.1.1"
+    function-bind "^1.1.2"
+    get-proto "^1.0.1"
+    gopd "^1.2.0"
+    has-symbols "^1.1.0"
+    hasown "^2.0.2"
+    math-intrinsics "^1.1.0"
+
+get-proto@^1.0.0, get-proto@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz"
+  integrity sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==
+  dependencies:
+    dunder-proto "^1.0.1"
+    es-object-atoms "^1.0.0"
+
+get-stream@^9.0.0:
+  version "9.0.1"
+  resolved "https://registry.npmjs.org/get-stream/-/get-stream-9.0.1.tgz"
+  integrity sha512-kVCxPF3vQM/N0B1PmoqVUqgHP+EeVjmZSQn+1oCRPxd2P21P2F19lIgbR3HBosbB1PUhOAoctJnfEn2GbN2eZA==
+  dependencies:
+    "@sec-ant/readable-stream" "^0.4.1"
+    is-stream "^4.0.1"
+
+glob-parent@~5.1.2:
+  version "5.1.2"
+  resolved "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz"
+  integrity sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==
+  dependencies:
+    is-glob "^4.0.1"
+
+glob@^10.3.10, glob@^10.4.5:
+  version "10.4.5"
+  resolved "https://registry.npmjs.org/glob/-/glob-10.4.5.tgz"
+  integrity sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==
+  dependencies:
+    foreground-child "^3.1.0"
+    jackspeak "^3.1.2"
+    minimatch "^9.0.4"
+    minipass "^7.1.2"
+    package-json-from-dist "^1.0.0"
+    path-scurry "^1.11.1"
+
+gopd@^1.0.1, gopd@^1.2.0:
+  version "1.2.0"
+  resolved "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz"
+  integrity sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==
+
+has-flag@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz"
+  integrity sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==
+
+has-property-descriptors@^1.0.0, has-property-descriptors@^1.0.2:
+  version "1.0.2"
+  resolved "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz"
+  integrity sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==
+  dependencies:
+    es-define-property "^1.0.0"
+
+has-symbols@^1.0.3, has-symbols@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz"
+  integrity sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==
+
+has-tostringtag@^1.0.2:
+  version "1.0.2"
+  resolved "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz"
+  integrity sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==
+  dependencies:
+    has-symbols "^1.0.3"
+
+hasown@^2.0.2:
+  version "2.0.2"
+  resolved "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz"
+  integrity sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==
+  dependencies:
+    function-bind "^1.1.2"
+
+he@^1.2.0:
+  version "1.2.0"
+  resolved "https://registry.npmjs.org/he/-/he-1.2.0.tgz"
+  integrity sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==
+
+hosted-git-info@^7.0.0:
+  version "7.0.2"
+  resolved "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-7.0.2.tgz"
+  integrity sha512-puUZAUKT5m8Zzvs72XWy3HtvVbTWljRE66cP60bxJzAqf2DgICo7lYTY2IHUmLnNpjYvw5bvmoHvPc0QO2a62w==
+  dependencies:
+    lru-cache "^10.0.1"
+
+human-signals@^8.0.1:
+  version "8.0.1"
+  resolved "https://registry.npmjs.org/human-signals/-/human-signals-8.0.1.tgz"
+  integrity sha512-eKCa6bwnJhvxj14kZk5NCPc6Hb6BdsU9DZcOnmQKSnO1VKrfV0zCvtttPZUsBvjmNDn8rpcJfpwSYnHBjc95MQ==
+
+imurmurhash@^0.1.4:
+  version "0.1.4"
+  resolved "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz"
+  integrity sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==
+
+index-to-position@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.npmjs.org/index-to-position/-/index-to-position-1.1.0.tgz"
+  integrity sha512-XPdx9Dq4t9Qk1mTMbWONJqU7boCoumEH7fRET37HX5+khDUl3J2W6PdALxhILYlIYx2amlwYcRPp28p0tSiojg==
+
+inherits@^2.0.3:
+  version "2.0.4"
+  resolved "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz"
+  integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==
+
+is-arguments@^1.0.4:
+  version "1.2.0"
+  resolved "https://registry.npmjs.org/is-arguments/-/is-arguments-1.2.0.tgz"
+  integrity sha512-7bVbi0huj/wrIAOzb8U1aszg9kdi3KN/CyU19CTI7tAoZYEZoL9yCDXpbXN+uPsuWnP02cyug1gleqq+TU+YCA==
+  dependencies:
+    call-bound "^1.0.2"
+    has-tostringtag "^1.0.2"
+
+is-binary-path@~2.1.0:
+  version "2.1.0"
+  resolved "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz"
+  integrity sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==
+  dependencies:
+    binary-extensions "^2.0.0"
+
+is-callable@^1.2.7:
+  version "1.2.7"
+  resolved "https://registry.npmjs.org/is-callable/-/is-callable-1.2.7.tgz"
+  integrity sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==
+
+is-extglob@^2.1.1:
+  version "2.1.1"
+  resolved "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz"
+  integrity sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==
+
+is-fullwidth-code-point@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz"
+  integrity sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==
+
+is-generator-function@^1.0.7:
+  version "1.1.0"
+  resolved "https://registry.npmjs.org/is-generator-function/-/is-generator-function-1.1.0.tgz"
+  integrity sha512-nPUB5km40q9e8UfN/Zc24eLlzdSf9OfKByBw9CIdw4H1giPMeA0OIJvbchsCu4npfI2QcMVBsGEBHKZ7wLTWmQ==
+  dependencies:
+    call-bound "^1.0.3"
+    get-proto "^1.0.0"
+    has-tostringtag "^1.0.2"
+    safe-regex-test "^1.1.0"
+
+is-glob@^4.0.1, is-glob@~4.0.1:
+  version "4.0.3"
+  resolved "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz"
+  integrity sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==
+  dependencies:
+    is-extglob "^2.1.1"
+
+is-interactive@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.npmjs.org/is-interactive/-/is-interactive-2.0.0.tgz"
+  integrity sha512-qP1vozQRI+BMOPcjFzrjXuQvdak2pHNUMZoeG2eRbiSqyvbEf/wQtEOTOX1guk6E3t36RkaqiSt8A/6YElNxLQ==
+
+is-nan@^1.3.2:
+  version "1.3.2"
+  resolved "https://registry.npmjs.org/is-nan/-/is-nan-1.3.2.tgz"
+  integrity sha512-E+zBKpQ2t6MEo1VsonYmluk9NxGrbzpeeLC2xIViuO2EjU2xsXsBPwTr3Ykv9l08UYEVEdWeRZNouaZqF6RN0w==
+  dependencies:
+    call-bind "^1.0.0"
+    define-properties "^1.1.3"
+
+is-number@^7.0.0:
+  version "7.0.0"
+  resolved "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz"
+  integrity sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==
+
+is-plain-obj@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-2.1.0.tgz"
+  integrity sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==
+
+is-plain-obj@^4.0.0, is-plain-obj@^4.1.0:
+  version "4.1.0"
+  resolved "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-4.1.0.tgz"
+  integrity sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg==
+
+is-regex@^1.2.1:
+  version "1.2.1"
+  resolved "https://registry.npmjs.org/is-regex/-/is-regex-1.2.1.tgz"
+  integrity sha512-MjYsKHO5O7mCsmRGxWcLWheFqN9DJ/2TmngvjKXihe6efViPqc274+Fx/4fYj/r03+ESvBdTXK0V6tA3rgez1g==
+  dependencies:
+    call-bound "^1.0.2"
+    gopd "^1.2.0"
+    has-tostringtag "^1.0.2"
+    hasown "^2.0.2"
+
+is-stream@^4.0.1:
+  version "4.0.1"
+  resolved "https://registry.npmjs.org/is-stream/-/is-stream-4.0.1.tgz"
+  integrity sha512-Dnz92NInDqYckGEUJv689RbRiTSEHCQ7wOVeALbkOz999YpqT46yMRIGtSNl2iCL1waAZSx40+h59NV/EwzV/A==
+
+is-typed-array@^1.1.3:
+  version "1.1.15"
+  resolved "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.15.tgz"
+  integrity sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ==
+  dependencies:
+    which-typed-array "^1.1.16"
+
+is-unicode-supported@^0.1.0:
+  version "0.1.0"
+  resolved "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-0.1.0.tgz"
+  integrity sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw==
+
+is-unicode-supported@^1.3.0:
+  version "1.3.0"
+  resolved "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-1.3.0.tgz"
+  integrity sha512-43r2mRvz+8JRIKnWJ+3j8JtjRKZ6GmjzfaE/qiBJnikNnYv/6bagRJ1kUhNk8R5EX/GkobD+r+sfxCPJsiKBLQ==
+
+is-unicode-supported@^2.0.0:
+  version "2.1.0"
+  resolved "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-2.1.0.tgz"
+  integrity sha512-mE00Gnza5EEB3Ds0HfMyllZzbBrmLOX3vfWoj9A9PEnTfratQ/BcaJOuMhnkhjXvb2+FkY3VuHqtAGpTPmglFQ==
+
+isexe@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz"
+  integrity sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==
+
+isows@1.0.6:
+  version "1.0.6"
+  resolved "https://registry.npmjs.org/isows/-/isows-1.0.6.tgz"
+  integrity sha512-lPHCayd40oW98/I0uvgaHKWCSvkzY27LjWLbtzOm64yQ+G3Q5npjjbdppU65iZXkK1Zt+kH9pfegli0AYfwYYw==
+
+jackspeak@^3.1.2:
+  version "3.4.3"
+  resolved "https://registry.npmjs.org/jackspeak/-/jackspeak-3.4.3.tgz"
+  integrity sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==
+  dependencies:
+    "@isaacs/cliui" "^8.0.2"
+  optionalDependencies:
+    "@pkgjs/parseargs" "^0.11.0"
+
+joycon@^3.1.1:
+  version "3.1.1"
+  resolved "https://registry.npmjs.org/joycon/-/joycon-3.1.1.tgz"
+  integrity sha512-34wB/Y7MW7bzjKRjUKTa46I2Z7eV62Rkhva+KkopW7Qvv/OSWBqvkSY7vusOPrNuZcUG3tApvdVgNB8POj3SPw==
+
+js-tokens@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz"
+  integrity sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==
+
+js-yaml@^4.1.0:
+  version "4.1.0"
+  resolved "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz"
+  integrity sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==
+  dependencies:
+    argparse "^2.0.1"
+
+json-stringify-safe@^5.0.1:
+  version "5.0.1"
+  resolved "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz"
+  integrity sha512-ZClg6AaYvamvYEE82d3Iyd3vSSIjQ+odgjaTzRuO3s7toCdFKczob2i0zCh7JE8kWn17yvAWhUVxvqGwUalsRA==
+
+lilconfig@^3.1.1:
+  version "3.1.3"
+  resolved "https://registry.npmjs.org/lilconfig/-/lilconfig-3.1.3.tgz"
+  integrity sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw==
+
+lines-and-columns@^1.1.6:
+  version "1.2.4"
+  resolved "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz"
+  integrity sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==
+
+load-tsconfig@^0.2.3:
+  version "0.2.5"
+  resolved "https://registry.npmjs.org/load-tsconfig/-/load-tsconfig-0.2.5.tgz"
+  integrity sha512-IXO6OCs9yg8tMKzfPZ1YmheJbZCiEsnBdcB03l0OcfK9prKnJb96siuHCr5Fl37/yo9DnKU+TLpxzTUspw9shg==
+
+locate-path@^6.0.0:
+  version "6.0.0"
+  resolved "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz"
+  integrity sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==
+  dependencies:
+    p-locate "^5.0.0"
+
+lodash.sortby@^4.7.0:
+  version "4.7.0"
+  resolved "https://registry.npmjs.org/lodash.sortby/-/lodash.sortby-4.7.0.tgz"
+  integrity sha512-HDWXG8isMntAyRF5vZ7xKuEvOhT4AhlRt/3czTSjvGUxjYCBVRQY48ViDHyfYz9VIoBkW4TMGQNapx+l3RUwdA==
+
+log-symbols@^4.1.0:
+  version "4.1.0"
+  resolved "https://registry.npmjs.org/log-symbols/-/log-symbols-4.1.0.tgz"
+  integrity sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg==
+  dependencies:
+    chalk "^4.1.0"
+    is-unicode-supported "^0.1.0"
+
+log-symbols@^6.0.0:
+  version "6.0.0"
+  resolved "https://registry.npmjs.org/log-symbols/-/log-symbols-6.0.0.tgz"
+  integrity sha512-i24m8rpwhmPIS4zscNzK6MSEhk0DUWa/8iYQWxhffV8jkI4Phvs3F+quL5xvS0gdQR0FyTCMMH33Y78dDTzzIw==
+  dependencies:
+    chalk "^5.3.0"
+    is-unicode-supported "^1.3.0"
+
+loupe@^3.1.0:
+  version "3.1.3"
+  resolved "https://registry.npmjs.org/loupe/-/loupe-3.1.3.tgz"
+  integrity sha512-kkIp7XSkP78ZxJEsSxW3712C6teJVoeHHwgo9zJ380de7IYyJ2ISlxojcH2pC5OFLewESmnRi/+XCDIEEVyoug==
+
+lru-cache@^10.0.1, lru-cache@^10.2.0:
+  version "10.4.3"
+  resolved "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz"
+  integrity sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==
+
+magic-string@^0.30.17:
+  version "0.30.17"
+  resolved "https://registry.npmjs.org/magic-string/-/magic-string-0.30.17.tgz"
+  integrity sha512-sNPKHvyjVf7gyjwS4xGTaW/mCnF8wnjtifKBEhxfZ7E/S8tQ0rssrwGNn6q8JH/ohItJfSQp9mBtQYuTlH5QnA==
+  dependencies:
+    "@jridgewell/sourcemap-codec" "^1.5.0"
+
+make-error@^1.1.1:
+  version "1.3.6"
+  resolved "https://registry.npmjs.org/make-error/-/make-error-1.3.6.tgz"
+  integrity sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==
+
+math-intrinsics@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz"
+  integrity sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==
+
+micro-sr25519@^0.1.0:
+  version "0.1.0"
+  resolved "https://registry.npmjs.org/micro-sr25519/-/micro-sr25519-0.1.0.tgz"
+  integrity sha512-at5zfxiKNhh07v4GPb8Sc6wCW+jd18FMMgPM0ACIQMcgvMfB9a34mfOlXr5B04J4yFZ6imlvJfRaFbOxMA7ytw==
+  dependencies:
+    "@noble/curves" "~1.7.0"
+    "@noble/hashes" "~1.6.0"
+
+mimic-function@^5.0.0:
+  version "5.0.1"
+  resolved "https://registry.npmjs.org/mimic-function/-/mimic-function-5.0.1.tgz"
+  integrity sha512-VP79XUPxV2CigYP3jWwAUFSku2aKqBH7uTAapFWCBqutsbmDo96KY5o8uh6U+/YSIn5OxJnXp73beVkpqMIGhA==
+
+minimatch@^5.1.6:
+  version "5.1.6"
+  resolved "https://registry.npmjs.org/minimatch/-/minimatch-5.1.6.tgz"
+  integrity sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==
+  dependencies:
+    brace-expansion "^2.0.1"
+
+minimatch@^9.0.4:
+  version "9.0.5"
+  resolved "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz"
+  integrity sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==
+  dependencies:
+    brace-expansion "^2.0.1"
+
+"minipass@^5.0.0 || ^6.0.2 || ^7.0.0", minipass@^7.1.2:
+  version "7.1.2"
+  resolved "https://registry.npmjs.org/minipass/-/minipass-7.1.2.tgz"
+  integrity sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==
+
+mlly@^1.7.4:
+  version "1.7.4"
+  resolved "https://registry.npmjs.org/mlly/-/mlly-1.7.4.tgz"
+  integrity sha512-qmdSIPC4bDJXgZTCR7XosJiNKySV7O215tsPtDN9iEO/7q/76b/ijtgRu/+epFXSJhijtTCCGp3DWS549P3xKw==
+  dependencies:
+    acorn "^8.14.0"
+    pathe "^2.0.1"
+    pkg-types "^1.3.0"
+    ufo "^1.5.4"
+
+mocha@^11.1.0:
+  version "11.1.0"
+  resolved "https://registry.npmjs.org/mocha/-/mocha-11.1.0.tgz"
+  integrity sha512-8uJR5RTC2NgpY3GrYcgpZrsEd9zKbPDpob1RezyR2upGHRQtHWofmzTMzTMSV6dru3tj5Ukt0+Vnq1qhFEEwAg==
+  dependencies:
+    ansi-colors "^4.1.3"
+    browser-stdout "^1.3.1"
+    chokidar "^3.5.3"
+    debug "^4.3.5"
+    diff "^5.2.0"
+    escape-string-regexp "^4.0.0"
+    find-up "^5.0.0"
+    glob "^10.4.5"
+    he "^1.2.0"
+    js-yaml "^4.1.0"
+    log-symbols "^4.1.0"
+    minimatch "^5.1.6"
+    ms "^2.1.3"
+    serialize-javascript "^6.0.2"
+    strip-json-comments "^3.1.1"
+    supports-color "^8.1.1"
+    workerpool "^6.5.1"
+    yargs "^17.7.2"
+    yargs-parser "^21.1.1"
+    yargs-unparser "^2.0.0"
+
+mock-socket@^9.3.1:
+  version "9.3.1"
+  resolved "https://registry.npmjs.org/mock-socket/-/mock-socket-9.3.1.tgz"
+  integrity sha512-qxBgB7Qa2sEQgHFjj0dSigq7fX4k6Saisd5Nelwp2q8mlbAFh5dHV9JTTlF8viYJLSSWgMCZFUom8PJcMNBoJw==
+
+ms@^2.1.3:
+  version "2.1.3"
+  resolved "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz"
+  integrity sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==
+
+mz@^2.7.0:
+  version "2.7.0"
+  resolved "https://registry.npmjs.org/mz/-/mz-2.7.0.tgz"
+  integrity sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==
+  dependencies:
+    any-promise "^1.0.0"
+    object-assign "^4.0.1"
+    thenify-all "^1.0.0"
+
+nanoid@^3.3.8:
+  version "3.3.8"
+  resolved "https://registry.npmjs.org/nanoid/-/nanoid-3.3.8.tgz"
+  integrity sha512-WNLf5Sd8oZxOm+TzppcYk8gVOgP+l58xNy58D0nbUnOxOWRWvlcCV4kUF7ltmI6PsrLl/BgKEyS4mqsGChFN0w==
+
+nock@^13.5.5:
+  version "13.5.6"
+  resolved "https://registry.npmjs.org/nock/-/nock-13.5.6.tgz"
+  integrity sha512-o2zOYiCpzRqSzPj0Zt/dQ/DqZeYoaQ7TUonc/xUPjCGl9WeHpNbxgVvOquXYAaJzI0M9BXV3HTzG0p8IUAbBTQ==
+  dependencies:
+    debug "^4.1.0"
+    json-stringify-safe "^5.0.1"
+    propagate "^2.0.0"
+
+node-domexception@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.npmjs.org/node-domexception/-/node-domexception-1.0.0.tgz"
+  integrity sha512-/jKZoMpw0F8GRwl4/eLROPA3cfcXtLApP0QzLmUT/HuPCZWyB7IY9ZrMeKw2O/nFIqPQB3PVM9aYm0F312AXDQ==
+
+node-fetch@^3.3.2:
+  version "3.3.2"
+  resolved "https://registry.npmjs.org/node-fetch/-/node-fetch-3.3.2.tgz"
+  integrity sha512-dRB78srN/l6gqWulah9SrxeYnxeddIG30+GOqK/9OlLVyLg3HPnr6SqOWTWOXKRwC2eGYCkZ59NNuSgvSrpgOA==
+  dependencies:
+    data-uri-to-buffer "^4.0.0"
+    fetch-blob "^3.1.4"
+    formdata-polyfill "^4.0.10"
+
+normalize-package-data@^6.0.0:
+  version "6.0.2"
+  resolved "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-6.0.2.tgz"
+  integrity sha512-V6gygoYb/5EmNI+MEGrWkC+e6+Rr7mTmfHrxDbLzxQogBkgzo76rkok0Am6thgSF7Mv2nLOajAJj5vDJZEFn7g==
+  dependencies:
+    hosted-git-info "^7.0.0"
+    semver "^7.3.5"
+    validate-npm-package-license "^3.0.4"
+
+normalize-path@^3.0.0, normalize-path@~3.0.0:
+  version "3.0.0"
+  resolved "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz"
+  integrity sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==
+
+npm-run-path@^6.0.0:
+  version "6.0.0"
+  resolved "https://registry.npmjs.org/npm-run-path/-/npm-run-path-6.0.0.tgz"
+  integrity sha512-9qny7Z9DsQU8Ou39ERsPU4OZQlSTP47ShQzuKZ6PRXpYLtIFgl/DEBYEXKlvcEa+9tHVcK8CF81Y2V72qaZhWA==
+  dependencies:
+    path-key "^4.0.0"
+    unicorn-magic "^0.3.0"
+
+object-assign@^4.0.1:
+  version "4.1.1"
+  resolved "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz"
+  integrity sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==
+
+object-is@^1.1.5:
+  version "1.1.6"
+  resolved "https://registry.npmjs.org/object-is/-/object-is-1.1.6.tgz"
+  integrity sha512-F8cZ+KfGlSGi09lJT7/Nd6KJZ9ygtvYC0/UYYLI9nmQKLMnydpB9yvbv9K1uSkEu7FU9vYPmVwLg328tX+ot3Q==
+  dependencies:
+    call-bind "^1.0.7"
+    define-properties "^1.2.1"
+
+object-keys@^1.1.1:
+  version "1.1.1"
+  resolved "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz"
+  integrity sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==
+
+object.assign@^4.1.4:
+  version "4.1.7"
+  resolved "https://registry.npmjs.org/object.assign/-/object.assign-4.1.7.tgz"
+  integrity sha512-nK28WOo+QIjBkDduTINE4JkF/UJJKyf2EJxvJKfblDpyg0Q+pkOHNTL0Qwy6NP6FhE/EnzV73BxxqcJaXY9anw==
+  dependencies:
+    call-bind "^1.0.8"
+    call-bound "^1.0.3"
+    define-properties "^1.2.1"
+    es-object-atoms "^1.0.0"
+    has-symbols "^1.1.0"
+    object-keys "^1.1.1"
+
+onetime@^7.0.0:
+  version "7.0.0"
+  resolved "https://registry.npmjs.org/onetime/-/onetime-7.0.0.tgz"
+  integrity sha512-VXJjc87FScF88uafS3JllDgvAm+c/Slfz06lorj2uAY34rlUu0Nt+v8wreiImcrgAjjIHp1rXpTDlLOGw29WwQ==
+  dependencies:
+    mimic-function "^5.0.0"
+
+ora@^8.2.0:
+  version "8.2.0"
+  resolved "https://registry.npmjs.org/ora/-/ora-8.2.0.tgz"
+  integrity sha512-weP+BZ8MVNnlCm8c0Qdc1WSWq4Qn7I+9CJGm7Qali6g44e/PUzbjNqJX5NJ9ljlNMosfJvg1fKEGILklK9cwnw==
+  dependencies:
+    chalk "^5.3.0"
+    cli-cursor "^5.0.0"
+    cli-spinners "^2.9.2"
+    is-interactive "^2.0.0"
+    is-unicode-supported "^2.0.0"
+    log-symbols "^6.0.0"
+    stdin-discarder "^0.2.2"
+    string-width "^7.2.0"
+    strip-ansi "^7.1.0"
+
+ox@0.6.7:
+  version "0.6.7"
+  resolved "https://registry.npmjs.org/ox/-/ox-0.6.7.tgz"
+  integrity sha512-17Gk/eFsFRAZ80p5eKqv89a57uXjd3NgIf1CaXojATPBuujVc/fQSVhBeAU9JCRB+k7J50WQAyWTxK19T9GgbA==
+  dependencies:
+    "@adraffy/ens-normalize" "^1.10.1"
+    "@noble/curves" "^1.6.0"
+    "@noble/hashes" "^1.5.0"
+    "@scure/bip32" "^1.5.0"
+    "@scure/bip39" "^1.4.0"
+    abitype "^1.0.6"
+    eventemitter3 "5.0.1"
+
+p-limit@^3.0.2:
+  version "3.1.0"
+  resolved "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz"
+  integrity sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==
+  dependencies:
+    yocto-queue "^0.1.0"
+
+p-locate@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz"
+  integrity sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==
+  dependencies:
+    p-limit "^3.0.2"
+
+package-json-from-dist@^1.0.0:
+  version "1.0.1"
+  resolved "https://registry.npmjs.org/package-json-from-dist/-/package-json-from-dist-1.0.1.tgz"
+  integrity sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==
+
+parse-json@^8.0.0:
+  version "8.3.0"
+  resolved "https://registry.npmjs.org/parse-json/-/parse-json-8.3.0.tgz"
+  integrity sha512-ybiGyvspI+fAoRQbIPRddCcSTV9/LsJbf0e/S85VLowVGzRmokfneg2kwVW/KU5rOXrPSbF1qAKPMgNTqqROQQ==
+  dependencies:
+    "@babel/code-frame" "^7.26.2"
+    index-to-position "^1.1.0"
+    type-fest "^4.39.1"
+
+parse-ms@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.npmjs.org/parse-ms/-/parse-ms-4.0.0.tgz"
+  integrity sha512-TXfryirbmq34y8QBwgqCVLi+8oA3oWx2eAnSn62ITyEhEYaWRlVZ2DvMM9eZbMs/RfxPu/PK/aBLyGj4IrqMHw==
+
+path-exists@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz"
+  integrity sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==
+
+path-key@^3.1.0:
+  version "3.1.1"
+  resolved "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz"
+  integrity sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==
+
+path-key@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.npmjs.org/path-key/-/path-key-4.0.0.tgz"
+  integrity sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ==
+
+path-scurry@^1.11.1:
+  version "1.11.1"
+  resolved "https://registry.npmjs.org/path-scurry/-/path-scurry-1.11.1.tgz"
+  integrity sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==
+  dependencies:
+    lru-cache "^10.2.0"
+    minipass "^5.0.0 || ^6.0.2 || ^7.0.0"
+
+pathe@^2.0.1:
+  version "2.0.3"
+  resolved "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz"
+  integrity sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==
+
+pathval@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.npmjs.org/pathval/-/pathval-2.0.0.tgz"
+  integrity sha512-vE7JKRyES09KiunauX7nd2Q9/L7lhok4smP9RZTDeD4MVs72Dp2qNFVz39Nz5a0FVEW0BJR6C0DYrq6unoziZA==
+
+picocolors@^1.1.1:
+  version "1.1.1"
+  resolved "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz"
+  integrity sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==
+
+picomatch@^2.0.4, picomatch@^2.2.1:
+  version "2.3.1"
+  resolved "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz"
+  integrity sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==
+
+picomatch@^4.0.2:
+  version "4.0.2"
+  resolved "https://registry.npmjs.org/picomatch/-/picomatch-4.0.2.tgz"
+  integrity sha512-M7BAV6Rlcy5u+m6oPhAPFgJTzAioX/6B0DxyvDlo9l8+T3nLKbrczg2WLUyzd45L8RqfUMyGPzekbMvX2Ldkwg==
+
+pirates@^4.0.1:
+  version "4.0.7"
+  resolved "https://registry.npmjs.org/pirates/-/pirates-4.0.7.tgz"
+  integrity sha512-TfySrs/5nm8fQJDcBDuUng3VOUKsd7S+zqvbOTiGXHfxX4wK31ard+hoNuvkicM/2YFzlpDgABOevKSsB4G/FA==
+
+pkg-types@^1.3.0:
+  version "1.3.1"
+  resolved "https://registry.npmjs.org/pkg-types/-/pkg-types-1.3.1.tgz"
+  integrity sha512-/Jm5M4RvtBFVkKWRu2BLUTNP8/M2a+UwuAX+ae4770q1qVGtfjG+WTCupoZixokjmHiry8uI+dlY8KXYV5HVVQ==
+  dependencies:
+    confbox "^0.1.8"
+    mlly "^1.7.4"
+    pathe "^2.0.1"
+
+polkadot-api@^1.9.5:
+  version "1.12.0"
+  resolved "https://registry.npmjs.org/polkadot-api/-/polkadot-api-1.12.0.tgz"
+  integrity sha512-CstKp0ySE3JRVnG4nzl6hDhYLf4Qs/XpVk1xJrypYMqVbTu8FwjBK3l3j4pHhEttVudlEjK2hoVzQ1MdxMLeEg==
+  dependencies:
+    "@polkadot-api/cli" "0.13.0"
+    "@polkadot-api/ink-contracts" "0.3.2"
+    "@polkadot-api/json-rpc-provider" "0.0.4"
+    "@polkadot-api/known-chains" "0.7.6"
+    "@polkadot-api/logs-provider" "0.0.6"
+    "@polkadot-api/metadata-builders" "0.12.1"
+    "@polkadot-api/metadata-compatibility" "0.2.3"
+    "@polkadot-api/observable-client" "0.11.0"
+    "@polkadot-api/pjs-signer" "0.6.8"
+    "@polkadot-api/polkadot-sdk-compat" "2.3.2"
+    "@polkadot-api/polkadot-signer" "0.1.6"
+    "@polkadot-api/signer" "0.2.1"
+    "@polkadot-api/sm-provider" "0.1.7"
+    "@polkadot-api/smoldot" "0.3.8"
+    "@polkadot-api/substrate-bindings" "0.13.0"
+    "@polkadot-api/substrate-client" "0.3.0"
+    "@polkadot-api/utils" "0.1.2"
+    "@polkadot-api/ws-provider" "0.4.0"
+    "@rx-state/core" "^0.1.4"
+
+possible-typed-array-names@^1.0.0:
+  version "1.1.0"
+  resolved "https://registry.npmjs.org/possible-typed-array-names/-/possible-typed-array-names-1.1.0.tgz"
+  integrity sha512-/+5VFTchJDoVj3bhoqi6UeymcD00DAwb1nJwamzPvHEszJ4FpF6SNNbUbOS8yI56qHzdV8eK0qEfOSiodkTdxg==
+
+postcss-load-config@^6.0.1:
+  version "6.0.1"
+  resolved "https://registry.npmjs.org/postcss-load-config/-/postcss-load-config-6.0.1.tgz"
+  integrity sha512-oPtTM4oerL+UXmx+93ytZVN82RrlY/wPUV8IeDxFrzIjXOLF1pN+EmKPLbubvKHT2HC20xXsCAH2Z+CKV6Oz/g==
+  dependencies:
+    lilconfig "^3.1.1"
+
+postcss@^8.4.43:
+  version "8.5.3"
+  resolved "https://registry.npmjs.org/postcss/-/postcss-8.5.3.tgz"
+  integrity sha512-dle9A3yYxlBSrt8Fu+IpjGT8SY8hN0mlaA6GY8t0P5PjIOZemULz/E2Bnm/2dcUOena75OTNkHI76uZBNUUq3A==
+  dependencies:
+    nanoid "^3.3.8"
+    picocolors "^1.1.1"
+    source-map-js "^1.2.1"
+
+prettier@^3.3.3:
+  version "3.5.2"
+  resolved "https://registry.npmjs.org/prettier/-/prettier-3.5.2.tgz"
+  integrity sha512-lc6npv5PH7hVqozBR7lkBNOGXV9vMwROAPlumdBkX0wTbbzPu/U1hk5yL8p2pt4Xoc+2mkT8t/sow2YrV/M5qg==
+
+pretty-ms@^9.2.0:
+  version "9.2.0"
+  resolved "https://registry.npmjs.org/pretty-ms/-/pretty-ms-9.2.0.tgz"
+  integrity sha512-4yf0QO/sllf/1zbZWYnvWw3NxCQwLXKzIj0G849LSufP15BXKM0rbD2Z3wVnkMfjdn/CB0Dpp444gYAACdsplg==
+  dependencies:
+    parse-ms "^4.0.0"
+
+propagate@^2.0.0:
+  version "2.0.1"
+  resolved "https://registry.npmjs.org/propagate/-/propagate-2.0.1.tgz"
+  integrity sha512-vGrhOavPSTz4QVNuBNdcNXePNdNMaO1xj9yBeH1ScQPjk/rhg9sSlCXPhMkFuaNNW/syTvYqsnbIJxMBfRbbag==
+
+punycode@^2.1.0:
+  version "2.3.1"
+  resolved "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz"
+  integrity sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==
+
+randombytes@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz"
+  integrity sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==
+  dependencies:
+    safe-buffer "^5.1.0"
+
+read-pkg@^9.0.1:
+  version "9.0.1"
+  resolved "https://registry.npmjs.org/read-pkg/-/read-pkg-9.0.1.tgz"
+  integrity sha512-9viLL4/n1BJUCT1NXVTdS1jtm80yDEgR5T4yCelII49Mbj0v1rZdKqj7zCiYdbB0CuCgdrvHcNogAKTFPBocFA==
+  dependencies:
+    "@types/normalize-package-data" "^2.4.3"
+    normalize-package-data "^6.0.0"
+    parse-json "^8.0.0"
+    type-fest "^4.6.0"
+    unicorn-magic "^0.1.0"
+
+readdirp@^4.0.1:
+  version "4.1.2"
+  resolved "https://registry.npmjs.org/readdirp/-/readdirp-4.1.2.tgz"
+  integrity sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg==
+
+readdirp@~3.6.0:
+  version "3.6.0"
+  resolved "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz"
+  integrity sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==
+  dependencies:
+    picomatch "^2.2.1"
+
+require-directory@^2.1.1:
+  version "2.1.1"
+  resolved "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz"
+  integrity sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==
+
+resolve-from@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz"
+  integrity sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==
+
+restore-cursor@^5.0.0:
+  version "5.1.0"
+  resolved "https://registry.npmjs.org/restore-cursor/-/restore-cursor-5.1.0.tgz"
+  integrity sha512-oMA2dcrw6u0YfxJQXm342bFKX/E4sG9rbTzO9ptUcR/e8A33cHuvStiYOwH7fszkZlZ1z/ta9AAoPk2F4qIOHA==
+  dependencies:
+    onetime "^7.0.0"
+    signal-exit "^4.1.0"
+
+rollup@^4.20.0, rollup@^4.34.8:
+  version "4.34.8"
+  resolved "https://registry.npmjs.org/rollup/-/rollup-4.34.8.tgz"
+  integrity sha512-489gTVMzAYdiZHFVA/ig/iYFllCcWFHMvUHI1rpFmkoUtRlQxqh6/yiNqnYibjMZ2b/+FUQwldG+aLsEt6bglQ==
+  dependencies:
+    "@types/estree" "1.0.6"
+  optionalDependencies:
+    "@rollup/rollup-android-arm-eabi" "4.34.8"
+    "@rollup/rollup-android-arm64" "4.34.8"
+    "@rollup/rollup-darwin-arm64" "4.34.8"
+    "@rollup/rollup-darwin-x64" "4.34.8"
+    "@rollup/rollup-freebsd-arm64" "4.34.8"
+    "@rollup/rollup-freebsd-x64" "4.34.8"
+    "@rollup/rollup-linux-arm-gnueabihf" "4.34.8"
+    "@rollup/rollup-linux-arm-musleabihf" "4.34.8"
+    "@rollup/rollup-linux-arm64-gnu" "4.34.8"
+    "@rollup/rollup-linux-arm64-musl" "4.34.8"
+    "@rollup/rollup-linux-loongarch64-gnu" "4.34.8"
+    "@rollup/rollup-linux-powerpc64le-gnu" "4.34.8"
+    "@rollup/rollup-linux-riscv64-gnu" "4.34.8"
+    "@rollup/rollup-linux-s390x-gnu" "4.34.8"
+    "@rollup/rollup-linux-x64-gnu" "4.34.8"
+    "@rollup/rollup-linux-x64-musl" "4.34.8"
+    "@rollup/rollup-win32-arm64-msvc" "4.34.8"
+    "@rollup/rollup-win32-ia32-msvc" "4.34.8"
+    "@rollup/rollup-win32-x64-msvc" "4.34.8"
+    fsevents "~2.3.2"
+
+rxjs@^7.8.1, rxjs@^7.8.2:
+  version "7.8.2"
+  resolved "https://registry.npmjs.org/rxjs/-/rxjs-7.8.2.tgz"
+  integrity sha512-dhKf903U/PQZY6boNNtAGdWbG85WAbjT/1xYoZIC7FAY0yWapOBQVsVrDl58W86//e1VpMNBtRV4MaXfdMySFA==
+  dependencies:
+    tslib "^2.1.0"
+
+safe-buffer@^5.1.0:
+  version "5.2.1"
+  resolved "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz"
+  integrity sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==
+
+safe-regex-test@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.npmjs.org/safe-regex-test/-/safe-regex-test-1.1.0.tgz"
+  integrity sha512-x/+Cz4YrimQxQccJf5mKEbIa1NzeCRNI5Ecl/ekmlYaampdNLPalVyIcCZNNH3MvmqBugV5TMYZXv0ljslUlaw==
+  dependencies:
+    call-bound "^1.0.2"
+    es-errors "^1.3.0"
+    is-regex "^1.2.1"
+
+scale-ts@^1.6.0, scale-ts@^1.6.1:
+  version "1.6.1"
+  resolved "https://registry.npmjs.org/scale-ts/-/scale-ts-1.6.1.tgz"
+  integrity sha512-PBMc2AWc6wSEqJYBDPcyCLUj9/tMKnLX70jLOSndMtcUoLQucP/DM0vnQo1wJAYjTrQiq8iG9rD0q6wFzgjH7g==
+
+semver@^7.3.5:
+  version "7.7.2"
+  resolved "https://registry.npmjs.org/semver/-/semver-7.7.2.tgz"
+  integrity sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==
+
+serialize-javascript@^6.0.2:
+  version "6.0.2"
+  resolved "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.2.tgz"
+  integrity sha512-Saa1xPByTTq2gdeFZYLLo+RFE35NHZkAbqZeWNd3BpzppeVisAqpDjcp8dyf6uIvEqJRd46jemmyA4iFIeVk8g==
+  dependencies:
+    randombytes "^2.1.0"
+
+set-function-length@^1.2.2:
+  version "1.2.2"
+  resolved "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.2.tgz"
+  integrity sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==
+  dependencies:
+    define-data-property "^1.1.4"
+    es-errors "^1.3.0"
+    function-bind "^1.1.2"
+    get-intrinsic "^1.2.4"
+    gopd "^1.0.1"
+    has-property-descriptors "^1.0.2"
+
+shebang-command@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz"
+  integrity sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==
+  dependencies:
+    shebang-regex "^3.0.0"
+
+shebang-regex@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz"
+  integrity sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==
+
+signal-exit@^4.0.1, signal-exit@^4.1.0:
+  version "4.1.0"
+  resolved "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz"
+  integrity sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==
+
+smoldot@2.0.26:
+  version "2.0.26"
+  resolved "https://registry.npmjs.org/smoldot/-/smoldot-2.0.26.tgz"
+  integrity sha512-F+qYmH4z2s2FK+CxGj8moYcd1ekSIKH8ywkdqlOz88Dat35iB1DIYL11aILN46YSGMzQW/lbJNS307zBSDN5Ig==
+  dependencies:
+    ws "^8.8.1"
+
+smoldot@2.0.34:
+  version "2.0.34"
+  resolved "https://registry.npmjs.org/smoldot/-/smoldot-2.0.34.tgz"
+  integrity sha512-mw9tCbGEhEp0koMqLL0jBEixVY1MIN/xI3pE6ZY1TuOPU+LnYy8FloODVyzkvzQPaBYrETXJdRlmA/+k6g3gow==
+  dependencies:
+    ws "^8.8.1"
+
+sort-keys@^5.0.0:
+  version "5.1.0"
+  resolved "https://registry.npmjs.org/sort-keys/-/sort-keys-5.1.0.tgz"
+  integrity sha512-aSbHV0DaBcr7u0PVHXzM6NbZNAtrr9sF6+Qfs9UUVG7Ll3jQ6hHi8F/xqIIcn2rvIVbr0v/2zyjSdwSV47AgLQ==
+  dependencies:
+    is-plain-obj "^4.0.0"
+
+source-map-js@^1.2.1:
+  version "1.2.1"
+  resolved "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz"
+  integrity sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==
+
+source-map@0.8.0-beta.0:
+  version "0.8.0-beta.0"
+  resolved "https://registry.npmjs.org/source-map/-/source-map-0.8.0-beta.0.tgz"
+  integrity sha512-2ymg6oRBpebeZi9UUNsgQ89bhx01TcTkmNTGnNO88imTmbSgy4nfujrgVEFKWpMTEGA11EDkTt7mqObTPdigIA==
+  dependencies:
+    whatwg-url "^7.0.0"
+
+spdx-correct@^3.0.0:
+  version "3.2.0"
+  resolved "https://registry.npmjs.org/spdx-correct/-/spdx-correct-3.2.0.tgz"
+  integrity sha512-kN9dJbvnySHULIluDHy32WHRUu3Og7B9sbY7tsFLctQkIqnMh3hErYgdMjTYuqmcXX+lK5T1lnUt3G7zNswmZA==
+  dependencies:
+    spdx-expression-parse "^3.0.0"
+    spdx-license-ids "^3.0.0"
+
+spdx-exceptions@^2.1.0:
+  version "2.5.0"
+  resolved "https://registry.npmjs.org/spdx-exceptions/-/spdx-exceptions-2.5.0.tgz"
+  integrity sha512-PiU42r+xO4UbUS1buo3LPJkjlO7430Xn5SVAhdpzzsPHsjbYVflnnFdATgabnLude+Cqu25p6N+g2lw/PFsa4w==
+
+spdx-expression-parse@^3.0.0:
+  version "3.0.1"
+  resolved "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-3.0.1.tgz"
+  integrity sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==
+  dependencies:
+    spdx-exceptions "^2.1.0"
+    spdx-license-ids "^3.0.0"
+
+spdx-license-ids@^3.0.0:
+  version "3.0.21"
+  resolved "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.21.tgz"
+  integrity sha512-Bvg/8F5XephndSK3JffaRqdT+gyhfqIPwDHpX80tJrF8QQRYMo8sNMeaZ2Dp5+jhwKnUmIOyFFQfHRkjJm5nXg==
+
+stdin-discarder@^0.2.2:
+  version "0.2.2"
+  resolved "https://registry.npmjs.org/stdin-discarder/-/stdin-discarder-0.2.2.tgz"
+  integrity sha512-UhDfHmA92YAlNnCfhmq0VeNL5bDbiZGg7sZ2IvPsXubGkiNa9EC+tUTsjBRsYUAz87btI6/1wf4XoVvQ3uRnmQ==
+
+"string-width-cjs@npm:string-width@^4.2.0":
+  version "4.2.3"
+  resolved "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz"
+  integrity sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==
+  dependencies:
+    emoji-regex "^8.0.0"
+    is-fullwidth-code-point "^3.0.0"
+    strip-ansi "^6.0.1"
+
+string-width@^4.1.0, string-width@^4.2.0, string-width@^4.2.3:
+  version "4.2.3"
+  resolved "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz"
+  integrity sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==
+  dependencies:
+    emoji-regex "^8.0.0"
+    is-fullwidth-code-point "^3.0.0"
+    strip-ansi "^6.0.1"
+
+string-width@^5.0.1, string-width@^5.1.2:
+  version "5.1.2"
+  resolved "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz"
+  integrity sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==
+  dependencies:
+    eastasianwidth "^0.2.0"
+    emoji-regex "^9.2.2"
+    strip-ansi "^7.0.1"
+
+string-width@^7.2.0:
+  version "7.2.0"
+  resolved "https://registry.npmjs.org/string-width/-/string-width-7.2.0.tgz"
+  integrity sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ==
+  dependencies:
+    emoji-regex "^10.3.0"
+    get-east-asian-width "^1.0.0"
+    strip-ansi "^7.1.0"
+
+"strip-ansi-cjs@npm:strip-ansi@^6.0.1":
+  version "6.0.1"
+  resolved "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz"
+  integrity sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==
+  dependencies:
+    ansi-regex "^5.0.1"
+
+strip-ansi@^6.0.0, strip-ansi@^6.0.1:
+  version "6.0.1"
+  resolved "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz"
+  integrity sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==
+  dependencies:
+    ansi-regex "^5.0.1"
+
+strip-ansi@^7.0.1, strip-ansi@^7.1.0:
+  version "7.1.0"
+  resolved "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz"
+  integrity sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==
+  dependencies:
+    ansi-regex "^6.0.1"
+
+strip-final-newline@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-4.0.0.tgz"
+  integrity sha512-aulFJcD6YK8V1G7iRB5tigAP4TsHBZZrOV8pjV++zdUwmeV8uzbY7yn6h9MswN62adStNZFuCIx4haBnRuMDaw==
+
+strip-json-comments@^3.1.1:
+  version "3.1.1"
+  resolved "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz"
+  integrity sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==
+
+sucrase@^3.35.0:
+  version "3.35.0"
+  resolved "https://registry.npmjs.org/sucrase/-/sucrase-3.35.0.tgz"
+  integrity sha512-8EbVDiu9iN/nESwxeSxDKe0dunta1GOlHufmSSXxMD2z2/tMZpDMpvXQGsc+ajGo8y2uYUmixaSRUc/QPoQ0GA==
+  dependencies:
+    "@jridgewell/gen-mapping" "^0.3.2"
+    commander "^4.0.0"
+    glob "^10.3.10"
+    lines-and-columns "^1.1.6"
+    mz "^2.7.0"
+    pirates "^4.0.1"
+    ts-interface-checker "^0.1.9"
+
+supports-color@^7.1.0:
+  version "7.2.0"
+  resolved "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz"
+  integrity sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==
+  dependencies:
+    has-flag "^4.0.0"
+
+supports-color@^8.1.1:
+  version "8.1.1"
+  resolved "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz"
+  integrity sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==
+  dependencies:
+    has-flag "^4.0.0"
+
+thenify-all@^1.0.0:
+  version "1.6.0"
+  resolved "https://registry.npmjs.org/thenify-all/-/thenify-all-1.6.0.tgz"
+  integrity sha512-RNxQH/qI8/t3thXJDwcstUO4zeqo64+Uy/+sNVRBx4Xn2OX+OZ9oP+iJnNFqplFra2ZUVeKCSa2oVWi3T4uVmA==
+  dependencies:
+    thenify ">= 3.1.0 < 4"
+
+"thenify@>= 3.1.0 < 4":
+  version "3.3.1"
+  resolved "https://registry.npmjs.org/thenify/-/thenify-3.3.1.tgz"
+  integrity sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw==
+  dependencies:
+    any-promise "^1.0.0"
+
+tinyexec@^0.3.2:
+  version "0.3.2"
+  resolved "https://registry.npmjs.org/tinyexec/-/tinyexec-0.3.2.tgz"
+  integrity sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==
+
+tinyglobby@^0.2.11:
+  version "0.2.14"
+  resolved "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.14.tgz"
+  integrity sha512-tX5e7OM1HnYr2+a2C/4V0htOcSQcoSTH9KgJnVvNm5zm/cyEWKJ7j7YutsH9CxMdtOkkLFy2AHrMci9IM8IPZQ==
+  dependencies:
+    fdir "^6.4.4"
+    picomatch "^4.0.2"
+
+to-regex-range@^5.0.1:
+  version "5.0.1"
+  resolved "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz"
+  integrity sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==
+  dependencies:
+    is-number "^7.0.0"
+
+tr46@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.npmjs.org/tr46/-/tr46-1.0.1.tgz"
+  integrity sha512-dTpowEjclQ7Kgx5SdBkqRzVhERQXov8/l9Ft9dVM9fmg0W0KQSVaXX9T4i6twCPNtYiZM53lpSSUAwJbFPOHxA==
+  dependencies:
+    punycode "^2.1.0"
+
+tree-kill@^1.2.2:
+  version "1.2.2"
+  resolved "https://registry.npmjs.org/tree-kill/-/tree-kill-1.2.2.tgz"
+  integrity sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A==
+
+ts-interface-checker@^0.1.9:
+  version "0.1.13"
+  resolved "https://registry.npmjs.org/ts-interface-checker/-/ts-interface-checker-0.1.13.tgz"
+  integrity sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA==
+
+ts-node@^10.9.2:
+  version "10.9.2"
+  resolved "https://registry.npmjs.org/ts-node/-/ts-node-10.9.2.tgz"
+  integrity sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ==
+  dependencies:
+    "@cspotcode/source-map-support" "^0.8.0"
+    "@tsconfig/node10" "^1.0.7"
+    "@tsconfig/node12" "^1.0.7"
+    "@tsconfig/node14" "^1.0.0"
+    "@tsconfig/node16" "^1.0.2"
+    acorn "^8.4.1"
+    acorn-walk "^8.1.1"
+    arg "^4.1.0"
+    create-require "^1.1.0"
+    diff "^4.0.1"
+    make-error "^1.1.1"
+    v8-compile-cache-lib "^3.0.1"
+    yn "3.1.1"
+
+tsc-prog@^2.3.0:
+  version "2.3.0"
+  resolved "https://registry.npmjs.org/tsc-prog/-/tsc-prog-2.3.0.tgz"
+  integrity sha512-ycET2d75EgcX7y8EmG4KiZkLAwUzbY4xRhA6NU0uVbHkY4ZjrAAuzTMxXI85kOwATqPnBI5C/7y7rlpY0xdqHA==
+
+tslib@2.7.0:
+  version "2.7.0"
+  resolved "https://registry.npmjs.org/tslib/-/tslib-2.7.0.tgz"
+  integrity sha512-gLXCKdN1/j47AiHiOkJN69hJmcbGTHI0ImLmbYLHykhgeN0jVGola9yVjFgzCUklsZQMW55o+dW7IXv3RCXDzA==
+
+tslib@^2.1.0, tslib@^2.7.0, tslib@^2.8.0:
+  version "2.8.1"
+  resolved "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz"
+  integrity sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==
+
+tsup@^8.4.0:
+  version "8.5.0"
+  resolved "https://registry.npmjs.org/tsup/-/tsup-8.5.0.tgz"
+  integrity sha512-VmBp77lWNQq6PfuMqCHD3xWl22vEoWsKajkF8t+yMBawlUS8JzEI+vOVMeuNZIuMML8qXRizFKi9oD5glKQVcQ==
+  dependencies:
+    bundle-require "^5.1.0"
+    cac "^6.7.14"
+    chokidar "^4.0.3"
+    consola "^3.4.0"
+    debug "^4.4.0"
+    esbuild "^0.25.0"
+    fix-dts-default-cjs-exports "^1.0.0"
+    joycon "^3.1.1"
+    picocolors "^1.1.1"
+    postcss-load-config "^6.0.1"
+    resolve-from "^5.0.0"
+    rollup "^4.34.8"
+    source-map "0.8.0-beta.0"
+    sucrase "^3.35.0"
+    tinyexec "^0.3.2"
+    tinyglobby "^0.2.11"
+    tree-kill "^1.2.2"
+
+type-fest@^4.23.0, type-fest@^4.39.1, type-fest@^4.6.0:
+  version "4.41.0"
+  resolved "https://registry.npmjs.org/type-fest/-/type-fest-4.41.0.tgz"
+  integrity sha512-TeTSQ6H5YHvpqVwBRcnLDCBnDOHWYu7IvGbHT6N8AOymcr9PJGjc1GTtiWZTYg0NCgYwvnYWEkVChQAr9bjfwA==
+
+typescript@^5.7.2, typescript@^5.8.3:
+  version "5.8.3"
+  resolved "https://registry.npmjs.org/typescript/-/typescript-5.8.3.tgz"
+  integrity sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ==
+
+ufo@^1.5.4:
+  version "1.6.1"
+  resolved "https://registry.npmjs.org/ufo/-/ufo-1.6.1.tgz"
+  integrity sha512-9a4/uxlTWJ4+a5i0ooc1rU7C7YOw3wT+UGqdeNNHWnOF9qcMBgLRS+4IYUqbczewFx4mLEig6gawh7X6mFlEkA==
+
+undici-types@~6.19.2:
+  version "6.19.8"
+  resolved "https://registry.npmjs.org/undici-types/-/undici-types-6.19.8.tgz"
+  integrity sha512-ve2KP6f/JnbPBFyobGHuerC9g1FYGn/F8n1LWTwNxCEzd6IfqTwUQcNXgEtmmQ6DlRrC1hrSrBnCZPokRrDHjw==
+
+undici-types@~6.21.0:
+  version "6.21.0"
+  resolved "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz"
+  integrity sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==
+
+unicorn-magic@^0.1.0:
+  version "0.1.0"
+  resolved "https://registry.npmjs.org/unicorn-magic/-/unicorn-magic-0.1.0.tgz"
+  integrity sha512-lRfVq8fE8gz6QMBuDM6a+LO3IAzTi05H6gCVaUpir2E1Rwpo4ZUog45KpNXKC/Mn3Yb9UDuHumeFTo9iV/D9FQ==
+
+unicorn-magic@^0.3.0:
+  version "0.3.0"
+  resolved "https://registry.npmjs.org/unicorn-magic/-/unicorn-magic-0.3.0.tgz"
+  integrity sha512-+QBBXBCvifc56fsbuxZQ6Sic3wqqc3WWaqxs58gvJrcOuN83HGTCwz3oS5phzU9LthRNE9VrJCFCLUgHeeFnfA==
+
+util@^0.12.5:
+  version "0.12.5"
+  resolved "https://registry.npmjs.org/util/-/util-0.12.5.tgz"
+  integrity sha512-kZf/K6hEIrWHI6XqOFUiiMa+79wE/D8Q+NCNAWclkyg3b4d2k7s0QGepNjiABc+aR3N1PAyHL7p6UcLY6LmrnA==
+  dependencies:
+    inherits "^2.0.3"
+    is-arguments "^1.0.4"
+    is-generator-function "^1.0.7"
+    is-typed-array "^1.1.3"
+    which-typed-array "^1.1.2"
+
+v8-compile-cache-lib@^3.0.1:
+  version "3.0.1"
+  resolved "https://registry.npmjs.org/v8-compile-cache-lib/-/v8-compile-cache-lib-3.0.1.tgz"
+  integrity sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==
+
+validate-npm-package-license@^3.0.4:
+  version "3.0.4"
+  resolved "https://registry.npmjs.org/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz"
+  integrity sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==
+  dependencies:
+    spdx-correct "^3.0.0"
+    spdx-expression-parse "^3.0.0"
+
+viem@2.23.4:
+  version "2.23.4"
+  resolved "https://registry.npmjs.org/viem/-/viem-2.23.4.tgz"
+  integrity sha512-UQquuolKlS1w5H5e0Fd1KKoUlIPJryIEBzY5AUhGyV1ka+9O6+3uYVhUzj6RbvGK0PtsMKn2ddwPZFwjNDVU/A==
+  dependencies:
+    "@noble/curves" "1.8.1"
+    "@noble/hashes" "1.7.1"
+    "@scure/bip32" "1.6.2"
+    "@scure/bip39" "1.5.4"
+    abitype "1.0.8"
+    isows "1.0.6"
+    ox "0.6.7"
+    ws "8.18.0"
+
+vite@^5.4.8:
+  version "5.4.14"
+  resolved "https://registry.npmjs.org/vite/-/vite-5.4.14.tgz"
+  integrity sha512-EK5cY7Q1D8JNhSaPKVK4pwBFvaTmZxEnoKXLG/U9gmdDcihQGNzFlgIvaxezFR4glP1LsuiedwMBqCXH3wZccA==
+  dependencies:
+    esbuild "^0.21.3"
+    postcss "^8.4.43"
+    rollup "^4.20.0"
+  optionalDependencies:
+    fsevents "~2.3.3"
+
+web-streams-polyfill@^3.0.3:
+  version "3.3.3"
+  resolved "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-3.3.3.tgz"
+  integrity sha512-d2JWLCivmZYTSIoge9MsgFCZrt571BikcWGYkjC1khllbTeDlGqZ2D8vD8E/lJa8WGWbb7Plm8/XJYV7IJHZZw==
+
+webidl-conversions@^4.0.2:
+  version "4.0.2"
+  resolved "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-4.0.2.tgz"
+  integrity sha512-YQ+BmxuTgd6UXZW3+ICGfyqRyHXVlD5GtQr5+qjiNW7bF0cqrzX500HVXPBOvgXb5YnzDd+h0zqyv61KUD7+Sg==
+
+whatwg-url@^7.0.0:
+  version "7.1.0"
+  resolved "https://registry.npmjs.org/whatwg-url/-/whatwg-url-7.1.0.tgz"
+  integrity sha512-WUu7Rg1DroM7oQvGWfOiAK21n74Gg+T4elXEQYkOhtyLeWiJFoOGLXPKI/9gzIie9CtwVLm8wtw6YJdKyxSjeg==
+  dependencies:
+    lodash.sortby "^4.7.0"
+    tr46 "^1.0.1"
+    webidl-conversions "^4.0.2"
+
+which-typed-array@^1.1.16, which-typed-array@^1.1.2:
+  version "1.1.18"
+  resolved "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.18.tgz"
+  integrity sha512-qEcY+KJYlWyLH9vNbsr6/5j59AXk5ni5aakf8ldzBvGde6Iz4sxZGkJyWSAueTG7QhOvNRYb1lDdFmL5Td0QKA==
+  dependencies:
+    available-typed-arrays "^1.0.7"
+    call-bind "^1.0.8"
+    call-bound "^1.0.3"
+    for-each "^0.3.3"
+    gopd "^1.2.0"
+    has-tostringtag "^1.0.2"
+
+which@^2.0.1:
+  version "2.0.2"
+  resolved "https://registry.npmjs.org/which/-/which-2.0.2.tgz"
+  integrity sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==
+  dependencies:
+    isexe "^2.0.0"
+
+workerpool@^6.5.1:
+  version "6.5.1"
+  resolved "https://registry.npmjs.org/workerpool/-/workerpool-6.5.1.tgz"
+  integrity sha512-Fs4dNYcsdpYSAfVxhnl1L5zTksjvOJxtC5hzMNl+1t9B8hTJTdKDyZ5ju7ztgPy+ft9tBFXoOlDNiOT9WUXZlA==
+
+"wrap-ansi-cjs@npm:wrap-ansi@^7.0.0":
+  version "7.0.0"
+  resolved "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz"
+  integrity sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==
+  dependencies:
+    ansi-styles "^4.0.0"
+    string-width "^4.1.0"
+    strip-ansi "^6.0.0"
+
+wrap-ansi@^7.0.0:
+  version "7.0.0"
+  resolved "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz"
+  integrity sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==
+  dependencies:
+    ansi-styles "^4.0.0"
+    string-width "^4.1.0"
+    strip-ansi "^6.0.0"
+
+wrap-ansi@^8.1.0:
+  version "8.1.0"
+  resolved "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-8.1.0.tgz"
+  integrity sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==
+  dependencies:
+    ansi-styles "^6.1.0"
+    string-width "^5.0.1"
+    strip-ansi "^7.0.1"
+
+write-file-atomic@^5.0.1:
+  version "5.0.1"
+  resolved "https://registry.npmjs.org/write-file-atomic/-/write-file-atomic-5.0.1.tgz"
+  integrity sha512-+QU2zd6OTD8XWIJCbffaiQeH9U73qIqafo1x6V1snCWYGJf6cVE0cDR4D8xRzcEnfI21IFrUPzPGtcPf8AC+Rw==
+  dependencies:
+    imurmurhash "^0.1.4"
+    signal-exit "^4.0.1"
+
+write-json-file@^6.0.0:
+  version "6.0.0"
+  resolved "https://registry.npmjs.org/write-json-file/-/write-json-file-6.0.0.tgz"
+  integrity sha512-MNHcU3f9WxnNyR6MxsYSj64Jz0+dwIpisWKWq9gqLj/GwmA9INg3BZ3vt70/HB3GEwrnDQWr4RPrywnhNzmUFA==
+  dependencies:
+    detect-indent "^7.0.1"
+    is-plain-obj "^4.1.0"
+    sort-keys "^5.0.0"
+    write-file-atomic "^5.0.1"
+
+write-package@^7.1.0:
+  version "7.1.0"
+  resolved "https://registry.npmjs.org/write-package/-/write-package-7.1.0.tgz"
+  integrity sha512-DqUx8GI3r9BFWwU2DPKddL1E7xWfbFED82mLVhGXKlFEPe8IkBftzO7WfNwHtk7oGDHDeuH/o8VMpzzfMwmLUA==
+  dependencies:
+    deepmerge-ts "^7.1.0"
+    read-pkg "^9.0.1"
+    sort-keys "^5.0.0"
+    type-fest "^4.23.0"
+    write-json-file "^6.0.0"
+
+ws@8.17.1:
+  version "8.17.1"
+  resolved "https://registry.npmjs.org/ws/-/ws-8.17.1.tgz"
+  integrity sha512-6XQFvXTkbfUOZOKKILFG1PDK2NDQs4azKQl26T0YS5CxqWLgXajbPZ+h4gZekJyRqFU8pvnbAbbs/3TgRPy+GQ==
+
+ws@8.18.0:
+  version "8.18.0"
+  resolved "https://registry.npmjs.org/ws/-/ws-8.18.0.tgz"
+  integrity sha512-8VbfWfHLbbwu3+N6OKsOMpBdT4kXPDDB9cJk2bJ6mh9ucxdlnNvH1e+roYkKmN9Nxw2yjz7VzeO9oOz2zJ04Pw==
+
+ws@^8.18.0, ws@^8.18.1, ws@^8.18.2, ws@^8.8.1:
+  version "8.18.2"
+  resolved "https://registry.npmjs.org/ws/-/ws-8.18.2.tgz"
+  integrity sha512-DMricUmwGZUVr++AEAe2uiVM7UoO9MAVZMDu05UQOaUII0lp+zOzLLU4Xqh/JvTqklB1T4uELaaPBKyjE1r4fQ==
+
+y18n@^5.0.5:
+  version "5.0.8"
+  resolved "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz"
+  integrity sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==
+
+yargs-parser@^21.1.1:
+  version "21.1.1"
+  resolved "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz"
+  integrity sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==
+
+yargs-unparser@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.npmjs.org/yargs-unparser/-/yargs-unparser-2.0.0.tgz"
+  integrity sha512-7pRTIA9Qc1caZ0bZ6RYRGbHJthJWuakf+WmHK0rVeLkNrrGhfoabBNdue6kdINI6r4if7ocq9aD/n7xwKOdzOA==
+  dependencies:
+    camelcase "^6.0.0"
+    decamelize "^4.0.0"
+    flat "^5.0.2"
+    is-plain-obj "^2.1.0"
+
+yargs@^17.7.2:
+  version "17.7.2"
+  resolved "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz"
+  integrity sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==
+  dependencies:
+    cliui "^8.0.1"
+    escalade "^3.1.1"
+    get-caller-file "^2.0.5"
+    require-directory "^2.1.1"
+    string-width "^4.2.3"
+    y18n "^5.0.5"
+    yargs-parser "^21.1.1"
+
+yn@3.1.1:
+  version "3.1.1"
+  resolved "https://registry.npmjs.org/yn/-/yn-3.1.1.tgz"
+  integrity sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==
+
+yocto-queue@^0.1.0:
+  version "0.1.0"
+  resolved "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz"
+  integrity sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==
+
+yoctocolors@^2.1.1:
+  version "2.1.1"
+  resolved "https://registry.npmjs.org/yoctocolors/-/yoctocolors-2.1.1.tgz"
+  integrity sha512-GQHQqAopRhwU8Kt1DDM8NjibDXHC8eoh1erhGAJPEyveY9qqVeXvVikNKrDz69sHowPMorbPUrH/mx8c50eiBQ==

From a1df5c1f0c86baf40016b09ebc744de6946df2e6 Mon Sep 17 00:00:00 2001
From: Ben Mason <ben@wattmason.co.uk>
Date: Fri, 13 Jun 2025 09:35:18 +0100
Subject: [PATCH 351/418] fix: add update from get-metadata.sh to package.json

---
 evm-tests/package.json | 1 +
 1 file changed, 1 insertion(+)

diff --git a/evm-tests/package.json b/evm-tests/package.json
index 4834ef4e99..9970967a88 100644
--- a/evm-tests/package.json
+++ b/evm-tests/package.json
@@ -6,6 +6,7 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
+    "@polkadot-api/descriptors": "file:.papi/descriptors",
     "@polkadot-labs/hdkd": "^0.0.10",
     "@polkadot-labs/hdkd-helpers": "^0.0.11",
     "@polkadot/api": "15.1.1",

From 07650ce98e1c5dc16c126b4541ff066072b34b3c Mon Sep 17 00:00:00 2001
From: Ben Mason <ben@wattmason.co.uk>
Date: Fri, 13 Jun 2025 09:51:02 +0100
Subject: [PATCH 352/418] feat: add precompile test for registering subnetwork
 with identity & logo

---
 evm-tests/src/contracts/subnet.ts             | 53 +++++++++++++++++++
 .../subnet.precompile.hyperparameter.test.ts  | 21 ++++++++
 2 files changed, 74 insertions(+)

diff --git a/evm-tests/src/contracts/subnet.ts b/evm-tests/src/contracts/subnet.ts
index eacdaf3aca..b5a5a9dcbc 100644
--- a/evm-tests/src/contracts/subnet.ts
+++ b/evm-tests/src/contracts/subnet.ts
@@ -923,4 +923,57 @@ export const ISubnetABI = [
         stateMutability: "payable",
         type: "function"
     },
+    {
+        inputs: [
+            {
+                internalType: "bytes32",
+                name: "hotkey",
+                type: "bytes32"
+            },
+            {
+                internalType: "string",
+                name: "subnetName",
+                type: "string"
+            },
+            {
+                internalType: "string",
+                name: "githubRepo",
+                type: "string"
+            },
+            {
+                internalType: "string",
+                name: "subnetContact",
+                type: "string"
+            },
+            {
+                internalType: "string",
+                name: "subnetUrl",
+                type: "string"
+            },
+            {
+                internalType: "string",
+                name: "discord",
+                type: "string"
+            },
+            {
+                internalType: "string",
+                name: "description",
+                type: "string"
+            },
+            {
+                internalType: "string",
+                name: "logoUrl",
+                type: "string"
+            },
+            {
+                internalType: "string",
+                name: "additional",
+                type: "string"
+            }
+        ],
+        name: "registerNetwork",
+        outputs: [],
+        stateMutability: "payable",
+        type: "function"
+    },
 ];
diff --git a/evm-tests/test/subnet.precompile.hyperparameter.test.ts b/evm-tests/test/subnet.precompile.hyperparameter.test.ts
index 57efd64f77..bc95ca0716 100644
--- a/evm-tests/test/subnet.precompile.hyperparameter.test.ts
+++ b/evm-tests/test/subnet.precompile.hyperparameter.test.ts
@@ -56,6 +56,27 @@ describe("Test the Subnet precompile contract", () => {
         const totalNetworkAfterAdd = await api.query.SubtensorModule.TotalNetworks.getValue()
         assert.ok(totalNetwork + 1 === totalNetworkAfterAdd)
     });
+ 
+    it.only("Can register network with identity info and logo url", async () => {
+        const totalNetwork = await api.query.SubtensorModule.TotalNetworks.getValue()
+
+        const contract = new ethers.Contract(ISUBNET_ADDRESS, ISubnetABI, wallet);
+        const tx = await contract["registerNetwork(bytes32,string,string,string,string,string,string,string,string)"](
+            hotkey2.publicKey,
+            "name",
+            "repo",
+            "contact",
+            "subnetUrl",
+            "discord",
+            "description",
+            "logoUrl",
+            "additional"
+        );
+        await tx.wait();
+
+        const totalNetworkAfterAdd = await api.query.SubtensorModule.TotalNetworks.getValue()
+        assert.ok(totalNetwork + 1 === totalNetworkAfterAdd)
+    });
 
     it("Can set servingRateLimit parameter", async () => {
 

From 99ad390c194c93ad67fe3c6e26f0366825836a89 Mon Sep 17 00:00:00 2001
From: Ben Mason <ben@wattmason.co.uk>
Date: Fri, 13 Jun 2025 15:01:23 +0100
Subject: [PATCH 353/418] fix: ci failing due to missing papi descriptors

---
 evm-tests/run-ci.sh | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/evm-tests/run-ci.sh b/evm-tests/run-ci.sh
index cd7acb14af..1336b46e5d 100755
--- a/evm-tests/run-ci.sh
+++ b/evm-tests/run-ci.sh
@@ -21,12 +21,12 @@ fi
 
 cd evm-tests
 
-yarn
-
 bash get-metadata.sh
 
 sleep 5
 
+yarn
+
 yarn run test
 TEST_EXIT_CODE=$?
 

From 3274ad12d75f5c547bf4bec2d5e01589900cb909 Mon Sep 17 00:00:00 2001
From: Ben Mason <ben@wattmason.co.uk>
Date: Fri, 13 Jun 2025 15:37:02 +0100
Subject: [PATCH 354/418] fix: papi broken on CI

---
 evm-tests/run-ci.sh | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/evm-tests/run-ci.sh b/evm-tests/run-ci.sh
index 1336b46e5d..dbdabfbd8b 100755
--- a/evm-tests/run-ci.sh
+++ b/evm-tests/run-ci.sh
@@ -21,6 +21,9 @@ fi
 
 cd evm-tests
 
+# required for papi in get-metadata.sh, but we cannot run yarn before papi as it adds the descriptors to the package.json which won't resolve
+npm i -g polkadot-api
+
 bash get-metadata.sh
 
 sleep 5

From 25a8f821f8022f752b2e5757008b5a410ea8fcf4 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Fri, 13 Jun 2025 10:39:04 -0400
Subject: [PATCH 355/418] Fix fees when adding liquidity to a new tick

---
 pallets/swap/src/pallet/impls.rs | 17 +++++++++++++++--
 1 file changed, 15 insertions(+), 2 deletions(-)

diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index ec7f2766e9..1bca5d5762 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -983,11 +983,24 @@ impl<T: Config> Pallet<T> {
                 tick.liquidity_gross = tick.liquidity_gross.saturating_add(liquidity);
             }
             None => {
+                let current_tick = TickIndex::current_bounded::<T>(netuid);
+
+                let (fees_out_tao, fees_out_alpha) = if tick_index > current_tick {
+                    (
+                        FeeGlobalTao::<T>::get(netuid),
+                        FeeGlobalAlpha::<T>::get(netuid),
+                    )
+                } else {
+                    (
+                        U64F64::saturating_from_num(0),
+                        U64F64::saturating_from_num(0),
+                    )
+                };
                 *maybe_tick = Some(Tick {
                     liquidity_net: net_liquidity_change,
                     liquidity_gross: liquidity,
-                    fees_out_tao: U64F64::from_num(0),
-                    fees_out_alpha: U64F64::from_num(0),
+                    fees_out_tao,
+                    fees_out_alpha,
                 });
             }
         });

From 25a8eada43f004dfe528db4230d71f617b45154e Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Fri, 13 Jun 2025 11:20:53 -0400
Subject: [PATCH 356/418] Add test for the fee fix

---
 pallets/subtensor/src/staking/remove_stake.rs |  2 +-
 pallets/swap/src/mock.rs                      | 20 +++---
 pallets/swap/src/pallet/tests.rs              | 70 ++++++++++++++++++-
 3 files changed, 80 insertions(+), 12 deletions(-)

diff --git a/pallets/subtensor/src/staking/remove_stake.rs b/pallets/subtensor/src/staking/remove_stake.rs
index 6d747148be..5f54a7449b 100644
--- a/pallets/subtensor/src/staking/remove_stake.rs
+++ b/pallets/subtensor/src/staking/remove_stake.rs
@@ -268,7 +268,7 @@ impl<T: Config> Pallet<T> {
             }
         }
 
-        // Stake into root. Ignore AmountTooLow error here.
+        // Stake into root.
         Self::stake_into_subnet(
             &hotkey,
             &coldkey,
diff --git a/pallets/swap/src/mock.rs b/pallets/swap/src/mock.rs
index 191e756dcc..68eba3d517 100644
--- a/pallets/swap/src/mock.rs
+++ b/pallets/swap/src/mock.rs
@@ -29,6 +29,8 @@ pub type Block = frame_system::mocking::MockBlock<Test>;
 pub type AccountId = u32;
 pub const OK_COLDKEY_ACCOUNT_ID: AccountId = 1;
 pub const OK_HOTKEY_ACCOUNT_ID: AccountId = 1000;
+pub const OK_COLDKEY_ACCOUNT_ID_2: AccountId = 2;
+pub const OK_HOTKEY_ACCOUNT_ID_2: AccountId = 1001;
 pub const NOT_SUBNET_OWNER: AccountId = 666;
 pub const NON_EXISTENT_NETUID: u16 = 999;
 
@@ -112,10 +114,10 @@ pub struct MockBalanceOps;
 
 impl BalanceOps<AccountId> for MockBalanceOps {
     fn tao_balance(account_id: &AccountId) -> u64 {
-        if *account_id == OK_COLDKEY_ACCOUNT_ID {
-            100_000_000_000_000
-        } else {
-            1_000_000_000
+        match *account_id {
+            OK_COLDKEY_ACCOUNT_ID => 100_000_000_000_000,
+            OK_COLDKEY_ACCOUNT_ID_2 => 100_000_000_000_000,
+            _ => 1_000_000_000,
         }
     }
 
@@ -124,12 +126,10 @@ impl BalanceOps<AccountId> for MockBalanceOps {
         coldkey_account_id: &AccountId,
         hotkey_account_id: &AccountId,
     ) -> u64 {
-        if (*coldkey_account_id == OK_COLDKEY_ACCOUNT_ID)
-            && (*hotkey_account_id == OK_HOTKEY_ACCOUNT_ID)
-        {
-            100_000_000_000_000
-        } else {
-            1_000_000_000
+        match (coldkey_account_id, hotkey_account_id) {
+            (&OK_COLDKEY_ACCOUNT_ID, &OK_HOTKEY_ACCOUNT_ID) => 100_000_000_000_000,
+            (&OK_COLDKEY_ACCOUNT_ID_2, &OK_HOTKEY_ACCOUNT_ID_2) => 100_000_000_000_000,
+            _ => 1_000_000_000,
         }
     }
 
diff --git a/pallets/swap/src/pallet/tests.rs b/pallets/swap/src/pallet/tests.rs
index bbd8909546..c72302c06b 100644
--- a/pallets/swap/src/pallet/tests.rs
+++ b/pallets/swap/src/pallet/tests.rs
@@ -1399,7 +1399,7 @@ fn test_user_liquidity_disabled() {
 }
 
 /// Test correctness of swap fees:
-///   1. Fees are distribued to (concentrated) liquidity providers
+///   - Fees are distribued to (concentrated) liquidity providers
 ///
 #[test]
 fn test_swap_fee_correctness() {
@@ -1535,3 +1535,71 @@ fn test_rollback_works() {
         );
     })
 }
+
+/// Test correctness of swap fees:
+///   - New LP is not eligible to previously accrued fees
+///
+/// cargo test --package pallet-subtensor-swap --lib -- pallet::tests::test_new_lp_doesnt_get_old_fees --exact --show-output
+#[test]
+fn test_new_lp_doesnt_get_old_fees() {
+    new_test_ext().execute_with(|| {
+        let min_price = tick_to_price(TickIndex::MIN);
+        let max_price = tick_to_price(TickIndex::MAX);
+        let netuid = NetUid::from(1);
+
+        // Provide very spread liquidity at the range from min to max that matches protocol liquidity
+        let liquidity = 2_000_000_000_000_u64; // 1x of protocol liquidity
+
+        assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
+
+        // Calculate ticks
+        let tick_low = price_to_tick(min_price);
+        let tick_high = price_to_tick(max_price);
+
+        // Add user liquidity
+        Pallet::<Test>::do_add_liquidity(
+            netuid,
+            &OK_COLDKEY_ACCOUNT_ID,
+            &OK_HOTKEY_ACCOUNT_ID,
+            tick_low,
+            tick_high,
+            liquidity,
+        )
+        .unwrap();
+
+        // Swap buy and swap sell
+        Pallet::<Test>::do_swap(
+            netuid,
+            OrderType::Buy,
+            liquidity / 10,
+            u64::MAX.into(),
+            false,
+        )
+        .unwrap();
+        Pallet::<Test>::do_swap(netuid, OrderType::Sell, liquidity / 10, 0_u64.into(), false)
+            .unwrap();
+
+        // Add liquidity from a different user to a new tick
+        let (position_id_2, _tao, _alpha) = Pallet::<Test>::do_add_liquidity(
+            netuid,
+            &OK_COLDKEY_ACCOUNT_ID_2,
+            &OK_HOTKEY_ACCOUNT_ID_2,
+            tick_low.next().unwrap(),
+            tick_high.prev().unwrap(),
+            liquidity,
+        )
+        .unwrap();
+
+        // Get user position
+        let mut position =
+            Positions::<Test>::get((netuid, OK_COLDKEY_ACCOUNT_ID_2, position_id_2)).unwrap();
+        assert_eq!(position.liquidity, liquidity);
+        assert_eq!(position.tick_low, tick_low.next().unwrap());
+        assert_eq!(position.tick_high, tick_high.prev().unwrap());
+
+        // Check that collected fees are 0
+        let (actual_fee_tao, actual_fee_alpha) = position.collect_fees();
+        assert_abs_diff_eq!(actual_fee_tao, 0, epsilon = 1);
+        assert_abs_diff_eq!(actual_fee_alpha, 0, epsilon = 1);
+    });
+}

From 922fba136f14323ed3e5d79cf8a8e0c3b87788cb Mon Sep 17 00:00:00 2001
From: Roman <roman@opentensor.dev>
Date: Fri, 13 Jun 2025 11:05:07 -0700
Subject: [PATCH 357/418] update `::set-output` with `$GITHUB_OUTPUT`

---
 .github/workflows/check-bittensor-e2e-tests.yml.yml | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/check-bittensor-e2e-tests.yml.yml b/.github/workflows/check-bittensor-e2e-tests.yml.yml
index f204f870a2..b53f9a6885 100644
--- a/.github/workflows/check-bittensor-e2e-tests.yml.yml
+++ b/.github/workflows/check-bittensor-e2e-tests.yml.yml
@@ -63,11 +63,9 @@ jobs:
           LABELS=$(gh pr view ${{ github.event.pull_request.number }} --json labels --jq '.labels[].name')
           echo "Current labels: $LABELS"
           if echo "$LABELS" | grep -q "run-bittensor-e2e-tests"; then
-            echo "run-bittensor-e2e-tests=true" >> $GITHUB_ENV
-            echo "::set-output name=run-bittensor-e2e-tests::true"
+            echo "run-bittensor-e2e-tests=true" >> $GITHUB_OUTPUT
           else
-            echo "run-bittensor-e2e-tests=false" >> $GITHUB_ENV
-            echo "::set-output name=run-bittensor-e2e-tests::false"
+            echo "run-bittensor-e2e-tests=false" >> $GITHUB_OUTPUT
           fi
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -94,7 +92,7 @@ jobs:
         id: get-btcli-tests
         run: |
           test_files=$(find ${{ github.workspace }}/btcli/tests/e2e_tests -name "test*.py" | jq -R -s -c 'split("\n") | map(select(. != ""))')
-          echo "::set-output name=test-files::$test_files"
+          echo "test-files=$test_files" >> $GITHUB_OUTPUT
         shell: bash
 
   find-sdk-e2e-tests:
@@ -119,7 +117,7 @@ jobs:
         id: get-sdk-tests
         run: |
           test_files=$(find ${{ github.workspace }}/bittensor/tests/e2e_tests -name "test*.py" | jq -R -s -c 'split("\n") | map(select(. != ""))')
-          echo "::set-output name=test-files::$test_files"
+          echo "test-files=$test_files" >> $GITHUB_OUTPUT
         shell: bash
 
   build-image-with-current-branch:

From 732d089ba58c93a86002a797d3caa401edeae4b6 Mon Sep 17 00:00:00 2001
From: Roman <roman@opentensor.dev>
Date: Fri, 13 Jun 2025 11:07:41 -0700
Subject: [PATCH 358/418] remove `Install uv dependencies` as duplicated action

---
 .github/workflows/check-bittensor-e2e-tests.yml.yml | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/.github/workflows/check-bittensor-e2e-tests.yml.yml b/.github/workflows/check-bittensor-e2e-tests.yml.yml
index b53f9a6885..0ba22b00ae 100644
--- a/.github/workflows/check-bittensor-e2e-tests.yml.yml
+++ b/.github/workflows/check-bittensor-e2e-tests.yml.yml
@@ -199,10 +199,6 @@ jobs:
           uv run --active pip install '.[dev]'
           uv run --active pip install pytest
 
-      - name: Install uv dependencies
-        working-directory: ${{ github.workspace }}/btcli
-        run: uv sync --all-extras --dev
-
       - name: Download Cached Docker Image
         uses: actions/download-artifact@v4
         with:
@@ -294,10 +290,6 @@ jobs:
           uv run --active pip install '.[dev]'
           uv run --active pip install pytest
 
-      - name: Install uv dependencies
-        working-directory: ${{ github.workspace }}/bittensor
-        run: uv sync --all-extras --dev
-
       - name: Download Cached Docker Image
         uses: actions/download-artifact@v4
         with:

From 0ad9363a8fb52b3c1035f876c48d8b88028e3fbb Mon Sep 17 00:00:00 2001
From: Roman <roman@opentensor.dev>
Date: Fri, 13 Jun 2025 11:30:34 -0700
Subject: [PATCH 359/418] add `workflow_dispatch` with `verbose`

---
 .github/workflows/check-bittensor-e2e-tests.yml.yml | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/.github/workflows/check-bittensor-e2e-tests.yml.yml b/.github/workflows/check-bittensor-e2e-tests.yml.yml
index 0ba22b00ae..437c87218d 100644
--- a/.github/workflows/check-bittensor-e2e-tests.yml.yml
+++ b/.github/workflows/check-bittensor-e2e-tests.yml.yml
@@ -18,6 +18,13 @@ on:
       - main
     types: [opened, synchronize, reopened, labeled, unlabeled]
 
+  workflow_dispatch:
+    inputs:
+      verbose:
+        description: "Output more information when triggered manually"
+        required: false
+        default: ""
+
 env:
   CARGO_TERM_COLOR: always
   VERBOSE: ${{ github.event.inputs.verbose }}
@@ -180,6 +187,8 @@ jobs:
 
       - name: Install uv
         uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: 'false'
 
       - name: Create Python virtual environment
         working-directory: ${{ github.workspace }}
@@ -271,6 +280,8 @@ jobs:
 
       - name: Install uv
         uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: 'false'
 
       - name: Create Python virtual environment
         working-directory: ${{ github.workspace }}

From 0ceb19aeebb53ba536a993b4fb6468302be1334a Mon Sep 17 00:00:00 2001
From: Roman <roman@opentensor.dev>
Date: Fri, 13 Jun 2025 11:31:43 -0700
Subject: [PATCH 360/418] comment if `temp`

---
 .github/workflows/check-bittensor-e2e-tests.yml.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/check-bittensor-e2e-tests.yml.yml b/.github/workflows/check-bittensor-e2e-tests.yml.yml
index 437c87218d..c01cb0a533 100644
--- a/.github/workflows/check-bittensor-e2e-tests.yml.yml
+++ b/.github/workflows/check-bittensor-e2e-tests.yml.yml
@@ -32,7 +32,7 @@ env:
 jobs:
   apply-label-to-new-pr:
     runs-on: ubuntu-latest
-    if: ${{ github.event.pull_request.draft == false }}
+    # if: ${{ github.event.pull_request.draft == false }}
     outputs:
       should_continue: ${{ steps.check.outputs.should_continue }}
     steps:

From 620d8b32fc2b427c50b2beeb0814a556e3ff89d1 Mon Sep 17 00:00:00 2001
From: Roman <roman@opentensor.dev>
Date: Fri, 13 Jun 2025 11:40:19 -0700
Subject: [PATCH 361/418] explicitly specify the branch for the build

---
 .github/workflows/check-bittensor-e2e-tests.yml.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.github/workflows/check-bittensor-e2e-tests.yml.yml b/.github/workflows/check-bittensor-e2e-tests.yml.yml
index c01cb0a533..0604f9c072 100644
--- a/.github/workflows/check-bittensor-e2e-tests.yml.yml
+++ b/.github/workflows/check-bittensor-e2e-tests.yml.yml
@@ -133,6 +133,8 @@ jobs:
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
+        with:
+          ref: ${{ github.head_ref }}
 
       - name: Set up QEMU
         uses: docker/setup-qemu-action@v3

From 9bd87e0a426670965e6008673f57adfa113a7103 Mon Sep 17 00:00:00 2001
From: Roman <roman@opentensor.dev>
Date: Fri, 13 Jun 2025 12:23:50 -0700
Subject: [PATCH 362/418] ooops we use remote image. add `Retag Docker Image`

---
 .github/workflows/check-bittensor-e2e-tests.yml.yml | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/check-bittensor-e2e-tests.yml.yml b/.github/workflows/check-bittensor-e2e-tests.yml.yml
index 0604f9c072..6a4cbc2c22 100644
--- a/.github/workflows/check-bittensor-e2e-tests.yml.yml
+++ b/.github/workflows/check-bittensor-e2e-tests.yml.yml
@@ -218,6 +218,9 @@ jobs:
       - name: Load Docker Image
         run: docker load -i subtensor-localnet.tar
 
+      - name: Retag Docker Image
+        run: docker tag localnet ghcr.io/opentensor/subtensor-localnet:devnet-ready
+
 #      - name: Run tests
 #        working-directory: ${{ github.workspace }}/btcli
 #        run: |
@@ -311,6 +314,9 @@ jobs:
       - name: Load Docker Image
         run: docker load -i subtensor-localnet.tar
 
+      - name: Retag Docker Image
+        run: docker tag localnet ghcr.io/opentensor/subtensor-localnet:devnet-ready
+
 #      - name: Run tests
 #        working-directory: ${{ github.workspace }}/bittensor
 #        run: |
@@ -338,4 +344,4 @@ jobs:
               echo "🕒 Retrying..."
               sleep 5
             fi
-          done
\ No newline at end of file
+          done

From 8449cfeb582df8631aee949f1b74183d4a3fd7dd Mon Sep 17 00:00:00 2001
From: Roman <roman@opentensor.dev>
Date: Fri, 13 Jun 2025 13:13:54 -0700
Subject: [PATCH 363/418] add skipping the pulling docker image from remote.
 use just built one

---
 .github/workflows/check-bittensor-e2e-tests.yml.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.github/workflows/check-bittensor-e2e-tests.yml.yml b/.github/workflows/check-bittensor-e2e-tests.yml.yml
index 6a4cbc2c22..48f6f92a1c 100644
--- a/.github/workflows/check-bittensor-e2e-tests.yml.yml
+++ b/.github/workflows/check-bittensor-e2e-tests.yml.yml
@@ -231,6 +231,7 @@ jobs:
         working-directory: ${{ github.workspace }}/btcli
         run: |
           source ${{ github.workspace }}/venv/bin/activate
+          export SKIP_PULL=1
           set +e
           for i in 1 2; do
             echo "🔁 Attempt $i: Running tests"
@@ -327,6 +328,7 @@ jobs:
         working-directory: ${{ github.workspace }}/bittensor
         run: |
           source ${{ github.workspace }}/venv/bin/activate
+          export SKIP_PULL=1
           set +e
           for i in 1 2; do
             echo "🔁 Attempt $i: Running tests"

From 5ed48f561842cd8dac36c3b0690b24f7f43b1441 Mon Sep 17 00:00:00 2001
From: Roman <roman@opentensor.dev>
Date: Fri, 13 Jun 2025 13:50:07 -0700
Subject: [PATCH 364/418] add Patch for fast-blocks tests

---
 .github/workflows/check-bittensor-e2e-tests.yml.yml | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/.github/workflows/check-bittensor-e2e-tests.yml.yml b/.github/workflows/check-bittensor-e2e-tests.yml.yml
index 48f6f92a1c..c71b721548 100644
--- a/.github/workflows/check-bittensor-e2e-tests.yml.yml
+++ b/.github/workflows/check-bittensor-e2e-tests.yml.yml
@@ -136,6 +136,11 @@ jobs:
         with:
           ref: ${{ github.head_ref }}
 
+      - name: Patch non-fast-block node
+        run: |
+          chmod +x ./scripts/localnet_patch.sh
+          ./scripts/localnet_patch.sh
+
       - name: Set up QEMU
         uses: docker/setup-qemu-action@v3
 

From 238e4b13d174a1572cf90a0f06996e77e3c84d36 Mon Sep 17 00:00:00 2001
From: Roman <roman@opentensor.dev>
Date: Fri, 13 Jun 2025 13:51:04 -0700
Subject: [PATCH 365/418] uncomment `if draft`

---
 .github/workflows/check-bittensor-e2e-tests.yml.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/check-bittensor-e2e-tests.yml.yml b/.github/workflows/check-bittensor-e2e-tests.yml.yml
index c71b721548..1820adcb99 100644
--- a/.github/workflows/check-bittensor-e2e-tests.yml.yml
+++ b/.github/workflows/check-bittensor-e2e-tests.yml.yml
@@ -32,7 +32,7 @@ env:
 jobs:
   apply-label-to-new-pr:
     runs-on: ubuntu-latest
-    # if: ${{ github.event.pull_request.draft == false }}
+    if: ${{ github.event.pull_request.draft == false }}
     outputs:
       should_continue: ${{ steps.check.outputs.should_continue }}
     steps:

From c352c2d27c08b0dfb3b78110488c465737b42d23 Mon Sep 17 00:00:00 2001
From: Roman <roman@opentensor.dev>
Date: Fri, 13 Jun 2025 14:14:03 -0700
Subject: [PATCH 366/418] remove `if draft`

---
 .github/workflows/check-bittensor-e2e-tests.yml.yml | 1 -
 1 file changed, 1 deletion(-)

diff --git a/.github/workflows/check-bittensor-e2e-tests.yml.yml b/.github/workflows/check-bittensor-e2e-tests.yml.yml
index 1820adcb99..6be275e3ee 100644
--- a/.github/workflows/check-bittensor-e2e-tests.yml.yml
+++ b/.github/workflows/check-bittensor-e2e-tests.yml.yml
@@ -32,7 +32,6 @@ env:
 jobs:
   apply-label-to-new-pr:
     runs-on: ubuntu-latest
-    if: ${{ github.event.pull_request.draft == false }}
     outputs:
       should_continue: ${{ steps.check.outputs.should_continue }}
     steps:

From 1b665ff430da0afc1c6aba07853ce41d93f81225 Mon Sep 17 00:00:00 2001
From: Sam Johnson <sam@durosoft.com>
Date: Sat, 14 Jun 2025 13:28:19 -0400
Subject: [PATCH 367/418] hotkey splitting emergency merge of #1559

---
 pallets/admin-utils/src/tests/mock.rs         |    4 +
 pallets/subtensor/src/benchmarks.rs           |    7 +-
 pallets/subtensor/src/lib.rs                  |   13 +
 pallets/subtensor/src/macros/config.rs        |    6 +
 pallets/subtensor/src/macros/dispatches.rs    |   11 +-
 pallets/subtensor/src/macros/errors.rs        |    2 +
 pallets/subtensor/src/macros/events.rs        |   12 +
 pallets/subtensor/src/macros/hooks.rs         |   44 +-
 pallets/subtensor/src/subnets/uids.rs         |    6 +
 pallets/subtensor/src/swap/swap_hotkey.rs     |  697 ++++----
 pallets/subtensor/src/tests/mock.rs           |    5 +
 pallets/subtensor/src/tests/mod.rs            |    1 +
 pallets/subtensor/src/tests/swap_hotkey.rs    |  212 ++-
 .../src/tests/swap_hotkey_with_subnet.rs      | 1516 +++++++++++++++++
 runtime/src/lib.rs                            |    4 +
 15 files changed, 2145 insertions(+), 395 deletions(-)
 create mode 100644 pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs

diff --git a/pallets/admin-utils/src/tests/mock.rs b/pallets/admin-utils/src/tests/mock.rs
index f8b3e6a9b6..960348cecd 100644
--- a/pallets/admin-utils/src/tests/mock.rs
+++ b/pallets/admin-utils/src/tests/mock.rs
@@ -140,6 +140,8 @@ parameter_types! {
     pub const InitialTaoWeight: u64 = u64::MAX/10; // 10% global weight.
     pub const InitialEmaPriceHalvingPeriod: u64 = 201_600_u64; // 4 weeks
     pub const DurationOfStartCall: u64 = 7 * 24 * 60 * 60 / 12; // 7 days
+    pub const InitialKeySwapOnSubnetCost: u64 = 10_000_000;
+    pub const HotkeySwapOnSubnetInterval: u64 = 7 * 24 * 60 * 60 / 12; // 7 days
 }
 
 impl pallet_subtensor::Config for Test {
@@ -209,6 +211,8 @@ impl pallet_subtensor::Config for Test {
     type InitialTaoWeight = InitialTaoWeight;
     type InitialEmaPriceHalvingPeriod = InitialEmaPriceHalvingPeriod;
     type DurationOfStartCall = DurationOfStartCall;
+    type KeySwapOnSubnetCost = InitialKeySwapOnSubnetCost;
+    type HotkeySwapOnSubnetInterval = HotkeySwapOnSubnetInterval;
 }
 
 #[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
diff --git a/pallets/subtensor/src/benchmarks.rs b/pallets/subtensor/src/benchmarks.rs
index a7cd03e652..eaad64199e 100644
--- a/pallets/subtensor/src/benchmarks.rs
+++ b/pallets/subtensor/src/benchmarks.rs
@@ -1454,7 +1454,12 @@ mod pallet_benchmarks {
         Subtensor::<T>::add_balance_to_coldkey_account(&coldkey, cost);
 
         #[extrinsic_call]
-        _(RawOrigin::Signed(coldkey.clone()), old.clone(), new.clone());
+        _(
+            RawOrigin::Signed(coldkey.clone()),
+            old.clone(),
+            new.clone(),
+            None,
+        );
     }
 
     #[benchmark]
diff --git a/pallets/subtensor/src/lib.rs b/pallets/subtensor/src/lib.rs
index 5a6decd597..d303f1a316 100644
--- a/pallets/subtensor/src/lib.rs
+++ b/pallets/subtensor/src/lib.rs
@@ -940,6 +940,19 @@ pub mod pallet {
         OptionQuery,
     >;
 
+    #[pallet::storage]
+    /// --- DMap ( netuid, coldkey ) --> blocknumber | last hotkey swap on network.
+    pub type LastHotkeySwapOnNetuid<T: Config> = StorageDoubleMap<
+        _,
+        Identity,
+        u16,
+        Blake2_128Concat,
+        T::AccountId,
+        u64,
+        ValueQuery,
+        DefaultZeroU64<T>,
+    >;
+
     #[pallet::storage]
     /// Ensures unique IDs for StakeJobs storage map
     pub type NextStakeJobId<T> = StorageValue<_, u64, ValueQuery, DefaultZeroU64<T>>;
diff --git a/pallets/subtensor/src/macros/config.rs b/pallets/subtensor/src/macros/config.rs
index 4377d9f016..b0f2483331 100644
--- a/pallets/subtensor/src/macros/config.rs
+++ b/pallets/subtensor/src/macros/config.rs
@@ -224,5 +224,11 @@ mod config {
         /// Block number after a new subnet accept the start call extrinsic.
         #[pallet::constant]
         type DurationOfStartCall: Get<u64>;
+        /// Cost of swapping a hotkey in a subnet.
+        #[pallet::constant]
+        type KeySwapOnSubnetCost: Get<u64>;
+        /// Block number for a coldkey swap the hotkey in specific subnet.
+        #[pallet::constant]
+        type HotkeySwapOnSubnetInterval: Get<u64>;
     }
 }
diff --git a/pallets/subtensor/src/macros/dispatches.rs b/pallets/subtensor/src/macros/dispatches.rs
index 5c71c64179..f629a9e108 100644
--- a/pallets/subtensor/src/macros/dispatches.rs
+++ b/pallets/subtensor/src/macros/dispatches.rs
@@ -935,17 +935,18 @@ mod dispatches {
             Self::do_burned_registration(origin, netuid, hotkey)
         }
 
-        /// The extrinsic for user to change its hotkey
+        /// The extrinsic for user to change its hotkey in subnet or all subnets.
         #[pallet::call_index(70)]
-        #[pallet::weight((Weight::from_parts(240_600_000, 0)
-        .saturating_add(T::DbWeight::get().reads(31))
-        .saturating_add(T::DbWeight::get().writes(23)), DispatchClass::Operational, Pays::No))]
+        #[pallet::weight((Weight::from_parts(285_900_000, 0)
+        .saturating_add(T::DbWeight::get().reads(47))
+        .saturating_add(T::DbWeight::get().writes(37)), DispatchClass::Operational, Pays::No))]
         pub fn swap_hotkey(
             origin: OriginFor<T>,
             hotkey: T::AccountId,
             new_hotkey: T::AccountId,
+            netuid: Option<u16>,
         ) -> DispatchResultWithPostInfo {
-            Self::do_swap_hotkey(origin, &hotkey, &new_hotkey)
+            Self::do_swap_hotkey(origin, &hotkey, &new_hotkey, netuid)
         }
 
         /// The extrinsic for user to change the coldkey associated with their account.
diff --git a/pallets/subtensor/src/macros/errors.rs b/pallets/subtensor/src/macros/errors.rs
index 2a8e5bc346..6e701014ae 100644
--- a/pallets/subtensor/src/macros/errors.rs
+++ b/pallets/subtensor/src/macros/errors.rs
@@ -210,6 +210,8 @@ mod errors {
         InvalidRecoveredPublicKey,
         /// SubToken disabled now
         SubtokenDisabled,
+        /// Too frequent hotkey swap on subnet
+        HotKeySwapOnSubnetIntervalNotPassed,
         /// Zero max stake amount
         ZeroMaxStakeAmount,
         /// Invalid netuid duplication
diff --git a/pallets/subtensor/src/macros/events.rs b/pallets/subtensor/src/macros/events.rs
index 9849a517ee..81694275f0 100644
--- a/pallets/subtensor/src/macros/events.rs
+++ b/pallets/subtensor/src/macros/events.rs
@@ -351,5 +351,17 @@ mod events {
         /// - **netuid**: The network identifier.
         /// - **Enabled**: Is Commit-Reveal enabled.
         CommitRevealEnabled(u16, bool),
+
+        /// the hotkey is swapped
+        HotkeySwappedOnSubnet {
+            /// the account ID of coldkey
+            coldkey: T::AccountId,
+            /// the account ID of old hotkey
+            old_hotkey: T::AccountId,
+            /// the account ID of new hotkey
+            new_hotkey: T::AccountId,
+            /// the subnet ID
+            netuid: u16,
+        },
     }
 }
diff --git a/pallets/subtensor/src/macros/hooks.rs b/pallets/subtensor/src/macros/hooks.rs
index a0e2fc6e72..d4a2feead0 100644
--- a/pallets/subtensor/src/macros/hooks.rs
+++ b/pallets/subtensor/src/macros/hooks.rs
@@ -14,7 +14,9 @@ mod hooks {
         // # Args:
         // 	* 'n': (BlockNumberFor<T>):
         // 		- The number of the block we are initializing.
-        fn on_initialize(_block_number: BlockNumberFor<T>) -> Weight {
+        fn on_initialize(block_number: BlockNumberFor<T>) -> Weight {
+            let hotkey_swap_clean_up_weight = Self::clean_up_hotkey_swap_records(block_number);
+
             let block_step_result = Self::block_step();
             match block_step_result {
                 Ok(_) => {
@@ -23,6 +25,7 @@ mod hooks {
                     Weight::from_parts(110_634_229_000_u64, 0)
                         .saturating_add(T::DbWeight::get().reads(8304_u64))
                         .saturating_add(T::DbWeight::get().writes(110_u64))
+                        .saturating_add(hotkey_swap_clean_up_weight)
                 }
                 Err(e) => {
                     // --- If the block step was unsuccessful, return the weight anyway.
@@ -30,6 +33,7 @@ mod hooks {
                     Weight::from_parts(110_634_229_000_u64, 0)
                         .saturating_add(T::DbWeight::get().reads(8304_u64))
                         .saturating_add(T::DbWeight::get().writes(110_u64))
+                        .saturating_add(hotkey_swap_clean_up_weight)
                 }
             }
         }
@@ -127,4 +131,42 @@ mod hooks {
             Ok(())
         }
     }
+
+    impl<T: Config> Pallet<T> {
+        // This function is to clean up the old hotkey swap records
+        // It just clean up for one subnet at a time, according to the block number
+        fn clean_up_hotkey_swap_records(block_number: BlockNumberFor<T>) -> Weight {
+            let mut weight = Weight::from_parts(0, 0);
+            let hotkey_swap_on_subnet_interval = T::HotkeySwapOnSubnetInterval::get();
+            let block_number: u64 = TryInto::try_into(block_number)
+                .ok()
+                .expect("blockchain will not exceed 2^64 blocks; QED.");
+            weight.saturating_accrue(T::DbWeight::get().reads(2_u64));
+
+            let netuids = Self::get_all_subnet_netuids();
+            weight.saturating_accrue(T::DbWeight::get().reads(netuids.len() as u64));
+
+            if let Some(slot) = block_number.checked_rem(hotkey_swap_on_subnet_interval) {
+                // only handle the subnet with the same residue as current block number by HotkeySwapOnSubnetInterval
+                for netuid in netuids.iter().filter(|netuid| {
+                    (**netuid as u64).checked_rem(hotkey_swap_on_subnet_interval) == Some(slot)
+                }) {
+                    // Iterate over all the coldkeys in the subnet
+                    for (coldkey, swap_block_number) in
+                        LastHotkeySwapOnNetuid::<T>::iter_prefix(netuid)
+                    {
+                        // Clean up out of date swap records
+                        if swap_block_number.saturating_add(hotkey_swap_on_subnet_interval)
+                            < block_number
+                        {
+                            LastHotkeySwapOnNetuid::<T>::remove(netuid, coldkey);
+                            weight.saturating_accrue(T::DbWeight::get().writes(1_u64));
+                        }
+                        weight.saturating_accrue(T::DbWeight::get().reads(1_u64));
+                    }
+                }
+            }
+            weight
+        }
+    }
 }
diff --git a/pallets/subtensor/src/subnets/uids.rs b/pallets/subtensor/src/subnets/uids.rs
index c97252677c..008fc03669 100644
--- a/pallets/subtensor/src/subnets/uids.rs
+++ b/pallets/subtensor/src/subnets/uids.rs
@@ -187,4 +187,10 @@ impl<T: Config> Pallet<T> {
         }
         false
     }
+
+    /// Return true if a hotkey is registered on specific network.
+    ///
+    pub fn is_hotkey_registered_on_specific_network(hotkey: &T::AccountId, netuid: u16) -> bool {
+        IsNetworkMember::<T>::contains_key(hotkey, netuid)
+    }
 }
diff --git a/pallets/subtensor/src/swap/swap_hotkey.rs b/pallets/subtensor/src/swap/swap_hotkey.rs
index 54c7c01d8e..733535c2ad 100644
--- a/pallets/subtensor/src/swap/swap_hotkey.rs
+++ b/pallets/subtensor/src/swap/swap_hotkey.rs
@@ -2,7 +2,6 @@ use super::*;
 use frame_support::weights::Weight;
 use sp_core::Get;
 use substrate_fixed::types::U64F64;
-
 impl<T: Config> Pallet<T> {
     /// Swaps the hotkey of a coldkey account.
     ///
@@ -11,6 +10,7 @@ impl<T: Config> Pallet<T> {
     /// * `origin` - The origin of the transaction, and also the coldkey account.
     /// * `old_hotkey` - The old hotkey to be swapped.
     /// * `new_hotkey` - The new hotkey to replace the old one.
+    /// * `netuid` - The hotkey swap in a subnet or all subnets.
     ///
     /// # Returns
     ///
@@ -27,76 +27,98 @@ impl<T: Config> Pallet<T> {
         origin: T::RuntimeOrigin,
         old_hotkey: &T::AccountId,
         new_hotkey: &T::AccountId,
+        netuid: Option<u16>,
     ) -> DispatchResultWithPostInfo {
         // 1. Ensure the origin is signed and get the coldkey
         let coldkey = ensure_signed(origin)?;
 
-        // 2. Initialize the weight for this operation
-        let mut weight = T::DbWeight::get().reads(2);
-
-        // 3. Ensure the new hotkey is different from the old one
-        ensure!(old_hotkey != new_hotkey, Error::<T>::NewHotKeyIsSameWithOld);
-
-        // 4. Ensure the new hotkey is not already registered on any network
-        ensure!(
-            !Self::is_hotkey_registered_on_any_network(new_hotkey),
-            Error::<T>::HotKeyAlreadyRegisteredInSubNet
-        );
-
-        // 5. Update the weight for the checks above
-        weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 0));
-
-        // 6. Ensure the coldkey owns the old hotkey
+        // 2. Ensure the coldkey owns the old hotkey
         ensure!(
             Self::coldkey_owns_hotkey(&coldkey, old_hotkey),
             Error::<T>::NonAssociatedColdKey
         );
 
-        // 7. Get the current block number
+        // 3. Initialize the weight for this operation
+        let mut weight = T::DbWeight::get().reads(2);
+
+        // 4. Ensure the new hotkey is different from the old one
+        ensure!(old_hotkey != new_hotkey, Error::<T>::NewHotKeyIsSameWithOld);
+
+        // 5. Get the current block number
         let block: u64 = Self::get_current_block_as_u64();
 
-        // 8. Ensure the transaction rate limit is not exceeded
+        // 6. Ensure the transaction rate limit is not exceeded
         ensure!(
             !Self::exceeds_tx_rate_limit(Self::get_last_tx_block(&coldkey), block),
             Error::<T>::HotKeySetTxRateLimitExceeded
         );
 
-        // 9. Update the weight for reading the total networks
-        weight.saturating_accrue(
-            T::DbWeight::get().reads((TotalNetworks::<T>::get().saturating_add(1u16)) as u64),
+        weight.saturating_accrue(T::DbWeight::get().reads(2));
+
+        // 7. Swap LastTxBlock
+        // LastTxBlock( hotkey ) --> u64 -- the last transaction block for the hotkey.
+        let last_tx_block: u64 = LastTxBlock::<T>::get(old_hotkey);
+        LastTxBlock::<T>::insert(new_hotkey, last_tx_block);
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
+
+        // 8. Swap LastTxBlockDelegateTake
+        // LastTxBlockDelegateTake( hotkey ) --> u64 -- the last transaction block for the hotkey delegate take.
+        let last_tx_block_delegate_take: u64 = LastTxBlockDelegateTake::<T>::get(old_hotkey);
+        LastTxBlockDelegateTake::<T>::insert(new_hotkey, last_tx_block_delegate_take);
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
+
+        // 9. Swap LastTxBlockChildKeyTake
+        // LastTxBlockChildKeyTake( hotkey ) --> u64 -- the last transaction block for the hotkey child key take.
+        let last_tx_block_child_key_take: u64 = LastTxBlockChildKeyTake::<T>::get(old_hotkey);
+        LastTxBlockChildKeyTake::<T>::insert(new_hotkey, last_tx_block_child_key_take);
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
+
+        // 10. fork for swap hotkey on a specific subnet case after do the common check
+        if let Some(netuid) = netuid {
+            return Self::swap_hotkey_on_subnet(&coldkey, old_hotkey, new_hotkey, netuid, weight);
+        };
+
+        // Start to do everything for swap hotkey on all subnets case
+        // 11. Ensure the new hotkey is not already registered on any network
+        ensure!(
+            !Self::is_hotkey_registered_on_any_network(new_hotkey),
+            Error::<T>::HotKeyAlreadyRegisteredInSubNet
         );
 
-        // 10. Get the cost for swapping the key
+        // 12. Get the cost for swapping the key
         let swap_cost = Self::get_key_swap_cost();
         log::debug!("Swap cost: {:?}", swap_cost);
 
-        // 11. Ensure the coldkey has enough balance to pay for the swap
+        // 13. Ensure the coldkey has enough balance to pay for the swap
         ensure!(
             Self::can_remove_balance_from_coldkey_account(&coldkey, swap_cost),
             Error::<T>::NotEnoughBalanceToPaySwapHotKey
         );
 
-        // 12. Remove the swap cost from the coldkey's account
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(3, 0));
+
+        // 14. Remove the swap cost from the coldkey's account
         let actual_burn_amount = Self::remove_balance_from_coldkey_account(&coldkey, swap_cost)?;
 
-        // 13. Burn the tokens
+        // 18. Burn the tokens
         Self::burn_tokens(actual_burn_amount);
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(0, 2));
 
-        // 14. Perform the hotkey swap
-        let _ = Self::perform_hotkey_swap(old_hotkey, new_hotkey, &coldkey, &mut weight);
+        // 19. Perform the hotkey swap
+        Self::perform_hotkey_swap_on_all_subnets(old_hotkey, new_hotkey, &coldkey, &mut weight)?;
 
-        // 15. Update the last transaction block for the coldkey
+        // 20. Update the last transaction block for the coldkey
         Self::set_last_tx_block(&coldkey, block);
         weight.saturating_accrue(T::DbWeight::get().writes(1));
 
-        // 16. Emit an event for the hotkey swap
+        // 21. Emit an event for the hotkey swap
         Self::deposit_event(Event::HotkeySwapped {
             coldkey,
             old_hotkey: old_hotkey.clone(),
             new_hotkey: new_hotkey.clone(),
         });
 
-        // 17. Return the weight of the operation
+        // 22. Return the weight of the operation
         Ok(Some(weight).into())
     }
 
@@ -134,87 +156,65 @@ impl<T: Config> Pallet<T> {
     /// # Note
     /// This function performs extensive storage reads and writes, which can be computationally expensive.
     /// The accumulated weight should be carefully considered in the context of block limits.
-    pub fn perform_hotkey_swap(
+    pub fn perform_hotkey_swap_on_all_subnets(
         old_hotkey: &T::AccountId,
         new_hotkey: &T::AccountId,
         coldkey: &T::AccountId,
         weight: &mut Weight,
     ) -> DispatchResult {
-        // 1. Swap owner.
+        // 1. keep the old hotkey alpha values for the case where hotkey staked by multiple coldkeys.
+        let old_alpha_values: Vec<((T::AccountId, u16), U64F64)> =
+            Alpha::<T>::iter_prefix((old_hotkey,)).collect();
+        weight.saturating_accrue(T::DbWeight::get().reads(old_alpha_values.len() as u64));
+
+        // 2. Swap owner.
         // Owner( hotkey ) -> coldkey -- the coldkey that owns the hotkey.
         Owner::<T>::remove(old_hotkey);
         Owner::<T>::insert(new_hotkey, coldkey.clone());
         weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
 
-        // 2. Swap OwnedHotkeys.
+        // 3. Swap OwnedHotkeys.
         // OwnedHotkeys( coldkey ) -> Vec<hotkey> -- the hotkeys that the coldkey owns.
         let mut hotkeys = OwnedHotkeys::<T>::get(coldkey);
         // Add the new key if needed.
         if !hotkeys.contains(new_hotkey) {
             hotkeys.push(new_hotkey.clone());
         }
-        // Remove the old key.
+
+        // 4. Remove the old key.
         hotkeys.retain(|hk| *hk != *old_hotkey);
         OwnedHotkeys::<T>::insert(coldkey, hotkeys);
-        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
 
-        // 3. Swap total hotkey alpha for all subnets it exists on.
-        // TotalHotkeyAlpha( hotkey, netuid ) -> alpha -- the total alpha that the hotkey has on a specific subnet.
-        TotalHotkeyAlpha::<T>::iter_prefix(old_hotkey)
-            .drain()
-            .for_each(|(netuid, old_alpha)| {
-                let new_total_hotkey_alpha = TotalHotkeyAlpha::<T>::get(new_hotkey, netuid);
-                TotalHotkeyAlpha::<T>::insert(
-                    new_hotkey,
-                    netuid,
-                    old_alpha.saturating_add(new_total_hotkey_alpha),
-                );
-                weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 2));
-            });
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
 
-        // 4. Swap total hotkey shares on all subnets it exists on.
-        // TotalHotkeyShares( hotkey, netuid ) -> alpha -- the total alpha that the hotkey has on a specific subnet.
-        TotalHotkeyShares::<T>::iter_prefix(old_hotkey)
-            .drain()
-            .for_each(|(netuid, old_shares)| {
-                let new_total_hotkey_shares = TotalHotkeyShares::<T>::get(new_hotkey, netuid);
-                TotalHotkeyShares::<T>::insert(
-                    new_hotkey,
-                    netuid,
-                    old_shares.saturating_add(new_total_hotkey_shares),
-                );
-                weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 2));
-            });
+        // 5. execute the hotkey swap on all subnets
+        for netuid in Self::get_all_subnet_netuids() {
+            Self::perform_hotkey_swap_on_one_subnet(old_hotkey, new_hotkey, weight, netuid);
+        }
 
-        // 5. Swap LastTxBlock
+        // 6. Swap LastTxBlock
         // LastTxBlock( hotkey ) --> u64 -- the last transaction block for the hotkey.
-        let last_tx_block: u64 = LastTxBlock::<T>::get(old_hotkey);
         LastTxBlock::<T>::remove(old_hotkey);
-        LastTxBlock::<T>::insert(new_hotkey, last_tx_block);
         weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
 
-        // 6. Swap LastTxBlockDelegateTake
+        // 7. Swap LastTxBlockDelegateTake
         // LastTxBlockDelegateTake( hotkey ) --> u64 -- the last transaction block for the hotkey delegate take.
-        let last_tx_block_delegate_take: u64 = LastTxBlockDelegateTake::<T>::get(old_hotkey);
         LastTxBlockDelegateTake::<T>::remove(old_hotkey);
-        LastTxBlockDelegateTake::<T>::insert(new_hotkey, last_tx_block_delegate_take);
         weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
 
-        // 7. Swap LastTxBlockChildKeyTake
+        // 8. Swap LastTxBlockChildKeyTake
         // LastTxBlockChildKeyTake( hotkey ) --> u64 -- the last transaction block for the hotkey child key take.
-        let last_tx_block_child_key_take: u64 = LastTxBlockChildKeyTake::<T>::get(old_hotkey);
         LastTxBlockChildKeyTake::<T>::remove(old_hotkey);
-        LastTxBlockChildKeyTake::<T>::insert(new_hotkey, last_tx_block_child_key_take);
         weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
 
-        // 8. Swap Senate members.
+        // 9. Swap Senate members.
         // Senate( hotkey ) --> ?
         if T::SenateMembers::is_member(old_hotkey) {
             T::SenateMembers::swap_member(old_hotkey, new_hotkey).map_err(|e| e.error)?;
             weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
         }
 
-        // 9. Swap delegates.
+        // 10. Swap delegates.
         // Delegates( hotkey ) -> take value -- the hotkey delegate take value.
         if Delegates::<T>::contains_key(old_hotkey) {
             let old_delegate_take = Delegates::<T>::get(old_hotkey);
@@ -223,270 +223,373 @@ impl<T: Config> Pallet<T> {
             weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 2));
         }
 
-        // 9. swap PendingHotkeyEmissionOnNetuid
-        // (DEPRECATED.)
-
-        // 10. Swap all subnet specific info.
-        let all_netuids: Vec<u16> = Self::get_all_subnet_netuids();
-        all_netuids.iter().for_each(|netuid| {
-            // 10.1 Remove the previous hotkey and insert the new hotkey from membership.
-            // IsNetworkMember( hotkey, netuid ) -> bool -- is the hotkey a subnet member.
-            let is_network_member: bool = IsNetworkMember::<T>::get(old_hotkey, netuid);
-            IsNetworkMember::<T>::remove(old_hotkey, netuid);
-            IsNetworkMember::<T>::insert(new_hotkey, netuid, is_network_member);
-            weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
-
-            // 10.2 Swap Uids + Keys.
-            // Keys( netuid, hotkey ) -> uid -- the uid the hotkey has in the network if it is a member.
-            // Uids( netuid, hotkey ) -> uid -- the uids that the hotkey has.
-            if is_network_member {
-                // 10.2.1 Swap the UIDS
-                if let Ok(old_uid) = Uids::<T>::try_get(netuid, old_hotkey) {
-                    Uids::<T>::remove(netuid, old_hotkey);
-                    Uids::<T>::insert(netuid, new_hotkey, old_uid);
-                    weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
-
-                    // 10.2.2 Swap the keys.
-                    Keys::<T>::insert(netuid, old_uid, new_hotkey.clone());
-                    weight.saturating_accrue(T::DbWeight::get().reads_writes(0, 1));
+        // 11. Alpha already update in perform_hotkey_swap_on_one_subnet
+        // Update the StakingHotkeys for the case where hotkey staked by multiple coldkeys.
+        for ((coldkey, _netuid), _alpha) in old_alpha_values {
+            // Swap StakingHotkeys.
+            // StakingHotkeys( coldkey ) --> Vec<hotkey> -- the hotkeys that the coldkey stakes.
+            let mut staking_hotkeys = StakingHotkeys::<T>::get(&coldkey);
+            weight.saturating_accrue(T::DbWeight::get().reads(1));
+            if staking_hotkeys.contains(old_hotkey) {
+                staking_hotkeys.retain(|hk| *hk != *old_hotkey && *hk != *new_hotkey);
+                if !staking_hotkeys.contains(new_hotkey) {
+                    staking_hotkeys.push(new_hotkey.clone());
                 }
+                StakingHotkeys::<T>::insert(&coldkey, staking_hotkeys);
+                weight.saturating_accrue(T::DbWeight::get().writes(1));
             }
+        }
 
-            // 10.3 Swap Prometheus.
-            // Prometheus( netuid, hotkey ) -> prometheus -- the prometheus data that a hotkey has in the network.
-            if is_network_member {
-                if let Ok(old_prometheus_info) = Prometheus::<T>::try_get(netuid, old_hotkey) {
-                    Prometheus::<T>::remove(netuid, old_hotkey);
-                    Prometheus::<T>::insert(netuid, new_hotkey, old_prometheus_info);
-                    weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
-                }
+        // Return successful after swapping all the relevant terms.
+        Ok(())
+    }
+
+    pub fn swap_senate_member(
+        old_hotkey: &T::AccountId,
+        new_hotkey: &T::AccountId,
+        weight: &mut Weight,
+    ) -> DispatchResult {
+        weight.saturating_accrue(T::DbWeight::get().reads(1));
+        if T::SenateMembers::is_member(old_hotkey) {
+            T::SenateMembers::swap_member(old_hotkey, new_hotkey).map_err(|e| e.error)?;
+            weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
+        }
+        Ok(())
+    }
+
+    fn swap_hotkey_on_subnet(
+        coldkey: &T::AccountId,
+        old_hotkey: &T::AccountId,
+        new_hotkey: &T::AccountId,
+        netuid: u16,
+        init_weight: Weight,
+    ) -> DispatchResultWithPostInfo {
+        // 1. Ensure coldkey not swap hotkey too frequently
+        let mut weight: Weight = init_weight;
+        let block: u64 = Self::get_current_block_as_u64();
+        let hotkey_swap_interval = T::HotkeySwapOnSubnetInterval::get();
+        let last_hotkey_swap_block = LastHotkeySwapOnNetuid::<T>::get(netuid, coldkey);
+
+        ensure!(
+            last_hotkey_swap_block.saturating_add(hotkey_swap_interval) < block,
+            Error::<T>::HotKeySwapOnSubnetIntervalNotPassed
+        );
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(3, 0));
+
+        // 2. Ensure the hotkey not registered on the network before.
+        ensure!(
+            !Self::is_hotkey_registered_on_specific_network(new_hotkey, netuid),
+            Error::<T>::HotKeyAlreadyRegisteredInSubNet
+        );
+
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 0));
+
+        // 3. Get the cost for swapping the key on the subnet
+        let swap_cost = T::KeySwapOnSubnetCost::get();
+        log::debug!("Swap cost in subnet {:?}: {:?}", netuid, swap_cost);
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 0));
+
+        // 4. Ensure the coldkey has enough balance to pay for the swap
+        ensure!(
+            Self::can_remove_balance_from_coldkey_account(coldkey, swap_cost),
+            Error::<T>::NotEnoughBalanceToPaySwapHotKey
+        );
+
+        // 5. Remove the swap cost from the coldkey's account
+        let actual_burn_amount = Self::remove_balance_from_coldkey_account(coldkey, swap_cost)?;
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 0));
+
+        // 6. Burn the tokens
+        Self::burn_tokens(actual_burn_amount);
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
+
+        // 7. Swap owner.
+        // Owner( hotkey ) -> coldkey -- the coldkey that owns the hotkey.
+        // Owner::<T>::remove(old_hotkey);
+        Owner::<T>::insert(new_hotkey, coldkey.clone());
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
+
+        // 8. Swap OwnedHotkeys.
+        // OwnedHotkeys( coldkey ) -> Vec<hotkey> -- the hotkeys that the coldkey owns.
+        let mut hotkeys = OwnedHotkeys::<T>::get(coldkey);
+        // Add the new key if needed.
+        if !hotkeys.contains(new_hotkey) {
+            hotkeys.push(new_hotkey.clone());
+            OwnedHotkeys::<T>::insert(coldkey, hotkeys);
+            weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
+        }
+
+        // 9. Perform the hotkey swap
+        Self::perform_hotkey_swap_on_one_subnet(old_hotkey, new_hotkey, &mut weight, netuid);
+
+        // 10. Update the last transaction block for the coldkey
+        Self::set_last_tx_block(coldkey, block);
+        LastHotkeySwapOnNetuid::<T>::insert(netuid, coldkey, block);
+        weight.saturating_accrue(T::DbWeight::get().writes(2));
+
+        // 11. Emit an event for the hotkey swap
+        Self::deposit_event(Event::HotkeySwappedOnSubnet {
+            coldkey: coldkey.clone(),
+            old_hotkey: old_hotkey.clone(),
+            new_hotkey: new_hotkey.clone(),
+            netuid,
+        });
+
+        Ok(Some(weight).into())
+    }
+
+    // do hotkey swap public part for both swap all subnets and just swap one subnet
+    pub fn perform_hotkey_swap_on_one_subnet(
+        old_hotkey: &T::AccountId,
+        new_hotkey: &T::AccountId,
+        weight: &mut Weight,
+        netuid: u16,
+    ) {
+        // 1. Swap total hotkey alpha for all subnets it exists on.
+        // TotalHotkeyAlpha( hotkey, netuid ) -> alpha -- the total alpha that the hotkey has on a specific subnet.
+        let alpha = TotalHotkeyAlpha::<T>::take(old_hotkey, netuid);
+
+        TotalHotkeyAlpha::<T>::mutate(new_hotkey, netuid, |value| {
+            *value = value.saturating_add(alpha)
+        });
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
+
+        // 2. Swap total hotkey shares on all subnets it exists on.
+        // TotalHotkeyShares( hotkey, netuid ) -> alpha -- the total alpha that the hotkey has on a specific subnet.
+        let share = TotalHotkeyShares::<T>::take(old_hotkey, netuid);
+        // TotalHotkeyAlpha::<T>::remove(old_hotkey, netuid);
+        TotalHotkeyShares::<T>::mutate(new_hotkey, netuid, |value| {
+            *value = value.saturating_add(share)
+        });
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
+
+        // 3. Swap all subnet specific info.
+
+        // 3.1 Remove the previous hotkey and insert the new hotkey from membership.
+        // IsNetworkMember( hotkey, netuid ) -> bool -- is the hotkey a subnet member.
+        let is_network_member: bool = IsNetworkMember::<T>::get(old_hotkey, netuid);
+        IsNetworkMember::<T>::remove(old_hotkey, netuid);
+        IsNetworkMember::<T>::insert(new_hotkey, netuid, is_network_member);
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
+
+        // 3.2 Swap Uids + Keys.
+        // Keys( netuid, hotkey ) -> uid -- the uid the hotkey has in the network if it is a member.
+        // Uids( netuid, hotkey ) -> uid -- the uids that the hotkey has.
+        if is_network_member {
+            // 3.2.1 Swap the UIDS
+            if let Ok(old_uid) = Uids::<T>::try_get(netuid, old_hotkey) {
+                Uids::<T>::remove(netuid, old_hotkey);
+                Uids::<T>::insert(netuid, new_hotkey, old_uid);
+                weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
+
+                // 3.2.2 Swap the keys.
+                Keys::<T>::insert(netuid, old_uid, new_hotkey.clone());
+                weight.saturating_accrue(T::DbWeight::get().reads_writes(0, 1));
             }
+        }
 
-            // 10.4. Swap axons.
-            // Axons( netuid, hotkey ) -> axon -- the axon that the hotkey has.
-            if is_network_member {
-                if let Ok(old_axon_info) = Axons::<T>::try_get(netuid, old_hotkey) {
-                    Axons::<T>::remove(netuid, old_hotkey);
-                    Axons::<T>::insert(netuid, new_hotkey, old_axon_info);
-                    weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
-                }
+        // 3.3 Swap Prometheus.
+        // Prometheus( netuid, hotkey ) -> prometheus -- the prometheus data that a hotkey has in the network.
+        if is_network_member {
+            if let Ok(old_prometheus_info) = Prometheus::<T>::try_get(netuid, old_hotkey) {
+                Prometheus::<T>::remove(netuid, old_hotkey);
+                Prometheus::<T>::insert(netuid, new_hotkey, old_prometheus_info);
+                weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
             }
+        }
 
-            // 10.5 Swap WeightCommits
-            // WeightCommits( hotkey ) --> Vec<u64> -- the weight commits for the hotkey.
-            if is_network_member {
-                if let Ok(old_weight_commits) = WeightCommits::<T>::try_get(netuid, old_hotkey) {
-                    WeightCommits::<T>::remove(netuid, old_hotkey);
-                    WeightCommits::<T>::insert(netuid, new_hotkey, old_weight_commits);
-                    weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
-                }
+        // 3.4. Swap axons.
+        // Axons( netuid, hotkey ) -> axon -- the axon that the hotkey has.
+        if is_network_member {
+            if let Ok(old_axon_info) = Axons::<T>::try_get(netuid, old_hotkey) {
+                Axons::<T>::remove(netuid, old_hotkey);
+                Axons::<T>::insert(netuid, new_hotkey, old_axon_info);
+                weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
             }
+        }
 
-            // 10.6. Swap the subnet loaded emission.
-            // LoadedEmission( netuid ) --> Vec<(hotkey, u64)> -- the loaded emission for the subnet.
-            if is_network_member {
-                if let Some(mut old_loaded_emission) = LoadedEmission::<T>::get(netuid) {
-                    for emission in old_loaded_emission.iter_mut() {
-                        if emission.0 == *old_hotkey {
-                            emission.0 = new_hotkey.clone();
-                        }
-                    }
-                    LoadedEmission::<T>::remove(netuid);
-                    LoadedEmission::<T>::insert(netuid, old_loaded_emission);
-                    weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
-                }
+        // 3.5 Swap WeightCommits
+        // WeightCommits( hotkey ) --> Vec<u64> -- the weight commits for the hotkey.
+        if is_network_member {
+            if let Ok(old_weight_commits) = WeightCommits::<T>::try_get(netuid, old_hotkey) {
+                WeightCommits::<T>::remove(netuid, old_hotkey);
+                WeightCommits::<T>::insert(netuid, new_hotkey, old_weight_commits);
+                weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
             }
+        }
 
-            // 10.7. Swap neuron TLS certificates.
-            // NeuronCertificates( netuid, hotkey ) -> Vec<u8> -- the neuron certificate for the hotkey.
-            if is_network_member {
-                if let Ok(old_neuron_certificates) =
-                    NeuronCertificates::<T>::try_get(netuid, old_hotkey)
-                {
-                    NeuronCertificates::<T>::remove(netuid, old_hotkey);
-                    NeuronCertificates::<T>::insert(netuid, new_hotkey, old_neuron_certificates);
-                    weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
+        // 3.6. Swap the subnet loaded emission.
+        // LoadedEmission( netuid ) --> Vec<(hotkey, u64)> -- the loaded emission for the subnet.
+        if is_network_member {
+            if let Some(mut old_loaded_emission) = LoadedEmission::<T>::get(netuid) {
+                for emission in old_loaded_emission.iter_mut() {
+                    if emission.0 == *old_hotkey {
+                        emission.0 = new_hotkey.clone();
+                    }
                 }
+                LoadedEmission::<T>::remove(netuid);
+                LoadedEmission::<T>::insert(netuid, old_loaded_emission);
+                weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
             }
-        });
-
-        // 11. Swap Alpha
-        // Alpha( hotkey, coldkey, netuid ) -> alpha
-        let old_alpha_values: Vec<((T::AccountId, u16), U64F64)> =
-            Alpha::<T>::iter_prefix((old_hotkey,)).collect();
-        // Clear the entire old prefix here.
-        let _ = Alpha::<T>::clear_prefix((old_hotkey,), old_alpha_values.len() as u32, None);
-        weight.saturating_accrue(T::DbWeight::get().reads(old_alpha_values.len() as u64));
-        weight.saturating_accrue(T::DbWeight::get().writes(old_alpha_values.len() as u64));
-
-        // Insert the new alpha values.
-        for ((coldkey, netuid), alpha) in old_alpha_values {
-            let new_alpha = Alpha::<T>::get((new_hotkey, &coldkey, netuid));
-            Alpha::<T>::insert(
-                (new_hotkey, &coldkey, netuid),
-                new_alpha.saturating_add(alpha),
-            );
-            weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
+        }
 
-            // Swap StakingHotkeys.
-            // StakingHotkeys( coldkey ) --> Vec<hotkey> -- the hotkeys that the coldkey stakes.
-            let mut staking_hotkeys = StakingHotkeys::<T>::get(&coldkey);
-            weight.saturating_accrue(T::DbWeight::get().reads(1));
-            if staking_hotkeys.contains(old_hotkey) {
-                staking_hotkeys.retain(|hk| *hk != *old_hotkey && *hk != *new_hotkey);
-                staking_hotkeys.push(new_hotkey.clone());
-                StakingHotkeys::<T>::insert(&coldkey, staking_hotkeys);
-                weight.saturating_accrue(T::DbWeight::get().writes(1));
+        // 3.7. Swap neuron TLS certificates.
+        // NeuronCertificates( netuid, hotkey ) -> Vec<u8> -- the neuron certificate for the hotkey.
+        if is_network_member {
+            if let Ok(old_neuron_certificates) =
+                NeuronCertificates::<T>::try_get(netuid, old_hotkey)
+            {
+                NeuronCertificates::<T>::remove(netuid, old_hotkey);
+                NeuronCertificates::<T>::insert(netuid, new_hotkey, old_neuron_certificates);
+                weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
             }
         }
-
-        // 12. Swap ChildKeys.
+        // 4. Swap ChildKeys.
         // ChildKeys( parent, netuid ) --> Vec<(proportion,child)> -- the child keys of the parent.
-        for netuid in Self::get_all_subnet_netuids() {
-            // Get the children of the old hotkey for this subnet
-            let my_children: Vec<(u64, T::AccountId)> = ChildKeys::<T>::get(old_hotkey, netuid);
-            // Remove the old hotkey's child entries
-            ChildKeys::<T>::remove(old_hotkey, netuid);
-            // Insert the same child entries for the new hotkey
-            ChildKeys::<T>::insert(new_hotkey, netuid, my_children.clone());
-            weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
-            for (_, child_key_i) in my_children {
-                // For each child, update their parent list
-                let mut child_parents: Vec<(u64, T::AccountId)> =
-                    ParentKeys::<T>::get(child_key_i.clone(), netuid);
-                for parent in child_parents.iter_mut() {
-                    // If the parent is the old hotkey, replace it with the new hotkey
-                    if parent.1 == *old_hotkey {
-                        parent.1 = new_hotkey.clone();
-                    }
+        let my_children: Vec<(u64, T::AccountId)> = ChildKeys::<T>::get(old_hotkey, netuid);
+        // Remove the old hotkey's child entries
+        ChildKeys::<T>::remove(old_hotkey, netuid);
+        // Insert the same child entries for the new hotkey
+        ChildKeys::<T>::insert(new_hotkey, netuid, my_children.clone());
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
+
+        for (_, child_key_i) in my_children {
+            // For each child, update their parent list
+            let mut child_parents: Vec<(u64, T::AccountId)> =
+                ParentKeys::<T>::get(child_key_i.clone(), netuid);
+            for parent in child_parents.iter_mut() {
+                // If the parent is the old hotkey, replace it with the new hotkey
+                if parent.1 == *old_hotkey {
+                    parent.1 = new_hotkey.clone();
                 }
-                // Update the child's parent list
-                ParentKeys::<T>::insert(child_key_i, netuid, child_parents);
-                weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
             }
+            // Update the child's parent list
+            ParentKeys::<T>::insert(child_key_i, netuid, child_parents);
+            weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
         }
+        // }
 
-        // 13. Swap ParentKeys.
+        // 5. Swap ParentKeys.
         // ParentKeys( child, netuid ) --> Vec<(proportion,parent)> -- the parent keys of the child.
-        for netuid in Self::get_all_subnet_netuids() {
-            // Get the parents of the old hotkey for this subnet
-            let parents: Vec<(u64, T::AccountId)> = ParentKeys::<T>::get(old_hotkey, netuid);
-            // Remove the old hotkey's parent entries
-            ParentKeys::<T>::remove(old_hotkey, netuid);
-            // Insert the same parent entries for the new hotkey
-            ParentKeys::<T>::insert(new_hotkey, netuid, parents.clone());
-            weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
-            for (_, parent_key_i) in parents {
-                // For each parent, update their children list
-                let mut parent_children: Vec<(u64, T::AccountId)> =
-                    ChildKeys::<T>::get(parent_key_i.clone(), netuid);
-                for child in parent_children.iter_mut() {
-                    // If the child is the old hotkey, replace it with the new hotkey
-                    if child.1 == *old_hotkey {
-                        child.1 = new_hotkey.clone();
-                    }
+        let parents: Vec<(u64, T::AccountId)> = ParentKeys::<T>::get(old_hotkey, netuid);
+        // Remove the old hotkey's parent entries
+        ParentKeys::<T>::remove(old_hotkey, netuid);
+        // Insert the same parent entries for the new hotkey
+        ParentKeys::<T>::insert(new_hotkey, netuid, parents.clone());
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
+
+        for (_, parent_key_i) in parents {
+            // For each parent, update their children list
+            let mut parent_children: Vec<(u64, T::AccountId)> =
+                ChildKeys::<T>::get(parent_key_i.clone(), netuid);
+            for child in parent_children.iter_mut() {
+                // If the child is the old hotkey, replace it with the new hotkey
+                if child.1 == *old_hotkey {
+                    child.1 = new_hotkey.clone();
                 }
-                // Update the parent's children list
-                ChildKeys::<T>::insert(parent_key_i, netuid, parent_children);
-                weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
             }
+            // Update the parent's children list
+            ChildKeys::<T>::insert(parent_key_i, netuid, parent_children);
+            weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
         }
 
-        // 14. Swap PendingChildKeys.
+        // 6. Swap PendingChildKeys.
         // PendingChildKeys( netuid, parent ) --> Vec<(proportion,child), cool_down_block>
-        for netuid in Self::get_all_subnet_netuids() {
+        if PendingChildKeys::<T>::contains_key(netuid, old_hotkey) {
+            let (children, cool_down_block) = PendingChildKeys::<T>::get(netuid, old_hotkey);
+            PendingChildKeys::<T>::remove(netuid, old_hotkey);
+            PendingChildKeys::<T>::insert(netuid, new_hotkey, (children, cool_down_block));
+            weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
+        }
+
+        // Also check for others with our hotkey as a child
+        for (hotkey, (children, cool_down_block)) in PendingChildKeys::<T>::iter_prefix(netuid) {
             weight.saturating_accrue(T::DbWeight::get().reads(1));
-            if PendingChildKeys::<T>::contains_key(netuid, old_hotkey) {
-                let (children, cool_down_block) = PendingChildKeys::<T>::get(netuid, old_hotkey);
-                PendingChildKeys::<T>::remove(netuid, old_hotkey);
-                PendingChildKeys::<T>::insert(netuid, new_hotkey, (children, cool_down_block));
-                weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
-            }
 
-            // Also check for others with our hotkey as a child
-            for (hotkey, (children, cool_down_block)) in PendingChildKeys::<T>::iter_prefix(netuid)
+            if let Some(potential_idx) =
+                children.iter().position(|(_, child)| *child == *old_hotkey)
             {
-                weight.saturating_accrue(T::DbWeight::get().reads(1));
+                let mut new_children = children.clone();
+                let entry_to_remove = new_children.remove(potential_idx);
+                new_children.push((entry_to_remove.0, new_hotkey.clone())); // Keep the proportion.
 
-                if let Some(potential_idx) =
-                    children.iter().position(|(_, child)| *child == *old_hotkey)
-                {
-                    let mut new_children = children.clone();
-                    let entry_to_remove = new_children.remove(potential_idx);
-                    new_children.push((entry_to_remove.0, new_hotkey.clone())); // Keep the proportion.
-
-                    PendingChildKeys::<T>::remove(netuid, hotkey.clone());
-                    PendingChildKeys::<T>::insert(netuid, hotkey, (new_children, cool_down_block));
-                    weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
-                }
+                PendingChildKeys::<T>::remove(netuid, hotkey.clone());
+                PendingChildKeys::<T>::insert(netuid, hotkey, (new_children, cool_down_block));
+                weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
             }
         }
 
-        // 15. Swap SubnetOwnerHotkey
+        // 7. Swap SubnetOwnerHotkey
         // SubnetOwnerHotkey( netuid ) --> hotkey -- the hotkey that is the owner of the subnet.
-        for netuid in Self::get_all_subnet_netuids() {
-            if let Ok(old_subnet_owner_hotkey) = SubnetOwnerHotkey::<T>::try_get(netuid) {
-                weight.saturating_accrue(T::DbWeight::get().reads(1));
-                if old_subnet_owner_hotkey == *old_hotkey {
-                    SubnetOwnerHotkey::<T>::insert(netuid, new_hotkey);
-                    weight.saturating_accrue(T::DbWeight::get().writes(1));
-                }
+        if let Ok(old_subnet_owner_hotkey) = SubnetOwnerHotkey::<T>::try_get(netuid) {
+            weight.saturating_accrue(T::DbWeight::get().reads(1));
+            if old_subnet_owner_hotkey == *old_hotkey {
+                SubnetOwnerHotkey::<T>::insert(netuid, new_hotkey);
+                weight.saturating_accrue(T::DbWeight::get().writes(1));
             }
         }
 
-        // 16. Swap dividend records
-        TotalHotkeyAlphaLastEpoch::<T>::iter_prefix(old_hotkey)
-            .drain()
-            .for_each(|(netuid, old_alpha)| {
-                // 16.1 Swap TotalHotkeyAlphaLastEpoch
-                let new_total_hotkey_alpha =
-                    TotalHotkeyAlphaLastEpoch::<T>::get(new_hotkey, netuid);
-                TotalHotkeyAlphaLastEpoch::<T>::insert(
-                    new_hotkey,
-                    netuid,
-                    old_alpha.saturating_add(new_total_hotkey_alpha),
-                );
-                weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 2));
-
-                // 16.2 Swap AlphaDividendsPerSubnet
-                let old_hotkey_alpha_dividends =
-                    AlphaDividendsPerSubnet::<T>::get(netuid, old_hotkey);
-                let new_hotkey_alpha_dividends =
-                    AlphaDividendsPerSubnet::<T>::get(netuid, new_hotkey);
-                AlphaDividendsPerSubnet::<T>::remove(netuid, old_hotkey);
-                AlphaDividendsPerSubnet::<T>::insert(
-                    netuid,
-                    new_hotkey,
-                    old_hotkey_alpha_dividends.saturating_add(new_hotkey_alpha_dividends),
-                );
-                weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 2));
-
-                // 16.3 Swap TaoDividendsPerSubnet
-                let old_hotkey_tao_dividends = TaoDividendsPerSubnet::<T>::get(netuid, old_hotkey);
-                let new_hotkey_tao_dividends = TaoDividendsPerSubnet::<T>::get(netuid, new_hotkey);
-                TaoDividendsPerSubnet::<T>::remove(netuid, old_hotkey);
-                TaoDividendsPerSubnet::<T>::insert(
-                    netuid,
-                    new_hotkey,
-                    old_hotkey_tao_dividends.saturating_add(new_hotkey_tao_dividends),
-                );
-                weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 2));
-            });
+        // 8. Swap dividend records
+        // 8.1 Swap TotalHotkeyAlphaLastEpoch
+        let old_alpha = TotalHotkeyAlphaLastEpoch::<T>::take(old_hotkey, netuid);
+        let new_total_hotkey_alpha = TotalHotkeyAlphaLastEpoch::<T>::get(new_hotkey, netuid);
+        TotalHotkeyAlphaLastEpoch::<T>::insert(
+            new_hotkey,
+            netuid,
+            old_alpha.saturating_add(new_total_hotkey_alpha),
+        );
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 2));
+
+        // 8.2 Swap AlphaDividendsPerSubnet
+        let old_hotkey_alpha_dividends = AlphaDividendsPerSubnet::<T>::get(netuid, old_hotkey);
+        let new_hotkey_alpha_dividends = AlphaDividendsPerSubnet::<T>::get(netuid, new_hotkey);
+        AlphaDividendsPerSubnet::<T>::remove(netuid, old_hotkey);
+        AlphaDividendsPerSubnet::<T>::insert(
+            netuid,
+            new_hotkey,
+            old_hotkey_alpha_dividends.saturating_add(new_hotkey_alpha_dividends),
+        );
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 2));
+
+        // 8.3 Swap TaoDividendsPerSubnet
+        let old_hotkey_tao_dividends = TaoDividendsPerSubnet::<T>::get(netuid, old_hotkey);
+        let new_hotkey_tao_dividends = TaoDividendsPerSubnet::<T>::get(netuid, new_hotkey);
+        TaoDividendsPerSubnet::<T>::remove(netuid, old_hotkey);
+        TaoDividendsPerSubnet::<T>::insert(
+            netuid,
+            new_hotkey,
+            old_hotkey_tao_dividends.saturating_add(new_hotkey_tao_dividends),
+        );
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 2));
 
-        // Return successful after swapping all the relevant terms.
-        Ok(())
-    }
+        // 9. Swap Alpha
+        // Alpha( hotkey, coldkey, netuid ) -> alpha
+        let old_alpha_values: Vec<((T::AccountId, u16), U64F64)> =
+            Alpha::<T>::iter_prefix((old_hotkey,)).collect();
+        weight.saturating_accrue(T::DbWeight::get().reads(old_alpha_values.len() as u64));
+        weight.saturating_accrue(T::DbWeight::get().writes(old_alpha_values.len() as u64));
 
-    pub fn swap_senate_member(
-        old_hotkey: &T::AccountId,
-        new_hotkey: &T::AccountId,
-        weight: &mut Weight,
-    ) -> DispatchResult {
-        weight.saturating_accrue(T::DbWeight::get().reads(1));
-        if T::SenateMembers::is_member(old_hotkey) {
-            T::SenateMembers::swap_member(old_hotkey, new_hotkey).map_err(|e| e.error)?;
-            weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
+        // Insert the new alpha values.
+        for ((coldkey, netuid_alpha), alpha) in old_alpha_values {
+            if netuid == netuid_alpha {
+                let new_alpha = Alpha::<T>::take((new_hotkey, &coldkey, netuid));
+                Alpha::<T>::remove((old_hotkey, &coldkey, netuid));
+                Alpha::<T>::insert(
+                    (new_hotkey, &coldkey, netuid),
+                    alpha.saturating_add(new_alpha),
+                );
+                weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
+
+                // Swap StakingHotkeys.
+                // StakingHotkeys( coldkey ) --> Vec<hotkey> -- the hotkeys that the coldkey stakes.
+                let mut staking_hotkeys = StakingHotkeys::<T>::get(&coldkey);
+                weight.saturating_accrue(T::DbWeight::get().reads(1));
+                if staking_hotkeys.contains(old_hotkey) && !staking_hotkeys.contains(new_hotkey) {
+                    staking_hotkeys.push(new_hotkey.clone());
+                    StakingHotkeys::<T>::insert(&coldkey, staking_hotkeys);
+                    weight.saturating_accrue(T::DbWeight::get().writes(1));
+                }
+            }
         }
-        Ok(())
     }
 }
diff --git a/pallets/subtensor/src/tests/mock.rs b/pallets/subtensor/src/tests/mock.rs
index d5d302d5c1..dd2ad1d7c9 100644
--- a/pallets/subtensor/src/tests/mock.rs
+++ b/pallets/subtensor/src/tests/mock.rs
@@ -213,6 +213,9 @@ parameter_types! {
     pub const InitialTaoWeight: u64 = 0; // 100% global weight.
     pub const InitialEmaPriceHalvingPeriod: u64 = 201_600_u64; // 4 weeks
     pub const DurationOfStartCall: u64 =  7 * 24 * 60 * 60 / 12; // Default as 7 days
+    pub const InitialKeySwapOnSubnetCost: u64 = 10_000_000;
+    pub const HotkeySwapOnSubnetInterval: u64 = 15; // 15 block, should be bigger than subnet number, then trigger clean up for all subnets
+
 }
 
 // Configure collective pallet for council
@@ -441,6 +444,8 @@ impl crate::Config for Test {
     type InitialTaoWeight = InitialTaoWeight;
     type InitialEmaPriceHalvingPeriod = InitialEmaPriceHalvingPeriod;
     type DurationOfStartCall = DurationOfStartCall;
+    type KeySwapOnSubnetCost = InitialKeySwapOnSubnetCost;
+    type HotkeySwapOnSubnetInterval = HotkeySwapOnSubnetInterval;
 }
 
 pub struct OriginPrivilegeCmp;
diff --git a/pallets/subtensor/src/tests/mod.rs b/pallets/subtensor/src/tests/mod.rs
index 161749a923..60fafacc22 100644
--- a/pallets/subtensor/src/tests/mod.rs
+++ b/pallets/subtensor/src/tests/mod.rs
@@ -22,5 +22,6 @@ mod staking2;
 mod subnet;
 mod swap_coldkey;
 mod swap_hotkey;
+mod swap_hotkey_with_subnet;
 mod uids;
 mod weights;
diff --git a/pallets/subtensor/src/tests/swap_hotkey.rs b/pallets/subtensor/src/tests/swap_hotkey.rs
index a82972c2f7..0d6b24d7c0 100644
--- a/pallets/subtensor/src/tests/swap_hotkey.rs
+++ b/pallets/subtensor/src/tests/swap_hotkey.rs
@@ -22,7 +22,7 @@ fn test_swap_owner() {
         let mut weight = Weight::zero();
 
         Owner::<Test>::insert(old_hotkey, coldkey);
-        assert_ok!(SubtensorModule::perform_hotkey_swap(
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
             &old_hotkey,
             &new_hotkey,
             &coldkey,
@@ -44,7 +44,7 @@ fn test_swap_owned_hotkeys() {
         let mut weight = Weight::zero();
 
         OwnedHotkeys::<Test>::insert(coldkey, vec![old_hotkey]);
-        assert_ok!(SubtensorModule::perform_hotkey_swap(
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
             &old_hotkey,
             &new_hotkey,
             &coldkey,
@@ -95,7 +95,7 @@ fn test_swap_total_hotkey_stake() {
         );
 
         // Swap hotkey
-        assert_ok!(SubtensorModule::perform_hotkey_swap(
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
             &old_hotkey,
             &new_hotkey,
             &coldkey,
@@ -125,9 +125,12 @@ fn test_swap_senate_members() {
         let coldkey = U256::from(3);
         let mut weight = Weight::zero();
 
-        // Assuming there's a way to add a member to the senate
-        // SenateMembers::add_member(&old_hotkey);
-        assert_ok!(SubtensorModule::perform_hotkey_swap(
+        assert_ok!(SenateMembers::add_member(RuntimeOrigin::root(), old_hotkey));
+        let members = SenateMembers::members();
+        assert!(members.contains(&old_hotkey));
+        assert!(!members.contains(&new_hotkey));
+
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
             &old_hotkey,
             &new_hotkey,
             &coldkey,
@@ -135,8 +138,9 @@ fn test_swap_senate_members() {
         ));
 
         // Assert that the old_hotkey is no longer a member and new_hotkey is now a member
-        // assert!(!SenateMembers::is_member(&old_hotkey));
-        // assert!(SenateMembers::is_member(&new_hotkey));
+        let members = SenateMembers::members();
+        assert!(!members.contains(&old_hotkey));
+        assert!(members.contains(&new_hotkey));
     });
 }
 
@@ -150,7 +154,7 @@ fn test_swap_delegates() {
         let mut weight = Weight::zero();
 
         Delegates::<Test>::insert(old_hotkey, 100);
-        assert_ok!(SubtensorModule::perform_hotkey_swap(
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
             &old_hotkey,
             &new_hotkey,
             &coldkey,
@@ -174,7 +178,7 @@ fn test_swap_subnet_membership() {
 
         add_network(netuid, 1, 1);
         IsNetworkMember::<Test>::insert(old_hotkey, netuid, true);
-        assert_ok!(SubtensorModule::perform_hotkey_swap(
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
             &old_hotkey,
             &new_hotkey,
             &coldkey,
@@ -202,7 +206,7 @@ fn test_swap_uids_and_keys() {
         Uids::<Test>::insert(netuid, old_hotkey, uid);
         Keys::<Test>::insert(netuid, uid, old_hotkey);
 
-        assert_ok!(SubtensorModule::perform_hotkey_swap(
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
             &old_hotkey,
             &new_hotkey,
             &coldkey,
@@ -230,7 +234,7 @@ fn test_swap_prometheus() {
         IsNetworkMember::<Test>::insert(old_hotkey, netuid, true);
         Prometheus::<Test>::insert(netuid, old_hotkey, prometheus_info.clone());
 
-        assert_ok!(SubtensorModule::perform_hotkey_swap(
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
             &old_hotkey,
             &new_hotkey,
             &coldkey,
@@ -260,7 +264,7 @@ fn test_swap_axons() {
         IsNetworkMember::<Test>::insert(old_hotkey, netuid, true);
         Axons::<Test>::insert(netuid, old_hotkey, axon_info.clone());
 
-        assert_ok!(SubtensorModule::perform_hotkey_swap(
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
             &old_hotkey,
             &new_hotkey,
             &coldkey,
@@ -287,7 +291,7 @@ fn test_swap_certificates() {
         IsNetworkMember::<Test>::insert(old_hotkey, netuid, true);
         NeuronCertificates::<Test>::insert(netuid, old_hotkey, certificate.clone());
 
-        assert_ok!(SubtensorModule::perform_hotkey_swap(
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
             &old_hotkey,
             &new_hotkey,
             &coldkey,
@@ -320,7 +324,7 @@ fn test_swap_weight_commits() {
         IsNetworkMember::<Test>::insert(old_hotkey, netuid, true);
         WeightCommits::<Test>::insert(netuid, old_hotkey, weight_commits.clone());
 
-        assert_ok!(SubtensorModule::perform_hotkey_swap(
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
             &old_hotkey,
             &new_hotkey,
             &coldkey,
@@ -354,7 +358,7 @@ fn test_swap_loaded_emission() {
             vec![(old_hotkey, server_emission, validator_emission)],
         );
 
-        assert_ok!(SubtensorModule::perform_hotkey_swap(
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
             &old_hotkey,
             &new_hotkey,
             &coldkey,
@@ -376,13 +380,17 @@ fn test_swap_staking_hotkeys() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
+
+        let subnet_owner_coldkey = U256::from(1001);
+        let subnet_owner_hotkey = U256::from(1002);
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+
         let mut weight = Weight::zero();
-        let netuid = 1;
 
         StakingHotkeys::<Test>::insert(coldkey, vec![old_hotkey]);
         Alpha::<Test>::insert((old_hotkey, coldkey, netuid), U64F64::from_num(100));
 
-        assert_ok!(SubtensorModule::perform_hotkey_swap(
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
             &old_hotkey,
             &new_hotkey,
             &coldkey,
@@ -437,7 +445,7 @@ fn test_swap_hotkey_with_multiple_coldkeys() {
         let stake1_before = SubtensorModule::get_total_stake_for_coldkey(&coldkey1);
         let stake2_before = SubtensorModule::get_total_stake_for_coldkey(&coldkey2);
 
-        assert_ok!(SubtensorModule::perform_hotkey_swap(
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
             &old_hotkey,
             &new_hotkey,
             &coldkey1,
@@ -473,7 +481,7 @@ fn test_swap_hotkey_with_multiple_subnets() {
         IsNetworkMember::<Test>::insert(old_hotkey, netuid1, true);
         IsNetworkMember::<Test>::insert(old_hotkey, netuid2, true);
 
-        assert_ok!(SubtensorModule::perform_hotkey_swap(
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
             &old_hotkey,
             &new_hotkey,
             &coldkey,
@@ -506,6 +514,8 @@ fn test_swap_staking_hotkeys_multiple_coldkeys() {
         // Set up initial state
         StakingHotkeys::<Test>::insert(coldkey1, vec![old_hotkey]);
         StakingHotkeys::<Test>::insert(coldkey2, vec![old_hotkey, staker5]);
+        Alpha::<Test>::insert((old_hotkey, coldkey1, netuid), U64F64::from_num(100));
+        Alpha::<Test>::insert((old_hotkey, coldkey2, netuid), U64F64::from_num(100));
 
         SubtensorModule::create_account_if_non_existent(&coldkey1, &old_hotkey);
         SubtensorModule::add_balance_to_coldkey_account(
@@ -529,7 +539,7 @@ fn test_swap_staking_hotkeys_multiple_coldkeys() {
             stake
         ));
 
-        assert_ok!(SubtensorModule::perform_hotkey_swap(
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
             &old_hotkey,
             &new_hotkey,
             &coldkey1,
@@ -564,7 +574,7 @@ fn test_swap_hotkey_with_no_stake() {
         // Set up initial state with no stake
         Owner::<Test>::insert(old_hotkey, coldkey);
 
-        assert_ok!(SubtensorModule::perform_hotkey_swap(
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
             &old_hotkey,
             &new_hotkey,
             &coldkey,
@@ -635,7 +645,7 @@ fn test_swap_hotkey_with_multiple_coldkeys_and_subnets() {
         let total_hk_stake = SubtensorModule::get_total_stake_for_hotkey(&old_hotkey);
         assert!(total_hk_stake > 0);
 
-        assert_ok!(SubtensorModule::perform_hotkey_swap(
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
             &old_hotkey,
             &new_hotkey,
             &coldkey1,
@@ -742,7 +752,8 @@ fn test_swap_hotkey_tx_rate_limit_exceeded() {
         assert_ok!(SubtensorModule::do_swap_hotkey(
             <<Test as Config>::RuntimeOrigin>::signed(coldkey),
             &old_hotkey,
-            &new_hotkey_1
+            &new_hotkey_1,
+            None
         ));
 
         // Attempt to perform another swap immediately, which should fail due to rate limit
@@ -750,7 +761,8 @@ fn test_swap_hotkey_tx_rate_limit_exceeded() {
             SubtensorModule::do_swap_hotkey(
                 <<Test as Config>::RuntimeOrigin>::signed(coldkey),
                 &new_hotkey_1,
-                &new_hotkey_2
+                &new_hotkey_2,
+                None
             ),
             Error::<Test>::HotKeySetTxRateLimitExceeded
         );
@@ -760,7 +772,8 @@ fn test_swap_hotkey_tx_rate_limit_exceeded() {
         assert_ok!(SubtensorModule::do_swap_hotkey(
             <<Test as Config>::RuntimeOrigin>::signed(coldkey),
             &new_hotkey_1,
-            &new_hotkey_2
+            &new_hotkey_2,
+            None
         ));
     });
 }
@@ -787,34 +800,14 @@ fn test_do_swap_hotkey_err_not_owner() {
             SubtensorModule::do_swap_hotkey(
                 <<Test as Config>::RuntimeOrigin>::signed(not_owner_coldkey),
                 &old_hotkey,
-                &new_hotkey
+                &new_hotkey,
+                None
             ),
             Error::<Test>::NonAssociatedColdKey
         );
     });
 }
 
-// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey -- test_swap_owner_success --exact --nocapture
-#[test]
-fn test_swap_owner_success() {
-    new_test_ext(1).execute_with(|| {
-        let old_hotkey = U256::from(1);
-        let new_hotkey = U256::from(2);
-        let coldkey = U256::from(3);
-        let mut weight = Weight::zero();
-
-        // Initialize Owner for old_hotkey
-        Owner::<Test>::insert(old_hotkey, coldkey);
-
-        // Perform the swap
-        SubtensorModule::perform_hotkey_swap(&old_hotkey, &new_hotkey, &coldkey, &mut weight);
-
-        // Verify the swap
-        assert_eq!(Owner::<Test>::get(new_hotkey), coldkey);
-        assert!(!Owner::<Test>::contains_key(old_hotkey));
-    });
-}
-
 // SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey -- test_swap_owner_old_hotkey_not_exist --exact --nocapture
 #[test]
 fn test_swap_owner_old_hotkey_not_exist() {
@@ -828,7 +821,12 @@ fn test_swap_owner_old_hotkey_not_exist() {
         assert!(!Owner::<Test>::contains_key(old_hotkey));
 
         // Perform the swap
-        SubtensorModule::perform_hotkey_swap(&old_hotkey, &new_hotkey, &coldkey, &mut weight);
+        SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight,
+        );
 
         // Verify the swap
         assert_eq!(Owner::<Test>::get(new_hotkey), coldkey);
@@ -851,7 +849,12 @@ fn test_swap_owner_new_hotkey_already_exists() {
         Owner::<Test>::insert(new_hotkey, another_coldkey);
 
         // Perform the swap
-        SubtensorModule::perform_hotkey_swap(&old_hotkey, &new_hotkey, &coldkey, &mut weight);
+        SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight,
+        );
 
         // Verify the swap
         assert_eq!(Owner::<Test>::get(new_hotkey), coldkey);
@@ -859,28 +862,6 @@ fn test_swap_owner_new_hotkey_already_exists() {
     });
 }
 
-// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor --lib -- tests::swap_hotkey::test_swap_delegates_success --exact --show-output
-#[test]
-fn test_swap_delegates_success() {
-    new_test_ext(1).execute_with(|| {
-        let old_hotkey = U256::from(1);
-        let new_hotkey = U256::from(2);
-        let coldkey = U256::from(3);
-        let delegate_take = 10u16;
-        let mut weight = Weight::zero();
-
-        // Initialize Delegates for old_hotkey
-        Delegates::<Test>::insert(old_hotkey, delegate_take);
-
-        // Perform the swap
-        SubtensorModule::perform_hotkey_swap(&old_hotkey, &new_hotkey, &coldkey, &mut weight);
-
-        // Verify the swap
-        assert_eq!(Delegates::<Test>::get(new_hotkey), delegate_take);
-        assert!(!Delegates::<Test>::contains_key(old_hotkey));
-    });
-}
-
 // SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey -- test_swap_stake_success --exact --nocapture
 #[test]
 fn test_swap_stake_success() {
@@ -904,7 +885,12 @@ fn test_swap_stake_success() {
         TaoDividendsPerSubnet::<Test>::insert(netuid, old_hotkey, amount);
 
         // Perform the swap
-        SubtensorModule::perform_hotkey_swap(&old_hotkey, &new_hotkey, &coldkey, &mut weight);
+        SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight,
+        );
 
         // Verify the swap
         assert_eq!(TotalHotkeyAlpha::<Test>::get(old_hotkey, netuid), 0);
@@ -953,9 +939,12 @@ fn test_swap_stake_old_hotkey_not_exist() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
+        let subnet_owner_coldkey = U256::from(1001);
+        let subnet_owner_hotkey = U256::from(1002);
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+
         let alpha_share = U64F64::from_num(1234);
         let mut weight = Weight::zero();
-        let netuid = 1;
 
         // Initialize Stake for old_hotkey
         Alpha::<Test>::insert((old_hotkey, coldkey, netuid), alpha_share);
@@ -964,7 +953,12 @@ fn test_swap_stake_old_hotkey_not_exist() {
         assert!(Alpha::<Test>::contains_key((old_hotkey, coldkey, netuid)));
 
         // Perform the swap
-        SubtensorModule::perform_hotkey_swap(&old_hotkey, &new_hotkey, &coldkey, &mut weight);
+        SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight,
+        );
 
         // Verify that new_hotkey has the stake and old_hotkey does not
         assert!(Alpha::<Test>::contains_key((new_hotkey, coldkey, netuid)));
@@ -986,7 +980,7 @@ fn test_swap_stake_old_hotkey_not_exist() {
 //         TotalHotkeyColdkeyStakesThisInterval::<Test>::insert(old_hotkey, coldkey, stake);
 
 //         // Perform the swap
-//         SubtensorModule::perform_hotkey_swap(&old_hotkey, &new_hotkey, &coldkey, &mut weight);
+//         SubtensorModule::perform_hotkey_swap_on_all_subnets(&old_hotkey, &new_hotkey, &coldkey, &mut weight);
 
 //         // Verify the swap
 //         assert_eq!(
@@ -1015,11 +1009,12 @@ fn test_swap_hotkey_error_cases() {
 
         // Test not enough balance
         let swap_cost = SubtensorModule::get_key_swap_cost();
-        assert_noop!(
+        assert_err!(
             SubtensorModule::do_swap_hotkey(
                 RuntimeOrigin::signed(coldkey),
                 &old_hotkey,
-                &new_hotkey
+                &new_hotkey,
+                None
             ),
             Error::<Test>::NotEnoughBalanceToPaySwapHotKey
         );
@@ -1032,7 +1027,8 @@ fn test_swap_hotkey_error_cases() {
             SubtensorModule::do_swap_hotkey(
                 RuntimeOrigin::signed(coldkey),
                 &old_hotkey,
-                &old_hotkey
+                &old_hotkey,
+                None
             ),
             Error::<Test>::NewHotKeyIsSameWithOld
         );
@@ -1043,7 +1039,8 @@ fn test_swap_hotkey_error_cases() {
             SubtensorModule::do_swap_hotkey(
                 RuntimeOrigin::signed(coldkey),
                 &old_hotkey,
-                &new_hotkey
+                &new_hotkey,
+                None
             ),
             Error::<Test>::HotKeyAlreadyRegisteredInSubNet
         );
@@ -1054,7 +1051,8 @@ fn test_swap_hotkey_error_cases() {
             SubtensorModule::do_swap_hotkey(
                 RuntimeOrigin::signed(wrong_coldkey),
                 &old_hotkey,
-                &new_hotkey
+                &new_hotkey,
+                None
             ),
             Error::<Test>::NonAssociatedColdKey
         );
@@ -1063,7 +1061,8 @@ fn test_swap_hotkey_error_cases() {
         assert_ok!(SubtensorModule::do_swap_hotkey(
             RuntimeOrigin::signed(coldkey),
             &old_hotkey,
-            &new_hotkey
+            &new_hotkey,
+            None
         ));
 
         // Check balance after swap
@@ -1087,7 +1086,12 @@ fn test_swap_child_keys() {
         ChildKeys::<Test>::insert(old_hotkey, netuid, children.clone());
 
         // Perform the swap
-        SubtensorModule::perform_hotkey_swap(&old_hotkey, &new_hotkey, &coldkey, &mut weight);
+        SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight,
+        );
 
         // Verify the swap
         assert_eq!(ChildKeys::<Test>::get(new_hotkey, netuid), children);
@@ -1115,7 +1119,12 @@ fn test_swap_parent_keys() {
         ChildKeys::<Test>::insert(U256::from(5), netuid, vec![(200u64, old_hotkey)]);
 
         // Perform the swap
-        SubtensorModule::perform_hotkey_swap(&old_hotkey, &new_hotkey, &coldkey, &mut weight);
+        SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight,
+        );
 
         // Verify ParentKeys swap
         assert_eq!(ParentKeys::<Test>::get(new_hotkey, netuid), parents);
@@ -1154,7 +1163,12 @@ fn test_swap_multiple_subnets() {
         ChildKeys::<Test>::insert(old_hotkey, netuid2, children2.clone());
 
         // Perform the swap
-        SubtensorModule::perform_hotkey_swap(&old_hotkey, &new_hotkey, &coldkey, &mut weight);
+        SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight,
+        );
 
         // Verify the swap for both subnets
         assert_eq!(ChildKeys::<Test>::get(new_hotkey, netuid1), children1);
@@ -1199,7 +1213,12 @@ fn test_swap_complex_parent_child_structure() {
         );
 
         // Perform the swap
-        SubtensorModule::perform_hotkey_swap(&old_hotkey, &new_hotkey, &coldkey, &mut weight);
+        SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight,
+        );
 
         // Verify ParentKeys swap
         assert_eq!(
@@ -1259,7 +1278,7 @@ fn test_swap_parent_hotkey_childkey_maps() {
 
         // Swap
         let mut weight = Weight::zero();
-        assert_ok!(SubtensorModule::perform_hotkey_swap(
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
             &parent_old,
             &parent_new,
             &coldkey,
@@ -1314,7 +1333,7 @@ fn test_swap_child_hotkey_childkey_maps() {
 
         // Swap
         let mut weight = Weight::zero();
-        assert_ok!(SubtensorModule::perform_hotkey_swap(
+        assert_ok!(SubtensorModule::perform_hotkey_swap_on_all_subnets(
             &child_old,
             &child_new,
             &coldkey,
@@ -1352,7 +1371,12 @@ fn test_swap_hotkey_is_sn_owner_hotkey() {
         assert_eq!(SubnetOwnerHotkey::<Test>::get(netuid), old_hotkey);
 
         // Perform the swap
-        SubtensorModule::perform_hotkey_swap(&old_hotkey, &new_hotkey, &coldkey, &mut weight);
+        SubtensorModule::perform_hotkey_swap_on_all_subnets(
+            &old_hotkey,
+            &new_hotkey,
+            &coldkey,
+            &mut weight,
+        );
 
         // Check for SubnetOwnerHotkey
         assert_eq!(SubnetOwnerHotkey::<Test>::get(netuid), new_hotkey);
@@ -1366,7 +1390,8 @@ fn test_swap_hotkey_swap_rate_limits() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let mut weight = Weight::zero();
+        let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
 
         let last_tx_block = 123;
         let delegate_take_block = 4567;
@@ -1380,7 +1405,12 @@ fn test_swap_hotkey_swap_rate_limits() {
         LastTxBlockChildKeyTake::<Test>::insert(old_hotkey, child_key_take_block);
 
         // Perform the swap
-        SubtensorModule::perform_hotkey_swap(&old_hotkey, &new_hotkey, &coldkey, &mut weight);
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
+            &old_hotkey,
+            &new_hotkey,
+            None
+        ));
 
         // Check for new hotkey
         assert_eq!(LastTxBlock::<Test>::get(new_hotkey), last_tx_block);
diff --git a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
new file mode 100644
index 0000000000..583a8cf448
--- /dev/null
+++ b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
@@ -0,0 +1,1516 @@
+#![allow(unused, clippy::indexing_slicing, clippy::panic, clippy::unwrap_used)]
+
+use approx::assert_abs_diff_eq;
+use codec::Encode;
+use frame_support::weights::Weight;
+use frame_support::{assert_err, assert_noop, assert_ok};
+use frame_system::{Config, RawOrigin};
+
+use super::mock::*;
+use crate::*;
+use sp_core::{Get, H256, U256};
+use sp_runtime::SaturatedConversion;
+use substrate_fixed::types::U64F64;
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_owner --exact --nocapture
+#[test]
+fn test_swap_owner() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+
+        let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+        Owner::<Test>::insert(old_hotkey, coldkey);
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
+            &old_hotkey,
+            &new_hotkey,
+            Some(netuid)
+        ));
+
+        assert_eq!(Owner::<Test>::get(old_hotkey), coldkey);
+        assert_eq!(Owner::<Test>::get(new_hotkey), coldkey);
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_owned_hotkeys --exact --nocapture
+#[test]
+fn test_swap_owned_hotkeys() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+
+        let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+
+        OwnedHotkeys::<Test>::insert(coldkey, vec![old_hotkey]);
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
+            &old_hotkey,
+            &new_hotkey,
+            Some(netuid)
+        ));
+
+        let hotkeys = OwnedHotkeys::<Test>::get(coldkey);
+        assert!(hotkeys.contains(&old_hotkey));
+        assert!(hotkeys.contains(&new_hotkey));
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_total_hotkey_stake --exact --nocapture
+#[test]
+fn test_swap_total_hotkey_stake() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let amount = DefaultMinStake::<Test>::get() * 10;
+
+        let fee = DefaultStakingFee::<Test>::get();
+
+        //add network
+        let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
+
+        // Give it some $$$ in his coldkey balance
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+
+        // Add stake
+        assert_ok!(SubtensorModule::add_stake(
+            RuntimeOrigin::signed(coldkey),
+            old_hotkey,
+            netuid,
+            amount
+        ));
+
+        // Check if stake has increased
+        assert_abs_diff_eq!(
+            SubtensorModule::get_total_stake_for_hotkey(&old_hotkey),
+            amount - fee,
+            epsilon = amount / 1000,
+        );
+        assert_abs_diff_eq!(
+            SubtensorModule::get_total_stake_for_hotkey(&new_hotkey),
+            0,
+            epsilon = 1,
+        );
+
+        // Swap hotkey
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
+            &old_hotkey,
+            &new_hotkey,
+            Some(netuid)
+        ));
+
+        // Verify that total hotkey stake swapped
+        assert_abs_diff_eq!(
+            SubtensorModule::get_total_stake_for_hotkey(&old_hotkey),
+            0,
+            epsilon = 1,
+        );
+        assert_abs_diff_eq!(
+            SubtensorModule::get_total_stake_for_hotkey(&new_hotkey),
+            amount - fee,
+            epsilon = amount / 1000,
+        );
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_senate_members --exact --nocapture
+#[test]
+fn test_swap_senate_members() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+
+        let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+
+        assert_ok!(SenateMembers::add_member(RuntimeOrigin::root(), old_hotkey));
+
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
+            &old_hotkey,
+            &new_hotkey,
+            Some(netuid)
+        ));
+
+        let members = SenateMembers::members();
+        assert!(members.contains(&old_hotkey));
+        assert!(!members.contains(&new_hotkey));
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_delegates --exact --nocapture
+#[test]
+fn test_swap_delegates() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+
+        let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+
+        Delegates::<Test>::insert(old_hotkey, 100);
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
+            &old_hotkey,
+            &new_hotkey,
+            Some(netuid)
+        ));
+
+        assert!(Delegates::<Test>::contains_key(old_hotkey));
+        assert!(!Delegates::<Test>::contains_key(new_hotkey));
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_subnet_membership --exact --nocapture
+#[test]
+fn test_swap_subnet_membership() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+
+        let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+
+        IsNetworkMember::<Test>::insert(old_hotkey, netuid, true);
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
+            &old_hotkey,
+            &new_hotkey,
+            Some(netuid)
+        ));
+
+        assert!(!IsNetworkMember::<Test>::contains_key(old_hotkey, netuid));
+        assert!(IsNetworkMember::<Test>::get(new_hotkey, netuid));
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_uids_and_keys --exact --nocapture
+#[test]
+fn test_swap_uids_and_keys() {
+    new_test_ext(1).execute_with(|| {
+        let uid = 5u16;
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+
+        let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+
+        IsNetworkMember::<Test>::insert(old_hotkey, netuid, true);
+        Uids::<Test>::insert(netuid, old_hotkey, uid);
+        Keys::<Test>::insert(netuid, uid, old_hotkey);
+
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
+            &old_hotkey,
+            &new_hotkey,
+            Some(netuid)
+        ));
+
+        assert_eq!(Uids::<Test>::get(netuid, old_hotkey), None);
+        assert_eq!(Uids::<Test>::get(netuid, new_hotkey), Some(uid));
+        assert_eq!(Keys::<Test>::get(netuid, uid), new_hotkey);
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_prometheus --exact --nocapture
+#[test]
+fn test_swap_prometheus() {
+    new_test_ext(1).execute_with(|| {
+        let uid = 5u16;
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+
+        let prometheus_info = PrometheusInfo::default();
+
+        let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+
+        IsNetworkMember::<Test>::insert(old_hotkey, netuid, true);
+        Prometheus::<Test>::insert(netuid, old_hotkey, prometheus_info.clone());
+
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
+            &old_hotkey,
+            &new_hotkey,
+            Some(netuid)
+        ));
+
+        assert!(!Prometheus::<Test>::contains_key(netuid, old_hotkey));
+        assert_eq!(
+            Prometheus::<Test>::get(netuid, new_hotkey),
+            Some(prometheus_info)
+        );
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_axons --exact --nocapture
+#[test]
+fn test_swap_axons() {
+    new_test_ext(1).execute_with(|| {
+        let uid = 5u16;
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+
+        let axon_info = AxonInfo::default();
+
+        let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+
+        IsNetworkMember::<Test>::insert(old_hotkey, netuid, true);
+        Axons::<Test>::insert(netuid, old_hotkey, axon_info.clone());
+
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
+            &old_hotkey,
+            &new_hotkey,
+            Some(netuid)
+        ));
+
+        assert!(!Axons::<Test>::contains_key(netuid, old_hotkey));
+        assert_eq!(Axons::<Test>::get(netuid, new_hotkey), Some(axon_info));
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_certificates --exact --nocapture
+#[test]
+fn test_swap_certificates() {
+    new_test_ext(1).execute_with(|| {
+        let uid = 5u16;
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+
+        let certificate = NeuronCertificate::try_from(vec![1, 2, 3]).unwrap();
+
+        let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+
+        IsNetworkMember::<Test>::insert(old_hotkey, netuid, true);
+        NeuronCertificates::<Test>::insert(netuid, old_hotkey, certificate.clone());
+
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
+            &old_hotkey,
+            &new_hotkey,
+            Some(netuid)
+        ));
+
+        assert!(!NeuronCertificates::<Test>::contains_key(
+            netuid, old_hotkey
+        ));
+        assert_eq!(
+            NeuronCertificates::<Test>::get(netuid, new_hotkey),
+            Some(certificate)
+        );
+    });
+}
+use sp_std::collections::vec_deque::VecDeque;
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_weight_commits --exact --nocapture
+#[test]
+fn test_swap_weight_commits() {
+    new_test_ext(1).execute_with(|| {
+        let uid = 5u16;
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+
+        let mut weight_commits: VecDeque<(H256, u64, u64, u64)> = VecDeque::new();
+        weight_commits.push_back((H256::from_low_u64_be(100), 200, 1, 1));
+
+        let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+
+        IsNetworkMember::<Test>::insert(old_hotkey, netuid, true);
+        WeightCommits::<Test>::insert(netuid, old_hotkey, weight_commits.clone());
+
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
+            &old_hotkey,
+            &new_hotkey,
+            Some(netuid)
+        ));
+
+        assert!(!WeightCommits::<Test>::contains_key(netuid, old_hotkey));
+        assert_eq!(
+            WeightCommits::<Test>::get(netuid, new_hotkey),
+            Some(weight_commits)
+        );
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_loaded_emission --exact --nocapture
+#[test]
+fn test_swap_loaded_emission() {
+    new_test_ext(1).execute_with(|| {
+        let uid = 5u16;
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+
+        let server_emission = 1000u64;
+        let validator_emission = 1000u64;
+
+        let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+
+        IsNetworkMember::<Test>::insert(old_hotkey, netuid, true);
+        LoadedEmission::<Test>::insert(
+            netuid,
+            vec![(old_hotkey, server_emission, validator_emission)],
+        );
+
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
+            &old_hotkey,
+            &new_hotkey,
+            Some(netuid)
+        ));
+
+        let new_loaded_emission = LoadedEmission::<Test>::get(netuid);
+        assert_eq!(
+            new_loaded_emission,
+            Some(vec![(new_hotkey, server_emission, validator_emission)])
+        );
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_staking_hotkeys --exact --nocapture
+#[test]
+fn test_swap_staking_hotkeys() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let netuid = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+
+        StakingHotkeys::<Test>::insert(coldkey, vec![old_hotkey]);
+        Alpha::<Test>::insert((old_hotkey, coldkey, netuid), U64F64::from_num(100));
+
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
+            &old_hotkey,
+            &new_hotkey,
+            Some(netuid)
+        ));
+
+        let staking_hotkeys = StakingHotkeys::<Test>::get(coldkey);
+        assert!(staking_hotkeys.contains(&old_hotkey));
+        assert!(staking_hotkeys.contains(&new_hotkey));
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor --lib -- tests::swap_hotkey::test_swap_hotkey_with_multiple_coldkeys --exact --show-output --nocapture
+#[test]
+fn test_swap_hotkey_with_multiple_coldkeys() {
+    new_test_ext(1).execute_with(|| {
+        let subnet_owner_coldkey = U256::from(1001);
+        let subnet_owner_hotkey = U256::from(1002);
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey1 = U256::from(3);
+        let coldkey2 = U256::from(4);
+
+        let stake = 1_000_000_000;
+
+        StakingHotkeys::<Test>::insert(coldkey1, vec![old_hotkey]);
+        StakingHotkeys::<Test>::insert(coldkey2, vec![old_hotkey]);
+        SubtensorModule::create_account_if_non_existent(&coldkey1, &old_hotkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey1, u64::MAX);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey2, u64::MAX);
+
+        assert_ok!(SubtensorModule::add_stake(
+            RuntimeOrigin::signed(coldkey1),
+            old_hotkey,
+            netuid,
+            stake
+        ));
+        assert_ok!(SubtensorModule::add_stake(
+            RuntimeOrigin::signed(coldkey2),
+            old_hotkey,
+            netuid,
+            stake / 2
+        ));
+        let stake1_before = SubtensorModule::get_total_stake_for_coldkey(&coldkey1);
+        let stake2_before = SubtensorModule::get_total_stake_for_coldkey(&coldkey2);
+
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey1),
+            &old_hotkey,
+            &new_hotkey,
+            Some(netuid)
+        ));
+
+        assert_eq!(
+            SubtensorModule::get_total_stake_for_coldkey(&coldkey1),
+            SubtensorModule::get_total_stake_for_coldkey(&coldkey1),
+        );
+        assert_eq!(
+            SubtensorModule::get_total_stake_for_coldkey(&coldkey2),
+            SubtensorModule::get_total_stake_for_coldkey(&coldkey2),
+        );
+
+        assert_eq!(
+            SubtensorModule::get_total_stake_for_coldkey(&coldkey1),
+            stake1_before
+        );
+        assert_eq!(
+            SubtensorModule::get_total_stake_for_coldkey(&coldkey2),
+            stake2_before
+        );
+
+        assert!(StakingHotkeys::<Test>::get(coldkey1).contains(&new_hotkey));
+        assert!(StakingHotkeys::<Test>::get(coldkey2).contains(&new_hotkey));
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_hotkey_with_multiple_subnets --exact --nocapture
+#[test]
+fn test_swap_hotkey_with_multiple_subnets() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+
+        let netuid1 = add_dynamic_network(&old_hotkey, &coldkey);
+        let netuid2 = add_dynamic_network(&old_hotkey, &coldkey);
+
+        IsNetworkMember::<Test>::insert(old_hotkey, netuid1, true);
+        IsNetworkMember::<Test>::insert(old_hotkey, netuid2, true);
+
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
+            &old_hotkey,
+            &new_hotkey,
+            Some(netuid1)
+        ));
+
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
+            &old_hotkey,
+            &new_hotkey,
+            Some(netuid2)
+        ));
+
+        assert!(IsNetworkMember::<Test>::get(new_hotkey, netuid1));
+        assert!(IsNetworkMember::<Test>::get(new_hotkey, netuid2));
+        assert!(!IsNetworkMember::<Test>::get(old_hotkey, netuid1));
+        assert!(!IsNetworkMember::<Test>::get(old_hotkey, netuid2));
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_staking_hotkeys_multiple_coldkeys --exact --nocapture
+#[test]
+fn test_swap_staking_hotkeys_multiple_coldkeys() {
+    new_test_ext(1).execute_with(|| {
+        let subnet_owner_coldkey = U256::from(1001);
+        let subnet_owner_hotkey = U256::from(1002);
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey1 = U256::from(3);
+        let coldkey2 = U256::from(4);
+        let staker5 = U256::from(5);
+
+        let stake = 1_000_000_000;
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey1, u64::MAX);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey2, u64::MAX);
+
+        // Set up initial state
+        StakingHotkeys::<Test>::insert(coldkey1, vec![old_hotkey]);
+        StakingHotkeys::<Test>::insert(coldkey2, vec![old_hotkey, staker5]);
+
+        SubtensorModule::create_account_if_non_existent(&coldkey1, &old_hotkey);
+
+        assert_ok!(SubtensorModule::add_stake(
+            RuntimeOrigin::signed(coldkey1),
+            old_hotkey,
+            netuid,
+            stake
+        ));
+        assert_ok!(SubtensorModule::add_stake(
+            RuntimeOrigin::signed(coldkey2),
+            old_hotkey,
+            netuid,
+            stake
+        ));
+
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey1),
+            &old_hotkey,
+            &new_hotkey,
+            Some(netuid)
+        ));
+
+        // Check if new_hotkey replaced old_hotkey in StakingHotkeys
+        assert!(StakingHotkeys::<Test>::get(coldkey1).contains(&new_hotkey));
+        assert!(StakingHotkeys::<Test>::get(coldkey1).contains(&old_hotkey));
+
+        // Check if new_hotkey replaced old_hotkey for coldkey2 as well
+        assert!(StakingHotkeys::<Test>::get(coldkey2).contains(&new_hotkey));
+        assert!(StakingHotkeys::<Test>::get(coldkey2).contains(&old_hotkey));
+        assert!(StakingHotkeys::<Test>::get(coldkey2).contains(&staker5));
+        // Other hotkeys should remain
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_hotkey_with_no_stake --exact --nocapture
+#[test]
+fn test_swap_hotkey_with_no_stake() {
+    new_test_ext(1).execute_with(|| {
+        let subnet_owner_coldkey = U256::from(1001);
+        let subnet_owner_hotkey = U256::from(1002);
+        let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
+
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+
+        // Set up initial state with no stake
+        Owner::<Test>::insert(old_hotkey, coldkey);
+
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
+            &old_hotkey,
+            &new_hotkey,
+            Some(netuid)
+        ));
+
+        // Check if ownership transferred
+        assert!(Owner::<Test>::contains_key(old_hotkey));
+        assert_eq!(Owner::<Test>::get(new_hotkey), coldkey);
+
+        // Ensure no unexpected changes in Stake
+        assert!(!Alpha::<Test>::contains_key((old_hotkey, coldkey, netuid)));
+        assert!(!Alpha::<Test>::contains_key((new_hotkey, coldkey, netuid)));
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor --lib -- tests::swap_hotkey::test_swap_hotkey_with_multiple_coldkeys_and_subnets --exact --show-output
+#[test]
+fn test_swap_hotkey_with_multiple_coldkeys_and_subnets() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey1 = U256::from(3);
+        let coldkey2 = U256::from(4);
+        let netuid1 = 1;
+        let netuid2 = 2;
+        let stake = DefaultMinStake::<Test>::get() * 10;
+
+        // Set up initial state
+        add_network(netuid1, 1, 1);
+        add_network(netuid2, 1, 1);
+        register_ok_neuron(netuid1, old_hotkey, coldkey1, 1234);
+        register_ok_neuron(netuid2, old_hotkey, coldkey1, 1234);
+
+        // Add balance to both coldkeys
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey1, u64::MAX);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey2, u64::MAX);
+
+        // Stake with coldkey1
+        assert_ok!(SubtensorModule::add_stake(
+            <<Test as Config>::RuntimeOrigin>::signed(coldkey1),
+            old_hotkey,
+            netuid1,
+            stake
+        ));
+
+        // Stake with coldkey2 also
+        assert_ok!(SubtensorModule::add_stake(
+            <<Test as Config>::RuntimeOrigin>::signed(coldkey2),
+            old_hotkey,
+            netuid2,
+            stake
+        ));
+
+        let ck1_stake = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+            &old_hotkey,
+            &coldkey1,
+            netuid1,
+        );
+        let ck2_stake = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+            &old_hotkey,
+            &coldkey2,
+            netuid2,
+        );
+        assert!(ck1_stake > 0);
+        assert!(ck2_stake > 0);
+        let total_hk_stake = SubtensorModule::get_total_stake_for_hotkey(&old_hotkey);
+        assert!(total_hk_stake > 0);
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
+
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey1),
+            &old_hotkey,
+            &new_hotkey,
+            Some(netuid1)
+        ));
+
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey1),
+            &old_hotkey,
+            &new_hotkey,
+            Some(netuid2)
+        ));
+
+        // Check ownership transfer
+        assert_eq!(
+            SubtensorModule::get_owning_coldkey_for_hotkey(&new_hotkey),
+            coldkey1
+        );
+        assert!(!SubtensorModule::get_owned_hotkeys(&coldkey2).contains(&new_hotkey));
+
+        // Check stake transfer
+        assert_eq!(
+            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+                &new_hotkey,
+                &coldkey1,
+                netuid1
+            ),
+            ck1_stake
+        );
+        assert_eq!(
+            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+                &new_hotkey,
+                &coldkey2,
+                netuid2
+            ),
+            ck2_stake
+        );
+        assert_eq!(
+            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+                &old_hotkey,
+                &coldkey1,
+                netuid1
+            ),
+            0
+        );
+        assert_eq!(
+            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+                &old_hotkey,
+                &coldkey2,
+                netuid2
+            ),
+            0
+        );
+
+        // Check subnet membership transfer
+        assert!(SubtensorModule::is_hotkey_registered_on_network(
+            netuid1,
+            &new_hotkey
+        ));
+        assert!(SubtensorModule::is_hotkey_registered_on_network(
+            netuid2,
+            &new_hotkey
+        ));
+        assert!(!SubtensorModule::is_hotkey_registered_on_network(
+            netuid1,
+            &old_hotkey
+        ));
+        assert!(!SubtensorModule::is_hotkey_registered_on_network(
+            netuid2,
+            &old_hotkey
+        ));
+
+        // Check total stake transfer
+        assert_eq!(
+            SubtensorModule::get_total_stake_for_hotkey(&new_hotkey),
+            total_hk_stake
+        );
+        assert_eq!(SubtensorModule::get_total_stake_for_hotkey(&old_hotkey), 0);
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_hotkey_tx_rate_limit_exceeded --exact --nocapture
+#[test]
+fn test_swap_hotkey_tx_rate_limit_exceeded() {
+    new_test_ext(1).execute_with(|| {
+        let netuid: u16 = 1;
+        let tempo: u16 = 13;
+        let old_hotkey = U256::from(1);
+        let new_hotkey_1 = U256::from(2);
+        let new_hotkey_2 = U256::from(4);
+        let coldkey = U256::from(3);
+        let swap_cost = 1_000_000_000u64 * 2;
+
+        let tx_rate_limit = 1;
+
+        // Get the current transaction rate limit
+        let current_tx_rate_limit = SubtensorModule::get_tx_rate_limit();
+        log::info!("current_tx_rate_limit: {:?}", current_tx_rate_limit);
+
+        // Set the transaction rate limit
+        SubtensorModule::set_tx_rate_limit(tx_rate_limit);
+        // assert the rate limit is set to 1000 blocks
+        assert_eq!(SubtensorModule::get_tx_rate_limit(), tx_rate_limit);
+
+        // Setup initial state
+        add_network(netuid, tempo, 0);
+        register_ok_neuron(netuid, old_hotkey, coldkey, 0);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, swap_cost);
+
+        // Perform the first swap
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
+            &old_hotkey,
+            &new_hotkey_1,
+            Some(netuid)
+        ),);
+
+        // Attempt to perform another swap immediately, which should fail due to rate limit
+        assert_err!(
+            SubtensorModule::do_swap_hotkey(
+                RuntimeOrigin::signed(coldkey),
+                &old_hotkey,
+                &new_hotkey_1,
+                Some(netuid)
+            ),
+            Error::<Test>::HotKeySetTxRateLimitExceeded
+        );
+
+        // move in time past the rate limit
+        step_block(1001);
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            <<Test as Config>::RuntimeOrigin>::signed(coldkey),
+            &new_hotkey_1,
+            &new_hotkey_2,
+            None
+        ));
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_do_swap_hotkey_err_not_owner --exact --nocapture
+#[test]
+fn test_do_swap_hotkey_err_not_owner() {
+    new_test_ext(1).execute_with(|| {
+        let netuid: u16 = 1;
+        let tempo: u16 = 13;
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let not_owner_coldkey = U256::from(4);
+        let swap_cost = 1_000_000_000u64;
+
+        // Setup initial state
+        add_network(netuid, tempo, 0);
+        register_ok_neuron(netuid, old_hotkey, coldkey, 0);
+        SubtensorModule::add_balance_to_coldkey_account(&not_owner_coldkey, swap_cost);
+
+        // Attempt the swap with a non-owner coldkey
+        assert_err!(
+            SubtensorModule::do_swap_hotkey(
+                RuntimeOrigin::signed(not_owner_coldkey),
+                &old_hotkey,
+                &new_hotkey,
+                Some(netuid)
+            ),
+            Error::<Test>::NonAssociatedColdKey
+        );
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_owner_old_hotkey_not_exist --exact --nocapture
+#[test]
+fn test_swap_owner_old_hotkey_not_exist() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+
+        let netuid = add_dynamic_network(&new_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+
+        // Ensure old_hotkey does not exist
+        assert!(!Owner::<Test>::contains_key(old_hotkey));
+
+        // Perform the swap
+        assert_err!(
+            SubtensorModule::do_swap_hotkey(
+                RuntimeOrigin::signed(coldkey),
+                &old_hotkey,
+                &new_hotkey,
+                Some(netuid)
+            ),
+            Error::<Test>::NonAssociatedColdKey
+        );
+
+        // Verify the swap
+        assert_eq!(Owner::<Test>::get(new_hotkey), coldkey);
+        assert!(!Owner::<Test>::contains_key(old_hotkey));
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_owner_new_hotkey_already_exists --exact --nocapture
+#[test]
+fn test_swap_owner_new_hotkey_already_exists() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let another_coldkey = U256::from(4);
+
+        let netuid = add_dynamic_network(&new_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+
+        // Initialize Owner for old_hotkey and new_hotkey
+        Owner::<Test>::insert(old_hotkey, coldkey);
+        Owner::<Test>::insert(new_hotkey, another_coldkey);
+
+        // Perform the swap
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
+        assert_err!(
+            SubtensorModule::do_swap_hotkey(
+                RuntimeOrigin::signed(coldkey),
+                &old_hotkey,
+                &new_hotkey,
+                Some(netuid)
+            ),
+            Error::<Test>::HotKeyAlreadyRegisteredInSubNet
+        );
+
+        // Verify the swap
+        assert_eq!(Owner::<Test>::get(old_hotkey), coldkey);
+        assert!(Owner::<Test>::contains_key(old_hotkey));
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_stake_success --exact --nocapture
+#[test]
+fn test_swap_stake_success() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let subnet_owner_coldkey = U256::from(1001);
+        let subnet_owner_hotkey = U256::from(1002);
+        let netuid = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+        let amount = 10_000;
+        let shares = U64F64::from_num(123456);
+
+        // Initialize staking variables for old_hotkey
+        TotalHotkeyAlpha::<Test>::insert(old_hotkey, netuid, amount);
+        TotalHotkeyAlphaLastEpoch::<Test>::insert(old_hotkey, netuid, amount * 2);
+        TotalHotkeyShares::<Test>::insert(old_hotkey, netuid, U64F64::from_num(shares));
+        Alpha::<Test>::insert((old_hotkey, coldkey, netuid), U64F64::from_num(amount));
+        AlphaDividendsPerSubnet::<Test>::insert(netuid, old_hotkey, amount);
+        TaoDividendsPerSubnet::<Test>::insert(netuid, old_hotkey, amount);
+
+        // Perform the swap
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
+            &old_hotkey,
+            &new_hotkey,
+            Some(netuid)
+        ),);
+
+        // Verify the swap
+        assert_eq!(TotalHotkeyAlpha::<Test>::get(old_hotkey, netuid), 0);
+        assert_eq!(TotalHotkeyAlpha::<Test>::get(new_hotkey, netuid), amount);
+        assert_eq!(
+            TotalHotkeyAlphaLastEpoch::<Test>::get(old_hotkey, netuid),
+            0
+        );
+        assert_eq!(
+            TotalHotkeyAlphaLastEpoch::<Test>::get(new_hotkey, netuid),
+            amount * 2
+        );
+        assert_eq!(
+            TotalHotkeyShares::<Test>::get(old_hotkey, netuid),
+            U64F64::from_num(0)
+        );
+        assert_eq!(
+            TotalHotkeyShares::<Test>::get(new_hotkey, netuid),
+            U64F64::from_num(shares)
+        );
+        assert_eq!(
+            Alpha::<Test>::get((old_hotkey, coldkey, netuid)),
+            U64F64::from_num(0)
+        );
+        assert_eq!(
+            Alpha::<Test>::get((new_hotkey, coldkey, netuid)),
+            U64F64::from_num(amount)
+        );
+        assert_eq!(AlphaDividendsPerSubnet::<Test>::get(netuid, old_hotkey), 0);
+        assert_eq!(
+            AlphaDividendsPerSubnet::<Test>::get(netuid, new_hotkey),
+            amount
+        );
+        assert_eq!(TaoDividendsPerSubnet::<Test>::get(netuid, old_hotkey), 0);
+        assert_eq!(
+            TaoDividendsPerSubnet::<Test>::get(netuid, new_hotkey),
+            amount
+        );
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_hotkey_error_cases --exact --nocapture
+#[test]
+fn test_swap_hotkey_error_cases() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let wrong_coldkey = U256::from(4);
+        let netuid = add_dynamic_network(&old_hotkey, &coldkey);
+
+        // Set up initial state
+        Owner::<Test>::insert(old_hotkey, coldkey);
+        TotalNetworks::<Test>::put(1);
+        LastTxBlock::<Test>::insert(coldkey, 0);
+
+        // Test not enough balance
+        let swap_cost = SubtensorModule::get_key_swap_cost();
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
+        assert_err!(
+            SubtensorModule::do_swap_hotkey(
+                RuntimeOrigin::signed(coldkey),
+                &old_hotkey,
+                &new_hotkey,
+                Some(netuid)
+            ),
+            Error::<Test>::NotEnoughBalanceToPaySwapHotKey
+        );
+
+        let initial_balance = SubtensorModule::get_key_swap_cost() + 1000;
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, initial_balance);
+
+        // Test new hotkey same as old
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
+        assert_noop!(
+            SubtensorModule::do_swap_hotkey(
+                RuntimeOrigin::signed(coldkey),
+                &old_hotkey,
+                &old_hotkey,
+                Some(netuid)
+            ),
+            Error::<Test>::NewHotKeyIsSameWithOld
+        );
+
+        // Test new hotkey already registered
+        IsNetworkMember::<Test>::insert(new_hotkey, netuid, true);
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
+        assert_noop!(
+            SubtensorModule::do_swap_hotkey(
+                RuntimeOrigin::signed(coldkey),
+                &old_hotkey,
+                &new_hotkey,
+                Some(netuid)
+            ),
+            Error::<Test>::HotKeyAlreadyRegisteredInSubNet
+        );
+        IsNetworkMember::<Test>::remove(new_hotkey, netuid);
+
+        // Test non-associated coldkey
+        assert_noop!(
+            SubtensorModule::do_swap_hotkey(
+                RuntimeOrigin::signed(wrong_coldkey),
+                &old_hotkey,
+                &new_hotkey,
+                Some(netuid)
+            ),
+            Error::<Test>::NonAssociatedColdKey
+        );
+
+        // Run the successful swap
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
+            &old_hotkey,
+            &new_hotkey,
+            Some(netuid)
+        ),);
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_child_keys --exact --nocapture
+#[test]
+fn test_swap_child_keys() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let netuid = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+
+        let children = vec![(100u64, U256::from(4)), (200u64, U256::from(5))];
+
+        // Initialize ChildKeys for old_hotkey
+        ChildKeys::<Test>::insert(old_hotkey, netuid, children.clone());
+
+        // Perform the swap
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
+            &old_hotkey,
+            &new_hotkey,
+            Some(netuid)
+        ),);
+
+        // Verify the swap
+        assert_eq!(ChildKeys::<Test>::get(new_hotkey, netuid), children);
+        assert!(ChildKeys::<Test>::get(old_hotkey, netuid).is_empty());
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_parent_keys --exact --nocapture
+#[test]
+fn test_swap_parent_keys() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let netuid = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+        let parents = vec![(100u64, U256::from(4)), (200u64, U256::from(5))];
+
+        // Initialize ParentKeys for old_hotkey
+        ParentKeys::<Test>::insert(old_hotkey, netuid, parents.clone());
+
+        // Initialize ChildKeys for parent
+        ChildKeys::<Test>::insert(U256::from(4), netuid, vec![(100u64, old_hotkey)]);
+        ChildKeys::<Test>::insert(U256::from(5), netuid, vec![(200u64, old_hotkey)]);
+
+        // Perform the swap
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
+            &old_hotkey,
+            &new_hotkey,
+            Some(netuid)
+        ),);
+
+        // Verify ParentKeys swap
+        assert_eq!(ParentKeys::<Test>::get(new_hotkey, netuid), parents);
+        assert!(ParentKeys::<Test>::get(old_hotkey, netuid).is_empty());
+
+        // Verify ChildKeys update for parents
+        assert_eq!(
+            ChildKeys::<Test>::get(U256::from(4), netuid),
+            vec![(100u64, new_hotkey)]
+        );
+        assert_eq!(
+            ChildKeys::<Test>::get(U256::from(5), netuid),
+            vec![(200u64, new_hotkey)]
+        );
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_multiple_subnets --exact --nocapture
+#[test]
+fn test_swap_multiple_subnets() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let netuid1 = add_dynamic_network(&old_hotkey, &coldkey);
+        let netuid2 = add_dynamic_network(&old_hotkey, &coldkey);
+
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+
+        let children1 = vec![(100u64, U256::from(4)), (200u64, U256::from(5))];
+        let children2 = vec![(300u64, U256::from(6))];
+
+        // Initialize ChildKeys for old_hotkey in multiple subnets
+        ChildKeys::<Test>::insert(old_hotkey, netuid1, children1.clone());
+        ChildKeys::<Test>::insert(old_hotkey, netuid2, children2.clone());
+
+        // Perform the swap
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
+            &old_hotkey,
+            &new_hotkey,
+            Some(netuid1)
+        ),);
+
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
+            &old_hotkey,
+            &new_hotkey,
+            Some(netuid2)
+        ),);
+
+        // Verify the swap for both subnets
+        assert_eq!(ChildKeys::<Test>::get(new_hotkey, netuid1), children1);
+        assert_eq!(ChildKeys::<Test>::get(new_hotkey, netuid2), children2);
+        assert!(ChildKeys::<Test>::get(old_hotkey, netuid1).is_empty());
+        assert!(ChildKeys::<Test>::get(old_hotkey, netuid2).is_empty());
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_complex_parent_child_structure --exact --nocapture
+#[test]
+fn test_swap_complex_parent_child_structure() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let netuid = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+        let parent1 = U256::from(4);
+        let parent2 = U256::from(5);
+        let child1 = U256::from(6);
+        let child2 = U256::from(7);
+
+        // Set up complex parent-child structure
+        ParentKeys::<Test>::insert(
+            old_hotkey,
+            netuid,
+            vec![(100u64, parent1), (200u64, parent2)],
+        );
+        ChildKeys::<Test>::insert(old_hotkey, netuid, vec![(300u64, child1), (400u64, child2)]);
+        ChildKeys::<Test>::insert(
+            parent1,
+            netuid,
+            vec![(100u64, old_hotkey), (500u64, U256::from(8))],
+        );
+        ChildKeys::<Test>::insert(
+            parent2,
+            netuid,
+            vec![(200u64, old_hotkey), (600u64, U256::from(9))],
+        );
+
+        // Perform the swap
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
+            &old_hotkey,
+            &new_hotkey,
+            Some(netuid)
+        ),);
+
+        // Verify ParentKeys swap
+        assert_eq!(
+            ParentKeys::<Test>::get(new_hotkey, netuid),
+            vec![(100u64, parent1), (200u64, parent2)]
+        );
+        assert!(ParentKeys::<Test>::get(old_hotkey, netuid).is_empty());
+
+        // Verify ChildKeys swap
+        assert_eq!(
+            ChildKeys::<Test>::get(new_hotkey, netuid),
+            vec![(300u64, child1), (400u64, child2)]
+        );
+        assert!(ChildKeys::<Test>::get(old_hotkey, netuid).is_empty());
+
+        // Verify parent's ChildKeys update
+        assert_eq!(
+            ChildKeys::<Test>::get(parent1, netuid),
+            vec![(100u64, new_hotkey), (500u64, U256::from(8))]
+        );
+        assert_eq!(
+            ChildKeys::<Test>::get(parent2, netuid),
+            vec![(200u64, new_hotkey), (600u64, U256::from(9))]
+        );
+    });
+}
+
+#[test]
+fn test_swap_parent_hotkey_childkey_maps() {
+    new_test_ext(1).execute_with(|| {
+        let parent_old = U256::from(1);
+        let coldkey = U256::from(2);
+        let child = U256::from(3);
+        let child_other = U256::from(4);
+        let parent_new = U256::from(4);
+
+        let netuid = add_dynamic_network(&parent_old, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+
+        SubtensorModule::create_account_if_non_existent(&coldkey, &parent_old);
+
+        // Set child and verify state maps
+        mock_set_children(&coldkey, &parent_old, netuid, &[(u64::MAX, child)]);
+        // Wait rate limit
+        step_rate_limit(&TransactionType::SetChildren, netuid);
+        // Schedule some pending child keys.
+        mock_schedule_children(&coldkey, &parent_old, netuid, &[(u64::MAX, child_other)]);
+
+        assert_eq!(
+            ParentKeys::<Test>::get(child, netuid),
+            vec![(u64::MAX, parent_old)]
+        );
+        assert_eq!(
+            ChildKeys::<Test>::get(parent_old, netuid),
+            vec![(u64::MAX, child)]
+        );
+        let existing_pending_child_keys = PendingChildKeys::<Test>::get(netuid, parent_old);
+        assert_eq!(existing_pending_child_keys.0, vec![(u64::MAX, child_other)]);
+
+        // Swap
+
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
+            &parent_old,
+            &parent_new,
+            Some(netuid)
+        ),);
+
+        // Verify parent and child keys updates
+        assert_eq!(
+            ParentKeys::<Test>::get(child, netuid),
+            vec![(u64::MAX, parent_new)]
+        );
+        assert_eq!(
+            ChildKeys::<Test>::get(parent_new, netuid),
+            vec![(u64::MAX, child)]
+        );
+        assert_eq!(
+            PendingChildKeys::<Test>::get(netuid, parent_new),
+            existing_pending_child_keys // Entry under new hotkey.
+        );
+    })
+}
+
+#[test]
+fn test_swap_child_hotkey_childkey_maps() {
+    new_test_ext(1).execute_with(|| {
+        let parent = U256::from(1);
+        let coldkey = U256::from(2);
+        let child_old = U256::from(3);
+        let child_new = U256::from(4);
+        let netuid = add_dynamic_network(&child_old, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+
+        SubtensorModule::create_account_if_non_existent(&coldkey, &child_old);
+        SubtensorModule::create_account_if_non_existent(&coldkey, &parent);
+
+        // Set child and verify state maps
+        mock_set_children(&coldkey, &parent, netuid, &[(u64::MAX, child_old)]);
+        // Wait rate limit
+        step_rate_limit(&TransactionType::SetChildren, netuid);
+        // Schedule some pending child keys.
+        mock_schedule_children(&coldkey, &parent, netuid, &[(u64::MAX, child_old)]);
+
+        assert_eq!(
+            ParentKeys::<Test>::get(child_old, netuid),
+            vec![(u64::MAX, parent)]
+        );
+        assert_eq!(
+            ChildKeys::<Test>::get(parent, netuid),
+            vec![(u64::MAX, child_old)]
+        );
+        let existing_pending_child_keys = PendingChildKeys::<Test>::get(netuid, parent);
+        assert_eq!(existing_pending_child_keys.0, vec![(u64::MAX, child_old)]);
+
+        // Swap
+
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
+            &child_old,
+            &child_new,
+            Some(netuid)
+        ),);
+
+        // Verify parent and child keys updates
+        assert_eq!(
+            ParentKeys::<Test>::get(child_new, netuid),
+            vec![(u64::MAX, parent)]
+        );
+        assert_eq!(
+            ChildKeys::<Test>::get(parent, netuid),
+            vec![(u64::MAX, child_new)]
+        );
+        assert_eq!(
+            PendingChildKeys::<Test>::get(netuid, parent),
+            (vec![(u64::MAX, child_new)], existing_pending_child_keys.1) // Same cooldown block.
+        );
+    })
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_hotkey_is_sn_owner_hotkey --exact --nocapture
+#[test]
+fn test_swap_hotkey_is_sn_owner_hotkey() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+
+        // Create dynamic network
+        let netuid = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+
+        // Check for SubnetOwnerHotkey
+        assert_eq!(SubnetOwnerHotkey::<Test>::get(netuid), old_hotkey);
+
+        // Perform the swap
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
+            &old_hotkey,
+            &new_hotkey,
+            Some(netuid)
+        ),);
+
+        // Check for SubnetOwnerHotkey
+        assert_eq!(SubnetOwnerHotkey::<Test>::get(netuid), new_hotkey);
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_hotkey_swap_rate_limits --exact --nocapture
+#[test]
+fn test_swap_hotkey_swap_rate_limits() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+
+        let last_tx_block = 123;
+        let delegate_take_block = 4567;
+        let child_key_take_block = 8910;
+
+        let netuid = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+
+        // Set the last tx block for the old hotkey
+        LastTxBlock::<Test>::insert(old_hotkey, last_tx_block);
+        // Set the last delegate take block for the old hotkey
+        LastTxBlockDelegateTake::<Test>::insert(old_hotkey, delegate_take_block);
+        // Set last childkey take block for the old hotkey
+        LastTxBlockChildKeyTake::<Test>::insert(old_hotkey, child_key_take_block);
+
+        // Perform the swap
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
+            &old_hotkey,
+            &new_hotkey,
+            Some(netuid)
+        ),);
+
+        // Check for new hotkey
+        assert_eq!(LastTxBlock::<Test>::get(new_hotkey), last_tx_block);
+        assert_eq!(
+            LastTxBlockDelegateTake::<Test>::get(new_hotkey),
+            delegate_take_block
+        );
+        assert_eq!(
+            LastTxBlockChildKeyTake::<Test>::get(new_hotkey),
+            child_key_take_block
+        );
+    });
+}
+
+#[test]
+fn test_swap_owner_failed_interval_not_passed() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+
+        let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+        Owner::<Test>::insert(old_hotkey, coldkey);
+        assert_err!(
+            SubtensorModule::do_swap_hotkey(
+                RuntimeOrigin::signed(coldkey),
+                &old_hotkey,
+                &new_hotkey,
+                Some(netuid)
+            ),
+            Error::<Test>::HotKeySwapOnSubnetIntervalNotPassed,
+        );
+    });
+}
+
+#[test]
+fn test_swap_owner_check_swap_block_set() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+
+        let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+        Owner::<Test>::insert(old_hotkey, coldkey);
+        let new_block_number = System::block_number() + HotkeySwapOnSubnetInterval::get();
+        System::set_block_number(new_block_number);
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
+            &old_hotkey,
+            &new_hotkey,
+            Some(netuid)
+        ));
+
+        assert_eq!(
+            LastHotkeySwapOnNetuid::<Test>::get(netuid, coldkey),
+            new_block_number
+        );
+    });
+}
+
+#[test]
+fn test_swap_owner_check_swap_record_clean_up() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+
+        let netuid: u16 = add_dynamic_network(&old_hotkey, &coldkey);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
+        Owner::<Test>::insert(old_hotkey, coldkey);
+        let new_block_number = System::block_number() + HotkeySwapOnSubnetInterval::get();
+        System::set_block_number(new_block_number);
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            RuntimeOrigin::signed(coldkey),
+            &old_hotkey,
+            &new_hotkey,
+            Some(netuid)
+        ));
+
+        assert_eq!(
+            LastHotkeySwapOnNetuid::<Test>::get(netuid, coldkey),
+            new_block_number
+        );
+
+        step_block((HotkeySwapOnSubnetInterval::get() as u16 + netuid) * 2);
+        assert!(!LastHotkeySwapOnNetuid::<Test>::contains_key(
+            netuid, coldkey
+        ));
+    });
+}
diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index 9bf932b298..b934269cb8 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -1118,6 +1118,8 @@ parameter_types! {
     } else {
         7 * 24 * 60 * 60 / 12 // 7 days
     };
+    pub const SubtensorInitialKeySwapOnSubnetCost: u64 = 1_000_000; // 0.001 TAO
+    pub const HotkeySwapOnSubnetInterval : BlockNumber = 5 * 24 * 60 * 60 / 12; // 5 days
 }
 
 impl pallet_subtensor::Config for Runtime {
@@ -1187,6 +1189,8 @@ impl pallet_subtensor::Config for Runtime {
     type InitialDissolveNetworkScheduleDuration = InitialDissolveNetworkScheduleDuration;
     type InitialEmaPriceHalvingPeriod = InitialEmaPriceHalvingPeriod;
     type DurationOfStartCall = DurationOfStartCall;
+    type KeySwapOnSubnetCost = SubtensorInitialKeySwapOnSubnetCost;
+    type HotkeySwapOnSubnetInterval = HotkeySwapOnSubnetInterval;
 }
 
 use sp_runtime::BoundedVec;

From 0e914afd81e3d28ea41f0c4718075cbd5f8618a8 Mon Sep 17 00:00:00 2001
From: Sam Johnson <sam@durosoft.com>
Date: Sat, 14 Jun 2025 13:38:50 -0400
Subject: [PATCH 368/418] bump spec version

---
 runtime/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index b934269cb8..1a949a8ca3 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -209,7 +209,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
     //   `spec_version`, and `authoring_version` are the same between Wasm and native.
     // This value is set to 100 to notify Polkadot-JS App (https://polkadot.js.org/apps) to use
     //   the compatible custom types.
-    spec_version: 274,
+    spec_version: 275,
     impl_version: 1,
     apis: RUNTIME_API_VERSIONS,
     transaction_version: 1,

From 582ac00e6b0e3f4e876393ff03fc02b34a936e17 Mon Sep 17 00:00:00 2001
From: Cameron Fairchild <cameron@opentensor.ai>
Date: Sat, 14 Jun 2025 20:19:26 +0200
Subject: [PATCH 369/418] move guard check for *any* sn reg

---
 pallets/subtensor/src/swap/swap_hotkey.rs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/pallets/subtensor/src/swap/swap_hotkey.rs b/pallets/subtensor/src/swap/swap_hotkey.rs
index 733535c2ad..d79f124138 100644
--- a/pallets/subtensor/src/swap/swap_hotkey.rs
+++ b/pallets/subtensor/src/swap/swap_hotkey.rs
@@ -73,18 +73,18 @@ impl<T: Config> Pallet<T> {
         LastTxBlockChildKeyTake::<T>::insert(new_hotkey, last_tx_block_child_key_take);
         weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
 
-        // 10. fork for swap hotkey on a specific subnet case after do the common check
-        if let Some(netuid) = netuid {
-            return Self::swap_hotkey_on_subnet(&coldkey, old_hotkey, new_hotkey, netuid, weight);
-        };
-
         // Start to do everything for swap hotkey on all subnets case
-        // 11. Ensure the new hotkey is not already registered on any network
+        // 10. Ensure the new hotkey is not already registered on any network
         ensure!(
             !Self::is_hotkey_registered_on_any_network(new_hotkey),
             Error::<T>::HotKeyAlreadyRegisteredInSubNet
         );
 
+        // 11. fork for swap hotkey on a specific subnet case after do the common check
+        if let Some(netuid) = netuid {
+            return Self::swap_hotkey_on_subnet(&coldkey, old_hotkey, new_hotkey, netuid, weight);
+        };
+
         // 12. Get the cost for swapping the key
         let swap_cost = Self::get_key_swap_cost();
         log::debug!("Swap cost: {:?}", swap_cost);

From 038319873d098389978747f3c45a54174aa024ac Mon Sep 17 00:00:00 2001
From: Cameron Fairchild <cameron@opentensor.ai>
Date: Sat, 14 Jun 2025 20:23:17 +0200
Subject: [PATCH 370/418] add test

---
 .../src/tests/swap_hotkey_with_subnet.rs      | 34 +++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
index 583a8cf448..7720927540 100644
--- a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
+++ b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
@@ -1514,3 +1514,37 @@ fn test_swap_owner_check_swap_record_clean_up() {
         ));
     });
 }
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_hotkey_error_cases --exact --nocapture
+#[test]
+fn test_swap_hotkey_registered_on_other_subnet() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let wrong_coldkey = U256::from(4);
+        let netuid = add_dynamic_network(&old_hotkey, &coldkey);
+        let other_netuid = add_dynamic_network(&old_hotkey, &coldkey);
+
+        // Set up initial state
+        Owner::<Test>::insert(old_hotkey, coldkey);
+        TotalNetworks::<Test>::put(1);
+        LastTxBlock::<Test>::insert(coldkey, 0);
+
+        let initial_balance = SubtensorModule::get_key_swap_cost() + 1000;
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, initial_balance);
+
+        // Test new hotkey already registered on other subnet
+        IsNetworkMember::<Test>::insert(new_hotkey, other_netuid, true);
+        System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get());
+        assert_noop!(
+            SubtensorModule::do_swap_hotkey(
+                RuntimeOrigin::signed(coldkey),
+                &old_hotkey,
+                &new_hotkey,
+                Some(netuid)
+            ),
+            Error::<Test>::HotKeyAlreadyRegisteredInSubNet
+        );
+    });
+}

From 48359532761749ba86b93c272dc5317391194706 Mon Sep 17 00:00:00 2001
From: Cameron Fairchild <cameron@opentensor.ai>
Date: Sat, 14 Jun 2025 20:30:32 +0200
Subject: [PATCH 371/418] move state change to after check

---
 pallets/subtensor/src/swap/swap_hotkey.rs | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/pallets/subtensor/src/swap/swap_hotkey.rs b/pallets/subtensor/src/swap/swap_hotkey.rs
index d79f124138..eee75c264f 100644
--- a/pallets/subtensor/src/swap/swap_hotkey.rs
+++ b/pallets/subtensor/src/swap/swap_hotkey.rs
@@ -55,36 +55,37 @@ impl<T: Config> Pallet<T> {
 
         weight.saturating_accrue(T::DbWeight::get().reads(2));
 
-        // 7. Swap LastTxBlock
+        // 7. Ensure the new hotkey is not already registered on any network
+        ensure!(
+            !Self::is_hotkey_registered_on_any_network(new_hotkey),
+            Error::<T>::HotKeyAlreadyRegisteredInSubNet
+        );
+
+        // 8. Swap LastTxBlock
         // LastTxBlock( hotkey ) --> u64 -- the last transaction block for the hotkey.
         let last_tx_block: u64 = LastTxBlock::<T>::get(old_hotkey);
         LastTxBlock::<T>::insert(new_hotkey, last_tx_block);
         weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
 
-        // 8. Swap LastTxBlockDelegateTake
+        // 9. Swap LastTxBlockDelegateTake
         // LastTxBlockDelegateTake( hotkey ) --> u64 -- the last transaction block for the hotkey delegate take.
         let last_tx_block_delegate_take: u64 = LastTxBlockDelegateTake::<T>::get(old_hotkey);
         LastTxBlockDelegateTake::<T>::insert(new_hotkey, last_tx_block_delegate_take);
         weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
 
-        // 9. Swap LastTxBlockChildKeyTake
+        // 10. Swap LastTxBlockChildKeyTake
         // LastTxBlockChildKeyTake( hotkey ) --> u64 -- the last transaction block for the hotkey child key take.
         let last_tx_block_child_key_take: u64 = LastTxBlockChildKeyTake::<T>::get(old_hotkey);
         LastTxBlockChildKeyTake::<T>::insert(new_hotkey, last_tx_block_child_key_take);
         weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
 
-        // Start to do everything for swap hotkey on all subnets case
-        // 10. Ensure the new hotkey is not already registered on any network
-        ensure!(
-            !Self::is_hotkey_registered_on_any_network(new_hotkey),
-            Error::<T>::HotKeyAlreadyRegisteredInSubNet
-        );
-
         // 11. fork for swap hotkey on a specific subnet case after do the common check
         if let Some(netuid) = netuid {
             return Self::swap_hotkey_on_subnet(&coldkey, old_hotkey, new_hotkey, netuid, weight);
         };
 
+        // ==== Start to do everything for swap hotkey on all subnets case ====
+
         // 12. Get the cost for swapping the key
         let swap_cost = Self::get_key_swap_cost();
         log::debug!("Swap cost: {:?}", swap_cost);

From 248c5798c07824f0c847b0f0a855f3a7649c15c4 Mon Sep 17 00:00:00 2001
From: Cameron Fairchild <cameron@opentensor.ai>
Date: Sat, 14 Jun 2025 20:58:50 +0200
Subject: [PATCH 372/418] fix test 1

---
 .../src/tests/swap_hotkey_with_subnet.rs      | 19 +++++++++++++------
 1 file changed, 13 insertions(+), 6 deletions(-)

diff --git a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
index 7720927540..74ea5e806a 100644
--- a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
+++ b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
@@ -628,8 +628,9 @@ fn test_swap_hotkey_with_multiple_coldkeys_and_subnets() {
     new_test_ext(1).execute_with(|| {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
-        let coldkey1 = U256::from(3);
-        let coldkey2 = U256::from(4);
+        let new_hotkey_2 = U256::from(3);
+        let coldkey1 = U256::from(4);
+        let coldkey2 = U256::from(5);
         let netuid1 = 1;
         let netuid2 = 2;
         let stake = DefaultMinStake::<Test>::get() * 10;
@@ -687,7 +688,7 @@ fn test_swap_hotkey_with_multiple_coldkeys_and_subnets() {
         assert_ok!(SubtensorModule::do_swap_hotkey(
             RuntimeOrigin::signed(coldkey1),
             &old_hotkey,
-            &new_hotkey,
+            &new_hotkey_2,
             Some(netuid2)
         ));
 
@@ -697,6 +698,11 @@ fn test_swap_hotkey_with_multiple_coldkeys_and_subnets() {
             coldkey1
         );
         assert!(!SubtensorModule::get_owned_hotkeys(&coldkey2).contains(&new_hotkey));
+        assert_eq!(
+            SubtensorModule::get_owning_coldkey_for_hotkey(&new_hotkey_2),
+            coldkey1
+        );
+        assert!(!SubtensorModule::get_owned_hotkeys(&coldkey2).contains(&new_hotkey_2));
 
         // Check stake transfer
         assert_eq!(
@@ -709,7 +715,7 @@ fn test_swap_hotkey_with_multiple_coldkeys_and_subnets() {
         );
         assert_eq!(
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
-                &new_hotkey,
+                &new_hotkey_2,
                 &coldkey2,
                 netuid2
             ),
@@ -739,7 +745,7 @@ fn test_swap_hotkey_with_multiple_coldkeys_and_subnets() {
         ));
         assert!(SubtensorModule::is_hotkey_registered_on_network(
             netuid2,
-            &new_hotkey
+            &new_hotkey_2
         ));
         assert!(!SubtensorModule::is_hotkey_registered_on_network(
             netuid1,
@@ -752,7 +758,8 @@ fn test_swap_hotkey_with_multiple_coldkeys_and_subnets() {
 
         // Check total stake transfer
         assert_eq!(
-            SubtensorModule::get_total_stake_for_hotkey(&new_hotkey),
+            SubtensorModule::get_total_stake_for_hotkey(&new_hotkey)
+                + SubtensorModule::get_total_stake_for_hotkey(&new_hotkey_2),
             total_hk_stake
         );
         assert_eq!(SubtensorModule::get_total_stake_for_hotkey(&old_hotkey), 0);

From 52a06bc084eb366de20fdc5a98c72ec982ccd28d Mon Sep 17 00:00:00 2001
From: Cameron Fairchild <cameron@opentensor.ai>
Date: Sat, 14 Jun 2025 21:00:22 +0200
Subject: [PATCH 373/418] fix test 2

---
 pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
index 74ea5e806a..bf2cfb4635 100644
--- a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
+++ b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
@@ -497,7 +497,8 @@ fn test_swap_hotkey_with_multiple_subnets() {
     new_test_ext(1).execute_with(|| {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
-        let coldkey = U256::from(3);
+        let new_hotkey_2 = U256::from(3);
+        let coldkey = U256::from(4);
 
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
 
@@ -519,12 +520,12 @@ fn test_swap_hotkey_with_multiple_subnets() {
         assert_ok!(SubtensorModule::do_swap_hotkey(
             RuntimeOrigin::signed(coldkey),
             &old_hotkey,
-            &new_hotkey,
+            &new_hotkey_2,
             Some(netuid2)
         ));
 
         assert!(IsNetworkMember::<Test>::get(new_hotkey, netuid1));
-        assert!(IsNetworkMember::<Test>::get(new_hotkey, netuid2));
+        assert!(IsNetworkMember::<Test>::get(new_hotkey_2, netuid2));
         assert!(!IsNetworkMember::<Test>::get(old_hotkey, netuid1));
         assert!(!IsNetworkMember::<Test>::get(old_hotkey, netuid2));
     });

From 55b3ea2f7a03096cc2ae87ac0cd7ebc6bae41833 Mon Sep 17 00:00:00 2001
From: Cameron Fairchild <cameron@opentensor.ai>
Date: Sat, 14 Jun 2025 21:00:47 +0200
Subject: [PATCH 374/418] fix test 3

---
 pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
index bf2cfb4635..f7081dc2a6 100644
--- a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
+++ b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
@@ -1151,7 +1151,8 @@ fn test_swap_multiple_subnets() {
     new_test_ext(1).execute_with(|| {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
-        let coldkey = U256::from(3);
+        let new_hotkey_2 = U256::from(3);
+        let coldkey = U256::from(4);
         let netuid1 = add_dynamic_network(&old_hotkey, &coldkey);
         let netuid2 = add_dynamic_network(&old_hotkey, &coldkey);
 
@@ -1177,13 +1178,13 @@ fn test_swap_multiple_subnets() {
         assert_ok!(SubtensorModule::do_swap_hotkey(
             RuntimeOrigin::signed(coldkey),
             &old_hotkey,
-            &new_hotkey,
+            &new_hotkey_2,
             Some(netuid2)
         ),);
 
         // Verify the swap for both subnets
         assert_eq!(ChildKeys::<Test>::get(new_hotkey, netuid1), children1);
-        assert_eq!(ChildKeys::<Test>::get(new_hotkey, netuid2), children2);
+        assert_eq!(ChildKeys::<Test>::get(new_hotkey_2, netuid2), children2);
         assert!(ChildKeys::<Test>::get(old_hotkey, netuid1).is_empty());
         assert!(ChildKeys::<Test>::get(old_hotkey, netuid2).is_empty());
     });

From 55965741992757d29e7cbe8bb4eafe08132ce5a6 Mon Sep 17 00:00:00 2001
From: Cameron Fairchild <cameron@opentensor.ai>
Date: Sat, 14 Jun 2025 21:44:52 +0200
Subject: [PATCH 375/418] add

---
 common/src/lib.rs  | 1 +
 runtime/src/lib.rs | 4 ++++
 2 files changed, 5 insertions(+)

diff --git a/common/src/lib.rs b/common/src/lib.rs
index 75b18e3b14..9d856871ea 100644
--- a/common/src/lib.rs
+++ b/common/src/lib.rs
@@ -50,6 +50,7 @@ pub enum ProxyType {
     RootWeights,
     ChildKeys,
     SudoUncheckedSetCode,
+    SwapHotkey,
 }
 
 impl Default for ProxyType {
diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index 1a949a8ca3..75c6101b47 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -829,6 +829,10 @@ impl InstanceFilter<RuntimeCall> for ProxyType {
                 }
                 _ => false,
             },
+            ProxyType::SwapHotkey => matches!(
+                c,
+                RuntimeCall::SubtensorModule(pallet_subtensor::Call::swap_hotkey { .. })
+            ),
         }
     }
     fn is_superset(&self, o: &Self) -> bool {

From d7117b613bb012b1754cf7d40614a22c35cf4b86 Mon Sep 17 00:00:00 2001
From: Cameron Fairchild <cameron@opentensor.ai>
Date: Sat, 14 Jun 2025 21:45:11 +0200
Subject: [PATCH 376/418] bump spec

---
 runtime/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index 75c6101b47..4924a312cb 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -209,7 +209,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
     //   `spec_version`, and `authoring_version` are the same between Wasm and native.
     // This value is set to 100 to notify Polkadot-JS App (https://polkadot.js.org/apps) to use
     //   the compatible custom types.
-    spec_version: 275,
+    spec_version: 276,
     impl_version: 1,
     apis: RUNTIME_API_VERSIONS,
     transaction_version: 1,

From 4820fb2f75f9df7537a6cc9e9e05ed4d90c1ac01 Mon Sep 17 00:00:00 2001
From: Sam Johnson <sam@durosoft.com>
Date: Sun, 15 Jun 2025 18:59:39 -0400
Subject: [PATCH 377/418] cooldown

---
 pallets/subtensor/src/lib.rs                  | 11 +++++++++++
 pallets/subtensor/src/macros/dispatches.rs    | 12 ++++++++++++
 pallets/subtensor/src/staking/set_children.rs |  2 +-
 3 files changed, 24 insertions(+), 1 deletion(-)

diff --git a/pallets/subtensor/src/lib.rs b/pallets/subtensor/src/lib.rs
index d303f1a316..e8e911509a 100644
--- a/pallets/subtensor/src/lib.rs
+++ b/pallets/subtensor/src/lib.rs
@@ -1715,6 +1715,17 @@ pub mod pallet {
     #[pallet::storage] // --- Storage for migration run status
     pub type HasMigrationRun<T: Config> = StorageMap<_, Identity, Vec<u8>, bool, ValueQuery>;
 
+    #[pallet::type_value]
+    /// Default value for pending childkey cooldown (settable by root, default 0)
+    pub fn DefaultPendingChildKeyCooldown<T: Config>() -> u64 {
+        0
+    }
+
+    #[pallet::storage]
+    /// Storage value for pending childkey cooldown, settable by root.
+    pub type PendingChildKeyCooldown<T: Config> =
+        StorageValue<_, u64, ValueQuery, DefaultPendingChildKeyCooldown<T>>;
+
     #[pallet::genesis_config]
     pub struct GenesisConfig<T: Config> {
         /// Stakes record in genesis.
diff --git a/pallets/subtensor/src/macros/dispatches.rs b/pallets/subtensor/src/macros/dispatches.rs
index f629a9e108..ef2e2babd7 100644
--- a/pallets/subtensor/src/macros/dispatches.rs
+++ b/pallets/subtensor/src/macros/dispatches.rs
@@ -2057,6 +2057,18 @@ mod dispatches {
             Self::do_burn_alpha(origin, hotkey, amount, netuid)
         }
 
+        /// Sets the pending childkey cooldown (in blocks). Root only.
+        #[pallet::call_index(109)]
+        #[pallet::weight((Weight::from_parts(10_000, 0), DispatchClass::Operational, Pays::No))]
+        pub fn set_pending_childkey_cooldown(
+            origin: OriginFor<T>,
+            cooldown: u64,
+        ) -> DispatchResult {
+            ensure_root(origin)?;
+            PendingChildKeyCooldown::<T>::put(cooldown);
+            Ok(())
+        }
+
         // /// --- Adds stake to a hotkey on a subnet with a price limit.
         // /// This extrinsic allows to specify the limit price for alpha token
         // /// at which or better (lower) the staking should execute.
diff --git a/pallets/subtensor/src/staking/set_children.rs b/pallets/subtensor/src/staking/set_children.rs
index 2d2ebaec47..ff7dd7e98d 100644
--- a/pallets/subtensor/src/staking/set_children.rs
+++ b/pallets/subtensor/src/staking/set_children.rs
@@ -123,7 +123,7 @@ impl<T: Config> Pallet<T> {
 
         // Calculate cool-down block
         let cooldown_block =
-            Self::get_current_block_as_u64().saturating_add(DefaultPendingCooldown::<T>::get());
+            Self::get_current_block_as_u64().saturating_add(PendingChildKeyCooldown::<T>::get());
 
         // Insert or update PendingChildKeys
         PendingChildKeys::<T>::insert(netuid, hotkey.clone(), (children.clone(), cooldown_block));

From 4b232d3926c637005f8855204b0dc5b40714e2ca Mon Sep 17 00:00:00 2001
From: Sam Johnson <sam@durosoft.com>
Date: Sun, 15 Jun 2025 21:39:20 -0400
Subject: [PATCH 378/418] fix

---
 pallets/subtensor/src/staking/set_children.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/pallets/subtensor/src/staking/set_children.rs b/pallets/subtensor/src/staking/set_children.rs
index ff7dd7e98d..9f421a5990 100644
--- a/pallets/subtensor/src/staking/set_children.rs
+++ b/pallets/subtensor/src/staking/set_children.rs
@@ -1,5 +1,4 @@
 use super::*;
-use sp_core::Get;
 
 impl<T: Config> Pallet<T> {
     /// ---- The implementation for the extrinsic do_set_child_singular: Sets a single child.

From 3edbb98575042aa8eff5c3a62184229f0fcfaf54 Mon Sep 17 00:00:00 2001
From: distributedstatemachine <fatheroffire@proton.me>
Date: Mon, 16 Jun 2025 02:34:56 +0000
Subject: [PATCH 379/418] fix: tests

---
 pallets/subtensor/src/tests/children.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/pallets/subtensor/src/tests/children.rs b/pallets/subtensor/src/tests/children.rs
index 1a9016f13f..1cb362522a 100644
--- a/pallets/subtensor/src/tests/children.rs
+++ b/pallets/subtensor/src/tests/children.rs
@@ -3955,7 +3955,8 @@ fn test_pending_cooldown_one_day() {
     let expected_cooldown = if cfg!(feature = "fast-blocks") {
         15
     } else {
-        7_200
+        // TODO: Change back when CHK splitting issue resolved
+        1
     };
 
     new_test_ext(curr_block).execute_with(|| {

From f3c434bff7992b78642a70d95b1d6a577bdef6d1 Mon Sep 17 00:00:00 2001
From: distributedstatemachine <fatheroffire@proton.me>
Date: Mon, 16 Jun 2025 02:40:25 +0000
Subject: [PATCH 380/418] fix: tests

---
 pallets/subtensor/src/tests/children.rs | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/pallets/subtensor/src/tests/children.rs b/pallets/subtensor/src/tests/children.rs
index 1cb362522a..230adeab31 100644
--- a/pallets/subtensor/src/tests/children.rs
+++ b/pallets/subtensor/src/tests/children.rs
@@ -3951,12 +3951,11 @@ fn test_dividend_distribution_with_children_same_coldkey_owner() {
 #[test]
 fn test_pending_cooldown_one_day() {
     let curr_block = 1;
-
+    // TODO: Fix when CHK splitting patched
     let expected_cooldown = if cfg!(feature = "fast-blocks") {
-        15
+        0
     } else {
-        // TODO: Change back when CHK splitting issue resolved
-        1
+        0
     };
 
     new_test_ext(curr_block).execute_with(|| {

From a35e462871fceba66c4180b3dc6f05133ad8d6f3 Mon Sep 17 00:00:00 2001
From: distributedstatemachine <fatheroffire@proton.me>
Date: Mon, 16 Jun 2025 02:50:08 +0000
Subject: [PATCH 381/418] chore: clippy

---
 pallets/subtensor/src/tests/children.rs | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/pallets/subtensor/src/tests/children.rs b/pallets/subtensor/src/tests/children.rs
index 230adeab31..5a3302e647 100644
--- a/pallets/subtensor/src/tests/children.rs
+++ b/pallets/subtensor/src/tests/children.rs
@@ -3952,11 +3952,13 @@ fn test_dividend_distribution_with_children_same_coldkey_owner() {
 fn test_pending_cooldown_one_day() {
     let curr_block = 1;
     // TODO: Fix when CHK splitting patched
-    let expected_cooldown = if cfg!(feature = "fast-blocks") {
-        0
-    } else {
-        0
-    };
+    // let expected_cooldown = if cfg!(feature = "fast-blocks") {
+    //     15
+    // } else {
+    //     7200
+    // };
+
+    let expected_cooldown = 0;
 
     new_test_ext(curr_block).execute_with(|| {
         let coldkey = U256::from(1);

From bfeaf1c19a65e34e4a4be01cc1567bb0ec6d748f Mon Sep 17 00:00:00 2001
From: Sam Johnson <sam@durosoft.com>
Date: Sun, 15 Jun 2025 23:40:20 -0400
Subject: [PATCH 382/418] bump spec version

---
 runtime/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index 4924a312cb..7aa529eebe 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -209,7 +209,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
     //   `spec_version`, and `authoring_version` are the same between Wasm and native.
     // This value is set to 100 to notify Polkadot-JS App (https://polkadot.js.org/apps) to use
     //   the compatible custom types.
-    spec_version: 276,
+    spec_version: 277,
     impl_version: 1,
     apis: RUNTIME_API_VERSIONS,
     transaction_version: 1,

From 586eb24baf3e9534a8f99085e9018f3a1b2a1266 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Mon, 16 Jun 2025 13:37:34 +0800
Subject: [PATCH 383/418] fix benchmark

---
 pallets/subtensor/src/macros/dispatches.rs | 2 +-
 pallets/subtensor/src/tests/children.rs    | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/pallets/subtensor/src/macros/dispatches.rs b/pallets/subtensor/src/macros/dispatches.rs
index ef2e2babd7..3657c2d89f 100644
--- a/pallets/subtensor/src/macros/dispatches.rs
+++ b/pallets/subtensor/src/macros/dispatches.rs
@@ -1785,7 +1785,7 @@ mod dispatches {
         ///  	- Errors stemming from transaction pallet.
         ///
         #[pallet::call_index(88)]
-        #[pallet::weight((Weight::from_parts(159_200_000, 0)
+        #[pallet::weight((Weight::from_parts(159_400_000, 0)
 		.saturating_add(T::DbWeight::get().reads(13))
 		.saturating_add(T::DbWeight::get().writes(10)), DispatchClass::Normal, Pays::No))]
         pub fn add_stake_limit(
diff --git a/pallets/subtensor/src/tests/children.rs b/pallets/subtensor/src/tests/children.rs
index 5a3302e647..ec49e17481 100644
--- a/pallets/subtensor/src/tests/children.rs
+++ b/pallets/subtensor/src/tests/children.rs
@@ -3949,7 +3949,7 @@ fn test_dividend_distribution_with_children_same_coldkey_owner() {
 }
 
 #[test]
-fn test_pending_cooldown_one_day() {
+fn test_pending_cooldown_as_expected() {
     let curr_block = 1;
     // TODO: Fix when CHK splitting patched
     // let expected_cooldown = if cfg!(feature = "fast-blocks") {
@@ -3958,7 +3958,7 @@ fn test_pending_cooldown_one_day() {
     //     7200
     // };
 
-    let expected_cooldown = 0;
+    let expected_cooldown = PendingChildKeyCooldown::<Test>::get();
 
     new_test_ext(curr_block).execute_with(|| {
         let coldkey = U256::from(1);

From 0e99ff65982c75b0a2b156e4e57b2eaaeb9b55f0 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Mon, 16 Jun 2025 13:52:12 +0800
Subject: [PATCH 384/418] fix an error

---
 pallets/subtensor/src/tests/children.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/pallets/subtensor/src/tests/children.rs b/pallets/subtensor/src/tests/children.rs
index ec49e17481..4ee81052b4 100644
--- a/pallets/subtensor/src/tests/children.rs
+++ b/pallets/subtensor/src/tests/children.rs
@@ -3958,8 +3958,6 @@ fn test_pending_cooldown_as_expected() {
     //     7200
     // };
 
-    let expected_cooldown = PendingChildKeyCooldown::<Test>::get();
-
     new_test_ext(curr_block).execute_with(|| {
         let coldkey = U256::from(1);
         let hotkey = U256::from(2);
@@ -3968,6 +3966,7 @@ fn test_pending_cooldown_as_expected() {
         let netuid: u16 = 1;
         let proportion1: u64 = 1000;
         let proportion2: u64 = 2000;
+        let expected_cooldown = PendingChildKeyCooldown::<Test>::get();
 
         // Add network and register hotkey
         add_network(netuid, 13, 0);

From 0b94f9628d85065d36ceacb3429ed7aea7d41c50 Mon Sep 17 00:00:00 2001
From: Andreea Popescu <andreea.popescu@reef.pl>
Date: Fri, 13 Jun 2025 05:27:15 +0100
Subject: [PATCH 385/418] fix alphas values checks

---
 pallets/admin-utils/src/tests/mod.rs     |  8 ++--
 pallets/subtensor/src/epoch/run_epoch.rs |  5 ++-
 pallets/subtensor/src/tests/epoch.rs     | 53 +++++++++++++++++++++---
 pallets/subtensor/src/tests/math.rs      |  6 +--
 4 files changed, 58 insertions(+), 14 deletions(-)

diff --git a/pallets/admin-utils/src/tests/mod.rs b/pallets/admin-utils/src/tests/mod.rs
index 9e70858566..290867737b 100644
--- a/pallets/admin-utils/src/tests/mod.rs
+++ b/pallets/admin-utils/src/tests/mod.rs
@@ -1150,7 +1150,7 @@ fn test_sudo_set_liquid_alpha_enabled() {
 fn test_set_alpha_values_dispatch_info_ok() {
     new_test_ext().execute_with(|| {
         let netuid = NetUid::from(1);
-        let alpha_low: u16 = 12_u16;
+        let alpha_low: u16 = 1638_u16;
         let alpha_high: u16 = u16::MAX - 10;
         let call = RuntimeCall::AdminUtils(crate::Call::sudo_set_alpha_values {
             netuid,
@@ -1169,7 +1169,7 @@ fn test_set_alpha_values_dispatch_info_ok() {
 fn test_sudo_get_set_alpha() {
     new_test_ext().execute_with(|| {
         let netuid = NetUid::from(1);
-        let alpha_low: u16 = 12_u16;
+        let alpha_low: u16 = 1638_u16;
         let alpha_high: u16 = u16::MAX - 10;
 
         let hotkey: U256 = U256::from(1);
@@ -1252,7 +1252,7 @@ fn test_sudo_get_set_alpha() {
         ));
 
         // 2. Alpha high too low
-        let alpha_high_too_low = (u16::MAX as u32 * 4 / 5) as u16 - 1; // One less than the minimum acceptable value
+        let alpha_high_too_low = (u16::MAX as u32 / 40) as u16 - 1; // One less than the minimum acceptable value
         assert_err!(
             AdminUtils::sudo_set_alpha_values(
                 signer.clone(),
@@ -1289,7 +1289,7 @@ fn test_sudo_get_set_alpha() {
             alpha_high
         ));
 
-        let alpha_low_too_high = (u16::MAX as u32 * 4 / 5) as u16 + 1; // One more than the maximum acceptable value
+        let alpha_low_too_high = alpha_high + 1;
         assert_err!(
             AdminUtils::sudo_set_alpha_values(
                 signer.clone(),
diff --git a/pallets/subtensor/src/epoch/run_epoch.rs b/pallets/subtensor/src/epoch/run_epoch.rs
index 715eb89f69..cf6d89764e 100644
--- a/pallets/subtensor/src/epoch/run_epoch.rs
+++ b/pallets/subtensor/src/epoch/run_epoch.rs
@@ -1341,14 +1341,15 @@ impl<T: Config> Pallet<T> {
         );
 
         let max_u16: u32 = u16::MAX as u32; // 65535
-        let min_alpha_high: u16 = (max_u16.saturating_mul(4).safe_div(5)) as u16; // 52428
+        let min_alpha_low: u16 = (max_u16.safe_div(40)) as u16; // 1638
+        let min_alpha_high: u16 = min_alpha_low;
 
         // --- 4. Ensure alpha high is greater than the minimum
         ensure!(alpha_high >= min_alpha_high, Error::<T>::AlphaHighTooLow);
 
         // -- 5. Ensure alpha low is within range
         ensure!(
-            alpha_low > 0 && alpha_low < min_alpha_high,
+            alpha_low >= min_alpha_low && alpha_low <= alpha_high,
             Error::<T>::AlphaLowOutOfRange
         );
 
diff --git a/pallets/subtensor/src/tests/epoch.rs b/pallets/subtensor/src/tests/epoch.rs
index 0e567796d7..436f9ee6d9 100644
--- a/pallets/subtensor/src/tests/epoch.rs
+++ b/pallets/subtensor/src/tests/epoch.rs
@@ -6,6 +6,7 @@
 
 use super::mock::*;
 use crate::epoch::math::{fixed, u16_proportion_to_fixed};
+use crate::tests::math::{assert_mat_compare, vec_to_fixed, vec_to_mat_fixed};
 use crate::*;
 
 use approx::assert_abs_diff_eq;
@@ -1312,7 +1313,7 @@ fn test_set_alpha_disabled() {
         // Explicitly set to false
         SubtensorModule::set_liquid_alpha_enabled(netuid, false);
         assert_err!(
-            SubtensorModule::do_set_alpha_values(signer.clone(), netuid, 12_u16, u16::MAX),
+            SubtensorModule::do_set_alpha_values(signer.clone(), netuid, 1638_u16, u16::MAX),
             Error::<Test>::LiquidAlphaDisabled
         );
 
@@ -1320,7 +1321,7 @@ fn test_set_alpha_disabled() {
         assert_ok!(SubtensorModule::do_set_alpha_values(
             signer.clone(),
             netuid,
-            12_u16,
+            1638_u16,
             u16::MAX
         ));
     });
@@ -2227,7 +2228,7 @@ fn test_validator_permits() {
 fn test_get_set_alpha() {
     new_test_ext(1).execute_with(|| {
         let netuid = NetUid::from(1);
-        let alpha_low: u16 = 12_u16;
+        let alpha_low: u16 = 1638_u16;
         let alpha_high: u16 = u16::MAX - 10;
 
         let hotkey: U256 = U256::from(1);
@@ -2315,7 +2316,7 @@ fn test_get_set_alpha() {
         ));
 
         // 2. Alpha high too low
-        let alpha_high_too_low = (u16::MAX as u32 * 4 / 5) as u16 - 1; // One less than the minimum acceptable value
+        let alpha_high_too_low = (u16::MAX as u32 / 40) as u16 - 1; // One less than the minimum acceptable value
         assert_err!(
             SubtensorModule::do_set_alpha_values(
                 signer.clone(),
@@ -2352,7 +2353,7 @@ fn test_get_set_alpha() {
             alpha_high
         ));
 
-        let alpha_low_too_high = (u16::MAX as u32 * 4 / 5) as u16 + 1; // One more than the maximum acceptable value
+        let alpha_low_too_high = alpha_high + 1; // alpha_low should be <= alpha_high
         assert_err!(
             SubtensorModule::do_set_alpha_values(
                 signer.clone(),
@@ -3480,3 +3481,45 @@ fn test_yuma_3_bonds_reset() {
         }
     })
 }
+
+#[test]
+fn test_liquid_alpha_equal_values_against_itself() {
+    new_test_ext(1).execute_with(|| {
+        // check Liquid alpha disabled against Liquid Alpha enabled with alpha_low == alpha_high
+        let netuid: NetUid = NetUid::from(1);
+        let alpha_low = u16::MAX / 10;
+        let alpha_high = u16::MAX / 10;
+        let epsilon = I32F32::from_num(1e-3);
+        let weights: Vec<Vec<I32F32>> = vec_to_mat_fixed(
+            &[0., 0.1, 0., 0., 0.2, 0.4, 0., 0.3, 0.1, 0., 0.4, 0.5],
+            4,
+            false,
+        );
+        let bonds: Vec<Vec<I32F32>> = vec_to_mat_fixed(
+            &[0.1, 0.1, 0.5, 0., 0., 0.4, 0.5, 0.1, 0.1, 0., 0.4, 0.2],
+            4,
+            false,
+        );
+        let consensus: Vec<I32F32> = vec_to_fixed(&[0.3, 0.2, 0.1, 0.4]);
+
+        // set both alpha values to 0.1 and bonds moving average to 0.9
+        AlphaValues::<Test>::insert(netuid, (alpha_low, alpha_high));
+        SubtensorModule::set_bonds_moving_average(netuid.into(), 900_000);
+
+        // compute bonds with liquid alpha enabled
+        SubtensorModule::set_liquid_alpha_enabled(netuid.into(), true);
+        let new_bonds_liquid_alpha_on =
+            SubtensorModule::compute_bonds(netuid.into(), &weights, &bonds, &consensus);
+
+        // compute bonds with liquid alpha disabled
+        SubtensorModule::set_liquid_alpha_enabled(netuid.into(), false);
+        let new_bonds_liquid_alpha_off =
+            SubtensorModule::compute_bonds(netuid.into(), &weights, &bonds, &consensus);
+
+        assert_mat_compare(
+            &new_bonds_liquid_alpha_on,
+            &new_bonds_liquid_alpha_off,
+            epsilon,
+        );
+    });
+}
diff --git a/pallets/subtensor/src/tests/math.rs b/pallets/subtensor/src/tests/math.rs
index 01e02742b7..1db3622373 100644
--- a/pallets/subtensor/src/tests/math.rs
+++ b/pallets/subtensor/src/tests/math.rs
@@ -41,7 +41,7 @@ fn assert_vec_compare_u16(va: &[u16], vb: &[u16]) {
     }
 }
 
-fn assert_mat_compare(ma: &[Vec<I32F32>], mb: &[Vec<I32F32>], epsilon: I32F32) {
+pub fn assert_mat_compare(ma: &[Vec<I32F32>], mb: &[Vec<I32F32>], epsilon: I32F32) {
     assert!(ma.len() == mb.len());
     for row in 0..ma.len() {
         assert!(ma[row].len() == mb[row].len());
@@ -72,7 +72,7 @@ fn assert_sparse_mat_compare(
     }
 }
 
-fn vec_to_fixed(vector: &[f32]) -> Vec<I32F32> {
+pub fn vec_to_fixed(vector: &[f32]) -> Vec<I32F32> {
     vector.iter().map(|x| I32F32::from_num(*x)).collect()
 }
 
@@ -365,7 +365,7 @@ fn test_math_vec_to_fixed() {
 }
 
 // Reshape vector to matrix with specified number of rows, cast to I32F32.
-fn vec_to_mat_fixed(vector: &[f32], rows: usize, transpose: bool) -> Vec<Vec<I32F32>> {
+pub fn vec_to_mat_fixed(vector: &[f32], rows: usize, transpose: bool) -> Vec<Vec<I32F32>> {
     assert!(
         vector.len() % rows == 0,
         "Vector of len {:?} cannot reshape to {rows} rows.",

From 17e48b2026f18c41363ec323ac245bd2b53da670 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Mon, 16 Jun 2025 15:42:36 +0800
Subject: [PATCH 386/418] fix benchmark

---
 pallets/subtensor/src/macros/dispatches.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pallets/subtensor/src/macros/dispatches.rs b/pallets/subtensor/src/macros/dispatches.rs
index 3657c2d89f..3b3e46cdc7 100644
--- a/pallets/subtensor/src/macros/dispatches.rs
+++ b/pallets/subtensor/src/macros/dispatches.rs
@@ -1785,8 +1785,8 @@ mod dispatches {
         ///  	- Errors stemming from transaction pallet.
         ///
         #[pallet::call_index(88)]
-        #[pallet::weight((Weight::from_parts(159_400_000, 0)
-		.saturating_add(T::DbWeight::get().reads(13))
+        #[pallet::weight((Weight::from_parts(159_200_000, 0)
+		.saturating_add(T::DbWeight::get().reads(14))
 		.saturating_add(T::DbWeight::get().writes(10)), DispatchClass::Normal, Pays::No))]
         pub fn add_stake_limit(
             origin: OriginFor<T>,

From 651b8be52a7380df1fd0f53b5cabb252b035000a Mon Sep 17 00:00:00 2001
From: Sam Johnson <sam@durosoft.com>
Date: Mon, 16 Jun 2025 10:16:40 -0400
Subject: [PATCH 387/418] fix benchmark

---
 pallets/subtensor/src/macros/dispatches.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pallets/subtensor/src/macros/dispatches.rs b/pallets/subtensor/src/macros/dispatches.rs
index ef2e2babd7..3b3e46cdc7 100644
--- a/pallets/subtensor/src/macros/dispatches.rs
+++ b/pallets/subtensor/src/macros/dispatches.rs
@@ -1786,7 +1786,7 @@ mod dispatches {
         ///
         #[pallet::call_index(88)]
         #[pallet::weight((Weight::from_parts(159_200_000, 0)
-		.saturating_add(T::DbWeight::get().reads(13))
+		.saturating_add(T::DbWeight::get().reads(14))
 		.saturating_add(T::DbWeight::get().writes(10)), DispatchClass::Normal, Pays::No))]
         pub fn add_stake_limit(
             origin: OriginFor<T>,

From ba9b1f5d76cdbad2ac4a1ecd83f533364ce385ea Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Mon, 16 Jun 2025 16:50:22 +0200
Subject: [PATCH 388/418] fix network backend type selection

---
 node/src/service.rs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/node/src/service.rs b/node/src/service.rs
index 4b95f6eb5d..26071c6d0c 100644
--- a/node/src/service.rs
+++ b/node/src/service.rs
@@ -733,11 +733,12 @@ pub async fn build_full(
             new_full::<sc_network::NetworkWorker<_, _>>(config, eth_config, sealing).await
         }
         Some(sc_network::config::NetworkBackendType::Litep2p) => {
+            new_full::<sc_network::Litep2pNetworkBackend>(config, eth_config, sealing).await
+        }
+        _ => {
+            log::debug!("no network backend selected, falling back to libp2p");
             new_full::<sc_network::NetworkWorker<_, _>>(config, eth_config, sealing).await
         }
-        _ => Err(ServiceError::Other(
-            "Network backend not supported".to_string(),
-        )),
     }
 }
 

From 96e189485d84c7509486f7c0026494c2ac6d51ef Mon Sep 17 00:00:00 2001
From: Andreea Popescu <andreea.popescu@reef.pl>
Date: Mon, 16 Jun 2025 15:33:10 +0100
Subject: [PATCH 389/418] fix sigmoid steepness

---
 docs/img/sigmoid_steepness.png           | Bin 0 -> 151434 bytes
 hyperparameters.md                       |   4 +-
 pallets/admin-utils/src/lib.rs           |  24 +++++++--
 pallets/admin-utils/src/tests/mock.rs    |   2 +-
 pallets/admin-utils/src/tests/mod.rs     |  59 +++++++++++++++++++++++
 pallets/subtensor/src/epoch/run_epoch.rs |   7 ++-
 pallets/subtensor/src/lib.rs             |   4 +-
 pallets/subtensor/src/macros/config.rs   |   2 +-
 pallets/subtensor/src/macros/events.rs   |   2 +-
 pallets/subtensor/src/tests/epoch.rs     |   2 +-
 pallets/subtensor/src/tests/mock.rs      |   2 +-
 pallets/subtensor/src/utils/misc.rs      |   2 +-
 precompiles/src/solidity/subnet.abi      |  24 +++++++--
 precompiles/src/solidity/subnet.sol      |  11 ++++-
 precompiles/src/subnet.rs                |   6 +--
 runtime/src/lib.rs                       |   2 +-
 16 files changed, 127 insertions(+), 26 deletions(-)
 create mode 100644 docs/img/sigmoid_steepness.png

diff --git a/docs/img/sigmoid_steepness.png b/docs/img/sigmoid_steepness.png
new file mode 100644
index 0000000000000000000000000000000000000000..08dc4f4f5efba6dc0a6e863f7029b7e41a8e65b5
GIT binary patch
literal 151434
zcma&O1z42p+BQ63utWq!P?S<B>F!dH7*e`B2N=5B0zo>ZyJ2Vs1_`Abh8{|q0S2U{
zzh~Tg?e*>V{g3bXXU#E%^UQr;_m$^$UMu9SlFU8)r}!Wc=pI=1jVcI)=LiDbB>(F+
z@QGJ}kOc7b%uH5Q5d`w42Y~`Vf<R}$M}Zq4kQ)aGv}p_i34H~D9y_KYR78M3+%}b$
zc>}t}{+HQQ5DR=61b*{c-4nGv=jE&K)^xphlEke?f1aK%pS)9gOHZzHBk!$BG!xUz
zxbp-4Z+4;2G}z}iHC|;&t>S5$Ke+YjF4MDTxAGjJwv6hTaS8c8D4v04tK+1DbF&zp
z(OgB8U2OkWQkTeD>aL*Gpx}bbS}gZL((Vaaf`tw)u%3V4!UV`Q{(cQShrGMV_Rm||
zzliJqc^CCe_UAv}eD(g>ySxAV@y`4I{-Uskqj|=~3WJ84TF(3TxJ`#hdG){k^UnjH
zOW~fpw6U>K*U*rXB8X8;;RDB54y7wvfIyrNL7$UAuljF-OzA=Q`A6;&*OT$t!&Bry
ze?H*G3H*8o)UE(}X20~3ps$LhILpIjtzSh$BR(`V^sqeO@(VuBe}0G~*G~PPcOcr^
z*o$dsXw0gS{olU=T(mwU=h?e2CTa!-Wt*EeOt}B+&ouwf{r<lMRiSo^j7>*JM;#Y*
z|DWYs;)0wW%9v;;Sg71<O5wJOC@wBmS69ysxZE=OZ&5w&{m*_tQO`CcyguLh@Vd6P
zwy3Ge;JfkL5o;dE){pfAaEz*|ssLvvS;_!?!D!Lgn0j7bUJu$;m9Z5RpO`2gBPS<U
zNC0{U{P4eJJge}6)-m|Ag-&rv39xa>_>nRtT1E;&wI^n8*CR=RPvbK(%4cWwp9H<`
z0Cg1=6@`4E{O=1$02k=~{sC`%c9ufRk}ODJQ~@P~R#>BRp$yZAmVGnlP+*{^S7OXj
zxU^)-g!lJGev(DCQsVlzh_iX6q@<LDg%LF9!*cDTH;%mNz*LdJvF2fwEb{MOy<%l$
zEiNxlq~+!3XXfYEVoUsj{~sOPU?A7v_$`$3Szh(^>v#D0_$%&>Xr)JH2_|IDjdKR;
zJ_Vhf(*N@}(^wVh7@3*B;J;Qy`ww~qu>ZXzP^N=xmdMQ)(Xyq^826nMRCwEBCUHz4
zB$-Q5Em}5rs|oaTiuBPV)jR)DPORD_eU$xaIu+HbNagyNkU(EW<v~2?k9z)F%qif{
zY;pgn;Ir3JtsND6=a>8Em+Ch`hmtxvNxi+jg@66GSh-xY!b~29OBdY)Z7}%%!u_u+
z_Jln8A7*Jf=JWF%9*@V4{y>^=;y>!rS}6Uvx0U0s;5P5$X{%bBaVE@Mqn22PvX_@v
zGQUGQTg!#BVwzCA+<#;Wx}$Gg$ji%%4kEW7o+#5>?j@oS$h1oLl4fuIoo(N+`pCd_
zL`wb9-%@)OLjzdNva3+6eFjbRXZz;UHP{N~$EUkT(?kB6Po6ySzP>y;>ZXY-%*uKV
zU+{0-KRBp0{*J3e0*c9vi6Lgf`M(W~Klc6|eS(D^OXcQK%%{hO!;QPm%wWVyjC_qN
z8VQ3iWcXG+V$sf|lTRoFl)o>LeKN@^Jt^+!W@bTYDa-%7SX4L@C}?mwQk)Ik+uuLN
z-*P%YHOiorT37-@$i>tIT>Cd&oo%T<{m*8I|7_;Sd-cd$#(d7g!b0f!;(!+rtKY>k
z^<)I4aFB1>>gp=0+A5M3GLkI?s9DpX$Kt2Q?)O@bQMRcsLA2l$J}5F@G39@qD6J#s
zTGPRxFyd^pWPEry6R-!-i(hTYVt!{)<?!k)bMV=4u$XK6>Hhvc4+NPD`-zP-e{O**
zZnOL|VQ*eAF*9%V<~yKjz|_9K-brLd(V|PM2a(j*zq_8#{RWJz<zkiHd#7PtT~jk3
zfe^B=w6s}j4?+BVf7cbAm&nAx5S)|RJ^?c*$&*iHy8oATZyY0HxA{CSBSV~JYsb!y
z863-?EVlU#c${eVJ6AU_V9gjRh>Ig3r22a?uZV?UH+PCPN?hmMCVSQo!l#0EXB*Te
z^<Bd2?52se3;~ayoct8<V%NxW|0Cu(zmqwk-ERlP<!fbyB&Eu*>H)dvutnR$CO{oo
z_39J=FTs%J8Uw7F3Rv&)SBIV1h8u>HRTh0Uo_kC6Rhyfeu*Dxge&nz%2+mcpXlQAj
zB>lSe_i|dNT=nnFuC1*-P@LD))ZDD<V^afS0c{Tl!9a$%5gi>J;6Emld2Lrt&VjEM
zl>4qSdtdBzxd8^jpgDlIm6wPgvt=i2RlY)zK2feLep$2g?LbK<A<yez4RX4_y6-8{
zhG?AIJ(<z^g4!9C*>C#KZwE$OP<Q`0Jv~hp^{G=5#_$ZJi|UoPTp_6Ze=j~?*w}(K
z!kE2;O@7=I-S4ImLg&UJ^7(mqHpH(F#B1F#x}PMT8~7cKpRJ2uPup(Ehlvu29!6=x
z^clgr^^RHgjTk<`v_YD|>y=n#LeI3O+KPL(KNz$T1}_)(c`P))de-{-=HFtFRqcvz
zH2}Uf?|YyaPAx75yGZkxf3kni|7cvR)}-w=xH5M#CsM5Vp_0IJ`}EXQipw?r7C?o+
zs2du>^7HBE0<JI5=1-ct9#FrwPt<d62zI4p)+`-<s4VgvtozNg(!S|PGb!I|%mPqu
zKH3?iC?h%krxoXh2myx^^WBlP8&M*bgQ;M;|2u*&Spv#J9`lHV<WP2=Fj0ouug3Ow
zj654U`Wt3t&(rl_fZror{Ob2IesCMbUbM)x9pAK_qz}>T;0k7}NbTqY^+o2;3g+$R
zyoHO=+zXG4c`c7VP|SxJOu`H%{{`spQ~(=GxqGH$Mmy`^aN9YAo56CTp*LD(y#>(x
z!?|65Eer+&q#H<bhi}mWCqLZQ<T6UZ#j&h5LkZa<&lQ)_eRdjjo4kQTLFKLXC2l3?
z*`r;O(u6$-J)1s#`Xr~UysI)%gh1#5VO&PP8F-<(?LXM$)<y8_^!Mcz><eHX|0FI;
zmiuHHcV@%M`Q7KJ$CmdtYDSfWH!tkrdO)T!B7U_;1V$p<wul+t*-p`F`8zi`HO<4!
z_|@%OF5Uf38W+a5%3ELs>E3erkj?xQd!bFPL?i#xz{y6tX)ad7ZvwE=nwlD0&)xYZ
z8H|uI@DyVTHq!lx8<ksC#RW!gPgfWH&p2N<Qd24HzP<4@o!2&D`?&dFs36r@Zt|CL
zP0btA>KP1TIYRg_I@0%zYN`CH(baw;O%>~0fbp;683$@7V823`8F*yoKOSjh9M@wK
zW?<0vkX~V9lB=Vm!=R1UG4?~-;xM3hMJW!=I$INEqh^t!^eF@Rz<!!1Px<X<1!!kf
zR8_N)NL9>qwM@YE`GVVWIR7yU+IpA$+c57p$3+RkXMgMTD`Ij$ik+REu*HjuD>rfd
zw{M4eXUE1|^|!*MbBaq#MK(p|9(Is<5e7?o%(*4nBhd6^MlFUdmly|&<a}7eTC&Mp
z1Q07Wy2P(4lT%WT`i!nr<rCS$Qw&v9vKB7Z_+xTI9x`mEx(qJ<#K!1X??c{vz?YdJ
zjW{EX@B|)(sOEzG@MU~MwO>n>MP+Mht1wUPQE2j@1SvN8M33!sOmwQubyRdh<wD&F
zJeapAcE9FFnCJxevUIFPlVVWr@|tkbN)mz~S{>9eEN2qk#6IcwXzO$N-1?TbUsE&h
zN>|mnw^@o=N7=OM5LeG;Gg>tNxOsKr!Aaq{_c?rh!f7(fEzHf1^7<|j>cP`v4O0d3
z(gVwZlrcIG#TSP8{z>Ka2O@Z;>U54XGc%1r=RP-9b`IQ(uC&L-#x}yZ2L(1ouo)$h
zU&WU<=E;^?kB1f=wZ9uzbaC;el-ZsGF+?KkZKRjNXk6cF4DBsk9H|%4R0jeSgn|^6
zM27w?MkCfWT_Q>a)wVw0C{MC6WiUIwl<X1f$?$xlNv~_v@^pctz-%q`hbHAT!UgzX
zLOnU3-7rn0NVYXkF?+yi--kM7Kgt4^AyKU%vGY<shxyWi41e9DqocEJD{<z;zC0iX
zY<RSsr=ezMe4x)oRJ$M?gH5uu*~T0%f!G7MCLj)jWB8z`v9065R6#YsjQm?#N+K`X
z+}zpc#>R4ifN8jucOcdVB=*HH*bb+%re*?=?9zgPSlx70m{U>lR!T}L#`N;&M6(Ns
z2-^?Oc~;KVjf@t|W(1XhckN=8%1yg!>uy8QYl{Mv%D_jizs00jG9+x?cH6w&%XRgV
z9JjHXD-TMz#Mgs{7Al(5GMUygX1hy~lDQcDb+pfU|I+-hngtD{AfU_-G*3S_O0OS`
zR_=}#%Kf~J8!X1*Mjw8*<SNt{6dAYuV`|m8p~kcW-)~EA0ofT&ezcJj*~_D7;I$gx
zR^>m+<2D0@qX8c@QU{%>@jkLCGi*Y137(ZX_{krv53L7cb+z@`9X-}!Xn@RB9X@Xj
zX87H(4}PI4PKlh#DPnD=IR$~u>7ulO66tmsUJNO-=EhFrZUSwZ+l0>9GWE4UA-PWn
zsg^5U3#{o_*AKA7U6-Ws60NOJW>^$$UVgsK`7!3wa3NLD1t`+;ur=K8r7tpRaG%G$
zfFpS;K#?$KKY55A73>R|x<Mq8iAU}G78$*3wRLjt)^?A70|Q^!5ek4IHj5X}m!45f
zR1b-jXq0F|hSEiW+_$%{Z}gkjf$QmNqV48bk=f?gUw<+Tj#Lybp8Duj-R2B`$zY?-
zy?IvrkK{#Uz+Q}RZilRGc3CycOA)jd+Pq6iPDb(0E=<$_w$yx4Sut%lyUh0v8&I(+
zR-{nm3}yl-2e+bqa;7l|VDWBy9gkgFfh&QG1HXN@(co#x|4`;oh;aLWdQaMh@R!Wr
z&X;l5lY`6H&DIE7a8pnc`LMUSPuuNT1ex^Gt8v+Jna7%t0S~~_lzDfQiE9`Tk^}=H
zxg_`eW~rX?g&FoD?w!AQjv<=ZGOhrRe}ANLi(G@$ZsPmfYMb{1__~Yr7Lj92&#ofs
zr85o=d3S$NX!Wo)Qt+v{x6wD6^qPEiCgYpF*SH<TILcxElrO2O<BC8s-=sa=qBnoa
zHN~Xca?0F2!lU2E`iWY;=|Ot}CnCQqLT$U-or+qoi<6h2XTqyrXf5QPd~k&Cx=~lf
z2y}LXZ%)9jdC=`i@WhN@!0r*Lkv*9-yOq8}6YGh)*zvx%jJ|{N^S&5<;`qtXZu0P6
z;Qm;YXFFVa<%{$<74Rmc+e&IRQhF7hjZaw%{o<55%0XclV;3YeFP!#(%iY{gdR=hg
zvT2yJY-WFNy_wJ_!!>16fJA3`!Dw#5rxJtq#!$@+H~8n+Qn@iFI&GASt3L|pbb~ck
z&kC?CogB||6Z-H|qGa5pl6H2%%M~8RCwsr$x*SSI`s$8n^V{a9J4Y5YIypOk(R4(a
zc~PdAP>gy<AntYUL3g8ewp5mPHoiFL&=E738Kf`uFH(<#!i#U(ySuwjIzpk)mIR=1
zML*ryE`Lgsb3j!eya0a$8dh7seDZtY7PheB3~%PbKs;Zcrx<E9c^qVZ%WqRi>{59a
zne&!00yj@!f2GQ*7h>rqV&yI>+&@-Ni?NPKO0X!JdpMqOj30kWXp;h0oe@rF{vc!9
zkSbO>W7C^Y;1h}*AhGz$C<kwhw@1XA<i8wu?Ss0!>{t^y<S-iw?xl1Zo#hMG50X?$
zF(7P<8?ESrRQEyJW9lqrUQp05+vwPYebjh}U(81#bVxy1bX>8BaFh*?u6W-y`u*o(
ziwl|AcF=RUNo=2GH)Lvshd_`Zg(Apl#YAs+wQ`S!V21FXFoC3dTU1emRa;ckG9G?@
z7HqL?9SucgnNWI{*^df6%+<HT1!W9%ZC~#L>A_rMQd!}~Lb)w7Gjn55fnrK0kP3b`
z=5R+wx84dAbDJMa|5x?j(@$PJvU6rtTYWWT^UGdvZ50|MiH3oD9TS;Gd8MB0F!s78
zGK~u=F-AxTDhz!sZ~IKDkpx%WtxMdRt8*?ZLX}p@h9|QuRFsO(DX73i6&oTVf<+Cc
zBh*(>qr#n|agY;NT5B}~aShrsbe0eA&NwIS{qRlWmzg)dXEI6RXaotR3wPQI#nc`x
zM!hhzZn+08;!`W)OHox+OCL0u$ufx?h?}weA{sVTU9#Lz-EYB-$nWTk<Ot~Ei9I2l
zOaeKQBv>%skN17h^Em$ELC*qa`f&(##DJ~afJ?4LaueGvb8CM?^*-e~m6019#axiN
z-Mj|qOdZU}j%r|SAlN@%9``ZUkp#ADO<twfsf(A2-Wy`J`E*tr*4M9Uh=TMUq-M{K
zsl~-|$wOcvRZn`3XqL|2mQ296hY<;wGphr4sND>!5syIO7Kepe7Ps1Rst%L8Wl48Z
zo~c${r(iXr7kG$YmrWe)jI57+?IKXRpJ}xEy5$(}hEvG&;2Wr)%#dA3e^i`(a&N_S
zyh(B|pjAnhaHo_ao>6sOE8Gc@xQ~jMgeVM)$CH}v+aQXTLW`cq(cdVEjNn#A>ia=-
z4mIaI%>L>2eN@f9uCjGgq>brB&fB+b)D5JD(u4u51q;9!mTO@vS|AKW2n0O4KRn~m
zGRNBtRPYf3SOI|U6jxc4%?mohi)ZFHT?~VhV0%xf$LqtY)#Kdrt5hvrXBqe!DE{Kv
za0pMSt;<umwws4Rn|pCu@)d*RX1$o)9v8O9m#cbgb2coitn|k~hO=MjXeZ>IIm$NP
zxPs9_y*M)W?Ux6l+pW26WqY|Wy>&D3W<o;gzzg9xGgQ1;WW0qtttof^?>Ermf$f8<
zL=cEV(dtL7=!@D<%Na9`;czJyuQpXZ`2KuM>D9(YDV|ZBi%F)m1};A@ug2X+EW?}Q
zC3IkA(W5byhxP1DhcPG=inasM@KroOOojrx$-tXxz%lb_UZ}^j+C~Uvbg2{~Q}6OJ
zZuyetr#(*@h<0@&{Tx(N*Pu}HlpnnsbaL42aqZNinT(#elWsa7$2g&&Txpq4Vw+H)
zJ*tYoD)$4SXbE@_A&N1j7G>cZl#%vrH1U}O9Ezk<X}xgaxLrrrdyfSufS2)B9xn@M
zbW+UV%xyKJ0JQwG{tc@<)THRBLdKVPLRIgLQ^;gp8*%mgXLFS_{5ORk-aU1@oYDtU
z34=Sc*i;Lf&GQ0<2i3u;uNY9X8yGChC$KEemtc1WqP-tb_?rCqI?{do8vXg;Ymj`N
z;1^!j-2)~$ae2Nr1%!7oA>Y=Jo5N;akVh>7Qu1x2m9wSO(<(wqnOQ}pQIC5-!oU^T
zQZ$yvPR<I6m3#Jd+`UDM`gap*({>Wizr60W2}Sy=NK{Bf(L&XZk5oAI>8@kZ6k4^i
zt;jT3{!`i=-C&x8idx~-Dkpzj&=~_+IGwScH~2><Rf4V%aaEZ~5gmzqbKOVNWelyM
z1wSoZ(K$s`uFGZC5xyP=b6Os*P%K8ZXtB{0k6J1$=2C3z$$ku<Y6%F?-<ksOBfUfe
zcb)PBHr*Oo0LIGavzy9%^(>RQ{F`c|$o^*~k-c`9*VCs@T`{$jHh)T~GKcbpwWkrs
ze^on;+yh;%xi<nR9Dtgd0mwOO^w+ofsgs5M;4PoDuH~0wcWxOW``@$oLWh(PLd8V2
zn}DRyMW`e1GDt~w*ROcf(19W^wA#^P*c06-K}oAzMU7@|$ru2ip$8`?t9FM71bNXs
zfF8j;Xl<I#S{Gnt&Dz=SFGp*ZDU=kQ5j@`kIW50+uA4${KON%1%szYs_-uhCUQ@j{
zHiT{>KZ1i&eyF;1hq4n<%e9`x=Jpw;nD(eedTmUPLPh+Oovf+!hE@^cjdn3@e7~-T
zELba376$uQ0xn-sdf=V_x!zkKY1Y>P!sO&Hps+uzjPxt*a*h-|{tBS!w`)dD=6%Z9
zzWtH_pcC8ctII!lSiqI9V!DV9kizR$TZa3J8QI}s+{^SERFjgDD4=YfAmg!(GLJjh
zikR%~#iDfCoJ;jFZxeFM6^N(>qzi>lyb|dR9`_8Gl&2T@$SaRGXSMJ*l~;_nG_O}}
zQ>CT2#XK_aAA2A6L`W1`MZqV`$qgR+_}+VR=8?~D(;*B0-Ao1>Oi)$`VWOPAeY}7H
zlM_NX$ZYvxn!RrS`z-}fjA@9r!yB8w!1rDkF|s`&x4q-z`Jzsc#8#C2iP?a$0UzUd
zoGL~YWdelZdwHnkhm{6*bo6{<CLn4O*Y`u~1wT(3b~XMy#>{A_s5rHw0UxLbx5ubZ
z;eWdQZ3L)wy*G;rTnBh3t@{#Kt61c>Cd((!j<%N9`UVEZ=R6k5B7IkAC?J3AOIq9D
z+_G%`)UEcGkAKEb9&XpodRsTs?;2Gpj9@i}1PgQq>&(&Haa-@=<9nys-^CI+%{Rgh
z8P7bA?fgW})d%{%GWig@v!>ax^dZwTjmT&8mWk`|B)`Ab3!bTfg!Yv|c1RRmI;hkP
z7?anOMraG<-4V0519M3tbZrQ!<vRI3=5}U|k;Ocf(1b5WpkFicgg&g~14G;y=cs&?
zc+H0PLbPb?MKBfXgZtmD$3s_mY#i`~p(viFUq9|*vBbk!m!YE4QUy0Rx8CmV;aqU6
z>-SraH?TmPk`kee;A>a<T}nc{cpQ-5#`dadW|JoN<X>e^shreYHJtc_YK!hJ2r+Ig
zpE>p@uQ<^Uo!5&lO`46{x*4r9qn64xT&~np<TD1-a_+i_=SEs&l#0mQ=5z_OB@8}F
zfJ>31bdRKczVOw+3;8IX#!aSgxT4>{Wf<z!+$2I}xP@YBItUZ(TpbARb91gqvB-x%
zFA^j38M|e6XL_e+YEVX!V}i?_XVr`{C~omHo$)9}Ra)jn-GShoeS3T!_3^K-OV`hx
zT-pJ1@MsIV_o42=Lk6X>cQ^1Nyaa(RiacAxn?!x*J2K8B*#6I@mVv=Q2O-eMdB^#^
ziUnF)Z;(==dHi*)ZXI13lVR<Ad<*QN+<)WU?Kzj97NY94y5Wn*IfGkug03cmXavtS
zi$Ro2vPk}yuY%IRTJ?M}sNs2H`H8w(>yicGO!mHeVBj2uzGFs07%R;&A&gW5&OUMW
zs3O<EuOXbjTXGp)Uq08Hj8CmyBCbvALA`0QD4mPqqEyW{=yj%e8X-zvX(hvgld>3v
zRAg*gp0<ebrL&Ll*Dw3ife3tVqN7sAe$5Uo@%z?Q^S*}Lb!W_|XPHGI6fw10GBI>~
zE!9$X6)Yjs056;4IO^G+MwI?!VI4e;LSh(GWzF8cd^$ce&v$8L8+$b}ky{HLu!(pR
zaegGim!hNy9)+ayr0oDtj1VC~It{8=SS^lm&D}RF<G1sY1JxhK+1yZ7Y~7UWbf>o=
zC+1<?0=jcDaN6w$#FYjXlx<XM;Da0DnUh1e{@t=8vr}O%t@UZnNjnPI=EQt_&kmVy
zr|zy1?D7@e-q+ZYSq(r^+e|Qe#~sJ1&3!tP8<FrU+Q?yYwsgV`=X}tI>^#<NLZJ$;
zZJ|g+on@^|<gV?pZ=<A(2wG?$cH-#knp|{G;w*@x_+w7OrX*#^^eY)tKI<ZcOFfOr
z42fJRMhV_UTqQ`zIP-*j&|P*~iAHmxOr-1ei$?;6w2ps7+L{@v``~h6hrFg>@wDDq
zl8^Q41@}OAi*NtrYl}=3@%a-gQT-#t4;hHlIaZt|7Yv7$+iK?AcBvv}-E1w&0k)9g
z1>L8$h+42>^e@hqpf(Oy1cTy%8aIzPucTGJMd28F?TaHw*753dUU8u7FuTUBT&4gP
z!I`AevODd%0}-xYbR;ViDjSp-;WT^6qa(U}T@Y6~E0@$@-4P+X3nJX08+Y{o_#%$N
z`Pu8`^d7x7*eA7}(UsJ@orldnG&pk_d+&E<ufO?@7?&T^69hM_AFBA-UNG>Es`cOD
zwv6z5Q(nin*|Fx`gq$rDeSHnYfAa#pgHbM5OB=*mf#n8|a`G%6;`QyoH^h~|Y3F_b
zWGUC8PFk@PQ+tnQ)`qW<n{g{{Ux=zfDQ8*mxO-Q&7X|Ldy%TbiEhxOlPYaZ}P*t_T
zM+EeOS~qHH&-hWgmyQ?fuiNrm3PdwQbk@VCFY8$TL<+s*i`VBjj+zEzZCudg9bXPH
zdylPCnNz+B-rgoUJ2F*kGPH(Gmar=B>vc^eY~F;+TqmUG1;`JL$&6O1Z@a1#fhLp4
zOa`9I<6X?@4N=JrYM$kxGD#|f0vc!e7#HYB5vDzpzKL<`Jl?c6)eyS7OKV?W;XZEb
zTwRj<3v{Rj2H*M9;WHkao;>t`PMx&XbEPZ}XQLyneb;2Vw*7a1QI7G~iI+|$!;gjL
zpe`GzrGr}6CDT<wuFpw1UoCXJhbCd-yc3)3if$+Z)1i*Pxd1D+;`yt}jy|r2(sfs?
ztZLMXL#prEz<Id(R;FLQXc7p2=i;}xwlYxu(kuQ2#=EGLvGw$XciFcSm*0Zf6BRg3
zd2Y{FyJisq`19Y*>f5FBjT+^<2+au-4;Nvd{e8}qZ}+6ybXE4WE{B@Md#EwfTG@(0
z&HAnpSB)z!$v=BnX`kc)p{C_q*_oPI+SQbHNg9q(OCoE9aLr2^J?g&hiR>^tMMp%@
zTM(J)_rg567D74;KTWtf=9jxes(oUpzG}4avHnjk_2KAJjGbZ%Cd!W15{DuPIBUgc
z_oLp(>w`8T_xGK_7dH3)9Qgf+--l-~Tha*c<z8j>tGfJEKYN9pgLBOJ5%tW@WFuy^
zNy+G|SGGSVM%-0ylh$<Y<ycaUUsaZLfL*DE7sqh<ssi{flIy6bU*AuJTc#j4cRx?0
z)r~$Vklhs0qKsOP?QKGeW#svZK{EI!#`hc#9k**bVyc#fh-;Q-RipbhJR`yjrcbFs
zOY{*$KnF5KmX?dQ{JixB(Z+W?>Nr~HY<+a-Z4P=KUS6ll8vtftJm%?g9XY<e@I;G`
z_vApR?6;noy-|*)`U!=n&ce(=F0SSfy-2LS7s6+g*pKfd?Bn)Y)K@Q8A6&7^=4RbU
ze)W?6g_eZ6>3oBX{{E3ql;9bP#t)%4>j&GPS>N@bwGbw*o{O#F{hnn2&(da|cAC>2
zig4+QsZO&HBt-Ds{+uEie3Omi<NNQKK=-)DqAvl~b#-}ep;NgK810CK={Zms+q0Cq
zaj{2Q30s0vR?1h?U(Zz!j5AfV5-#Ne9K2h)cqD^h)Yndz=KFba+-Q0ao+6^)Ls!Xg
zDu==eL|uYEtJ;z)`e6DL@se5DD$k<ZeyUIwBtZDxx|9w>RbEqIfLg9qpO4Nhqh5kV
z9Hb&W;XKdjjz#97*1n-U-znvXg`l)nIAIjT^{w~+^cOA;hSVNlJy9pELxryG36?Sd
z&)Y~XI_a$mFPmBaHeaK0ef9lX&8@JZt0q?D;o)#t`Br}zB$XuR%~(|pqE>}yf@+Lg
z(G6e6&!bLoe08D&Se}5e5#Z8m5V(Q<Kr$Ad6+v6ZpO70)XPbxLLh>a0DuNp`7gNoM
zya~@*iueev)RW^3Sq2e523p;p*_DK_Sm#=Q5)(VSmY<(!{0(4z#$y5VI*lifPTTG|
zty(FaMRU!mb&mPZ1Ael(WgRT#(~vVCzRW%h%}eZsx;U$b;o^P3xy)~tBO0d~OV4Z>
zI+ahe_j?Y1m1zEWV=PWRrVc<H79%EV8hyZHe8It%X`k32s&eaX!*7)BJWWI61}_0Y
znbJDGdw#e`6rhc56NNCO7Xp0}pe5!9;P(uF$Tr4fGn0p*OvzeZ@$u$<65RW2)ZFJ&
zRC`;!RYqu_@;Lg+H=mRvW92WoZjsU76ZJDYAumzy>ESDAo}qQIR&L~}i$WvY5aV#n
zti*uwz%$5QP;iKL0+TN?!X0AOSW_~GjHuJj=HuxugWLlz&(6ivP)WwB=ElTn%j@cn
z;F6VK$qoV(5xFz#2Sef+H;8`Lll)DIAl4Mv91Xg>eyEkO^m6z;Qn*W@YU@?z>x}6t
zeFr!O!-<KVu0CqinS41Jt<<kzTozs7uV<9!Q%qzn)9NwiWe}95Y_$pj+h>VIN7EF9
z`=D@t3US-$2yH~tK|Jc@g;8Y@AInHS6Ye1PQ;{T*JkvDs-URWkHMwa~Kbov@mMooL
z09*v_m^-sT8_Xc!^2o;8`mMb^Y^UkOP%%R+?E~&J6H-!Al|KXy;)!z&qC(aRc9<PD
zseleqJv={g-=gyK?sL|-O}^ZF@5z}-&-#&3EL+R~S=yau^Uq0*H^k=jTwW1PQmV_Z
zY+#_uO5pLygHG&{t1yJ~v!Iw`p=vhkqSD%Gjj}vS$`D-#^IsE-9J$0pS#K~Tky$-O
zszt#&5jacqgfh5~&E|!7zvTceNfn^{Vq#;PxI9@Xzw?m(EhpAS94Sz^q$t;4&Gl73
zYP^zT4w5)41K9cPkn8X(iFxa1Fp<8Uk=Sbc;Zwl^XJXny-ZDi*BSK<`cN}dk>gjFA
zXOOOzS-u)Rn&cWy@T><&agIInpiotvl)S3CDMvrYUlY+=QF4Hz$)n0y)_I!oBB>ql
z%#X1QDWL5W1CVKgp=q|0uyJIbJn3IIc`SNKfZE2dcW7wc7$oZnbY)_4len!^pJ4eg
z#Jwr!0ok%+3%vH-`KNT^R1d)w1-1*rG0+o6^A3Lg<W07*y9@y`+@c-r{Wr~Y5;SXh
zHjY1>*VL7r79OO>#1z}!?c7>$!H+Z9k0%SPq~_L>2qvzX0Wdz{nY^FR+yYWDQTYXO
zqpEq3qM-b|j-YA^S_mM>j3K<xlJV%Xzz5-Sm~e3I(1SKQGqT<1)&GCk1*S@Npbz;6
zG5`t4ls-zfSa)G;zVq>NujL~a71(;aN{a&#rLW?`)Lv9}aP8cM^%~11x}98R_0qn}
zxj#%h;c85~M3``Aw6VF4X3$DjH#NS*fmC5w5Uo>FcZ<W)%+g>OIiU%${Zf<1%je6%
zAyA%Xva5h}r?pYbLqk+yv0w26ht?%O-Q1CdIK+9NXID_`)UarzbC89`|0fe6)dQ;<
z9H3pzs~7gO7M75~-zhSe{+HQHbbdZ3W}>~<qStNS=4<25)Ajr|*?&ppc$a4Bii_4O
z3*$D^3?`Z+pE>Uc7-(@As?9N~Qv`D6@!gjnwugwum6lO`G>3*NCMP_y)evsd%jR2P
z^atGlwT0be>r4%%@|I=Rg2mCY>es)8&$*|hDy=_Q57_Tv!234%<A($jwt3U~Rde(>
zf=O?pJw8qIg0*3LI>)=^YT;d?kK(+)+3brsVT^p$6Fx$J+|Swx>DGl4RlQ9pN&)A-
zh!CYjd#2Pv_H|OmH2WBwFq~Q(`CYi2o-T{uFg+9!ZF76kzgCJ3qM6LYt(cr-Zw<VN
z_8G%{_2Z}9BeUL6Qs%?<hsv@skJt@M^&FZs@*z}iNs!Te6(_8?hJzL3Tf)edE7xr;
zzdx2f5-TgcXl!oSf{XUHi0{3)^xUVb;gbUarFcWW(44n%WZmy3nN)`$W~l{Aey~wL
zW8A1TlCpJUC0rYYdI7bG=7Vc{mrE5tHSW`Ge6V#UkWk9Y!z`Lmvno~#ikbpkqyk!D
zUMWpTL;Ux5BJ*WQa_lMyus{ID!Jiklz2c<RXHVW_Fe;{cgn&(-%0})B%dt-)Lo(Jf
zBRTr24o?!KFDKuLdiTwEx1TDV<f6}|Vh^XceRace$TVIg<jrA_KCDO|${ti2Mzvk&
zYEq#R%#bV3kPqC+g`OKQ9my(@?>zuXlM~m|(DCY}XFwH-4G0^N76eWbM?gJ44nUr@
zwv%kEM$P*0S!el-zU|otm)0#-78Z4HZ=rSGz}IT3suF+59I|97OuHfE9y2aH%-5kR
zjp9RNO?l<efC`yYWqKo_wODx0bIays=(ys!2fB75pJvbnC<_uul_wauoUIw}8LPMV
zBQo<mQu0oc&3aHLdUOsezm0~><QQ_n3>NJ%wG8gGwx^tTK``DffS*azUNN0}IGc;I
z>f$I}2KWb)Ky%mtOVq-mF6PPkK$|~5hs_1(91?jp0RYVCQpXp;N*sdZzZqb!B&>h=
zXYS`~I9V`|`YRHSax<M+K@a%+7C-n{FgAybR>cf$oyW4hu#CvueEas=%@|HqRDz6t
znwbXpp_$Ia%^&^x#BdNXpQSXbd?PB)BN@1}HqEhMPAIS4bCc7`Y=Di#BJ+BvdZa0C
zw$`qFl>*%P*2lUTw=PPL4Q%HYU>sp}vfCcMm9lU_|0k^gb(y$~_trZVBo#fxFQ<q<
zuc~d50K%gL4l{|?RZ~dDNPzMg1)k5xo7pOt*$4?ZC5x7A&B>bes6OM_-tQg+Ph;T6
zTY(>!zi4~6NO?EXn4H^Jj}ePCPjcOZNEf@x1-aS;WvOxJG1A)NJVXCs8hSUy&_-HW
z2jpQK1zgwDJT})-93}wr$>Ee)WRGPv`fRIw*X;_RsyI7>XjA{2h)c$K_4dOt&$s(p
z?y8Ggt2{CbtmaHN!p~OD#nsH}MPU~uQg@GHdlKmtZ3o|k0xdCgQofL1foY;U-bK?O
z_xD9))e^Bmk{)f>{e^@(pfhsrt@jD@_CjNb;}4pQzNsfLR(JUVOW6W*G9g}?iC(@A
zTAjOrwgcwa;1~l?Nen#Z@>1*(U@XAq5OA)SlwV{EYY6JamfnH>D3z1AY|RSWSss0%
zte@i2bN;_`Ui;Z^&7r6ZBbkj-51!A7U-r3n2;<hBHzD$U8x2K&_}QyL`TPR(L+n{n
zGf7gwpK!=j0B7UC3wGesMNQFSj;R*5Jo~k)j>jS<Y75L|PuZ^Ua6sNbX2IEqcC`Tr
zVQ0tima==~d>hd+RMC)RY_mBSN)E8pYWy$H>Z{JqB#p>K0N$VzK>ES(D5eTTf57ry
zjoWoJ)n{y|BbifD4;ULL1#|4gS^Uh-+q|pYwDeDt(4&X#cP9JnqbMkp-dU@AXktd8
zczvW5-VU(iJivL1HLEYDvM~{~elFbaBCcbHhfhwtEiRs*G&(>zv7se(km#f!rJ*>>
zTrj=(Q(Vv?Q1ypFfF=%>#TCv!UkIP~mM0SXovAQ7rqyybZlZHN-{f<YLw&jNd6Xyv
z;O=q#i^NPUVbP~sd%G71gRAUM+|Kt7ZUl_)+5lc%(dqHVX{<v+7wv0-)QK8C^yWSW
zz^r{nYi~iGoOQHAl2ejjTi}q*UwiojB9(LC?I4Dq`=zO!UFXn^Mp@>A3#{a*H)W?D
zHGn5@LD*6&%nP7%h+m%${mmJe=#6K_l6MfBO#h<pM*RFW0iR~%)`;TsP{*_}-`hne
z%msXAmgk=HKF&>vTYm-?(0}^lIcwQeS@0&|v5;T(Xr3^G!idH6Emy01#@al$S(`>)
zHjP+A{645JiXTtP^5%_l5!J#(c_rm)AGU!&A3oe<lWr<0Z$=E+N6*>A{jr3Z^E!Y_
zt3}Rlzw!*LZe$v$4|uiZd-3&ENvHDC8qQ@e-j=i5H)^SLc=(()CS4cBs-aJ<>qX|?
z=4>5f-YN==nI$VC;rI+2G99t;miwfnfmv9?Z3OEsL|0s9Vy28}2IAH%!7kPJ(xU0o
zqUfigw01Zk$qyxF1my4;MLN(c@qtvq*gwQ~4%52Ht8x}8L??zX5-5=U$Ls>8LO1SG
z&z77yUhp4^vovTwUQK)5PjUO+Viar!E~(5jb|~Z*!Jyc}mQ+NPmwym+gJT1T9c5+6
zv)h0u^57|X!<_S-d~IxL=~UyX{e@zwyTb}QMt4EJV${+AUDeKxj~swHF54pwu}r(L
zxI)sAW7Kc^;DQxH+5$muVyO7+IYSwg@e6a~OAnZRn(G5j7cx@-1;2N;KMyS?xaFfD
zU!8Q;^IH|jIMUzz75KV#!3tvFR~nBAk}jh2wd=DIG-b6L>JF`~NQ<VQCTJGJ1Bqos
z5?tLd`Q3c;vou|F_pQLIU+0(lhkv>W55~(JibY8R%8@$284Mg>mpN7MOkL~iPn&Bs
zQ>E{@O%sSk5?b`zeffBl7CNV^qc^>E2ox2Y^Wah55%9O$9FFfk=Y=aGlW)sk7bYHi
zM?z0YQh50F&K&EqP6d&N>OJmLMDq26H?hkg0aD>(epuIX78fX!$ikxX5lyw#P(Bw{
z7z8Ci!?!EkssQNrZZhVW&e*;mK$y<>RUzh1ChWg@FMZsK$H*@KBsA&QpG1{1pZI4Q
z-~>cMbn*>O6q8{ALyTk^Cn~q2JehnGCdPopzz;2RR=yku=!`}wffEONqX&EWTy64K
zwwI~u{?(?J!T&dm_Y54WYl4AZ*y>Nmr7A~;Lg6g(K#p2rBf;vl>JeuM<L1tHatxMj
zuX3IF?tEG3T<+bMlbR7-CPP1j^ep(&i|g2rfL9r)v10@~HS5$wkQWgjG2iSM=LREX
zL7<$!;lgKNp{af4)3zfg3!o<`(@}TbY?+o`wm_zJT$DO`1ORW2#=){~FALds=8LuT
zQoI!ortEaZOp2SMjTB1sKwY`?#t^r(!$`zblU-z9JTyY`%rW9{kwWsII`0Ml9v+B8
z2%r`K#svb!c)Mq$0yxE!ot`@_bENOQ4O$LH>Z?R#5ZGgl36@-`O_2688Nw^Z2ee9<
znOCxfIV}%jZ=ZED(;>kE;?sDjTULV@M4p#j8cjq2aquu&Uy`~fUP*4(i&_r^lBW6h
zh{mgE>$g7SMxo5)_vRS%67tIJuWOTO_AYH;saK?=0^EWXAN<m_6YRycVbsS+iz-HR
zKxd*2WP~<}_AQ7)>ZJ|ZNU`!G#?}pq6L6h4;3Rw3*%Ul;OHj2g*7F94%;)bR8I8J9
z4GtuQmS(bx$q$DUNsV%JeCL3Zg*^V?#QOf4(_1_pKy-AC;=>Di<UR`IyN;VZj0~IG
zhb&C^ugXzBD$l22urH$UkLPfTGQcnNe8z&MU6PYv(6A9!4~hS!hi#3@gUXjtNd1Sz
z-YF#?26PeYL{1jVX@X~~W7j_e37z|AhbOX!cD#-7e9&B{51$Bnm%1kGQz$W!y-Gy|
z=Cw@9l~3q;SA+5OF7?>v*!+03&fpL1E&ANB<2V0Nx)^<dO)am{J|_z`=SK_|?h7?r
zoV=fw8<qSWJ164+RnH{MUKrOvZ>?J3YwsmJRzoTSiBv*1xF+bva9*zi+MyQN$D1$@
zNjOWY)~M7I;#U^p9~w?&=`o>!0p|~(F$4>baTm2)Ub+hxP=XHgii*H7aq&`*U9t6L
zkfBB2(@!tT=Hv(z2T#={91gI7fT;F5jQQO3JFef0V53VSO>9k;pt+3<-3+A~4HZTx
zT>WK0e<MmA4L_6%2kv<udS@-OJ!s(ke)s|zlR52F<ZG<8FRjTwj}0<;NYIJUc>zEz
ze$4Fb>!x^Ec(P)8p+?C58wV7onzl^r?&BAo37b1jsjp&bl<6yASu`e8?YF}ZKHLRP
zvN$1#YIIP32>DP=NnH&1X>i#OEA;A9biA&7%6U?a8yWI~0%DS$^~p;$i@8#7+BprF
zWg3W<pudMTf<RhJodl-j<%jjLRfEbK&}QgDHEOjyg85tr{aAgYe<hIcJy(lX#(bsD
z%#CKMQTvx<<)jY_dI4bW<+D5SKEk@F30)Kt)nb8EK&OhJzxhg9t;-g<BcyMGGTHy#
zv5+-Yyu#QJX?Dgdc8f5Wz&#Snb^DkNKQrq^aY`C73I%@<{L9eZe%PWBUMNT$!t6m7
z<j)HUYK{?)ki(5ph+ja;^CG{DC)6EtLsCp4=Z20ia3!e+qf=*x9)SYQB>qi|q17BY
z)SdM#HcJIaAoSbEY;y;Ax5^wR>w&&f3EC(+{8848W9zxser^s)FM{JAPf?y7jK$VI
zOM5i<s>&L_10i!|TMM}AnDIypE)3G^v@#cSVFv(dAcC9!_Jc9nQU_a3%gfb|dO3&>
z<WDA3>agwij(7tt-)1GHwC;BlpuQ^C^Y4C$T4&`*NP!RXaC<D4w`Vm!JCGA5YKN{x
zXd~UBA4qm&CirHav-Tzq4)OD_>p4f&+yWWD#pchI)4zFnK!=Gl1CP!BrH3z(`I~k8
z%f0lLYzp1baBY>j`mM_PDt(`1EPzhYjnm%$*#aHpC+r#kwTSd$?-`uTiM8r6OID}g
z(7Yyk!+Kf$+Pj%4;oFhaxgq`Jb5^F$bkL#hm~Arw$Uin0cE-Q+H>)zH#%Woa>1pd%
z4wp5BKQk_^Q6+Xd1%;%WPvK7pNv%@TqGrxgimylWkN4}Vu9JL2s<w+Lx|hR}nyud$
z&0fAshZJvdE_mQGY!*Ds@3tIHCM2^3F#b9|bOVz-yC(Q3t2q%2@6tv27Y`4A<4mtv
z6#}O4QbGc;81v@VR;}g0)25>dJyf$_BQT~$g8wNlDXHiQx25&sk5Aa?lHVHmSp9wA
z<ayHb31Zc4l2145UiYyH;kJ9-8K1VDR9GG^ocO^r6-d<lyw@$uY;8lB`DrhGmw5cD
z9dYAthH(N}_>h)-fS@(R$7kW7(GDr-1su7IGi_oIkr0r7v0*b3iL9xiQwl;E)$LvG
zA(5PntHXlOH!no<$0sLkFVBv2Tl|}-0xp~`0c!CmmYWI&xfT@{$IxP7zdtxt&_`g}
z&Dx(8W+(C9J>%lw273`bNrtsPr(4MOZG&?v<$jU-gy_)x4`;2r;VEl81frVW@7V?z
zGXahH@wl=E!8d_A&bX&)BubkS<f`e;0`W0yj<ZzW$z=s-Wv^x_7_rNYVST4(WK=Fo
z`y#k43n0Gg0jymu2&71aDw2tb>2SMxXcNfDhk*$jEQ?@cuZvpC#N;^xJ_xMp=EnP2
z_>ZQk#|8ugIp<O@y?J`9<BZN@n~^!vfN<tUj&)Z*mU9xqB`43uVpXHN@S^<+9;G12
zW<wFfR%)0X(;c!^;B*0mAcKjuNu8!v=FD(yi~v0<6(nZ(Y*h&IN6#p%W=o4>ayW}6
ztm?uj9+Pr`u<&zCOiVVG8v`(eRNUP!@P6u4TVf}j&Q6B{U<=n*CpLC=V?c^t3zQ2?
zgut1%RtS7Mf)-b6>oA6R3>9bW1Q?b*Fq*7?E(uRG9K;bJ6uva{qnj;e(s5etAS}>S
z6xS&5L>AH-lh_jIp2^1_7JNu>KhF8G0@N_0QkCsc2oqQj)LL2jBB4~Syc8gS9M>=+
z;EJOjwcP}A(elOS*S>e+dHyVRzk}Vsa>xtTxFghbvEK*GD~{ThH|0}b{KTu8wo}Jq
zQi0F4rY|Dv_wFR!wIB;Qy5%pGX?Q~ENq1GP`5iYcRVey~XIR}S%5CRZQ8Wf#JxkRj
za;dK9+)xB8FjPBXf*&AcmQTo;Y;7F)D4;KV(cH@fK(;<j0N?|G%{t!;OD{21$90UT
z=!)9oTKTNsh6X|oj;0t$4)Qh-uwx{E`94_7l{YUB&r4u_5unpJNX)uSEIL{rZ%=yz
zvpM4v6ZydO5>=TSw#qQBkSePvp5g0^4<Gt%{R6tLd@NcLh_!R_{DgSlbYQjfC$;Er
zRf@%Tf|q)g6~W^RR{fgIZD2Z_oPL~)JS#%ovxC<~Opb?M_d0fL&y$=g&r#kAfZq(H
zsg_XDIY(Jw>@{3HQc6Y3s*Zi~K964yk<&WjVNt$s9`jx@{PUhU0RK&0U%&Kxx5Wq;
z?~wh9xr?1Us%gfiY8(`sGYeV*o8ipN3gX;ZbxsB4a*^syR9eU5*`KhCCLEF5yWV=W
z*5~x&!EH{f)cd*U_$SrzwjOW6tuG%$=z2F9dT$2ixdAq0l%wn_pTWxKsuHcfLJu?}
zHhS=>6H4di=xqbeIq7U8e<{l+h`(rqs`hmKX%#~VugTpos9IfwYZ30dz<h<I?DL&Q
zWncm;#AT6^(Dq<$ASM@>R|V$CoU=huv;ao^FSI{ML1QN9_er!5LY1Q7PHnh2V}P^?
zGm>`)AZBdk4mtmd_^yXxJ^OupGDa4nJfCjqfgT4IEw%rMjI{Vh!j(4TWhGM8jk*k)
z#)mdLMRs(!M)v~=QhW6eK&DLqRU@5Gr%}%$o=BpKZ-`D0k{s3pDV9HCQr{l?sFqJV
zi_yViab$dKiMHC4@c)HPryD-Zby**z{Dnwh)ywbr@|gO-IpFFbV|;9k7L1*q697CJ
zBO_zhzmmSB%?bYH&WB}37<;2yf1_$P*fwG*vSg}*)#}XF%;(D^=t6FSEG_I}yGEf&
z;1b{=`_kQ{t+MWFf?mUsNLx3*0Js=4YeLPXdR83z=Uo>VHx8{ZGex|{B4*;Ab4uxc
zU9&^NJf4|;D6kJMxlu$+o%C52^{q!LM<0Spj-tH}-sGsd#2n$IC()aIMf~M|hAwae
z(52ogmVp$0WneHfv1=JzxLH_OI1F?(*ulUQ9WV({;%Nq`5Qyw-C`YqK1{eO)&rkxo
zoJPw2GTVBxzH1HXL9gHaeXD@A+1<~y%LlN?yQ9^Ii4X?n@D<jmil-j{Wfs$bKw5S;
z4)SO6?%vHCdQ2|FnU>26qTM}eqSH7hottK|)hfvr)-%UIV<m1VOgt*+eyJGCNoP>U
z2;ik8Fq+`IyrQbfGb?(B<GCn{nJ*_j-GgNN3HARTzI$@+i1^>bcb`6Wxf9X1ER^fn
zH%LLDm9$qL%?D{8H&IVoyMbIWvAx_6JD5(;OuyiM>xJT81_Vi5aBJt?s}EFVXD#(r
zC0%I+zE-#K%BkH?{m!)6PrhAhOV_2Rc~{vmGpQ>B4V1yPugo12e{%sI$+whO9ICo4
zEWk68pBwPa4>REBlEk)SqfAWrIEA{aR!M1EnZb|^5zz*3cs9usHA49b?+DRPva=K-
z*cg-@{n>S@JOFRzf1=~HLq5Ao0H;@b>p2CXEgG4Jjq0@Mr7!Gau$@GlFlgFbiOavb
z+!Y$N9q?vF7bW%N5&@Gs2d|DV_`1Q(fzD6e=Xe&?DC+$S|2o5(Iwira<=)46R$J_&
zN(nQT#N6+05{K!Y>4hJ9e#%p1mC4}m2&=7YvJ)wTHVod3QYd}(<~pNEI5M(W<ox!P
z@OpnjlDTD7aMb<3?wAl&HSFs8l@->O<!R`ZX{ICgo{>OGq)NK=ZkFBsytEwTu$c8F
zv`$lxu{+xsG=1l$?6Y$r9s1bm!OJVo`vTJsW5AaC=l){;{S8BcE|xnkYfJt5E=F*H
zk^5u@DOyBF+LUh>#ai$bd0s0;zK^4N^85O8I-Ttk{_{r<>q#^RX&q!DC_;cyV`Aqh
zIX(};Dg1W;jrOS?{PvnN0)U}80sdpUzzggRKN)$3NnUNoQ5S2NRr|s(*F0QvDS~Di
z^qYxqKJa$DjBe^a;envoE4B9)(JQPE?h(XOy>pXlMZI_@r`$DTsT-IiN!Krn`@&6O
zmiWOZ?yS((Z?#@-1FKOTj0}TGI=Sb>3hy4&qE+4r+RD6<2py}gmIPr}2@JPAwVSHI
z>58Ci1Nw7~aTEi6eZsrT^z`&En3#%3F;~BW#ea?}i{JD8+`K|8a?sCxgRMv54feJu
z|JS>!M|Wm(3*V`UokmJ!{K!imuzVTCDIQPyMQHh#ms4AGlfdj)AtZz3K}d_0QlON{
zeuDM04VxtMrkk^0?~_4&-rb9$rMD0H{9}K9cJZBe4dGHZ`Xgq~yVZ|sS~rEtS(+p_
zS|v(G`n6o-dy)=wXrU=Cyk+XegS}mTym5JV^tqVIDbR;7`TqXaRJ{`oFlmk_rNZH{
zGfQ}qB<Ql{MePA(mT3vE{Q;PNFR|s~7Kp=Z-<(CK>ZTCo!uvnlAQ3s*!R7Jp<AL6w
zd#AT<+a9_U07302eIsa7+!Jx4bUeHKy))wXdty8jLJj3wK2UjRGPx%&oPD*Tc1x@r
zq?xh#O~E;alLK{(*Yhgu9a!&0w&M$5rZ?{%E?HBKjo#6V<3GB<33oPD$8^7xeWDV@
zogJu66L9!Y`m5+BLk!D}k%{j|+2rKsSMMj#6`p&h{TbraDf|wd0QR3bistY+-uCxH
zJ2aot&-?6(f?B64&GrB*`(e(t7yjzc7G7&im|p3{vJq-7f5zFHooAZ+DAcmGy>2P%
zDRT5Ey@t?JgA`6Z6A4v<YFgKS{}>RS{MobVUD}&5<)^;50j#&@h3VcRd(=Ov*|i!J
z5yQf7xN^04GQ7aYOCG6}*?Jbi4@#$sfW_l5juVsVq&&FA*oF@&d=m2`fcwW2K#h33
zo5ZZUfDy(!YXd34WqNSaqs{RsizfgxS~g{7eP!hkeE=kY_kfw?JD~3F?p7c*#QoCo
z<L>*<LUCWeb}K!5VcJi->6QnLQ>OZ>1$lCpl>PCg+NitUwz_#ztQQjX{A25lTQa}A
z48rsMKF<dRMD|LDesBK@9wU-VzB$iM^4sOX@K1*T;T!^A{s;BkQa`@F^v4-GS9pPs
zKIh87cS265mTE+%uWz6{X;uhqjm@z~(MIz;Ny1EypmSip?IznT#R}qjtB50jU1A1|
zj{n{)DgOnGx=E;zi2VNf;kDlY&^_n^#!G>?!)Hg9z-~mCGSK<u-DjcrxVZNJ?BIs$
z)eI4{OVln5Fkz40>%}`;t<`k5JPV4|M<11pE*j-jaUw~+e+846<89rV7i9c3<lH*>
z{h|&m{j;l}k5;ByfoqpL<Rxv05YZTo+kKhM8#%U-<0rnZW#BusHr!<cc~NwF8=5L6
zv)iHyKUJr=$OyC%u8dSZ+nja_&6EyJM~_IPzL)A$zjwX>+A*d;(tTf|)wI%h{+m}}
zQPFEfMa9N*0!ks02M->Ic>PhIu`T_1{ISNnJkXFEwC~QlvIDFW3Z(OwxojUP>k4aX
z#V>huoF>=(rPC?SMQ^HqlUeM+tuIVB`Lu9$Q;DYxNB8QcHGf*Q(du_`^}KoWT<R|z
z71YgWy}L(_tnJZ4pG~zQsg<7+<1mimd#RJ;D%fW7a9tZ@@^QSAe?2-z^76_3{syCP
zX&NA92?A{PCouH;9r*tOWWL1TX}P`<6F&wf8~+bqZy8W!)N~CW4&5yc(jnc_-6;Yp
zNC<*7NOzaCgh-c2cS(0hNk|<U5dmo_sc#>=@Ar9ryx)sI`~}zE*R}V|nprbz*3MC_
zH-$4b#Qy%u&)lzlyQ!iE^d?9!@o9yGNFedaeO#Q85u|*PUW%WbE6*?y=7WAk-1@KB
zRu1>fG}EUwJZ2Tbj+h)noCs?sU;L0=YLy5nBjb56MPDBMQBHbQ7g>S>aaoKte#_Qh
z6ur~+s8bwl$HYu+!<Pv^6uPEEdrXn@b4L2djPz(ZvUQudH+LdIYU7zpjow(D%)7~O
z*E=5jGioMB);CXe_daZ-sWG*JPC<`96N=S<9xXHcLhvqc6<ps<W!gN1-H|w>h=>TD
z#G=Nh!sl;NHrO|4Rc|Ce=nYRavWAgfKeQLod`5xOoY8bM=jRdHAhD}jOx7eI5(|E#
z^5F3`lqLz{kV(X{vsz9>i?~7oUCd;o9UbZA00-yIL&6w|h<sNqO=cT;Bk|S!=bZH1
z&1Wu;e`p6gyKrn+9GF5s$Si~NA;J-5%lq-LpTYs@)DtwV=y(8L)FTKiEF$8KRFO3g
zRA@%5dL?_RxRCAo)2r~py|r8+DXx><cPT1u_KPkqT-KWUULs~1uP~^U)l5<GPjkJp
zI~QbD+jOA1R9M~b1R(B(N~w>Ds&+p%G18Go$kkKqtSwB@+uG1#WCZ-`LL}Sl%&5;V
z3$}3KKqip{=kfk0^f9emDZ$sHl;3{-MwK6Y5G2Q99jgWvuIaX|v#K7DUrQ|dxX@sT
z*{fgeoe8t6lMUg}?a=E|2cB!7m$4#|U+*~xO+pvb+17qCbar}TMMj`Zi&wF@NmG`H
zXV#S?vn_(J*Mjgih4@Jd_VJrX1$9bF7-kZuR7{SM_nVLC&Y04HeyEh0dSJP|g5N~_
zJ^YUKCa!SrbEN*m7c@hJZaBJV*ME9Vf7{xAt22HR*}a2r_RzV)B+p3y2Z6^`L8q~*
zNJZX9J7m8ErnM5`!!{*3eh8Yb6p<hbK|?sD7VfFf?F(Q(pQI2UzoGb{t@m&ODY7~%
zC<5K^9uCmuaqG_)W!}x?%;CMJT&^77?kS;6^0X1K>riWtWiAbsXGFf})GoGC6-uj;
zFoTY~>jtktK9n<1=ondo9odH}X{wc<DZVMw0<~j=nQli>h8Pc7qbQtmG~ZVHVD}c0
zl>oR^OU1d^8kw3JO5Rg0_{qgWK@<&)D2ke#oSZ|KlLHr{t#GnfeYO8N)0y|=+UdH#
zO$t}7g=s5eGV?AajVN1nm9X*DgZy8IRzKw!etDmfrGo=nufrKQdxAXU9^aG<F{GhU
zT8ypbwHgMdcn7!pv&;`6De<S6PKPeaKNS4WX$JE!8LVo{;%jZ=6%=H655t|J(-AR&
zOKFW#9~h2_C@TH!CJI&szbvzL8FzwXiyfPZxIz!sB<oQH?C$y|8p*$?$29Hs(q^Qq
zzDKw|7_26J&C6#&a2k{t1Fa-MB51sIBWM&sPfb8tlvL|R!z65M9S2?E1QNvS&%~#L
z>jMky?Cl2X_h5u}0b>0qo^{xhqy{-+yj$#+i<GOW+Vuav35J<W#0>hPU)G%)=zmMw
z^k^eqiAx_#bbV1i9&T`QmOEBSrCr1DnxUe$zbZIlOvleG=jrjl>pf=s7~aDk^VMZj
zg0R#JMoD~at$l-W2HSJd9BLOS%3{=3aizI_GTOL$X=<}@vHt!`8&(D$xNV%9LxXUq
zkN(D@%hUKhPsrk&nwdE|cJC`ixBzJJxL){TvB7?G?q~I<<;ZCMLt2A(VnvAdPcbt{
z4n|;$CZ&vhqUzLbVk(kYN@{nivJ3Sw1+v~xOrIwhbsuoJhdSfJpprC9w9A8BSDx8J
zz@2^wVSA{-FD1Sj;MIxX)MQC-`>6m;$;>uTyTQyheqH^yVgG3S021fFtEx?E^Z4&f
zK~!j8{G!9SrCp!C;{|#82Sz22huh>?MN@vp8F6torTlh@bad5h98vU&5ne@ujE67U
zI~A#tR0M}QM{+yIrx<$4E{y2ub}(hoBDxiduBh-(q4~Dnyy4|Zufq5j9+18kT|i;&
z9~}Es1^o1XA6;r|`%>bIBw^s4&R?3*W9$jS1nPuALgdw+Gz_tqPjalHzHc8&_Y0>I
zhf>K+s}tJ?3Sl745F;#u<ABe5xRE4P{NouMdwM0~LG$X+*QKzhZ|Va>>_BfiE*-*?
z66E8#&g*(`LmAQoGgVFF{^xe;Z7=3O-yc673a5xV)Lqh6hat)e|9t>?n@)Z-MHnt%
zhY{eqy}`Xm+6C?<O1S=NIW+K2AFXMjxR)#!;*Nv7PsT(W772i&5j|UankrrC6_r%|
zXILEVr{@pjYGui7!o?OaSl{c|eOvvX9j6k=$bWLqF60>FtzO9*Z+V?AFpTc?sGY*O
zD@Rh3^Lw0VER|GS2?uQxzbivUwZe%E(+=HdO<<2ZVa&+n3&n$Ew21Cm)J_zmy&U)x
zmn#l4p1J##=t=StzXDk7cFxR{hVbM2=V`$TsBOZ{Uw5bcFN>rLbD@;@UThV`cdiMY
z<$79XpU~OHx5oSHwV%MzT(Q~Q?qt^ImRAHkqO_qTJlZ7um&h|j2o4X>rt5S*>Tn@Q
zl4D%csmrt`z_*=6Kut{7_+Uo@b=p?|?-D!U*U#Wya0MDsZz*iHC>!MLRzEXfkS7ko
zfz?hPsK{}H;^Uh!O?Z~NSZ{R*>?WEB{u%eF&7S=&U;SBO%FSUiIrx^cyp(g`>$_L#
zunROyBTb6$%+ADo7EgqaFazUM0`xV|lD@!}6%qmt7!mFSWMpb0BMsoNlQS11LPw*>
z+a_n<S&Fg(S<L#Jnqk4w%cUIq*h91cNdvd5NjVd^%^-!8*I*smBu9!||LkM#f~!_7
zr48AN!}w<Aq<Y$Bal$sKgEH0h*4DE`%np{p?{yzvlij6DJg|^A9bvEz$AcQ{A#hO=
z3h&tZw;V7*abx1S7lG&Iu^@1LG^W?0$!v@GDM5R8Zy8Z;=V2UnbX9WyJR;+J#{O6R
z>N`0107Kxgl#=OfWQ54<^mK1JH62~QTHcA?#v~J}8D0OM;gg~>!PWedOkfO9E`J%s
zmAv|S6kK#-!@OfC!A@vK&khVbC>mg{V%Icj$-l9yh()AU{}4|+WR3t|MX2Lt4s}`R
zoV!<&ownIIbtem|3T+(jh}k3TTB-MB!DK?)K5*pbzmYa-;f8{*&HUCG(YV3F(z2E>
z;vRyP6&_VtJQjK7(jgWnKnz>OZ~yr^xS(g`A`12N%X2Lk%EvLMX$>uAgh#b=3}Eeo
z8E?^BUDQ@-HuoHyP5BR3wh3zN)X4G7n6wo`jHM_m9jISFik(5cwO2ELgz&_R=trd6
zAYmSDOpVN>)9M2NyqNySb;rZDr1Bd9*0$Tveq8(_MYEm5p6%72gy6HqGWVzJeKj)b
zFcvc;J*;7KPwBh|ltzKcmr#E;B%i$>4{GQFztA%pk|VZ<M?@^pS}$syPfOhh#@B^T
z&9<Q`aZ6|6Db0P|*o&t-{rxmgqW6DnQHhh4;>y?e)PiPS-?9hR`sse#3g=q2FgqQl
zXi99`cZ)OEZS}J#KNEUONe4>FWL?5wTvg3@&vYMZt!Tv34xx=`d~kFo$l-QUl`Ek2
zVe3t3mg;uX6p#z7^~N=skfyeD&{$AW#s`mmxXz6DUz9NY_SPVs6|si$I)T9EYsVxz
zGuiJZ39s%PF=mO}b!KLqy#C5jg&Q6L#QC2}Ms;$K5WEY0<SKs6oT}nIyF8apL@R=Q
zH3T&b!bUl{QJ%V*;>V_?`|c1<|5<lE2BrKmOTvb2?RZkN$iLXYCm$R6-?)~&sK<cB
zCnomb(B3aYX7|#;?62vq0WH!@lEe49C47H;A}hzSgfpLQR$IHGsk$3(5$f9YM9(e)
z1mR~~hyHOGKZF+mvJ1#AfYgSm0(kiJAssLX>yCC0O<O*r<W*H0T&c>A#xu{+sz-#0
z&7iObvC`)S1|2BmN&K1C(OgReFLkm3#AAwYc_r%z;T}QzpvayFI=hT}va)Y09N1dO
zs}9p#=ORnm+JN<Yv9piO*2QqARskpE>^7OBzxKdmyQveEQA%`bas6kn)R!N*_&yzY
z6RS)rFSR<b8En4?<8+q0`EH>xa)<8~ycs0Sr|tVVmn(-z1dn$uYCmR5$xX}8&(Hrx
zy1#(bgfg8Ibb&A$ddIuzSAX`Dbm$7@V<=s=ddf?hu6j*9`sSyTuvYIr#RaO9ELK{O
z@>xl>30*@EvY^W>cyDY!f88>tINVi3-zWnqoC7|q_~lv8Yc1SqnVSakSKuUA=`@~w
zP>_=uiw(=5LS*H`c&}mcnP9^L%>?>^1#Nv}<LK+7N|z>e85yYPyL%k#6$)T%oUuWP
zkjNmqVTV?A#k!3;Y$PNKb@R>C3UPL)-v^zkhKE+9oUwIBuRcjDqXmv@jyoGnYf#h8
zBaIBlJIaa)t7Jx?7-y8Z$u8+)ySfuk`{Hy?#b`Gqh``^7<~#K0ntBTGT4;f%z#z{a
zCu#cS5`0iIwe14J{8f1=xtBj3k(hjIV0!??zzvmssgu=K$M;9tRir_puZKU>him;V
zo~XNFSeuk~=WLi3Jp{)_-M}pb88b1Q&tfvir9gUho_=rKnIacbJIQd(PRz~r?+rQP
zl>`Xutz^^@UyfBAup>NCAo}r}bZ~wGKuPKMWRj6ieA93owQ=MDCCQBaK!vYu3Dg}u
zYGvi%nFBKp!lnuQu53$J^-ICgV+K|7{?u@sl9O+%=WCXi;R4QH<P7KsF{FsWi;|m|
zWPHUP(^p7F;+%({={i^X<r)bBU}2EEOiqBFdJ&H#61%hC{E=QVAXHlLGr*qqY-z7m
zr%{^Ico!x{Oa3G&i%KOr-8AeYKRMA`XXhiJWSG<3OkQ1G?E%P}gpVJGV(+h0Ue(j7
zIo?2u#p5CS?@=9k``_wD)tbz|Wrll(4md8Bm*ZZk9iyr7D<0E*l9ojaJpI%;X$IBJ
zYG_;&Yn0=ER@4`x<*pC^SWZn1d&YHj^3Vcpy+M**q@OkFwT?*~+NoyH58ccAOD#N>
zW0d^-{0|>LCIh8?QYtDKqG9*vrd!XIg5EKB+gRXAYhx<qHl57>C`SY}dq!{V^c{gZ
z>{Ei?h`P!qvPy9O+Fx*UUe?=HZh@y0?T2WF3P1I3=6@?7S6sR)YTy!I3l2#vc9OzR
z7K1$LP;f?U3>s{^fRrLmBP{069~XAxcFLopBWZtXAVlf`#3vnp&++gJ3U*u9)A8{U
z0==@waKX4#HKr`~dvmixT(To?H^rlF5dFA`-q9eoy=^2d)U>ck+8L+B$LKz`uN~xF
zrjkIxNPNnVHtmUQBtcu%fTsm}<`5rv6^78ElxVUJU#^8*8_7;ZiPWT<1NQ2%yQeX0
zA0>dAj~`63JYwiq%9D-)>ovH$-jb{adSVwhe$f;{I9wgqytaY{rF(@MnO@5SKwyv7
zVk8yFm;jB?-wXA-zr!y}*nrZ}8qg~12eJWCfP|qJ6-{T3xqr7~2IW^sPjkz4$Vc#-
zjJ}7T>WT{3Nk()yYGnp1YEa8Z>U-m)e6lbpU=1Q+2^G*q^LYksbyUk~&Mc;^e24tN
zT!qxa;z>|McQ}i4SGEqaz-Kls@-I=z3Au?6V`^o;JVZJEL8^q_s{b%=YAx{PH%)|>
z#8ScTT5T53nGvK*hVOtzAQ>QK1M#3!pEU<S%GXpdJ@___QMo$=ozM|vNzMNJnuv&u
z3>?^yHZr1?`1^~VQrHm!6tFxl*21d+;}lITp5}l<2kI_CXbHzp)hQ<{X{V9gJ9)uw
z*LT7=4Q$yy-ivk8Q+IccPfgWbzZC8%*kDmdP=E-;bWbU`bLtDU1;+Xz!y4)*uF|dR
zbbp;$|DfwiWxNSU(;-t@$g=+ZcWfeTD&N-ZVO(68`IEWa-X`U8?m(C^dF!Fr;c1T7
zP`?mokh#F0ODDKgAw0tZaRgV%4CK4GNf#vd7wT=suTmo;BkdX_&*sb`-o3N_F5$E;
z=X2n_(gU~*xFlWA=G(P-%j`Z-#r}8;6CVLmQ&aPw&{zD)l=Ura^;YW-S29dsm_*_A
z!#+|`VTqk9-;2#5`ZU3oyq-I(adPhLQ&PU-#xK{<%1k_uEuvK$v)+%|I7uq)4x}dL
ztXk{7OrhLsy0kbVt9OMMJ7a7){ZpI10OAFP>>=~ShbhXuC&P_&N)+iw;tWj&4S1%b
zX#$V{P!q8VI=2GyT&^(-qoboGyd~@y9n$Y6QW(Vke3KP+T!py(o(t>=$29{&SgHJ0
z1ey%@fzj!+7*)}8YZtt&j#ErxntGOOu~dZ>32hfBv$*}<*7S6Ok|3$4>62#*hKz@5
z6;h@;u-(c?%p_HfNRzyv2$@93zd8FAVQD(Zu9~j1TeSj%_jfolRE!nn{Zi)`L!Lbx
z3HR@wN*}9y+dcJli{=}GCD1Fb4>4zlun!})8^h%Xf6oEtrwXLL05U^^XuWuW0Z~#>
zd1Z-*5676Q-~x}nb?Gh2q4IX#Gkxl@%WnsQX$h9UzTUD_Mx0!ebuS5D542SyJ`&`y
zc;Zmx2=pI{IwiltjIzlQuHBMC9=!rNrDe+}zwndQwVX><$BTo6pJHCL2<MjT!mVyh
zs8|=yQ0L?zI5y%SUPX=>-$icyHHEY<Fl!hLs;*Z-79E~9{W+e!vMm90Y`1(DdwY9v
z6k%@Wy%G49k`UdehcdKu5UJ<S$sFA7k!`cOZd;Kv$(se+!sr~TyUJuy{^3M+E2TIk
ztSi6s5;i~W_$cR&WdUVg5PS%%77m$?6r8-{ky#z@>%<&D+VL%)-DOxMv4X>{VMf9O
zK2~!y+J_n<xqdptspEnjxx-f~vUE^%SaEecZ#jF6T6B7JdRrL!;w?dO_*zU93Sc~j
zmL(+nfeKzYGUfx5jsBQtjrLR^-wV1fL>DbV`ytpyC??6P{%A7sg%8fl1ozm;q4+!_
z2ydb6-6%gD%Ya_!J6yJoiMk~TC2%r~-7u~UHTJf8fAE{9j<m9{+EUu#J@a_B3Ttkd
z)vQL)j7j01>^^uL@n)3}?r(8j6&bHZ*#c_{EB09KeQvQ+VDFyRt%0VTZ!k!Z&<zoo
zP?@_PQ26@#OYgcoYxUp(FF6kIxn|&Kf7^CR756?1*h|?Mh!eV_A|V+NLjBLlwVQGp
ztx+aH%;ywg8Mtlc#O=!>SBIT%^hgGJ7Zl@nZ~+kaTJagT5Kl4*Lue>dN2kpt)FB(m
z$L=Y9{Z4@KYo&{2JgJ{?(~)l=gnl4>@!*y!S*xQMsYLuGOq)xZnuZD-jmS-(200=k
zc<y{+_w?ESgS6N^xq+?R&Rm}-vFdn0?~{W?124w>Z3I4{9@MHQyZzZCJ<*Eh!NuOa
zeIR3^*M;BIH(!>5W%B)y{nzV{V2!PrIDyQ#m_LLX+WZvgxFvOD$^t?BOP+J5=dBA8
z9a`>BWk!pkJ1x%`d7q$O29XX<tv}R^4l`eeuh9^!@!90=smJZ*77tJl_5t?I<9x|I
zmj#2`=ddeBJlyx{%yclGb}zPsSZ1|;)~F|zD)4chLJWE6@87mrV*fm5bqc+sowUj-
z25nXQldFw6*hXQfuYZT`^LH_)IO?!`bk<ah>f=`h@jw5dw|W?wsMCJy&oRJ?g7|%4
zTzgLnQY3Fy@zwp{0kVB%KyxX%<7G>OSqA>sIw>o2t2%6gtz)J<KM)Ne$K)ZM>#Lvy
zBLH#CKA_nd2Gl+`${Ux1@>o&@Z1l8ZJM3VBt)SGR2_(mzfZj2kxHwfpLc*a}o3Pg(
zmYGW9xSOkUM2H#_q2Cp3<*kGvowY?HZ2n(1a!GHNEl`w~Wnk2mn7*=D4NebDSMBdU
zsiZi;sHe}G!cq|9a}hRU3azvI9{9yRY9STp2{Xd^X9U~=Wp18o>DKWA1UX?}0Fb1Y
zjL=;*u~)TQ>avq45iYxh2d6e3V#obBuayG{NEA56SIDn6j{O4alSV%Bp|1FxVC$8?
zK$h2b1VYrPn-|n^sDS(K23j`@OH8b+=s=W`9q<$bQ6Uj&Krg+T@Snvf-$XMkwUX0{
zZE3guVDWe!FJ>r#zPq{7-*rcr(l5Kv?)3tT92??Q>4SbXYt2l36XmSV6_o`e$u0~r
z(HAln42cxIS8C*>a=|3lW7`FL%jBJ0&2`!QVl|Jg9^neq(npdCp)!E9!0(U$SIQxM
z{~?$v@NY%{pda?8HkRKGb40|%^ns?0gbyFWfk^%I%nTs8=JwoxXD7c$T&+j_e#-X$
z;wq1$i`}*36q|)00qA)mpnKEJn8Q!eQaDa=T8+!8oUTE3aq&&mW~dUam27C|fiv<~
z@$y-+*CuYwAuT!xq4ZM`McL?|aji8Nrz=}N)=|9<6%)t#`sbMvI{t4ZI`YHR&QCc`
zElYtEcSag|V`&1VQ#FH3iRcckM+#cT2l2GBhd{m;0&juyIF2lW0R#^@)VI0Mzr38S
z@u@)~(=%J?;3{c7ozrudn-ZkAcsqAiYm6r5b6iw7TFBx-D-g_+D5FuYxcY@2ddK46
zeZwz$cr`&VIdTs?itqlgSUp0Vd?uQ-{dub{W(`74*FXBL8=U6@*@~5Mcm@j8-*u%^
z{R?2Mo=ZHQOohttUvWLU)4t(&nsGxXAS1X+?tP(wf8r(2bJmoR*091HCzZF{nW{{?
zX}k&5+{BpnFsS5v)Y*!K?#_V7tGEPWJTktkK)Aat3;L@oKbzPff_~ilOUmlUP<4En
zmm35AhQ;73=!but1PfN3+A2z^&+!02jKi~vno=RJ(1s-{{&*eAO`zXryr|Wbej+R7
z5<UXlYAl-1lbN%>!><B9E2t_7@_@WT*Y}LNn`Y=vmOX<VbDvcEFPF)gkt9_7P*erJ
z|0Wc)U@mI4wgR8dFL}gEaI?Svo~m1-?B7iEH*kRpfaAKCJdO2>;Umez(2!AGs3x_w
zcZESI&a-&dwHbzxQ_2}R{;CKCn(2%wWmua)KxLFN3<P8(d{(M*Yf%aR5O4(833VXs
z9DPw8#C`|vRtxPEe5~wOLIcmkb(0y>8b0!%H+>}^jfz7N1If!vu|U^8yUGqhoQsz!
zAs+M~Q!#xWGJxx<FEDLK46ZW5GT0B-yI`?UK)hr4N58$NGyx5%ffm^8r?l#4Sg%?u
zCT`6TM%u%bTZ|DHu1VeZ#hA;$oNWAa!O40)0@r7SRiSVsjPw_kQIiNARE(wybm04F
z)2x(UJOx${stn6u%Nbg^)KFU>n0VM9p(vd{>pbZ}msg>pre@Ck57Ru)ZzPh?6(wk>
z-0B3z7=BY6IkK<qby*ukcLnS;v6N-+8EeE87}w#z2J|2kx<C$dv%)$Yd4sN;v6~XX
zQ(L)D{1m~d=)rCICh!bU?DjGDNo6?xGA0@?;K1MbnbZGEQ5v2R)}96Wv;Q?RWt-QH
zB9EaKzANoQI4$oI;N0_Q1a=2fMbB1Wkj&n%pK4}EKN$*nEhYo%J2XtXqysl%%4g*V
zJ1cn^uUS6k+eeb}d1vE6=_;vr8Za(8Dj?QknFj?KiFKJ@;m>74P+Pr668QL`tpM%6
zP~Y~=O1-o^r5-)jlEq?r5f=J#MM5_t?rpaI)Y)+r7Af$4)Y!s)v{h_0&$75y9n9wT
zKzd`56uk$2>9h~<Wu!7(P~JDdz6N5rZ;2`g@Q>kazW0DzVfnX*xcC!a;AX+f8bht&
z74OG6GC8@-!O>A<h&gDV`IlxC(S?CrkDp$?`sy-}Z2GNmLgn)K$l5cZa8J*h-M+35
zzFQr@$6e=iRxHfy{vqJ@E(po~1jPW~mdE0ZK>KHqzv^Rfi16fNUM?tpt&{n}Pkk(Z
z6#pB=jSlR&J{X?T(A9-|pO-E_;VEBu+JM+qT4Po4@6y~4;WDch9ud*se@~CPHx9FF
zZIc*U<I@1Ok2toXitOhvm(w1z%{ZWd5H+AQ7;U}|zVOL)qzKn^<)hUVLma2N3e_v6
z9*%e}jexgKVg*Pz`?RkX3o1Z9=Ra4zw>|@L)`EQg^8oCrH=4auLs=D+Y*s!Fw^ZUr
z^Ch-KartE3sH%#5Gfxl+B{u1)M4+WJvIM71n+6KEjqssy596=bOb(GnTOlx9S4-k)
zj!lrz%o!!$<4}^NduU96d-)z|P<HgU99^FM{}`H(OI;!I#n7~dcIv>Z=c7iW$MQ2+
zbFL{>+d8^vBafz;`UqXT#IpFK;m>TL417N%Z-?bVW(~dN*6TJGg<nuUz&D~&9y)M_
z|5axMp>?}X84vg8Jx28SFoSM;Yh=1SlmGQRfhJ7aoXnbjYs!hw1J`BEeb<eqdJ>-M
zu8-XW1m7%VX;8<qgc|2--JKLeADsaH3eiqo&sCM+5T;F#=c1N@r+p4!^l_$EV^UW~
zIkf1=rClcp=eX}ki&H%y$ttuL|4vS>Eht;;-)oJKd6s!qU@>156(()DSG$qvm`p#b
zn+LunlMg|YdI?Pj>*N@#*n)Zg&5^7}wRVT-COAX^osD*CqGX>C{e)Dy-4j#AX!G{*
zH`NavIKrFjDM8Begz69P4*=Y`R0A@ou$7r>2?4WoUmSxH9C)8Bw6e1LPqL7+*q!7}
zN`ADj!OzCmmp_DkiI@~|aMN#nzLcSXFijoyKFQ@*!QsW*G#);eo3^K`#fAu$6uN4k
z=K}6T^}4^Ifv-x+*P;NhOh-w8zbaYpTJxBDJjAM%>g#Lt_|JXPynOXia;>w!RikVE
zZ&a!(`Qm5(VePPK3Gro10ghp2%@9hap;47e)F_pD^rJ`gc1`mShEtVq`Zr0Q`N*wu
zF_zD=5*&U*L+?;RBpMS??oFLXUn9{vpOLz$!2+&*l{j;s9y>0?#}k?qwLuHS)V1;O
z4+Mfk$OQi5Tk!N&@<QGwRUi1B?rZyAbUR5+J<vE=k<fV(AkyLHu`xNF5T8n#@ArO-
z$iucnDy#Oic^Yl?(usiSg{Lop_P}(aMv-w!SH~wxM;B8gn6Q~i!5-MF4*PE@x;(#5
z;H}lo%uH^PYUf7)MY_|QB_5c-0ng9=%RA!KtE{H|tq3`8Xr_O2C<MF?p*Su3-=jA=
z^m<Q;Y!>_o5(A1K*gSj575y<+8ZEFR83LRre{uQjN(vH)IFX`ahYaZYN8HwxGEr|i
zh_yP{g9jac`JhJO9LqatajJ$Sy$)sIYlrXpijc7Bzg|cMEzm2jA>^$&O^Vj7{;0(0
z@sGhZCGNTIJTCv2fKhX5NGi~NU-jk}nvpq?i$*p)Ig*`JZ$y#{!BkXkdW}Z-NN&2{
zH&8#cxrKbEkhf?>5Ajw*h2aswk0G9TF3k`hX)K1e5e)`9@`u1=#-D>mY_snrx{v@c
zo52n3KC;3lx9>nS@^35T_&VoK?<iEqlI`RBr?=|YK>2C?g^l{B!o7(QA}k?=L%RGN
zk*72)9}QQn+c+N)c$j8{;6DI|?H4;OQg5}_1=w_RIrPn;Yja!@HTvc|xxo(%QZ+mC
zk#cf~cwp1MgBwQ=K}8NK4&|HM12B34@3a5+rKJ#Opmqhug+u|3_MEaZED#}pBIKt1
z=3Ph7=iX_~TRn9jU7;j|J=jcSWQpKsI3KFE_KmqHyiG0KdvVnie;`YX^pnKeSU)<i
z#~}=B16e`34QG}J!C#nd)y}MQF)kc>!pA^L3}39vVv$=<#}_Q{x<K*KmZ%&>j$szs
zCB~SIsvHqUYA554Y!nGs{{W5u;-k3J%@4-+xr?c7TYDR8>uxZG$mwuZ+6Sb&JixG%
z__VaIvCQy8OwO?Lg29m^%zW_eN_4^eFJUy|trXIkjVCsGgXe3X>%Y(aECXx@r>F35
zkyxd?)uMBBF;At{lXo+_bi}J4c?j&4On?)Btm)(e$k%-268S@ejiKkEY}Nxz@G6xE
z^Bz}n;A^9S{7Mm*L&?}j$)Q)(4<9|kL`Fs~Dk<5S*`Sp0A?>(5tz2_!0cks@aq)8#
zAbRfDvUCB8){cP0)as9+L=avJ>Qx$HM}>Ce-PbOVW9=9)I9}EG9FuT-Wj1~_DhHtB
z_N`86Ct)8mza2dm(>1TeM-md`zBRAFyJarNnwTzU!m`d9CxRz*sgAVdzo!8`ddC{-
z@BCQnV9&+dDw;!!4#Z4K7KM<A2pRl*A>>gL_5<%B#t$Z75)7%R8@oa@DZ=xVBcOcc
zA{q#vH_^0Y&+;xv-`JO!kU1;U(t4rJN=aS4Z<wni8Vre92gTh3peD(q3qQ2!|FFH<
zpZ}Su{`S(r+OBHjS|7VV7x4!jxRl9rOLI9^-fW)2ST!T5%D(<L$!OOS`kmzsM(&zy
zhb#1qq{1&^-+b#=TLU?HJ)FCK-UzeP%!7E7pttgLNyCH>8Q<c#)2+8z6oGVjkOIyI
zZs*?Rn0vePa$Gf-=kt5HjRNAhTi$5>zR_|KXx(01Y{WUO_oA1*Y<U18a2gkp_O?hF
zvaLF%`xNLqlbB8pr`c5#GXOtcc)wwGypdUTmtUA@%vZNqBugIzYy7%L;;~=UnH^<N
zS-Tz3XU1qqJkZNAVG{ij?k%Yf9l+gcBRDL{6q81VJFg10dy~TB1~(}^$b4c%{3YZ~
zYro>;?CtG2sXc$-Kh@W#7ZiL@+5VS}myb_2Zv{Tw;QE}SadGmeU=905%gPO>k?*PQ
z^z1A>Gczj5OBZ}DkvzPa|DlaFkRJuYKn$fD*_l*?PrKx9Q#$NaRjfUA=5p-FVtTtN
zWM*;4=7OxkL}P2ly(IVOu-gNDh>6K00>xm2C>gjvwqSo9GOgw5?XyWzilkBkT4Pe&
zp@Ks>eE6b)Ng(<oR55Rhv*YA`up9%b`*Lz~5r&3_o>jj>24lu#3Rl{1&I}-+j1@^C
zj(Ta|4IBphTW^rl1c)=V3G`q<q}<#DMT74vfYeJ4bG!1Xh$-e3(HB!T6Dw=tLNzd!
zxT4!i-i31fY#)uST1A~WivBolDX5Df=BJf2HtV&d`6S?yjQyh;f9k8k!y+wbHo&K!
ze~08HQsrR>dfHX01c`+(zK@JJPg{%q|6?d}PXn)eBRfA}01bGm6nSb1ACFSsdpyD7
z^H`h_PbM9GCknqwCPI(iv9dZ2bGzNUv4m(~aRFar9E%F!<0s}~+>6l8(g9>6t~YI*
zGALQp9H2hU$XhNr)axs{t1Rnv`fvb>@c;!d?5x%Cl^Q`}Jml}YpGgB!2hi=NyV-Zw
z%nvvX(K=S*oHqK`fYk~cwXmsQ0!DWH>KP^pXKyqapVy55xM*PN21H6mMkXBgqFfI+
zqR!2?xn*V1B#`@LV5*H{_M~6u2M+G-S6(;5p6Z{3H!DEGm8AP*rCFD_gKNTKvd|#U
zv6dr+g!r`CI<B)75o$bJXC%~(b?wv|GNQy}9?_lYc$Mp?i*OhAB!b>G)1K>7Dy?xQ
z(&jOek{+UHe8d|(P^g_<B-6P@Wmq}?Fu+6?`u8OJE*eZxkwOdHp89MC8V01fmKG_<
zDaOYJi0~&ot&;fA7oE@VO;+CFwAU@{sgf^u(4Q#sy<ad|6j8v=h1qtrX=_L8P&XFt
z&Hupnopk4K+AGE$aX0vB-?rb6wEA&^fL+AMU2aWn)FHrM7JYhjGhle-s2?BWhbm!?
zVI~r*`1?ChL4^HQZS{;WoTSM%iu7sarLj)H8{ZY0tx=(sUeJ_=00DMN-~q=Aq~P2e
z<C5~1EoZH9A5&B3m@E7CB(7LBD?umCn62}^-@TV7%Gz06&@RxHPP;oJ2d?Vo$(M<P
zfxHL#4wcb$Ya%xMTr4}f{u~c3d@BMP`}8G6&@XhuLRy}5{=m{sCE%o)w)?CIqb@xF
zhBbrg>-Wfe{Kf`g4IRd!Pz@$a2D?E6md#8V0%RnW2T@b(2#M&^21Pbt1rV;hq7}?e
zR*W3BWE;l+*MeT8XvOjtp8e$s!JB*P{cOt36>Z$Vr8N)jwZxufsb$#PKOCpjm28LM
z`JnazxcV+gtFUx8vY?TJ+?oO!f>SHPEtg7;eJLbOgv`!nO7;sIEBAsRYY>%^oE%_b
zRHZ>~2%$FDL9!r2c{!HyF@dJUC4>2MoNWow#^1HWn>#L7e6WyLU*6D7ejOXL_)myj
z<chvoXC&F5+fVn@qu%-S<!cJU_cyv*=WDp179?7_$YX}{e}l{Wh)o>oe1`tJ%&u);
zMzqSMHRKs$Vx!y|5ubcM?oP_viw>4R7Du;h6M~19in8q%XmBXx!Yi5@;Zdo)2O^8^
zum8_1znq-B{3&R_AddmVK8niA<w5#?z*u4Wy8yG}RY?KgKhQ*ZTCT8q=7+us@)Z2T
zpe{F>n=!=Pzs*oDf-PHf>TKj2ertS@{_j%4)HcnWx)`z;zZ8rSDpqM`K2KF5oDe)b
z#a+aFyN(iwnDu~YFDd-^ZI&=79Wl8*#K(6<Cv3Xutw3!s6l}6zq-T`$k&ybl+cFG<
zlCye(kTI)3uWp$^BhI@#6Hts!wa*8%{7xkHyF)Q~%=)82bhN#_J=f+f1mvNRv&U!c
z?>4u#gzm&&A$5d2#Bjw4r$0OhT^a*O7%+6!eY@^?L;A%xBi~UOlR9ic;nt)C6T>j}
z?3J%ab(z+bTe>*T6uVx(nur5U3Yu8*qZgZw(Y%L$-k>)!fYcEY4v$WgMqI;<JBcDp
zBR14Wo#2NuPdrgS0`Q<ruDD<)aw!bGq$smC_O^eJIGZKZR(D)P*o|6ALBr|*=n1F>
zjlaKKL`Jg2Ma{45CJU6|OE=^s!J(0eKH3;){IXQ>vL)@#;v+Qgo4%G-=YMi-ZuRWh
zSP<>7W%bntfxA6o+7}X@ujP44Zh&LeWW==u^vb#}a@IJZM@Q9ZGXwqMjvTsKerg>p
z#%Zb*`+3h3JY-i@&n;(IKUuD!vsay6bOJcRt+NHxa1uP$sB+*vqbj$<vY72sGjXYY
zWf=Rg$BzWXg+&QwW=pA#EYPMv;Lvd+2r&Uo!FEiJy1IR!chwyt_4Fwb;D5hjg2L2@
z2$pC8fT$^RH3Kvve|<NjbWP5i-uUJxf!>8wp?Yd&Rou{FUp+tvqa4DF^eS7R=eF$V
z6pEeMEu0S|5nkcYRwAS(-Z{g-x~f9>NhkS~zpkU2PCAPKb8~?KU_#nzLlJ!ZQ|MTd
zhN*Jp?8fC*_COzrF%|^Q1XRE3dl&D+0jQJ#WD+3GdjSRjRRK?{2W!2%y%Kg>M+%Tq
z{?$&o`LAQ=rc&}}hdS?E0$BplTi;U)dGxQoM(Qw!#7Pf)?Kr9ul8ZGVJ7$Li6@=xC
z-X9#=MFgKXFP0^7#$}Cr8pTL{=HVzTGNtBRdkA9<bA{YiSI5_yrM5DHGR7Wu+)$3-
zt^hC(aJ_nfx(8^UAI%szNNW>~qzOEFGoD*hLtyNCnp{{8`o1p@;v{dM)!Kt|prmg1
z^2`>T@Fp-maMi8l=&%QO10<^ZfLjA7_Xx1FYr(h@pj)3p5DN_FBGHuij}tp2vPz-H
zW^MC});n2QPzYbVZnW3!dk?H`hgnSjAEifJbUO+D`e<T)Qk~ylwHpLui6t|xHPEUp
z<Asug(A8b9>#p)ugl}xDPzt;g=>{*h0qjJg5Ad)8`4bUvDi(~1x&S&?Re<#d;1%?-
zO0o=$kB<+4eyFAWzbU)GAJ17p-2r0`XSuR`j+H@+0w`%{{VoVJz<X4=+K{69x(PMm
zZi47%1{mQ`11e=p<G4aPnZgAFDc+r|wCn4>lc_YAI_t%YZU2<j#=Oh|F%sc?QLf4h
z<x-F5?)oZ+qpj3dS-N!SuMGw67VyVM{S#rGiw*kB((m}HPa-0U#^Gfy^usqg)i873
zHE=q5!HB+hFI(J9H@_xp5h26dg_TZMi1iHvfm+)uK*P<|yv78xlX7Qw6VlS&fo|sq
zl7A=SOn8q_-m@4U-l*NDx)M^*7nRHom>f0vlk>mnlv`oeUpn~8^sT>7To~6)5HzHI
z4X&WQ(-m@-82h2}^Ig|OyG|Nrr3kYj^St<nApvs-0e2^_ibP8x^&5LHw^61wqolq@
zqsO~s#KcDcywydIPK(r%Yo}AFCT(TK3Yx~NK=&%=0eGX@7d{feVwhW4)X-afTk{Tp
z-?So!@=G@i!{y_jo4dR#-P~8FZD$t_AMAU56_?)_#m*XNdrjET>dJV!>azNItydN9
zos2{_EkEeNjA$<F<~aN%5h(6jKI`j%R>iFv6v+5A5=Cs{SMcB0WY^gwvP3N+%X4|b
zZ*}Q@*n~@I2-d=1t#QUVnqk~P@agXC26(A50D6PznWnY#ATE3dG{w-}7oAXFz54sJ
zM;oZv-~OHLcm?L!v9Pnt$;u)E9&3Glo!jr)W6@(HrfIt{-Graqv+!S=0So(uE-q-i
zQBUvVuG5b@dR;Df<S8F9>c2|@9j_<#6<s0--7TAF4JaDM`Hm@8r=RoGAe4e2z>|z%
zUs--|6jPmlu1G%S&|eShbeI?9r`H;uSP&)cCW34+>QGMA{pvIIp+a0-xInM#Ar2V8
zYQ@FHrReGT*lm9?a@NQjo2&H@3g&h#7<o^A|NcEy$bnko>UXW)E*NC-?c2A2>uVn$
zpv_1s;Uj!|F(CO01Z`rln~~j9APeRt4nTPkA>g_o0R;sNpb`|+=O!qCEO<aes-8L5
zcp$~j$;xecAv8Rl{67C}RujWhJAC_+_V5A$K|kua<N@+C5smI-r`D7R6gK#k)a|-^
z&eQ9sI6y)1dhi1ysNL_OC*z9*ZvC;zAK^d)L&InwGp0DoEc>3p5X_HNQdO1J)g=bQ
z;G)5NH!uuiz5Qyx2i()RVa}G{t=Uz>o85rD6Hwlmn|l^bBS|eAh9wPt0U(wjFo_Hz
z<p<h3!AMp!FzPW?%#(NALlT~sEZPNP$p0-9D@1WmI16sG4U?`uUDzOLE{#8!i9N*r
zbm<U^=h09gHI+hT+BMqn%t$Qy<I85h`|G>x)n83SSml!k2g?qTC_k<m$1v~wRaWox
z(Y3bs9SuP9$5;3Fw8mMGp)#`(2H-}2225=r?f2kHE@rf<D=T*a`N>d#^93p^D=PZI
z{5w_K`5I)SN|IWO(QYu!&7?MSCHyOx#>UU=0BU#O15(8fI}yPh`L<|VY1}~#=Fv#K
zd`Sg-ES!9YPe>HoxJRpUM3Wg=1fy>YOy5+-vM)VJFMZyyI|7Q9(Ldf^7BpaZztm8t
zP+WPU-*f{Ao(C5NWv9)of~%j<30`5f#zvr!pFZ==Q9IV(4A8IZ$VD2|G0R<y$Fj=E
zyyL{fp9o+&H~$Pq{6b-k4yX`PEEE8gMbmz8KtOH9Dj4Oa@ZtqIq;t*Dr0*T^)=kK4
zxxwu9`MCeBGk^vLiLJ=c$R)6I;&I74A7@yuY`EjEZ?suX|5At;RvK|`NELnD1^P7p
zHcR-U$BZ-D@r;id{uY)`G@7YdEK*aAV}^@7-N0`;fHfpGg3hSxab&e+0_-A>1KqV1
zLzHpCmbII`{Z7ipJw}K8KU((cp=-(8-^Qs>J$?8A#FXP-J^e*E2lRBOuFrA(FJz<1
zrrcN=Yv-fE6juQ*(2jO>c<CeVR|AHYfIDt$)V|jM6Ir|kO;pni?r}7dV|*I_-ZJgz
zHtP(#0hX-y=}}{SLMJvc#SYcnTG?#fjm04M;B{V>Nc;-R;YKF3#kziv0A9S{;Z}zf
zJYo~^<{{p9`-|IiBr#mOa0gFLIV0Z|n96p-H}O>Do@311t0Ocer+W|?8g2hU%S|M6
zuG!V*<e18RaboREXvu{T%r=I6o<a}r34~9P9dKR~$y^{%%1kz!*>(YiP(j0+P)Je9
z*Z;HD@?3eS&}8bOP29@^XH(5!H>BN9GiCAH>07Fr)+tjlOe4|CtMamY3!8Wz9@zms
zrFM-hos&)k713tvprKbQZl>$b3V(VpIiMq$cL>m!Abnx46qaH7dH_`B4(_-?g+Ttn
z-ra=21H4M*L?+j!wjuLwP*!mW;#er8!G39B1IgajmK|8kw6rt`1hh_f4JOdTmfA~7
zFp`s#M~BS@VmHYS6yN1l5k^Eb13k=I@IUDITbTAjvOi#SY@FSa?wjZ8cYPmZrM*o%
z!R1Xsarhkci|*-17Jmy>y0q*cS-k=z>TEcY7>D0MwmFi~a0)1U2RO$cGz0C#s$58N
z1PQ+Y;UW(T%Ph0(7bf)gqkzGc>-8RupWQ>+pU78CzoQoS;&*8tqj?1i=0?#MTU%SH
zC7-t$#R1tr@@&7qtdP}DAB?(n^<RFs##!V8LFBa9&KVeTvdcZM>O201zXrbiUn7*q
z|LCMA#wl9%kMH)92JyKc<sLn^e?HGT`Zhx&F1wHMD9CigRvs--7rB!ru93P=h>178
zRh^sHQ+3+mV8V;*+Bm86&XY%LZyQ*Y4D7Givb36!p#^_#uTpptBO;t?J3#Wy8<b-G
z>;NjP&A+~4`2DvQpicAc@w_o&wkD8S0;eSalr<7)d?p058hb#tD}27z(hL}TFryF+
z;5GOqgcoXpd5sWAG`Ro<+--~t-iJx}q5N?j)YSf&h2=tutM=ui-`T^zUN?qjF<loo
z8%~`$c5BHEmLbW%Fw$K;{{niAt=jg#&PmOi!}IBRw>epFQNA)baH6(SsfAj`(;6p`
zvLt3$o5Ih{GjMJi3xC=^&bzp{;M_}$cXVqf16m+Pn!@z-h%|l|v>;fbCL$)Lm6W6b
z;gOZILHcOe0kCx*U@$X28QJ_vI;yU`lao_8EF-<3upyJRZ8QO7<})9$ppA$R7?<P2
ztI;w`H-8yGsz|*olZrJjj$GT$6lXsy$j}E~y?u`Fv;O;yN+QEXu7{t7<;Zl&Ir_*v
zb5(iaX)_HjvR~$Zf;}}EI1`QfmEqvvhxZ04ViHA|%ojoQCk0vX?{J=GS`I@u{5<7(
zhL|uk{mFN1X@Bv?+ZueBxmHiUnX>1>@=*_RK`rp;UPbG%%A(h9`Bri(asU`^pq4IJ
z-eY%r6z9)>w|9P(%cA1!X$7>Z<3787!F`^Regz8gx_3_-78JCTeujL8?S-uzIMl}&
zRfZeUG+9}JS;d?bzMR2b->!WYcDWLVke;XHmRO&N^>BO~{Yl*cWUpth-J4nq9mO=;
zj?%9EB*mz4fzJTaNX|=FpiZmq(x<kjCT**6Y;@GlIUQ6LK>}$4GcFZ#UUvX476GE7
zs;aH0H)BoFvb21St0*lkoi53utfnUS<jE>#)#Bo!;FT~3M@(g8W%0PNj<&Y;iIZp6
zMcTiAB0yC)98n^>a)~DDSnNn3bjpUUXnAs7wv8%zvtCK%o$$fz4;7x=uF9oZzpvrq
z^4=(aJWEcl4qrqa5AiXGzr&%HVW@1=s|4aq81M4<C0DwR{Yw7qR+sTmT~hBYrV=3S
z^M6=p(r3i^ZML{!vu=YiWAlCq+R#Sbd!S9L?_$XG++0q^-<hqIkk0Ah0h(i($Q$?{
zQ#qN>n58x*y#J>&P`Rx}ypj^vcQSo5I}HrMN9`ob_d+jCxii`x+jFf=QvvYg0S18|
zHFn%!11F7+j-D#w%9fX(udS~izSQClM#tj8+sDClCnq3p^6F^4Pm3r;<3H5cw@v)y
zg>l#u!%FcpeQXfh7S~W!A9r%8Un<D+kdHl2fh=;=9usCJAMmZ=y7sK$EgV$;(K>Sc
z!Kx-SQ=J$QBxjsY=k=MQL7bX}>W5t@)^yB7zC{{>m3~a<E8Z>`=E@_GuL;Faj&Qcd
za_s`@>oK4L5(1(2`b7(d7k6yCWWy^WL9;sw<Qe+|%ExaD1~e}&jy9UWG-s_RPoN+i
zTDjSGZvunJ(-b+N0eDav-#_?pyYct07o=0u|E~@R_L~d_(s*BEfD@4rA0N<hcXL2x
z?`@C1nXeevy>%k}d5V^gFHwKq%2FXIi;PNTE$RRv@5KG*hnJRqpXBfBc_3A_j_7Ae
zt&^=879IGr78N_m1GhuD`c)0<rFY}YnFETtOE-vji{6&w?FR_&rRY?<3!nH_As15w
zEj*dFwpmiy-8c?-aH{W_Q=Xz2@<JQG&zjgk%20cEvZRQG4UGXo4Gr&omASDJQ{wY|
z@eWC7ps4c0UGw*st;SqNl_Q%YnID}U#ui5`$Ik1P+FAGMT2n76I`(lt6w-3s*-$!V
zt04FhP{+*j^&gwBrJ_UTUOaMiZx2{1EqYpj?;&C!qd}_5M0gpbHwQUwqyN^Ri)i_m
zUt}8XwE{GWhFR(z=>^xup$M=E8$YGC&#)GAa&%VO_jYU-reK+Vcl$uyrs?Jk<^*cs
zA)TN$+X)PlYp`KfCa7rtYb~dsunx#QR7fk(s7e)e=VVe#{kAud{Q9E}(ENb^Oa#=n
z#BSdy2%Rpilo(Ub`p^Fj(z-LgbCZ4fi4)k9mA=o1a<q_6?@cJKAJ^&;M%1KjC*Na&
zCuLX;k$)4lkU`y?)`}>W_OwTT!(`P%mJiI*?GGOS9h5C#jyreV0w};k&YZ!hw-5U|
z&!5kqoeZT-h&Lbl9f%VV5kVl6Q&XT$agnc~<5yl3x9iSRA22Gn+<(q)?pr?OKUEEb
zH2hy;f7zpcykhF)uq#&hSgX*uCnJgL7>f7IsKWT_tRtw0n^8EL8Ds6>6Lk2jG5e>`
zV@i*=86n*CJqCGx6xmeNMcH~%zIWVOo4;ED0!_@%F-$?Sav^1i?DzoC7qhEqr@E%5
z!`0>CTF=Yoap1OLeq)1!zm5`@T0Na%<0OWT(jS(mffws;fPnBQPSFSA>N;vpM+XJr
z8oU6U65xtzZ{((~!UBo;1AU`f2YM{&!J12V#u9&;O4+QQ3YeQQrR56B-_&CCz|AY<
zTcerVJI+W1YATMdGHwRY>zvn*ei}@#B`JZzUz#aY$EH=-C;NpT|4Bx&852H!r9d&_
z5{{#$@pw&6PL5sXFyGMlxWm;KAq0C*&&y&-Ce3toA0|*5X(ve|>6ZZ($kWM4x6^!a
z;Q{Z298ja9qUE1^x!G*zt1EN4+kevxlSHFJe|~&GkP_!P+CEzMjOUTqJ7yI~+(%CJ
z)$<k1R{e?FJ9{M*YEo9|H7v<IiO<AB(!K}Wb>+GNUSY`g`J-B#nnAoA)bB^RS&S$u
zLD(g1kCSBIp`(!{MrKh<2H?Ty=qRYd=>wzNMC=Y+M5+NMYk-j$d6>p!m-W4}y86=I
z-mZFHTv}>#^_V^SbrL*g2Vw$_Z#_zK(QmveyL^dO{hSSHRyEMcwr72-OTXaXS(Q!M
zwFq${^Y(lR`2GXGiP_l1=H=C$K|JT$%+o5dN7^(5X#owj4X(bhHf&4VN1u>ozwnYB
zU-HBYBW8gBUA38N6$Kf2ts9f87l`dZA@GKpanjXxfYskvTSLD!-|hjR>2+<M_+BG9
z45(~ZHoIg4yi>Ecwbm1U5`mkOlJWrZ_hCDi7>IqJ0htnr3BW<W-_Vg0U|?b*K)^Uc
zco9MDM>z<j<)mo8fq~3~r~i*vhsJ13rh2#wtT4pl!qwQL(wD-9d!0m^efB|-nMJbB
zs?ZnciqLi=1;eW5bAk#L6BD^<{SejAGf&28f2uIyonQB-H!o*IEi8#x<V}ZE*RC3P
zPCDWz#d<clJbeSi9h7)CZKfEAh>-$M3Faw2gYAJyA4g@IDdXmV`}F`93;}X=elP%X
zIB@k0mjyqdWe?|rVfJ@GyXOZ!jZ|78@}f;ead8)ku}>fvKWn<u?#sf(6%N}|c=n7G
zUM&n}9ISyMj>0xY;-1GpIK`KHBMFayuFjD;JvmgvZ#y(1LKq+=bN6k;#fN54bLH(*
zKX*Z@AXSeAd)0VHd!^=;vmWgagcLg^F0lP~>Ot~)9`BJ>Q$35Gug<n0;dr;PmqM>y
z%R-8^;ie`?ct7m#gmw`PH8S~9rV#&7ygw1@=CS!8`i%5lvu7rN+)mCpf8I!^!}}n>
zUQoZipt~$gx9<j3tFCs|Ha1Sf9F42ra%CYeELWDD2B@g^D?wd>va+(>9hl7d&9o(o
ztDO`S+}Jf9blmyDEhZRH=`T%-1SrxFFnhMm&fwK6I=DJGwbSuOp%ouOeM2W?YQGCp
zIPcHG$r;wO764jc)YY*;aPkhWEPer`3uE*0=-f!}jculO;%>ygTh*7inT}JoY_Wxu
z5boenhbvRp@7f-{#R3n?Yob^BnU0Xqr7j1M?Jp{PJt(Y@ZY2WOIJAxNl5v`h7jb7Z
zSEPK)3r-FN7m+p>*0{xeC88U_prbVoU}vRvj$GzGXL(`h8+kGUxkoKMy)ZCF5D6s9
zx`1JWSx|{kmcQl)stthcU)mLTgN=fi<*|-Fk||08&I$(yhsR+T>d|b+EpZ}~x{SFw
z133i+xUx7&$(d}Q%>~ns{!D51*b1IRB#uu{PfO|QlEx@p&-&kx06n}Qe0qgWi`q5t
zAP+!;AD+${=hxK{!IND^o}0wIeVJc=%z|OQW5T<O)|-7i_wGmQyB~`E3R2UG;11&A
z$xV|_jm}h6v&sr?M?|!2Qr93ML#NNnM~;^5Qnk0DH%irz@t6<XBmIXdMM8D!3PlH$
zVGZ>dc$tlfPi(a;m}J|zAH3JL0FeOxX#zEB6KLguUv2QQ-Aw>Lj3;BVJ5vrK-_nYg
zARP~e({{j%A$*TRm^CsYfbz{cz%%`zm;(U<R68%gYxr(@H9h?l-YK+|<;@u<c$xIw
zx=&qbDFj?7`1+gghQEI81}y3!Ap5~+`wLVc#$V-iY7MZ>Mf6p4M1+)r0*dIpA7g>k
zV>(`0q3kEcC-}ioDXbr9Z%&NgHj8q8WL6Bg)J*PdYe8N#%AHKbTm49hKEV{$C?`%E
z5-?a9zLm)vas8LCA^9zxNfRCV6Sv-+mn$g|5rf%eUd~(5(OB>Td5^2T#v{<71P6`)
zT%uuP%UfHsRWz+*7<%v3M?^>eo?;d^?MCtef_d<yKlsu#4?&_2Y_$ru2WYK`*jNQX
zoO6EpK`@f>m{5VfBT}{9y$4$;qkc5geK`_W@*4h!FTfe7eltNg$lFm4xIOT*C*X<N
zRJe@Vv{~Ur`F3YEQCxCba<+q5#^m*;=~6?KY&TCod2b?pK&#W!Reww*{>nWPIf!O-
zBA&TPyxjEOkuLGK_KKjt8f3k+-dotj=*OWvpq3#p<7+i|b48M5UM+};Lm}BfTlHdo
z+;3*Xx1gY46~y{W-s>oc_d9gzBNlrX95Q51UNykU&fW{gH-s)Mya24-TJh(s?!g4a
zyYjaHlY$B-9}wvQD=#A}E88;PEJu_YhE35ADz?{Cl?yf;b>TRJz^iTCq19pq<<SEm
z(YX~pQ+~E_QSn8&F{ai5(Pre@ySTIFX3yq}5dk7Q1$`F-Un}Dd&P1LJ%n)bXJ3Nrh
zatoUS0~EF88fGD}E_A~qI$`_20f8^2Bt+-25S^R%7QYYzo=Z_jhme4f5Z)rkz<f1M
zbIJLkbkB0EoiQ)5yQc?UMG8k1Xt}xbFN<LoeEp|h9md|}{@zAPB1A)ycbw0k=Vtqg
zcAIyNRIy}HB5+%PevRWCARe`M=b!<t5>^fBCa92md6y}&AM|$(7*8r>a`8+dEIyep
zV(4F^k(9aupRdKwegw}ELd8HdB%cJc7~rG@4e;E+6ncQ8f=@`eAv8Yz|FQMfQB`)`
z7wDn8L%K^!kdjUjMI}@^1qo@CZfT_yBqc2j1f}~BN=Pap9O57%(g@N5cRl!hzwh2L
zuK&H`9h~!=XYalCT64`g7m&1|WL8@W9JIByb#y%j<JegUaa2hh%B1HFs2La#`3N*_
z$bgOU6XzfKsfaD_HgPfJ8#LI^B^kV(zbWL+!H2PyV*Vvptrz$DzVXHQ;;1p;QmxT_
z8&IFA!Wc&EEzpim^DXii%!JQFHY}TgCtmW^*RX-1`>lQFwOOvLb7KJOJ8?;%*}1Z*
zi+|VPEy|c%x_3Up&*}Y{+Hru5q(bb_ieKM{o~I48GS~^9h0p|xLthbK(8cY;DgRjt
zAh+P5#G7`%mshF!uNSQP-nk<M@a;M@k!CKa?$e};n%=`=ZI15IP~g<o*8bzg0ay(w
zlyuNzz4QX~&4krql^caKm``|hZr3yprO+WSHj2fYs=Cg)$0yClOSX4h&Jb9~T1D)L
zV2-C77iittKVj30MJgT%6nkW-W6TKR`Y;z4xb@#%icpd#rPY13`7g&0zZtHmc3a84
z{bwkHe(ByoF-e@{?u&_T5Q@A9P82b>=TyMFEzAN@Axo-Xgjj1*dHcpvER`&)d(+;}
zs~9s;Mg-<Q2Xq68;9XCX5~HEvVO#L(^FQ1g9Rz?L5mkZp9sJpF_~SPMNIh9}G`K82
zI$6bH$EACzbi1}Al*#u>^Up%nKD3XMa9)YZYmD!;>q@N@+IdWxnVJkp!lhdhT2F3s
zF+EB?o;)M2Pg}&*iNf7)DDQo)5;tx4vb~O}?UO+OHh&0aZVaSsA`WR_@P-OU(gv7b
z647P9SOFc<rJ%!1FRw`v%aJc%?tu!e=+!F{)H<+`Rui7*PKO<bL`6kaU{qiL7!t&4
zAj}z<n8dLw`kqLa0C(!3J87so5&zDMaFN;y-Ch_?JYR?56_t#WiQb!Zv9>mkXGsoC
z{G@1?>TgJH+cAmj_k(2FX~08H2W@A^XTkD0Jib^8Y-Ab~{HKH?cbf_~WA5YcwSF5h
z>^iN!jJPeTwxKd0-4Zdf0ni^64z_eNg|Qs>ik|G5FEBGV9mdpl%(eg>Eg7^`I4Drm
z-5J^V%pP4Wcpk#f;04Z)aO+`z`<L0a5fc7md1@x?kWVz39B;dnZh5?nO88ShDi($A
zCO!QAQk60h?Ih9`Q~0`%-xDJqv6k}(Q$o7_;~dE;t+NnkJR64aD?Hv5HdzuHObi8R
zKER#(?vIpR_p8cgA$9&s59iqMYD_hB`%NmGXzWe5OCLCMLtgh6$2xS6ABF8uJ(5J)
zkV}UGf`YTKG994ciHE^;ph3>{(msP+Y%~<&D~{N074+oK%A=Kl!iCVCx@u_|n+#1(
zt%=^TYE2_ZR?{tUiI(?Q3JI}eY$Wowkft?|Bon&n@(*3PMSX!C0*$0vttd(N^Z1l|
zruQK8?wpo{b8A4zD||<sxOmjnr}p4b@`YZ05^zEAfdGo$nEPB$pR_vN+&r4hdg_$l
zC({pt%HZGT4+<(A6ck}NV7sllW!m{9J$;0c+}OzIEYvvgk3}PUavvqv`K_L|`^s&y
zCXbPRSLHM9$G8)ZAMej+x>sTELx`l-9C*(dVeU(s=0B$=DS+MkO{+}^!CN8M^R>R}
z>Dc{M+k#JH0c|>TX(FkGm-WK!4ZeB71s92rH-W>WOM5fnMR;Iu_Lt+A7~obpBJC3d
zjzb7@(CiIbYuriLS$N>x22@cM7v>+2MU20L!Vbh~PtMUmiXGX4wpQm^G;wecK>Vq|
ztc11x^P4E|Gmh9*C(#%}uf;Z;i!HkaGof4Ay18Qh<?k+4uRxUSq>XGSlyyj#t?p}3
z9xs~Cvmvy~<g(37?0E8v&vr-c@Rtx&2RJN>`J&t(%?o<2MkvWpB6-m7e=&ut?N40r
zr&DtYknW|6Ti%Cr24;{=Xqd%hBf;beoKW&#E@7Y;{Jrt{3?2$tb%{W9Wn<KxekWyU
zVKK2S<v2}C5gMYbO-<v~!^bkgW+mn6*7zi%zHy;ob=$=J?A!ZcAzl8E#umSvq<nO1
zg6%On)iy3Mi)f`p%0t9*f92K4$hz!c>v}pdN~@7<u{lZYaK`{$=sSLug##!q*E{Dg
zXg=CIX!}>qL^9x6Y%pK>iux0l;v&t01ilHF|F;W|_uhBKtn))c{c7Etwr%Jbt%2a!
zeNy4ARU->3<>A8!#5@%c#gKg_q#poTI$nW~@&xqq@;tR7Ep&Cs&IFzmCOD|;z445C
zCGO@Pj#zh(A)=a8%`bl!W$L9V`i(iix*gnrfM@d2NhdLjAQ88Eg|>JrTPu?Tzd^!E
zBOz;s?qRWe#C&esfQmd}&H0xr&)yD<V10w}`HY0IK2WT8^r|OsNp-$#t`Q6iILH}v
zYDct<h&?zeJi{uG<c(3u#-7Vmg)<$Jg`!Y~*RCPCHLs}XTk`{?6r1_&uW)#roy{U@
zQA6$Sw`AP_aP>@=wlqFWy(}s#OJP^nYL`qU?p^Kn#khW&BB;UqRYHf9H?iE{2zk9T
z{r;j7bId?yR+t6WSP>IjZQ6p?rDK|+jlV=R;j-Q0(=Y49$+05c@K{i*wT6%A1^;Z}
z<v4r)&;J%c6Ti9cl4d$IT;N2$w`su*-t3k02lXX5ECM%YKDA>S_B}!<CFZ84r;mcT
zOa(*Qi{HFi`lA9RRhd~yog0*%On?m|=NsCR+>(+s00}@BY!|X@#6z&4sfh!Hbh@GZ
z$RNr;sr!kYx6O`?9*RkvwpE_8E~zIWGW)}y)lYG8=gnwC-D2_THdSPsXOc{uU>o&s
z%SN<^H^H*i4V!XJ(6R7EF*B<fV80~EYKGL4kDp=)AGyd2(gv_<5hmDJxAA3x5{bGU
zV!1T5l#p<K^mp%Dl^ZL->3E>h#JE*&9oTtHH88&(-ybcWbnifhPL3QPdkf*1RyP7<
z%qr`OhJ;a}aScrVku(^5COG_&5LCqdtaft0+N&|!cFs~|jE7ZnBz;+~v>I*O@$*yQ
zWYu)Lz=jqRPt$9L8WBD848!GIR?4^C>5v2a>qcA@Dc1}srym~?E-1g$1@}+UIid1v
zT!JQJ&JceznINWbh%%BP69y(ib|yiIPJ|G);i+L^sP4}<+jr3-0($TxKNq|!fi&ZX
zh9D=3si`?<@8~!SMlV{B+f$u%U<Rp&mcJ0ysK3~?TJZ=<RY9|JN|S4kg{g3?=Y_D^
zNqo;<XUZeiL^}@S?kqEU21Hk%(#93(xL77k?s0nEDK@*H$$)ePv)ISV%-{Ky)+RHT
z{B*VpDIkgjxP&#*zaYg}dwc7l7$aF;(5igCN-0n{ZMq)uH%|2f4kY3Hg^$DO<c*<*
zmq#-6tG2xl&DWS~QvW&~VjOOK)Roys?~nY#&%Bi-*veI1Ylh7W9&~5!cOFE~+VN-F
z$5hjsR2+7gJ5GceV*+@~$q}ejB$fMo=E=*#iNg7h;oC#bO-KrsZiUzPilCK8lW`}E
zmxK*U0|9_QxhG%5UX<tzG2~xYttU{jnpv59k3LRJx3Txv#nBRR3ZG9jjBBXtV>P80
z$`H`V%ECXLrh5x6MgktfnjccKIf*9%9eH_qM4<Bz=ouxSm`c-E`T4euCL^?Jw3d4z
zbknTyv!FE#OT4tyXaHM}-OsSs_>6a{r>q#Ll!BA+&)@Xd)dUsYO}!8o&-!XeJ!A>G
z=Pn|!8ojIif8w_T$}U_Nsk0!P>d2l9k;C)L8QrgLxlfQ~beuU;S6)jq{f*TJ6H1rb
zNoPZS;P)Ke7&IPRJ<5j)>-p~&_$e!uK31dWSZlD2!|7(|0-;ls{cJ}id?=iV;LcfR
zvB+Bz>lM5_3ONWuujcQ64xv!n2@ury@}~t!;#I@uZsFz9J$m1?Tn_MNYJxxydGZeu
z37w7}DiMNJ3~xbTbhYXg)KLn*x&!<!lZ;4=1aF$@X?+J!d<ZR{vvQ=R@tSxhd-+SJ
zqlLKf(!~xycz?aUbm@}+dob96XeM4s!_oT=Gm^txGljEiuWEX{U9;FCBC}txzn!VY
z^q0@#XXcnP=XKJ*?;_W?9plm8FUM3%-}RBNNtAApP$by+<F6w?Sl!SE{D_*1E0Pya
zsKGou8`q}FJ#f$ti>BcsQRpfpYd`vMw4!=j*k-h%3PT!>DWdboCD&LpCKjE*s5Io}
z5dS^XX3kPn$2OszV_Ty@ut7D;&Admz0Q+{44evjun>?z+Na8Ge+E$`-gk$B+kZB@|
zUaC9h2bKo!hy}<VpFn-Pyza!8)uV(%nC17Gfa9A;L4aGcIElX#J$!y3eEz3Q+Zq7|
zPz0rrlY_Nj+^=P(|0*Z<UTrT;Z#M*QB)!nA!_dTVC6u*O?z;RP4`th<49WU6-Ojgx
zr8=9_O>ksQG_%s58a|!;h)c5JIrlSjDfh5eEMNq2b;<vC9`Zi~^`a@xe%kT3o|a);
za@Qm0SUpuZe!Fz6+S!53Axe84OT`19#xWs+y&=OaCxAzl1m{7MDAF8$_XY#9^FQ>E
z8G(%TgNf*WHooVd8S;tTEBh$Fdz@){@3v~*7giZoyII}k(Osb|lH9arfE=K)4P(uR
zM<oG|ra_GJeqPJd9F0v!U~R97<uG#3_-06qLxrH*1IOy*UULr#cahl^MTD`6r6|8g
zocJ{^F2Y#)mqn_nd^10P`E%^5pLGbme%dpP=vJ!7B^*Wv`1C?`%r&b1PnwQY?xh!_
z|7sFeLj?`Rx8bzS|DB<i%i^W9-7oT@b2==xitjG9#l~~D5&fwo;a;y^w5xMdjgM1L
z7;MK=B@VXW_nhXy8FpC|gT)fAXeIQwQpSJ(vT#%TWT}etCD8o&phSn!WrLl-oK<+R
zu`xpBGCM1e2lywPowE?vsyO=4lQS|0vRdzXCTZmgO5K9)@NTgCPF5kiZh)vIbI-IA
z{dW?VqjY^c2Ev>4t}_vfc_d~6!jELl9MB1%K0jbaaw4RDurxL>Xn6qA@}w+!Y}9}P
zv1gEP-kOubvwCH2e<pip8%?6Mv1;DSjF-ts<|B4CB{x5_L<A`idz4<mJ>nc~c&>g~
z#Q9#`d;Ib3>^|1>$o6K~NM@Sw238S3$%haAZ@+Nf{yn5Yoa~;{J5+9}##(drzg&QF
z#YPA0RVM6~N6rm~rQ0Gt826;4*q-(N(vTChF8s60AV!`9T?E*zv*(v2>1x7iYh#}&
zp)W%Uv%Y3Z|MnBff2tu^`OcYbN;*E1L`kq9fzl|x1zC_rBjf1V*MZ|Ac%clv9t#KM
zD?Yf#xq{d~q#mV7MCtYy$)}wMXyz#Wt<FSLJ*TD4l_mvbLxG|DBT35TlLhMZ``=mO
zjx|@+9KIPBCF*nBzbicIl_tN%uP#WrPHwTb(UlRS&GXTIMt$d+;v&J%Ig)b?t(Yt?
zbbg<$zi#A%;@c7Py@pOXpK(f3wYdr5YA&#NMBMeZ>?<6w&iVg+Nufh2bB%I-$eT0y
zt}x}Qf}i}`lJITkPxDtO>fEZmw@aqG-KaA&M6mi>m@|n4>3O{B$QMKv`?PKvF;^rf
z<J=a!=I%y{)E@vIb#*6Sfso*YUB46+tZlHHcpi=(DHW9?(Br*&o}uP{m7{i2R=0Pt
zwh}scJ3C`!!*g|*K|)@K*bAHC2Q!(q^EK$wJCGyItRyhmj5(1IX3dE0sSaZA)x9EL
zywHL2gRcXu>T@cz6p%aTCCz`@IOmYV?oeK9y$vmneuMyu3I}hF@~81mI*6P3zY2!n
z+!}4Sk)3PucKKHq!qq4oi{lYq>4xi1sXW7I7>H7PD)|rHdPHy2)+ien3_hJ!5o0k?
z(Z2T(9zq@}myl|5s09ipzxN7e*`M6Ak8w|@wTS&ITwWZ*p&d#_;2226s&(Du0Eq`y
zm{gU#?=ll&{eg%Bi;8f;`vC+(nUZ#dKl^gY9z?rn|Epmcrl3v<k;e1m8f^|~E@bSO
z5TC3ve@f?Hc6j+>Il81Ce{phu<(Pp)NyX@1JUo-+%=N-hPkK-RqE{Dc9;)9v%Zt-J
z{3@mO%Ca;P0TszTyBwcf6%0ShiB}v7fszR+v6p>=FjdeITAr*w6|}SZ5h3CU=K14-
zU~yTrh`Zp~GkjEYr8W}Ra80e#^xxf)o3VKiDzMg$^CaQ`i8+{gqG+20nK&X$@~57s
zVz|}I^u;6d%bBz|Z`nH5)Bk3yI}NCuj)gr~&^PSGd;Xr17)OkYA@}*;o2S2@)Eifh
zKf*PxePcL0WJOX^(jPdO{oe#+t2VuzKnsY#`ZISGfP=dJ#`=&Hve}rg3+)#;L!yvA
z1`sl90N*Zy(h8s8Hy(9S%e$tgyi<w@{CFBIKQUZ~Q6};98`Hg8edQ6(Q@1X>jlk~7
zs}1JXPcfgys*hwGjN}R2Cr^9!yqZ>#B=;9Kzjq#X_0a_<-0_UZ>#m|W!sZI@d^m8&
zN&J;&Fns$sSNq=;y|4pEXYc!|UK_y4wUgJHZ+;{NJ~R~5NEZX7xNgUOz}Vs8=O=&}
z;95ZVMOq0xIdaLlC!{&)&aICuHB)n`9fbUCd{jLbaLyPTWB-(HjoUMiYJb{LJBSag
zMz7T4Ut-%|d8!%i=*{<yY3flvcnKW5BV3Hpq`uXgTb0_M9COz1+z&ohMZ|D|kRr=c
z?Z>n)sLyg0{cur8%g53`=nKrvilgB*8+{M6zLcS`QA|21S*Wkc2tK*p=x(m(fc+`6
z;0STCU<;U@E8T+qiE-zPTh|^RL<)c;$`bbg(2@mpbT%6aH(^Zm59<o$EzjdMasTu+
zq!I&g|L-O~(|j@{Pmq>HQsP;V5=Tcz*Zg>-i;SSK2wZqBBrMD#-G2y!y<83gV2%^}
zG0*3-4t-BZP)@F{?LeUq82BfPm5i-_F<I3lRH&rlZ*wUtWNaur<m%y2pZU|-fP%vr
zi)#d-IU*_3#nX8=365l~G@_90Pqm`PYmxk;<?y9aT+t^=j1I4+?cZtFOb#|8d9kQm
zZRDwFn-?!>PW9y~BEv|eWn_@L4ysuVZ|{wQfTMcf6<id6jzIMB8F&BQ9`B|)|MTZf
zka#NX!e7JRr}^#Ko1Sfb8|CA|DV9w(Eyp?R_L<}od&=l$^`iIWih+ZOI638P1cwbY
zq4R<x)>!^vW_!_Ov;6JZ%u|oT1}HIwO=h@Ieq6=qyi(VH$4(h=laDWc9!dHs+>ryC
zp#8L;^9}$mHPFz7ZT~PmJqDSh0_Q>{jDv!LVt1=FED?{0vY@t>xv;R1N#2_ev>Er`
zysIN+eDM710pqDtcqq^s+DP0z5>X7^UH9GLE@}}G7f<?^o#1A+U3*^dCZnbKsLoi+
zrSy<kNdtZbM>wk5U<*5}5W*Frdlwfk9fw0oIU5}kgkLqZc&yq@+#sQ@@#t|!EMZ=;
zYs7pdt&{b2R8e{AIBr{ijAj!T;iI0-bpL;?OeY(_fu#!zKTXo>m&$iDk(+K<4zB_!
z8wKD}%<I=oQV!%W8za7~Y<qe=Pbt8=l+y($LWpP5%j4;Zi3Gq%D<+|Xi}WL#j`m#|
z{(R9z+{?VZy~ii}7w#4{HTg`w`S$IbluGQtfIh4lXaKKYzrLQ4;FR(p+3}+KNrKVI
z=3a`bCYnpV)7UNe()>I1?e#;26px`BPffp$yNjSgnLkqb5_<OxMWG{u2#&7JZTUUN
z@ejQhH6t5iBVE?+B{w9eTX=LJgk9jPO_XR^|9ZVs^?s~9R@kfkKUf19fNO@c?iv%L
z%_PO67LvDQZeA`_33!W)q8R&di&_H<jNmo^B5cd|jv`4fK9X>sI0v&F7)(t~p{*4K
zjP0Yt1ElqZ7~2)UecO(7t7Ke8DnuRvn`~mceE7EV(rhldr(QGXzl%X-ia)L7(>M1u
zJLA-_w_yj~iA}*9w`?EkNMr@15XDjBCNI<ZcPs@p%M$pzgMQHllCto5#|NZahrIf7
zk8vm~XSG`hg^Zu80YBr>McbF~v4bf{A@$<p*geMHyPv#ULS_)%4fq7&puWDi(#D&t
zgqzwm<a_|KfSr9wMG>+xz*SD*?Y!LFL>Mkk2*;=ua5-Wi;l^@?GP#Vt8-7f4M<Lfu
z)$cj}R+sF{>Et-Vm#wWDC^ZB^{8ycE#hN$w*;)6X+2c04p7${ZkDHWYwm%DniiB~A
zjaeloCK}YaIWYSRm}~e7K^DuT!7!jA7CXO1dvcXP_3UsKsh-Dn9||DXZfEJ#=jd>u
z(w3QI*|vsbi6Y1TaPL(U-^*v#Z^s5}f5or(+U>9v`~QcAV=|eUnGd&v6-Yhw9`TVJ
zA5I@90wE9!&GYl>>NsFxDjE8B_gYv^re281<ce?p*6*uT@`s^X(&s8GDiD(HIR``3
zk{ih_ZhY^YOFkIFn}n+(l?-*aMB3;H%G;j$hZA*<pB)r$kkLVRd(rkK0(8<O7!_Vs
zLb$kpGwx|p66<N&G+o+4i(K5(J?&R{k&1J#EvRM^$88PAseVWE^E8nU3`BmxF(`Os
zofu~yj?pFebk>n)o_g`}C1M1ba_iU{Z%$BkkK{yUj80-#yo<BCa4Vmkvcq)8=R>br
z+Jk>hlcui|pHbEArip|%nk%{iwN(kB&>(KOUUDWs*iB1R^sH_kWz>}p{B*{JQQF5S
zXcXGshMI3fdF3F`|Hu?5Q{TMsNK(!uMBA=P=)5;VNCJZ>n%9H|!AxeMG((f;2YlCJ
z&zTT96>aY9O`cz_u|j%7MF}m%nI9AitjdQck8KwLh58LPidb|6o=H=%JmC8NBL~a>
z1JK8+9M9ftkE_am^ZF0xm&{&=sOV@2c{o6jcAV%3Asq&HqVJLdkp1A>vDik!cO^M4
z*wx!mO|Ux?Yk!dc^0IWsJcxH&e#=^`@pSfFDpBjpVch03PRBTy@0Uq3K0;Gs`b+n+
z{wRYc#sK5YdRh=SX6b?&2S*PjRNott29{ww#bWo;t?^+E3TlHGNGk3{QoB>}@!ECf
z-R!5JHhn~6M@msVI<f4$y3?_XXnu(}{87j_BVb5FchM7o^}OFIqn3V_rJR2MiE_!S
zLHpU&>=$))+u$++LMdT#2VP|1tTje6ma_6NI8f-HfGtwbLsw|+_LtJI9J;i?k!I!n
z@y{~*W7W(KBB9ju-H}Unm?eD1Wk&tR4a_m1Q*y{fm;~sqqa8^_zexC1fn^=%mXem0
z8e(LH9-f)X&lPtf`1rDQeDZ)h>Bg3S*zFVoF<x34-xiQf6Eb19nSzpHMo8QwY(TJV
z0&cI+X(U60nc!iuGjS(*T4g?xh^p$4jh%gR^|&LMGa1s1))`M=b)oD!d@bZcp<M^}
z=8qri_FM=~#`0|9H9N<ZV*-;ml6B?>o#jiT&Aq>W?^j>F(pG17DEi%6`{SOH7UkU_
zR)W<|I?vntD^g-NYC=pz72|?6q-&905fID5>r;Qo_Tjeq@N(sIQe6CbPF+iD=*(J|
zhFaR=rB<_&b?SoG%9z3;H4Yi_jhcrk9Z6A2vUqzwkHh)6W0=pE0-Y>hGV8KR0NX#U
z+e{NEXOPwr2*fnfZy}xs>{Y-MItbtX4E%_}?M*=Y#t)AXQ3NvD1{HoKN7jc4dpkP@
z)MZpCYFgTRU8#bbQM@ca{?~)Y>8=kxi!!OV)G$@W^J_@Po7iEwt^YFcF2+6KyWyFp
zyTzt9Q{oW<rTw!G+O_M)hP~upUrm!_kZwgj)t?r}Th2>jjb^sp?ULv`)uDN|b6FZm
zkPWPxPRWg%YmWZ~FTXVp%Z#eRR~-kbv^Tkudz~m;IufIv$m2dbpMOA3R{nnWfEa4+
z$u5WW$pr^#mfzp(l4lTsA&d(9{YCc-C=@4vQlb(>323X1j?OPnBe8*fw+zR;0K)0e
z12L4%P_Y4f-xIijMS*Y`4y*eebS$498(YOglN<)YSp^V${P+=NrmJ!Ap)|fYEGjk@
zktRU&3%|WBobQ_ACLyeD*%a2;k)(O`P~{U5#m<6@e;0sB=UZ%<Y^ye~`#RCruvM10
zGVX`l51vLmx9gSYWb~!oVl5<b%D;gw|4psGv{>`dH0G=bL3a<Ij!|fgI+AiPZXJ}q
zR;TBTNv|&TIUH{Yq5gOwut_tAVB^=Hsxl*HMOwo@V;x#aIU%veI@0#w5Qwn&K^cUG
zLLm}(dpMvjhOtm80e`_mg7i$|AKFkb+d~Lf7eJ?TFESD&m<HFcN5N9t?yLeZ^5Ek=
zWO!?CDBeEu4#C=y^ySxhkjv1)CrSzE<&ndGBGeLOS{aH<Muq|AfbvqEXf_AAM!vrr
znOt4nuMW7fztN?AQ9WI3(6PU{d!@CR<u;%W_mk!$U?!xWi+@nX`R2n0Pn$g^62kPC
z&qI0OT6oI1Sa&n7t(RTSkgrpU)&_7k!<u*`j~)8DGr6zrw0B;AbEh(0bE=%POfj%Z
z>f*h$^a;kHZo3N_mvm#El_`8uyBV&l@^xY&@V9&Uo;zvdnCmBS0+xW>*A-Jm0TTO&
zBB2^k^aOA0if54Jhio$=a=5FQ_KuF(nOM$GP?RdTr9OTf4Ki0`uoh5l5LN}I@*-H7
z(CH~f6cljfxoT;ufl3hd&iTqok+|U@2nf}rc)sgsh8~BVZp_8)$^7Fb7m*p7mm{?m
z-DiJlwXdW1!zX#yb1Wk8d=IxJxzX3gXnXEMiMb!`TR@X%OsNq(J>bl`M<gj>p~z;a
z<Ty)*RQ7e6{@3FUpX+ZvD99ytJ-_fiZ%sn@tyuA6I08xv?1uW&4XSr0mZ8vf?kqPE
zMPw0Ppc)3+Cc8;vpbYrNg5$wNX|iI_wkxn}xPd?fRKg2xZeq}LfbJ0RRvyByeRb{S
zcTliIj=8EV9f{Zd;&}@KGaz5J!Ne|oQ&SR%AZcmz7C`o`*&cVXeP2e-cya^T%&!X<
zx-R`BpNOzJ9;pxBkeL}IzOnmTGwhBt?xr8v5B5<HPFuXZ-iOq#*dFu6prY3Vc@(h)
zZm*Ur5~T&$V)B#2pK!DyH_u}Cfy<Q;7n7W7s_|7Gryxp{SYO^sk5hQ?RWld;AfB?v
z-=8X$5MDZp3{xL0kb}NYdHVS(_{mUk2Jbh}($Y$R-8pChU+V4DLaHWeQWj1GO>BT;
z;x;HfAwZ3}5W4%Otl>^5Qz|yOxPNgwxJCb2a7XS6vFN^)&4VUyneV;m?BBFJSN?`4
z?Wa3!tA)HFUp$D#ss2@#D6K?{T$9~N*w}Wci*g%Z)+rBcv)`t0fu&gyzjw}XZ1(UX
ziDXLo1q}{GQtxe{&ZjZzXPL(aBdPy~KYz(Vjq+Y!c2g<Bq|-fFET2F6FuIJve@Y^y
z!RxPoFlJ3j+;FXMn$g{r!h=qXysvnTIGJ!owF4W_NbhvlZ$fCCysfeg99YQWUBn>?
zSa5n=DcCwr7va{Tj$T+D>+2EdwEJT2IGV&taBEpdN3vm?L->Di7tMt;Bk0LBp$iXQ
z9HX2p^zZBCRSV-=y&8NOC#U^MeWs^Abj$D+n(X<$o6$)M8c2PRw;w}|JHE|Qd@K|r
z<ac+X^R-&707Lh!iz%1SBK7y~(ZXGI5g~Vq+j{RT%?-Z7TR8n2p6Q|fr^I_{4@tW^
zGd+sGKRjvsLw>>Am=%%Zc;@TmRf%Zcai+!8`NOW?3T!_0cQK*N>>YUH$x|Yy{O>k5
z1()#PgfWY73nt8nZBe)#d-+?*6B~Fo%o5(mpX(se4}C;>dZ-<CPEj~t6ePeZH%R3@
zI4fFjqMvTN#>$fYkYskVEm3mkdlskfdlzL3al!7r2}1q0gpuT3{}^OAI>b1!FU_iZ
zZ^x}}9ByX+xh7d28EmRzs(RpCB*tV{(xOy+_~VUP1W~g`^Y$;!a=yP3X23ja<V+Se
z$C_G`ue^DE71KGdtzH|7|3iyaF#)LuBeql)JT(rE)XYuZ{5*vtv!y%*ey*=%-u9}{
zjJ$ZRW=Lp#o(zfEIO2N=qUFJqGzP}Mb-{fQ@EeKRp+F}MYus8z{xm<iB}Z)1ra`!i
z@r?%4QmTMZW`=&ealLI>(urJP_jh~Dzr0u@ppHBc&oW1`$779<W8(2#dqJHAZi$IZ
z!o4RFzD!7!5OWkX+cj2M8(kvhvbn8}@gvr+%v+K8Mi{WH(>W&SFq+gGPOl){wA<-b
zzJ`G0gB2q!3F_iBgJY2DuNT3z6hOxd9Q+Ql+>Pw6XRNI$<Bb|GO*ehjr>OT`#1myk
z`#gNFRB%|(!!2>fxM1uJ%QQt7+N}-l$bKN1Y)y9*G+E(F2PnAHyT#1R^K$9MNAQ(j
zmOFX4UqMBmC+mFOrc|5)N(xJgUoVaI@sSvso&B+F0J|vai8ASzGA$iVX~CJAF@T64
z^@n-6$)*o;L-XsTyaHYJf66QBwJnd{OXujvCY~Q~>`2e1Tnh`ceyo4wc;)%(cESL0
zJ990ggY_FPl8GkW0`2A@3GqY%gfIW7kE0m45*`}FPMF&TN1I$)0lFQDuB2%$hJ_Z{
z_+9O1ej@SMDX#I9(Xe{&wBK!C7~m6*`C6VE9sR_lx=QBl;|nh}NhzOPj+%9thTVps
zCkUU4%{_#Aykw(myKP@}m!H72sy#HUPliKoO4aHOW_z>q97m6e!w&IZS>uAC!s$?}
zbL(OAI{JKlG0#@N-cM@V>{gF!on@EP=M&1{)7ZNx{EV7c5s0dU$}<Ms+Zh_YB2nq}
zRAxsialDU}F<CsC-Ap4aBY96Ob7-fZpBbjfrTAa;nSn*Sov^wQvbhYmbJhrc=G+mL
zh1Huk_bxm!6a324RU^QYO;k=*D;=>{Pv9%JSnWuNr{|z6A@VmRrS8J@YIONKrtyp$
zxm6GQAH;Yc5_giEltC0zI}I@cP5}pIj^BPVYGBGaJ<kPIm6u^h3_HiNUOJ49n+Rv_
z6aBv)#B=nQyLqCdWmBnN_|lt=uH)iY1Cx0S9MSsGoN|8{xbYcJ5xWlRd21ID_{(0<
zhyzNs&us8*gF<)VNMQY-pZk2%?k0|yIpv%p)%ML6RJ}D*^U@UG2MnB$J?^@BpNo=x
zVXW_}b-k=2op+y*&MT59mbxl!&Be%#0RR4KJ$Py6hxwAoT(f6|vw9BtRY)~HI8=b~
z#e-Yn)yw+?Q{tl@WOBGJ-hA!ZdpJBki39i*XN0k)VZ_CEd?tiOaND+!jr=qAD?Grt
zsp(}(r}_uTJ6MT?@=1Ce-T{}$kN3QK_*GB2l37Vk^Tp*}#*6vCeoej;!h(xi{BjsY
z-C3QnP?bn_X<=u+{+&^?l}XJ_G$0&GDIq^9pW^njeeo#oL`#j)YU4}VJbgDv%7P8p
zL$$ZONMij)FQm#$IQK<MM>~rha;4CVVDD3dYi8wg+FmA%v;D|WjZS$yKaF<Uj8I;X
z?$Wl9j`Qgh`X;JJ2wtyZS3dSHD8j&>{{+R(L3cv;QQQebN13EIl#{Z6fgd@R0Oax{
zjw$n2==$)fred01&B7zRi_GZz?`geT139L=d&t>}zTot$J}3;aob<wDPI2TzOE@w;
z)2D;|3dR9pjmecY1tDS7W>z!t=qlo3w_k8yX?NP4<w{nh`IZFl=aDXf=focm=r8_f
zk)n3UEp$&gVgpOVSl!FG$0nMkZ2c6oQ|1RUitD-0rW3uVT6Uw)Y&KWh%GTc)5F+_n
zB)^&7cUd~904buZV{!aC${#&jjvMiDzh=Vn2-ZE)$N*2Qni@`wQ|&<k10x<s<%NSs
z-;22B?W_9AdN~LJhCFq&KiNvxtS9j2|MpiZ5zLKv$qte5gola{eZi|1BDESZ_joV5
z($|Y(!gns!?bTsZ%$%yrpSe`%v|G@(PPa`de5c;M@=mRMbpCPmbKFt>ouf?e9=2Ay
zIDrB;@mR+;?t+#{Th`Nqq;sbhQaUbp=9(kS1iYQR=eMa3bPInns$qr|+KkeScU&C_
z3A~M1ek?ysDc6gt@-kSqPs)kpNR{4T&iFhW_yv&;DZF{~h}LTPU#DqyFuU-!Se=_?
zZbZ(S44$8b=kdERktio)mA(DWbDiW-fzMmS)^n61ZfArZ^qj+neK~mHA@4wWWjt>m
z-j(h$yBzUZ^m@51tfJc4vL1PaO*>8NOH?s=zT|m|AA<(Q68{^!GRD-NDJ@mXrCf?T
zKb5en^*IV8Maq}I{9C`cziJO&0<Qh858b<&9f6r%nhqVl%f>JM(jC+P)I_CL&LSH<
zxra;Cuu*-dE#gAoL#Cu_v0Alwd0}i(RV6P@?)pbsLaJAyq1P1)<-DF#$Lqp5#tOo!
z+Gy(Y{NVz1&Ag^an!$f^%sXdcj&zb80|_bd|29#0o6Dj3`Lk_Y`5__QjJ?qzy&ZQk
zp9r?rpp!UOZOX{{$viTEI!K2OxB1x0#=J2!D3H3$`w4z(57p_5df$}wr-h>TTWBiG
zMfdOlyG~>M$|X3C1f8L<wTm1KMaB5H-QldkrYb6W;iyPPat|)7?wW@sF5i;6!s+dA
z30_0WlK)%?L}m>m&6P|~>!s@p3igDqJJq?_xgDOu*2z$mj@($Nnxtm_oJHNZJ{pO;
zwjkxDl@mTZM%$XOY^-p;7<as*13PAdEA9KC&+P+6jP*11zIf!l7)&>xl9AE;d`5xc
z+p0Kjws~O1nbY!=-d6?Eew(J;Im?}>bC0ilNR<W+bgFR2{1C<yw=ozeoXf6p@?epM
z4@Su?TuzNPPr9kTtyi94i=@^(?!CUd^IPG1(4UsUt%qJp;mQ?9ap+C{eK%PGlU!cz
zuI}~ptAiU$W}~%YE~_=_aWpZtZCrYK;m_75xOs}E=m4uQ*2LT(7OO6(WZO9UlJ{6s
zRw$+Xi<#p{Qh(H=T$0n-OV4P1_C?ynxvU@Jt>;KVRR%qjZ{?19m}cO(5)bYZj!vTY
zkXatk#zFY*_wSPeiHlEA5L~jD5tXDUqi)7_YEI4r#P3AWZ&eGb8}P=H@cyA=5is|-
zX8FTs{|~f#5$}#vAZ6~j%%Z@yx-I2df77o#^bqr2z3Xsa31~lhB&6r-qMxq>elNcr
z5lgnk87@q_zH37ARC8Z2d^S^lH|`RVl1u-Gz7=5nyt^1p-=4gWXr{KlE6>}@|F9%@
z+0AV{vhC_vsGd?TRrrM1b#9P3MO47|Y{!*F9;;!RFt39_kbM5`Q(XJg)ueL#_l~Gp
z1+i~ED3yTdxV<|0pfPCYJ5=1@C!`dSmL`>PDd@kF<80s8?Pky#0J%4!)R_gxBs7@S
zkb)O(YPu8Z7MSS#2a)(KUg#?0>qfY01+8tneXm3F`qwN}U%vd83-G-p@Nn~QfW0V{
z6%sp5$}adbG!v%VU&>?|4l5Ug7{F0<K6>AmdC2cGw40YE@>mJlD4bKi@9~o&;Yr!Q
z)Y&yAy;;wia%^UKu<2Ra?ud7%d{#<_qdH4or*|it+^bVia%|1B7M$B6GSb(l2J1=#
zL&JO7*{fpTt@QQ7i8zC)L9rm4L(#lHT#EF{potg^la&2|9cN%>c0XvfmI&bV^ZNSw
zu?GRbgvWGW5fl`h1*azHI}(CnL0RZwATkUanKcDEo(oDFoxDonCp%f?2U3$t-t{7U
zXB@6LG7=``Iqh5=b69aEQW*8~EPADCgE2zUn}F?g=z&Kpp6V6*1@q8!u7Z#o1pTU%
zxRvjqk=Az4X7`rD4@psFAahuTh0$DiQ!oeN_{KLg$~`q^u0RvYy(e^YDR({;{78VY
z^*ek;O-MW8(~7$#Z<muaVUJ4__8u9+okK=0@M<T7i+)DhSd%L#KQKn|RLBL>COzdX
z`VZyhn4>ii;+==_Tu6uL%NN6jjcyTe>anU1f$3dXfQ#`_2tEP62a2t2dX2BZ5sm?|
zC`EuuM9fz6Gus7ui+MF#c+bGDVrA#?2|8ut^xL1H#xgSk^UDjHQhur0%@s5Pme%I4
z>O;Jo@V_UBMvt=lCZpK{a35RMPAvOl`)Ce1;U@p%Vdh1r6gEv|;1Bf{HzCtI_NltQ
zlAf}BxX2B_Y#h&Rx^N_`vYxbXjzQ!4@RqBiZ3|Ss>Rny8#bSf6DtzXq>*x*r1aCxu
z8gBwLZO=vz5JNa{B_cu9EWUnocV^`x0vv%lf}Q@<DLc>>)NGBI+e-WjYn%>T5`#`9
z4hr0Z#V!5GP%v0Kf`|hRmW>2AZXk?eAfn(E7Zu(6Z_nGmG{R-2m3*SH_rl%kTROnw
zfFYSK>;CJZk)ae7OXm)%%&&6;H7Meqz~MGrG^!34Q=T1B{W#~aFX%Nv(7&$<Jr*K`
zY+`=AZvJ@vpX8Az*9{aW#fL#%UEZDbkk#D|+Qt)87L9$9?P(_e<FZbh31t?@gjoLD
z_66y@zPb5>;$k5s7_|*e${z*(tAH?>V*1M+`&Y{nML%cC-x0_QTs$o;D|-_JsF`PP
zU5Y&*Ath~vwt(V<o`nS)#D){AI!u*Y<fQvr1)CItv(Rjn<n^E@-Jopda88UpznVWr
z?J;WH=3^GG{FHBIaovfd#(lS$C!)WB^eja+4rsM(zPomZ^C__mB`0Zwl;ArVDZ26|
zl6i<_JZWw2kB|FBU-E%*{2i`SJ!!$JaJY~#P6bDrrYs9r@>Nv>%37I<$2=NiEn0X9
zIN}rm5L4U#?rjbZ4FR1)3mFdy^o_`$du!vBWGI_TGeD4ro$KT21gj38<m9{|^PF^-
zgJw4#s<W?8WmfbT{GXcuCVAFc>>eGg$&;Pv>pF>|1_r)Y61p2ZU{~FNMqI`DS+Lpc
zCA4Flo%ndjpOAdJQJO~bS2GL<)%bZ`>D2D_{;Y8o6K4KaD#TvTYG(=GGctufBn<FQ
z({pg7qj{)mEkYXiofoS9syC?bI=A|L85wbJ1v{AAh#<L1k9Vim5hULf&PdPz{Rb5w
znH3e%N{4^G!Z<YM>!pP?HB6|KM~}X|6Wv&dq2iocRS|rgmZo-N*mtGw1LuF}Plx@l
zWYyGE58jDLdG7f4qS@`1^3S{(37FXZRTJ7<;lgX@kF9gMQ;9xiSa57-;>UJ*(Z-B1
z^$@TatcE+Ts5?y$-<?2<Y9h?19(x^u^f!Dwq@6pY)kNbvM0z>4=ETy{+fLR{@pjJY
zrD^tc-IErLuqNkW!Dqr!4xvP)EBqI6mt}IeFE$;tom>RpKRzgYEey9|BuE%|fRk=n
z-$X2Q>WozaXkWJWTp-#Mmx8T8`=`7Bw^#q|9w${PYzp2m%G;M68QZ2ib!v3Gd?)lI
zZz~R~@Gl7?LosUpFkPE}!(8JrV%!#Dwr5|?XDj<z(64JsJ0fU@*vSgRDSx5$nP;d!
zi;fmFTYC+Q*VqY_*fVO<&Ll+4%sZzP^(;&96sZL!JKaVgY&YMMs(ND2y87m)sdFhE
z)iIS&jihS|uslP48s~hT!dr}tN`cj;-i0u{2eiNw8L#o;1q_mq8y`6t2)Heq<2JBm
zdS~<1*-J)mw%)Gj5!Sq%F0DV1KRj;S(bQ_9<KXD~PaV@f!+_0B(-+#v!h6Ev$J=eW
z1-Vw_z9Zpkj9Ey0lSpe3_3L%s=<?GZG&Q`&=$Xojg<M`f3uaY`8L^Jb(~!Mj3`wA%
ziBK?(b$dqBBJo$4-P?f)%9+tDdQ`=0GbhCZo5OJ%^QF4V*>Wzu&U;D<xpOJ;vp=a@
znyWe;FAGTZd^$QNT-fYaO&)$@jE90@LNOOO0`LW{&3l-EUC7#&U7m_d<r(?hzN-BG
z3ilGfoUd!6lZQ`^j;9W|d8V2F$J|O`Om0eh{c+&&Mi;ch1iHe>U4rvftA(q{IIBhS
z**-`5GX6J|2TVdJuWplfAS4Bbh*Fp;%HS@<@j`8;cdV3q7k;PM_jL+Dn}y;$=%_R=
z6s#;C?pGRG(Eos35pMCU6oS*r1dn>W4?v?W1evR5H(=;xAlpEp!NGfdK$A+{AWdpY
zke9d3!#a5^Sa{vHzTfKXto{Gz;h_^&bc8?-H<f|{ZUSd-{@Wv)lr)tvkZ%|-8O>LA
zoqb3C;Jdma-VNfv?#XKEsi6lyJh929w4=FXsP8qbd0QX<g=PKcItc%H<Ew4Tz1`nz
z(7F$#@(e0qU{i97aXT|odPUDU*HTf1Y$NIpm!KyJS&>?ch!#>Ak(l1ub`kPF+W=+}
z9YyCKa8Ye|aOPTVkIi^KsXXkGoti7EFVFva943*TE5ITQ%x2WOxywm)r|;hnwVf^D
zs(Vn@>Nb<PVY8AP{08Hg^V~WH{sVnBrVr5$huj|}M37S9E2{s)kIb>=D1m~*c_t-R
zN*rH3*fLLunL@KD<>SNd(7|02)BbIGereR9GNuaBrPh06E$v=XYKX*&Q4{|iXR`=2
ziGQBeyfGXak^uh6voHg<B?6DAEO^fwR3+<gcgC8-!b&;i#KkGOxsUT36_b<Rif$4e
zg{+l`1>IWe%d>jaH_jdi6ReVnzkIph`O^cXe*M{FFZzzzvq^0|25kB%G}>$o`ug<r
z_B8qz?rJ#&QB01dT7B?!oKAgxX)<Vfn)C5>?>EAemZrkGA*%D9zv_JMT-!1lPBq^e
z+EgMT3k_TLRRj-532Eu5)z$LqVI~faZ9!{1bA?h<smZBji;jiG#j}%Vc+6NLBO{f@
zxWSwDnb7w<O#*itvbhg669mncxmHw19_>nw87ry%tH$iKdYPOo=StAL47gX9z8FuP
zbr9!x>cuqvw1Ye6g5%ygdPaA`UDuXDmZo3InZF~buay7hL;^~{Gb4_g^yb^aVei`$
zicP<oXU(Vg8JqsjotXtIJ+i#eeP<Arg6wGNt?C`nME4x*gwC=~qw|!580S>nzLg;z
zbte~>$QRCKCK}DIIXO9p$5zdujSF>PiCFxa)N=I7L39us($D2FV{<Q=zPo3!cItUr
zF^8NnHoap`ba!QcON}alIb)WA!I<y)I!?~V=>z_zF{dNcsBrk22V-aQtycHSN0D>`
zp<bk)tm`$_Y>W%6a*2HWD5D<VA&rkSx}IR&vscOL&3*mIlB;L{hC2*zMOB#~3NNg#
z^*${!j2X!#%1lIeC+1bEZ?1g>57_YT?n^Zm;($gxZD>&X5emYo-^cYuMXi4$B8Kln
z%>*u9<k0_#99@b=m^5ClvaGPPcb}d7miyra%r)ud#@M_pruJ}IhjAm0`gMky=EXHh
z%cBA*21!zkVC)wq@!xvGv}S5JePQ%uu6}0&>RB#YY8)Rr|LT{<dpE$|kyib@&3l$G
z?z-Zsgg7VucHdIMr$_V&-E{<c*5>5=Qn_T8wdNB^EX;h~8i}kn?pOu?eqh}WZRQAs
zX$c7(gmd!RWAOh=-#QE!t)GhS;0Pi|t%Ju$)MYG7Oa$UagbI&}!UvfQ?+-8Fb;P`X
z5ABR`mm08oh}?#a)(VFMg+dBGNSyNZPm+Hc>T`IbUP+`A*<N>&r_Oy$3cfIYZ|cQ1
ziQJK_g8lfX?XE(K0RC-`R3=KMfc>suY-HBusdw7iD_j-Oyse5}l@;*5X<J)~x|Egr
z;Jj8v!o>_C?HhCn)r$qjBW>qKh-;K*I6I3pPK#jwn(>%PT*iKRZC`2TH65}u^R9li
z724_RU-OUXU%$S&Hq|Jy+LV@&VF$SnLUTfH0mN?@(htd%%^#_H-@yVG6)aY$S!vn?
zIq^C)u5It$rKeK<LoMF0u5m8+s|TNtWd~SJxg9_G4pyY`dO-Pxuu4qw7M&=6fxvw$
zvo^%r*+Q27eVN#99!YW26~h}Ad7ax`5e+fzr(W}C<8An_UBOeSj_AS+Yi|b?C<oAf
z%26)#i!&&+N~PM`5G5wV+@z%ut3RirL^@kS_{(Fs<(whW(^bBLg&9sE&rr86ZDOMN
zQQE;)7+S&OP?g^J;3K$3C{FKDHmygWu{l0E^oPm~@(&max*azeGc{$kjH&LgC@J;W
z&)EW_$fAWhGVvNzZEcHNKa$Z;_+s4F{grl?9aSG7PLSX^7Y>44sBVIkfNy~chh2@B
zsd9Vh8XD5BHf&yn>PY$AouB0HwR4QYVCD%PWH^C=f$K0ReDBReFnZZYxzV6SFApW-
z91k+9%P?&qk>v8PpO;4O+`x_``DKb{h-n}Ez}XD0e)Gh+Oysf-!G6C$d<fo8xAVWz
z)w%@q@Bh-)BxK#;mBHH=VIK(lN?POSobk6$rtEJUA+ew;TJU>-fLPA%q!cRTHTwq4
z#-1$+PqXE`@b=<w{@Z7SW?(aX>WzcJPCNo%NGwp$Hr`$JYkmN}mz(GO*SSLfJmmyi
z(%|oO`Ei|V9`5d+K&z&_v=uQL0#S)L3oRxt{z-XfBC<5>aEXbPwGC`S*(&s4JTEc^
zvb;+9sPlr#J$SW$!K76?C`j=L$Xd!y`G^O~@qX!Xx1i`C?Pr+B{hyz|?sTY*>AMkO
z&N=`yuVjO4r$75!d{cGE+kq3%l6N~}H(EX;={oEBI%CAS&l_)>ZuOAo8^~Z?GJ?k$
zHUb}V&bwq-JZb;PgZymn)BN@q<Pvy&j!4bNM&w`G#Z$=Z3({3}kKBw)kS1>FV}Xf^
z4`F6mNg%kAP${jWj(&3<(;$LQghhAbh8OsYyemHNg6SdHjOM@mND1_J#Uo79&rc4*
z12QdpYNzScsCAe!8)b)l@*S|om@RrB-YV6v6baGp&(01nH#g2dT!?B4=n0z_HId^^
zul_E4uNs$hIel#2;nHaXMMnJy){OE35L1V5cb$GskRiag*^)ie8yfE+lO^KsO1eJa
z5FtvWinXM$FJ&F?zuJ0kfHg4o9GU27Nu;;4KvZ|flQ^O8UgHv6dKCx4u7by@%6K!J
zIyVaFOJY9^XS}^}Mkq$->JMDH!AG=)eTCL)Y2TVc6crQ|!N>`j)tkT5FC!zP{#6=W
z)<F5`%`I3v>5e*A%Ew#c8cadmYYm>ksDk3+xCfvI&Aj-=qGRBAW+(CMQ~jHw3%kEY
zc+1z;7A~wF^=DV*j&E^ourHA9gw||RCnY5Bp9$j;qf<5O7|jHx37<-!$xRa}kLK#@
z*zSb6+)le5CAkHeg61L0!&)PoR^r;^jXZJ_l{!kEhbxcb{qrt9e9+I5uz&5yzU0VA
zSwe~ND8ki9XpTU?DqU^T4ENS&fw&qbaS0ef_o0>4;yzQGL=CZ)*1Yo~(wIaZHUG2A
zJ2Zvgk=v7-7v3rRw7B<^RDVtb)3K#%U-s0lu>85StjzeNp;4Lhvr53{%mDYmTdIHZ
zIbxT|8?WBfR1)Pp6K;s^7Ujuv{Bko@oGM{afa&p8lQ70EF&sm86!HCL!FBq*N0sKf
z1!-<kWu~=g*j1ld{%_8bZf8jrrd&aE{t}k3r#bO+3{M(Cy>c_NM77@4a+BYy_=23^
ztF8HcbC^~P2dG6EloPcPVt0+tj?Knwm(xj5ZbwgXx8Q!JSSoA~#M79uyP{Pg^xof|
z{F6DwSFwjKdZ=uUqliazh3+B|-s&VnZv52Id(^L62?UB5V66Gc<;hdTPw!6P-fN<U
zE9YxFKYgUY6%kY^MZwrYrTjc?*WqdVQTSjW|8KPNbKLtjh92it-euz)`mGFvN$J+x
z;|OIqw0a*Z#Q7V!(9noEk*~7<5p>z=R_J_TWJ5{EdEP-G&5d6lcG!m!dLC7}dtn*z
zPSJM%9Tw+ALSTgbWb&o2F3eJmZ0^ywWrBJ!F%CJ(q~y#h%haCjF4X#_FLvSUPd8^-
z?2H)hdtp^RtN4U$bthHldrB*$0gXbJqvmE=3*YKtZ_?28rl!$;c#6q?D<izbZQkFr
zU~)60s=3u@%nX-bDiQAQH<bUcm(Q+E@GkAF6QTPUt`U~7O7E(Hm}@>cc1tDRLoQ3?
z-ZGpl#t3qv)M}ALwsp0j4ZZ}qK#jE&r|7xkl34F9vnpNaExNpwA@59G84y{ry*{!}
zTQzwIXNyMvzMR^a*|JM~LnRYW)}79Hr!Dx=Jf9rOy=da%`mTkBs+<D-y<}=plt=<|
zO)gy|6O8@ATsl>TD_0h>aihz*On7ioWv@N6-Ex>VqSvR{l&6f}YmR@XNZ#QRq%CdE
zzx3qr-cd_2jEQG~qwGA59YyC0#$Ok1+p@ijwlbw6PmBuV%3-(^fRk3juV0<6Huiyp
zM?8k?a(fN452R(C%44Fzbu=`&XI`d07DtQ>>BT0j?#Nu~F%|a2d*flppt!+K_Eokl
zq%|?buI+`};FL<hfXMru%yuWWcWX&L=+#P*^0QKAb}t5{mt8U@lo&Sx-*a=MV@L~K
z?d$C!O;+Ok@}{L&b<QO|xQ6kQ`4;+@|1Qz}2N8w__&zR@X(i9~FUhHWGbPr7ao0V?
zC!i4QA?|92tJra|)8(t?tkTD_WcN)nNyi+CdLE-MzP`UBz;|I~wurf@8&ehjyEvm1
zN2NT^&BvHj{(JQH&}pVppO`7`KHSe+O9d9$UA|pfT8<B1(pfRd2->i{iVl57`Dri^
zJx6k^)`vg+cf5<#+#r+6)&S0>77o0VIA+eB5SZRAn+~DuF6D(}4gwVL(LE&*&t7MS
zujF#lZ5A|4chVWVWoB1id?p)Hk@q}WiG}<3yw|~xwY-#XayC;&>8Rj0T52>Ra)YPD
zB(Jg1ezI05RQ4fd8q`>QYVm<FJ<NpaVf&>sa1lA^v-#+ui*G-1jkh3rT1T_)-=>n(
zsT29Z?F0M92yL8?DfK<;Ok}{~9Y|IFHK3g0{VO60+$fip8ESm&ev(dnsd++B%MLY&
z6({>yw+BDByPB1Ge}9$TtdeG3KkUVo6jr@!wVLqLz`Fj&i-Gb}=dX&2Rx_xbwtb+=
zQ*_#Uf@0PwGAyRV;11ispR#0LZ>a)Tk*ynJ?q{MOW%YgJ=gG!{ap?cPJ3S7AajX+9
zXni3NJz;#Q)`_8}pW=^3U(J((Vt?zKcdPVN6!?C7P{4#o;qc>e(UcjR4PW`xS(ZO9
za|(}-q`5SgvHB-j+My{mV>Fqz)*!pog-<ruM>I>{Zt}Y>>EYJVY<souyB1?E6}pN<
zK-B2YrWXg&2CfaR9}N^SSH2c3DLhMaB~c&r*%0KvYq`_Rc=B*gzAc*`soV}(&X^T;
z?Pl5A<3=p?5>N(EI^{QXWRb?whRknHa>R$deUwSO`*+{^0lv7-_n?EhzbZriPl?7;
z1tVJGQx1eqJ#X>;s{OADD3UUwB!@@a=`VYn*c+ZU!>&afcTXwIr=+eDpNBvGfv#2s
zaVFXlA8>z|t!#KHAvu{BG#U>y4D5n~*}OM?^gGP5ai1i(<z6m7NiAY;ZNGjz9=?cS
z`WWMrv{%i){QD~Q3~wZyuWu@2PY)hdE92}nv)&0$wwDa3w_s+U9pG@g_m&wVU8g77
z+XW|$)F_I^;O@i5$R^*;Ya|#tw;4{YfAK~ktE{nriRW}4JQh6+KNY_R&}Kry?$5VK
zwgJ2PMh!i?V2oi=bMy2cvlCu#(O4~>12)g?$gMY1KEj+Whu}s}GsUt8QIKRgR{E;J
z`q8srmwYdt_VSBte{Z|FO_mxFCXPMWyS0~j<<~&ITlCRQ#e&#ku5w}h((dRw!BefD
z;Lug<Gv_u+Bn|DQR(+Veyh~(oL+BRkOUG|U^y=*$-d^!>=_tCI2V5#D92&$rrzI5>
z?r(4Vf}xgH2+!z@=X%$Bv*~ksMmak>J9c-6M!#Gkj@b1N<xO^acmMu<<OYXWMS$yw
z&1=N1Zo3;$_;VV9_mP^R@XeyPAseYHXb;6+j5iw^Zw}Y!mQQ1{HHGBYbK_KNdP#Vb
zt0|)*=GSa$Z}GN|GZ8ZLm_3%fc8O$caHaH}Owy2s@7-7=YIgtB5Q0k^j=+anYMz+<
z8Csg@{4+%GN^#E{q<~f;DTy+S)(;9B4dOoh=Qo^hPi@k3<3r=4Q0Q;E)S$%)^$8x6
zT?t3Zvp*eOLUsw;7k1>9|MO#hOz#aeXZ(llE{|>9iJ%FK7Urk8RBkk$X2#PQWyan;
zX?Pq?s){6b)_T9#4Ohx0KG1Y0UH8@CExN%V^*k*_%rTe*(^e@Vyu?+%|I;&eSzlNd
zrp1xoGABv<fJ>}+p@4>_UnYZB!1L5a4UK!J;}y4JjlNbCTc*D9!R8bXy9o#6q@<uf
za%B@$V|r6LkonN}W9B{7a7Q_`ajW@cU8b6kqg$+gNr@{)-J3KRQmOT^_)a!_wis`%
zS{GmTV`<;cI}u5TOPa0!4^>|sRpr)weP{&%rIAKb8UzHS!J?6Fq`SMNyQM`GrMnyH
z4v{=`H_~y4Zy&w)y}$1`_{ZUp{hVj-wda~^tvN4Nh)r8wpwyl$k|`maBJs(W4Efvs
z4nLNtJTmzH>_HDMxE3w`-bZLBn1Mc@Yl#>L@nADlHf({4jR<Xh36MvJS`M^&l{ykY
zeRv9Jk-U8MisQwLh|tjcoAu;XI~?4E$)Qc-uauRiEO}_?=%|H+J|)&jV89L8Ao5@c
zxfAXcl&#Fn?zdC=J!rOMK_JY!#7)Ga7qL<v%QDkbQW1T5eDfk#Pdfg>GO@$9^}O)B
z7-_!7_|*H*^;@U($}fgW3SQAqME3!dcpI>W8z^tTLL?tz+Sw(o+g6QvmGxM+?d&xf
z`!k$dKb)1%)+~pErE@yy@Oxv4P%|WCBbDh9*v!%jc<|+c`L6BB<;~Hr5MR*6B?K-G
z_y<zk<j0Z_FTSrT>^*aBtdl#nsK!;YAeifR*bPAaq{JJTq4-<RZ?el5$!@T3Tdnh_
zyN|0#U)NyWY#DEsI6^o(u<QubZuJEdTuek5JO@Hd13RC$`@Wb*zmaE&Xy<N5hh~lb
z#!g7zv<Pl&!rQLK35l$G$XrNCt$`1mBmV+D4Qf&R+K(gnwWq8Oh&AkVNGe9&He0%+
z+y1JuCS8_di*HTLl?q`#nQ<2jz8v|1cCCW6i0Iw7%zQU`Y=BBYy1}I?QJt?t{Yb(q
zLStwB<WbRspX`)r8d(&d@=J?Qg1Xy;qF&1dEz3=P6f5jsuH~oxq8#=g%%uE=5N%xS
z>omZL#A|zNWjAoW0YA9SFE~&_6-I<Eqvvq$<}Bww8X}O-P(L(T3SN}DO5Jo4_t-^_
zX!oKjAxz<DcJ4KjWhHpTa^T9trSD-{-sa4DA6n?BE3j(ST-`%$!h%~ZA))Z$zhBCp
zg)J(^Yn5h&YAp^B=JM1ft?er(Odldn`e<Psl)ZS8SG3JqCi~q5=!>`ZezQd0l+8-n
ztXVBT5pGh9TMdv8^neIjpa0blt$R$G{y3xd5eBG+@A@4B_q1@Ur!BH}83OB@22{<`
zQo6uh8Kwvv0RJKx7QfcZ8i-z|5vuhZBE79H*><p|EPWrdnBMSHo6HxRi5I&Z_mlWc
zqS)~7HL?WuLchI#hA9rS!!?xJln7>UX|va)N*Ex5KP`zOFC|G@7DaKOT{gj0EWe&1
z)_rJtm3(!Q=$yi~)RZy1K4`^=KNzh=#$yCxidsMqqzj0$c1eGE<9BSs@|Ki2?1`(e
z0b<VV+;=P5vgzZixnaz+RMr-O`B1!Yr}5${R@!DYmeGA4n>$-NTLUbEb;THi$CWv<
zKQ6|IMS`ZNdeQr3fFWsP(4JVRX|KU|MtzUkuB1{jGHjSDHE;VQPRe~v>g77R45a@6
zc56|}hUXB^U3KsH{U?;|%6Rd78w&#ZM6PB%*9|4II&&11!meV=G7jCQN;HTI3^>wQ
zFOw7CWX_1UGa}JZ(Cn+aXSg3pCPX_l>+~clpOu+E)%VElnk1+z_ujt`-HT_5tw|D7
zPeZ*>C;qn=pbxx-FUM`jtdawZi<FSoEl2x5@GTTTIL7TdZiknn`j{E5McAg9=>}4w
zAB^_*40TC}TT89?pIlRIY|AV*&#)Y>s2o>2lKfsYMo7c)0<R__rF;zKKrWTC099Ov
z?Pyu=Qi3W$CiKBW3B2hGyyQ|rMYM=Iu>E`bPiQS`5;?*9@br=WvkYm_2%!r!6C!}d
zA^3@(oj)#UEz(`QtQp2ihSImNus%}ff#qwhd{+o98BZxlVnMu^H}>N`+bnF<4ohZi
zLOmgbeioiYcNIU8s%DZe=?!+5<Oz_}x262j87-BH^|g$+3q&c+)jl^m%bcf{li9Z5
ziai*<y!8|Xu6KVpM2SjdaAEQ@XB9Xi;?_zYzh2x{T)qTE1BK4Fz4+iJ92b>0wF8}9
z7u$4xMQ<$ANEu(wQC3oLi+;k&AX2FQ21gze_5Of941a0P9})D99cyxkO+PJ@FQX7d
zL)r}R_5r8-e>VRj@;)<uEj-fD@OTWhI4o>Ftmi(S9mOtbJL?TfxKJ#TuxK?oRy9GK
zG&!szyl?*tV~;RLuW^FdJs6LKxdu;UI;D@VL!$CGhpBPfnLH-oD>o8KGkRVJ7Cgt^
zI`9B&4PZ+Y{`-{(a_}qcJ!&yk<RU>Ihr_Ul5Q)5310Nk0O4O8cO*J+MYz1}V+&uIU
z-36LtW-UX-w?r`a&o?K??5mjbqL6J^MV3wy_M`UbZy~0B@1wuB=L(~&{5F(Y<)gEd
z^d|U4_U+G+QwjS%)=agX0uGuXHFX%nCq~eN1OI>{Ph87ErNL0+cD2Y!2lBb~DKYi8
zp&N+n3&maAP~p?p*Po{wSvt4VJS<dG8nva%yD|4hSJ<Dzz^>xyXg}%|W7xs1Rg-wu
z;`)^&CUS5Dd;H?5<;Dz-n>Np{y>If)38H}5i2Y<aug?j8wRmRIi;5l3Nz+Y$dJWw4
zBl*oU+S0)Cxi~<zX^Wg%eR=HvAk9Ix<$z_9A(ejiyOk<^PDwtuAUECNnugiTcl1R+
zdp~KA<Awup0m9x40=RNo4FWE{J!R%C^tV?h2x#l}3t4|?@&M^bg5<=Xn;lCTAY!CH
z(OxYR(+O(W=B&vmks7}NHn^uxGc$*u)T4JwN*$7aZ2aI>eyMmbka%n1nXUaB%d>P%
z2%5@5aSdN7EuHmv;YKc<ok?Oxvi1D!H$=aTUg^iIDg)1CBgJ3}PgZ+J0bYXwyjBIF
zj-*(BG<q4YDE4XF*E{!d7nQE2;e)6EFVZq0lI=522B_39lYaj(h<nY#x~%`Z_QKc)
zZAH1dWT2!}#)}h?fH)=W9x}My6N%nB8t*kLFeWdgqHWfoxBJ<cU2D$*f?uXhxM;o8
zW{b7ot-Zj*FPj9iU_V+1lru#-1cz?Ua!9`IncxEGJJ|d)MKQuv5IFb3`VC(nz^`2;
zdP0z=snF2bGQI~C8Uh5&qiQ|)HynqVTOWvw@C4I7_k%8SsxA(3gFY7WSCP>4x$9Dg
z(@MEp1&rS<>(|f1R{R>mQR0KcA96*0z4?7xdw=sVpiu`N4x@{MLsq(FCGb-Ja2-j7
z8HMGEf=Gb4T{RM$<46JMgupqFWf)A_TmWzO<&<ZV(yFS2|0e`NW;HUm%6-w(Qi&>c
z7az<nC)d&1B0=d*)T~@JJ(u&<`X^yDw>#Nx`&Mx%7bWlvGQI|bm}?F63TI~c9=??8
z*^zW+X3k^|P)zR#r29hIl|oL01`cGf1(kqDyHHS%&WhB;K7)UG(}TVlrB7f4_VDI1
zzXSOnRV;-7w-4(J-$m|qRu&Bld>}t4HPeJ|4DSU8|MdW9aC)A+il~wKPHl(q<m&<H
zg{P2aP1YFP_SHSHSjD!B7FJWaPslH;7Ri_qw}X#Ad$SX^<=g%Uxd+j6Ja2!lv}Y5}
zEKm=Yp_T?xB9`FtiU)6v`3Zp%(H9W>{>DRzN9$Ox7iWrkMPbh(GC8!X(eX*%PXydF
z@YB7R66Se7Q~h{`K6(e|PK}m>G)C?^Clb*{PXEX`i^xQ4#C!IhI<7mxH-<MK;DE8*
zpiWIfLG}zwO!x&~I|x;VJ1M2nR6pZ#m@HiqL{|%qm^?w8c>BLlC7BE*QS&32MJ%^&
zY<H{!P>die=%&G2z|>kHB|G0$?t_D53FvOV)1V)HZanX;&Tp$po~esb-UX<)PUp?x
zYKRVTqj)+BoJv@mBYub;&m^HhOph7_Fv6+obl*F&B?=na``c%VK8Zy=!-j3(+3)@L
z>$MgiXa&>Knr6DIwq8T0>V{glYvh_a8S#0HjB4t<8Zlk@KI58*lKvjV`GI{)=sWuS
z!QQLL7^@XH{`-j4-_0ZT+)9i23j=lVEAZCi@vFNv+l5~%BL3Q=1tCg&P64%yD%dU!
zxJ)9$4+4-Y`O9{}8LxZ3nk4MnSShV!*smA60)+3X<&KyCWWcKQCA(+6XlOM1!urMc
zWJ)1-RqB*OZ9sqf{ddyI&o@VS5yGDk#PH^*2f-RJK3hwziQz~h@Nr^&Eyuc2YO5|I
zj^S+dr|A%#;{nG&9kq;u@I8uGXb3zqMWjgq$}=n(ltNj77Xe)N3H*pDEouxu@e>F}
zpG`uAeIC9R6#KCj%E;tAS1*X8n;ScVbcA-N{<M_!V=wfwLmCc*UqvG!;r>uX7ipp<
z*>>8YBz;O4Ynm8mz)EB@4%?V|>_m_7WFWvw>j9j1qu-bcli8vCl?Xlc`)?Kh5U=-+
zO-(ZWc6jJ)`>ggKy+}gdKSnsVVUv6NGQFM?*A@`J7~?oz2$!8rJH9SC9Bu-t<qJrA
zWh-#rw^64s+<z@T?X#scAU=z#CtLcFR!osj#K)ThtoH7U@U{uOjv(tp>68aMa9RQD
zo2y_zpzaAs`cv89uS7#b1M-`M=zp-px`fZqqJ}1omA8&xANiydlh<#D)A8DS>e{2&
z{(I3BH*Cl*^ojVo)xm3ovtpAYXI2g_FnHHxkul=!jYBl)?^4MqUose6FMuYt_87Ma
z)xHhmYyJJJALc}87J5qDh^gfBqPr>#_<*wDWcWrxRakKT#26kKIILOm;VVK#L%VFF
zg<lu&AH+o=Pz%%+fvu8iqAx4IQfpa}YeypD{mzt!2T`Rf8kqjZ=JMvnsP+8EJ;*)_
zt~_#l_)?d&MGMw}92%8Hu-N{Sr*ZmCMUeM04+tYnQQ`qk0>xba@#gG3%~M|!>PCMx
z7Wrz+RN1MIgkn>LFNQ%GvTIPX>whr{`HflYSIp#UzQXkm^Tlf@Ag4=xhL8Q%Kh_d<
z(^CzaYufENc}g$uoUWT2rXjwlRc|#jI^rqZ_{17}<bwTE$3@(n%K3F=oBi=i2ErV1
zb`IIfBb}8X1h+3%<!#lEua-3Q2Jq)anV*8Rok5`Q^FBjxxe;zaJ3Np0GUDUWNZ!-z
zOyp%1(`5C!NC0u?HDROwLGY<IuY=#Z-~Te4dq<n%G3>)cj>whr#S{nZ+N|gmUgcD@
zIuDY4V4@p+1<hpRG(xJhOX!=wFHdC<zulK+4?0bM&W*ko9H}<8i{;jI1Zsk_jgP2*
z^mS5eP-Q2?SY<Q^?D;+23^w=u5&IkK%Tqwq%F<gh@rZUjuLS{g6{h*sBE~-htgM;F
zN|z*Jo(C+or<tcG%X;kg-GTYZDjuEfM(F=pB=SHD3M81e(~%G0fJWr~+cJGeGo7(&
z?4r`k8pXHQQW+h2cE@MYhKLls?~l$JC+)<7Z+BES*{Y}(J&=UVoYjOC?yY^mV<i|x
z*Gu0Dv@<QIJ<59AQ{4O;ixOF4ls{LX-^(f%@Z23`+We0cetlwkd!KK1N2=>8zQT(A
zYKF=KN{J?m6hwY&2b-y_J^t@9LPi;Csba8`$8WeRr^0+zJCuCJh{fdx^91lI^a(*=
z)D(V|Y;+BR&nAZr6VMhk!i}%l=+7k!I1`qM$)M861)<;t#x~{-6$l04rYUhZ;&9lu
zG1Ui#FQTb<Rz>F2v5a2v0sQvx&7qbW^%v7CO-`X*8@pYpp=!}H*=oUk3$(`lKw<2?
zoyE3cT;M;?@xQt+I3UJ~zc8d1QB@YI-T%VMwhTX#=XcKElo!ZJV`}dLz(xH9<wB><
zSKA2jTx+!!b#H@S|C-V9%d6qiA7wRoecvU(_h#>L6BQvUtR;|9D)`77CH~JPEvqse
zc4ElN4B&z(Fe^^Bl^f2&G_|ulsYWPX>TG#*$SAMquox;8yfh%zR{#DrBNg)S+y=<%
z!;*pM|9_EGQZSlFuimoexl9s367+dxY8Ep52P?ew-3kXh=VZ4d=&3%?z1Rz}$N-@y
zK1`5VO*(L)WBU$C3IpIz-|goYy2zxAaGI|*Rov%a`V`zQMk4jIfaS`f$PcnBMSXem
zrZq;NOgx)bd|G|Iq+Gdt(pKN?(;JC`Et|k%QLOa)bIY|QnD(_Mhc*F%Sk&BTZ#7sY
z%vlqDX@yjhF5JCypd@YH$Fl5evHcGkQo4YuS1DqR_3W&5Aq@{xp$+i1mK!RaDP^)Y
zQqpk83}sW2Izd?_KTt!{itAh5o9_8>-!z&c`0#u_W-`1DSxu<w{#$EO@Y)%53qYMg
zS*Dq|8m&NIi5Ed5xdJ7A+3VPXzQD4xo>}Gjqen%nEtra8Smy&jmuoTY7YEYUM}j)v
z`@il@mF`&=%U%<EGk8dAF=p>qYj|4}$_|f;V5AuW0V3Z22SaN7z^`4O_~?gUyEN3|
zMfKV1=u@^51Ji2z#{<%&=bVP~XHj^12kzc#&qx?)Bkp!SoOQg>lg60;Q7qD=FZip!
zf)ejX@*BLZ$y|`&2yB7s3;@%bn15no2S1$ruacNo$5Kc}%PI}~1a7U$FSq0o*p~$+
zMmA|aw}qon)aeB*SHW-(qyS%A<J5dpnLAmH21*}IB3?pJU&G_Du1O0Q`8OZ&9QtH{
zYHf>n4(OgUSNh-UxqL|Vit7u_v$Tg24Q`s%?UVfKOEov*adWJ$KEIIFxrvV46=EOk
zSOq?`AO#t7th@GO)YVX)O|*PZ<?2`4z8tEqXl0sNN_gVnjyE#lOIXHysNx*~hyEH9
zhdyoG88I0Ok^-kTwJ!<oUUuY&z3IO{y8N7wniiw&y}_)O=ta^Wsb2t3J`Ab*?WB63
z>`RGzu^Veey~Atd9j)7)T)jx{nA{oUqOd}TlK?r1y-<;#F(bNLzPFBCiyR+ZLTXy!
zas5E6UByKr{Kg$%@zaPF+H&t)RH6sR;_k|UiaHRZa!`8Ix~E@b2j{%sHBNH({21EW
zo}QoR<*O`;cQExJynFe4`Nk>|Ns}}@f%G2QE2BcX|8Sc8$OEk%N5q=H7<ua|jvc2K
z@HuR9(thF!NvG}+<~W%JakeNCr&m{Wem{}vD3FMY3`V@C?zvGret7NX!Ou(qy%*cD
ziaq+J32XR7wnjoo4Rd;qVjdyDSFzEXU*AKNL!!_h1C%iWvJ+ZO?@q3#dpinS_U!J=
zT1N=ZU#eL?WSpkbBxTC06G@NP9SWyDe!D0uExi~>sM88>{s{^~Jvlq0W@Nk%YzpA*
z@StOeA5i(s+hn=<`EV_v5YPibmXVP`L`o`QZ_f$bwt!Mf5NH6}gR6>_0*`f}nSVHn
z)elc?$G4EJ^<aht@@4aO-UlY#PGmkrJQN;vHF6&nmvy&kWFymRd}welUK0qXa~35|
z`rcYHoe<7Iv{4UY-utgri{(P!0XU9vbG1Vf;GNs0Ys3U?XcG#Wiuse01lKp=feHzD
zV!SO^p`}y>QGu1arlJ_HJzo<`I~!kl$~dl^0^@f%8l)Q{;6&0CFGV;Ur8yv;182FZ
z1{XFkts)I=XlNLnn~Ma^5i4lI7YO@sx1RH+1MS}=^H6Ab!$C92un^30#7SFQdvkkR
z%*lz{`?NrJ>7%Cg58jqbng1U6g&&t~(U`7hF~;jff-b{W>Y<VkXFjh`7dgK}xAGxE
zi(2!&jhR*d-`&GS9NFHS4~;qmsqsO7z}nXxs`t~Tk)~8VOA4F87B?)hYoXQP;whgL
zn^s44GU5A0w)W6WmX-O@==<&iqmgwrn(s0y!?M-SWz$k$rR_+~=c@?GJL;@E8v9(G
zm}&XkoNn&!o(NI}wn`Fe2LQl)a(cQ1CUoG|OExxa)(v|+FD_T(UAqP5%k+5bzkWrU
z)N;Vo(A2zv@>tJ?EHA$YlT7Vv_F3P)p@7a2&?E1ekQDm=0dGleMoiaA(Xr|jE?bgy
zjyq6hJ`z}tk1<zorg*4~^~Uo&pf2v&D57VHR%<b*9|q)Sk@%f5*NLit??cHNYA)1|
za#kM{<KT2h$>a<&;D)j&azEIWKK|b|K`&P$F|UA18$Jht-x3%;tSo+I2)doS13caF
ziItDc94w>LtnJc25~gQYb+TLk{E++(@w_7Qrcl@|Ek52KC==ot85!N~z+f=Ad(Wbc
z4~(QyhYhrZIX7Oer@emrHuW5noSeK1=<Dyu%{Sld*}&DhBY*z<`Pqw}jt;IbuIK2O
z5PibA=y;SC^e@!Lo1;6SdQJ4*3aj4{#d_s}c+4s7J?HRFZGD2PUFmS86<>`Ud2&o`
zfrc1HPxRk=5?B!vjU)ZOmBSs`!)jK<mp@+>Y2v47BhX0`1Vpb0pycX7JBSi2uDbiN
z-+dcbv^Q^k>%R_UR^nf#q)YX{BV!0r(=V$id<+TmGe?h=$`?NNDsTExmg9&Ih<Tq-
z?;`JK-k#6{*(M5z9?)n6W<p=HvpXu~zz7ey$1Vq4`OnnM><8dfZ(%KWB)XS<s_S0<
zcPqlTaMLD;FE$Wiaox-c{+yo$eKT#z)3_mcu=Mq>0Fp%i2Z7I51d!d2TiAS$wbzlY
z6$UPq7jL~Bi3C&mE`MjOuBEh&f9psxr{x!1->ca`O3FTJXXh&xg>^C#-FeWhp2E9r
zYHU8l4PT~6Y~0kx;lRl#q;YmE6@X|kA_AwY*jQ2fs&RCsRx{QfqPV5MdoA%SDcN!}
z2FXOMlF!<I*CJ9cZRLfJ;>6^>Yx#$X6of2$W)zmD(#*hU;oI7~1u$u6C4c1n7Wnx#
zUv#o9gKkb_2z;MkZ1~)os4+YEEUT)jt`N3dpg<^@m@vS!(n4XcriM4%e+H79o4fcP
z-lz8muPLFY`&cNv*HiGcnrI9P!riwXJC!WkQ1v635~_Pahefj6U*QGCPV?g(==a6Q
zXf@$wcPmgm69<&ni0~uNZ^|M~&Sbx^S49TCc0Mzplf+nYtO0E-!b+H+jOGGqz<(=Q
zRziC;WY0iLLdkqh8V7D^M^;g*sGB!4-^?A-1-^dZ!KUV>--eQMSr<RhH+t9I)dk;>
z7i_vNb5166K0p}f0?7VHfCkhDSXj$&|Jg?4C85I(+*_Xo`+k;?=#3h<?ko71uGyl|
z*qRKr2(In>(K(HsZa~HO*!^HsCfntWcc6&*!n1Fdmv3&}BBSu79TPv_b|Abt>2`(;
z+~WzG1@(hrYvCcL)sv&G>?i(!v&U8vcXkAiAt}Ph;#*!ox?Ma7GO-V((ArW7iLCeg
z%vMoG@T8);r;<;$H#Igr13VHEEladjl$r89CO;40?CbiXnfw(npRENWX+!lb?Mtmd
zdGe2K7zF;D1AKl3JN%z~Zr$$IfRpL*=wB7?FZi7xrCZ<~PWFK=@>|uj4yO9z?bNl@
zY8^Zl|Jpr^?#MUPvUl{_Gw<bl<0}>XR+oO{pL?S)gf#EZgfnufzF7~CdH2wnDYUWI
z%9-y4Qi$OU(sa*(Qn#3}Jm!razM+BCRQE#?2QU2U1|D%xm5ps>d-L!SLVw=ip^`mM
z_p|ViR#A+P15O{<n42HnHPqH#G=g&IeB*Rxs~}LOOSdug0wxzPUqT?jIZUm_n(UcO
zyN&lT3Ec5i)WG0LP*4z<=J^1|q8ksq4nP<9ETmy>=vB&}Hx=>`rN-q9efFhl&Q|@G
z<KpH$F72W6nNmR>ef2q;5-K~@DhVHvs3QjwWM`UJChrxoWJNr#pGUL=-$IlU1oUr|
zs5%~3UpzsCY>k7Q{c3%RJokfw7wO1pX%rRb7<ecFUfBB7cfPt(3A_vrr<6)Qg1qK1
zbzR!M2pTJMtbh#N{H#p^6~uGk#CPih<ipY@hk*{~<(*(A^1jl-ZXOs7@p@dd;4Sc!
ziAe_L<m~*Vq5>B*lx80OZpU8nx!v#?QfK@pXyDx^w;FMDGe)e@pVjhfV5Hk=j3S;A
za*O7|@8h%}K5vT0d4<>|*G!Lj;i_{Yh?bqeKED}sc5z?tSqIuz4!~bq`GS7I>f5im
zbeKrxS#I?#_C|t>X8|q`O%Q)&fQ{(#QGB&<Z6_?`3w@MqEhTJ*KE6_FYW+F)q;T{^
zQsJOqTq;IK4m%xghNRm4SwFum6**vOvvJA=CXEm8JZx=khj>p;%#KN>K_l~hpy~<n
z{qO-1bPNGoI^cPf1<V>CBcr2!aAidR2$;dBFXzUB717I)1MFv93Nn9T58hii9hZlA
z9<fy~Q%1b;LMO=u(T9SB$4b+BFaGY=lS8!v0F#j}R6^C9L)Sa$V4yxWi@fsMr)MY8
zim}x5%R}nGxekUakeq1(S!qjb5EGS<9z+JY#1IK2SbdXsu?ng$ApJs#Ev5j{_e%a1
zV-N~^J9gu$`OfIgrq`2Ao7>z^BO+ydp0tB8lF8wLS)29YU<+5*D@-#lucm`^W;#@O
z6D*j3GnhFCDzvRR!Z&81s|4KgOHl&*t#B`zDNCTFxWB(|y*pcXTnK~P7m7lG1t8=C
zXA)cyRFmIxbMN_<*w+>mFqu+-K{bE~AR<yyQav;mGgTI`u}dBX3nL?t8Yo$%9B7bB
zm(|rwP8lEI0u{|4OSY|h&an6u47bda-fAB3{}rqY6?Juop2Po`xy|O}CG#CuAKNW^
z{r!XPl?l2<faj6%TyQk*!I*u$+}ynJn9x}-Xt&GA$R)Gp(w$rr4YxZxmm7XeJ|;b_
zb}u`_yj@|mnVCGtAP06ho+Sp^j=-j-A!ksHF~lD|o{h(;%X$CsT#RiI-TE?L0J)yk
zf$}oU@_GDTxO=9fHg9Cw`-nv^jXu~fO&`*-)4`A;tC!N+T!lC7`rhSvZQ3#ZWnW%I
zBozjGh!f}?cBWl(%RZ-%uklQG&0KfSL|jONFF$P4D-I{j19>8rHJj0z#{5Z4QxTDs
zl`p3w>clAdy(f(-M@yW{SgyE}ZE2+hGpl!!=2-Sj^Qf_@{>6Svi?CJH^soF!?^rzd
zC6~O=PgCe9a_Z)CN^xq*haJ;!3dY@agt@rP9-BWJngqVABh~QGU%MQ}^r2c8XkoeT
zmUaJL!uBBw(uYgag0T(K;+9+Yk)I06iT~tum5W2?{of?|{ZJk3+c*G^J36<SxXvcH
z!Nj=nVqW*bvHY})#%?J~eE!6Jq>K62LS5f38`sY&MHA@1zZ^6GAuZ-G48v|P3-?`n
zr;4NYx-WSSB_CpR1{i@>Q^ORO5|60+d~*o_WL=0y1x~1yw*E~co-e%%OGgwZP4fmd
zgJ$^X#0+Q2Flp$;eEP>{tnPyH9%)&a6v4Yz;<I@g&)qfk$o7MrvT?&)_?u-iPFYqP
zC>Zff?{EF4lcqPT=yMUxUVGmW7xHmlpK|fKW64&ecjlQBT{~JV$Y7a-UNf#;?t6~O
z@GkwaPV!vm%KV`U#=0GD2jG6C@UsqiNJtpm)z!r}H&WuYX93qJyGg3CS%?DqbW4T8
z$9ZyI=q<3h0|?~6`@G>02ui*vT&VMcIXgN#!-dRmR|bMu5{9j|4O1yf{}{T%X`V{=
z>g^^XN4XX@@5!J81A}el=g;jC301u3TD1LIrv%7@wNq~T#|-MDDr@F_H6Pzv$rZA7
zMdlIrFE`(6Hu>cseShSo$6{-f7ZT=X@-v40*7ottyBtXLqek&Ke0XQ(ewbyy1?czL
z+-Vg=STSvCVJTN|!C^O4>wf5#A`jx>bQSS-6z4q?M8c1t<q;(Vo9GYES9D8U`HssB
zT+6Gr!^;aH0ZO`>24l<`x=@2^KDw^KHKsyUV=XPM5r5leY?Z~~V5Z+D;>z==^<ZON
zhfV@L%)v_+rm!~TJ;davRGCkSfj!^f4uvqDA6&Lx%GH=F>z6e<WEMlIp#54H>pU&4
z=Be-8oBprmr=7CI35|0PF|IWg9BFJK$5!AO?)1a@r;>Gsn9RI30U<Rnud6wXf4+}P
z#Y*~RRQYc&z}J1`2&C~5Y^5Jy%0=3>UEp;-?si~W*8c1RIBhWSjFtKDMf^vXU5CgE
z<KeTaOPs3s`x;+s@XK3}M(7C6QKt<2<15}(m;&->x6Csp#LfW)oyjjPJ$?7iMQ-@g
ziz~aK0eW|k=RNAcaqNO5qOZTi=VQDs^!4jkA~G^bPtO+=PJhY%u;+}lFJ^qr(&m;u
zN}!vZ^tR#exrW^uH_%|xNo;RysXO0mAHm!JpS-X=i0{mS{#yiO+(u6HHt?$KENBEG
zXeIfw&C`k6PtPklm)b^%T$EZ%Csz%Nt3t~Mbx4#httB!VAp%hI(GA=y9(=e{@pU<z
zT%t1Ww%KA#xsofsqN#}89qL==*V%*+h8~-a68jO2mZdu(UHRvc?*(3$%ok;bLgam5
z^LKM+ZDS)`lF8@ge#KM+#M>R3v$%YCZN0}E{b2uVDUdP}qX-JHp5amUBS~(Z!*e)8
zE@q|Gc?_OScvb7_X%&aea%Mh_7D8RW4c>jcu9AIhg2)LD)97a+pGYy?n!s!V^PP>L
z1Tz%xC%R8@<`&?-05lX<10Xl(ACL?7r(z>{TbrAkL}lgbMGPaO0GB!wOb#iix|Wxc
z3jb|>Nl{r`DpyM3sq)XTRcWvp!^HHPwoOzjCnhJw;WG;+!V=2LiFXUfZx(^5cG?17
zRAdG$(x6oc04&dre<1D~WR(TPG5lK4rZt?{>gC{guPL>TWh*#c3MvE&_&ydf&-tw9
zy{!m-{}>ogYfJ=nxJw>TheLD^nf_!!S~}l+A52%VA!?)yANuJ7;+!tNS~+G<dx=cs
zk^EbX&%000t0ar3kO38>AIi|?Q$kM(lar%2^3c>jkx?G|L$)>{sB}9j^03%&stZi-
zKc_`&d(@2<8Y12Hc5xs0Dmgchffm!1m6hl2Ck)j#3qr88chP9@NjY60nh?I>DSmu(
z6qA$`JTajH5dpTItW76BD{iIVy^FtF0MZm?WxJ<;6ze4<q}s`1T9pII2xw7*o{g+-
zKht(8Cg@{Bt(2R`!3}mgOQvn|Y2nAbW~D57hlA}|WqV3z6B++xgxoB^67!JO0U=k_
zP`t^SEWm#}u+skZ`QQBeIjWZrzM(i5r4fiGBn~(D)!WsIA;{izuOz}r8?upK!jLpb
z<!)O5NxS%fGP1J)K}>|kNSe;*`1_r(x-t{a*wlJ*NE?m{B77VaxIS~}c<gaQTF2ys
zy(W<N!I;^HQ3c%{N`M@~S?f)8c+Y_Ob1Pih719b+dcy?vYgY<kEx;@L)@S(K<)5C6
z!QfXryxP^8aZ~{!4Gk14LEVnp3epqm(f9yL4&$gUs9;OYj+x5-rcv{Bu-V(*hLtM1
zV{W#X`Q3_<JY25Oi^WIk&k6r*`JSF#17X-?&R4+)r^{P6u*j|wA^CTZ(}UR9^^#I$
z5IeK!9rQy@AKl)%11LFI6a}04ZZhiL1&<>upR+eav)5%*hh>$=zpsj@?SW`w`XgZO
z`HcYuELqqOHo!H!2<&^G1JLr}%%M)J_MjPdodis?yBw-Dg_6>2nu()@t{4CVfknn2
zAbh=q4HtnC+t*ZA4+Uzjoj#ZKJH;zsn>qmE`r9K5Cmisq5SeUq))#ncWz(v=3$P4l
zjBRQ>ey)gRKxcDY<$nGgY#}>(>)EW)Mk4?Dd=SU4acVrNky|!G1SX1P2y^|Nhz>8W
zZ;xL-<O$@6|40kwrZnkKZj{-vNd3J_QHkzzZN(-)oJ>+m+MFkiL(;1XnV*1Zn6{3b
zrB7Rz6<&Mm>XrT(aH<$FHqIzjSfC=6z^*sK3DjdB;X1!O1!A_HfJ+Ryft|On94>+{
zgNWSgL?Pkh$E)+LgM)4pp=07_yu3)il^6Es8hBR^XJ%%k$IH$ae1rimxr%`m165<V
zjH~xid?o}UbeuB02wa6bz(1CO0kaTnc(UQBjRpZ)sa6vbf1M>CDbNJux1#u>s)D*+
zM1}YBiw4k!xkbR_+(paW>lLTCT;PO5W_^67Y40aBraFn1{?kI_&I#j$&?K*ZFxr1@
zEbTKGIEl~rxNux!^AHp{LCC#*+A}o&8*8ytd|Cz3>8ZXZ;LjOAwFh08+^vfW=ILOP
zqe)iNwt1`_G}#1#7mpb~V_K?3suYuAIi(U41r4<Z!MYL-42+^L!M)Nz&jxr_+i9bu
zCHUMJa7rARoD7DOsjNx;=NQZcaD5oSLTSX1TvwHNVFF*|sTLpMuI}!`UO8_ZFj)pT
z3E%vD;E2}_479IdCE5)H(JzkfwGdZ4069P6Z`u<O{ou~PU<^gZ7NwZY5Bl6%b}<Ml
z<mRG?o<Qq93^Qf=z2W;}q?%^&m_&8b!*=DO)MmmeH(wJl6#UrR!S+<l{lZzD$;4!<
zwIp4!8gPyt5NkCcek=Pasw@_iHra9|45m>Q68yPqhsb;$Alc_y)OQ{ZpwBd`^eoN8
zZzB{?uA%1cei82cRDmR|14KPL2g&5I6yUB&0H1q?+nN9-F-Gw{5O<!cvB@-R0jAiq
zK6f{+8v+Y;dc0HCH7mdmxLdXP2><%52GkmX+DcYl9;4|(k!H<uu<$h%XwJTT%?2l{
zJV876KSa&1BV-!eoTs)VNKCc{Tqc5Dxy4I=dlBeZ2Ctz{{Bafp%=XjLEm4}^(dj9x
zyh2o!9muUu{4p7RdI(6^Yu7GmjhT&nReuGK_wG@9WiR#0x#li$b}F*=XCADzvB=jX
ziqUk~>xXWnM5JUHL|Js`atLsVTAWmiow-0}I+o{sFA~5(xqYgkTdwk)i&DvZDF8hE
zTABk569Yr56kAikMy3z>u<+drxTPMTmqAni>e?Dy+PL=iY9}@>u6&V~A6Q@j1!H#W
z`YpQatI3uwFh@KxJ$+w$GWOG_C@W~SKJX=Qy@M?b_rZO%z(<1s^ul26tUj1MY$fQc
zptrqqafRU8^T(S$LOhU?4!!UqK6&d|_EIb}_7@&xp9#0ewlL~^>E)Q=xK%f^a?Rwb
z_*{Gib-uOPY3!ettmZqS2qfhZ>`6p}Vn7%CjLXv6v<NNSoq1p+gAST+JUL!YQlbd}
zKozfCMMR=DOQKhXqB`<jwu*l!(6-}P6m$#Q=;%t8O<TeRdF}S9CWkJGKviLLb2E8t
zSO-`Nf4{8zr+cSAQNR|pIQ2mdhaW+7U83HoI;f27#j}OViN(>DE7O4n!?#5eIo*vn
zU{DGAPR093MV4qJ(=6y#5w@#b<ANvJ8@>{sN)4OY**~YX$XTB{3rZ0Q4fm^Wax7;#
zA_zGJ(@~UR@9jN%5)w}7EkMsYj2|Md`D=j<XUxmN1k`JC)<i*ZAl-^O%zc+u<eyX?
zA?vAabVEHQQh7i{l{`;&N5A+w&2L4J&lcie2s@Ay6Y~2BOq5(p#Ed?Bu!n{jlOwLg
zS-$;|S~@C1Tv!pq;En?vAxgPGbx2k|ygk7(ypj0r*2|$X+OY3LUt~niGCzG1hC;V(
zJV1#S5tL{FY6u3X=;rRlLWG9q0}w{OR4l5K{B1~7K(6&SUgSSi0euwAnw+4Iq9?P2
zl%kWk#O?bmT6(O^q6!wuaFa|G!uiMhxlFZja<X8m!z`s~+qoUQXVwC1vqzc1I+!n&
zpZtmWN<VV>ur^<U`yItiK4*s7hAA+_$yPs9#bO`^hiEU;+HQ8zIRAShk_p6&c^>m2
zA~mDIOO!pOf|b0dGtX2maUTtW{$M-~EVPAZ|07Es;}k(4)=(T_ckHWVNk8iiJR`ES
z?|8W@^uV2VKOgIphlfp`NWIsZw}{0vEO8IRkNKMYN?>&X_54Bs#sgX}?S8;#TSXUy
zrwJ}?SpdW1^q`E#$v$e20CWXV{Y=+V`=X4;^=%SqdQ#{KpTO7D>Ke@75iI+drQM=$
z&IdEO>CGLe6zwSsorT`OJNm-|;Pve<U#S02eVev~16|x*2D<yv@LAniO7-A`5HZA?
z*Hm^<hxo@fv|_Ny3yPlM!9?%4*<ubF2OX8?fbIj!iZojUQn%+DsQ<XgoxCerNOWL*
zg(p~=aY&=IO6{Yf#bm~B0i^r)P3>MhQ4pA_t96lQc*v+e#u5c;P-Fnzhe#PmP*H!f
zV14wzF)RXgy;Bx;bw2^`naUytI;PcO7k9zu&xPL45cFQw6j<#Sjj|)}#lGy}s!*EK
zNy9$v8-M2{CG`p`S_}|F2IYM!)t~MkKvXai!l-izt%J%fFcRW0A3il<$1Tcz&b}11
zYvDgSwwx&};6TpOxDWPN*_*M%ioA8VN>D=;t2zS4EE+-Zfw`^S6E6eiCr|wU&i=w{
zz6zatd%W5z0r>eLlK%ba1JigUS8iaO{c-~r5C0%UF098&SH{8S+pAzuN<B#u5L2DA
zmiAqXl99JpIVjZZ8tC+nl4*TDbMK~=V}TSp6Ay;c$;9!BGCvu>tCbHl6L45IlD7)J
z>}3?DTcwOHPbK9hiqD06Jb~9Xh73`x_9Ilf<3nerXoO-UIvfV^L*Q?-xR|vWjIj}c
zwn)$j{?yIU0i}2@F2dUj4=L5ndCn5QmJOv+uK5Kc3XjoY!EcqZS<SEd_hzskQwf+9
z)N7-i_N6Q9I`t>lm1bLu@bHK)_zduNpB1^cu3+vEQ8SVC1!{iYpV>__NK5Ytq}4Fy
zaIi8jw;|Y5IxW1rYc^z|(+c+xUw)UPNdhY{^-`{C0|kg918>kXzi!^%^A9ku>;WT~
zh?DwnUbffPT}?byDs;$3yD98u|J|(*<n6zB9a%cq2sc?94K^i`lU<dhX0_lnDc4l`
z4%0JIK^r`KXKp|QRz?#43UWb4^6epe@Ou5qEw~cWtH2>J`aRQS+QKIa9Sht2$gdV8
zz#%kG;mi$O8mfDr&NObJ&k!G*20r<Ojq^w$;lF{yShr^m7={hBw7FjPqSB~JkF=Cw
zld+-^kL&NsA-0l=eP0&VyP+R8=J)LpJyb`)7w2vN2P72uy3g_FHaI-r`8f0z4AOzr
z&a0(_rToPl?mPl$1|v+kfKrElae9cpF@+;}T~!F;o6ALfMYEw5iJ=V!Xe(;vA~@mV
zz_@@(zOT30w=~B}IPpAYp6TF@z>ttI1YQ1r<J>5<g9Ye{h(x$Q`z3iGMi}-phA+IH
zi50=3uv)UIDN!5;JN;g=hXu;MCe`1q*AM1uh7_GNV<7!xlAwe0ay5H#BiaM;rBMdR
zIW0}G4j^J8jB^m9N#opxYLUEuQa1uv6%#Ex&!*hK)$PKvjRP~<5ag#?BgtaPm%+^9
zFEW{yPU)!_V2m25te~$9qbK?PCFV`-+$tA|Ya<Q*YTVEW?s(pLJmIW5U{uZ{V6;dy
zPn@xKDX>K1F=n5dTW>?@Dhw*?p0ZjW5Jan(W+zGx_p?aj8ptSvP9^_H0wZPm53Jco
z2uV<(ifsF=;}iK+w91J}-@N1)xt5!JB%UV5=54E}Fe)o<!T56IoQ+>U$_p9T$UZ69
zaBD}f)|B-2wI~|IuniX!x|H3SzdbuFD%&se(SMsKcixLdf5gk`GAC56+Lg6Kuyvkt
z(0}%AvTW~7i9v(XB7b#J!>W+GqU_|Gx)K4_ckQ+BJ~JGsvM~y9&<K>{3|xJ^NoiHV
z;Og{31O|*eom_JjvdpzM<}N=aF(7KZ$hA}Kz@<4I8S>c}5yFiNRrL1NOyU)*vr5F8
zZSH6+W)1T1>D~?_Tx|YXUt=@1x-&l`;a&t4aGE18R#?5Uf;R7bOil4F!j9}Y*q3pc
z{*?F~{ejnG^EI%h{jc;NoGe|q?G*h^^EZyima0rECbFw=dA}7Jp-g0uB!=$w7K#es
z=Y3SI(G-Yk=5dXvGDYwmP9+I|5R%Z5M?2s^d{gg3eo0$O-M8U%6yBcLI%=yMF(`<X
zAKGi4BV!pAU+aXe9I9xaPqeV-t;Q36(=2eB<F{X^liP=$k2p0%T71t)i9g@vyBtQ=
zu6EYTEhS4x>T}yGJK?V;;|$g?d{9EaSUexyOz1djj8c(O)@^|FbJox<Q^Y7EU2Vd3
zrR(Fsl)<|esV+M%-Fp9i6o}_Uquf1P1PJ&rlz&sYh#sxr`I3$4^02CeQ|vM??{MU%
z+rmH+BeHtAzQ(yX{+zz#rxQ#fEq$&~pmuJ`@a^ri)KR_1+WASJu#5W9-i*s45nnep
z%FfiMZJ_liL)Vu%>dW1NhFig;UGWuZ%dUG1ENYTgSh>+(pjf*7lRP^Ka@AIA^_L(F
zWXROX#cC+#*unx^sE;24_@=;nd=GoG8X@1j7T69AdY$<A>yj{o-1oREU9P3Y8nu=9
z8nCY0Z)V?w#_2sAsC*25#lpm4tId(c&^<-2qN?&q>uj*Q67R0v%!I%gn6y;IY%vy}
zHkmyIAL~2qUJTUQF^{2hBl=*6E>djceGBKtTDi}S{G>z1^=6tz+b;dJJI5wALMDh1
zr(<ub*3O`m^z_w8jDOaq*{6+k?#|iRW2x!pFn@kMcM?!;Ft2EELN<Q7b30o-Q(wcg
z)erN5t$Eqmo)$x^Pc&*A=Y)Q9k44G!?eO6uR}ZJhHfihWDQU8tkK%5PoMoraJ&-~X
zJ1FbCEcA7jzcux_a;Dt;BEy1zu-J9Ki<q}_?OAnChlaRl(Nl9?!w9}iE(G6tx0Z*C
zi13#vFY&1*H$j-feRoFj!rP;BzwyB1smTqrMrpF(r_<!krPVhlo10tpZ?_hiyRBNc
zUAge@YpdSNcREn=l1=M1*z>VXzjUXt-hQzs=cncsB$%!|h_@q^Wv)K(=sP#cd8P7_
zBpR!S;=Y)M01u^rpvEk{yar=V9``+yw4ZYo{RYt_&ixW^YhOcrt->LM@J0Dj_w6+&
zW;b_8Z+dIGx!!0FYuw1l`odfvb<wvxH#*I%ZmqAGs5rVcm!Ho(XL`25H%MBjvWm24
ze>UO-qb&Qx)^d<~y?>&%I_9NVUh2dpqp4-B`f9`oHu5OtND(Y;5@yOsCBT!c9_?&2
zd+576^*Mp-(R*#;C-0!?-1E;H>5B3n^JIq;Kzxfr{$11CLY&1<G6Aoe)=_H(9mXC@
z1^VZAn@{q#W=Lz?45%0UqSFQEkfY=mJ<PCVVAaMka+V^b|K<|`ani#@(Zz*YmX;h<
z9hZ{EjiI;iDp0&yritUnoH*}UQSedW7OZ41`xzG{8oykN&i0=!6P=E|1xHW7sQ_%R
zY_0EhMmOp?Wwf<c=80xgOt@<lG7yL@@4qMUOXn}cP48btqo;v+BL;i;OOW%tUfc7%
z(4)7VQvDNqeCigbQiMm7O<oJlgBANlr$vn|O;iUMli90JwQGtJ!>%10(p~Y{%2@`6
z26};!$@l&V9X58$eC8zBZw|gKR?P|<UNSG&-}CgnlGBGfOjLWDdZxQ&9|^+TJ>NBO
zjd5F~F5ACnqAJQKaT^Asu*mSp3Us4ZX&@l1LUL24ob6vRkmT@t>b?x_YcE-0TZ@v@
z+1Q5)*Ry)jnwYh}+Rnz_h0-kT{r(Uqch=kdETd)g_5OKv&&_SEbik=pjmBVQZ^HF_
z_>b4CpSX^Obw7GGoRQT=rQ-&3X;%*&igPO5HU<_AYA_8(nbaHKjNYDDv7b%JVoFUA
z9Nd?X@)vRDOSZDqCiWnOGQCrj9Ylu6^YRj9+Lr03rls-Shlqf`F{i7}kYt<nOXFM;
z4(OI5QC?3l+{b37`_;fsc$M01PBO7~nVwm8b+Kmqa3n_OoM(A<0Wzt<bhkzI?RGQ2
za&yCqx1k^3?Thx%(qkPp&1_>03!@U9q$Kk2U7zE|O8KeOG`eO@>&f2F{bx%noa2Q~
z5k=kKKN@!16b4j25q)jZ{UJ(&);Jt|sbdVd{piLOUF2!0bi~0v58F3DaI?0iL#~CN
z5D1>a{^Q!?u%LYkR_wdjmAv$QC@Sxlcgj1sYD3>XIN3PR<J_%td?h<~o6{5k!tG;(
zM#IwUHqYW<)q?gurkT>A{o&^E6;E)FKJmqGl~;Ym4cz-&tg&w&y!VyN-kIB8vFs9T
z=eNi2Qi|1m94YUaj2T4lb;KCnEDQR*4wbgF0ZJ;dV??^d9<x(V-}MQ5LLhof@OZbi
zvlCBKRa4`@`S0yTQuibw=h`-DY$;3?%XUEp`Z=WTe2BrK$h&CRoYEw(!=>i!!s7;?
zrJ^d8Tj2%8?H27=g2rpMDTVKwxK{R26Nm3-vbo1tX;y`Ogzi~2co>yDAgK2LnVTLQ
z)h9Skbv_!;X=PWBP{ydvMk`>)r54OnLB7{FWxz6kcYa@q+t6vaI$+`}x08So>8&5e
zp8$CInG&q^4GqqJcfYK)ufTGkK<P}Mi_xvm{PD@1Ot64Fg=WsFP0Mp;uPv2}vUu*F
zEyA`G?a*G@Z$b`lZjTKLtX*!$StY%9eWi)BI*jvECXUy1YoE5{@NSk1&e4Bs{BWi}
zbKWnQxL>~ag8H3GTj!7OdW7HCqOtm-PIB6(6JsW#7GgY0T+v*pw^(NgQo3BPcm&U$
zPf)+p8AMrjpaa{q=02j<pO+rSz}wmstARc@jAeUgXDk+4_$aM7`#>Z3)TU%e{ieJ5
z_w4FZ)vF7;uW_)-{h~?1FTW0S<BSzANl4z}dFiI5525Oaqy-2+XFf>b5;cYGs++kN
ze?H(HjQsJqI){H%$X@LGC#MKIAGL*~jAk+{(^sg5uV8D@4_-Uq0tA)lWdDAPqg#g0
zAZjPoNb6P$0|NOs0_96QomCJ>9cxT%LfwD&ZY9ggrZ8VwoW@<QTlb_;$aTn^%4Dlk
zSJ?cQV)NlrQO296r*-{DEga?B&Kpo?h9lfy!>5<=oi~O##%qEeJYz-{HnXgjXo+j~
zx-MEnd02JYWSm6}h7n60?+tWX{sbXW_O!`20+h6b;V!n_iFpfTj)TTsWF~VezoWq|
z(ps=mL-o(MR)gfiv!i;LYlqKfk$_i-0{hncn_=mcDD%3kU&X6psoUGO=44KQM@ahk
z6UDo2uB7bVZ`YAk3X=04YWq8n-9~58oEaJK9Cblh6!uXrcit1Q)#jteMtc$~=hVaJ
zEKk?AX@PghEg;O|Qz?AUw1VGsZ_0PKLtejRK`c?Z-|Vf+C{LHT#n03$ZBFY109+vZ
z_YqkCtWL5rdCX71MD@1Rr_?fsn(khmJK?&cU=GvnVZ8^2?cGxKIK{#}Vdq-KtC6Kh
zOq)H=w|T?5v3KK|VC&UC#&;XmPkAgBjoCmq(WgV6P}3N-$IJFQw5=Xz@K#V%59*}2
z-`;KXw4bj`tz|OzpkEfN#Bqq#<!97`9*VuB^_(ylTZ0djJQid#l)0E)WCi6>QT6~9
zD8U2xp=)|P<X_}cHeo)BfmU0gj$rNTX<rL-_IZ;M^-+2Dw9JNC?It*>jm*?YwshYr
zrNQopzmKt4FFo5^gMtA6#7C0zUayBpQtyfLENetWSlmhR8h&c|9GD4X`>E!Kpe9~4
z`%2DOOw+_9B0kKcAQrsb(I1ZVdm<C5l{e)E{)*;#u4vI8izB$L!-8!{&Uz%I>O>a*
zoQwk!L@mqY`g(p@M2I}VHL0Oiv|EEcGfJCfb%nZ}*s8mI*FO6ftKB>AUC7Moyb3Y}
zOt{H}Durf^9c#@EJ}9RBPPkgJIJ&!C&xdAAK4UnVZ|B4eppk4qJ-&ZAoH^_`JyS4=
z0TY)u3r(LSPlSSCqZB;wgMheuspCuO<kGC+!yZ<&ij=4sgz3Dc<tYAQb2W9J>OAhv
zT$zQ`R63pEzYFDM`S%FZ#8%uE(G1Qc>UKhZlGQ%xrF9yX32xrknP|CTn=I6Ma3E{5
zK;?B;9C=xH)67UKJWW6McGZU21>bE_l+R}V&Ey_`#V5AAZv{sl?rToxeZuf4Q+3cv
z#P<rjM;(M2%XmhXrH<u9U6*FU2!7dU9;^kd*BE1+0=0IAkDX0WDyGS*SUA_XwJ0Hw
zQrbt0@7vRbyfor|O;7jsLckpezR5Bc=5^#+MvF=YUI!nyfTN_G?!-BNm96LQ@0|9u
z$&PncR5JIlg(np0yjDXP-Sy0qJl%ZG${X3VlT^&|xw?1oynNE6-x0G#IW1#Hen*0i
zfotZ8%pk$Zjj>C7dT|uE|6*}DoyOCZ3XkSx3mu1y!HzuXk6K{Z&s~W-D%5j!W0`S$
zWz|lea__DO;yHv2*<SY#{uhd=pR^(D7gEQmi2bTQ`b^8?;(6pU@ho@14nt^uGj5zM
zy(Vk-+57D1O!oXJJl@9Bk^zR(JfZ2G<4Y1LQb}*amh_tak9M2&O@z+YqVvZat1f8T
z)zx>#q6-Jg31&;CTBkNQD)5lwu@&&LRHtU0?&u{co6FCcJWUV>$IA*8x(`Q+^7JDu
z!B=?mFO;SU&+8qz;UgKm_6dBKKSz7|_Nux0g&_G=J%A4ALLbF_@S6VZ1+Xa+a-273
z&Uv(Ng7r9~kWuGC|6Oxq3u(-G5>i}d%UtC+!;wToy7pQl<^KA$d-FAh>Y7XD$H_6K
zyA#P?COu~Rj>NH1f(VKI?UCtUg{#kJL{&S^JXkJ2?RLcMzV<Qgup5B~M`LilyD{sH
z90bhLexCQ|*NT9sGflC=hw>--;JpGcVtQwRoYm$d$IClTuDq>uk^McFvfI54)a;T#
z2R$!MX?InrLvJA;J=r`sGHdLcnh%ME4SCs9K&2+FvNoJdC2o0T`*-#e&v%LcUMR4$
z9{9bil#?DD-K%66StuJ_)$ZTRI@BM98T5)Y2T4P~Tl^@lQ^3_svOe6|NN`4)-m2Z2
zn70oFWF=}({&!ePkW`rvUTV7EKy$vgt;ACl=l<M}`}ra2csXJGKnIhJzu~LI)uzIe
zoO@qi71^xaoI1hxVM3qo?!<11B0M9|c<T13aLsdQsNdt(6U6T`Z2W5f8S^@A`n6B!
z^_CgyFJ-s=uQbY3Qpqq7rw4LZZU>4o$Qic}Wn>H<j__3XJ?jJ@tmf@_WCTAdSR4Jn
z0Ic`D4%+@(Uk_Ke8)!P@ybQ6yCMQls*kh=#zfU1D`);RJLA>`WnDKV-Qm+UqRS==+
z6ghifkqB#I;d~TK*h;20oaA%+_TiK>IKvKkzsq_uUVUJNPP+8L^QY$v*h4!{;ArNa
zafScP=wdU$26&b9)VNS4kOvgR^LUY1#4@f>7=ia_i3|^eK(y%pgh7y&^b==!@^O?j
zcZh9Tke6tB0G4I^l}>qm%01!RTd$vAPj^V>H5U3{4QWTWtErU<EmK9)npr(^HT~1N
zgMqq%J}cGNpLE>ja@GVLR8kpjnUDOM>>K#ui(HS8{BCT`$HS4dAll&Rvm3MuE|TBn
z`H4=Z23xW-j`9}UF1@wabr0dZ3P^-kaEW=O)zyjV5kM{guy#jv9O0tz&Et8M(L(TM
z!zcD5Bu;HRXOKpOn;37rhB|%)TYRHGD{^r45Xf4M_bT7WIpTfX>-8#pmLj5GVheFF
zy<*zUZ8)PJMCcz&ZO-yFF9_<mh{7AWs#%A_Q|m-07c{1~MjaWTYyvpV;{$36(SY?S
zEEI-LJ$~#~n2-9B3<*vbSX<k}Z@N&454`OETp@d>SDt~7`mEL(PME}jx5|PJiRN)?
zl~;vIixXqxt)-R3)s)@WkP4xt2!K~rgA%W<l^J7&mnWYkF~ZO6*^HG>kyT&3&r;a6
z4WL~B;}N$};)OOE0`RI~y=6EzK}u>})a0yGU)0>a57VQfmrri~A5~ug6=nB*4Wc3-
zpdwugA|;?8-6ANhlr$(QFbv(LfQWQ=htg6r^Z+UyO2d%SF(BRW-5K=v{y&zYYq^&5
zaG!h6*=O&4?vXSU?&A{XW8vr_-<Y;myAOM&WF)eb-93I4poU00&Kv0ZWMzR&#wUod
ze|VT#c4cjC&iG$(MMkC?m2q6Ye6wRWLM}#N{^;}QpS{XZ<<xxuy@nPPxzCm!Wi6CB
z;zL`>V~*;BwhWRr9czy#YUj^>dL?i>BlQi=kBaUTqLv9;7<$RbMiP8EnuK70_0V@$
z%dI=`Udl8jI}m%`l{=h)QpT<DO;FMnwpHD#|4mz0C?q;2fZmVjS1!Owe(mCwV@vx0
zc!-515iu9`f=I{)+2OoQpUWIw!A@K8(r71zch_=k;~AH>UUxgbw@1kiDrBE-QrmLg
z8wFGGwvkTMF`?~gQIVdSy1)4J6jqz+WU4<|ZpLFdI<^YOM@o7s{(KFx@uFHlGA&`9
z?D{@$rG}H6u?g+i+Ae^t*`o|$LdBLnRJP+(D__)2XtP2AX9Z*Z7g!p%<Dz%Wq{29y
zr(rSttMXAZhD+Upj`>aor^7p3ggU1`UL2Gf4ff#@7fHDYS7rko9eduj1V94(G5eMg
zt}z>|HI2jyyySJen$Eqhi4bY8?q3RVMQ?-1O&)OTql7ryL-pdsh2qz<Y1?XO!y^NK
z(~78o(@Ra~I6iXAp|3^TSdN108X!B=#boU8G0|AlTYge)(#U?9*M>Nje-)wRhcn)4
zVc_XucV0JGvgbcsUu2ULM$gYy-RcOfH<O7uT4Q=Elz=F0cp8yr5p|r1i!d6Xr->b&
zU`HHR)S30l*%Msx^nOTIt-78^Bv>NIrmEkO^crWxe>uj`$>HI^OH1Yt_g2A<o9A_9
z4E06Erhkil*$SS8<;FjF8vcB~gjP82j929Mz_Jq?O|;k<8}@o6bhpV~V_Q((+ADj)
z+~CJV0NjZ$Z@{~j;oQKwq-Mg^D2m~HAzVRy=UttWlPM=f(72~I;6Bzukf6@Y(69!4
z?PsBRhm`34@0xR&y3FW;BZX(hB_~S*)EdH7kGLIc-}j8JDUIbiywG{siOvg+H4KfI
zw3U9%ZWy8WwOHiJti6F!teiHUO<1)0lA+ci`}&4+v1Updp7@?;ZMO5{DNmQx`iI2>
z8+y_AW4HJ<o&mgkxB7D;-IvujQF(wMN(YGkf`@!@D`q>9F@aOZ{!2`0+o}_U%%rsh
zH>F}!5;bDzHn90-lZcL0ODhOgs;;D3pkO2-y5drz5UpeZmdlC;9e{g!l>Q6AjQovy
z`sW&vsR_gZ#bJXDcEby=WQxSZDZJJs{CDIb&g7G0{?RJuz3PYO0(GDYiil^}5PYEe
zs%*Z*w^D=8{lS*~B0hbPhd@K0$#G&9w~5Yv-S|f0+r`gwVE`!+%@s*oG6&qV408U{
zQFA99@~H&yqQ|*T%#tEl82Zt^|IWYV!h{EVe3=^?!9&Xq4C9+ea<fqZBpL{ZyEGOt
z0)5O%6zWy}xK(G>vP@}fQ8F6KriC`7hwV~!4UPf9k979Nk;|iCwb04H1R8o9=BrsW
zjzMvt^j6%hOCNSy_cU;_6QKQ>3z8M~Xax3Q)@k2~+9r{8u)=Av!=jbt5X5cHR+^9;
zY<Vo5OW2%zU312NT7%Hw{p#Pyi>v>eh_<To*Hx4K`k|WQNzKY5szlbQmBn5i#SdT#
z8y6k7MG4yj!^)u4I<C408&GIr&4j}c`;jVyyR?X(ZRo!0R<FLC^XOiOxWTmM9AF5B
zX$Wep45lc9r6-%Qok}fp6*)UXi8|;}y_d_u3Akp}dNpT2Wz);YTuUe%qP3i@*8my$
z_QmKg<ivRgsQ6q2B8{K(UxC5s?6;LnC}cyDPb7M#$4mHW^0mWi6qk-Dx%J$jPExk>
zI_p~XL0oRkk#XAEPqr*yd0J_&ll0^b^GWWE91x`pS*}^RyKPuMu+tIgH(3>NFqRLK
z)(3C4DCS94XgL(u<nxCh;gzcVyX^50Jja2=F<N4)Dk7g=kT@s4bN>rrcc6shJ0;Wn
zs`D9BE%YTio*r8~BpS*MG+tKD2|Je0x)O07B<;+fx+3ZjRM8sk$gW@7=x|zI?$Mv7
zEX>OeIDoAh<<1R3Mq#xj%{d`(Am5+Up~ByePkO7BH82Z5ist_<0M6v=To+vaP=#;n
z$v0cIQYz*LZ{I-gdCPxDNOF>@YME#}TVrVEapa^%fB1g=th|P}cTY#JTNiI%YZ&#Q
z%rM#H(XeUEk=kDtnQ=d0zx{Mwl)GnP%@ob-@sO9dFc`2Fu9iP$TdZsa%1Nz|F;S&e
zZI5DY^mE*b&ZadVCq2=ErJb(}-rf~eS)uYB<?ly#s45hT*t0?znQr5Ohngn(M@YPv
zhVJs(%oi3qA0Ks4@ydLYjIGq5Z!mNeX4X00KMtYG_uR$m%k^+Ipo!im$BB%icS)2Q
z{N$0Y*R%df(XpYhvg}l9nFtAX{ozx|<A<o@K0R29oe<JQj(#otC*T<s=fZ@PoCiQn
z;5wyRovNHJM0UA6gu^cJHz>Pr6U)#JKjvPc01s6q|G$-Da3<8fLR-bnPFodL#4UEX
z?b|0F=1=b~Rlk#ZP(a_05F;;iba&+Q&a#|4Gt^xd);1pRzF9cho&cW1kV8jUMEmD{
zQj445a^sNaj-SF>6LpYPee~Mg*9**VBh13|NnmBf*4KJe;UV(YdNxPF?+_yJ5Vx_x
zk^BE4ScLEs*C82W#Y*GxE~BvF4>;rH{TgXix7HIwVxA)$$J<=}tz}kqT)pk3Ce!qz
zA`2WQTG)Mykq4)Q<5t{Ei2XM|O^_4p=gotcS{dTnTn{t>zNQ&DmT+(#`*9e9iQW;|
zqou2nX>5~C^6c*)0$vWH0jfGQ(odqq0!$p%KsO-<(@akG$o{YT)U>RON4~SniqxV^
z8&^@ukD6!4ftaak(2H2cbae29WKW5i4rp%SW9Z_vl_*qF&(zZM_46UN{bL;yh8|Br
z;=TDKu)9H7*P9kaMn*6e@OCPVm#i8hA1VzSk}EfoyaNE2x7EXmm(=6%enx50hP=1e
zFO9WmB;>9k$?_6G8f?6vT>1XKy~6TnaptM}QeoX}x3tgqO2;(s3zQG7yfP@G>eAZU
zoodP9e_TjctTol)?e;wH+)G`1XB(C@G5_gg=cXWT0soE}oCMUtqDg>mg}2}zd6j2L
zD!qDkV+?48xfxFKy7sF%#?01No7UQV*36Hb9xP=K{?^?jT7PQ%#@&}_Ow%$qimwV1
z!&)@0h~Dc~chSi8+qZ9#*$WG%{{>NPFdSaR3)gz@U=BeMdA8tmuu7jFaW-)#><7=n
zV-oj#xz}ZUCc{__onqflu}!!IUlK3SlS2~;C7<~zf=>D>n_C#-Vm`DoY)qBE6@CJF
zV{I~ETjT5GI$lbPxO=F-Nu;k4vz`ng9Lj*`;#nx3a#A`&ynkl^tdAjAs}Iqv!g!5i
z(0^g`uCs?-2Ng$Kx5IR-aOk9pDzj{jh}kYR`L}mwiWo%wg@lN^sB-IkIabBnMOs^v
z>A^Uf07lt`l9gBvYO}keKGdyG0_NawTP4${w5_F0u*~3s8pIq+zE+`vAvEYucXx7-
za59zvTG)aHj}iLSPDBuy&dwlPH1hIa>%E6yNDd%_p&t|@gMIBGQ=RD<ah1N8pn$us
zlfSCAUM1(!R09u8#%nv@{P-(%EBTL;oorsOZuI%dL4K=4gMA!>xSK?-)oHCY>U%|9
z>Lfsa^`iRVc&3yp7_OpUYQsW<9`!1dNvpN-m2w=(SE%O*pfpto7}WXJzDyWNP4{)G
zj^gWoiDXb!=}7{UHn6b%!md>gz*&N`IsZIYuCL=@ZmP!Ek=5+&0R1GR=VGXh%c|!o
zOeL-ML3i#J@z9IRrDNp0!$1jg8!j(<$hFtLD#lUr`PE*IB>-E6YCWr=pIaH6+t!dH
zrEPqVk}8QH-a_ew?*W7_2XVBs0L0Ou7tBR@Q%ti}b&}}EsAKq>W`?u?LC|yr=Z&<z
zCmS~SV`m<zaXxE$a6DF!ohDv!%VBIe8~q>%cjLiX0q9s>TP;zC+9a}MAH0f!Vc$kr
zE!a|ZRTX=*6pV{Y?*O!-g-Fu|Srx^k)TF@aARuCOlerGq>e)|zoSj$FRv&_l@p=HT
zj%7vozk@e^v!ncz@el&VQWCu>w;K`HygC^x+{YYB9aAHDuqeu(J7C5sr`mpkGay6i
z3QZax{;_@}IJU{^DryEYiMyN0v-|i*XMi;^10vv(Y(mY7qi6tM<vn31QOoa}cF!O-
z2JKHbISsR)-iJBIylgGvE+tEd<kp`<FUF^RcD&D6)H%h)q5sjLn!1%ZK!2OkAnET-
zEl+Gu_;AvRlEGyQSpx*EcpbxensrePbWtsfVMFYJs;Xu{fu3%pcMTU{wvY8W*8<oK
z=z_*s0Y#$VF)ZqwIOe}xX9#w~kkWP8A+Aa3{4d?qw#k%^y729Hw2lfGaSE+iiKBt0
zi^%_pm4&dY>vp*7<GQ|XpT8NLho<!H^T~T{_yHMBcD5jxtN0Vk*1DA4)K??L-X?I0
zOkU_aL%}L^6ZnToi#go^5G2_uDv)f??DFbySwGxfhNi?}z`{Dyg}jL(p+*lB28yae
zUy8oufa8rW-Y3SR|0Y>Yv%mqDrL*MsMC01b`JbU0?6uI!O5G#k<3g|}7|!WGXiTJS
zk6lIc=(!C$q+yn=_d%9Vi=gGOd0=O6^feTfr&Jx5tl6(=oTRHu>6lDC5K1W5{^NJb
z(sNl23F^515r%#W;!9&A`U&Q&T%ZjVU`HZ!BJ=h}+&jDSKj1i}VE5R;dr0P<YC&X<
zTSDOhpG9`qs~*;)8G<cnQCY5KbwQglP4sqdN<k<)ERgAttKnV=^HNzQ`7wceCaDQf
z_wRl#kOEaw!q8wV1M-j+)Z}H1%K-2&hN0%djUk&#rY3qC5=o9oAa~WOw%EEfy+kw4
zz@O2Li;sb`bN8US|BNKf9!j|Dg&a`|{&KNzGFrV&-zWrlZ@jONJA11%z<PAXm(Wty
zWdzPhC(c%bt+swI<snyc99fj5_nXiN`?c`o;wU?VDb~gBuM^DgQ8<bSJ~&rVzA<1r
zlt~*dKE~CpOuAuA`7BpVbfqefcS16$0b&)C_hsga^uL_~C;i_E=H?}(iV`Uhk_}~3
z-A!nnbg)#}IQi{=0_AkPefSH<4hUG3t!<%7S7~9Q^}w8wQ`-JMHE4A3wqIq5Fk3l7
z!^!q32&Z}S-fYLa@4)HE%lVxWZmy*vfuvf`4nf5PM*qn~pID#A|2{JUs><yowlk94
zpN?N5V|_IIC#5{-Xpjq$J^uPfZoN!|Gktiyt77{Us0w>2N9C`CN^^2WyhYya*S^pD
zpiO!5g~b}NF+xChoW3sqE)*P55S}JVSIkY(TR=kW-{<^#!{$ByCz(n;2ET<_xMA?w
zd8x8vP~K1I;=<4OCpzcZ--+w*agaVF8-1R?Z&J{j({VG;PHCvL4|3(ah<vu~@fw;U
zVEfG4(DzbDzxxL|2KzWlTu>K{LfQ(7bE15!Yig@1zW0_rdx@7Szx5|T_;~Ll&O7`3
z19|Dc#d6A3s;ZzW)Oa|g>vmnYnC7(@Lv`jKx4g2ZcH+U{KP)~F*7>@6QiT7fGt;?j
zx0n7r^>e(3QVBFDerBz(BFaT17g@M#+?p0cd!BpmoOJ)~M6?=D`K>YV5zfL9RYI|(
zU4SNUF|nYc#6$$N;!)$8c5^!Oppc6rB(HjsaGfjEMhR<L{Xz^Wvb0&S0_QU%pW9Jl
zmw@#&&7hiPSkB2-;jG9zob1`Fb6z=({6rl*s{+$ux)Gsb1<!H?tCHjvQ9G*rj_-SI
z;8!3jg0-M-d!IAJ4m&RagV4s^CmsaKw#;OYGhNcXJ=GV#0~Zz`M!y(37CsYWa)vGP
z%(Cs9uCt_NzQPVizfwNcS<kPUs%L6LOT11C$Oj+Cg^O>#Uvp9Z6Q)<b|0?lX^VnEk
zI&v?jg`u_~c`I5$n%greQZ*u)Rk=Mn$2ggt-5@F4f$@|c{TWt%@QGNtBmrXQz`t^U
zx+eSE_V&vaXHT9wi6u6Kv~fm1=Nar%3wf;0SpMR!s=e;{*6i@Esb1TfSx@ZhRKvpp
zXtkaCS<&a5??r~^)kYDWWKymCOv{FR{9ibf<(L}c9j>E4iunG;K5K-Tc(&hXkYq-A
zc)eifvYd;Hd2A3tWM!F?z($!gxvtSMdP?TGobfE0<^07G1p!POvE}T|0iCl{na{3Z
zo-ol7b#L_<ivDcO5Q`T7u&|JS`IYH+rmFWzI<88h<?5u5&-X~RwaByj98hv`5Vpj9
zrra9E+-2nBpD#X79mJllJS53L@$$(08dC0Xo&A_x^Atn`8CrW!^nZ!<`f?RZLuC98
z3@PNkUU+Z$`zA>;36=}#g)0gL3K|}xvMm0&Fg@j|$#B|QPVb!$kA)ldQe2gWH0QJv
z{I`U?i*z{6T9Zuji7bBc9{FzwWNwyesax>vnBeZi3Qok&i8*g$_}j}qC{=#>H_74d
z5<Wq{c|z63?)5^ht(TkgV%4!>(A7=T`s}q4LO=tQG2&>!ae$E5_xnU|U9(AZuH7LH
zWd%O-m5SpFrT!!n2Fb?bw3@wwl2SRIb@_Z1hMk-ubzB$E_ZasZAZg!p|IIi_@Acv%
z#D!Rd$GE(+4FJqL16X+pNUe(P`$LNoK}-n|ZHfAx54LCpbL{p!<ARZiu1oBjS3PIG
zTg&zpx+|*Rr#y<CFe%c-DC&)gXrTIi*7hH7QyrpZY4X_`7aO&d4l1gjAh2?n57^!n
zd6rllE4vnXzaVG%5&}_!Huuec7oJb!jLTI`P?U<vIU3}rjlIVqv@Ms2%zvEs6FwZf
zHvQZ8|NaD}uUA%91pZo07I1oUWBV+7fqK|UTPew06dA~H_CW{D@Av;?o81Vver8hA
z-KJm7k%PZ9>8K}23$a6s&4a8Y(3pK@uFmt;*Rt$0Rvpjj&qDbW<F3%wl}FgNE9I%o
zV8I`&^b%m`Z8ZB%VtKwBtBTnoEPi_NO1NdG?C|AKZD5hqLb%|Te2M9&h<j@l(SI9!
zj{)CLEDp&(%<U&f?8liIe=a7i&>@*(LW?=7zy&A9sY+Q0Sxrk)+mhmXo)zRewY{u*
zyz|B$vT$Z)tjjbRFUK&GhIr6S{|NJumd^lVZ4WN;kySA>V`j#=;Qz<J7Xm4I0)HsI
zn+gqcMEJGpe5n~#;q0_su&eM8+l1UZUwBC+4J{VQ=0v@f&W7D82Treyo+bIyeul}d
zGct2$6qOgSdJvI`x_a9wPR6~O+TfY0d4=$HP+n;G98EUPI+!D~)euXhi;0CGO)K7h
ze-SWXcawCl%g~1HEaFxIdD*V?BO)*sn65zS=VFtzp3PfY&;6_KWO4Oyi%U0V>J)%`
z{lm{(a{BL#BIqsRkb^fb!=4efRrTZ>tQaI~tN?l98^IxUr>^4Zf#j*mGSO&GOaRF*
zJS`)2lUBQirk8;_-w4n(IM&xagQN@P?T=yEwyLCrF!vqr$Fu{v!<m&)QjwKF5HqPy
zZi$WY;bZ^8TM7Isi|WoZQ*|7OT8wkdtoM1p{T0zG<<PM4;wZ^D)VEe{qlgWchRB9G
z@zuEfVc$Ns&n+|sF~<!~r&})qWm>->_lCkO4PVQuoARB=!*w`}X!L{8kK)72h+zkP
zI696R*5+)4;!(Xdw9$XD#dJ$V-c$^csg5z#>~ciwayl&YPqC`7FxN)4{g(UtpF>2~
z(J~qv&`2fYAg=<F^+GJqG|tBqemV*Zq#+)yw4Fwr+953AV*D(poh||so<_cd<f^lg
zDJn6t{;-&5R4y5q!VCY&MXpVXSL8IkG^)Ui+Cq&uvR10q`9A9`8_Em`5VkOKH(_Af
z-z(1%IV3M`JC}hzBs=VqZr>(22pNj$cYV5!CUW;qooRwR78j>GkAJ7vAt=J@PGCCr
zRoW5EWAkgpKbKhxrs}EA5_4}Y<Nhu`T8qh^Q_hoX|LJrQ;UzLI0?f2n*^r!llvdN4
z#FwlgB_eXPf5`6{jTwf9<8CQjojF;BzyAtD)9XEQ<=bc*AL7}1UJu&QWyDQt;(V@q
zbuk*va}AE3gcL^{m(1GHLnCZMa--1VAX`k#6qPK(vui2ua7V;MIHx0-XuR*aC>JnY
z0AM3|4H(kKkjM+5-~-X(DcWdPy6*psHjKzv=xyagRd7t6<-S(dV1^VV=N`yCgSa}{
zdhaCwEi6?L;CT-BQ;pZcUkdcKT44oJJv}2ry2R`od8=DzJ0||OM(0&wB`OibG!gyU
zlpgh!N6*s+L!KV2P9l_r1`T(<SC>v>d&|WDCzMWW(rrxQKnIX3XkQmAJNxWCjNn8!
zlK3|67RZ*)1Dg^LS4QN?Hl_jWX|f7RZmCjGwX~r|GS15IuZv`h94>Npf?^c07<^J5
zhff_u6Vm3o^!#fq3IOdrPwvoiuU@E&WINE6^^-9a&VFUbX@f>WTgRjGwcH(N_&0;2
zG416*PnqGkTW+>@Cz>p`pRx46BluUr2R=bZ@O!uLCL7TfJ|7MpVB+mtbE&b1iF*%h
z4xoOYr4N?cJVcH}E@$)dhOCOMRE2N9DVd5KPN54r0S+kZjC9X<Uk(slFB?S|0J+QK
zv?OP@=){{sWhJacF6i)G*{Etp8}8UV&2{H{28oqN-SRV>6JsBDN@rzmwl3x6&2P4A
zY%!}-X5f(jZ^`yQpo!y>66OEntFY=wd<(d`@7)d(!u-o)=Ks6^@uUM+_haHYCW(Jn
zX=R1J8p<LRvd}T<$mi=8g!h+g8AZ68KyOp%4-Xp)S)~9svM|-BV~=Mfa$>G8_tr2}
zP8cfYxMaUQ+E3V%T%;gP&}@5aa!SCWqTs=`uCzoNoihtcCUui$+A0%=>Gx<N8LcMX
z$A5}Be1<xufz^g}wi*(vXk~#A$dch`>Rw;_reA5u=8jv%GBURc(D;P3j=Dbu<#XrK
zz*bvdkMTY$n?qJ^q~Bv(<n1(y5H=x#7q4p035!92j<*}Dl7?X5a5*&iTCVU5oI;vB
zz1?H)?aaZL>OV%}uvc#Ksy8M%4^mT86Rz<cs77YX%{xusy5M8*r7%x6{q7Cm3FruG
zO#5d;d`nxKYAO;b+0oj3l!B_RQXx~7qH~{+Vv&maT0@8s=K&4T^($bt+~!4{i-DjX
zpzT}Q24p4?ho`x94o2P|0;O}jHX={RTV749*Ezx&#LEnFyYw87r^d^Uwln@1Jp-hM
zXocNr1Gi}274eBwOJ6L0I8NL}+IYco5i4{;6*=00X-}LxeXQKzm9eR2AoPLpP|jfA
zlfPtLKW#<PvZJ|9e@bN$cMhq}cCu1;hx>v8piAv#oXoSo(tfw#p@jhqVUoD6Yy*h@
z^N^c4Ugu?x;d1<rg=)X{;q8L1i;KhJP&C&;+d^8r6G$S%)FbC}JfJote)Z31V`Ftm
zT#SQkn(l(b8i`(Ot~iN^*)`)?{RO-<fJoq5^01Qgu7{`MauxL8nd{7fszioXczsA5
zfnnTzIg#uAz)Krrg>4iepJk_SuYeZjN;aYe2i&G=gHR4CdA)j(Q=&CMpXwGyJCG7S
z37@mo&FP%32^Lf*lMj?sP@@Vo4-X3~k5rs|EI+GdL?<V!Hd0|+sy^UwqN98j7be?x
zfKn@MIeiz%v(<r_bW;PoCAWUUI^G7$$2jV|8L*XHL~4)5K|5BL32Us<gqb-WkU8~?
z{gw=Xym|&S%tGV-6OT#zEIH4G$j32VQ<~K3bDziN#Aw_HPfvPC3+#DjS{vY6N2v>c
zR%h0lldr~>^`wdC$VE+U>QLp)c4IOy%QZB6fJP!1CjyKzNjI9dHdQ|eCO+{pi3lwR
z&0&<jh``G1;dBV$m5TeYSGn11P2%Sm_LllGY@)slj<0h*{CKEyStx-BqTKPF&w%3X
zqKe$<47gm%!+j9dvzm0<b^mU{%2L7lDtnej8vS)~7~;uM4(#Ni_+zorBW@=-btM52
zrxb4KWIKH9gJg7{2SB=+cP>b;^}v)Q1)zGQRN!nqJ2nAE%+DVPs5^DObO;HS&ilaB
zb6Fe8$RK*<!LwE+mZj0r-Zjel$|Wc3`iES4?0{Vf1lF6J;WAXX;7D1XaKvf<ten?T
z=HrHFL@8TlTP<<B=eJN^l%>Gy-I?tfd-dPX5%$erxFfxZfX&8?=`deKppnC#G7VD)
zvCv%b8`<~ribHR{K}V0TF`83RDHPhg;C13=`!D~d9gjEc9&K@PQyi-T2*%+BbzI(;
z(IMXczr<~SlQy8@<8FaU-+GE`U+u<-Pzs7WhbifNQOQN_^q2afGI0?Qj;kai_F?S<
zMJO}bLk)4~9t$?JOIsM>uY(xcsv_%Y#JB1Q{d`YWU63(aUhA9;?F~a`1Abd_bn-kp
zK6af&_wqE}H;E%#r}#OxN&VMBm@}N&O=zxTLWQ;v<|T{{Tf7mf4~3KflglV_7M;m|
z-C>@1jiGJ<AAfps<}b@6?)b7MrEN-cooy=$ciscp^Ij-Ge79_HTXm*&a_nBceea6F
z`Fx)3q1L|qT18|en_?9X{PCECEjF48N5g-`+rgLsGIF&LWTyC&UubW?!;7Q_TH5fG
z8a>bsK`M`1Q4lOtJW-n0x-+?N39q^xEWJ+jL<i|y1UhzNt{MTKDfqU(F&epu<aFI?
z_)~^9@E38DjwKhW?s!7DL;Q;%<D%BPbDcA-d(pB8ukYiVBK|GR@?#{5OY=;5ax+BZ
z+;QUCXq174{|pmdMeY>FMW$3yUM^?EVW+LkI^BAPoAccY1hFbfxRsIo!!f`uRY9yk
zHtH;>mawc31r}4v>z9zJ0B`-cB$OT!VGpcypej&y>{vFBVhyxjw*PIAsIj8zS;kMk
z#UCs5>0}98aH_gs+R)9a9q72o7j!g_FpA*QS5vS0_IKy=Y=-UqO~LD|rmYHo0UTCX
zSmRePf!2@!q@^yG*?FHK`eou8^H%8dhF5jIaT?jRrXWZ1Vx%^1!djDY7V;(QlGTyy
zI?x&LSJ4!D`9C5an3@|FngqCH4M4L<=W#*PV68RM^0sHDUT$^WwCC~Aiqv9}jD6YW
z`K-@NGgON2bV;wGWgmg_SWotQ33%j1^#6LHEcz&Z*Jc+Mz2#R9@K4nRUJfSRJ;=>v
zeLN|^vtE^_p8x65ic5X5{Ttb{ATDqOMLFC{5f_bD6SmcQlIE6sD6i?_5O0VK+E7Q-
zvj`2Qs@@pq+DEw?C)XZVpBqXX#U;=CB61{;_=`$TJe3tcO!=nFn+WlciNx|h5p4b&
zUYpU_Cpsp^7Skvu5sAr5&%*?JXq`pwaB$qda1t?#P6|wj0^id(+H=DGCE*9SuNioS
z!@*G8Ew`RF@0q%ac->>7V8A>2B&(*NEncN<zuIt)&i>4w_DZ^X3*K=(guoXJD;em`
z<H{G;4GKPgF7(>BaG6qM>Vwkp*y%G}>(x8o+a*=m(EQ3J!}4F*D|!PwVg=|1z&xTA
zwbN_2T^}b<y1#i|<^>>ze!ZInno&i!nB^r<Z&FbtgzqZ=zHW6nrX?4MWc}k5bV0iN
z(<O{+#64H^;KLePC8NA{-gh|n-GMk-yTO;Lr0w}9S)Gj?!5isy9RIR#E@t1|(N>cD
z)=cQM=dT}K=dTiMa5=F#FPIB}d)BXFWELB8Oj?ShU5*pyqZrS{(e`$bNKASF@P(c|
zOFW?rE&L)m1q(IMmjq(^ox*{)1}&{@NdT115_Q}bc&7rj68?6g5>lMCTUf_M*l}F$
z<sUgXKYZLEC!J~@M^aJ)pVcfdaBW{PWjHxF-k1GMrGKis7^-aj>8Z)-d}|>a>3Sna
z(7<L3dh=tUqXo68i;HID!1#C<#*zD#X=Lt=8){Tt=q)Bc-4xG@11((|gyxDyK?)Vo
z1P*DIxx1dD@;D$@I+vV~8$`z9Qv|Jn&N?C!;Bh1gpaaTJ$#;Yxy~Bils@6OWFigQZ
zPN&dXsVM!bGW5B(_${xs88p(iB<QejWfs?<?$7bJkIYs%{FG>OpxZ%Jb<rY;^(Co_
z04+SittWnC`q~UtOVKq`LZ#Vh#2IkL;*_a=1Es7x=obJMeLVBogyY;|trpv==ShX8
zM~t&uweFy0Co!IL>9~76_fDbc;LTv^;=Hkj4RK&b+#+=K-YSdkqGz?<)3~e$#~n6v
z*pcS}-aEk)ui}vB^upG+ZS_SPQ+8F3Rurnr&q~Lxo-V%2m_}J`eLLm`d+&enb{)7(
zz=G155A7Q>e<-^&CV9a|frOglp8ztJKvQCQNReHlwh5?mkq*odU{5hGM|hFl+CsSA
ztq(;}j<Wj#39U>7_?Lj6bvK3E-I;q*JF>nq9duioa21wuevKG!-S0SU^5kY(-43Hz
zPywQ$yrAIbvoK2DxFVFBh^S~rPNDbDn~!9mMUbBeookoISCTi|Tb|x_EN~@3)8<(C
zGU#~h!_mvhG5#pM(un^a7obC)b*|q4@aX$q2k4HI&{?jWJKi#=xescoI)K`g_hs7$
zFx`{PL?yw}VqVYhgAS~?-jd3#G&)eZ6w3txy`C?QeG4>S?u|K$u0wSzYWV2A*7P{~
z;QYm+3ca*xC%O6BTD958_H=^UK0gEI98SxZIOr!@2O<mjgHP15=&>-FzOPfZIM30D
z(gf!^$(K+5zN7OmTNP~+67N4r<mf@T3WMe8XWtkt?;Eg^oPzGHM`NscpU0ntcB;Ly
zQ+ef1A9g?bWJh|GCkk{eAl%{O^pjkwH4X3f4G6VPduRR_wHD;030Cdx7eR|s6RC(r
z_gwT8;>a|dbYpm)R0r=uG3)e~@lATat5Qb7?`sG|38xB!vn4|tz@u>VfR4vd_WrNT
z?CFYO0@iX<Tm`=`i9Ro>Ob`S{(Wt3@>R@T5lGin+>ZEq`=mKUXyuW!&ti+`O;BRGk
z^wBr=zV~tGR}^zTH6ZkQHftQk_bLSo3~DL#_hEf8Vz%R7zH7Pr9Csg55;Dg<2@?fJ
zq`aT2aP5^KZB>L2rx<$Sri;-5Z(wi}_d2>4wYEHP)M4Mst!{J4&}|Jg8Xgd~?*pf7
zUq^ZnU#$50$m6wG+brF5+zQh%bZ>0umYdtZ-q@2$`bNjOWC5Dsr(T``$yvCRL3Km>
zC*Lzw(yH&BC(VMDY{=4zpclTQ+Hi(Q<a7f&uR39~g!Yj|5lf-v889_&wg<>}I#v}v
zIrns7Iw|Q{ZsZ6V*uGHdG0<cjs6_wiiF7t-{XF95Mb4!RH*H0?_x0bVg06knevi!6
z$YX2yG7G`<$#P9~U4{Ycd``80v%Wm&!gflz-oha6p_^Oto<z@(;}1eCb6}BE-oBvl
z?l@YZ9-DI@gLeICE!M1$<{>=Bb&`cnX}Qq0fxJQM_(&E%<VA58b%ufu0ouHV?ioy~
z62@R*mXB!9mYxBgX&msDNsj))W=&w3Y?}C@V5RI*XKMs_kSc{j>0B@<1lhpJoa@UA
z1mAf;U)HNni<5mRialNm+|h=iyV`73Hukg?xL9|=LZ?ycIo57Ngh>wreYs<P96RnT
z-z*Sspz~TY%-P9+HGe}U$p^WCdp|EDviPpqaB&toOl!=Cyf7uappGXn&2AeTao-V*
zXjz0$7=2b!NxL}1MCih4X`@r9VhcGYNmxqsMbpvh98lLE){sRiK4|yeWO5a)*FG@l
zWpzWDz83x{GY3jk>sJBes<hmwV`G{C68EsW|KsoE%Wrc>&NXmq3@q9hHLb*P`B|#v
zF`o9=X4%32fL_n!b)@$2Aa#L-NztIRkWCZXxPn$|lcWJXPsk%E*iKCjh}V&Og>j(T
ziNJgNO2{1abrH!0j-u-@RODN$_RHl>5Hx|Krq%kzXbxfOX|VU^TrLhpz$Gg$X$Tt{
z4C<b#x?mkGLp!45?A{Eo9(CQ1Ir0U4Tzu$0u3g1Xb;scfj<&;zN=F#%E@Wo09Y9P?
zTU=9H6DcfqSZhgj+mVKlOVOf5hq7A_Vkc~)b&U5Pf_KKSaC9%6ytL2E&*cP!`_k~<
zq7D?>kEBncwHQb`iOl;`DncY*SY}=}b8$TTWB&C6M7ab_#gX&_0RJ{Wu7B{R!>ChA
zbl}Y|q`v#jRVoPQmx-DkQ<}6d=R^bMQ^(>X2F~|+3&`#D??aJyPaD^3kyGzCz(u-&
zKaIjZ4<qUY#BaORv2iu#;9#1OZ7v=P#<J>OMj};~<-45j^st^2I0m*=K{JSYX`vxZ
zI`<LXINuKw3#W&nWd4X;v&DJQzpaYL1T;aq`fQ6cv+QU9pOI7>KWr(MGq70FcD_=i
z4i^slejDAxRTD|*DrP`keq`l+P#Vj<JRBNd>qYC~XsWV()*<d>d#|3O{0wEYWN9yK
z)2aFQ(c&=c1uPx$os`hzN>0=WVLO_QQvx;ye(_|872Z%TFo0c}nbe<RRX(fkOlTYu
zcbDD5U%KuboNN^ExC|Pw5Jvw3xnB=D?@I)zo5Xp5-JU$B^v6jEX)%Mi>+>G?`p8!-
zPvc)J<h=pI^&u3?B+SA249@2?XKvggVuyt4m7k>FKl({d{-MmPbWfc@=;C&ORbPZP
zh==3PhR{9W+?KspjY3~N(e4f=-N%a__8Us;){h$+;O(sP(ETpdFj*8sOMyT16$P3|
z#sx1pxq4x6l7ZymIRP>aTS%H1trcS(#~H5zC>J-?552`Jj&_#|U!kiXLTdi|6TqKu
z16pbpr^-G4r2h(}vR5t{9^Zx1D?3lg_2m>|!Bq~=;{h#)4%0U90|MOtB-!!UHI*k$
zYeyY!6^x^L6=+QWV|hH~1d@P0b5TD)sKA5##Ma<13E(iYx6?rs2D(ra<$!@9+C5)N
z39#Uz!e0{h1HsJ|?aI5da1yj8AU)|Q(F5m)9*nH??#WNgm{{!Q#_trzx+6Cd`~?X)
z{a3fQfM3hS&koqOBGsre8vf(w&{>#I!QP$+Lsk&qLkAd`1#S^KxX^%9%u;l%dE^By
z#I4H~G)g_kBgdoO_tHe$Oq9`m=Af)?h-0!OI3WCSL6b*G8oJN<1h2l}*;wS&+nV#7
zF>&>Fm(reBNt~_x)KH>l`fT)rI2@`phQ1es7`pagqvhPQC&Jh@j>Ek!7_L<p9GB3Q
z8Yj`oHP=ntclU<*Ef)esg6PK?4+v+5W6O3u-D9wrAgmlFoqf4E;U6B}mC#A7Q@qw0
zY}OvUZ$id3TPiyFs$FQ&)ytbkYYz;DFp;MlJ@YEIEG`Y5=jpQ#wQjdhJ8sw<l;6XR
ziMxFAgRXSpsh!I%iYShHaQ!xxPu@Kt2%fI{m16l`zxxNPe4F+cgVS!#-Y+8Z&H_WT
z7__lXx+Ft%OC!sM$(YQ1i^68oLRS%7B8Pi?t%6J$`P$j8!}Y&ISa!x<;OA$t$A5+R
zh#)T=EM^KLoJpk+t|fz1hmCX}jrqy>B-=vqC=4upSAu@72+8`+P6($@=wHhy^1e<*
zz#=l9ZOGX%Wr5Y8#t}ZReLRbo=I!29e#5fXWBA4k(<S%3*W1tutF*t@hg&vY<}6Br
z!T7KwOiY-_eZe(%Ja_XFY}+iG_*#P^%U86?2bR<&+7C`=d+vQqzGXi7TN)KAU+7l^
zzt;T2kBo^(P~c7XS5aHKh4!n4#v(PeE}|KJMPAuN49<{t&Xz8L@81ORwwF5}rfr1i
zI_e}~FXF`9IBe%%pi#s3?koIBKlJXbiS|-J*-&a7?e(si?>l}F<nKdx5Rw^3BK6xD
z)b5Pq|1RehlBx=84>5YosJ!hDD!JIaLx?Zkw#qh~5aPK?PD3Y#2I4yt)TQq==Axe%
z&pk1xBEH46U}@HZ>zdy#H<Btq?6@rFAZ)`dDXd9&YEHY8<$l+Rw6($_`4JDyc=2*@
zNu`utg4U7ZXCE(R%AF~en!D=o?bIb~{W9{l-(PU65D)l{&)W|^azImZmk)Lwl$V^q
zZE46;`DAOuU%X;qFpW5RU>kbIfpwqu#YM15pSBb^D)<|QOiHq8*RN#XM0o2uKXHL0
zqbdXm1}mCVI&hv+&pH~*wJi{YBZSN<rNyR*;ukuc?_91B70#e7^7YylGk0gdqpQSe
zl}W$v<97(vdziKwsOwnELl}z7o<TY>qPe$H)oh^mRa~Nk<ls$+4_y`kj+cO#ajmDj
z3|S<Zo-s*kWA`vE>~b+OqMPK?#hp7EA(;7NV=tnkUy%69N0m1r<EcV7aGvi<Y{zQi
zjg6}yb+seZu`-rLo>$y$PxXpt?vVnESl)maA8cJ*&eG-Y^mqh)qnICaN>EKi=()cv
zFx5l-@^$ni&bw8XoXMn?_?;&AG$m$cL-wlSmm0|}F55-D*&bQQ{_Y(dHU^{Jc7ec!
zP1iW0>xFz8n^E@y0+>lJt}H5|!i=Jfwi!q!wy0tj2y=RwG@D`lWrps~bl8+Q=i`rS
zsHVg6A27aFZ6&;?a#x9OKthMXu;H#F8TQxizeNUOnwFfxV=tZB6vb53yK+5!sjq-!
z=od=C#m3uCFdT&VJ(_xBMnyxc_JqA*llF47%0WMwf5B@g_I@08NoVLp_5RiXMQ(Qe
z?~_mkcQBOg62BgW<_U>a#=is9gt=a+NI2*AL&1s{g2LlQN%93PxWA9FB2_ZxIjy0(
zH7{N!>0QexA7qC#4^QY~ZF#tV>CoUaxE!s0NaR2}Hi^IVY&CtNj(jXt?*@@ZGSqnM
z&DRx}SwcS2IaX609{N4L_tcp9k2fkM#C8NnM3W3jfSXER?rbLznHVbanccyCC|L?z
z;YrVbqN!WHZh8p}S4Dpf`QYhl^XKH`fKk_(9JhI59^vwi*M8|PjY*Cft|?^GK3C8^
z_ncw<II^JG$#F%cT$A;AQmP7memV6*;MI6$>O0E(I1Nkr!#_e%8uD{l?isX&AD%0k
zc8y<O{BZZRSU=&mi}PGQvh1+{-4`E?#Mp;nhvQYvS+DJ(<tdGE7ME!fKQ6B>1kCQu
zt?7KrhjJZUO>h2incyu{F!eiS)%V_uVb9=}(~7GK(|t9YE&{lpKAQ9VPyma`LpQWg
zB^>=#J?m9g!Fo_^KLl#OmI8Iwy)?t|-sb-1(@c(Md&H8dR@ayykGSb3h{|{}=<~{N
z!N6M1yHfJ-BL(f=-f9^h%cx=O5*WI&;~XvFt@B%L;!>jv*ounyG9x-2jDweuk#F1|
zDHTAklAnqpVSf(cGpHzdZQ0F-R8~mMck+J+Qlp=d3^Q};S6TF1i4c7~ZAof{kvC4<
z#pexeZCd8gx~gtlumxo}3(Nycezm`i|D5<lR%dXKe1a%4`RCp%DRFJH?$QapOBru<
zN4i~#DQ+#4PdrT1D_-FnOms|=P>1_Cmj3*#efwxlP~GF}ZI^ofy$$T%0QD)*Q2&){
zwBbIA=M;vFS%>_=T_cybx%&53uOduD1THRIEO6&1JqY0}@80Alrd-$PcET+%Cm*9J
zm|^#M{ChuaRp}b^S0-O8Q&Yb7Dl{UxIqIGH=Bgtn*67dI-KC<VSfc}YZ7ggP{ytwG
zl#ek?feqOp_wgRN(ZYRZE@iE9>)P17n)-svM@W)_6{ktn`bGlqrio22d4FXTBmd*q
zix6Gd<gC_Ysk;Pc8^yW2R`Ts0Zix`{#TDk@Dsx3`QOxape1c5fhNKYXub*Jlc2&#+
z>lCVto1R#CS{J#{ujtR5l(`Tw7$aXYrP)==(dO?oU=dUZCcC$FOgCG{Y@0Q#?BR;~
zR6qX3C8sju^7WRsmi7~|vk!RwT#jS(aAqQV=wb*3_K8P_zU=W(S2EN7>NWZ4btO4H
zJ9>@3qvwBJgyssoFQb9d>J=IVvp+?~W+o3bepv`T-P_9{t*Fk?_|2El4ki&6x`skz
z*mk~E{tR9B2e~biB@ER9|Lr<JT3AzGr!a^@24zgCM~17zu^!%hao}P!R}DX0KS=I9
z7ZbZ={|jZT_^pUip8c(`DT*UnKE*ni^NdMH{+*Ql_B}K<U;vkT8lexZIgVz$bZvM#
z;i>32p+eY?eeA0KjQLniS?!I?IV)?{ryAIP>vNI}+Nf0|U+bQT+VJ3#)3n`_+B|$P
z@ZKEkeD!sopMtGUovF$n{9NmB7xru8N@_gQFO7xneD@@ho9QpYuLmzp{Kch{M1C)F
zM)1-+Ro%!UztubqrtGJ<t}p_d7fyy<<}85zz4W^XGYC-bhJ`7^!0(ZMn@c@`*j){e
z>&42={eAx2zFc7LyKOFI|5pB;8ZrC9$2Ys$1|qF{PjQUxqwTG*KX%amgckdH-4kf#
z6AUDfZ^}nHed$z{N9182A?4B$Jhlbai>IBW)1Qaekb7pA=qD)=`*)>ePmIUKRHoxw
zYv;UX2H`@FUHsl67yb)u;IcxnXpWg(ja%v!QWK3`Pm%@>1Kqh}iSMuu=4bB4`c(>Z
z!nE%QCtxvr>a-Lmv$rC!m*R*JY>kagHu~Uqs7u^s26i)t(!1Gra^}MQBxlu+6<It=
zzn#%=(>59mT@$E0V6yQR<9+w2-z#IFv?~X1e2>!I|D<OQ@=(D&$^O4>1SWZ}=9ZO3
zg24|-sflz1>c2XE*qaB`WXK$2y=~c`CvUbeTO;gACuDkCgoudkX4B4eyp<#f(~vjr
zDV<;JT1~YS?SFXIK)BLprw;$|bLu7jjKT?QEb2qER0#gNYxYor@lDb5H2QM5@?=`%
z2UKwmIbUUf`n1M9@<!-LD+PcU|0hampd+bm?F5MVV}GJ4eW;cR<bQJJXQrflw122r
z{;G#lX}}a3U{mE1{?YoW)ijNcSC8)gKBI~H#F@@35Y00U2T{d4A)A6{Hc$R}0X(9c
z&9q6~ninR|tnvP=3T`4??s}X-vR8Dlmf|ZBu+FIM86IlXA|pxF-vR4SzgNjxg7Kk6
z)M>q~<PUE$iR9eAk)KHj6QI*qlNRp7WuZji-U0dh$(J>Tk82D9TTUYd=7K@7ERWv&
z&|VzD$9}1G_0-%Z6s4$s!&={`sW*Y0(LMLIM-k!58vrh_(ZJ%oJLILK@J8(`pL2=|
zC^8P)!^-SrYFo&Y$9%VY1jZ592qBiotdsa@8HAeMCh+1S=Z_z4qipTL&dzb{9~!#)
zFK}A3U@$r!)7x)I+Hd@nQ@GPgaMNE4x23jY{nUSvJrU3qa9*b|y8n{l2O;L&Jry8U
zys{n8l&{11WDvD?8=VJX?nWs(-BI{y#7XW+Ggu9})Kk^)?dAgLHjNUEoMIRSE<@#u
zJ;mU$sRi0mkC(Up4p~Om3V3L=Q?ab6UXiuOrj2|sR<K!=Iq2}Q@QF^+tUp5DCt5+{
z*DVNEX{u2H>7xD1x4Vl*8;>!F^`lKh1lA7xYJs&Lb;0i50JlB#{7sldhP&q^`?tlZ
zvk$EV9L>iL=i?N)3hrTxTXP-*)O(k$Bfotk0b{Q*XaU^k%D^xduGUCjm|5AI0dnp2
zDK!sz3Ax;&%FX5}rW;yUZq!8K2AXI6Anhs5c`Cw1h_@Y3|1eD}cLnxvG|^F~VUw*U
zM&-b&;K_cW=dtIH#-i%gsJfJggmsTi5CTSrd+mEGNaJpQl&qG^4~lY#8G#8V{4r>=
zqZ0$mUDh0*ycs6Eu@{+6Yi#LiCv-l!QpQj?lW7s#n9Ax#v;y6|%n&-WH-fEuOZw)=
z0<E!c<ee0o4g#FM$ai+th-zFuU01ml*Kjv&%K6wQ&9A$@s1xhVX86c4?_huPCPk2#
za+O~rgffEU>&!M3?Ap6`rg>znkQ12H4lw60DsY^iKIIQqmquDD_vsUyiH_qOm;p4W
zBHBb*(W(Ax3leFr`h$iwgL6ldBSJYjK%~D}5EdQ3n1A>6SvoFA>OPbiE3iA7jyk2b
zy@&-_|6Vv(iu<v7h>yGu;_|w^krWIG&o#U2nXrHU=d!i5o!BKid^t)ON;Vn&(daMB
z@8=2k88WM0%3()Ib-wx)y5Cy;X$X6U1HU`1QoY|T=&nk<%iXcHC-zp}j&!D;vtwWg
z)dWEiOIVQHrl=X0qBcm@pX0n#v5ug(B@t$`8UXb?m6$OilwX`YJEVJuYF~}3BYYl6
zAA&3}+t_i5tM`7UNie@Pcj@5U!qlb0My89jR0-13P<MmpF}N&0DLipol5qcORM|xM
zx9xTSA-cL-_OY`~{clwes8{6N5d3i?^@LDIx-(w3q9gvX*p+QH#<_MGfFsjuUJ17H
z#eXFwHAyxCx5J7pT1zyac#(I_iu&jtdA^Lk)Ot!vZ8ubea%J-uhrC?c9feQ5x;`Gu
zKD1kU;$cB!lw0q%S2Qd;4eRxLHO;9wZPAPu5Zgh{ba6vDrqoKrlv=|%(eD!}-fJhP
z*AG>G`Q&t`fmi}vY3a0ULEAGe#%`GlO5bQN%w!ttdt@<0>{?8?(7qkcOnp~}OZwF)
zeWFn<`Oz;Su)V3DI4NnCTe~v`6aB<G?Rm4b@xb54`XmT1bq!npt20N7B4wjg?e`k-
z*u|Cr2%I=OJELtr)Wtw5p=!F^dm-<6dq8j18)WQU+xr{unR)-#GvI_*Sc8!`K>rB~
z2$GC8EMyx?^=BK)_{uis!v!kW?%FS(hV&KLMGkKyHq3|O8QuTIz1i{bt`4UrDU6xw
zPA?oAn=#+h5A(uLUl1;iaGOpx?i-LS^n-$M;|hbW^BsVR4o>kwR^$I+D<oX}XX(l@
z$*#aVu3>zE%3Vb_ww%~5M16l$`Pyl%htxHeepnGhHI@;HA`Aj}f&WrTa8l{l+{^3Z
z<20%6>w+}mUNjI0go29diK*%RPeDPLd5_><B%Pf0YD5!yJ=g6I!2C7J8a*{NKN4o8
zKP=22FYXhzzQM#aa3JyZJ<Rzv9psNCuNcLmGd1~Br>~#*;P(m>VHC|NExsUe+!pj=
zz2aC(4!DH2BN>38eU@2t%FS}Yq%MNfh5DbN1Gb?YMy5}~A+rw~CW!{gXFLF~hm%Vo
z3NAO73TnHA^{{%>y=>BqMv!7Pyx@2-t$+S$&~)lL=K+fRiyrh0vZ|1Va)L1u>YE82
zebZ)P2B-c1{=kpEu3WYTHXJ&SKa!7mM@t0gXlTAqPv22W6AQtNFxvU`Y%`a?o^@S$
zZf&&u09>Nq%_#R&2i&%LtvgL!N>pQa%|jj4M%ox31ZwF0s|BXy>c8B4QK6!)I%S_?
zKWaSFr+r@t^>Ho3UTBvwba_xid#^ejHHCBfoMVU4@kWfv4XVWvmG^Z9$BOaiZj=iM
z15o4Z#9nR1A^j=G-}^&Rh4tiR`4hxc!|56KG~pz5zqLT!5o{#JFDWw4U>m084#0QL
z4XoI%Mw5Sa;G5U#c;gKXV&m=`^-CKYxLDWj+H808XH`_(27Q_bqrF~N(|Q9kGVa!$
zpKi3ODvSCLBhGeh-EX~<z)Cy#&U`0l?j}>FqCBPj3&vOPAtB^UW&!SZ18UwSYziQZ
zs_xYN$QWvYA?knJSXZM16B_h9sMFrN=HJ|UiUaEKFY5)rP!hxGgKHn0M&w2;E?A5Q
zOf;h+9~y^|@7`U@!gIhr<(JPuRGRmzP4pbMm`umqJceb_O-l(|j~9+CwybSKH@bH8
zot+>qS3tzX#%eShNu$7U10Y=9CMb}bK5L>skz{ez0h_Ot&iy(Vgpjcj792eN4wtSG
zJrzabj?eK1f*t{;R)!}eP{uKDI(zRsgK3@ESmTbvdM<mTX0FD8=HFh*Nh)3kac)GL
zM#p<!B4iJTt${rMV=&FN4NyA;<-e6~;nVnf^QG1Ai9-6VL5=ub!i(^MEhkN0;zTM1
zCT*est%Ngp<1MSMrrfywq*?PpoP7BCD7@=1*}A)iW730M>eS-tOhMdQ$p#JipC44%
zdgJkzt-Tw=Ncu@&kl`e60xVSd9)WypLF4>&kd@J2pZvd&RB_e)d178%*g4-!qAc=G
z)O~McJt`$7q?O*A20r0LT~kx@kdN;J;`|uVns(Bj_WcA8%+mVJZg7Z?HBGzWf~$Xi
zG|U6i44(X9Zc)eROsYR$tJFjW^4bANamnk3mb01ubA|A0+SYmM(n;ShU%UC^?jGfR
z<IXDu&3nd-bBBC)44+mKM=VxGRtBtsiAw%$CXs%8S4SUyYUCe#XL)vQqw~_ygvn3u
ztZPrmlh&&Zw%I*0wO((|n^E~73U9V4*4Xy$KQm&4tq(3Ih8id%!1YHkO0a3UHQ%lB
zuW?Lj{Y!$SHykhR2QsH#^YjE$M7d-qd*o$ho4yf?2ZL!g->`f>r@G;zcjvT?z?;44
z7!{X;nSh!7<C#sDKVV0bft9)xX7Sz*jfBT`&^7xmF1z_681R&FkK=y8>@k*~PaE4;
zxKL`E)G7yz&B`CxI=k+Df<92gUwOmT6@`AShN;$9bIr1lvZho!QoJDkXxUo@ZBru5
zrG6;z8Z{m)28DC&JoD=0?ERW=4TtsweZHRe$0n-zPqOFnGbenS_L|a?`NbC0HgqaE
zAtZa%fs&FZ_tA~7VfltvIRE9Yo3o}O(lLrDsi`f!V9Mi9l>2)1V$D8cHdOdetM^H3
zJotx^5eoEh<R1=X>ru*Lfk#JfSdE{>c3J1<=Kg%V|Fxq-j`I@4MUK_b?ZLp1K;3(d
zkR9y4j~ifW`t_a^4*W_%BF_}PYcn>R65vydgk2r4l{H{5$QE>veKY!ny3>9Ia!$AO
ztWXe^Sr!aIzWvssaJceO-BFkuzLUgBcvNrlbE=H?39^oy=>)~(fAsa?A4~mdoE-i=
z+wS=LU_`cZ&E)c?{=ON2xwKDOmG=3te7GLG>%`XuOUi)xJ)W)kk?o!P$^h%Zsm5wa
zboA|UhknK3dIS>H(&US~xz)*qgXIN=T(&-V=RV&->H+?Wi$x>qc6-BZxYp%yAj^HV
zMre{Kdq7RmoYlkE1XF6sjO7Fj?(Pp|b!d_$b!e<Sb+1Q6Hu(bhCZ-Xp+$1t+4#r7A
z{Z<;NCWssewY#m&1B(2LVDL-L^K;F8Ena#GR}4@3rQ71JGI$xRwfk+K;eR}tQ>-WA
zB4qU_?`+@@$8*WnmZ)ut+2K+MeWSto*l`GZJi_(#vh`}Pr_(0qKA!;Z>Z`YiM{mw)
zM<Tk(Fa6E(T55RXp`oEaht<{9*)0Ne!IT=gX(uPAmbG`@U;@wgfq~n)oa7CE{JFm7
zOkVvt1+5J0?Co8A^OG<q+b@wqcVI!F@RO6ro%JwDV{3HD2Ik*zZ)-Zr1Sdqhl-dsw
zA6l??9RY@pDt(L-2gIFYOx&^TE)#u07|~LVtZ;pk>*_|)0vGc6bxj>EOGUFWiH+K8
zR@8GO!15IH7q^DBUJbxH%hza}t=sH9t$uVY5H$SRgaK)L8uV<;6ooh50p^QK9T`4%
zcXt7`?tewftm%WNF^%;$Gf$RQGcz+uPZeIje!aA+$z&5oFCKb+RC0a^OXOhMmxYUK
zF=8C+>eZ_U%{h))rp$K&3P;O>qRQ>6a4o9HA1+`RQs0>JAiyAyR!lNnBR9joVRWC#
zg@#uF(BMPYkx?Pxi~o<Sw+yH%?cRrvC?G8*(%ph|my~o!NOyNgw}^m%l$4Z!g3@{D
zM!H1FLrDu9K)QMFgERAc{x380Wxkxf@4ez$*SgldV8IeE*_LFoCKV<q0FO}jkR~M(
zYsQ~bLm9<H#OKa_QhRS%C<#u+Ns5$%;{0KcsS1n8&o3Ml4_U-2^i7P{VpQi9KJRsM
zUR=V2Max9rFgAs`S-P#9)k6NaRPC!HCRL|*dG?Gb@afRdkm2_cunCFn@Mvmk>I3Co
zZ|{AvtKX`3A)Y(4k+J?Ow0~}7j1|DXZ^IL@DEx70f}sA?P?FzK0^!=&Cy*cJfXn)T
z9j|3WZ|VLvRDK38f~+X_;aA;lObKaH)>4*RgcFHkpA7$PW#Y@%kZExXa2x~QIl79O
zQ#;zNMcQ*vY~Aa=tJs=W-1$deIH%cms|mYh_Nz-^M+^MeU{O>i^3SP?imFLlIb~68
zOZTNd)pKMgkQSX^2h9_>{3i2wdRs_H+Y@OadHMPZ9oE2_D>o~?o#<a46dl!%1Ymb|
zYQu`2QTW`GmzQ@n{?y+7luXS3wBh9JPi#<=1q@(*h)(2IX=!PMJ-7I1eQT@uOUn*3
zuv`uB$&g^g|CiruYHAuC#{{Tw@62CuM?+5!J+|jA1k}g|UF&MPx@fg9EC4K^P-w)7
z?tuFTaVN0qJ$+5kv3vPF$A~=hM%A*5%3&v`VDOUW9p0Z&_194xWghLEqL?`r2F4dw
zZVX7jVGra+o>2vmMo0VK<JvDT*@SQ@vQoe78C&PUHfcglN@5l{In9_j%vdvDTk08J
z?pi0<T3>lY@$5PY_fw5Wr^xhu%x7MIqFxGe=o`IC+vIZa8zB8vS`-}QggxZw*tYTU
zD7+_f#Fjh@AM)r;#dd(%RfaDKJJs0&O5FUzdKSa&0m+jRq5QefwzGCN*9?_G%cX4J
z&Oq&hWurX&^^t+s-YN?`aH7xKt_2dFM~kx_!=h4YHaJCX<7G<Avu%PFPPHSg<MHp_
z9K=N9`m3PbWV{Iv&)M?b;ETo2{`(IQyE9*Uxl=HT{r#t4OT0ktrl4=Rx?!C_3u$uq
zB)r8_D3kS^IAwtFTxg6&diisTQ3v;k$X!U?#ZIH^09$Qv1Rp!@Ub~<mWc+7%o45E%
z8$H3x+73=m$odL|$DDd?a8kjhUA%(Ig9wS(hhyyEL2s`Vl_-uaeNyjyGf{{B>*G?^
z_+{;5&--)jcjcr>-|_K=zMo*H<2RO77_h8EDP9S!A0yu&u^K?<s4Bp$;uT(m)sy$z
ze(P-N=NjJ4S5{?4J{yC$Wi_EYdj1Zx7%OS_Sa7m&9t@qH$38{UH#77NK+3kO8fo^B
zTr&SXC->c=Lu5GRQ^4zPn22E8;Zf{&%LU#?<>KL7LxnS$+@0)ip9&e%{WW6(d`afd
z+P>>2Eho+1f4&jjfl!{0hVOwDUi-X3Yu|{ByZja|j35$rb}V2_>BW(RwUw32R!MDc
zK>@0+uCDjlYD#=&X7ftm!qtw~AFw>^PWjqlmVm3-c$E9z;#07r*Bop<JN+IT_;T)|
zGHl;Iy;Z^V`t9ABOVCA@En^?dBHx693y)4Dus!Z3cDlZELF&+efO;It&knU3MQMFV
zT<-vvk4~$uU*3zx*;nEQz&G_sSq+{Nk`#1UCHcG5Y~$HxF|-%8kb3NSU3oRVc|OS@
z^<D|~mxDaq)-w3Wo8^;!>dHju&zTFQFt2QFoAgTOn<|Bn##+YV^<s<`-EF7p8>iE#
z!mCqC+qB86`t|UU#o_!`%(-FLeDl2^e{#sE(5dRF%w)%I7wkFClFkv%=_|VbBj3A+
zc%uqmKj!82_(gO?sQrVzWnn2hc7irm<W*J{1whnbEnGw&%=<e}4BE`2)F=D}LsHDh
zO0jHo0PTY?2D)xWUv66o7gPz{53NRgLnEg%7DZ-?CGT6~;Shk;q7#t=*Mhxouv3p>
z;=sQ#nZdTQ2(TFDS&e-j-wf7XNv`Y}d@3R5PSON;7<E}V1rqeyZtNu^S!)%>%ocPl
z%rtvf=R;F7H|6Qjy^EvY;md$6fdS%7J^=1h<5+ck+?UjcjM2J9a%>TpKpXW$c4=Md
zpDn4%ZzI3p)#>VDw8j}VdOFI8a|;O6t=*j*9Sug{W5`~^WHa{3tUFHZEDFzpR|elh
z!ab>&L%pP`1H$SYmKlmR1m*Wpn7Rp8^18ToN?WFAl|br~#Xc3TIfLWeBgfRZk`yXc
zzBZBZ`yc@?##UO|BXD7jb{ITfC}PRqlaZ=>kZPL$?(!B~%@H4b)@F91cMH?V@xNvg
zz#avyu!4(inCEAt?5_l9M9;EFtGogQ*ZxQvx0^d;R*1LvzYiO%UML@F^AJvJqYoVZ
z4>?T%<kV<CSvoq|+}zB1p4QS5X6)^?JKtQ0Iz2m!$!uv8)boy9|G0&g7Nb=f2OE24
z=b|Du025IX#0q_<QTU){eib!ChI&J>Q-fEteAhJylZJNE&YsN9!vJYW-@@@=<tga6
z5a8k#52F@V^%Rzij^97f#ODwtol{9L7(Lz%39KG2EMMK$%l%x&E7jrOLbS$hC_yC&
z`}3HHjFKrlaJ12K@{75`uMt2JGuXEoPojU?h)ilC=SA}N851iz9v;jfymGi0JYsQy
zUnq@%7rd=%auM&QZ)60nqphhSd}G@7tL~Z|>~NDbF5?SnoLU`7aXs5#C7knea>BMA
z$-<hWprBa8Z4CjH4rC8K`Y8WBQvRFJDr-L?tI=Ub+h^wx?gtB~@$W&G5IbFpv<VKH
zh4cp!pdUZR#c6PaEiu8b=kB1&dxv&eJ#gkn&bXF@u)*Cc7q;pdxBDrHQGgB@h)c;Y
zE`$wefDbtL0jI~$Q}UAlblX>z7@g8lGZkx#>8hS3#PDn6i}stuKe&&b7<M0$I1T9N
zR@Qh-7=`Ft7PVPoSpExqX}X6_BQ}G`5eq3leWE+P3LG39T%4_U7x3O&tUNinxDs$*
zQ`$IYtDWs2T<8GY&}l~u{%U%q)-XGrtzXU?Kgf-eKP7?)C45}Xd(2K}U6X-F#g+~i
zhy=@r!&YkI)jG7Z9A0lyzI8&Clqj0H0|(9S@;PJV`0ce0Jo7dCfUFOR9NE8Lopn-B
zb$roxaPK^8ceAO{7nU!0-;oVvGQhs@_VJ?Lo4D+{Z1VCSq<H2$&?{MZJwt9Ji=<Ka
zu)KDpR0%X+{;q`reIZxw>s*D!{QUf-WPPXhs3$G=A*b^vEnai?c0feNS5nq}QR*i`
zG3$RYROB0XGVk|fr}<=_aPFjW;fkHYcY_)tp{|ark|EHZr$m~?wf0fA^mU=lxSCh_
zoa>Vn7aR^zk{i_cWO6%uhoX-|%+Q2dp`!YT2yMdUo&r#kRjy4<@IN(d!8;P`dIukk
z{rOZF@Iz|6(y}B($xP^#j<bag@Tk!Q1IRf!EN4LjCBCZyTlEkk-fXp?orvvUDZ-gp
z>;8O+ars!c#>-cG;=F;a_<Vx-<+jWE8>fp7>qVi;GqYRsq{&T<XxN<u6(~UPVpoSh
zycaI!!~6UD>A{6cncq@c4nL2=Pny<6%ch;uY>J*gmyE%=hhNn`U3K92F5EY#`{K^$
zr3)&9KJC@wTAQ4qirPms1-<7&f|;Px&Ge8n2*^^P-|Qj{7VeLG3T{4ng6@_>{xvMH
z4*NWZB*H*D0JmiGXoK7IdW$~w<~ypiH}TtC0)d^fVC}5-Z%8h7n!mnd9EbJ4)NyxC
zJnT|hY~c}nBX0{d6$1vQNc;}haCR?>jG2zz>gzq?I&2(OyuWV+A|-brB09XI5Pb`{
zy0+bu<(7+`PV-pNH{dpa(EwRl*}WW`04AQI39xV!><W#pYXw<C-*P7}R;*#kPCqwB
z5|JEc^huwnfIG79bQ}0nzFrINWyb_5@zvgNtuXtmWDU$uKGR@bEfdA=9rruEZ{C?G
zuAuaGtF-ZelG>Buu#*?0gr~v=2<93?v08S2_CC_WHssAE=nrCSI6rw4_yX;<)Uw%~
zy0sVHU*y{jZh1W&+Hz4rS8*vZeldr}06JcB<kC-sSKCKx3ksGd!_^~nUR7aSe=D(X
zy@d*9U@3Xo(o}`{qeqV<R8?`DTCY42mdV7*+PSyK5qMmcZR$B;C%)z)u!nQAhtoSa
zxMKGsKmU?jTaxdwJg7HwWJ@6}U+ctC;_I=@0*|--)6L70J`ra5-_O+Ala_W366c_|
z*plf@Y!`%<L6NSRo{Y&Wh6I)i@$_hKv#iPRNmuyBsQg!J24&5pq4ey&kYtr#HA6=J
zglO|gndWSVAo#ql7-a=!5hA{uW5=uvLNK+b0|+mLryKUIoGmNY|8)o|DhnM{Oiif)
z9@_l{K94k5Wel_{t51R=jj#7ppcg*PMk41MdET9*^KD5CE31y%cGQ+AA7#&9$<OSJ
zUg~anKH=ac174OutTgzL&CZofX$;X8toO-9#7f^*ai;%eV$(yurfqm8ti1BnAiV8^
z|CB76z4L3aSUFdxN9kbYL3EE$NX303Edkz*ljNsC1D^LYiIg56zaSz|314M3&c+fc
zr>&U$eYwrku)a+=!I}vut`crj!n!^T!n*77zxCL^f{?B{V&Nk89$2#<e^$`74}yB`
ziKTp|uTT2s&6~LR_>hDIyjj3M*MZOiaNUp=14JS)Fi=ul3=qv-AGLUeXYcYF1A)d^
z;rBowUK6`t;HQ4Hy+r32IesjVb})(9Zim}De}`39e*prdOpl0TolqOFOFa3jX+5;Z
zprvF8iU98$vsGb*;G<X%$t<$BrvVj=_`?^hRQrkbsixQFYQG{WE}*aI7BR+=d|!E?
z+%IdH`{kC`-CWtf8O-C-Ze2E3YM>di#Vre`T(05S_z=a2`9DgwZ(SeGzcv`K&w|*3
z0P!!HW0#i94C>wJtyDMW{dQL|4d2Q!BM(OFqfMW6ZL95ekO6suN2*j2NCZ0WHtR*!
z?yuzaoH?asvGpzRaOs!)dTZ1H^5RhCm7L(0JTi<zqyx?5r+|>Wk|VE9FQj@t#T#NH
zDt6PCf@*TPEMqdG;~Q>4{%&Cg4L;$2KPJ1q!|;Rlsb*BAqdWRy+19;EgUD8+k(g=W
zmD%5aN>8hf=@)qKy$>+*`CNiDnbl@_#P*My;h~z1HQ3tQ--T#uYj?vJ)ZDAoI-8@`
zM)mq;)Y8otEM~I{dV39j&eZiPOn@|9g)R`D9D&DRHRds|+Kq_mZvZK-yKvuw`8;Y!
zdfId2nO%t>6o6%s-(V%5M|7H<$-@w54+-9AnM-2FAU*`-*kf?LLz~J;C^qwj!*RrP
zDUlG#gE%s~shMlN=PU7r^^I^|Y7mUi-Z?vCYfu8p&GypI7HP6G@y)5=?K<DvE-<%M
zs(h};^1<0e6OJW`THcGCHw{EuV|rTEc7UfaW4czQ6AVzdUj{s>b^;V=9w+>y-#-Go
zfW3p#{yc4&L9d!GEKe#)fqc%L3GW>V@%%Jl7wKR3P>;Pw?!jC{>Q^P?gC5W$-9cKT
ziEfqiYI6leQSD0QL7y9^I<r4iE607N<;wA_O*D*jS&$6JK0D*<mbaAN+S?#8&|$Z9
z3%Sa`P+V*PwCH7qJYsbu*jSy;2|DZa1fL0hcGZLxPMd({uweCzJGR|tTEFyCrG&FT
z4KeG=jpbYHOW@)<9-fdckOAfv^izsoJN`g!i{8JYXYI6$BvYDtn=8T)8sWs@V~gI+
zKa<0*EOXg%++ZLOXiX%IVx43(;#CR}uZ+EUcNX-o79dDQhGj2Jp~7@&7N-NRu7|7H
z#ct+pP>bVnA>7mQt*Co*HBt%@{K2hhsBeR=+?L9a(v&`FIK3_IUeC#$`&cxr;;C_L
zx^ff4wSvRFVG&E>UI_6^)5#z*6{#?lDzC0Q>;Nv&7U9GQb{F7`O9)%gJAT_SV{nMX
zdwrj2rD;iOafO&l@;h6lp$k|~aQ^fO(H3t8=?m{qo%117%C!K3ZjsWi#gN>&T#)zM
z+OB=}9V{Z9G0H=l96|q=Pp4&YVctP{B8E~`MIqA+cTvGKv2qf+zOiZGfB(LQ#Ww2U
z+Nc$g<c12xBbr=grCS!f_naZMfP~uE@$Mzi_0aX9!Sh+bB72atL$zz}cI3FbM&d;~
zkbQgStlZA~klLLU0zZ}%nAbvyA2bdy8tBdFpyXqDWJ<nrldJdfvE{Ns`TjDZFFmu!
zh!(<cE&GC+6d*`K?T{_~=OF|CZf^XBeM1zwH0*FgKX`D1?Dg1dQzdi_6rTd@*a0P=
zMzJ7zTBlJDQjvZH7ro|%C5Qr`CYgR{!qA^a`Zufr_8Q<MnEst#OUUBVXcrCH=xyGc
zG%G<kRL`X>5FJ=l){j~iE*0AQX@<=Hx$-&U#l*v?3c)Zpe(l<jz2m+cZdy{?^ZuYC
za%?3tCJtMecADE2y1}iY3+M-!l7XC}4u5`0D<h3PV!K1e-6l$ku=+#oBe|n;M|xaG
zJA@GN^_JRmNyCkrLi;UJ(=6LN40+poAJJ_5Jay4v;1Qh)U&*;5&hYA}j9{hgjfu#2
zv}n}i`KLrc7J~%3u=g2z%!+@$c*1fymX+9ri?bJ>NxH>-Qq1!w@sBACx&dQ^6**^0
z_F$jz!Jwbf3~*Fw{-;3f9!doZJC{@jBIDW!k!ZLnX$qJG!ug7aT&*b9NAbQVul?B*
ze?_FB@YHaps?c6lR}1<mJ=%#8gwgk4DXcxc!^v)loa(P7JjYKu94n!Jyct)1$M-%t
zc#A0@rh{D)F{hLJXF&?xc(>Adz~fGkF6-hbpElA-SfskrK$zzYNwBc!_aQN-%$kwb
zxy%fl@bcQx6XIj{QTU?2<$up<HXBWjFwJVi@WrO96S(}}3Y#cAB7){Qcr@bIBIEa}
zT5$I@@qdom{Jg+zd|P4x&mjRjkrCn2AUEa_{-;-$zqKAM)ZaTD{Olz+@yq)J+oqOK
z!e)C6FJ^!nJ?N(crSH~*Hsf*hl{&t8Ju%V=v9siAr4=DVbvP|TzgN$(Evmr&^=~Qq
zPo;Kyc2B;B8a)qpUmw16$7BIYZa_ejJL$4BD+p-=lp%D`J^4yXyW?0B-y(ok^G5CG
z#RGa|0P-Xd2;GGDb;^q?T*uR?QDLlQQgSsoqDCekl)V_b^N4t|T$Od@m5k|(+NoS<
z$0yT;>piECyIC<QO}t4R?&kLPVCvry00u&!+!%6Yl7sQ_TmPTd8Z=QbZ>1a3{I5w!
zLVbMI!yHwEz|V)(YkR<d>Di##e_X9VdTaBeD<b$-8V7_LUz6vlf1vg3?!58jLG3;}
zFetZ~e8KGBpq0bz;D1UE3qE=1IJkZo_0<)V__)5;c|=bJ$*Vi74Xdo}2>DIQWi${{
zC%*kFpD}xLE2P#VvU9*&`<<_*Zvk}X;P>lwN3l_@rzi@;paG;r$u{^2j?3EP@T9be
zg~{t|e}O=IROt_iQ8fynK)DgKS<ucxzuXl?l5`m4`w66|CkzE<*3aEEFYe3TCGtNG
z`-)lAhLs((^>gf_JsFPFUwW*f^EOg^3;U1};sYhFY{6ao%JAj5bi*ql$&}tcR9;{G
zdATV*hII9-I!@5GnjDA|hu@_kn4=lNTHj5QDza>xsW}~w=tvQUV`Ko$(sRbRT<5_@
zMejRsWI-=r9PIqvAbp*)?Vik<*oj|vjBZeyI9~e?H>ZCqo>5o&LQJ_*RPq;oJcSzF
z`}Ed{k@)K<&cy2(ny5?}r71i|+_m4Pj}~?yvTMnK8g~!Pzl{b}-Rt=5UNNy)s0u{6
z$7rQMA6|&8puy+VBq}Z(qv#GqxsBRC#C$+@Ip(uQsm!p2I<^EiBk@PV6aPvSnYwQ!
zin&_qErPuV@W0k)&S>%h1ZZC3nQPI}byf#f1!|s{D8=d|v%W8s-HAlhK^|;NC*Ov7
zfaBgNc^nf}BO9mz1TyG($D9?Xqu3$FBhynv1D90A0d8Me(Jm75#I5y!kSd>m-LR+p
zVLup<H)j0DFU){QMj0_a5dxA}kJ4&(sKZA2+7tjaA`95}qBlI3Q~++)`odO;$Pw*!
zLb)Y!^2lc$w+=ceU3c2~`Dtqb=D9vps!3Mg80hiZeObfAonP3bRyzmf5uILD#@t-e
z)TkOMqlSZKDX0i^E-XxJF;?kN^?mXG9X9|j-~e1;s~hg=jvEodr#7ewimq<#UJYgN
zQKa~)@4AP8XK|A(Dhdv)Lz&6Zv#DvM&bT~%T0P#EW&3DhJJ>Ee;xs^gJ>=l->I0v?
z%M4;#)ss6TQ|^gO$|w|HACB^Q7o96!>oy4qTf#hFXzvsrkMmv35Y~yA{|vkq{C_b@
z#kZTMpApFF6p4XGVKMdV8d98cX55joc9Nr%@M0{NY0=iGomaTkl${6R11BOJCS2s@
zXrRh>N*y^tvU*KCZHp}s=toq|?+{h!n~=?2wmVy=70{?tiS7Scg{rgu&w4Z^z)Ra6
z0xpVrvWM#h&u!A`%|KcrqYfc0f3esgcsJ!gsP~B9JQ|^f2h9pdaKOc}D`!Lm9+g#L
z@SW)?G@w;j`)$>G;P{=<f%lH%h>A^kF)?%oC=Z!0gJq=^`wsH%`xo7PbSQ((=sbne
z<L4!5AszG`Rot50*+%7;c?`O&PRr#;(Y^j3UHRVcM&8t@ws3Q!V&h(k9JROIlZ~;3
zK{wyS6>p?y98lOn<LQ429s67Fal~aY0Ro?bbki)mS0a-rVDJYP$$*gadX|%%x0Bdh
zoJf2saB+>aIh*1ZLtV~hmu%sBbcXHYBp|MaUGmOd+MJDwP;CAS$6~GX%^cn$n@>8e
zj~^RH_>25*N7#H;QdMC9@5ted6Qe!*`-YUAsM}}-4EQboUrjbMAqQ3Z6A8es;6cku
zX-rw~Nn55R6^m+O1>8_X9BQ(&<2HL@K1bhg1+~M0j7h(aFRGzLYt{X8L;45onHUdI
zV~y0lP*yn$e?Y$crBY#=wS2JL85iYLU_)|k-Mz_<VuNj;ZIJZ*KAR+cnYc*E05K3d
zBK`=>{~iGzi-`o(03<hy8tK3q!o9ORSmc8TgqC1ex0JBX-GCrM1i_OMkxNrH*mkOo
zsyX1jqNWjlrw2qZ)-`16Kl^!sVT^v;u>Hi~CzJODs)rKWu$;3m*P<Qh?28(ys1S<P
z<Gwe77*fMCQ2L7h<T1c7fSMRf0U5J*A}X%ngX!%dR9$~Lp=D7hIjcdnFGhzc0q|*)
z<Z7$ZAu<o<9&nN|4UvNh$lu-6;LnttJxFJYOtqQGClH&nGY(2YL0BlP#%Cg6jAt(!
z|JZJ79IA>EoNVid<TZj06n6j3k5u#^Licx+9LyhpbZ!39;n_`e6exY>-@!M9H=Q{A
zjXsw*QP~`1jPYrZF^p0$dYpG(?bX%kxbje_o%Z@5XIDGlybP0Y>|Rs&aO3TNFR&)=
zi|73i^RyyoYqEJsK{q6?sp~8jGMC@PB7gqoDyDpd^tH-)L5v*<SDk=UgP38kdpPVh
zd^&lY-oY#7vE~$oNk?*onIh=2f{)z`EWkf}mQG;)1$IEtWg)?t;14sFu$wa79LDXE
zr7X$C%&_#brL&8?Nrzfz<rAubUk2kXfIED2e@Z{_McGHBNqFy@2gMAG*G?+`)-V;{
z5O1#jO6?8Wbl~&{Q$Lm|JRe`a&8rB*Zy<)NmD9UDWCha<*qn;Yy)RHq5d|w(`5`vR
z#~WGPL$74XIuG_Kq0{szba7Jbi&eq9rxxGV6gj}mtvE@o__UYRYN>A!zzP5jmaa6>
zpBx}};MeK?cLZyQBjD!aLxJphix^<i&_Md%gLaMS1V6jxR4JdSU-^u}6vY=Sa12Y7
zt>@Obr=F;qol{({%;fKIlBHM;v(siSGte$AB!1}|9y=N_?oE0il`0E3pBCWfr6ywp
z<RS;x`e=*a@HGXv0m%}X+3zsaYkI;uBb0kfyKA6|1Jf^n=x|5qwSRAJE@7lZK&#a{
zj$d*QYQ)4@Yp0dZ=~~b`;7mw>jqvfAeZUfqA`#m4PNUR?T_hyC-{c7%0y}J>o_^F_
zLJU~7=j(&X@<2XWK?#6mLamQ{dR6l-w<$bvAuc&mWPNj;HT=b*tQ~++Ri@l7bMG8b
zQ2u`pf`^OyEs{&AcS14F`opBQX`{LDVJPn?wzfW+{u6Ns?)URVgz|3s&bToCpNpAz
zvfDb*6OYKAJZ6yDzwT)}BOE5KOYJgRC3wrQ)>ll`sG=k@xSTvrY&#;&gTmxh{wo-c
zZ`1Z$To8El+4Z;`MtG#M?C)CntM5L0@7QCbOJP-{P;pRNE3v|1swmCR0aXSR+5mko
z(FN@SH4M4uqCbbyjCK0xVH`RRFUw(A^Z2ac{U-aysp^r7R>mF<D-x)qm*r})ZT1kW
z(&9PNFTy&J-G3m%-{01w=Oqeu*nBNA2TEb+T`_<caX*KR;vnnOP=0ySJ0y8g?>=#o
z+C-mAO1S*~mA?<9TO%d7PvZ3=@`m#~_EpyN2#aeyS6crHjb9d1kCyJHwPkBZC|@;o
z!Wb##m7i4%G;dxhlT>Z|f#Fw;e;uH6nU+lZ>w*(^ZVJLc(Hr*O8N0Fq6yyGd#FZ7~
zd#Jhdu}sXtfxUK-#bDYhdEn-fKDUd;ufWv55x>w<#EpzqF%+~4bKnZ=W^+^vyBeqK
zMi<Z~y2Ua(WP_PC<;4#Qzfgh3*l~BSxFo=B%OM*MMG1Mk@+#uwD6B^9zZr_95JWn3
zs!a!T3#4y997$z4SFKHE*@if5Ly%;_K?p;o#7*e!0d^whj%1=<&RTeVc6FPZ^Ywhg
z>9Ed4fheenTv9cI?w58{+IlzPb@5Q3zX8c!tp`%Qe0t;g@w&$HBc5#{)n@k+cwzw@
zp6ErtPA%^)+q9d2ZZO<N|3A^d^>z^TR>y=(&%?VM>R&T%7w(^rT=^BBV-Q4Qgu+D!
z3ogNXc-N1r>3i){t3kTlBdaXpH=qi0VRK{khRb1-wKn6^F#ZW7hAD8mkCyGlql8K5
z1YQNbK>ukKp?q@*zRRw%$~Pyk{tw5~T=uGq+E2J|v{~>2JLjuDaJxjdrsLmEZXzUE
zw{l{j?EIiBH<e}g#-aIsDpy11{X6RFc3L1XylH7gr(q3^Qj{iTe29HviV&l$sI3UE
zFtq<^Y|NoF$=#GqPXrw!wK_iQg+OCY7wh)5TQSPj_wwUD-Fo|ZXGK8nj&q?Iu=?1K
zWHgfNig5m8p0~jXERe^6^dfXY558mNFyxzLIfjYMVfy3~SHkhAv|b8-zgG>$Yu5B>
zcFSJ%%9(@nh#|rU^9T!NZT<}ydomk*A2Bw1-hOP&yGJ9xzCK7A(Dc6J##Tds-*h3+
z{o&ppLo>yUs)BsR?*J}El+^@qL3l=ri;*UsqaRNvBPR3~h9Ut~3LeUp8~Zk1a&WW}
zvE!Do^75e_C}FImS*2Qk$eC$`5L$L<Pkz*bS0~h<7UjT;UdgFOUYJ{hNAga9<8!pk
z-5KX4|8rrc%0RZefK|ejl+BIb1-PXVgBoX6x4W?u=mOOx@ofQCgY#nbG|a@jJ2jbk
zRcmDIXDE)aWW~idBds2rzejnA?xO$ka{t@#1$D9@BAD3xP@`SOK!a&0s}cF;E<~0}
z70qG6+bD|I_QCwxPYZxt9N!5D5(fXtR7A-2TBI8A-<@m+AKUvpkaTIslfL@WK}&v&
z5tqQb=zN0iouR)h@YQmLvFu31F}oR^cml{kK65Mu1ca!=9QpqpjABwjgs)sIMMKgW
z;5XRXQ$`JVS1K9UHZ`jteVOo9HxoYSb3*)hsrOfcl@SzE5f9wd`_fIZp7vr0Jy!hA
z$}9Rf)+%&LdrgiG61hv68VSpp3HeI?L6y88;`XqIvB!O%<pt%&X@juum;IlfcPZ?4
zQiEfq&4o#q6@*O>!<axuc@>))LV%U@-5u-)sAnC5<fPLDJdM&SX6X52pIx>v$=A%#
zzp!$vz#A<7itvo@<rx=OpWAL49qqN`#JTO9vkjIMI@;eK^6u7Jh8;NHX(QshI|<+0
zr~9W>TW5lROn3=kLevYg@1R)D=7#YzDP+TIMdcN=tOK}fISEkN-6tv<h_J!vQg1~&
zn087P-$ow1f6$u9v*DHUG{~JAG<06kFJ3Hyfg(My)MjA=S**!@tETq)S_f1$s!mEX
z{^5)+MY-~eLRH?mASHo6bpr&A*uDJ61vkP*S3%*6;)`Mn__P(6@pa@mC;warOwK@V
zN_+Q}i&ImrFc3ZHVH^x{L^HBOLR$cA!uI=B=S(C$yk<k(N^HKy-w;e0W>{NIi+m~>
z6Ab;fhF^POH7X$N2zwZH+}Aetuz#|s?Fbc&e_qaIfRT7W7eC^kL`7)#6%-Zg?@JTp
zV&a1-{VD8v<h5yS6Mru73=C3;F}xg-B6_!R?EB%vfT`8zhGGwQc<<A!{QlMJ)hqvM
z*~?2xysjQkHJ#1sdXhJ+wce)egUXMPvI(?L!ce0lNAHUj{{oCMMSZ`4-C&+kPM9-H
zJJYur-QZ%2B@zUvf9IDT@h{(w>j1g|%y0TrrxrVgfU-epM7A~WP;&$ISVCA03lJ{S
zGQ_WkC$gohznMFLkqc8W_U0EHY=D67;$T>&6z_iRFtVaaNg{$0Qk_SK7#HGB#j`+H
zK8TPfw*@pZGBRlOX13gU)L-ogbDw+Ie>_a(^j`)CE&wK|#>bI^Uzj{_B($4AogT&g
zV9ZJiyAwopPHt%}xzLI_6CyeaXtOE9N_spf06o>uL7OkSM>yx4wpQ_>7BPar)pKPr
zw|YhTLF07PCrsB*1s7-c;ptIENm>*9aA<KmI^e<HoNhhmwAVp(bAVgOz};B$vq^bx
z<WgAQz5mtG`XkK5%E2M}i2-12l~tr#W>B~VS`ow6O56ZhUXt0M7D*xK5C}DNK1h$-
z3h%pp_Z&54bWqcMA2+6ba;{95%Lx@5=PBs#<qfNdH23Gf^03ffTph!mM^FO`ytlH}
z!9Zd?He(>0C^y4}Q>5878{`xdB(r~&HfFO1l!$`nd*PQ~oT=9O)FXOq@mhXFA2n~$
z1z@AVfdD~;cHF=>dYT5KOJ2G`O2d$|EA}?Z9K%XTH4NidT>&Od66Fbh7pE3_w!M~s
zu+u^y75=F~(o_Nw*ARy4VhcAb5jJkR3fV8T*}^S4m%D42O15QgUc!~$`~SMkUeHSb
zFl1K7se7x2a*}%si=Lb#@|O`_acK!6eRXUBCKI=W=OO>Q4)0?8!YBKfuIgFXJr|x*
zu=wF`GZLU}8#wB`pdEMbQaLkN5!L|YL5MnLjfutO%5=OI0w(Hi;S5vYZ7`&N|6FbE
z1@(x|c+I{N#?Nv4@4Ir7AK}x4AB>CUG|}SYyO9}a-tw`>o+4u5KG8te(o57^X==>b
z1AT#CwYbeZpY~Q&{7|DT$WJc<kc=iL#FD{z!_20{rZw?^{wL~tp~l<f=AhF{ePw}P
zKYeoU-3AEUZ@@dHrSF0MUs#rjha>l36<gb$_o1+xV9t1w6pYd#(%{9N_@y-@eB2T~
zF;cv>pu_gtB$>*}4uLBpyEGMH(hT(>!%T$o2`HSNs~t<deWHz_na_!P(~RqfbVAPQ
zknKP1g(XH@?g&eKUblT^efJn#rSNNRtfb_hQ)of>Lt;uwj|`Q<14K1z_(tRhS%xVL
zT}kCxYaRiAbwE=4S<U#Uo#)fKR0$K19(Cf_%(WX=vH%@OB>ZF1J4mqFuo!7Jg46w_
z$}g#P!u-zteaboJy?g@(6yX4FZx6mKc%q+UZSy;x6(R2A=GKu%m2)bdYaDVwq=b9>
zAE#3{79v#b9~^*C#UBB%9iOKJXjL6Ju!1&_$pq!qJFXwE4(v}PV6CWnAVNs3BLPoP
ze{6m{l`+nK1~j!^avp7eO1W&DSxg#Nut>PqKXp7KCG-tAhWG3TFR-ruxwixZ9Th#R
zWT<M3k&NRf&{g?A2Z$y@ga|%rUN8eTuHE|r_y81?_V+LmKA7>?2DM~U?+V;zLJk9@
z9EOrKLF|+xODYhA9r&e$O!so?`<YXa-2h_rO%w)HJ+|uk=>cDuhWRnvgShSHE1tsu
zDZ$8bA7qrv{hMdwrVu<4q$&jA^WW@%D`N8Wf37uQ>RuVoQLCKruOZx&94S1eg|0sp
zevo0@7=$COPH{t<2IA@j?Yr7{o!(9Og{*GEe(K5ShynxA5#jS5^e-ejtt~osJd<yG
zv2`!uWy?B}#Ix7OeJ5Sz0bJ$PVQwCq$6ND36W}2js{S9L%sYfh01^xg&~bkJ^txdd
z^}r!Y%g_%>SQuoZb%7@wwapfPa2<5KBO+E>)N*rkF)KWCVp#cjpwXcRy7HKg`V-m%
zNjzxz>jzX=_96FX_OTr0Tdx9xUgogvIikO>c`r&GN1%X&#!QzZp^b+((72+NY-wNd
z(0<ZpN3>OZMW7|`+l*EGp|2Q4poo9$u)&<5`?`DC8h5t)DMvyo8dWK0v!8T)BaW(=
zp<8~@DC|YQ&kz@Jf**#MmDs%PQQ8&XX!4Gn@r<2jLig51Ze)S#aCYlSW(~edj>xJY
zUnx?GAHxH1scb45gvzNK8_fVB=jO>n6SVNF!UBFAun*;zD>%1mp`DD^s8UcdjLC2$
zU3G#nX-Lo$LFnk9&-{H_ZQ@Us^Tzh*e$X2m6^=G)53Fz-?wh&Tv~3>GX$NXvh&yr3
zyqDTPb~uqy&c2*@g;#$dK-*gp&wk|Bjzh?oWskmk-~R6v-Am#3*dcVp!UB(jtn-?P
zRLYDS-CKF^vd-R(JzsUuWh`*&)JcLTdvNIzV{$;~QjHfr_j=*<Q&4``ThC|F$T=xV
zs^ZLU*Q4{5EpeJN9VbGAE<pP?K0HsTwNAG=Um-OU32=Ltp40!cgPD?>Kr1A@{hw=3
zAJK$hK+voj{dy8=U_JR#$E4VbS>gxet5$s_Fb+P#eJGY2UvaWL_26BJv960_YMGWG
zx$CM-e6QY@tMld0cgB@cno?f}6p1g`dhoCq2PuDjxuwv}s8?K|n#|LF*q6kmp?Ruj
z|Ml<s)Gos8?Yk0WU@=InS8tH%?i2|WMrsjTJ!of~U%a7IIWY%Sx6=9?z0A=IiF2qB
z-|q8UOl`VI|NK3&_2aUEZvLopk;Q&0yHADT$xUhd=80(gv9jP;0sjZ)#5amsh#&nl
zr%qV6{y|J|`>4M*FNBZf?;Tnd(nv(E8is~LR3?2DEl>Q)&t6t~W?vE=_d&ge?2N6B
z-0ER`y<cGh$#o@*p;BfH!Jk@CbXaeuRlpmoZ9Yn)gIcp5&eyn2R4|;GMW-!@uw1Q3
zmzU6KosT`t!z?WBiR?M-OQ`nyC|Dj~q&@!rDzC_yp2g+q;5~>L10=YPSf9=Xmml2j
zz5M3e$eU-YyMjzNVZhLK6O9+Bj<5#(pOvy&FK<?SjjMHhudh#=nB57%=f3m!LEymR
zlu)g31LICyV(zFi>#Bh+`*K{bel+Jn3S8TZqB;bM`Ru%3J8%D`(LrRF`MHICiKmR#
zqSLT}*s6K%WGj}SE_yw2lL-~L#*PyoA~73Hj8_NYK!paWUBBxF_KxAVx+_K%6Fuzz
zjM&x<TAHHo<$E<VWN*neMr;Dnv6&3ZiD;svOgf2r*jKeI{HQMg&Q<SRl-#Fc+V=2k
zX0vwota+ZXZ@`*J-hrF^yb1%w4@OFI!LNbN0;A9~1H!tzcJ$e3g2KNyPgckvzJ#&y
z6ZyiD5=)M9lQVL|{aXIsg%;I$j0=ks%6Na_19HNZeqeyf#U(H*>nnvc0!gljv^Ggg
zaJ{5=BaOJgV~=pgZF9ag=EE#rx56soav3u2SRDO1Xs4ZkUH$S+P4`A2UP5i6ZS;@B
zzDAT+Y#3j_HR@CldFiK`<F#iwN^FX3sr#Ir@g~Slz7dv>CI0U-Sztg+@W4%LIOK^h
z#FNXxW_Jty8S9!S8oDe6PNB0P5d3tE)2&zP-lJxRJVv>W50q&MkbvfREny>nMQ`@2
z$w*0ga6wdm9Wh>Vq|KP;cIsRdH(&eePg*}t<Es;$ic~S(1WzoK$=10HU60`t%R`bn
z&A)NLEC$4Z46E?Y{S&gd)@D-&g%$FcD*e`pM`<;zD=j*PjgEO4W0EM3AP-?4c|n@-
zl;rU@y=b<%eUA)iPmTswTYSQl8U}*d+;A5*@f%A>@|?)o+2gKNW2k+^$Nl>B=J3H3
z3^mFRM#Zt6FX*!emC4x$oKor<Od22zfWHV{U>V7eVRORCUjiyRJa?&?mxlbGF;fes
zPxMYhT^;mRW{$Y(m15B#QOD=MbkAb5)K*$(pBr0rh^ZKc%!(V)TI(|0g-ZJ$2ah|4
z`iPbEzZYwrX8K0$Bb-Dob$5ne<dIF|*Yd{<t@bA-93g(CN6z%N-aK~bmjC!Erz{dt
zTY^bRlBlm_;MMQV8E}VVy2_xF^>mt>o&CzhM0AO1qiu<jFH0yUL@~Iv@mc&X#d}eq
zK1{67ztQI^WrxqgG!59Py(p_1SW}5K1K%Ewm&p1sXP~a*i3aSy{mEnaAyas_wWq4(
z7_<7`%<w>lEV9!fLI1y>Ao?DAuuR`O*_B;kx}XakkCGP)R30b8AVB3xBND+3mfIFz
zZ!z#e0ZcB)<Ih_P7jZOR<jFS|iTD73tQZ;7pB!m%eKnv>PFTpOJ}>BAB%5KDJ+Ebx
zW#y8e&pK$fgxB5Mi9!DCX10eM5h~?KQjr$|{Y~c*o>!ojk92#d-UD+)umIzrm`G;b
z$5_!?lPv<|`#X2XdN&5WRvx8!u&z#wN0%6bI8hLd^BY)i^7fJCRN~2xynPB0hM1Yi
zC*(v#tS=Aj(w1JLI7EIM?7pt>aK8F-95iL~@~K!K?6<eo#~05!Izyo8Zxzh<8$Gf3
zP@x0Q_carIcN7+W$?Zjv5;JQqz5)rdO9=vT<%Y^F(m0L%I8(zv=mhuB=bArOZwzoy
zu<+YRwSW(LCC4*Z51dyp$AiO}u2f-Q4SkBjiLbLcNdk7bHW|kIVS@|%&@NI5b<Ka!
zXQzw=v$dyA^O+s}@-4daWa>ITX^gZVgpNs3_3_%RA6%L#@#KjMHTG1#S1|V%3+H^f
zzvR63{4xHliv3^Oeu!q!H3Za<&L)FzW4tRb(z_>0MGZ~ug&Pp=YOpu<vKPek;-X}<
zdQ1>LAj5knCoKD!p_Ql?3_Ef7&o{c0+>ErSm*c+ZzvXnN;!19EBu9g`mMWcZunb53
z-Y*_+o+Aebgsx}~4LsZlF+tw((bZb_AC&u~|9nsJ)&CyP1mbvr1e{L3rltlHCEo%y
ze0A4>EFI71LhMZVL@~6pY9>WjgO`uo4UQt{L28kl)U_@36abLNdt0iL5i}=c$v2J1
zk-~MdJL3Z@EgoS?p6I}l%-6m+AN?`Z#=2@hcJvt&ci@<{9&B?y_x&kEQtT4+%+z);
zaG|svIP;)8qf5AK-efbM0tVsUQpkT_E?;gDNlu`(+1^2D<p-L6W2^lBW!f$iugtKI
z{p!#0-jX>g>n-23CI=8#IOs`_S4F**=2c@AXz`7MlpI4OgPLSjEP+$MA0f0q!imw2
z^+JXfaesQ^$f@8C23(~N5Bofbr)T2g2@@B1mtqTD_oP2M3TZImJQKPLv(51rd?TKB
zd*^V)H{&eGQonD@c6;9bCh6*AEWIQA&%0^(<0sa|4N#}zhKcEN1%{-zOprF7GWm)A
zAgD(CF6Db6S%z)%e(sg)KX!sJ^smLQTfWoHd5KJE$I%3oOnjkAIxuJGXepyq<p^*q
z=E2U4D_A7r;j`4vI&l3?SVv5quX=kIeisFRd7PFPD66|OPn@51PMy~@V$0o?LVOtY
zKhHfJ=TOo%(Z!TdA%kxhewOu~VE6Bc@w$d%zSz+(S~aRtVp!oY84WGb&K4&yz~CK<
zZ)qC;B9wR$pLTBPoYK%N_YvN$qmnK1AVaKPs6?ke$Nj}moLCfAmmeB$z5gJ>D}?hI
zh;B_46a5tSiLK_~eT$smi%vb(6+XzUFU^Q4TFo$OohT`aXC5?<y904=)INI0;<kW$
z7Ml^r&>%wG=VMtf$zS@uPtmfCO5V2=wpn&Ev!NlAJ#C?x@@(IeFSkH7&_}zp@W+_>
z@r5TA4=R-3T1$D$RSJ>kgb4p`5)q&Z!7!QFmeaXz=`>HOIl|ia<WVpzu&S-vRuZh?
zHP@h-bc(C8jZu;%0Wmf;+g`gX<)jFI|GG+^BtmJb$DvniBe}*+yCP7?$PK{VJmC`A
zJiP0miiwR)fH<o-H+&je8B-qxJi`PK$o9mf9LY;#ZQoXuy#a|o6#e$fUkS3fHksL<
z6BAtbF)~D_55_cmg-KR-Md@N>tq`e}PusB3vU#=vi_1QFKtM?y?E!a)Pm8B6>&+Rv
zj~8Wvs8}Dt^*3AeX8W29#kXl6vQvp&xEv7CWc~{*(~CXD>8shS_11cU5bt7ZHAM;S
zZ#bvQ;trVr$<%xX@6bJV!n*(9kP-wWJq8O=<KsnjpQD(4FP`2q=l71b>2t%+CCz_O
zPlD8^N9zS#WXT_e81g_PP@@$@{Diq_Zr5<lXFKVID=mTbN*@M-sZDyT8XUvND}I?=
zutt3ro*+)Ra^LIx@;lKuN#kSX`zdAJc_QMmU%%c-z+M)pQBc6q9sbR{sCab|=~-D7
zII0H+^0V}`Fn*?>$?G44Q1C$T6qGmM^K^*R*YE;-MyWXCq(h(BE%XZDxriUUC5*+r
z&CgbD8a$RfoahBpl9*opU_k`_=v2XX)+N_wwd2F{CKqdDzunh~>*<`W;hJ>0;VQ@l
z^zV)k=qPk+p~0=1xyns1))LF$HonROJhWs*gZM~1yu5$9mGQuJ*5;1pKd7>e8Yd_O
zSP&*lOk3p{HcOOPqdz(D_(>iMGC0ydtu0}qJ~+_c##UXDV}=%ol40$QWL`JB{YM;T
zYoAW!Z>kqID@^89l75f9u#4d`+;Lr7DiCGlb(;{ie#_~r_|zdWSNJ>>ZT7<;`e#Ar
zAHEI%AN~H{P>T)XnPM<G+Q5R>>EKMw{5zDd2S2wxlar{e4}=73wpN`=;;Vczl~fpj
z`O1OWM!hptPbRk!)88w-U76?_gblVy83PKIWOy#Av;46N;sOsH2C(Ffi+EX7R%g?S
z{2E><x)~(ue|e>*pcJ$|+`f2Tt6!z9wB?E$B$pQ$^pTA=>>n%Mj&DPLNDTw_J5z(O
zUqPmS?3bay^J;3Qre@1>qBzc#9GFcU!DY9ROpBM=vBW|b`It(X`-RX%{kM8imyXTh
z&~{>Z$y<zIUnw^~tOc{tY2AclSI-eF|4yX0wbn%5Nw#Hh$(w9V`gHi<A3vU=4Z(Qq
zGI3yu!#f~sXt?F<9QTjWy785YRe6>G4^oo9gE)kiE#r&w+Z3bO(?uS=VxXRnsF?}!
zIZXr#7#oYPtrkvK>8^bezsn%gIj?t$8anQe%nZAcHB*a2(bPdffq9SBrPcz(l8R3C
ztpy<lnXgXlPrwc{0IJu(_rQo29e;u-Ude&E?xeI{1oLq4G-e`De2E}<lq%O6B|QXW
zlbhdKG?AXa8rr82Vu(>`@@$-bUobjkzf#<9)yBc*cV2w`vOtS&^Zj{IjqGGnd{gEV
zFAtPfi_^7BJj=$4tHf%bPZ|YH?SCEUt<epiCY`y!?KV?L1&FS$iCJ00RD+{Y<2BdA
zSLSFi@|a5H9_w0ebBhVhK2cHfN)3J5s-|e198i{(OO!@xUze#exj85P6c+mPxl}|7
zh}!$=gXu6h-Ot})=>~k6w;RQPE<C57t9*4})3QxYGD-;?rf=Rr^WnilqdS#AfLm7j
z*TU-GT350!7AvpW0MI~G6A$>8!|t&!fqA1hPX)q#N=k>6QmQQHfKdQ%nXWWqU`%|9
z0&1F9%adNrZj;p0YweN37GWzbHF`Vagk01Uwv1LP#$HpKp|BF6&h}$_#m}ueiu;~o
zGA|aA3qEaX)t_<RG~+90i_AUoR?-Z?aLN7`s!@Osg2q)gUX!3?`Fo0|S0CW!aR6DV
zm-ngpASS=|^-)#>Za!YZ=kUE;VrC~bdjs@q5OCuSG4Xz}SY>A+^Jb$P(YoSIbzg7J
zTfgi1fr-tXQWK<;{Ep{gO53|yUhfnaOH;1}xkwDmg+;-8-Wq}!0t4yk>(k4xuC6NX
zpN-giIO@I4h_Ua+gX&KV%vGx7e+o{-1W_Vt`NK56_KJA=inyobKI6`^fg0V3VbRKC
zb5FEE5i42$BGql^%y&`;<81l>*CO>oDe&T=--8sCf5l7ai{z^&cdO<!(HGgx#Kx#B
zTIIjrH+yxV1VM!Kh;-Mdzzo0@X;6##x&tFaeRUe^Eg?bu34k^x%ihcXf@6SWBI9{Q
zcD#Z>IwSAoJLkJ5yEY$(%{S`}KWwRcJ^f9|zT~>)`{rc(s<KuVLqPK|6QlILXG?&%
z-T8|0@3g{!-gjra<bR&kICFU8w0K|xn88fnl)5N}4*}mFgieFFJ4kDH#%myu!Cyj~
zx@WDnS}QFKUxh_n3obRooD7)P-*OQb(sH62i_**y9W^)1#vSf@$XeQF=pQ&voxF7R
z^7{y%ld=3^6z<7>j1BFLVp(3usPUhPW&B&J$r0eywPC6oVnEtN3^hPqESb_oNtP_i
zC*WE@@C<CqT5YLNU<lo!U0V~6)erbxj#d3xXe_0cq-2Q3hZF-Rb90ROiH`bBX~(Hj
zb`!1L6)ee?z8_0DXyzzK?j=$R^ZQ%O_NTqTq)ku_@iUhPI7iHGC)Cq(1q?eTbl?TT
zoOGBq-ggI^4hN1q9eoYpJLmba&PQw*r@GIl4X{WHjj$@~*cez-0wUMk2hpqFiK61g
z@p4`ugnmvXB0yNp10p(?kgBN&evt9EAczC&TGE4w75Bzs4+Q0!?{8TH2)b)PUm%oz
zr?bgB9|j6r$DbArW5#9tzRJvfFrD9Tqc__%GDDzVL`mP^C%e&wZF31)yzn0EXF@$S
z>i<->L|pO_>6e$6pM)7;-`SieuPgdz3{h8h1*x!NKzXS-iKMf_iJ$s|w>C&~UNwDH
zbe2YD`*pxzKQN1Wy<zRr?9|rO`hpPvcZy~6R2s#B4!0&_#qsgn<Xn#W#aLSbab7K9
zmoxb^IUu0)EAx#*gn38|Y9~3F72FTJ)!PFYARx6ux`yhgLZa%vmX@k)?AFqno?T#P
zt4zG3cXZt9)7_2T)PqC`S|J^HUXdTIUhUU4Ws@bL(BONqC}`Z4E9xxEacZ5H-v((z
zwSy|>?5OJQ6*=iJTus{z*XUdXTHBjkV4Z#I$NAi~>gDy?Z=7TYt=cj3De}&u&Cm1N
z95dqOz1;tG6)0L%LXGyZPWokL3;=_|Cj-tRG%`)o@Hp@!5Gzl%<C4n)A%e4CreDny
zrrEd*>L<(M{NP+^nki2^o9rkn&KEt4O23<2*eiUx(KoliM4QzS;^F$lc<y)Ck-x|F
ze1%;72V+4RLCFwP_VIFfE`A+wlrM-cA6!Qb4#L*XE`cE3*<`Ba&RHW)|H3rW?%~T`
zp>h7LtF->-g6Wgb4KYmAyOpRWE=5J(&U(lltKD>w1G;0=(ruwhl7T-Am_^T^MxJ?6
zEn8=MAP8I8a~3NJO)>S9FQLd#jJdedKDKDs?t<7T!PI<$*5|miYa*H40yV2E{r`)Z
zS-o=9PQJdrYpXH#v{~CZYZcP)-@oJFzmlhSIasBJ^8xTGPOP%boE_S-K-XPBZ(E8;
zlMp%UL0Oq|*SV%_V1O?hJTD#<*6w?6&0!KDKS;J;>;y9%7kIE;#r*8NwnWyJ9T;oX
z#O8%M+AJxCV$x=pGy2l`wFy!!pP$vF28#>AL=cR0*N`+#NYp25;Re+g<5^kQJ||CY
zy)8V2xn-@6_Q7){AGz_BCF#}}bX$tDf{zqXvO}i6(xbe8Q=qlaSbuMFh2?N(+-+i&
z%OoOAePQ$1P<tdB9s0sr&bW-XA3MG&CVU;`;->%?flbspAT2d1wL<jym+$TLwef)x
z3H(Wj#J9;jujoWrXQojtR2}5fO2^Eq1yj?kS+=e2e5v^+qv8B<uIV&P9th;Xb#8|;
z$t$R;DLhs&58v8ps1mat`0V;Cnh7!)r8DjG){Ek6#?6TeK$pe}<>hJ)w|bu$X&%8h
zt6v%>5Vk&X#=J0vlZ#N;6b<Qd<^@D&OQ!vkR02U#F$D{^hf4OnGPBTq)&tLCloQs6
zoWcPsMXKF5-Ly0KvNu2XHBQtWNb0WrX$0f$uZKQ3WQhp3=~q<WC>aM;K0CfyK1SEP
zXz1#>&(H0-`kaatM@y8G&_7&D7t0f^0bZuM2D^PHnAJ>Xp+OoBnXdmuz(^^OPL?sT
zS+7Q2W5lYA=S#2ly~yKKj)r`L@+%#RD?JAg*=0c2m@V-`hs0gT1KNqI{h+zR-q`d{
zJ9}N3V`TM{Y$+Grt6aphb~Iu;lq}yz!b8!ZFQ1*;m3(h-NT~gDSe2Eyx&O*|yY6$H
zNNG>GC`dEBzb*T*h8!MdJq6_n!d>nyY4CO#oK`I)oD8az2#(RnlVlF5RC29kcnRq?
z`jp&S=D{NaNR+m&E^%n^CsU9W2IYOkg=qZDY?f3?;|~hm!saU_^QmH<O3lu?4{nBs
zu6{4byY{I14iy29aSR`xXgemH_R-5s#+@|(vYQP%ug#kern#2*$d-7Iy>8@RGW!|e
zr`)gGt)_qU!E8BYt(228*tS-HtxgvgzjsXw#BCc>H!>Qgq7p1!Zfqc|Uys;s@3S6q
zVP{hZVT@~)81vE6W{7rCt8?}8jCk|+jkjjt_dRJua>G@T*DC^5T`$Y5k3b-G&jf5K
z*K-A*kpBswAa10(^OYsu%<l9F6RgJ2+Zh`)dj23udn^V)fl$R?c3!=mb=UEHcJe7;
zFxfxMNsr#z1N-iqI=@eyn?bweVBF3;^E>H){5(U)i7;#>yC!p0z*qmNKkJK<n!;Ui
z5}R~eWT%%%{3{kL--ecu|I!CofNshF5H9To7RTzfyqPjlGS{RHXhFaPlR`2|a&n#~
zXliJ5noyNGY{k)>P{iL@^neH0+^*<?CnKR?qW!T*8HYC(H+{K;_h=K(8GH+{lr#&k
zS<Y7t^n3cXa_;oHZ<@#LIRf758&32S!_6a(oc}K>+@nRjx4r%QeWKm*cAg>^tu&~S
z_nlBA$U29J$RHK?T~(d<Y@WWLYOUo;vx2m@nDu}yaChZ2ZjtP0a_QeRzs+4gCO>;^
zbh4(c@u>%jj}`=Uws+am<g3ol2ho)qKI)&?ukHXp&4icPw%UYr@*kXyy2oxdOt8YT
zN<L}#sU@o&K>xm}_K2oz-T}WaG9-T(cQoS)M*&r0@c&Wu-C<2A&DSUj(yyo>NKt8m
z6a^8GswllEy(3+ugpQPeh>A+@9Yi`IbP{?Ikls51A{|1LE(zt^p!dDMFaOEolg;kV
z%${>*c2<}Dim9?EYtOU<jA~S$;#qQDp~C7wHNU=v5}kk4P4tG?<uRkkn1asIomn3S
z6b=y35ex0!-((zfcO3#f{LYYvBghjF5WFNQF)^Ml4C%zJyvXI_cg$AO#uIKMb<W5|
z{#SB2O@vy^llHC21*0(vn;~VNzWr*Z+ZI1Af`M{{lyBSbH87jkFBSM!3)-{<9o%ob
z+VRJg0CfUSh`%5E#CIxW_vNTU9z&`+$=MR_)eSNmc@ZG9(HG{xBdxWGwjUOxx2^vs
zhh0*Z@p9vr`Mf*05&3Ar!wM0cA<4_7+Exs}x2U>wdZW1u``_r91ZW`vfzJ7S$b#f}
zS{qb010g@cazDZu$TuKw!l_`^7k2fL%#R2poTYI;c0uv93TWhMyAS*8rpD>Vd|Xxh
zv@$YVkA*#N6F%an&QF1N>WR!9<D;VBpLEvNSrP@G&H|#+6-P_p=>aNuPe+LfTT3o|
zyIr}d!<Nk-`B-{jnT|2>;o<W0BB)}>?gCt9rQnt&`&fUtiTD7D@s$_E(KHXTit`7D
zbVArebKb-)pO0}*=qAC-QFtaZsdNu7OdK6~6P*Kp_;kevzShI^%*W;F{!4VmahHb&
zX{}jwl4~V7eT0H>Ge#N(rzd{5Zd003I7(;nf&9JziFbXe@_zoh!RYYbVGD^!4A$@G
zZhIpC-DphLnyQh_`tJ+&pZ;%bF=oZjk%q2*W=Ln&tv6R57gsJqI#r?8gLfi%tD9%4
zaq<hac#cABovu|>>i4qt_69xJ=2MVp4SA<#QDy%m#LDY5ykXyVq@Kb{eA~{U*dpuC
zi<r$ffEz1Ap|z~J2t*7pVpDe02FU@wO<CFb`aVHx=F;1W8-N>EetrHU?1J<*U_{^;
z-+MB2K-Dpj0kIe0k{4+1V%>Uk%E@@0qz94=)E%~!!<-8nh&4?C$x|8C5Svap&e;~C
zGtV)<htK_K|Cy3-y~XossPcB|MqF7aXK$F7G*GV;%^9eXaw;q-!>Jo(Sg2}I?Hx_5
zR&xI~dC!zNwINhLG9@jrlv;oh7e+g>;b-QD*a6+uye09ls>;JD`GJuw-lnAt{utd?
zTfp=s?ITW64=>WBiRr&ccmgrJwe-b_E_R+aLVFB}{ml#G_(s}BrUvW}RwC>h+5UEE
zWxC*H$xiLFYb3BWw1|U7%8>v{My9+p?umy(nRroh`!0Ar5q|~&?GQLl!&t%PXFe0$
zr~OwVgya_=@;%$w0|~0CC+x$(afWW!4I8f^u&F&Sz3k=i2fph#D<rZzv<fx6>1Bmr
zloz6nW?Op$7(zjN&T~Yf#N6>y?VpwzQNK*jp3IvK!5{t&=S{r6Z*M?i4nT@)D78Xe
zOK#&vOlNJD8awFK7`7{B<JxKjGk(@hkg~3T&Jmc1liq$v2Th-Q`VyB=^MprHc~YaP
z_kfwww$~DC{`oJS5DCNkrkoQ(h<nq|Y}?1ffK)Z2LfLuVNShO%xY3=QH8J@GA3hzo
z*?Xy9B;FKVXJl2z7CUdpKOr(!m`&_SXvfT5Ah&$K_8(0@FQ1+~-F1BW9(-=n{aRuA
z!}#%LW!bPF+<`m1??Hu>V~J$7R}Y#5In&xY1$MsZ$4%cw>fys^L7n3=!Lbxjs(^Z3
z#sk5&>zi77L+8wku!!4inuVQr6~?ySAAfSAd_X+W)0<*<UZ{e|p2+6se-NHT>R-_V
z9|;Cu;$#=Z$M|C^7`NFs=IKQWxwV(ET=AwowA@9`lX}NHJ}|FPVw5`LilTlnFISxI
z0?&N`pO4<E=uPq%rFvwJ0jJ9B$i%e38zqw)BxS=OEWbAP2l5-B*ZA!5r$qU;K-K_{
zYQ_oO1BB-OMbYcwATjJg#S}@zAwT)(EXV<lz`1bLa9*qzK3vaGhCM0HkyHxWJ?xg@
z<4Za$Yj5uQeb~D}x%Z~ge1%wnS`@my1I)Qlo=@H9j*S+Mo}Pj|TR{HrEU7`AMnyaU
zJ|jj!K@pKLF`-992x5_NAmf)duit<oF`r>Q{s?D}_$LtETk0u|Uja~E&5lH(AJN;o
z2k-JN(HZKBRSQBs$8YUyGByH1Hd6nqruFAw`7;AaO|5m(!fhR0rjV^VZx^4tP_z7p
z%7fe&s1ISp$Mv@tiknhujG1B&N-c9CUz*n~GM&&RPkKs}h$zSoyi-{{R^`AWZt0^@
z^hBKP>p&=)JI+3D=c{HA{%g*&jxVlZ>f!1hMD$0wMOM_-_y1$)Qc2^NRi{}v=EeKC
zlj)PoQk|_oPa-utb6Fh&FZ%STM$`yKoH(ZUyIQb9Xx~AS$hFWhAJuk$9L>IGQg8Om
zW4@H4Qwncjyo4k|7;+fq+B5Nqo!R3C5P|@oZZErn<h#qHI9bqU+E?_e7snZaJT2>A
z4!(x}J`?od!6Sc?o`b8gcZVIRJq;-QIUdXh5ZWy*<tGi-5w*g7_1VpYCC?7!Eg-Q0
zL;tZ>#IdQJJz9~><>+P755ly?L;sI0jvJ9Rh7V3)xQs_Ejk(j3VdR4xvT)z(+i;y0
z&dSn>(U%$*c?UVprcQmP8c79>nW#?trm9TtD~DH1X@T+!!^ozuCR<6TBN&wkWS|Vl
zE){mQk5=tAt8SinpT%@g<-wlQpv<%Mffzqc)(iNEZfD2i59Zp%)=2s62Q?CyBldRW
zzJNa2)v7eTo+<+(iojKIhesZ`ZcL4TADF{gEr9$;P4ebEZ~??V6%}R_D(;7n<jj@(
zV&-)#@4P$8fEuLc|BvavJBv$V#r~IpQ?~)sgGs&ZsIUJOk9zVs90Q;ImJpWR-dEO`
z<`q7@tO?b>O1jd0$VMW`+l!s!azJ+5T;%<W5lr#g`tEKJ)J9TLG8KOgEq*g4?opVe
zR7$CEMO^EEu9Aw_$WNMv*U?f()v#IqP#HVeTaRq)7}EdJ5xpo(B8m9eIEOj-NN7j9
zkRQKy0;shvr&1dE2EMN8kAQzR$eDnD@$CCSa5(<<Y?@Cm<1u8wr|04aC-irEq|W>%
zvCZBor5@Dl-TZpCnSqC5S5Pvsr%E0RwLue(u%-Pzbh{K9a2};;{ftYoJ8|!X2=Hf+
ztHz^*`;ljq^};Ru$#72^0pt_u>?=rVbyj;mE_z^e9hQAXIfo+{<^%oXpE^ayE%WPp
zN{KZukG+O=+heVktj%P!)EH2u$HasvTFb(ey*im%pJzvYQu^$FmF~aat&ES^jWizh
zViK;i`xY%{?x#SF)H(9D*+Wuj9WYWMfC2ud4<O!yO>an{h!wda7JsJ%<~7vbv)U(_
zT*m0jcPOR($+3rBKRc9r8r_21aO3wqLQ}%NpEM@}aoj*m%dz@);Nzx<pSrO6aT`}(
zjg8J1YuU;&YtVA>xM)5XX+Rd_)fn{0LUZaQg^drMIm`W&DfCUmEOO3UI#A=Sl7RY;
zv9Q{L`T)R2PbJ}M%_@`aay@KpX4jCKtoFq&L0B#KwPMd4@v#m1mD0qZ0v;BR>M)8o
zDRonHNfL+9mTMgjlNrKwhJ@Yp#f{}2d~HU8tH%@{{YeZ)>cJ@nY@Zr$`=D3mneAU}
zgwRE~pT0N@MJh&Ko$Qe7$pkym35>{^1gDicX16CNJH$*YQ{`ORugSKhJWVaIgr=&R
zaOv3Tq4dDYt(0Vl)LErxsTw63Wxb0USJjskrsrm{!kXiS61=+VC=iYpd0)SNef<LX
z1H0g<TzyR{6P{;UN4(Rol<8RjQBj8tRDt+^WV326#qJnt)vu5vvL6l5KD=T0g5k77
z-*oY)WCYW>&f|x$*&!`|#N&~5)dz9<@+IzDlA!a1vCBn!t=A$P=katCpN*=BzlYzd
zhKMDh{SI7V`nK_MLXG;D@SP4oXP>jFe@BuOKcMi?Vg@+P+`UMAD!i_2czNLiFtY1n
z<7gN*%})wt#}+N`8q^C4ql|<D_8^&CK(hT?^Fa;Z=WJHF>zZ`<wo_d<C5R%;r6V01
zBAIQfAsrhV@ik@%EC+d{m4*7e>Ty3BOxo!`=}c8MVa9WiidlD|cCh{r7e6cFS93I0
z^xZHLHaOs_Y-BRPfc`4<ZHln<yq&WOun#}QKOXZ3SKq|rYVe5NbOp#4C<)uZfgZo@
z<D}u{yE)G&0CYBuj#`8o(6{`WB1UM7u@1GvWZCc5#|!W}v8%^tIEV>7b2=d(_fn@C
zTY@FkN|Zw6Q!tqIW9980y|0tu{fFasm&$tma!3sT_62AZU=om)xN?Ssbg1#<#90kw
zVoGGO9Gh`hBD|)YDhmzSBirHBeb*4!NKcqJv~eHk(#)<hiO%s4J?<aMv^oY)#L}Eo
z6$+WwHVD^fy<U5=p4GL`;bbLQURz%GQ3ge5_wTBHR%HX5_RX@X?g))&$9a_6uKt>5
zBvV@e+0sdE?Y4|+a)z6^u45QN6r7Smrq)m`12RHq*LKUJI__zHVWE4{rLrjvoxJbQ
zow}dgL$9JKWvdoY{r@K{;ENXtXxQ)wq>aRbs$5Qdrd^aKn{zjdOGG=WGvg6CgM;4S
z*I^t|pD`3WE&U>I7ybu~(k2pnK615nVeNC%x3(ByTq@m3YG4dXkkIAtkmH<rkM}JC
zR&so-F3K58DXIz3p9gB}gJtE3UJdg$0OEQqGWl;&BOAu)ajjesRT=1ki7r-W!OoSv
z9o4doH}3VoQYV+kS}JOcW~$~=!P1RfGl7c<4HU?W2mv*P`RgYdXSxC_rEm0YeBCo0
z-lKj5*)gllFSUYft}^`|$GVl4RVNe>tk`Rv!mMd;U+rb*OK3obZ;&7gdl>Y05Mtto
z(?ZQ%l_=2%Ut6)B=k3~cptyj#CcpKobFXbizKE;~RGp9gzbe90pd#SqXUl(p*eJ4j
zl;z_=^`O%?PdY&ia<^2(I88{i-L@z8KC8XoXR#>@SCk4YEoXKwczi$z6GW;Wxl=3M
zl~i5m#z19D8=&SQ{dilM<;Vr?*RYRRi&k)6M94sZ16y*D82lGBit#|??ZtMq*K2M^
z+>_CHe3;eXK2X+l8kxWMs^KcrdQlY=sVR&J{AX!N-WV>}L9*2n(2|D^T&_-T<Qk&7
zs(ok5F>*sEb!Ccq%tyCpLS)nVrNKpe5stGscry(jmJ$*YShpz1!7}!w?7@#{tMG^l
z)hFs9JK9!Rqp@)#Z(hTa-=RT7tnc++{ehmx!?BYuPgcnEgZL-sRq+11h)cG^>=|)Y
zyRkwm%yqX73G*4X{k-HiCa+XT1360f|H1(hP^;!RI5^k@UIhLWUuw!ychrhnI6jJ7
zD{gET%@T1c%nJif760u45oO#*uMpj1XgcHQ$%NX9Kw^*@ZG&EabJzF|e3*73^x}k3
zs&NLUY&S!6q^W8Bk;nw?t7>y5E(c=S^sIkR+W+x!fL^S}{XW&ms<e4kJi}0`PT%KX
zJpj+A;@vm-d&9Xw4_{qaA#-@$n>XIu`|xW6*$=N*=F`?Li+krOQZz~XAwr|I*cXar
zKrS(3{<Ws(O45PoKOqTE;{PVL-<^?3`PLMM7(BQSEmx49o@Wdkz*jm<YR7cqefOSn
zN;x)L2F6?#bUMzXIbd8M$j=IieeY{WriHd|ZySI)lSXXoq;3R*YFw-Jq+WG2^RUCb
z`PbmTgM9llND~ADFtyosDyFZZMYz{A#;W7Y;$z$1Gk}HjD}wB`i)&FKLr=$33;3~p
z3gI<|x82D1SHtVT8Q<C&!?C`4s)Rmi*l(%a0Z8Sy&=X72zsRBaEJRRu=-sU@l??|<
z)y7(UN#S@L#{os>!qBx2Vb-{}@t9B@sBQMJz|@OP9(mu|>1D%C4`Uv-)X=;-9*WH6
ztnULEVk0J!`5?0TArzfPx;^Us(*cKIjLa*0evab|gx*YBjB20=Xz~PaH@KW0AHaYb
z$f25|VPuq&mzU=<<vO~u4)LufB_mtfdz+Y;xQ9ZYXsJpbm+fy%!RA^+ZC<{V8Xq6e
z%gO0GTuLnzsz2<m+8t2zaE(;br9+z&1Nf$B+Z=nU5rC&VcJy&I>ETI%feUqM3Oxx7
zDwHo{R6fEb%BEgJe217X$l!^HO(%{0b_}j7-sT3y>P7)V3I)%MR&bASeuSmPhQ1o|
zv@)a*;_cEETsqzly|8q-R{{R@JmY`DPlYar0~LetSA9sWX0`h!Wf>BQgw@s>f`<&4
zcZUmoG~K5?vW<>0+P#NT?&}kopo?at=gbFM_9G8f)liU2DRbX6ngX5T@Dthlz~}uq
zIy$<hL;hP$Qh5f5J)Gk}JZ#ll5O+}m>f7}F?r^+5HmcbXW#OPk;OyYihw<Oj>XvTY
zSJKAL(xk`I@~*wVb`URcFuYImVO>#u7^K`nqqr3(=7Nn*_iMm0L}Ah6QBOEC=eNG5
zapH5~zcUY_MKTFidG*H)h=$GTn2Y+4>xNG4Y<UF*T2@xsKA^{^^_w?3V8e!R=u;oC
zTZW!3ca8366N-a|rxo+-m|<ACNfXhvt5<W7NbO$ngCx)h^p?CQCO3Qchfv)M$-{P4
z4Iszer67=cH(qf0?0Ud5iFIFMjhWGx$x+@&T!IC^2q*9wSy1DE58-rs(9hqluB?K?
z)hXwp!RwDuRpXUQ?7V10jjVyFp$zdwE9^Ux$wQq}E&9}kZUw_1B!J8T>7qiH%|Q~|
zADSXR&1+m|fX0p>U8X&jk`Fz!wPPi=!$X(1TA4?emvba`)2LS3IZ}ZUPA5^lS?GxN
zToOg+B5M|SfSp}B>N<c<f!9^AiS>s!0JF|5FV|!~UY6Z!Af&oSp+)`b)vGYp;h~{>
z*MU-Mn&q3LIxWouyfjQq)LK$K{MLbM=fcs8T&28Dd4ewg?CKvQHH@FIJx?{O@Cao%
zK5&jH9#~&xb*Uj^c)t`XHI_$p!&xNn{6R$0q5RK%e7!5X9~q!4_!3iaLvK3hN=2vy
zHYdenkxpLi_3OO4o#f3|b3cOpBtCrjfCcZ?z+nYd3d+jLn3a`&?Yix2Q=p$>sYKtv
zfZ7yT08bQZnte3+x3poa<8Fw1jkJe{2eyG&0+h;~94_r8qK{;>jXc;2-QH19Q3+fk
zD0*s|1&#?xmkz+>+%|JLaR~_ql@J}?rK8()0elAMb{1ybVD%Grg7kZ}pA&3X&^Eye
z12nz3U|bhnvz5(Wp<TBhVsxJ7m9vc70MpLraC=5Z5xQ5^tnO1aYhE|KZx<ye|G3(L
zmlE(LA+wgVA_C9`cQ7r1)B2f@H-4}|jHBY?b5*@(uUH{At5$iR-454fUIvZQ^KL+D
z90%qB+^gN!vqK@)yY@j7(+<3SG2kh46A!8Hk?yk-i{ANmeHIbEyILLSVa`3s>b#MT
z(l$+;EWQ95I{JHly>mNrGr7JZ0vQ)C>sejy_2ypR{uXOtU2uwo$Y^)pkFLYqD8}pB
ze)^5_f9;Eo&4HMRXt()_YSOq54uzJmI9)BMRslW9BQiigRdLW!*3rw9*67Vl{Hc(T
z(2fGgc}efj7lEQUwcjJz*A9Cg=h{U;P??XM3i6(JB-3&(_}WF3O2jr2E`~$k64mI@
z>>KcJ9NhI)PqCix7b>6T*VWvtP{j@VA9s~%A0qGNh92hPtL9=#WkMVmYtWyBGG^qo
zzw+FT{(E%HcE2KBSW59yVPRp3_`zknios;9rKY45knvVX)gP}z*yL5kw%!|UebH`S
z_?%q32w(E3836jg+xmKUTPVuv5v%W)kc+ua#??w2u)F3?YS)Et63K{x-8S3n4B3+O
zlFi($AH7le5&SfS`ztA`1EMQ2%zXO19PPb<99}ohqiC0Uda+2tbPgcsloI_B07<&;
z_*MI!o(P<xi%k5Vq&Z7^cgFBoQCARCGJHZ^K_MaN_)|XpAIvkLE`)Yf_pmpGK_87M
zcJHXO)I?0KaxEC>-M-><UF@a|xXL2|D8?a)CC}*?S2|T8xliL|#lfZYJV@Y^TT=!a
zF+;6lv!R$ufb|faPBx1c=wlXeD5+10Wmb$Q-NA>7x9<~QoIm*4=x=pW?|ryCBL7I#
zgTC;By`rMx%e<vdzWOBXM<g2B+IU}hYnH_r)P{3~)fkt_amcc7zG4OG+e#3QZM#^k
zFEo$!KZa2a>kCpmn_9lHvib13p>gqVwEv`43aY)osBUze<`vGNo!>&(UXA&H8B1x?
z9FpSt`F_=dzrG+=l>BUu=RZovY8lnAzOf;(a~cs5VJ)6jR<_%9>gDM<yPYAim#dl_
z|FE*8M6J-H+h(y$5`Ex$^m~gF_k6+2{_yaS{5%17L)=R0^@vk6&$iDXJB4yF_u~YX
zB|r!Z;8C2tKc8Kg{dy8LY$uvuCF76hOdoh;Vrh7T`JOwZdf1<iOn)=M4Hz77{#Zst
z%o}g+Z2@Z&vf|M;y5nrL&zRg`@qa0=F4$Gkd-og`Pghn}20gpRk9&N)^YIT;c`l~~
z^w^?76arVQ69*+wD3ojeGg{^Gr8V^7Hy~8Xn|)r*%E}^X&C0U0#TJf?Xo2!@<u@hu
zzk@&E{~r0%!oq@!k1v*0@WF#uZ{EByNCmBo1t3XSES4lyT3I=GU~o`SOe`PtkR`$W
zN_wLr#*uQR*V<YvdvA3FpqY`M#{tnLR+v>}>{8y&(bc`7td8F6VH5P34~_8ulXIkZ
zrP3kf1P=M|om55D2oy7k)xL=DX32vry3UHo6Ney|cQ`_bd`|Q-?|6UHRM-Zs<NT}$
zp+-p(9uh{`Ck_sz3o~_P0<FE3t<JL|TmSxq&r8k!{xkcjL^g;SvNA>qy!YAIEc8O<
zm6f3@RI?;RCKAJ=qpKmJ8^Wc~<Gs<<Zir857{en`(cT(A0)oN7_-D_aIUd*ce9}}o
z{wh;{lC-vUOWCzt$i`{Du0RdG;E!1mZ3!f5?)Rm-wo>hXt%Ou-Y{Xm<)M~z-5-Q2~
zkzQA46fXBP?fIujv-9p0Nos|*U)O8xJqMVP<yw12_u4&mH?STkU%*K6IA_coBPx4c
z3=g`9pAo#B$DtU2oPBRZPjsqB2<=_U<h6ERe!vbnl~sSTS}(C=hX2D9Xu2Gck)O{k
z`0(M6`On~K9}S4-VB*m9G_U+bg=0GSpC^hUA|j>JOBZPkzJd*oj)}p5=Eg}SeCl^n
zQGsZ+H(NJ|!Em4B5w3F6zRa-)l5lm^NL$vWZ>E)nuqfTsPAozy2?%7Tj73<Lo!_ao
zHB#6kn)J240WV{xRFTTd=uu3v>gw-Tzm-sl+kv}-<@ymPV>gIGZRVU)FO@NRj?<R$
zLw%^>lG7fUDiq9OrO*}(-)rT|#suIF#=l2T_wro~2;o*Il2flIN^!}@zYjtEbylK%
z)r!(KqN+;I9SuE50yhSo83Hcw5WMUMW$GJi;Rg<ZfJkNJ)(u2oi@@api9nZKJ)!64
zIg)$Jx>Loi7;VNm-~C0>6?H)wPD<lEsXoJGJHL52E40MB<(=?;tLnw<uX-_hUomB~
z9@RvkM$)qQZ?u#Lex?8XIq)k+Mn>RQf%2N157n34TwPbd&l(74k!20;Hau=(K6wtj
zq^631K&gS!Yuk5}eRF26gvVcfU$9eP0i=SLu4VGC@cI+8%Ar2teSUv8_;g%Wn+|H8
zne(Yt7|;}38;5n&-I5&_dAI3z!Y3S_{-r{OG1WfPJv)~RWiR{Q=>uF2A2P$ZL0mE{
zwd{^RWfpa_)e9BzIm(0x78+K&8Bx_07OLVOcIx4#G|<t>VLtg4pjT{qv5=d9;02KR
zYEC6?ZH{teG&(CqdOr@Iw25g?id9v+Bv&L3)k2Qwmj|TV&j;_i-v}xw{3-tB^Kscy
z2EFV%`3_O8Jld`;NxJ9;sK>Nefv@NQ|Hf==v|5k+nN%)EDxmPQKp(l$b$YOl%9dmO
z_WTvbaBZ@3r|Wb{z)w_II42QOrz`5V7RI`;xQN-P-W<X1t$JvlBM|P!YPne<Ym8IE
zPQ90g23f7DoQ!pE9bib~OUQ|+<j#k>=o}B*!){5ArQC?X7lLGdV1?Y5KSFAqdf(Q8
z>c@t|Va{YU&0F|lGGUk7efwV~6M#bjSw5cA!YS#h3Il%Gq}1ZTN%NhIPeV^H0rX*i
z0DcpA@5|7k@nYmYGaX(3POqe|C9b5CH!;>9yoNC1HNC?mj$12@$OsA|hi-bI2S?!g
z9?v3ml$9xfmg)E<9xo(ACgx8u?`>E6qM*taS@;F5tO>G?@MATB4};2WcW~hv9+*eI
z0@DxHvI?(RkZ^Vi-FIEBZ2XyoO3l|Perc)s=9^H(iCs)&*2LN&jA_H_SpTdF?+kDj
zgQ!(nQsOdh5xY{{$`r|phr{aZ4!&D~#yR!%#sgzmWUPTxI{?ovE*i{7KZ*AMD3Xg9
z7#P@vL!gSZhAx*2Eh7|FRjvL3Ns;@5l9PO!v8@Y|{k$KJ+ePWy$F=SpOen;6D@BsC
zMgkt23)PaeV>~S-+sWj!zu%!cBi;#J9Qp=>jAmr6!Y{UvE&c|TlC{F_@F$ihb>>$M
z{SuYW)8a2+{YkyCJ{TmPbn3(-3h=yKDtNx&KsoLOGd=yllEgu!0BRF3nO>2p?aDVP
z*(m$!^{!2-4^OZYqjg!5*mTL+XafT9j*kZ+p%l4k7N{?joVo>muEoKD@{~wZw3kIC
zo~UqIC79nFcL{)>*v1Y!i~n)%Q`mh45WPS&Dz_r`+<RsGixu0seT|gPs!=S!aTUGT
zv#BO>Jo6KOl@Whu?2lF)-}RgCHy*On8haOK6mv#EDi>(h$4fc-vSBbqu<1CL`L@gQ
zX2VG2wCC!3oQ=J`mW9Payf2>Ku&-Ichu4wl0%B%whqVSqS>vNwTGzc{?Hw-Oe*j&1
z{p!`rn*=XYOtaRnYt5%Lk)p9dw~g)N_&sd$_^)}M>Sg*Yn0~O=mENY2dlEpDKfM*O
z1)%cEzM#x$k>5PeLHytqkX=uS$OB~@`uAETmxGrp>wq-UxhUdy1FU?sR{Li{{N3HN
z{6@xoSi~3~bVbqgc-6QN=(d7FLaP{9;Rsu-!MEtU+Igj=>h-v(%?A%2Af~4SHA?{b
zaDLQ>-;t`#I$V#fwzl@_LH%j1&nXVAy1JEmvYYKuevW_)C{=4c_8_To>-12iU8R3q
z(8)-P8}FeM9(cPc2KD(8b)9*9)V9428NEqXE}A5p#!9_)Y3Gi$d)t8mq8NL3N>|t>
zNpiT_IDN!x#fjZ&`mRI#6S}j2)@2#pV2H4d2d`NeO?j@uCu+Tr`Q>NKbx2+HBKF#~
zYb!mXn?nn+#u7_}>uYP|w#*XVIssJ7Df@HsK)0jeM@e#R3fXP@x*8x{-(Y$GYzE2}
zI1A$6JpeIe@c>bdH7eb$B-HAMX~kwK80QM&Z@$wE9#kS08{ECN4YZkg4RzYv(Mc0G
z#v~-IGM%362syupu+Wne)5cqpTAYOt{`kFbW#GY>Vep`!^OW!Dan<PwZn&@SYb1v%
zmynS5U9J2+K+LlNGkO8|U=Tk6=m`fuBCOqJ61jESPRY5ZIzE*Y%Ym;9<-HR@A`-+L
zHV+`Zs-Vsk`q7Ei(!yCofEXF@%iPV)<<P6PWMxx&YPkkNWnWWTA?ef=zEMa=qXWt7
z_UgOZ>?LadE}_`sZmc)pqxKauL{kn;6s6O$nwrsidU`$MoBJrpD6rC=yF>&!yKB#%
z9`Xf&i`_*sD1<8Bsdi*7%s!(!l!&NwZcfO6%MAg;JtQ#&b%6P_D$B(4w(ECwNu~(r
zeS+qmJe(57mX<7#VMIVRr1+rMy*{@VF%F0HY*jbqgaK*qt?OqSD)xl@905UlBR<%K
z&uynJKR+xIvM^SU7Ktf?KFd`iigkW@Yuu*;qw21gOb%2tP-_N#l{sHzDQLOe))oem
zOWaE*0INr5X7J`LZ7FR&4j$`|EpX@ed}h>La}sjm@QbWjH@8!VgXwHQjo;1S#<sqG
z=S>2stD<Y|z9oj!>2Pq1GHYXv9#GF1FV_!UAH^hWiD<s2G9a-iBG`)?w!JQyzSHJ-
zW3|~3u(JAwLDh2?>N)hXfGeF<Yp)jqN*4Fr$=|D9K$H%|NznZ-$hDs(hDm-hGhWw6
z?Yr9z^bHLoxKtu>7}84ZnD(m~_un*}e}K`4ZoC~fZ2fVX&jq!uMd2$<?u$lhqO~%3
zYiwll@i%2o!WSFd+%Wtqx6kZL4PR~y5PUf6!qSq!b%Gey8~gK;P&JTwH^1SPy<x-Z
zYf~^#pnEGDA@$={F(LPu*Vh-Y(9IIhEU%+pUY@WMi_#Z9q??XlI*?)w^vB~*DVQnd
zSJk&6O*N+}b>ZoL>q%u?(@)Q?A)M7tap8*=fL>AKc#d1%r}OI(P;7B_i4XpXuW~lY
zo7C3KNy}FZH%OnDctZ4#P6Is_E`eymjQ#qZIt6Z=)cv^AO#7gsH_5+61B$anKc+b3
z<Ds-OH&ydP(Nb#tT+GniVL$&rga_tFMj%B#c3JgAfMY@2?TH&2tQ>!Yy7rx=;cHGH
zrCcEsj%6actn-uURXKL(w09cXD&#hNc<P&a7tqwo(PHtrl@$8{uk-Jx%x~Q?u}<5F
zu+YWYU;349tE1DgA@n|`K`pjh?Fol&1cBdfm`aB^|FA&H))<q!KEgsDk>Taz`>Jhz
zB85)1n7h4jX|9oF(%DtBCtAXJ0ofxWn*Xf;DLxu5G4;x2;r2WIqzYR)=v`&wQ#Uh*
z;*O)VNbL0j<vaW{$(=R#AS95p%SBRpw?MhhPgbXckUNf$*h$Gf2B;k>!r;(IiwE6F
z)2?xGS?s2wQkB-Ikp9%beW<ZTfy<msdY0*T{MXY%@5)nAtpBp@ZCOSYx7$~`4Ghwl
z{tY(?_-{^RXMFx|Ex^wU<NXzr0bWrRNJTf}`5dIs4aIq{mfIrP(Vg?cE;qxTRdM7O
zjGOMQkrQqve#t1bdyv<`Qq$5NuAB~;dzcmw;O;TOo8V6%#J^&AI<j;jDpkEbk>t#U
zv@U@JrZ6SAM8_!I-j4{~lfQq^Mtt>fp*lyeE|9i;XnxR7ipJBl4>Pd@$C?cu7;17r
zZKGfCu1?Lewj=tHs=;fTtTTq(*zdD~9LJ6_>^0}?O*W|MnwHM8&0$8D9K!ki2nPMn
zw|PGl%Wd|ba@t&tSZ9#j4h}Yd7~OHOonXdfr`UagKZjQbmWayW+bmYl*{l<j#R`p7
zFFbOlG#^~nm#^YDs<HAie4NbX9H@ew3sNfcK<J**3;_fpc!eM*ape;ME$86am>dT|
zo7_mblMq!$EmD1BkT4;pPf0VJ1FdK??`2)C)Ust*_FTZP>mEH4JMRXQ+*LtqGs~&O
z*C4`v#jJKk-bKlv6$WZ&;3?~YiVwTm=ag>vDZV9p4Nltx5`v-b2T$LE8z&}X8;)#D
z%UZK1yw)$b+l2P%M6zQ$54P#!gERS+B1z3_#nZJ;Yg+OwY_WA@otdY|o}4jNo`&{=
zO=7*$*SqU)Ox38UJOHAqc%XT1!*m+#HBd#$q~8WctzZ;FsB?02(*y`Icy1`SLG!gg
z6IWRvsTlY6vmP4vbkerFKaN&%<Q2T4bJJ(k&UK0sR@@wwaC4=$GibV0!%0Uwa<xmO
z$j)2iG|?g*!pt<COXBrv>y@kw?X|+>$X3$}ybZ4G1kXVNyDFXpzdch^Q{E2eGT1-~
zWymeIjm;RGPT_+Yro*=evOVL`z$}8F@jL%B0M>2yL3k0?w;Jv<0ZjTuh|95OI$0-)
zePvIQXzKE-{=m~{(nlc@h&!dyZC+VQsopX(q}P_NChfL<uAZY0-Fq|fB&gvc*f6Q?
z3j`QT`rE+LxpfeHdB7|b#QJz#WkWr^O2t^wov-JUwAs`fB-0w63_h~lOIv~?WV1H)
zuP79_R|}{9qH$j8Zwou&o7}X<J>N6c#5oIKU8e+o0~;wAsSj2vQ?)VsTl>biHEKoB
z@XnOuic{*c_N*W8_)=4Zc*nUkhQpr12<I2UNfx&r{iE~M2W{p$<p%3--i2z9$fdr1
zK>GU<<bJ@Zk1i~<9QkIV!`W$fCZUVz@uTa3%eievs;HJs@Hl31mP#r^TW%PdcE0;8
z<0mJ2p@QITz7;%rO8i?h;gl2eN`Kk2yV?8^I}!XMw3?kFaDyM4eV-f73xc(rwTJ0j
z#_@~%lp7VKueH3~$g?=T`H^V%WpnjI9ET0P#(d{mq00f4T`aV}F!y|j@zPazLS$<~
z-3ia%dZmFY=XeQj+Ke}nurXo6aZ*Uz*0C25$m^YjnlhO>vOIHzon@()eke(>if}EI
z3|K{@n@|h?{=9!?cotJ^;1bg_jL>RUA=S;?yzbwlZU<2-k-dDcH5%d*In%O<E0jQw
zTkw%ny-*<+58euTbgm((wEz92<N@c_%h0u$#&p&2q|HcY`%G^>c(|_a9kT(Jpfqq*
zXtls!on6-QdeJF{ex+(yrjg;heu04cT#TQ+xR3<K8h0>ZK`LAq<ZE~EF+1N^zsjVC
zDUg8n=Of_I;FOx`x{4q1<3}R=h(!g_Q#4w$jZBrQyYl^DNZW@|ZSG+A1UfC81~;jG
z4k^9#!N=Q8L{%mfi;o|p!!o|ra@IR$ROY_jNiK$lqs6_0h+C35$QW&_Bb(K@>wP_2
zDqtVkoaufdJP;%fkAYeK@rwd{T%_x?V~)l>52dDZRV0j*mHf(e6a8#>+fai?{qk4B
zb8pIm^q_BG!y#?E&`z=pKFB@2?x=RTV#ongUtN1n_Bxqs=X~co=F5`;7Q1%xDt;;?
zJiz}-M)?0y`ulk2gTvtwzb_KKy<!%?9{namdqaAvgeN?m`JZ3yBCscQv09z^oIP<b
zoQITdesFEkJI+(bh8k+kZR{S$YAdF`Ht#ThZHWnHoyFQ(!LrwDo`>_^<?a14deGX)
zld>LrtuVG%*m+y0|M%P30(W}M^J!BFv9F+D=4^$P6!9zUAlyYv+u&FnSumN6U62^!
zIT%0J4m?DLKT%<!`m0_K-2%TyJW}SS;1#*xw7B8=^&+hF<}OqzUa30?V!UCm4G~+k
z#`RV$=x+JAz+u%ysi3o<Ddi||L^`OAQpmf?z~8^{@e@C=s{qes0Nw{8Tmii>0XBOU
zZDNEm_buh0_k0-MPS)mBPmtv}FZ@k107%Wlc{Zllx@(VD6j$T<>2|U?9_HSts<A;B
zX&DskkSUhT?uj#wXV;B=%3dEB$P)3Y$sObfa9W+eUPpN*QVd){>zpI7ZkdwgI+$T%
zW7-JEvWNIc$rpGpX|`7uDX2()qP*as;W&y(#O2r3LKXpg8J1@@w7&Z5^0euR!DzAe
z<%7P^*q{g-v}GWg%68vYXpwKA<R}k}6;1-V-h)M+MQ;}wa5TiZBZTsrS;U=~H=?H`
zJ$DJ67)7kK+Caqa`lv?tgodDW=)V14I9#ijQWdS8!~(U4_qRk3UF|CDHoFWhEF2u%
zM{K{g<8Dh~<~la%0Ci|lg54`~%8d9^=*$hR@ZrV7B*4sxc~x_EhG{&xNmjB!&eHI+
zH?3B?Na+*yRNwCe42ftreW+)Eruj#@@m{X*6X)6&u1vt;57DwVuF5F;-sNBCTl;A-
zF;?9+<gK!M%MPX4cD$g15pVe56aS&!hs7cf23xuC((jMEcS0*<H=O;|zBBDzSJ%F|
z^quRl2Nscg33v=c=}g@4lDqEIw0KiXQMg1=*D{8v-Rcq~H-2aH^gFZ)!n$US)9I!j
zUa;()*f=1!*PMNJ8Fa;4{We?fjEx%{Y3SDPA}0Rdd2S5?0jIjUx-<s?Sy*tj6Y~AS
zNv{4zDlU`cV3|0Y(O`7{h%27$as0*WdEi`%oGU&DQ?*565=`XRTh6Tn-Uxbl?ee6W
zz+lt+RZP>mSIy?&q?n<8vZ2Y`CUNa5+DNBH=CE!OY+;3HL7RDXHe47&$IJkxLI8fl
zSNklU^9BSB@>Yg-QDXVcO<+IQBV|lwCGW(sEUkT+mqQ7*@KgGczMZ30)`6C{V2JGm
zHtWC1VCP?_Kc_4wTABNi;<g_D$#bHh(751yDxX)u<@{ko!fAqoh)R&(n&4^|U6p<D
zmf(-JSBDP-qV5|}tU%2jpp&908R<YgotGF$Z%(frXqfM(+7@+Exf|>36P=W$MprK_
zt0v%g1!32WN!N$#{m9z9+ZBG|THe1PcmX-owL8F=IAldt<~h+rL9-H^sX4xP$guhx
zH~$v6NJ%AyL%=r>8qWI$AJyH&Pr0(^0s#Ox&xHnQ&he_T(+3ZbNX6hqRuKH;ApB+P
z@hwY}a+d1WPG9B)IxMyivp*$}BryPw@q!Qdu9tr4Eo$D^%^aW|q30p}XBsSeuPdXM
z;4HhCov~pF|7y(TxJS_Kh#FFOdtvfmE5jGh>`Y!t?j>o$|G}!VAI9D12wJ=F@%B~W
zq^y?(RZuVHdTHK0x``A+PW1>y5D#+qgLR?aiNlLCE4Xcj73sS{(`tMoAAixTER7fc
zb)Nn0*U6W;JE}$>LBWM+XC^h(|2)SX?>V}~hI0x>Y-LlDk6>m>hJHyqTnnN|g)H_|
zl?x8rHj(AnabP~(X90GVH1pKJs*GRGA#fK;Wju&zEq!9+H@7T_Dd96`2nk*BOIuGt
zfc?}>;A}8#yg`L`oUjqR2L)Jor7MWJ-7B;E+=aQWekIIVB{Ru6&zy$Vd}=6^V4&46
zXE+<7FU~IvP3@K2d>wXTo%^Cdn(+yEJ##V}C;L4G5jx8K!p`1kq;^D--2O!uQv&-0
z#Jj4({5VN+<5v^`^3&x%*Y6(4g2?cz2>OC8WjPY}D%E!9*BWJBTjXYvg2<9q2RFs#
ziSu!&M;34&A1OTEC~n?8rZ{YWfmCi8x}AY^6iTx})vT8Cws#Mf3kH^M?@jlgmRaE}
z*j6>7)bC}7(gjnzx;;bD_OIx$fj3s5bGe)k%d+il1W8+?@x}0QMva8K=y76cRP=}U
z2yj@jO|-%bK;h%>pItb#28UtwKu&|K@;A$@`d)X$>rL~aK{x0z>4IoozNjq8DyGNJ
zO3W@cI{DF3sOZ%_qWO@myHVP`0Yv{rgkXF`0B?eF5Lh?61>fEJ-Pq?AGspsK<6Fun
zJ?w!;S#!sj=&8MC54&AZj@1otX<~wH(aB6{Ey<tO{aAkIgrOD`5Lmm;JiKRUmx3UB
z(&8y?4Vv+!%LcgTN^aCnSJa4IJGTMQ&rVFoeQye)|KU{6xx~8!+&4G;?pKB$v_orD
z-O$|9sFy1IW#ZXtAn=l>PY`72pelx4QSg*Yy)~z<ff=Fs{9IjW61N0&Z1z%)yT9mq
zEeFQm$67XF@{{{#_kA{(QNfKZuP=2$b;O(ho*?8;0sbGa@hD}@&CUJXL!j2SemxSW
z16&YTYqkG75hoSCSZBA)q+m9F5lTk+?h9(h_4&g*>jT>RI>FV02crxOu3i%9_POzN
zS^~aeeQ=y?O}$(NqRMD>$6wbg#D3GaqZH~fZq4a2Im3C5cNKl!08~n!F{pTaFe(Wu
z*FqdWOS8j`tx<A!g*(f9@V3%y%jYP&c&~mxm`!#{Lh!-P$>^v8v##}3(;*)Iu9sq2
zc>5`NIKQ}3^-QsJUvQIYb0B1kFa@EZl*+Bl{O`%tb^-Wb*u{Js3-{1AXo>1ZB(%h^
zf1FWgKGu1$u`gyN{9J~g{3r&8%Y>|#CM1~*+1cF`!R$}+W3KTJay;74<6zn;o2oF6
zekWl(Qn!f0rS98m;{sh}W+sVq3zT2IF-<)f2>2UP&jByIDLr0sw^}g2Ir7*k6%$Lu
zVdef(z5pP`1yPuqrCo85^riDR#ci2NutSuv#ip)(AI)T!b<*^k>Gt7iDWAw!QMJ?I
zIoeTCtHW&9bdRex<EVeum8@MAvD~o2eo`vyET3LYpKTzW{)Bh@w`F)oq-&M|M1xT-
zqzq~)MX%Vk(NJP=*pnaTtd*%`b~%mbZ5j1veW+{bu<9dL(WaBCx4YwlGFAc@8ai%!
z!&<LX-d?Yo21l2<Sxqn?vDsyD;j*T|eT)YvRU6gLmr|jF$lwQ)nqX<T`1XMnfB~r+
zsvi-(A2Q=as|h=I=0#yodUUVx!!FsK%gFZfgi9bh^Sn&460!p*8pTcHA36Hwb&y?#
zJ^{1Ks;GJ%y*xG#zkHu5cXF}x_mqa!^K|t_FRE^_g^G(cVUa(cE8<5ZSPA_fy)HG!
zeNzw%C%0P<NsAB2=x!LIZ4*g1=%KsD-}&SyJR*T41D-+x<6A2MAh8QK`aZ&D%Kpx`
zkXt)8i+=4S0ECYYA|#%FwaHs8J()bJ+9c`SH;%S{-WQwD=Xs~9wX_>t=^6$2|BNDL
z-E4T)apC;AN9TmeZQ!;z9jB=E$m0?(mQsn4eC{Y`nP>bJaGtLMx$#nZ&hTMAN;%_c
zGePRqnc7XcO?}JV{g#N-c*3xYf`fXngLTNrr&YuKpNSN(1^1+U3BK^B8lVU9k~I$X
zML>Q3w|e$-UQ+J4rt=QTfa~L7faQhr1{q2Z=objdYd$IKj2lWjrP7DtmVCwww#FHk
z1^8FLEQqE*=~-FexA1Ub7rfGT2_>6<0?h`8RQy4zJ{L5v|CRi?MxK&v%M;roS>y+t
znBC@`!v2dN*mQl3d_;fcf3sifi&dQ)gmtPaj?bxrtCS$F|8M@5`1ym3ntH_0(9lz>
zmyIQ6j+KeT3lhV80Ht$Mr%w5Kgd}B^%-=z&cbGr%c@&vIVjdJ;F&xaJC21XNsn=57
z%m=m21kk_~<8H3mz4lodbBs$Aw~H3>F*L6Cew-8w0CRo*n`EGLMTxm_-_PpT$p&z!
zD2a;fKb_z*aHp3c<0+18DPaCC^=pV*ocB8~+DU_$#1rdmS(yZs4-bh)SEMY5C2d?~
zkuJyfu#@(9i1V}H-Tr8q%*qSMHi=CXI{&2Npj8j8Q=)L~WHR4(eeSdT)c9#oHc#{*
zhbklVF5R_@G22-e@J4427N0=49R!SnAXeFNFlE%khdBREr-h^!x6pu;*eIHNU!W)8
zAKZ8W>s>GNye+nK!gkoc64A?(-g8Uz*y*cmJ;T~wS#3d?S|J}y@1Md`D*s;Vq2xCv
zsJ7*fFN0vu3Fkz`P-!(S9gf=`W@mLq{O19oPP*_gA*_1g=TKWOxtw&dF0)MxQ6!6<
z>fKmfCR6Nl0y?_~_Iq%s)+vg;#VXF>W^efP@Jp9HYR*vR+?$GfE$n;Koa!90OY_S&
z6t#HbB=896VoPvd50A?D9F+=*L+AF5f5#&N<1uiE-n(_M;!~+g(FXN-{-xXL^*jSh
zY2DMh!H$I_J$CiRcN+vHU)l9w)n1vWuMn7oxWk9E(Tb@$c4fk;KWWC-3GJ$fZycP&
zt!A~rG|CCGRAMsZg$mHSlIzxr3!s_81K~vq2gRMyUqAjVE;(4-xJ=qC86P*P4FN*H
zImej|mSde2;*$nD7i_u1+p~|(w=q@A!cUxIhgtjuHjSfV$?c7eZduYvja1teX-hIL
zZ<QJ9s-?kb+J@RATp({?AE~F=SWghMK~WL`ja$j!ULYt`2hocC)?=v-aNnn&q)ph3
zmHnXdab+)g+mzUyV1}llw!MqQ*)qJ5x|*zW|LDC<_`Jq{wG{iq2$t$1_nD6UR@?mn
z(HObYvZ0)}D-p#6uNS4nvfPmy+hx&Mr`_(4nq-((vifD{WGU2bMqzj<I(u!4W7Z_N
zrK)Br?JZ~*Qvj5%Gx4tLF$mCnra+ky@_ZF#w^Q_>Gd_Gl4x9u@V3kG74FC$HyciZu
zJ%XVn&bXnU|2^Q)uoEC#S6FZiF^PS#!_m&k6efk=b$c`>Un5u&(zyG0C^-pnV%L$a
zno@ECH#_3$(eJr&)<7ogjNZ>U=tO7$)M9lLK2}^Y$-_r)Au23_^C$CmGE!q-DsvK1
z2KD-qjHIvGOC}=ywTxdOCOqPF=V4Bnq4^IyEd&SI%uI&6jH&i9vV>D9h|Vvadm|;7
zi>|yrLPg^O(30?eP0gi@T@i96-BW~cky=QTApL)SEAm%j@OB8N0nIAb%>rb`HyBbp
zHhP=x?Okl|+mGUp|8YB>0d!pxyrNrZHi`KtuI0YhRU<hXK3%NiY32XoUcgTpGMFVo
zRc5aTIxVOj2$g`sO!nU4ZZ)ZTF>TozKc9>nSc%MBSw+VbpYZ%Qwh4$C+?VivB$&it
zfm?e!By=C=@60H2Lm?t<U9rPF@4U;Mw-?R0P4>`mEi{@>xk3QFSjd%0Rro+JN!20n
zLu<K~FVa1L=!&B%Zj`1_&Cq`O9VT$*cbq-*n~A~wtd1SE6R|9!ip+}uT7b{nt|xEF
zZr%lLoDV`fp!Ux<79Rs$Tg`hv-Byz^Y%|I~-F7slZJxh_rr~=;krvWbL8x43kHOON
zQ1kK194x4Zm!+cRyQ{Qz;szs$*TnR5y<B9hHeW?u1^l%4OI5%KLC<}O+5-OaRkWVX
zwG{fF|0+57shU%WK8QEy+{fGYhs<C1^DPoVZ?EW@dx9mUcYs|Ly%e8>?6pj3Rm)gS
z8%MD~9V+{8yv}3@_(elDs-Dh*9VPS<w+nRMp_vEXv^$t0D~^hdvRA9Dzn9r-;<Ejg
z{Yp~`V&F(-I{$30LHN0v;SrAW@0Tw{?^Fvp*}6XucfV6)Xngz1ul`&Dnli)7up4gr
z$JQ?wk0n@Yi&Z>N`O~Q-8+m9D{ZF4j?8md>#2+*Tgzq+4*k~rq89N;J3y5S$Qrd5o
z)#hR*qa;Hcw-{5_4UEIzRhHM7oCyPT9{?1%a;eDvjtU+u-sP(HxG6H=wi<R-x$A_|
zTPCac4&7K?hEi7D%f}%h=LE0B<yn2lWYNI%MKhbYonbp202@EhWBg|SE`d{iv}}E(
z;IpGDs?{cD`P=u1iyo9d{Rb7)e0etyRSJv@ee^m~TN?n|VXY5e6@R-54&^fqY3`q&
zw=L*z#8;8G_Jp)7NH9xO#H_y^5_JSia4oDfS3?ER)hN4j7F0t@Klx<lfO$b&cYLgm
z?zOLDzV6OM%PhrSdHXiukQPa~kEw<xryvAKN%vMJGRgKCjxs>e`Tn(qY|eSbW7>mX
zaqh<`e$cG5;$NaH@Q*yv+cMKDT5i2<WH#dyi!)7B#EJ3^99GbFvNU+E36DNO9M|HR
zSXWr91r5;Ut>G7{>{*WvWMxhteM{@2q_UihtGQ*;=jhV8UA`^a^KLD2aZ5#<zov8W
zAv5TMJSh7!h9-YT`Aqa_6UOUw1qHnFYM=}y*^gGo#sbwkZ%@)`&lpv0Cr7W!FbIuX
zNHc#~ovUH#8m<%~-TE$pq^qG^tA0Jke!^z>p~Q~eHgrIe`#u)Orsfy=lV+%kR#69r
zT%RiNdpbGjGZ>+%M|TI@g7kGB^-ozR^-bgDv{QfvJDbse+1M|O2A2MxFe`=sIU5`H
z5*1;r<8`l`^yd9f)!%H7ZG3&8-SfkL@HT`yoU<cS9q6ec8t(96|KkB|{d_kW%er8e
zmGbfdTr8dD;^oPA2_liIu4}_k786y}s^Z<fg9S3A7Dqme*+p{R+RJ&^qr+A0RMYv@
zw`T>x9(*@;=s-8Q|3Nb*aJD%2$e21IKSrk8rc!mf1v8@<e+PFZ%z|GK+s@4!X7Wgt
zATB!lyO!~|+1_s748++dem6W?2KHn~>!*V~)xipxAx_+G??en*4I)|{Z>5(*;3IZo
zfYEa5UKyoy{)}_S&I6@n+ezWg&L4C@d5-sOWRD7~xjQ+V?3g`8=SHyH{@6wn7_M~Y
z=OctopvAVg3pW9SKO>8lv7LNKjd+ssvjM@oK|Ne-6&FJ?EKCg`=v4}0=b-*x?R<6X
z5Z}iK-Q81E;4u&q9!>Qe6EJSWZ@1oufSutTo&Opb@rvaYErbOt-IzUH)RZ81OX&S#
zcw1y?8moxlHkLY`I_nwH+qq&$7v_c+d}B@G$WH4*rmwF3?l$TD^m7hZUkIg*u8-&a
zigJb2Yt%nkdjEyi1x^0rb`^Y+Qx%2o#i!UX%u}=Dyq(6aH~ysa!$C}A5J)U4@sgdl
zzY#G-6H{%b^MyTRT?IUYI1<}7u5;T;I#+}7=2L>VSNcGb2EZYtyZnZUy*jO2fuomh
z@O=8>`O<B_<LbSxIQOk(p%^U;p{6TY9mHn>m&0yUwwRCpy_=QiytsrN(%TCLKpb|-
zeiq!50-rWHyp2UrkEC{JJT$R5cs6fO)(L(_wV52f<d24jqw)o2)x}SHK2pbj3=5Ke
z19W@GZxcV@b(N!-eS1#FxOS?J<ALf}y4pIej?8^vYBr~Xqq&=VuAUPk7f5$&GlP$Q
zDGh?Yw62HNdB148JDus`#|l3`9UIi5vz=`^_n)D$;yHk{G+}bst$bW;gPWY2&F|mm
z^=0|*eu)64ekWYlkaf;|*#IDy$PB2M$n5@U6(#fJNAH1Q3K<A2_MOOk<*$}ZfmW?D
zyVE0<s``D7yRd7k*S5C=F^ByR#YF~YtrL4!B5^-z(jkN*7Nm>(3iSUuo6^z3IVt`k
zyJYII5Vnv*A0_Bx{`@H&E-SlYrE_dV1S*ISN7!bW-qeK0?}Z;b&;fl+#Eji%01Ab*
zX5J_jqDnPitR{yYRZ|4(#WH93vqE7z_PuV(_Mdq<6YDtxaoI|#227L9cdYU2F7@NK
z;p2`n1VUk!_WH_Ay0H+??59k@%sa<%Rp;YfTbxFsSqVX+`w{I|OVbdSAbluu7&9tM
zYR|Z$yf-kc7}ViJ!YkD+#^kt)$&0a@5V*WoR$rf|0^usmDrI{{{o=R?r<#Ir*D%gt
zm`g-14T)Bb|NoSaodr;y_e~}e6+6v848~(FSBicF&el2Qk;Gzavtuz5-6nE<f_m)y
zkWyD|ZF>99{g90&V&pm5syr2J08zTrJN@SZs%-(N{pEt0$EqmZ#wXBRpNovpJ|1x@
z8`k?i%k(c~HuZM5535JY3$U^vx5q{L(D56=|8Qc^v$tgCw?vs@fv35*Iso}a{C3Nv
zSsiof9b?Pm#s)XA^43hrWCWZgW~?Hb+lJx;CQkYbjO6x(My49^vJPZPIh(soeWRX_
z#PB@p*tErS;SnVxYr7r{!uU%i^(e0-Hs{uJ5lFAKaFzCbp;=(~)F3GWKK!)jc*8EP
z{mPhRY$_3r7`%modN3)164O6@0WPnM?dZiP9L-0ytx~CcHjsHqMv#l}Xv3gz`5T*(
zM|Mt(E5YRhqBkzt`$aC)%{;D!_?Cjk5JC2a#g7A>30?XghlZ|=l%~VM9*owR8l?^n
ztwfR?4Rf`@XUxwIcz&P)hxyqWYi#VN(PlkGFq*Zx%MSaQ>)>KJ!%1w<z4XCUm3!Xi
zhT5bK&-n+`8#aU+8Q(RW`hS$Yby$>J+crLm$W|0oRHQ_uTe?G$mX<E*?h=qt5L5)D
zyQHKMm>C)YrMm_g22^qw1{4O6p?+&{KhNIB`+djzJ3jtVN5^~JYh7_(v99y!6IJly
z0s|ww%|1iAU(0=)4t!~-y-m$|>2UYvH=4R?nguGgk`o3u{c8d(hXA#9;2-Dab*@e(
zt)?OoB)d?exb}qZwRDkPalSYM+5`h_PFvO348eC*#3B33hNTAw`I}HfN%7~uk;H+c
z>6ijIk4==(H!IRE%ZBHBH!m~)$l8sW;2c46-1@q2LG<Z$(BuIq#F<2LCk^#);zk4W
zw25Y!)ov1Y`cB?efFTGKjxd9&k+Ag*^ZLf{c+8YgjAGs|%T|W$ScBWj=b?^omjrJ1
zgdKX_ml=3Ooua6Zn&Uz>&6h0w70;URy8w=$X|6YA-=dg3%hG7mSzan!>ohjFT32-R
zHqIlk#f6Ga{OgIAbk0Yb0CObB-!?3N@C#I{h$;<siY$uycc@=Tkb7{e>7_X{jECJ9
zQ8k;{^LY|>dmaz%^|aEx(PLngamiWlX7A$u>Qi8A1PD=*K?JVD2L#$3^A&u0{$1Dd
zKx(dy_NCF&3WsGu=Kx%n`DW9S>i&ZxyJ<tw@S(ZLug(w6HtYJvc4yx5>m-V|YCn$X
zN>6ml%YwZ<EC20Z=|GTfRlG~%Yi*=p_Ln2dL>81GexVFl71S(0^`}|cIVOc$dC-bc
zK}Lr`Dw}+!EXZ93z>s4f=oxh8W%<hD*sbSb3ZIP|avfV+=ElC;m-ha`2y+OtFD^Ka
zK7sE_7EivBQb!&*ocPaWBY+Ib)<@p>ne5(9I2s65RO{nA);=4vY)TGJPR92ur{ygo
z3LnmiayHsNO7n`@9Aw{GER(A9!OmEuHk_r3klr8~f1F<fTrL25JB_#5%*lfrCmx{J
znB;@Cx%P{(pED5s^f+%c1C}cbCSmD??7eIlN0}pQ`*R|C-VZj!X`JgBsXKJAy+(st
zZ?*!1dHw;Lqy(_}VZ=_iRSLL6Y+m&MgNHA9pHNJ<&pW#LOwl+4YUSuE6B9;T0KNQf
zyWRt*bLoARE;){=NGa&~&u+M6qX5-xmL4-zp(C-D7Jo3!24dpC=dt6-W`U!Z+Q*c^
zjJCXvMjW9ChfQnHE0jZl)`<VY&6=xcxZN_=zlF`B7{IU#Nrurc?$H&Oml<VeCgeP*
zBdwAsd(Y{&-h}WeF}ip=7UA-IN@2e`<_B%_RoDwkY2HoVxHfaP7^iQgSm`=lQp}$k
z{3)n@P75%g({<`0oAX>LR}wMMMBBlG?YB(w6VfdMW4c$Zj*JLLA+roJjW%s+%vO8y
zWanWW9=<V(ffQYV!G%I6!`(BT7O8Ukk0UNYs2omGCSs7~K`6GU+vb7D=L-JL<v8ES
zsI{%)eVGzxdisgdG`L;=&hfX6nKl2wI-3i0UbhZDG~;#VDY9VX<E9^I`A?*U*562Q
zIW9z0d{T{O4=r*7ccZ`$705rPv>S3DZ-A}}PPpGApS>z4%xWwpkHocBhMMZ1!+#-l
z<oM)*#6UXeaQ<x<N&Fb&{5%UC+U&JQD=z7)JgDh11p&Q~s#TZwR@(NYR{SD~b>%9Z
z+}Yt+&0(l3Uf{0hDe<^#CbMabtFC?Kg1YKjWvp4H8Dw^b<uYLn?|=Q}_UYU7_Y|kT
z*Rzr&3WyD=Sot4a!4W!VL^(*U2@0yiS|h+1zc4%k^4uWi@byuVMpw;HiEcR~!t>!g
zLiltCwq%2wA%6U~V$h=|L&eUc;sLz{a@P3cQF+la=|Fv8vRaVdl|@*(3CdzdmXw=A
zm5z(<z*~Pe$N&Q^!ExvkGJ>F)xBtMiYQcRv>Gf>V)oIC|Vcq5~=^NEsfqWbn;~!vq
zKUldLW%Tu&e}6-eA_6oj9MyKL!PMA1!tCSdlqmI-T}y?<${+Eall|N@*&qAJxYA+n
zL-`1=`ax>jL*TE(_UVGGd>Mu5>QrJM;p7AdS3|v%3%`1*)KRQONnq_uxh3M`&;Nsw
zhzS@;Nl8hWen_pMx;&Qhr6KZKtmJ*4ML+JCFN!wq_eJTp+OEP1D?*@-XRPD~zIgE>
z)>>K??T}q0G0&0jdForRMr%=P2J<%+Bh#pqzU=fabNPFDO^wan>PBRq8jjN8*mqyL
zye+#nC7oT%BosKdO2>Ze??kz1wyQnko-CEMb^Gy;7ccv4#`XS&(`=$My|}=Qt*qBh
z$O~mg97<o07yY3er12*vx8r(N7>FR#6~66+gip4w{?6mu`>@OVqehf8CI$?|p1_NG
z@un%R>I@j+in`wyHBV-jHtGr%w-3EzQ`jCDY!tjjzf&9dyyu4f_F==lIdr_rHceu3
z2mM9DSwW^>2wY^V@!Pgh($dx*yMT)EE_Yg~TPGd6qhPfsm!A@F=$nS==DgfvpvhXp
zPBm3>FQ%C1jMejjFY9$eqP@E-BxM`u#2*U3k78oI%<H{$GDnD)ERG)E8E{zEzn9zR
z>pBvu-Hz;~Z9T4QP`d1QMr@t6lOi7PaRB03jy`on__rUme$lA1;D5zUyx^z=fgPjk
ziG})@J=&NHHOGFr5C)ZEs9{V2<0}0WZRBzv2WoV7(SJMhG#8y&)d1DTPn;=*t;V_<
z{YW;2EBedQjWH6T9cEQm-=c;vEwNQa&G))018CA~xuq3Z2HN);Hni3I#dmNlNye!{
zLqpID-U`R-_NB~(8D}7~dljtVGL5G-Qo(vpei8Nv*cPk3n5?O8Lx$9uv#B@kiuRGl
zn>))YG9z+3&OCjgtY0d<qtYtz)I0cO#1<K>6ziqaJi?Tybz6G(%;;no)PG=O#e46y
z@5maTS@eb}D*y8ST`~Kc%&5ASDWAq7Y}}}-ShJhoj6_%4CoHgW63&9T{Gxt@#e|eS
z2#NGFXQ8MrC+V08ygHo}Uu6UMvxv#gLrIEcO*<Q)kdS;L%~CT^)v3d#iEKF&MSB@|
z^VON?DcX_dH!6W~;`csCU+$8`GPTg6P*eGZXWNm}co#&oLpJTt+Je*QDvdADLvv2+
z#-gt07U8iFgHS6{5WiAXAKYUP^mzDUBaAutFv02I<6_n~y5wc%j+rH}o~2g=t40g?
z`4W`IfWBPsAtzT<I7l7t&B5Uf^Ee#x?}2>I`wREp)JdhhUggDHb_EH#BljKVOf3y?
z6r*<cN`|0wYxa#*&!V_lP2+WkYQ(p~Y}3*4r)Y0F975^Iz5AvJRNOH<t#9CO=?*fV
zEHZV>Sl>-80O#<KkEz~^8}gLeu{?`D)&*1BP-B$FcgHpDxdJ|Y&C0E@SdlOM+s*Fl
zp}$g0r<<$|pBXJ~qsdFty!@+PtBIW#_C9=o`gB(vX`9?~7wd31ezi{U)!#j3-Q4Hu
zQao+!6?Z@XUUxO4cyHkEW`%A0Jb9h38l>n(3H_Y3d2<&^=e?BR-Ue7INjw%osa#nq
z=&u94-g~!}m``<OF^t<jNX@9Tnf~|tg|SUN=h4)=?MTb3(J^cI-T7xT++5DejU#Z`
z5!BmG5bRIf{Wr{+2H7mnK~A28+vrU52rCEDxIBmCX4W#UZ_XDWFJwa0QeM3Yn`jOM
znbPmac|(KrTT00jjG;!8Fk(K$+#C0!iHd>K7$<q(11H{&T=0-ZW?t;-0%XT3H6!r2
zaVf7>+s4mkdF@S188ZJsiqiK9=7V5!l||yp`;w_&ZdG!sg~Kl2O$~`5I~zjvC{L5y
zpR5C_tNyA$yrFz!O%#6}WY~4zczwN>*IE&G@%cHp3^P(ps-$%eYCvKUpS3F|8iYdq
zzE<8xKC0C9F~CF74D&m)2)lE`7Cqi>ZNF!XjM&(ALQu9Q6mR~M5-$TSr=qshkqH6Y
z`~EHmH<fq=1t&(>Aa2+Hw4;EOJrxP|tv+hR8WeTL1>JE-1W7&zC6$RL!^F~dSKu8Q
z2~n{!6<^7s7h!wJG?7cIM!hUel4{xZM~U(%*;f;>BeqE`+}JEzPF^wRBP9MuvisTp
z`FsE*&p_Oa#qtO))7Q%YoA$K<wl9SqWk(AN$`>UmlI2y0l)2m1nYlVmmuMoy4e*_Z
zIW4q(ng!p}wx3Bz&lGNY%`Mm;G_FO~7T!4u@|qUidTktFw+Q7GE#VT&j{l3Gaou8s
zH1VDCFiYLwbtSdfL#t;#T^TxYw9W@_mDy5c?MSWC(;JXGJkFpW$TLu_O3}As=HrnO
zd_<|M&9IalyPs=3O*ylbX&l(_9csV-9N7UZeyMB`hj7GB^dEIPtv~lSy7jMRnW8Ih
zmv)^msFTF=a)gdrPsmr6*u1s6W5iT8A?V!bt*zcw8yKwfq{K+iNn?0rEU00vZkG3F
z?FN}NXlqqGvNoh;Rc~BzDAzd{KFSjMn=QzSgHThs&l64-4r`STABHij`&$EJ<a|jf
zoGtD}*$v=23zM)7mLG#>THr}Km;e=;#FhKbTffr07VvI;F_O;S_15_AAAO_S^Y2z~
z%P}J*oc~UrJAuF#0@1P&vGH~_<Ess{dg_zwY#!~URN!S0HG(d4B<1`I8?R|Hci5Cg
z7xNgo2lA!(@ek*NKD)nc3Hrt@7y~-Zk1eNlF5=Ik_p@$osbw2~tJJhVrdB)cn!m$A
z2)V#CoYiv>{SZM<@SJ(jK=R!n9Of78rCE<FaRB|q1rqcRE>~$tNQ!+Rc(@l+`9+e5
zTY<r7>gIx`G)zCmI4^I`Q0?)|n2+vv<>vae+1kKC5Z3|Gy7q(UzYPrrpoI(q$?yt{
z*WKGu-oqJ4irx8YLp5Wn!EIt_4W4$r|2z5i=ZD*&E!;=iV8lT=#-3-WXQZ4%X!T|L
zH8C_}oy`!rK-{gp+Cb~C$i);~Mx0pEEgeMn!as+>PryAQv`LJK2|pu*A>Ey6^{$-t
zh1ljm(BY?4)9sXqQKU>@l0_!#UYR*dI+2fAOM{{Cm2*U6yXC!o2v<Gl@m`rTh*Xv~
zx+8T=a-jONnd27x!%UM}cIRx*m2L(PZ0^<R&c%<g)#qx=pM5?5PJlZSb`o$}?0-8e
zb93S`!cbEB9t!E`t)5+L>*dq6Kad*><0*gtFbwwj<s`4@Y5K2AKB5TQc>hV6S><fb
z7OgblslYw#ZMIC0>1I)k?)1%POb!K{e502@PUMayrfYw>K>XW<?C)AQp(PG--!Z;o
zB0jXIICc}8=+A8Hn=!ArlB|;agsQphAv<F&@g4Mw*s8fI+fx4@pX?9j%yf!)CMq>5
z7KSxhdTb4Y%a14mvtTqytvWZ3ahGK&Hu85b9}kYf>V8|OF%y*ZPAQ>1G=zaVqt@R}
z#=mN4tu2TxE(PUIEQN0OK>xUyM|#2eOw((qt{K_|p@7`8b5QE>r41}Hht3(A$|__&
z3chVWqBj$au@A8SCDz=Ge_0zeM-qOL-}B{tk+Z?Hb;fD8y^Jo1Yao!@lZMVQisZXW
z<TxWqVTr~aC#GTvJ%7JfUhV}W(*;@;z$$z$<q;|lwnG)qhaD7Qjj||*D}lypKX@H2
z_U6Mz{;|u7aN_%ehej1WBf@$nT$ZDaYMXR*s2Y<S5~{gP{%Y+1ycb07hi(iR$e=~w
z3+8&J=>hO<{=i2y<H8<C3!e1U#+RIY6&v9Dkzc5}yQ#YFv9uvfw?M&Q^JdqE+1}AZ
zWEV&&W$SwsP?I{0;r+T$9}PQz&Lt(93|{yHtt1H&dFM(F1>}yZLm^Z*pevsQAFs_I
zEy(y4yB;&IpO8Vl|3lf{@5N})Im(cIL39J&s>>8Lj1qFrj>Wk`RlHFj!WWLu{Dnx3
z*c%>>w%2CKzG+w(!xQ8^BfS@$OLAT1-LpBazFyO>O8=6M)8|@RGGv0W`}+J5mbx+I
z$}yJ=C1-h{3bw&cEex3^%qAKxxay0=Vlkg@eqLXH7mZfsLgM=Mt!7$E0EG3OrZzD&
z9`s(Oea-m6ziZI7r^W8xp~M1WAZjyqUg@OrB^OcaFDJzHtm2o(lk(^PkxXfVWL7`v
zSFJER=nk1+AR0|FZ?@a%$TP~|F?qsm^2Ei<|4qUQ1L$H3m^1`!w%RA7FeA$i+?uDo
zW~z%ROn&0nSj;i{x!c}=!<*e_Gg6JX9YgxZCxTWBZ``4;Hg{`z1HrXEF!no_5Po@i
zdn?5`IQ*WFfb`1^)J{6gr{KDu0)uIxL9I&LA@?G7kTsUO<bFeyv7w>NQ_^q0*VAty
zq&JWSjSA<BuziB^2t?&DNy(bpOxm=ut=eAb28p-lUT79<JCfR4^@xN2$3FZrDz8p_
zw;dLnS5Q#7_ywdp|ERv_gVQDW`fj%ohr}E6lQ5I3MM^x~`56M-vr~+ACX0zaxYg+5
z<x_mUA3!9xLu1FCfjJ`l$;_UeSGXn|bC$TldS6WNMp)fohOBs}7_Mdc<X7#h=Vy-8
z7aEuN)#RJPn~C57FvqupIxVen@uY;F_|pnH@e5#6LoQv5Hjor$mAtAJUFCdR61Lz;
zhsIf;Gx+jAaj)~e)g{p8M1i2C8<So~7DwEZ<=+Taw=Q@2XqJ06J7zFV7W8~HyB|bR
zdpEbP?hlsuI>-fi+cbsiXYWRwtlAq5{yo!~IE?Tx0U?m)^3*3>L3&eF%kQziH*za(
zkSl(WgI^4)f3YfwD<q!Pyu4)wRS}GxD*c!#wFaBZE^-wvo8(aGMVE=%luwZC&X#fI
zIcMz#m-*FKl!ysinksnC4=v41ks_tyiwX*YJ1(5gyyLt@@PzrXpqp7+b~H0DvX<-S
z6O63x?yb!{c44ZiENvSvwbUoEDo;tDx=7rnnhe<6938XdKWSJrxe@6F8X9k`{Dd;x
zI4<3e!3QCZvS6xhO!&38aNB;zs>zAyIr;#Cu2wW<XsO*lm8Z6EJZxa*3IXI6MdTNC
z^nCN_dYwSqs>_Qx==RMYQ;BDA8e&V-J)e4$>N72(Vk%#1Zsfzs1}4q@q<S`_rLk6%
zlJaUpL2uyqa(psM`e!Y1ro@pKmLy@bZy*IR!h0BUj{?A6$CA0uzu%Gdw6bz~k>jOJ
zxlUgS&P(6l22^cfQS=8#=V;O67U*|cc{R!fJFnvA?^Y4t-vb>H;>{$up6F)k$6t!D
z!f{d>Iz>YWF758*hDvJEBQej-XEAeCSV!e<@mD*0G$%@q7uWdKpzEvqv9^tz!I>bH
z^Yc3q;nD%2t!w$^L(u7HZ)XRr6elZiD6p&O;wl{O{RF?PmWa>#Ui^w;(RCHuq+6K=
z?9Qxl9w6<UKV=zv7i6=y&5Kk_DOrc%G`g6>_VHi?qi#g1>@QxEdaTM?Ou$edOR{k>
zLN6;*v(nnDTHE=1<LS%ymR&pTb0l0WF?Iu`Er^JcKTDYqxysOG14(gCXR0LTS<BXJ
zV+FASR?+s|el2^77hEBJwZ0a{+3QoK*_Uwrb<&H!aRkWoR44N=S~j9!IE-e@5gsUK
zB#)H9>Lp|s4hb}IFPIJu&KX&m3A`2Qy5JzU?<g`tIOz~#01es3W@gymm_3DblTlnK
z#a^}FeqZZ1wN`JAmcjkr;8=_|)#A)FwD2-?=c~dxs8^gIG#(C|yDyDj;0<i4(J|XZ
zYxK`hxo#I$v!gUxA42Q>jBN{398H=nSKx&Ho1(zL2hBmlzfDD%YuddKQTBS9>JrWz
zy=DxpJYOQN5^CqC&7P#7imAm+O9o8H``9w5Lkx&ER|sWPc#NWZ!1F!5OqNWa`&E)q
zeZw1Z&$SC9@@>wh@GQ7I6!!LAB{eChR%Wzm8fcJt(b8g-XsY|9*LzuFU$Ku1Z@-y0
z7i@O;72mppD7nuf4K^d|1ybN9X1BJy*q?)5@zjnGTI;w$fe#GM7!fyzdOz|H64{^U
z>KK(-|Gnv|qag-;BnB0snwmWS#Xkr#sy5qz*9?YBc|XmbVP>&uQvEbkgt^IUvi1C+
z{TPW$jGp(OdDs%NG5b@KYp8Ot4zVy3CgdB08q)<1c!?MzI{oJW-T-@2m9wMHEIU))
zF}ls5YZOtC)w9srnxj4g+~WCtrmylmY)Q(8VNl4Z9(bsGaEuhPUOj->CW~~=^&J7s
zsB=4L_(f-{r7H;6qH=>#d!C!gVhdwDh~r2#F5{%wO8d>vSn6olvl*d@mhAY`%%Of2
zLEcC^znQhqT(!r%p4jftLVWo(pB-Dv$0~S3DgA9!+S~l4HuTtCA{jA!-)rQMH|(}h
zU1A(&HmJoVHEC&S%zk^_k*;-2VQ-GF{HRs0RVCO2#>QY453LaLom;f$;F-$#`jyhN
z{WJ<81tlEF9ZcP1Nucq})mWcLWj^m1Pfp&1LF1k*C#StFP?hVc@{x@NA#@q>djpG#
zQhIV)$+|#$^EWN}t;R(pk*l==ZrWWY4FCZbLFem!Y~o;Rq<p*HP_kpw@4rm4V1;t@
zR>h|e`}|TKC^Hz`Sx5oUHc;jbO%T0+5~b8V>^sH0Hx!NYIqHUbtmQljla$ngH&ndY
zj2n~EE_}11QTwvfJf{{2Ejp@loK+sBB7TK`jM6eOe3Ha_*H8!n$j+qTC%Q*Q7@i{R
z!RQuz?Z`XX3g;LA+m=^1vJc9mR_6Im^e^vp+9G~>X+*?j($HH~aUf62^O3`C)#x&3
zs`wwfUpB<&V<&GiD~wn02+U}(3SL(nlsHcbJS&Sz*J7B<x;+9OKyJtC{@V<mLB%;<
z<jBuaH?W(AHq@hc*pGEt|9w;&cv8Qv+E93$NOgqYjo2LhJf*8{<bf;iAORK8|EL!=
zVgIop&K$UEkN7xFt3+^=iSj>Kg693AYlRrgdE$hwQ<rmCp$s9@_I>(~%+_4SxQHa*
zPIsJ)E|rD0VVS6I&Dzv}4!+>o9lE2c74@;*Ky$PXe)UHmKOS@ueax~u$RM<7K2+&5
z{n~Rn>yh&r!LnzH`zps#)6k$VLE`d9>L#*2Exw*X<>@xw>&bz+ZY|CR7n>PUC`VVA
zQ1BUQvvLh2dt~6qS%Gbi?gHTn%q{!4v`CixQF!z-q-UsHLj~+E$4jJBY3k9ZtIaM*
zy`9g)KI)CJBM80Y<~i*HJ*pFGxKE%S0|h84CXXN2&@L>5Uit?y5ITn`qT~tJh^XHh
zVCmuw<qMKNEuOeWD`HtbadP&kheI7NMoot23%=6Qso)bz0NW^X6NH(8MR4tTEar*c
z`p?#vym6-5TDgvnH!-ssyogkLJA{4__dH&X5OTKGQDwWhJcrL2dz*H)c8>I@Id3%e
zoN9kxU&XhM|E@+A+!BVk#R0wGFR{`PXNJDJebM>Al4aBVrIfvn2C#Ly#8Hzsm80&m
zC3MtgLvAL8K^p>|Y0Pg(<^b%UAkywk)Hx!~?%<{B-K<M|akWWc=itSFe_wQ^<9%?W
zk;iQdR|BOVFYQ(Dd5hS8gj~7q+hsOx;pNj|YjAK{bqon5*n%#`v?>QW_473Voi|(R
z2FMo#T563;`o$~=_dxCSND6fB=IK1Jx7H}R{92Iu45yuVo+W-B#Hl&0Ds-P1hD6O0
z7Z3sLjyo+SVmf$Fbdx}0RmE}h4gx=WY-GJ;QduVif6{7jVxDPO$H`&pxbib^M*Js@
zx{>8ly3W<vZkkig{j-*_M-;lw3tE`EaWQ5rJ$yzwX?7z`q&{Xz(NHUg^6bn6$U-tv
zRqJv=^4m2eDzeFUSA+2lxYgC4ny$eQKI(6lmrTqjJz+<fKd}_UWYSI|eS&0zZ_V;K
z&$Hzg;0N&JrQDT-MS#{~1w-i#`@WqUAd48Yb=t@d`6dT8<mrnvMSU!N@^0&uab~zt
zSN_HYRjL!uYsYQ8JsLg+FKRhi%USP(^GTvqJVXD03-VZSgBjNdCXIOIDEMC5ah#Rh
z5+J$TRRmAe!$>AVXY{XpAmabLNg{+<Gnv;#SUsC*X)PC#6&7w$xNCOD(R7o-IeS9G
zE2aoL-ayXrjb~wi;36QOBTxIvsHs=a-Fa08rGBl1UC>ex*q`5ZFNJ-q4dxV$n;dLg
z2!9@Y!LGoXSibLN&wC&DmPOk~T!Ivzuc|gw9E(VN%qBZL!J-15U*Bmy`L#DEOzFY$
z;@n?<vA(`|t@y7GIwQ*LA7C=haw5CW%Iusmzs~M@;1DFz*pB%aT_a@H?z1l4VMAF=
z!EqA<`)j*%Umza5SK{7>&F-~q9~5CA4?v83$`N2G+!1c9cy<v6CK~Ye``WbB%xCTo
z2Boaq+7@cbL3JGdiioaPdtg!R(oJ1~;qy$eh#VR_cyW_IT~-R!yi)0(zYZ1ZbE;l@
zp<OY7^?Mb%7JKG^>_mkrLKm8rocJt>*~+Yog#He&YNu0vL@r)1#--KP3izCLdnp)k
ziSDOjflb`x@Ntq=x!zWonkllwIQEMZ;{(SLwvk6*w2|#Npvdrw5T+f)>_qHXI47El
z7#DQpe&a<@Iry$N^wV<n&=%Iz&G^WC?e}$nV+u1*^60Wcos%y67NV!$!0mO{!rHuB
zepC(z1Z+ATMSK)|KpB0MS$6Z7k@z(La)i;9%+Z}@eURZ8LE_7aeg%A$Uc)SOIC%<~
zDLO=<<U+>mZiE;ETyju7L7quJA)9rH<xxeUYIS@*aY&XJ?WNU%28U*SqXIpQ!?@Qw
zB!fyE%3|b3aVj2OW}X%wcb8-cMyKHrs@mYVXNHqra)mZF-M4&uTXKhaNkp4u!Y3l?
z{TynWV*h1?(LlD;S}@y$WH{03wbKwEz@t#f#?76?sG22_nt4X?B275ienIG5x5jc5
zqa8WkuvaVa=VEINr!6C!IJ;(V470rg)1&iowP4~1OSt*1neW@Hi46`%H84Y0;qej<
zVWlcXJpR1^SAX{;e6%`Y$*r27M8E$Mjk%=BudJlaKp4sv#jKx+mo9p)E`3WXKx3}W
zVnJ`OxGcz|)Ndc{DIn!|mxP<JYp3(pN6rBLHn(eGmt`k{ibq*=e&1X0$j*J6vglN=
zevz8xq<M;K)D14s&K0Hjerq<#t~!a43zG3TDmQ1&>Ei^4x1c|?LO$SVj=NHvflZE-
zzgkc_@ME~R$$I}82iYU;qt!kZ=%?>}KFPt(-TIR5Gvoqyd0jPJPGDOKJAO+G<;zTB
z;r7d`X20rA6BiIMK#vM(=%M86&v$yIUh-4r#@ysK*?s_vDDqyPAL9dLTs~duou&E$
z+GH#E784sJ!|4G-8R&=fugTS|M9@zLM0sDlWpXg|ncd#Tqhz_j8jVEDCT@Dv$dXji
z4Up_a1`gQ|<dP#zvaG!AzoxuuVA|uG<_z7|ogzp*jq;{rV1^MGa5$x~2rKe@e`*kh
zFMv(DvP4c(@=HbMSn({ZmqiC(pq!n%1@_4~XK&u9kip{y)(xJ3Ns?#O2fMW-7hiip
z=vpmg7}*}4J0ub1U(=%NDnvWkc-b3hWJ6O6(qh887~R0mrJ|Q_<G>16xc#$bOBbDN
zc4VTS(3<ytCb;6)4JuoV@4~Ta-mF2Wk92~t)3A7BFl+G+`7N8M{Z?wBMMv7xNtzH^
zA}|X+G|l{03AucHbxXHMT#n$A35N#PYc+9;RkTWjWWG>FdoG)5pA;33_#EO8DFopD
z$Sd?OcP&F4sCwgbKAA?yq5|~&Dmscqi>cTj4~z?I@g-Q*e6l2YLD;s^(co2dulGf2
zEXyx-)ms&2F(&z<RNCivT0}JVDop2h0$;V4yHZIBZmLBMG`$TyJ<Skq0-5{g3sm82
zXSGyiN`BE(=^Zc(WtNLM{ERr*XrAF5)hJ59zMbtALEcarT<&Ca;?ImrT={%Prd4}w
zZ|$hlzj<E2XeY`WUt6!4>(Ub5VKK7bQ`{iIB<rcg?<N26+R!mA<E4(_h|A(T!!Pu9
z4s$PGEImS67fn;_jA`m&BI@VgkBQZt9O6rMPtXG<(i&4g;c3!RjxEgOCwECsfjPwF
z(OJso<=QbdOO_myaPyDctaQ676E7GR6g`AIj25P>BZ#!>=$kgr88Nb@Q^aQsxEmM_
z^m!=@wR|MurC8l72|eTN;xN3tEFU;Kn?s(yrn9!UvkGOdr|@=HZs4YhtBBMd75LK0
zw)gaHYKxo95dBO}M4#z|!sSMBDfKEbZ=<=T2FEWqlzkb=@lsO;Q29-4vr+g6z67Uf
zKR^8LkmUFGv!DG=8CpZ?-ne{2GUBM=$N{z2M0Yzh0`GW;|Co8|<wO?lK%`~T-_$X3
z*AAEW+3pRaX@poo+3G}1hw;sA_8D4Vs|+U!GkGup?UGF5nN}fT;nju0&hEPU2M7Ks
zWr_Lj73WMO7*#2Y@-Z0M(S(i~Clc%a!zTOIW8>qbtP1_2w5Ooz{&j75FTx~0Kz?w{
zO%MM~dXMw~nv0VP)ZBlPZe3*6KSpdB#8o=c_TZvh)+y)n9hVO@ir+pUo;90FeI|Ns
zerqetn~^Hu$wL@-+B-@AkL1eo(x}4g0gQLW$Jwmw?=5i_ea&!Dnkp2lE8qnj)H%Ot
zU&*rn@~@p3%XiLVcHR*{$1lrc$#D_}j`3bTKduZYs*Su`d@}G@ZR9VO?6Ed#evTt=
z!@yP9qXLg+A%XR^+KnqlFO!x{OXybyG^6<ixpxC<T8&+U{A$=~grNpL4wJqDmN=qn
z!)Js1|LpSypg9F_Q|q2mnuH&pcwTbYCE3euiq~LwStp3C)es~F_?)X$zEu)-xD)5c
zpH!&S*gD*;B*v}ZFx%!`K-yJL+B30{S}@<gMci(V-IBWoHIh`FS&n+=>o3_A*moq5
zE*V#*`j*kLh^c_JNB*J1{jPqZ7V7fyV|~X`=}AlkoZahP9_xH!fsqH#SSxv}qWx}u
z-PC-zxt-q5eC_wrfF<$?sDTvQ%KQ#ARyz5s#nQKPB7aCQuLzG20p{W$b|<jg_byCy
zz8}9Xq2+Q3b}5`X&)e`?<tL@7&f(9<4MwBKd@vo0$q$!o7biQ>(cK~g543JVexOgj
z9tCCl{7!?8VMfR*6~qGvX1?#(#mtxHxF5EPc^Gh}Wu%n7{Bk!fEv1aAr#S7K+G53}
z&<x<QW{gWdlqin+XfJGVm+$S2k9j-JSvT<2$n1(V^wy5R%`kghh!+iTBxj8QDlPSd
zBdV_<oanR*Fl52a_=0ikd?nNo0fvApGBGiM`SgTg+w#%0#qI46x%8`KsHmt|mZJ8o
zkutX6MO3-oOzK`hOxfpQw^BT`Kc39Jtt-7&7K^-E1Qpj$u!-Ru@=!*PSd}9?lNTXZ
zDx1E)-`x+KS=hF#94eIzs`T-b1U}X-8NpC_Rm$9%$*?>v?tNLYlI)ZBDP_fPWCcbt
zStAlT&M!PDXjOAXI3tXpNZbjT>xhf1b@F7NPrjY|;4A#zcQeHAu<!2Bq33O4&Z56b
zoJ*fS$*qD9Y+0=+n(!SD^*+w{a^^I<_}P8U{j4vd!o;w_s~F~toOB4Xwk}}j;Mf6!
z(J|z~ze9B^jEhyc>ledX&@E0hp(?CtPR`L}s%;EQQ@L!6f+SIDNpz{ZVI=cG)vO++
zKc>z(HRLggI@(J=a7;F4v^)dhU6Xx)-8=C5yg4S-suyr%iv1-Q-W*g(cK(p105zfp
zXJ%qtdl$x-8T&pTyrNf{xTa7=SrpC0i}TIea1+;wpbEI7Gy=AKWMV2jvNo!dN{n|I
zd~A~DQ%F1cyWx%Io$-&@M0HF}XiRNDqm>eMJg*-AmR`5D`pVN&-1F_+>Ij@1j72r9
zbIa}R>tj;787T+ato4F|T0pNQ)CDEx*KDezqk{$m?OSxq4GX{o&XcgF@8Er#d4SBm
zVp3=2d)5&roW{5#Uz9GZ(3|ys@iLY3GF-VqzS6}xnmaO`ypbs`Ox0acc3rDPl27u>
z)l64-t;uaJ@=uXG^=BZN$H694IEDC{AiBSP-&>MlG-#B*k~)7&s(x>G$Xmo){$U)m
z90k<2E?$85uBNP$gdk&<K*V!=zI&yR(DP!|%Z&iIs05<RS0^3wXRhrGykl$N!_eNa
zd8}DIK<9h#sckP&s`8n!c!@5@6$d-G+6M*&{;d<Ze1Tc#i_=K_^M&y|*BY1R9bNtx
zVisTilH8rLOcOwNmsbOZBCqWMVNCPhoc5h7!>Yol{Jr^LGjQR%>nQx7+8Nh>AQ<i=
zpd64E(QB)}GaBud&gkUyQb<UXM*YI1rBanrj}Y7RZMtaoB9RXlrtI1Uzg|^phb2&y
z#nMYaAj3BRCMtO<llUTpJv2z?+}V;#zjdzSO8KtX2}<4inf=~&*hj8<qEH)kfqGMU
zxOn4>ohY9gTzs`o#Nt+X?_mTKTKuGPUudmw_%8O~w}G=WyN)7C`VH+;?`UEwaayuL
z4yhK)7gQoF?)qPXj`QF3cC2?u*-On>@<Na7VpWSSgSeO>smFR{lk*fnsR=}ydu<|N
z!gJ4L5oW>7j6G<tH89d~^2-|v<Tx0tIk`Sv19hF3Qi}b8*;?w0!3^yBAc={I!SHEB
zm3apasD@`PZg>b5vD4o68x;iCQGUy85HW@1VL@^^$5-=?DGBwsFzsK2tftC{ly&6h
z0H-{0F0_P<_zA_Ok7Bppy_1dIj}0p~yU`X>68b_a;ATJ}s)Bd$T$E3}U?+OActf$;
zr-|c12d!Gr`|Gw%=B+*f?9e`=T$3yh?9T+ucHt4hu+2R6j4>0QUY;yV7{l$<j(OYT
zQ`0gM=##sWgf;Sxyj_cHH!demw&Xso+YS^H1C@Y9RPK1#C)$kDeaK)$9UJUZs7sh9
ztqf()yPVaDyGB9b-9_iS8X<j{%V<AQqSLTFC~ghkJ4{{=oEGvQbfyv6oG_2Q<~(vY
zO+<D5sbaN}n1N6JI^(a4U}Rgkc{c@FDfjhvWOpaJ5-<<jR=rpY)ij{FPZ=N3T>L0?
zeN7LUU=Mc;>nPx@0Por$*m;9WUK~Y@_3-Rl5D{;|$lk{8P1v<o8WxQF3JQ+eeH0Hn
z2o&T~`#f~vTAA9wV^JM5b#W8QB2}#iTPbx-y_1w>+SUuqiNa1AejO2F<G5n4{v$`t
zpc!ES(LG&jCe`IX-Cf@pF_XeK!E`~x)}Ut5=BI5h)i9JdZ#qm@TLbCWa&|74I{evj
zTRH~DgY5jJRFyS_@HAx5gECLuv-B0voY7Ky9gPxV8)2_^O4_CPG{WfESA8z79D<J}
z3@+C)G^7@{gj}FD7kt(3a4};17FjVHt(G=xexaKPAKlwQQt(mcyuX;CFf)}AJ=x9-
z_DxK(s#e8VfkcFgpIVW;h;grHL%(}gM}cvX_61!UlD<1Dmk+$V=W}FV`0EhgTaX?3
z_2A^YT{}$v;7HKnlArps16>0FHv6!`%T%TIJ(fGrgim4&?vIR_oGy20c;*;GvocG5
zIq7+i-P93u)ok{S8UGqq*O6AH9l<^RWj$E?t#~#O%{K|aQke<?YzsW-N#R@RLe6nR
zEAiLsd%b%T*fJ-58&T}6tiz3)EgVW<;{s#iKLRO;9!hx>X_HU0B|O<<%_|_mKk&GU
zS)VKRk(1L8!L$t3*KA$faChV*h<nZwFC=5#%cT4M_51BxG~s8%?*`Wu&{7?|t7`hb
zdW9>%qIWK@H;ZgJAgW5@yGA;~{!+vu{hc?H8&!(Ewc-iRzN}r}-%*JtF1WEGzmK~q
zFdC#|-L_6}cdq_LqC@GRYciaNf3M)(w%k2D*o0qgT6-!hV1RVfimRqmg4GMkqp2O~
zN=W6^blcwZrlm<3Dhci7Y%p}(UnHL>8S#~gIzC#i>oF^opAVYY-(|hxu-axjSJ*U8
zDj>A&5T$$&P78Y^bp^6Qi0c_a%E7%R*_-1<qvwiRjf8o77&j{JcR&A-K>Wu>AMDyM
z8f+iT{dq+XbT!R5@@-^m9Eh@0+SJa3P<*+6=@ru}qfWl-LebP++%d(Je3yvxWEJ1O
z8$eH4k9@jXO!0(dr{CJa)+8^}yCCFhG_%p=eWTuGk+?ADR9j{n%eDOuh2>YGv<-~Y
z4%*?UipPzzRIpW%!VIh%YuCmT7(-mnK()9PTz}fVnbj%m24DL{YV-Z5oWt)q&*f!~
z-86z2Sk1g<=W2OqUnc>g-ZT5{X9OdT9LV-3Xm^W67n51m<5_%6rz)3+W8Jl<SX@Ph
zH+TE)+opBadkP5MRiL=$=`H_5F*8=+A%jWk%+_>Lx8L&X9wPQ2l8)QN9jX_@sBiow
z$acl$$(?c9)acYr(#dWl-?@^d%es9u5@l82rFny|8&V{ud$h<G4orTmomO_cv=n;U
z0wqJgrh9e|Ff0i4G04AL9TlsuueaHM7WYTivUer(OfF}CoJKM#DbJ>jM?sOMJysbx
zrRneDKaGoA-7Gz#{N(k0DQaPMO>OT$X%=xa&$iMv<Gr(FOAxxuT7?9Y(L{>7M8$$l
z6n9+th|a^0t^VA3Cv?zmXB)}M+xITdfl8s=%4@47%4f#4wPK_IyXr)LOCGc5NZX7m
z-%Y%#z1RI~BrXN&q=DHPKx|+*B*k4%o>jKhDtgF~WL8c29C9`{%_EU9x=KEg1=t+e
zHf?pcIkeaOQ%b1du8!<ToA2UO**mgk_YB<n#Jg47{`=CT*nwp8TGL6b`TG_YZ_R_|
z441<#rHVdnBTMJEN@D5dA9aSeU+jB-_2`W3VhwHd_?s3MPca+R6armtIYUJ^IwKB7
zpd5P!aw_R2Ypq{UhO)4KUDhp;)TG*7?Ea=0H}>Q8Bu;sT%g?v8lVd`Wojg$`uAO9V
z?fXf#IhDL(_|>G`_wDkmHl~ja?!Jm*uwMA+p&yGk@2J$6s(k-lPlQ&Z`zIT1W_15H
zht+R9=Sw6f_hr?r59YFk94!0BOP5la8@=7kKAm2S`z$kBes1G?N5sI^aIVRLj*pKI
z%)q67&s!a5jRd#N0rbk8e4~0Z4_Y2EY4`TiemCWd+q)MaiVo5=?I_z3ljh{jj$c7@
z`_Fx`&&VE;$ORd>-52xv+Q#Q&o-X~n?2WQ#jJEs_Mr)?b;{GrEiLoM@LZy+Jr{GQ|
z_$Z)7JTW~jt-l(Hf|}WNO-7ouHsY(Xy}in+=|bgWVmz&f9_fDZEDA2)b&ZT1=k^X(
z_k3sUi<II37}U|!94S--lh^^P9FyDz-JIz?F%}kuj_}Lzpn(cpX>va3{{$$#x3d<$
ze*KDd>98-#WQHTTDiNiCjKc?mvr2!N`?OKdo#0YMOmB)N+$~}<Qd5B$Q?rBL^i;%(
zS<cESdywhL$rZ4(voDq=_cA7;BOh$TJD(mNym7WjSKAfR(bMa*sYxBfQ6RqveNuJO
z?m|8>F+r_0kElES`6$zMY{Wf2Xl-8zm>|qHUHw3E$9JGCYDHt5a5%;Jhe*N#+&m1d
zwO^JgKl#9+qjqq`An}fwr@m0%mFYzGMkcxF)n`9`doKD|u@A57qV=44Bz=%5WuK)_
zMrUfxYo@K>$my$);je_5<Sx6!kt0zgZ@CR?6<u5Q3mMT#MlK_gd$XSX-gD2lRk^_D
zaR~_t`E=qwxYej#xxev|9yoeae{_Kw#)EVz8fE&tChj?X#;PnFRnM|O7MJ9Mq<X$5
zv%Vo@;6JOza}IW9L_I0!Ij3S0#o;k0%ESWQEcvVn>40u;sqxzCj0vQ)R-uF=Jk}A_
zwSjahtzx?S{ky-L4b+a4sGI9n-l^ruV}`=Mdf;pqyKUP%aI+~U)^F;I-1}NblGmOE
zvKbb6(<H4P*s&RL#Ufy7ePtt)oaGp~6+<qr%CYLh?pi_otVQWphiEPqwk+>TORi=w
zuf0hj1M5%v)`_Y&Be`a56?$X$%U7TY<u@I@0@DqK9Nc?tyyZJ>rkT<OeP-Ai1vSZx
zs%c@2)12Jf&rV}1$ggrE>H5dY%6xq$%^w6|rt5grM6$C{x$d>vF7u^D=_(4sS)Klb
zaIa3rD*<A>fvsHGh=y7<5PbpFG4mp*jtDP7Kut{tqyO+xf|eJ;e09P+{trYb<!{k+
z;**@4^R2Ban1n<+zuRMV?hF2h@&K}D+ybM@u~JW{Pczbl-0I)oRej{e@j^W4@LA2_
zS4uP1TbFKoW^x(9QkE8!KI~eb%Fv&M4bwCvewJLx@Lcq$XH*&(7+~k--l%OES{Yj&
zNFP9_^4sqIj`}~pp{lIxkoXrMg-|WpG4orx0fxsZzm*8}!Q;@9L3sc@{QchG7u<PA
zUp@V%XP*p$HtJWvK#EZp$(XJ@Fv5N~qh+H31H_Sly#Ku@w`y<k7vcfCPMHB4^>O#$
zY^LDrQYVMoy558!rsJ}(-R4|#+&#U|+$IgRC<F%=7udcm(K6HK2E>f~CSab?CSbL*
z1l04NtTWh|x;JF{mpbk@G-??bq*m1ZxTy2w$s^M*79%+Hn4mw-4ydOis=<5fnM538
zBdS8DRM&p8%mCY>Yj1B~ilnJDuGb<3jBAOon1Y-fnWd#AY9Xf-spH?4(WeErKkv+v
z2xZ{_oD&WMX@Y42_Hm3o_b&zhY$L&A%uY%WrU3(wb8KvE)<zWQvF>M~t<XQ|z|-%t
zXvffB5_g#uIoi%Xd7`Nq`}XZyuwfrcO4tkX^X<kzYO-^3j<>%eO^l6oZ=d%vgGFTl
z0;Oz5Ho%vh`G+&??~)04@7YJ<>s>X~W9ae2{cXYE<HOsno!zkv-rqjIkg}&~E``C8
z$hrS3F+kb~(1#+ks`@l5^5<o8f=}7)|NH?0IRd=W|M@)xvdVHwrv3K^GScR@lsWLl
z#YG_Z{}JH-6mV9-7jbFk9pRt;Z+{2Z_@hvS|0yKs<vDJDRVAf2%F4=9SO0x{1f@{*
z3Nd2MBc%0w&i<ck|MrIq>(7e*=kf?i{{Q~q3EB1k{tT;6O%tzj0Uo7w0^{hPs?&eU
zJcQ~%Gcy-g6zDG`DCIwYJ^P5I?$v2?-k<*oN5SYe;`lZ)Qpec1|No}Ur}WByKQ$-&
z|8Z-D6A}}PtEx2Oa6oq0goTqc&;HN#e9^4?-(K?lpD5{c0jK-?-wl8emVR29J^kqa
zZEd`lI-UyG@<>aYwLR6)E!6>}jqC3hu8>9O7#OfA^$rduP4v0~zMsF1+J9t1g!;m)
z+B;fNt?zCrbpLv`9ykj+&wAsn{pZ!wPQCs8RuTWKQ>6HRyrGNCzZB?ym(TxI0RA8L
zrmBW?`0D?EzA&`H8FGu&y|lLW31GXZ0FkGx^L&d5KuLsH)Wf4XoSeR*Si5MAK$!u!
z`V>gc+;O?x0n#(2(kJ^v%edE98EOH;qS!?UFTVqrMvw23KF;;VOcpma83WENWp#DL
zaIUPN{V3x=3a>1svD=I4ni}+dh&v6xu=7klf%9z!jP%>xoUiQcl&?p*fJdX>@edAz
zBuE9wYt|cci(Qn-CVlmgosCV?-TjlO6IkC18JRc&c_JE+ZpM^up2t%}n%_Df!4?g3
zL~wJNG(17VoH12uy1Ge!rwpxzYcE5H?z%Xm8g#%a$5^tTj~3upGJUgd`>);wR&vAu
z^5fXJMl$>P)|-l^E#+4o=AO5KA^Fn(8dx?IAXy@CWJVkK_QWv}$b&M^-`TLR0YqOL
zbqi#GTI2)(;*mTB3}66_DpXCEk2tf+U)h2$Atbr{B(lgb8SCe`>vINUKg-d8S4<Q4
ztpE;{f#l8C59qNX4j`8k6BCATm&_*9O2(e=ZgwEyAqKn&$#W#+zQzw-U}%%LO=cYC
z*orbfT%cfPm6SBu+1Z(?wT~yeEn&w^53D?3_9F%y31jw<AG_dHz$SSv_mAvikwyb7
zFGxdD*yu#uWaf`|;ed_BEOomxn$9uH*I(i`7714e8y4TS0H_G=a9b93EsQkzZ5uM(
z;p6A`?xeD{`~CAf;M|-9PQDi8qCEW`K70wBP96}9QFjRb3!vHbKET3#4Ogs~-Fk@W
zXy6+1G=LkXbU&Ah*CLES$fcSl&|_?>t(`}pJlbsD%R2ia1W;HpHv_T|Kn+PZ>`e4o
zCekQRA!gFI^}xi$b3l+<>iM%$Yk=7uC(A~Lf_C}+ByJ}rCu1g!TqkCrjsO>}ia^|{
zgpu3b3^6G^$kNId!{C#Hc{C$1IZ8W5c20l?gG^lM(Ss*DJ89CvEvZeJyq4jBW=SeD
z2#<DN!yg5eo3)xoMMZg0htx%;ww@eq4lI^`wHV3tohv^19dn`qUeuuL{-tu0MqMB_
z+JS-161QUjAmDC3#$&u_L!<<~Ry9Bc+d#YU@yKFN{0`t1!2r`2)d+-=fg^&&qWM=R
z&2r*-wIXf6Z1|{@Jc`lU%8EesDO~xZq`Z7$6D;`*N(gc(zb-K|vm8*;tO048;DXPN
zGW&5T0aG=<Kj@1Cyt9)TaBx?$8Dzo0gX<&^PD2$Yjkup3<SKC$^~==2l}D<bmFa(n
zU*ZY2H|6qKO4M7Mw#{}H_CszRb2qHs8^{z-jwZU|%j*gLt<8QojmvOM5H3%*$A~R%
zDpS}s>-O`X4?O39z#wOd&qMtC<S0$@qiBTJ#?+-J;?<>!vkw<p8h-zX3}AYo%>B_3
z)UFa)vYxeb4rNQ5QLv~v!A&hJJ`fbb(;tZM#q*&=FkoI3-7!tugJS>^Sl3Jg4I0c4
z6$2DfMwxfc$Vg;4-X6Gri9iSnOew%bW5Gv=;E@La6log4T_((qw<wjgTwE%^(%QH)
z1J24ceeDM`&$08Z^BFB`C8c8J!TU?eaOI7Sx#sjiqG1+bUVxBL?#*Au*)qDB12Z-X
zNVNvg#H2U93|oO~0@rZk?zIN}1{+6W1(a)QVN!G@!!il5E21TU^Hx%q+RvB5uQDi&
z5`+#Y>xdFzIRw^U1Ji1&H*xXt=<C2Rkj+GUmvJE0eHz0rQCX-(beM}>f$%nxx6-T*
zDSm6OwI5^Ne-0A2W<rls`3lDHE^s4|xLx*Ik8rsI5LKw8%U7vwq3ah%{2)K1Ty6v1
z1gY*;M)a)b&;%eGr4#!L*wp3cpFV!<&fw<c%$EgNLi~MdDjOW>thPDzDQ^r9Yz8O;
z@fC?T2ueb()Tkf(5*^W9FiruZ0qm1l9;e)CL<RMG4@zu5u4w`kJ!b&sy|i1m1K@Vb
z((J6U7`e=B*8sq;3P1-u#4_=K9(ZCc0syW}-t9=977bb1P)0T;COM#%y7zC513ia6
zZ9A))$|q;p`A+k}gBKNz8)B0Ci}B0JZjdXkykp<pRzE~?^A*tpt9okoD)m3LH?8d+
zZVw@*K3Sq=AYay{@Gd#63@=E>lFfqblN8?F8Y%F$pg7aD-G=Uioq2k{tDK00tQK!Q
zQ)W=JDgkk)6OMfQ7Kg`Fs>A^kSn_M3YfKaz2rs}eM$I+^l-#h!jtV-!5)!IpbYhIa
z?QLy&H1A9rH2|(r0mn(sKs>tWRB48c0i}{(zz~Qt>~`0u4Qp(oz%L9Sf(FlA-9eZk
zfN3nBDAiMmQ<L0zQf^!yH%KJYzmd0j{`^_-2vS2@spnIi<aA=SDi|wU+w`TGnVHjF
zU9R&6RxJ&#I@s4Y28dvlSI)df))@eUmwj@$5|^*7CMpL<`Owf2g{1f;R99E)jz!+&
z(gF~Y(SEkh9TZZlorKb1uJaXOX^L+T?S2A{hY>7#ruU?Q*PW0$u_0PvmkiVAzvQ?K
zsviMn(&4%0fSvg4!+cZ&sE+_T;g$lB9!+0~B)Vf0Pr7y;$N{)Z*6*=iLnB6E#N%`H
zVjLX*WF6FIfV%l`t8W<x3JOae^@Kg95eBO_1+j%n-0f%I&RE=oSlEcKVK4(8eR(3+
zu3f_c4`=APGU%-1dxYP?w~+_sq@_^<gG?Y=1ngAsMK3WlNV9rp`GKt_1SqGW#0?JJ
zk06DH@&~N5xgc0m*t!YfHClWb{mO{7<N85Abwmf@@K0E`{hNuZfvtGwURqbD-<QlI
zTvQ28)g*9df^cq8>6=a4(ZF-HD#a}iWmkfbZ<Gzl0M?ENeY#PqTe@*JgBitL^uflu
zj*FOr=77C5U|PlL{<^bqELB-tJOW;pa6~2b^#%a^5rPyz!zKxABBDuk75EcD*EtCS
zgY+`08o)qQBX2+sfa)n0l`?;wJ8NRtwYitRRB>$hfe;Oaa=Cz&=@|lR;P;T<{l_E8
zpPz{cP9!QFgr^M$8;wj#fU*exl_%&y1VH29o}dyTeVrldDOMIdD7s<?j37u&Bs0pz
zQGjqQpW@7yf%%n2-_6OF#H3z7zdZoBr(FNjLxhQM=K3y!Su;&|?uQTefNVSlv!(r)
zQ*EtkrU``QV=o}Dr<-rpkX)<y{ECf@t%uWhNAJ?79Sa1#B5<is-x`7FyJ2_6@ej@&
z8ba_7N#xy?4Ic(5LC8f4tec&SE0OW&2W6{<y!?5(vmq(duV75xX-&?Rg8<2_%7B22
zKeR2!rRkSEoy0SZIKpEc0SqdSgU4BY()XIs(L<{T<Ksm)i;J>G0kV2Xa`ukRo>u>D
zJ75MAva(!~fWnLyfa?0WxP+u6p*zU)A#K;-gfJNkMK}<`<ot{bS^}?NZ%<Ed2jq+M
z>}<7l<n7=?ccsyHRQ$ET=!g+Pcxxh^RYrgRT8ODvbIJs8kuVPa4dll?n-)M-zP#Pu
z6-^h=?>Rsq69!a}d_{VdV1~zk)&ioS$Ch2uf_(>jo13Fzz^>c)0nIxVyG!l_;`jN3
zxjhid-c#!B?jEigk}B2AlPBOpF_$1fM13)$V;N)O{`CgkWO;G1{SJwR6N>)icUPKZ
zfDqk<I~B)L$qhb<9V6bLxi~Q+<FUfoTR7frz%eG&$8XdB{;P%PvKYVZ;CO>KhEXXy
zaF>eiFCb<rK+FK@(q8AWY5o0!lsL3a2!0?klf-4D)=g5x19s}gZFpLGI@E6D-Zpt_
zLc(>)?S6i-opEh6E9A?-t$@7^!A&hU&Y;#-FzK2wt_Nu0ReoUmhaG@fK&N16O<0(i
zUa6hCLdjdx)HKUUA4n1!{Y7dJaIj{Pos;QjrX1&X$-Oj2aDq}Y4M06WaxrsqZ~r*~
zn2SmR40&qd7VDOF{GnDo*8)Lo7ndIvc1{wkLJU(@vkCy0DnZJTA2ss~QD3cB1~a>i
zSzv@zCaB{5SrN(wZctHPjvW;P6m>#<z+!pbfmjI5U#^Wj$4!`xQBHO&=s4+Rc#^1R
z%A4&NpOjPxkTH2Ta0xk`<uZ422n2E%L}fA~(2diIv5+%0-MNrDDyZA{hXC5<sC4uu
zat!Rq1CQb`4d4dh!JZYOwu7`ahai5rT@&O)cPvG6MV*(Qhi8bh6+llD!=feEXG+wP
z{sO1R5xG)Nbm4+=ZS}KX7Bz>!6Q>SoNu&Wh97--_r)K7h^6qNtZ<dCGV1mo#6(Dp5
ztd9PmV9liD(`XWWxIpjSMoc-(3kYgKQb3{tR@r*&FG@?MGzv5cH{)38t-l9=)Cfmq
zlZ6_OepSdI(G_7{Pk^Ou{6OOaf$v<r{A4a*6Adt+U=dH#&xc~<5Z?67^D}a1Da-q_
zB#nSatH|#zKu1#YOs-@H&y}cwAcVkhx4mx;Qb3@0!oIOm&(N@>sY$|9zuDirl3=d{
zZK%U@PY#Dp##MNlukR22f4h@)^)SEvn$vo_d;Az3?f}<3J}W$a2GoH8*0bizK^H!P
zs)*cIpi!YH;K-KK!U-ywudb||GnuJl^^D4ss?%Rg3HCEw4(v7Nfzm-*OwV8Iy0^Es
z?gF-V&sG8p{aNPua&y@e0u;nc9(^<}+wyVu{l9+UF@>$bk!Rp_qpN^+gASOx{^H`|
z(Ae0uz&_*2#~)qz7Q7IRSASK>3mTu}nX=>Slga+Cc0QkHy!`X$&sz&0yXD^5vC;cA
zuvyUrY|2i5J_{JmZ+3xhWxTbkbhTN|jRnu1rQNM~+$&{Yw@1x?p3dyE%Yglx*TC#-
z47`u%$&3E_KZ|w5xMkTD@{*R_&AaZ*Z@UE8Hazk8<B8W_vwnVh`s-|d-QuPuCSWst
z1+Y+<ZJrMtT3fku-sz{8l>2Rx?AV1EejQrm+8q)XcQ5N6aHRB15wKgTxA)5>v)7<I
z)`8<~68CxMqyUFm+<*;NP(Nv@_w+1a2g``ZS-$2&quq}O&0$}GU8}7{Pfvwy=aM`D
z>icv?0~>Q|mwkV8bFpppx01?Q;MmWjuQ8xW(b(rjJ3-gFX8>JS_3@~<sweRDfh*_c
zTHn3`Dl@;{|Nr;?+Ig&;3?GGzm;23K1xzA-z_!NhviJ9NJ%Ou*GQOW<on(@AMZ*?2
zu{;ZyYv!^o@PB(_qcf-^ET}9lE}pHOtg0!%@!_t6zCvSn8L-Xo2W++21BV`$0BarK
z+{21htGs}<i<D{B6fSOVP=*5r56`M?!0}2}NalB2vSi7NiSBY2fkE>H*xbv0e5@C^
zNFiK9<PvBAp!8J;u&NCQHu)^W?=f|}o>BSjW;(FlaPLy~`n}7-<7-2KMdD0g(f}Uh
zz2wLd7tk=kn$71frB07smS6XI_Os$+z!B%O<;=1hCE5}TW*|me9PV!>do&R5Xv?2^
XSv5}QCo|%&fGqQL^>bP0l+XkK<!T=J

literal 0
HcmV?d00001

diff --git a/hyperparameters.md b/hyperparameters.md
index 31d7261608..2d69a1f378 100644
--- a/hyperparameters.md
+++ b/hyperparameters.md
@@ -7,7 +7,7 @@ TxRateLimit: u64 = 1; // [1 @ 64,888]
 ### netuid 1 (text_prompting)
 ```rust
 Rho: u16 = 10;
-AlphaSigmoidSteepness: u16 = 10.0
+AlphaSigmoidSteepness: i16 = 1000
 Kappa: u16 = 32_767; // 0.5 = 65535/2
 MaxAllowedUids: u16 = 1024;
 Issuance: u64 = 0;
@@ -48,7 +48,7 @@ WeightsSetRateLimit: u64 = 100;
 ### netuid 3 (causallmnext)
 ```rust
 Rho: u16 = 10;
-AlphaSigmoidSteepness: u16 = 10.0
+AlphaSigmoidSteepness: i16 = 1000
 Kappa: u16 = 32_767; // 0.5 = 65535/2
 MaxAllowedUids: u16 = 4096;
 Issuance: u64 = 0;
diff --git a/pallets/admin-utils/src/lib.rs b/pallets/admin-utils/src/lib.rs
index b4bd58364f..5a5751ac30 100644
--- a/pallets/admin-utils/src/lib.rs
+++ b/pallets/admin-utils/src/lib.rs
@@ -105,6 +105,8 @@ pub mod pallet {
         MaxAllowedUIdsLessThanCurrentUIds,
         /// The maximum value for bonds moving average is reached
         BondsMovingAverageMaxReached,
+        /// Only root can set negative sigmoid steepness values
+        NegativeSigmoidSteepness,
     }
     /// Enum for specifying the type of precompile operation.
     #[derive(Encode, Decode, TypeInfo, Clone, PartialEq, Eq, Debug, Copy)]
@@ -1560,10 +1562,14 @@ pub mod pallet {
         /// # Arguments
         /// * `origin` - The origin of the call, which must be the root account.
         /// * `netuid` - The unique identifier for the subnet.
-        /// * `steepness` - The new steepness for the alpha sigmoid function.
+        /// * `steepness` - The Steepness for the alpha sigmoid function. (range is 0-int16::MAX,
+        /// negative values are reserved for future use)
         ///
         /// # Errors
         /// * `BadOrigin` - If the caller is not the root account.
+        /// * `SubnetDoesNotExist` - If the specified subnet does not exist.
+        /// * `NegativeSigmoidSteepness` - If the steepness is negative and the caller is
+        /// root.
         /// # Weight
         /// Weight is handled by the `#[pallet::weight]` attribute.
         #[pallet::call_index(68)]
@@ -1571,9 +1577,21 @@ pub mod pallet {
         pub fn sudo_set_alpha_sigmoid_steepness(
             origin: OriginFor<T>,
             netuid: NetUid,
-            steepness: u16,
+            steepness: i16,
         ) -> DispatchResult {
-            ensure_root(origin)?;
+            pallet_subtensor::Pallet::<T>::ensure_subnet_owner_or_root(origin.clone(), netuid)?;
+
+            ensure!(
+                pallet_subtensor::Pallet::<T>::if_subnet_exist(netuid),
+                Error::<T>::SubnetDoesNotExist
+            );
+
+            let is_root = ensure_root(origin).is_ok();
+            ensure!(
+                is_root || steepness >= 0,
+                Error::<T>::NegativeSigmoidSteepness
+            );
+
             pallet_subtensor::Pallet::<T>::set_alpha_sigmoid_steepness(netuid, steepness);
 
             log::debug!(
diff --git a/pallets/admin-utils/src/tests/mock.rs b/pallets/admin-utils/src/tests/mock.rs
index 830c659c42..9689d01de5 100644
--- a/pallets/admin-utils/src/tests/mock.rs
+++ b/pallets/admin-utils/src/tests/mock.rs
@@ -81,7 +81,7 @@ parameter_types! {
     pub const TransactionByteFee: Balance = 100;
     pub const SDebug:u64 = 1;
     pub const InitialRho: u16 = 30;
-    pub const InitialAlphaSigmoidSteepness: u16 = 10;
+    pub const InitialAlphaSigmoidSteepness: i16 = 1000;
     pub const InitialKappa: u16 = 32_767;
     pub const InitialTempo: u16 = 0;
     pub const SelfOwnership: u64 = 2;
diff --git a/pallets/admin-utils/src/tests/mod.rs b/pallets/admin-utils/src/tests/mod.rs
index 9e70858566..cab9be200d 100644
--- a/pallets/admin-utils/src/tests/mod.rs
+++ b/pallets/admin-utils/src/tests/mod.rs
@@ -1146,6 +1146,65 @@ fn test_sudo_set_liquid_alpha_enabled() {
     });
 }
 
+#[test]
+fn test_sudo_set_alpha_sigmoid_steepness() {
+    new_test_ext().execute_with(|| {
+        let netuid = NetUid::from(1);
+        let to_be_set: i16 = 5000;
+        add_network(netuid, 10);
+        let init_value = SubtensorModule::get_alpha_sigmoid_steepness(netuid);
+        assert_eq!(
+            AdminUtils::sudo_set_alpha_sigmoid_steepness(
+                <<Test as Config>::RuntimeOrigin>::signed(U256::from(1)),
+                netuid,
+                to_be_set
+            ),
+            Err(DispatchError::BadOrigin)
+        );
+        assert_eq!(
+            AdminUtils::sudo_set_alpha_sigmoid_steepness(
+                <<Test as Config>::RuntimeOrigin>::root(),
+                netuid.next(),
+                to_be_set
+            ),
+            Err(Error::<Test>::SubnetDoesNotExist.into())
+        );
+
+        let owner = U256::from(10);
+        pallet_subtensor::SubnetOwner::<Test>::insert(netuid, owner);
+        assert_eq!(
+            AdminUtils::sudo_set_alpha_sigmoid_steepness(
+                <<Test as Config>::RuntimeOrigin>::signed(owner),
+                netuid,
+                -to_be_set
+            ),
+            Err(Error::<Test>::NegativeSigmoidSteepness.into())
+        );
+        assert_eq!(
+            SubtensorModule::get_alpha_sigmoid_steepness(netuid),
+            init_value
+        );
+        assert_ok!(AdminUtils::sudo_set_alpha_sigmoid_steepness(
+            <<Test as Config>::RuntimeOrigin>::root(),
+            netuid,
+            to_be_set
+        ));
+        assert_eq!(
+            SubtensorModule::get_alpha_sigmoid_steepness(netuid),
+            to_be_set
+        );
+        assert_ok!(AdminUtils::sudo_set_alpha_sigmoid_steepness(
+            <<Test as Config>::RuntimeOrigin>::root(),
+            netuid,
+            -to_be_set
+        ));
+        assert_eq!(
+            SubtensorModule::get_alpha_sigmoid_steepness(netuid),
+            -to_be_set
+        );
+    });
+}
+
 #[test]
 fn test_set_alpha_values_dispatch_info_ok() {
     new_test_ext().execute_with(|| {
diff --git a/pallets/subtensor/src/epoch/run_epoch.rs b/pallets/subtensor/src/epoch/run_epoch.rs
index 715eb89f69..c2ffc3a45c 100644
--- a/pallets/subtensor/src/epoch/run_epoch.rs
+++ b/pallets/subtensor/src/epoch/run_epoch.rs
@@ -1298,10 +1298,9 @@ impl<T: Config> Pallet<T> {
         // sigmoid = 1. / (1. + e^(-steepness * (combined_diff - 0.5)))
         let sigmoid = one.saturating_div(
             one.saturating_add(safe_exp(
-                I32F32::from_num(-1).saturating_mul(
-                    alpha_sigmoid_steepness
-                        .saturating_mul(combined_diff.saturating_sub(I32F32::from_num(0.5))),
-                ),
+                alpha_sigmoid_steepness
+                    .saturating_div(I32F32::from_num(-100))
+                    .saturating_mul(combined_diff.saturating_sub(I32F32::from_num(0.5))),
             )),
         );
         let alpha =
diff --git a/pallets/subtensor/src/lib.rs b/pallets/subtensor/src/lib.rs
index 1a48024bb0..19e218c6e0 100644
--- a/pallets/subtensor/src/lib.rs
+++ b/pallets/subtensor/src/lib.rs
@@ -595,7 +595,7 @@ pub mod pallet {
     }
     #[pallet::type_value]
     /// Default value for alpha sigmoid steepness.
-    pub fn DefaultAlphaSigmoidSteepness<T: Config>() -> u16 {
+    pub fn DefaultAlphaSigmoidSteepness<T: Config>() -> i16 {
         T::InitialAlphaSigmoidSteepness::get()
     }
     #[pallet::type_value]
@@ -1292,7 +1292,7 @@ pub mod pallet {
     #[pallet::storage]
     /// --- MAP ( netuid ) --> AlphaSigmoidSteepness
     pub type AlphaSigmoidSteepness<T> =
-        StorageMap<_, Identity, NetUid, u16, ValueQuery, DefaultAlphaSigmoidSteepness<T>>;
+        StorageMap<_, Identity, NetUid, i16, ValueQuery, DefaultAlphaSigmoidSteepness<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> Kappa
     pub type Kappa<T> = StorageMap<_, Identity, NetUid, u16, ValueQuery, DefaultKappa<T>>;
diff --git a/pallets/subtensor/src/macros/config.rs b/pallets/subtensor/src/macros/config.rs
index b0f2483331..8853bd9e51 100644
--- a/pallets/subtensor/src/macros/config.rs
+++ b/pallets/subtensor/src/macros/config.rs
@@ -107,7 +107,7 @@ mod config {
         type InitialRho: Get<u16>;
         /// AlphaSigmoidSteepness constant.
         #[pallet::constant]
-        type InitialAlphaSigmoidSteepness: Get<u16>;
+        type InitialAlphaSigmoidSteepness: Get<i16>;
         /// Kappa constant.
         #[pallet::constant]
         type InitialKappa: Get<u16>;
diff --git a/pallets/subtensor/src/macros/events.rs b/pallets/subtensor/src/macros/events.rs
index b327376aad..3f3c71860d 100644
--- a/pallets/subtensor/src/macros/events.rs
+++ b/pallets/subtensor/src/macros/events.rs
@@ -51,7 +51,7 @@ mod events {
         /// Rho value is set.
         RhoSet(NetUid, u16),
         /// steepness of the sigmoid used to compute alpha values.
-        AlphaSigmoidSteepnessSet(NetUid, u16),
+        AlphaSigmoidSteepnessSet(NetUid, i16),
         /// Kappa is set for a subnet.
         KappaSet(NetUid, u16),
         /// minimum allowed weight is set for a subnet.
diff --git a/pallets/subtensor/src/tests/epoch.rs b/pallets/subtensor/src/tests/epoch.rs
index 0e567796d7..1e26a2413d 100644
--- a/pallets/subtensor/src/tests/epoch.rs
+++ b/pallets/subtensor/src/tests/epoch.rs
@@ -2643,7 +2643,7 @@ fn setup_yuma_3_scenario(netuid: NetUid, n: u16, sparse: bool, max_stake: u64, s
     SubtensorModule::set_min_allowed_weights(netuid, 1);
     SubtensorModule::set_max_weight_limit(netuid, u16::MAX);
     SubtensorModule::set_bonds_penalty(netuid, 0);
-    SubtensorModule::set_alpha_sigmoid_steepness(netuid, 10);
+    SubtensorModule::set_alpha_sigmoid_steepness(netuid, 1000);
     SubtensorModule::set_bonds_moving_average(netuid, 975_000);
 
     // === Register
diff --git a/pallets/subtensor/src/tests/mock.rs b/pallets/subtensor/src/tests/mock.rs
index 53972ef391..b6e627ef83 100644
--- a/pallets/subtensor/src/tests/mock.rs
+++ b/pallets/subtensor/src/tests/mock.rs
@@ -156,7 +156,7 @@ parameter_types! {
     pub const TransactionByteFee: Balance = 100;
     pub const SDebug:u64 = 1;
     pub const InitialRho: u16 = 30;
-    pub const InitialAlphaSigmoidSteepness: u16 = 10;
+    pub const InitialAlphaSigmoidSteepness: i16 = 1000;
     pub const InitialKappa: u16 = 32_767;
     pub const InitialTempo: u16 = 360;
     pub const SelfOwnership: u64 = 2;
diff --git a/pallets/subtensor/src/utils/misc.rs b/pallets/subtensor/src/utils/misc.rs
index cf7c5f1a18..c6075995a9 100644
--- a/pallets/subtensor/src/utils/misc.rs
+++ b/pallets/subtensor/src/utils/misc.rs
@@ -699,7 +699,7 @@ impl<T: Config> Pallet<T> {
         (converted_low, converted_high)
     }
 
-    pub fn set_alpha_sigmoid_steepness(netuid: NetUid, steepness: u16) {
+    pub fn set_alpha_sigmoid_steepness(netuid: NetUid, steepness: i16) {
         AlphaSigmoidSteepness::<T>::insert(netuid, steepness);
     }
     pub fn get_alpha_sigmoid_steepness(netuid: NetUid) -> I32F32 {
diff --git a/precompiles/src/solidity/subnet.abi b/precompiles/src/solidity/subnet.abi
index b853a6f94c..805c0057d9 100644
--- a/precompiles/src/solidity/subnet.abi
+++ b/precompiles/src/solidity/subnet.abi
@@ -411,12 +411,12 @@
 				"type": "uint16"
 			}
 		],
-		"name": "getServingRateLimit",
+		"name": "getAlphaSigmoidSteepness",
 		"outputs": [
 			{
-				"internalType": "uint64",
+				"internalType": "uint16",
 				"name": "",
-				"type": "uint64"
+				"type": "uint16"
 			}
 		],
 		"stateMutability": "view",
@@ -957,6 +957,24 @@
 		"stateMutability": "payable",
 		"type": "function"
 	},
+	{
+		"inputs": [
+			{
+				"internalType": "uint16",
+				"name": "netuid",
+				"type": "uint16"
+			},
+			{
+				"internalType": "uint16",
+				"name": "steepness",
+				"type": "uint16"
+			}
+		],
+		"name": "setAlphaSigmoidSteepness",
+		"outputs": [],
+		"stateMutability": "payable",
+		"type": "function"
+	},
 	{
 		"inputs": [
 			{
diff --git a/precompiles/src/solidity/subnet.sol b/precompiles/src/solidity/subnet.sol
index a6086759bb..7517db3019 100644
--- a/precompiles/src/solidity/subnet.sol
+++ b/precompiles/src/solidity/subnet.sol
@@ -102,6 +102,15 @@ interface ISubnet {
 
     function setRho(uint16 netuid, uint16 rho) external payable;
 
+    function getAlphaSigmoidSteepness(
+        uint16 netuid
+    ) external view returns (unt16);
+
+    function setAlphaSigmoidSteepness(
+        uint16 netuid,
+        int16 steepness
+    ) external payable;
+
     function getActivityCutoff(uint16 netuid) external view returns (uint16);
 
     function setActivityCutoff(
@@ -174,7 +183,7 @@ interface ISubnet {
     function getBondsResetEnabled(uint16 netuid) external view returns (bool);
 
     function setBondsResetEnabled(
-        uint16 netuid, 
+        uint16 netuid,
         bool bondsResetEnabled
     ) external payable;
 
diff --git a/precompiles/src/subnet.rs b/precompiles/src/subnet.rs
index 03b2fa56ac..3a598db61c 100644
--- a/precompiles/src/subnet.rs
+++ b/precompiles/src/subnet.rs
@@ -394,9 +394,7 @@ where
     #[precompile::public("getAlphaSigmoidSteepness(uint16)")]
     #[precompile::view]
     fn get_alpha_sigmoid_steepness(_: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<u16> {
-        Ok(pallet_subtensor::AlphaSigmoidSteepness::<R>::get(
-            NetUid::from(netuid),
-        ))
+        Ok(pallet_subtensor::AlphaSigmoidSteepness::<R>::get(NetUid::from(netuid)) as u16)
     }
 
     #[precompile::public("setRho(uint16,uint16)")]
@@ -422,7 +420,7 @@ where
     ) -> EvmResult<()> {
         let call = pallet_admin_utils::Call::<R>::sudo_set_alpha_sigmoid_steepness {
             netuid: netuid.into(),
-            steepness,
+            steepness: (steepness as i16),
         };
 
         handle.try_dispatch_runtime_call::<R, _>(
diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index 581e3d2252..4fbd0dca71 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -1056,7 +1056,7 @@ pub const INITIAL_CHILDKEY_TAKE_RATELIMIT: u64 = 5;
 // Configure the pallet subtensor.
 parameter_types! {
     pub const SubtensorInitialRho: u16 = 10;
-    pub const SubtensorInitialAlphaSigmoidSteepness: u16 = 1000;
+    pub const SubtensorInitialAlphaSigmoidSteepness: i16 = 1000;
     pub const SubtensorInitialKappa: u16 = 32_767; // 0.5 = 65535/2
     pub const SubtensorInitialMaxAllowedUids: u16 = 4096;
     pub const SubtensorInitialIssuance: u64 = 0;

From 4dac3c66f6964ca34b03b32e36f02457d4ed7a92 Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Mon, 16 Jun 2025 17:03:40 +0200
Subject: [PATCH 390/418] bump spec version

---
 runtime/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index fe8dc13472..ac34271ad9 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -215,7 +215,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
     //   `spec_version`, and `authoring_version` are the same between Wasm and native.
     // This value is set to 100 to notify Polkadot-JS App (https://polkadot.js.org/apps) to use
     //   the compatible custom types.
-    spec_version: 276,
+    spec_version: 277,
     impl_version: 1,
     apis: RUNTIME_API_VERSIONS,
     transaction_version: 1,

From 00e787e92c9ec16a9872dfc5e35dbfa8b3962f9e Mon Sep 17 00:00:00 2001
From: Roman <roman@opentensor.dev>
Date: Mon, 16 Jun 2025 12:25:19 -0700
Subject: [PATCH 391/418] update workflow

---
 .../check-bittensor-e2e-tests.yml.yml         | 48 ++++---------------
 1 file changed, 9 insertions(+), 39 deletions(-)

diff --git a/.github/workflows/check-bittensor-e2e-tests.yml.yml b/.github/workflows/check-bittensor-e2e-tests.yml.yml
index 6be275e3ee..1f0878a548 100644
--- a/.github/workflows/check-bittensor-e2e-tests.yml.yml
+++ b/.github/workflows/check-bittensor-e2e-tests.yml.yml
@@ -10,12 +10,7 @@ concurrency:
 
 on:
   pull_request:
-    branches:
-      - devnet
-      - devnet-ready
-      - testnet
-      - testnet-ready
-      - main
+    branches: ["*"]
     types: [opened, synchronize, reopened, labeled, unlabeled]
 
   workflow_dispatch:
@@ -30,35 +25,10 @@ env:
   VERBOSE: ${{ github.event.inputs.verbose }}
 
 jobs:
-  apply-label-to-new-pr:
-    runs-on: ubuntu-latest
-    outputs:
-      should_continue: ${{ steps.check.outputs.should_continue }}
-    steps:
-      - name: Check
-        id: check
-        run: |
-          ACTION="${{ github.event.action }}"
-          if [[ "$ACTION" == "opened" || "$ACTION" == "reopened" ]]; then
-            echo "should_continue=true" >> $GITHUB_OUTPUT
-          else
-            echo "should_continue=false" >> $GITHUB_OUTPUT
-          fi
-        shell: bash
-
-      - name: Add label
-        if: steps.check.outputs.should_continue == 'true'
-        uses: actions-ecosystem/action-add-labels@v1
-        with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          labels: run-bittensor-e2e-tests
-
   check-label:
-    needs: apply-label-to-new-pr
     runs-on: ubuntu-latest
-    if: always()
     outputs:
-      run-bittensor-e2e-tests: ${{ steps.get-labels.outputs.run-bittensor-e2e-tests }}
+      skip-bittensor-e2e-tests: ${{ steps.get-labels.outputs.skip-bittensor-e2e-tests }}
     steps:
       - name: Check out repository
         uses: actions/checkout@v4
@@ -68,17 +38,17 @@ jobs:
         run: |
           LABELS=$(gh pr view ${{ github.event.pull_request.number }} --json labels --jq '.labels[].name')
           echo "Current labels: $LABELS"
-          if echo "$LABELS" | grep -q "run-bittensor-e2e-tests"; then
-            echo "run-bittensor-e2e-tests=true" >> $GITHUB_OUTPUT
+          if echo "$LABELS" | grep -q "skip-bittensor-e2e-tests"; then
+            echo "skip-bittensor-e2e-tests=true" >> $GITHUB_OUTPUT
           else
-            echo "run-bittensor-e2e-tests=false" >> $GITHUB_OUTPUT
+            echo "skip-bittensor-e2e-tests=false" >> $GITHUB_OUTPUT
           fi
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
   find-btcli-e2e-tests:
     needs: check-label
-    if: always() && needs.check-label.outputs.run-bittensor-e2e-tests == 'true'
+    if: needs.check-label.outputs.skip-bittensor-e2e-tests == 'false'
     runs-on: ubuntu-latest
     outputs:
       test-files: ${{ steps.get-btcli-tests.outputs.test-files }}
@@ -103,7 +73,7 @@ jobs:
 
   find-sdk-e2e-tests:
     needs: check-label
-    if: always() && needs.check-label.outputs.run-bittensor-e2e-tests == 'true'
+    if: needs.check-label.outputs.skip-bittensor-e2e-tests == 'false'
     runs-on: ubuntu-latest
     outputs:
       test-files: ${{ steps.get-sdk-tests.outputs.test-files }}
@@ -164,7 +134,7 @@ jobs:
       - check-label
       - find-btcli-e2e-tests
       - build-image-with-current-branch
-    if: always() && needs.check-label.outputs.run-bittensor-e2e-tests == 'true'
+    if: needs.check-label.outputs.skip-bittensor-e2e-tests == 'false'
     runs-on: ubuntu-latest
     strategy:
       fail-fast: false
@@ -261,7 +231,7 @@ jobs:
       - check-label
       - find-sdk-e2e-tests
       - build-image-with-current-branch
-    if: always() && needs.check-label.outputs.run-bittensor-e2e-tests == 'true'
+    if: needs.check-label.outputs.skip-bittensor-e2e-tests == 'false'
     runs-on: ubuntu-latest
     strategy:
       fail-fast: false

From 7a9ded837690f752cd39c47e6f54bc72620d0f81 Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Mon, 16 Jun 2025 22:04:51 +0200
Subject: [PATCH 392/418] fix hotkey registration check test

---
 pallets/subtensor/src/swap/swap_hotkey.rs | 26 +++++++++++++----------
 1 file changed, 15 insertions(+), 11 deletions(-)

diff --git a/pallets/subtensor/src/swap/swap_hotkey.rs b/pallets/subtensor/src/swap/swap_hotkey.rs
index 4b598c77d6..08e299165a 100644
--- a/pallets/subtensor/src/swap/swap_hotkey.rs
+++ b/pallets/subtensor/src/swap/swap_hotkey.rs
@@ -54,37 +54,37 @@ impl<T: Config> Pallet<T> {
         );
 
         weight.saturating_accrue(T::DbWeight::get().reads(2));
+        
+        // Start to do everything for swap hotkey on all subnets case
+        // 7. Ensure the new hotkey is not already registered on any network
+        ensure!(
+            !Self::is_hotkey_registered_on_any_network(new_hotkey),
+            Error::<T>::HotKeyAlreadyRegisteredInSubNet
+        );
 
-        // 7. Swap LastTxBlock
+        // 8. Swap LastTxBlock
         // LastTxBlock( hotkey ) --> u64 -- the last transaction block for the hotkey.
         let last_tx_block: u64 = LastTxBlock::<T>::get(old_hotkey);
         LastTxBlock::<T>::insert(new_hotkey, last_tx_block);
         weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
 
-        // 8. Swap LastTxBlockDelegateTake
+        // 9. Swap LastTxBlockDelegateTake
         // LastTxBlockDelegateTake( hotkey ) --> u64 -- the last transaction block for the hotkey delegate take.
         let last_tx_block_delegate_take: u64 = LastTxBlockDelegateTake::<T>::get(old_hotkey);
         LastTxBlockDelegateTake::<T>::insert(new_hotkey, last_tx_block_delegate_take);
         weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
 
-        // 9. Swap LastTxBlockChildKeyTake
+        // 10. Swap LastTxBlockChildKeyTake
         // LastTxBlockChildKeyTake( hotkey ) --> u64 -- the last transaction block for the hotkey child key take.
         let last_tx_block_child_key_take: u64 = LastTxBlockChildKeyTake::<T>::get(old_hotkey);
         LastTxBlockChildKeyTake::<T>::insert(new_hotkey, last_tx_block_child_key_take);
         weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
 
-        // 10. fork for swap hotkey on a specific subnet case after do the common check
+        // 11. fork for swap hotkey on a specific subnet case after do the common check
         if let Some(netuid) = netuid {
             return Self::swap_hotkey_on_subnet(&coldkey, old_hotkey, new_hotkey, netuid, weight);
         };
 
-        // Start to do everything for swap hotkey on all subnets case
-        // 11. Ensure the new hotkey is not already registered on any network
-        ensure!(
-            !Self::is_hotkey_registered_on_any_network(new_hotkey),
-            Error::<T>::HotKeyAlreadyRegisteredInSubNet
-        );
-
         // 12. Get the cost for swapping the key
         let swap_cost = Self::get_key_swap_cost();
         log::debug!("Swap cost: {:?}", swap_cost);
@@ -276,6 +276,10 @@ impl<T: Config> Pallet<T> {
         );
         weight.saturating_accrue(T::DbWeight::get().reads_writes(3, 0));
 
+        println!("we get to here 2");
+        println!("in netuid: {}", netuid);
+        println!("in new_hotkey: {}", new_hotkey);
+        println!("in: {}", IsNetworkMember::<T>::get(new_hotkey, netuid));
         // 2. Ensure the hotkey not registered on the network before.
         ensure!(
             !Self::is_hotkey_registered_on_specific_network(new_hotkey, netuid),

From 3a2cf2824ad2aa18bc2362260b2e496f9a0c0e1a Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Mon, 16 Jun 2025 22:20:25 +0200
Subject: [PATCH 393/418] remove printlns

---
 pallets/subtensor/src/swap/swap_hotkey.rs | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/pallets/subtensor/src/swap/swap_hotkey.rs b/pallets/subtensor/src/swap/swap_hotkey.rs
index 08e299165a..dae87d3747 100644
--- a/pallets/subtensor/src/swap/swap_hotkey.rs
+++ b/pallets/subtensor/src/swap/swap_hotkey.rs
@@ -276,10 +276,6 @@ impl<T: Config> Pallet<T> {
         );
         weight.saturating_accrue(T::DbWeight::get().reads_writes(3, 0));
 
-        println!("we get to here 2");
-        println!("in netuid: {}", netuid);
-        println!("in new_hotkey: {}", new_hotkey);
-        println!("in: {}", IsNetworkMember::<T>::get(new_hotkey, netuid));
         // 2. Ensure the hotkey not registered on the network before.
         ensure!(
             !Self::is_hotkey_registered_on_specific_network(new_hotkey, netuid),

From 6b71322e5f13d0e89cdc8f04dff82ab8bcd6af40 Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Mon, 16 Jun 2025 22:23:35 +0200
Subject: [PATCH 394/418] cargo fmt

---
 pallets/subtensor/src/swap/swap_hotkey.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pallets/subtensor/src/swap/swap_hotkey.rs b/pallets/subtensor/src/swap/swap_hotkey.rs
index dae87d3747..10988bb5bb 100644
--- a/pallets/subtensor/src/swap/swap_hotkey.rs
+++ b/pallets/subtensor/src/swap/swap_hotkey.rs
@@ -54,7 +54,7 @@ impl<T: Config> Pallet<T> {
         );
 
         weight.saturating_accrue(T::DbWeight::get().reads(2));
-        
+
         // Start to do everything for swap hotkey on all subnets case
         // 7. Ensure the new hotkey is not already registered on any network
         ensure!(

From 409eb2e7b989523c227f8718a1a255830bc311d4 Mon Sep 17 00:00:00 2001
From: Sam Johnson <sam@durosoft.com>
Date: Mon, 16 Jun 2025 16:51:39 -0400
Subject: [PATCH 395/418] bump spec version

---
 runtime/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index 0695641eb1..815e0a156b 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -209,7 +209,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
     //   `spec_version`, and `authoring_version` are the same between Wasm and native.
     // This value is set to 100 to notify Polkadot-JS App (https://polkadot.js.org/apps) to use
     //   the compatible custom types.
-    spec_version: 277,
+    spec_version: 278,
     impl_version: 1,
     apis: RUNTIME_API_VERSIONS,
     transaction_version: 1,

From 7627c0c4b051e6f9e0c60d2de2cfbd0c26f92702 Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Mon, 16 Jun 2025 23:10:24 +0200
Subject: [PATCH 396/418] fix comment

---
 pallets/subtensor/src/swap/swap_hotkey.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pallets/subtensor/src/swap/swap_hotkey.rs b/pallets/subtensor/src/swap/swap_hotkey.rs
index 10988bb5bb..9cb79a1002 100644
--- a/pallets/subtensor/src/swap/swap_hotkey.rs
+++ b/pallets/subtensor/src/swap/swap_hotkey.rs
@@ -55,7 +55,6 @@ impl<T: Config> Pallet<T> {
 
         weight.saturating_accrue(T::DbWeight::get().reads(2));
 
-        // Start to do everything for swap hotkey on all subnets case
         // 7. Ensure the new hotkey is not already registered on any network
         ensure!(
             !Self::is_hotkey_registered_on_any_network(new_hotkey),
@@ -85,6 +84,7 @@ impl<T: Config> Pallet<T> {
             return Self::swap_hotkey_on_subnet(&coldkey, old_hotkey, new_hotkey, netuid, weight);
         };
 
+        // Start to do everything for swap hotkey on all subnets case
         // 12. Get the cost for swapping the key
         let swap_cost = Self::get_key_swap_cost();
         log::debug!("Swap cost: {:?}", swap_cost);

From f2b8ac4696ba86b5f75893957ed6602df94c104f Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Tue, 17 Jun 2025 00:44:23 +0200
Subject: [PATCH 397/418] commit suggestions

---
 pallets/subtensor/src/macros/dispatches.rs    | 284 ------------------
 .../src/tests/swap_hotkey_with_subnet.rs      |  18 +-
 2 files changed, 13 insertions(+), 289 deletions(-)

diff --git a/pallets/subtensor/src/macros/dispatches.rs b/pallets/subtensor/src/macros/dispatches.rs
index 5d2ba29bb2..7d4f1a0850 100644
--- a/pallets/subtensor/src/macros/dispatches.rs
+++ b/pallets/subtensor/src/macros/dispatches.rs
@@ -2070,289 +2070,5 @@ mod dispatches {
             PendingChildKeyCooldown::<T>::put(cooldown);
             Ok(())
         }
-
-        // /// --- Adds stake to a hotkey on a subnet with a price limit.
-        // /// This extrinsic allows to specify the limit price for alpha token
-        // /// at which or better (lower) the staking should execute.
-        // ///
-        // /// In case if slippage occurs and the price shall move beyond the limit
-        // /// price, the staking order may execute only partially or not execute
-        // /// at all.
-        // ///
-        // /// The operation will be delayed.
-        // ///
-        // /// # Args:
-        // ///  * 'origin': (<T as frame_system::Config>Origin):
-        // /// 	- The signature of the caller's coldkey.
-        // ///
-        // ///  * 'hotkey' (T::AccountId):
-        // /// 	- The associated hotkey account.
-        // ///
-        // /// * 'netuid' (u16):
-        // ///     - Subnetwork UID
-        // ///
-        // ///  * 'amount_staked' (u64):
-        // /// 	- The amount of stake to be added to the hotkey staking account.
-        // ///
-        // /// # Event:
-        // ///  * StakeAdded;
-        // /// 	- On the successfully adding stake to a global account.
-        // ///
-        // /// # Raises:
-        // ///  * 'NotEnoughBalanceToStake':
-        // /// 	- Not enough balance on the coldkey to add onto the global account.
-        // ///
-        // ///  * 'NonAssociatedColdKey':
-        // /// 	- The calling coldkey is not associated with this hotkey.
-        // ///
-        // ///  * 'BalanceWithdrawalError':
-        // ///  	- Errors stemming from transaction pallet.
-        // ///
-        // #[pallet::call_index(103)]
-        // #[pallet::weight((Weight::from_parts(162_000_000, 5127)
-        // .saturating_add(T::DbWeight::get().reads(15_u64))
-        // .saturating_add(T::DbWeight::get().writes(12_u64)), DispatchClass::Normal, Pays::No))]
-        // pub fn add_stake_aggregate(
-        //     origin: OriginFor<T>,
-        //     hotkey: T::AccountId,
-        //     netuid: u16,
-        //     amount_staked: u64,
-        // ) -> DispatchResult {
-        //     Self::do_add_stake_aggregate(origin, hotkey, netuid, amount_staked)
-        // }
-
-        // /// --- Removes stake from a hotkey on a subnet with a price limit.
-        // /// This extrinsic allows to specify the limit price for alpha token
-        // /// at which or better (higher) the staking should execute.
-        // ///
-        // /// In case if slippage occurs and the price shall move beyond the limit
-        // /// price, the staking order may execute only partially or not execute
-        // /// at all.
-        // ///
-        // /// The operation will be delayed.
-        // ///
-        // /// # Args:
-        // /// * 'origin': (<T as frame_system::Config>Origin):
-        // /// 	- The signature of the caller's coldkey.
-        // ///
-        // /// * 'hotkey' (T::AccountId):
-        // /// 	- The associated hotkey account.
-        // ///
-        // /// * 'netuid' (u16):
-        // ///     - Subnetwork UID
-        // ///
-        // /// * 'amount_unstaked' (u64):
-        // /// 	- The amount of stake to be added to the hotkey staking account.
-        // ///
-        // /// # Event:
-        // /// * StakeRemoved;
-        // /// 	- On the successfully removing stake from the hotkey account.
-        // ///
-        // /// # Raises:
-        // /// * 'NotRegistered':
-        // /// 	- Thrown if the account we are attempting to unstake from is non existent.
-        // ///
-        // /// * 'NonAssociatedColdKey':
-        // /// 	- Thrown if the coldkey does not own the hotkey we are unstaking from.
-        // ///
-        // /// * 'NotEnoughStakeToWithdraw':
-        // /// 	- Thrown if there is not enough stake on the hotkey to withdwraw this amount.
-        // ///
-        // #[pallet::call_index(104)]
-        // #[pallet::weight((Weight::from_parts(213_300_000, 10163)
-        // .saturating_add(T::DbWeight::get().reads(20_u64))
-        // .saturating_add(T::DbWeight::get().writes(12_u64)), DispatchClass::Normal, Pays::No))]
-        // pub fn remove_stake_aggregate(
-        //     origin: OriginFor<T>,
-        //     hotkey: T::AccountId,
-        //     netuid: u16,
-        //     amount_unstaked: u64,
-        // ) -> DispatchResult {
-        //     Self::do_remove_stake_aggregate(origin, hotkey, netuid, amount_unstaked)
-        // }
-
-        // /// --- Adds stake to a hotkey on a subnet with a price limit.
-        // /// This extrinsic allows to specify the limit price for alpha token
-        // /// at which or better (lower) the staking should execute.
-        // ///
-        // /// In case if slippage occurs and the price shall move beyond the limit
-        // /// price, the staking order may execute only partially or not execute
-        // /// at all.
-        // ///
-        // /// The operation will be delayed.
-        // ///
-        // /// # Args:
-        // ///  * 'origin': (<T as frame_system::Config>Origin):
-        // /// 	- The signature of the caller's coldkey.
-        // ///
-        // ///  * 'hotkey' (T::AccountId):
-        // /// 	- The associated hotkey account.
-        // ///
-        // /// * 'netuid' (u16):
-        // ///     - Subnetwork UID
-        // ///
-        // ///  * 'amount_staked' (u64):
-        // /// 	- The amount of stake to be added to the hotkey staking account.
-        // ///
-        // ///  * 'limit_price' (u64):
-        // /// 	- The limit price expressed in units of RAO per one Alpha.
-        // ///
-        // ///  * 'allow_partial' (bool):
-        // /// 	- Allows partial execution of the amount. If set to false, this becomes
-        // ///       fill or kill type or order.
-        // ///
-        // /// # Event:
-        // ///  * StakeAdded;
-        // /// 	- On the successfully adding stake to a global account.
-        // ///
-        // /// # Raises:
-        // ///  * 'NotEnoughBalanceToStake':
-        // /// 	- Not enough balance on the coldkey to add onto the global account.
-        // ///
-        // ///  * 'NonAssociatedColdKey':
-        // /// 	- The calling coldkey is not associated with this hotkey.
-        // ///
-        // ///  * 'BalanceWithdrawalError':
-        // ///  	- Errors stemming from transaction pallet.
-        // ///
-        // #[pallet::call_index(105)]
-        // #[pallet::weight((Weight::from_parts(169_200_000, 5127)
-        // .saturating_add(T::DbWeight::get().reads(14_u64))
-        // .saturating_add(T::DbWeight::get().writes(12_u64)), DispatchClass::Normal, Pays::No))]
-        // pub fn add_stake_limit_aggregate(
-        //     origin: OriginFor<T>,
-        //     hotkey: T::AccountId,
-        //     netuid: u16,
-        //     amount_staked: u64,
-        //     limit_price: u64,
-        //     allow_partial: bool,
-        // ) -> DispatchResult {
-        //     Self::do_add_stake_limit_aggregate(
-        //         origin,
-        //         hotkey,
-        //         netuid,
-        //         amount_staked,
-        //         limit_price,
-        //         allow_partial,
-        //     )
-        // }
-
-        // /// --- Removes stake from a hotkey on a subnet with a price limit.
-        // /// This extrinsic allows to specify the limit price for alpha token
-        // /// at which or better (higher) the staking should execute.
-        // ///
-        // /// In case if slippage occurs and the price shall move beyond the limit
-        // /// price, the staking order may execute only partially or not execute
-        // /// at all.
-        // ///
-        // /// The operation will be delayed.
-        // ///
-        // /// # Args:
-        // /// * 'origin': (<T as frame_system::Config>Origin):
-        // /// 	- The signature of the caller's coldkey.
-        // ///
-        // /// * 'hotkey' (T::AccountId):
-        // /// 	- The associated hotkey account.
-        // ///
-        // /// * 'netuid' (u16):
-        // ///     - Subnetwork UID
-        // ///
-        // /// * 'amount_unstaked' (u64):
-        // /// 	- The amount of stake to be added to the hotkey staking account.
-        // ///
-        // ///  * 'limit_price' (u64):
-        // ///     - The limit price expressed in units of RAO per one Alpha.
-        // ///
-        // ///  * 'allow_partial' (bool):
-        // ///     - Allows partial execution of the amount. If set to false, this becomes
-        // ///       fill or kill type or order.
-        // ///
-        // /// # Event:
-        // /// * StakeRemoved;
-        // /// 	- On the successfully removing stake from the hotkey account.
-        // ///
-        // /// # Raises:
-        // /// * 'NotRegistered':
-        // /// 	- Thrown if the account we are attempting to unstake from is non existent.
-        // ///
-        // /// * 'NonAssociatedColdKey':
-        // /// 	- Thrown if the coldkey does not own the hotkey we are unstaking from.
-        // ///
-        // /// * 'NotEnoughStakeToWithdraw':
-        // /// 	- Thrown if there is not enough stake on the hotkey to withdwraw this amount.
-        // ///
-        // #[pallet::call_index(106)]
-        // #[pallet::weight((Weight::from_parts(211_700_000, 10163)
-        // .saturating_add(T::DbWeight::get().reads(19_u64))
-        // .saturating_add(T::DbWeight::get().writes(12_u64)), DispatchClass::Normal, Pays::No))]
-        // pub fn remove_stake_limit_aggregate(
-        //     origin: OriginFor<T>,
-        //     hotkey: T::AccountId,
-        //     netuid: u16,
-        //     amount_unstaked: u64,
-        //     limit_price: u64,
-        //     allow_partial: bool,
-        // ) -> DispatchResult {
-        //     Self::do_remove_stake_limit_aggregate(
-        //         origin,
-        //         hotkey,
-        //         netuid,
-        //         amount_unstaked,
-        //         limit_price,
-        //         allow_partial,
-        //     )
-        // }
-
-        // /// ---- The implementation for the extrinsic unstake_all_aggregate: Removes all stake from a hotkey account across all subnets and adds it onto a coldkey.
-        // ///
-        // /// The operation will be delayed.
-        // ///
-        // /// # Args:
-        // /// * `origin` - (<T as frame_system::Config>::Origin):
-        // ///     - The signature of the caller's coldkey.
-        // ///
-        // /// * `hotkey` (T::AccountId):
-        // ///     - The associated hotkey account.
-        // ///
-        // /// # Event:
-        // /// * StakeRemoved;
-        // ///     - On the successfully removing stake from the hotkey account.
-        // ///
-        // /// # Raises:
-        // /// * `NotRegistered`:
-        // ///     - Thrown if the account we are attempting to unstake from is non existent.
-        // ///
-        // /// * `NonAssociatedColdKey`:
-        // ///     - Thrown if the coldkey does not own the hotkey we are unstaking from.
-        // ///
-        // /// * `NotEnoughStakeToWithdraw`:
-        // ///     - Thrown if there is not enough stake on the hotkey to withdraw this amount.
-        // ///
-        // /// * `TxRateLimitExceeded`:
-        // ///     - Thrown if key has hit transaction rate limit
-        // #[pallet::call_index(107)]
-        // #[pallet::weight((Weight::from_parts(3_000_000, 0).saturating_add(T::DbWeight::get().writes(1)), DispatchClass::Operational, Pays::No))]
-        // pub fn unstake_all_aggregate(origin: OriginFor<T>, hotkey: T::AccountId) -> DispatchResult {
-        //     Self::do_unstake_all_aggregate(origin, hotkey)
-        // }
-
-        //     /// ---- The implementation for the extrinsic unstake_all_alpha_aggregate: Removes all stake from a hotkey account across all subnets and adds it onto a coldkey.
-        //     ///
-        //     /// The operation will be delayed.
-        //     ///
-        //     /// # Args:
-        //     /// * `origin` - (<T as frame_system::Config>::Origin):
-        //     ///     - The signature of the caller's coldkey.
-        //     ///
-        //     /// * `hotkey` (T::AccountId):
-        //     ///     - The associated hotkey account.
-        //     #[pallet::call_index(108)]
-        //     #[pallet::weight((Weight::from_parts(3_000_000, 0).saturating_add(T::DbWeight::get().writes(1)), DispatchClass::Operational, Pays::No))]
-        //     pub fn unstake_all_alpha_aggregate(
-        //         origin: OriginFor<T>,
-        //         hotkey: T::AccountId,
-        //     ) -> DispatchResult {
-        //         Self::do_unstake_all_alpha_aggregate(origin, hotkey)
-        //     }
     }
 }
diff --git a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
index 5969d9b1e7..effef6f8ab 100644
--- a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
+++ b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs
@@ -155,6 +155,7 @@ fn test_swap_delegates() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
+
         let netuid = add_dynamic_network(&old_hotkey, &coldkey);
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
 
@@ -179,6 +180,7 @@ fn test_swap_subnet_membership() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
+
         let netuid = add_dynamic_network(&old_hotkey, &coldkey);
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
 
@@ -204,6 +206,7 @@ fn test_swap_uids_and_keys() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
+
         let netuid = add_dynamic_network(&old_hotkey, &coldkey);
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
 
@@ -235,6 +238,7 @@ fn test_swap_prometheus() {
         let coldkey = U256::from(3);
 
         let prometheus_info = PrometheusInfo::default();
+
         let netuid = add_dynamic_network(&old_hotkey, &coldkey);
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
 
@@ -267,6 +271,7 @@ fn test_swap_axons() {
         let coldkey = U256::from(3);
 
         let axon_info = AxonInfo::default();
+
         let netuid = add_dynamic_network(&old_hotkey, &coldkey);
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
 
@@ -296,6 +301,7 @@ fn test_swap_certificates() {
         let coldkey = U256::from(3);
 
         let certificate = NeuronCertificate::try_from(vec![1, 2, 3]).unwrap();
+
         let netuid = add_dynamic_network(&old_hotkey, &coldkey);
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
 
@@ -331,6 +337,7 @@ fn test_swap_weight_commits() {
 
         let mut weight_commits: VecDeque<(H256, u64, u64, u64)> = VecDeque::new();
         weight_commits.push_back((H256::from_low_u64_be(100), 200, 1, 1));
+
         let netuid = add_dynamic_network(&old_hotkey, &coldkey);
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
 
@@ -364,6 +371,7 @@ fn test_swap_loaded_emission() {
 
         let server_emission = 1000u64;
         let validator_emission = 1000u64;
+
         let netuid = add_dynamic_network(&old_hotkey, &coldkey);
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
 
@@ -764,7 +772,7 @@ fn test_swap_hotkey_with_multiple_coldkeys_and_subnets() {
 fn test_swap_hotkey_tx_rate_limit_exceeded() {
     new_test_ext(1).execute_with(|| {
         let netuid = NetUid::from(1);
-        let tempo = 13;
+        let tempo: u16 = 13;
         let old_hotkey = U256::from(1);
         let new_hotkey_1 = U256::from(2);
         let new_hotkey_2 = U256::from(4);
@@ -824,7 +832,7 @@ fn test_swap_hotkey_tx_rate_limit_exceeded() {
 fn test_do_swap_hotkey_err_not_owner() {
     new_test_ext(1).execute_with(|| {
         let netuid = NetUid::from(1);
-        let tempo = 13;
+        let tempo: u16 = 13;
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
@@ -1443,6 +1451,7 @@ fn test_swap_owner_failed_interval_not_passed() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
+
         let netuid = add_dynamic_network(&old_hotkey, &coldkey);
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
         Owner::<Test>::insert(old_hotkey, coldkey);
@@ -1464,6 +1473,7 @@ fn test_swap_owner_check_swap_block_set() {
         let old_hotkey = U256::from(1);
         let new_hotkey = U256::from(2);
         let coldkey = U256::from(3);
+
         let netuid = add_dynamic_network(&old_hotkey, &coldkey);
         SubtensorModule::add_balance_to_coldkey_account(&coldkey, u64::MAX);
         Owner::<Test>::insert(old_hotkey, coldkey);
@@ -1506,9 +1516,7 @@ fn test_swap_owner_check_swap_record_clean_up() {
             new_block_number
         );
 
-        let netuid_u16: u16 = netuid.into();
-
-        step_block((HotkeySwapOnSubnetInterval::get() as u16 + netuid_u16) * 2u16);
+        step_block((HotkeySwapOnSubnetInterval::get() as u16 + u16::from(netuid)) * 2);
         assert!(!LastHotkeySwapOnNetuid::<Test>::contains_key(
             netuid, coldkey
         ));

From 8be6b0ead95d68097c6c2f275f877c3f5359cd2c Mon Sep 17 00:00:00 2001
From: Loris Moulin <contact@lorismoulin.com>
Date: Tue, 17 Jun 2025 05:17:44 +0200
Subject: [PATCH 398/418] update benchmark weight

---
 pallets/admin-utils/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pallets/admin-utils/src/lib.rs b/pallets/admin-utils/src/lib.rs
index 0f544b504d..8b871f88a1 100644
--- a/pallets/admin-utils/src/lib.rs
+++ b/pallets/admin-utils/src/lib.rs
@@ -170,7 +170,7 @@ pub mod pallet {
         /// It is only callable by the root account.
         /// The extrinsic will call the Subtensor pallet to set the default take.
         #[pallet::call_index(1)]
-        #[pallet::weight(Weight::from_parts(6_942_000, 0)
+        #[pallet::weight(Weight::from_parts(5_831_000, 0)
         .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(0_u64))
         .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1_u64)))]
         pub fn sudo_set_default_take(origin: OriginFor<T>, default_take: u16) -> DispatchResult {

From e66e7e9175094854a642df644e625dfd5270efed Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Tue, 17 Jun 2025 19:22:28 +0800
Subject: [PATCH 399/418] use hotkey to register uid in evm

---
 evm-tests/test/uid.precompile.lookup.test.ts |  3 +--
 pallets/subtensor/src/macros/dispatches.rs   |  3 +--
 pallets/subtensor/src/tests/evm.rs           | 15 +++++----------
 pallets/subtensor/src/utils/evm.rs           |  8 +-------
 4 files changed, 8 insertions(+), 21 deletions(-)

diff --git a/evm-tests/test/uid.precompile.lookup.test.ts b/evm-tests/test/uid.precompile.lookup.test.ts
index 6e702d612e..f6e22ce032 100644
--- a/evm-tests/test/uid.precompile.lookup.test.ts
+++ b/evm-tests/test/uid.precompile.lookup.test.ts
@@ -55,12 +55,11 @@ describe("Test the UID Lookup precompile", () => {
         const signature = await evmWallet.signMessage(concatenatedArray);
         const associateEvmKeyTx = api.tx.SubtensorModule.associate_evm_key({
             netuid: netuid,
-            hotkey: convertPublicKeyToSs58(hotkey.publicKey),
             evm_key: convertToFixedSizeBinary(evmWallet.address, 20),
             block_number: BigInt(blockNumber),
             signature: convertToFixedSizeBinary(signature, 65)
         });
-        const signer = getSignerFromKeypair(coldkey);
+        const signer = getSignerFromKeypair(hotkey);
         await waitForTransactionCompletion(api, associateEvmKeyTx, signer)
             .then(() => { })
             .catch((error) => { console.log(`transaction error ${error}`) });
diff --git a/pallets/subtensor/src/macros/dispatches.rs b/pallets/subtensor/src/macros/dispatches.rs
index 7d4f1a0850..d0902818fa 100644
--- a/pallets/subtensor/src/macros/dispatches.rs
+++ b/pallets/subtensor/src/macros/dispatches.rs
@@ -2001,12 +2001,11 @@ mod dispatches {
         pub fn associate_evm_key(
             origin: T::RuntimeOrigin,
             netuid: NetUid,
-            hotkey: T::AccountId,
             evm_key: H160,
             block_number: u64,
             signature: Signature,
         ) -> DispatchResult {
-            Self::do_associate_evm_key(origin, netuid, hotkey, evm_key, block_number, signature)
+            Self::do_associate_evm_key(origin, netuid, evm_key, block_number, signature)
         }
 
         /// Recycles alpha from a cold/hot key pair, reducing AlphaOut on a subnet
diff --git a/pallets/subtensor/src/tests/evm.rs b/pallets/subtensor/src/tests/evm.rs
index 95d0c4e6db..c08889f848 100644
--- a/pallets/subtensor/src/tests/evm.rs
+++ b/pallets/subtensor/src/tests/evm.rs
@@ -58,9 +58,8 @@ fn test_associate_evm_key_success() {
         let signature = sign_evm_message(&pair, message);
 
         assert_ok!(SubtensorModule::associate_evm_key(
-            RuntimeOrigin::signed(coldkey),
+            RuntimeOrigin::signed(hotkey),
             netuid,
-            hotkey,
             evm_key,
             block_number,
             signature,
@@ -105,9 +104,8 @@ fn test_associate_evm_key_different_block_number_success() {
         let signature = sign_evm_message(&pair, message);
 
         assert_ok!(SubtensorModule::associate_evm_key(
-            RuntimeOrigin::signed(coldkey),
+            RuntimeOrigin::signed(hotkey),
             netuid,
-            hotkey,
             evm_key,
             block_number,
             signature,
@@ -150,9 +148,8 @@ fn test_associate_evm_key_coldkey_does_not_own_hotkey() {
 
         assert_err!(
             SubtensorModule::associate_evm_key(
-                RuntimeOrigin::signed(coldkey),
+                RuntimeOrigin::signed(hotkey),
                 netuid,
-                hotkey,
                 evm_key,
                 block_number,
                 signature,
@@ -188,9 +185,8 @@ fn test_associate_evm_key_hotkey_not_registered_in_subnet() {
 
         assert_err!(
             SubtensorModule::associate_evm_key(
-                RuntimeOrigin::signed(coldkey),
+                RuntimeOrigin::signed(hotkey),
                 netuid,
-                hotkey,
                 evm_key,
                 block_number,
                 signature,
@@ -229,9 +225,8 @@ fn test_associate_evm_key_using_wrong_hash_function() {
 
         assert_err!(
             SubtensorModule::associate_evm_key(
-                RuntimeOrigin::signed(coldkey),
+                RuntimeOrigin::signed(hotkey),
                 netuid,
-                hotkey,
                 evm_key,
                 block_number,
                 signature,
diff --git a/pallets/subtensor/src/utils/evm.rs b/pallets/subtensor/src/utils/evm.rs
index 5d4f1ad493..ba6214968d 100644
--- a/pallets/subtensor/src/utils/evm.rs
+++ b/pallets/subtensor/src/utils/evm.rs
@@ -44,17 +44,11 @@ impl<T: Config> Pallet<T> {
     pub fn do_associate_evm_key(
         origin: T::RuntimeOrigin,
         netuid: NetUid,
-        hotkey: T::AccountId,
         evm_key: H160,
         block_number: u64,
         mut signature: Signature,
     ) -> dispatch::DispatchResult {
-        let coldkey = ensure_signed(origin)?;
-
-        ensure!(
-            Self::get_owning_coldkey_for_hotkey(&hotkey) == coldkey,
-            Error::<T>::NonAssociatedColdKey
-        );
+        let hotkey = ensure_signed(origin)?;
 
         // Normalize the v value to 0 or 1
         if signature.0[64] >= 27 {

From 5b510d369191ab10453cb6c845f90fb264fcd740 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Tue, 17 Jun 2025 21:12:46 +0800
Subject: [PATCH 400/418] cargo clippy

---
 pallets/subtensor/src/tests/evm.rs | 36 ------------------------------
 1 file changed, 36 deletions(-)

diff --git a/pallets/subtensor/src/tests/evm.rs b/pallets/subtensor/src/tests/evm.rs
index c08889f848..a65e69c207 100644
--- a/pallets/subtensor/src/tests/evm.rs
+++ b/pallets/subtensor/src/tests/evm.rs
@@ -123,42 +123,6 @@ fn test_associate_evm_key_different_block_number_success() {
     });
 }
 
-#[test]
-fn test_associate_evm_key_coldkey_does_not_own_hotkey() {
-    new_test_ext(1).execute_with(|| {
-        let netuid = NetUid::from(1);
-
-        let tempo: u16 = 2;
-        let modality: u16 = 2;
-
-        add_network(netuid, tempo, modality);
-
-        let coldkey = U256::from(1);
-        let hotkey = U256::from(2);
-
-        let pair = ecdsa::Pair::generate().0;
-        let public = pair.public();
-        let evm_key = public_to_evm_key(&public);
-        let block_number = frame_system::Pallet::<Test>::block_number();
-        let hashed_block_number = keccak_256(block_number.encode().as_ref());
-        let hotkey_bytes = hotkey.encode();
-
-        let message = [hotkey_bytes.as_ref(), hashed_block_number.as_ref()].concat();
-        let signature = sign_evm_message(&pair, message);
-
-        assert_err!(
-            SubtensorModule::associate_evm_key(
-                RuntimeOrigin::signed(hotkey),
-                netuid,
-                evm_key,
-                block_number,
-                signature,
-            ),
-            Error::<Test>::NonAssociatedColdKey
-        );
-    });
-}
-
 #[test]
 fn test_associate_evm_key_hotkey_not_registered_in_subnet() {
     new_test_ext(1).execute_with(|| {

From 5935085be84d1c8f08db557e540a5a649e35ed83 Mon Sep 17 00:00:00 2001
From: open-junius <zhou@opentensor.dev>
Date: Tue, 17 Jun 2025 21:24:38 +0800
Subject: [PATCH 401/418] update version

---
 runtime/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index 815e0a156b..595c54ba02 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -209,7 +209,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
     //   `spec_version`, and `authoring_version` are the same between Wasm and native.
     // This value is set to 100 to notify Polkadot-JS App (https://polkadot.js.org/apps) to use
     //   the compatible custom types.
-    spec_version: 278,
+    spec_version: 279,
     impl_version: 1,
     apis: RUNTIME_API_VERSIONS,
     transaction_version: 1,

From caf9ab2233638357df08a017b239cf28d26348c3 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Tue, 17 Jun 2025 13:11:01 -0400
Subject: [PATCH 402/418] Add (failing) test for wrapping fees

---
 pallets/swap/src/mock.rs         |   8 ++
 pallets/swap/src/pallet/tests.rs | 131 ++++++++++++++++++++++++++++++-
 2 files changed, 135 insertions(+), 4 deletions(-)

diff --git a/pallets/swap/src/mock.rs b/pallets/swap/src/mock.rs
index 68eba3d517..4ea245ec7d 100644
--- a/pallets/swap/src/mock.rs
+++ b/pallets/swap/src/mock.rs
@@ -31,8 +31,11 @@ pub const OK_COLDKEY_ACCOUNT_ID: AccountId = 1;
 pub const OK_HOTKEY_ACCOUNT_ID: AccountId = 1000;
 pub const OK_COLDKEY_ACCOUNT_ID_2: AccountId = 2;
 pub const OK_HOTKEY_ACCOUNT_ID_2: AccountId = 1001;
+pub const OK_COLDKEY_ACCOUNT_ID_RICH: AccountId = 5;
+pub const OK_HOTKEY_ACCOUNT_ID_RICH: AccountId = 1005;
 pub const NOT_SUBNET_OWNER: AccountId = 666;
 pub const NON_EXISTENT_NETUID: u16 = 999;
+pub const WRAPPING_FEES_NETUID: u16 = 124;
 
 parameter_types! {
     pub const BlockHashCount: u64 = 250;
@@ -86,6 +89,7 @@ impl SubnetInfo<AccountId> for MockLiquidityProvider {
     fn tao_reserve(netuid: NetUid) -> u64 {
         match netuid.into() {
             123u16 => 10_000,
+            WRAPPING_FEES_NETUID => 100_000_000_000,
             _ => 1_000_000_000_000,
         }
     }
@@ -93,6 +97,7 @@ impl SubnetInfo<AccountId> for MockLiquidityProvider {
     fn alpha_reserve(netuid: NetUid) -> u64 {
         match netuid.into() {
             123u16 => 10_000,
+            WRAPPING_FEES_NETUID => 400_000_000_000,
             _ => 4_000_000_000_000,
         }
     }
@@ -117,6 +122,7 @@ impl BalanceOps<AccountId> for MockBalanceOps {
         match *account_id {
             OK_COLDKEY_ACCOUNT_ID => 100_000_000_000_000,
             OK_COLDKEY_ACCOUNT_ID_2 => 100_000_000_000_000,
+            OK_COLDKEY_ACCOUNT_ID_RICH => 900_000_000_000_000_000_u64,
             _ => 1_000_000_000,
         }
     }
@@ -129,6 +135,7 @@ impl BalanceOps<AccountId> for MockBalanceOps {
         match (coldkey_account_id, hotkey_account_id) {
             (&OK_COLDKEY_ACCOUNT_ID, &OK_HOTKEY_ACCOUNT_ID) => 100_000_000_000_000,
             (&OK_COLDKEY_ACCOUNT_ID_2, &OK_HOTKEY_ACCOUNT_ID_2) => 100_000_000_000_000,
+            (&OK_COLDKEY_ACCOUNT_ID_RICH, &OK_HOTKEY_ACCOUNT_ID_RICH) => 900_000_000_000_000_000_u64,
             _ => 1_000_000_000,
         }
     }
@@ -188,6 +195,7 @@ pub fn new_test_ext() -> sp_io::TestExternalities {
             // enable V3 for this range of netuids
             EnabledUserLiquidity::<Test>::set(NetUid::from(netuid), true);
         }
+        EnabledUserLiquidity::<Test>::set(NetUid::from(WRAPPING_FEES_NETUID), true);
     });
     ext
 }
diff --git a/pallets/swap/src/pallet/tests.rs b/pallets/swap/src/pallet/tests.rs
index c72302c06b..d1e191bc69 100644
--- a/pallets/swap/src/pallet/tests.rs
+++ b/pallets/swap/src/pallet/tests.rs
@@ -387,13 +387,13 @@ fn test_add_liquidity_out_of_bounds() {
 #[test]
 fn test_add_liquidity_over_balance() {
     new_test_ext().execute_with(|| {
-        let coldkey_account_id = 2;
-        let hotkey_account_id = 3;
+        let coldkey_account_id = 3;
+        let hotkey_account_id = 1002;
 
         [
-            // Lower than price (not enough alpha)
+            // Lower than price (not enough tao)
             (0.1, 0.2, 100_000_000_000_u64),
-            // Higher than price (not enough tao)
+            // Higher than price (not enough alpha)
             (0.3, 0.4, 100_000_000_000_u64),
             // Around the price (not enough both)
             (0.1, 0.4, 100_000_000_000_u64),
@@ -1603,3 +1603,126 @@ fn test_new_lp_doesnt_get_old_fees() {
         assert_abs_diff_eq!(actual_fee_alpha, 0, epsilon = 1);
     });
 }
+
+fn bbox(t: U64F64, a: U64F64, b: U64F64) -> U64F64 {
+    if t < a {
+        a
+    } else if t > b {
+        b
+    } else {
+        t
+    }
+}
+
+#[test]
+fn test_wrapping_fees() {
+    new_test_ext().execute_with(|| {
+        let netuid = NetUid::from(WRAPPING_FEES_NETUID);
+        let position_1_low_price = 0.20;
+        let position_1_high_price = 0.255;
+        let position_2_low_price = 0.255;
+        let position_2_high_price = 0.3;
+        assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
+
+        Pallet::<Test>::do_add_liquidity(
+            netuid,
+            &OK_COLDKEY_ACCOUNT_ID_RICH,
+            &OK_COLDKEY_ACCOUNT_ID_RICH,
+            price_to_tick(position_1_low_price),
+            price_to_tick(position_1_high_price),
+            1_000_000_000_u64,
+        )
+        .unwrap();
+        let current_sqrt_price = Pallet::<Test>::current_price_sqrt(netuid).to_num::<f64>();
+        let current_price = current_sqrt_price * current_sqrt_price;
+        println!(
+            "Current price: {}",
+            format!("{:.6}", current_price)
+        );
+
+        let swap_amt = 800_000_000_u64;
+        let order_type = OrderType::Sell;
+        let sqrt_limit_price = SqrtPrice::from_num(0.000001);
+        Pallet::<Test>::do_swap(netuid, order_type, swap_amt, sqrt_limit_price, false).unwrap();
+
+        let swap_amt = 1_850_000_000_u64;
+        let order_type = OrderType::Buy;
+        let sqrt_limit_price = SqrtPrice::from_num(1_000_000.0);
+
+        let current_sqrt_price = Pallet::<Test>::current_price_sqrt(netuid).to_num::<f64>();
+        let current_price = current_sqrt_price * current_sqrt_price;
+        println!(
+            "Current price: {}",
+            format!("{:.6}", current_price)
+        );
+
+        Pallet::<Test>::do_swap(netuid, order_type, swap_amt, sqrt_limit_price, false).unwrap();
+
+        let current_sqrt_price = Pallet::<Test>::current_price_sqrt(netuid).to_num::<f64>();
+        let current_price = current_sqrt_price * current_sqrt_price;
+        println!(
+            "Current price: {}",
+            format!("{:.6}", current_price)
+        );
+
+        let add_liquidity_result = Pallet::<Test>::do_add_liquidity(
+            netuid,
+            &OK_COLDKEY_ACCOUNT_ID_RICH,
+            &OK_COLDKEY_ACCOUNT_ID_RICH,
+            price_to_tick(position_2_low_price),
+            price_to_tick(position_2_high_price),
+            1_000_000_000_u64,
+        )
+        .unwrap();
+
+        let swap_amt = 800_000_000_u64;
+        let order_type = OrderType::Sell;
+        let sqrt_limit_price = SqrtPrice::from_num(0.000001);
+        Pallet::<Test>::do_swap(netuid, order_type, swap_amt, sqrt_limit_price, false).unwrap();
+
+        let current_sqrt_price = Pallet::<Test>::current_price_sqrt(netuid).to_num::<f64>();
+        let current_price = current_sqrt_price * current_sqrt_price;
+        println!(
+            "Current price: {}",
+            format!("{:.6}", current_price)
+        );
+
+        let mut position = Positions::<Test>::get((netuid, &OK_COLDKEY_ACCOUNT_ID_RICH, add_liquidity_result.0)).unwrap();
+
+        let initial_sqrt_price = position.tick_high.try_to_sqrt_price().unwrap();
+        let initial_box_price = bbox(
+            initial_sqrt_price,
+            position.tick_low.try_to_sqrt_price().unwrap(),
+            position.tick_high.try_to_sqrt_price().unwrap(),
+        );
+        let final_sqrt_price = Pallet::<Test>::current_price_sqrt(netuid);
+        let final_box_price = bbox(
+            final_sqrt_price,
+            position.tick_low.try_to_sqrt_price().unwrap(),
+            position.tick_high.try_to_sqrt_price().unwrap(),
+        );
+        let fee_rate = FeeRate::<Test>::get(netuid) as f64 / u16::MAX as f64;
+
+        let expected_fee_tao = ((fee_rate / (1.0 - fee_rate))
+            * (position.liquidity as f64)
+            * (final_box_price.to_num::<f64>() - initial_box_price.to_num::<f64>()))
+            as u64;
+
+        let expected_fee_alpha = ((fee_rate / (1.0 - fee_rate))
+            * (position.liquidity as f64)
+            * ((1.0 / final_box_price.to_num::<f64>()) - (1.0 / initial_box_price.to_num::<f64>())))
+            as u64;
+
+        println!(
+            "Expected ALPHA fee: {}",
+            format!("{:.6}", expected_fee_alpha as f64)
+        );
+
+        let (fee_tao, fee_alpha) = position.collect_fees();
+
+        println!("Collected fees: TAO: {}, ALPHA: {}", fee_tao, fee_alpha);
+
+        assert_abs_diff_eq!(fee_tao, expected_fee_tao, epsilon = 1);
+        assert_abs_diff_eq!(fee_alpha, expected_fee_alpha, epsilon = 1);
+    });
+}
\ No newline at end of file

From a3c9bc4c4f934adc6be784840a31cd10c48b7935 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Tue, 17 Jun 2025 13:11:34 -0400
Subject: [PATCH 403/418] Use signed math for position fees

---
 pallets/subtensor/src/tests/staking.rs |  1 +
 pallets/swap/src/pallet/impls.rs       | 23 +++++-------
 pallets/swap/src/position.rs           | 52 +++++++++++++++++++++-----
 pallets/swap/src/tick.rs               | 24 +++++++-----
 4 files changed, 67 insertions(+), 33 deletions(-)

diff --git a/pallets/subtensor/src/tests/staking.rs b/pallets/subtensor/src/tests/staking.rs
index 0667a5b72a..536ff4feaf 100644
--- a/pallets/subtensor/src/tests/staking.rs
+++ b/pallets/subtensor/src/tests/staking.rs
@@ -5066,6 +5066,7 @@ fn test_default_min_stake_sufficiency() {
 
 /// Test that modify_position always credits fees
 ///
+/// cargo test --package pallet-subtensor --lib -- tests::staking::test_update_position_fees --exact --show-output
 #[test]
 fn test_update_position_fees() {
     // Test cases: add or remove liquidity during modification
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 1bca5d5762..5fd71b4494 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -6,7 +6,7 @@ use frame_support::{ensure, pallet_prelude::DispatchError, traits::Get};
 use safe_math::*;
 use sp_arithmetic::helpers_128bit;
 use sp_runtime::traits::AccountIdConversion;
-use substrate_fixed::types::{U64F64, U96F32};
+use substrate_fixed::types::{I64F64, U64F64, U96F32};
 use subtensor_runtime_common::{BalanceOps, NetUid, SubnetInfo};
 use subtensor_swap_interface::{SwapHandler, SwapResult, UpdateLiquidityResult};
 
@@ -209,9 +209,9 @@ impl<T: Config> SwapStep<T> {
         if self.action == SwapStepAction::Crossing {
             let mut tick = Ticks::<T>::get(self.netuid, self.edge_tick).unwrap_or_default();
             tick.fees_out_tao =
-                FeeGlobalTao::<T>::get(self.netuid).saturating_sub(tick.fees_out_tao);
+                I64F64::saturating_from_num(FeeGlobalTao::<T>::get(self.netuid)).saturating_sub(tick.fees_out_tao);
             tick.fees_out_alpha =
-                FeeGlobalAlpha::<T>::get(self.netuid).saturating_sub(tick.fees_out_alpha);
+                I64F64::saturating_from_num(FeeGlobalAlpha::<T>::get(self.netuid)).saturating_sub(tick.fees_out_alpha);
             Pallet::<T>::update_liquidity_at_crossing(self.netuid, self.order_type)?;
             Ticks::<T>::insert(self.netuid, self.edge_tick, tick);
         }
@@ -784,16 +784,13 @@ impl<T: Config> Pallet<T> {
 
         // New position
         let position_id = PositionId::new::<T>();
-        let position = Position {
-            id: position_id,
+        let position = Position::new(
+            position_id,
             netuid,
             tick_low,
             tick_high,
             liquidity,
-            fees_tao: U64F64::saturating_from_num(0),
-            fees_alpha: U64F64::saturating_from_num(0),
-            _phantom: PhantomData,
-        };
+        );
 
         let current_price_sqrt = Pallet::<T>::current_price_sqrt(netuid);
         let (tao, alpha) = position.to_token_amounts(current_price_sqrt)?;
@@ -987,13 +984,13 @@ impl<T: Config> Pallet<T> {
 
                 let (fees_out_tao, fees_out_alpha) = if tick_index > current_tick {
                     (
-                        FeeGlobalTao::<T>::get(netuid),
-                        FeeGlobalAlpha::<T>::get(netuid),
+                        I64F64::saturating_from_num(FeeGlobalTao::<T>::get(netuid)),
+                        I64F64::saturating_from_num(FeeGlobalAlpha::<T>::get(netuid)),
                     )
                 } else {
                     (
-                        U64F64::saturating_from_num(0),
-                        U64F64::saturating_from_num(0),
+                        I64F64::saturating_from_num(0),
+                        I64F64::saturating_from_num(0),
                     )
                 };
                 *maybe_tick = Some(Tick {
diff --git a/pallets/swap/src/position.rs b/pallets/swap/src/position.rs
index e750297884..0f27d69d77 100644
--- a/pallets/swap/src/position.rs
+++ b/pallets/swap/src/position.rs
@@ -3,7 +3,7 @@ use core::marker::PhantomData;
 use codec::{Decode, Encode, MaxEncodedLen};
 use frame_support::pallet_prelude::*;
 use safe_math::*;
-use substrate_fixed::types::U64F64;
+use substrate_fixed::types::{I64F64, U64F64};
 use subtensor_macros::freeze_struct;
 use subtensor_runtime_common::NetUid;
 
@@ -15,7 +15,7 @@ use crate::tick::TickIndex;
 ///
 /// Alpha price is expressed in rao units per one 10^9 unit. For example,
 /// price 1_000_000 is equal to 0.001 TAO per Alpha.
-#[freeze_struct("64d56db027265714")]
+#[freeze_struct("27a1bf8c59480f0")]
 #[derive(Clone, Encode, Decode, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen, Default)]
 #[scale_info(skip_type_params(T))]
 pub struct Position<T: Config> {
@@ -29,15 +29,39 @@ pub struct Position<T: Config> {
     pub tick_high: TickIndex,
     /// Position liquidity
     pub liquidity: u64,
-    /// Fees accrued by the position in quote currency (TAO)
-    pub fees_tao: U64F64,
-    /// Fees accrued by the position in base currency (Alpha)
-    pub fees_alpha: U64F64,
+    /// Fees accrued by the position in quote currency (TAO) relative to global fees
+    pub fees_tao: I64F64,
+    /// Fees accrued by the position in base currency (Alpha) relative to global fees
+    pub fees_alpha: I64F64,
     /// Phantom marker for generic Config type
     pub _phantom: PhantomData<T>,
 }
 
 impl<T: Config> Position<T> {
+    pub fn new(
+        id: PositionId,
+        netuid: NetUid,
+        tick_low: TickIndex,
+        tick_high: TickIndex,
+        liquidity: u64,
+    ) -> Self {
+        let mut position = Position {
+            id,
+            netuid,
+            tick_low,
+            tick_high,
+            liquidity,
+            fees_tao: I64F64::saturating_from_num(0),
+            fees_alpha: I64F64::saturating_from_num(0),
+            _phantom: PhantomData,
+        };
+
+        position.fees_tao = position.fees_in_range(true);
+        position.fees_alpha = position.fees_in_range(false);
+
+        position
+    }
+
     /// Converts position to token amounts
     ///
     /// returns tuple of (TAO, Alpha)
@@ -110,10 +134,18 @@ impl<T: Config> Position<T> {
         self.fees_tao = fee_tao_agg;
         self.fees_alpha = fee_alpha_agg;
 
-        let liquidity_frac = U64F64::saturating_from_num(self.liquidity);
+        let liquidity_frac = I64F64::saturating_from_num(self.liquidity);
+
+        println!("liquidity_frac = {:?}", liquidity_frac);
+        println!("fee_tao = {:?}", fee_tao);
+        println!("fee_alpha = {:?}", fee_alpha);
+
         fee_tao = liquidity_frac.saturating_mul(fee_tao);
         fee_alpha = liquidity_frac.saturating_mul(fee_alpha);
 
+        println!("fee_tao = {:?}", fee_tao);
+        println!("fee_alpha = {:?}", fee_alpha);
+
         (
             fee_tao.saturating_to_num::<u64>(),
             fee_alpha.saturating_to_num::<u64>(),
@@ -123,11 +155,11 @@ impl<T: Config> Position<T> {
     /// Get fees in a position's range
     ///
     /// If quote flag is true, Tao is returned, otherwise alpha.
-    fn fees_in_range(&self, quote: bool) -> U64F64 {
+    fn fees_in_range(&self, quote: bool) -> I64F64 {
         if quote {
-            FeeGlobalTao::<T>::get(self.netuid)
+            I64F64::saturating_from_num(FeeGlobalTao::<T>::get(self.netuid))
         } else {
-            FeeGlobalAlpha::<T>::get(self.netuid)
+            I64F64::saturating_from_num(FeeGlobalAlpha::<T>::get(self.netuid))
         }
         .saturating_sub(self.tick_low.fees_below::<T>(self.netuid, quote))
         .saturating_sub(self.tick_high.fees_above::<T>(self.netuid, quote))
diff --git a/pallets/swap/src/tick.rs b/pallets/swap/src/tick.rs
index 29106acc84..20a19007d7 100644
--- a/pallets/swap/src/tick.rs
+++ b/pallets/swap/src/tick.rs
@@ -12,7 +12,7 @@ use frame_support::pallet_prelude::*;
 use safe_math::*;
 use sp_std::vec;
 use sp_std::vec::Vec;
-use substrate_fixed::types::U64F64;
+use substrate_fixed::types::{I64F64, U64F64};
 use subtensor_macros::freeze_struct;
 use subtensor_runtime_common::NetUid;
 
@@ -79,13 +79,13 @@ const TICK_HIGH: I256 = I256::from_raw(U256::from_limbs([
 ///  - Net liquidity
 ///  - Gross liquidity
 ///  - Fees (above global) in both currencies
-#[freeze_struct("a73c75ea32eb04ed")]
+#[freeze_struct("ff1bce826e64c4aa")]
 #[derive(Debug, Default, Clone, Encode, Decode, TypeInfo, MaxEncodedLen, PartialEq, Eq)]
 pub struct Tick {
     pub liquidity_net: i128,
     pub liquidity_gross: u64,
-    pub fees_out_tao: U64F64,
-    pub fees_out_alpha: U64F64,
+    pub fees_out_tao: I64F64,
+    pub fees_out_alpha: I64F64,
 }
 
 impl Tick {
@@ -213,15 +213,17 @@ impl TickIndex {
     }
 
     /// Get fees above a tick
-    pub fn fees_above<T: Config>(&self, netuid: NetUid, quote: bool) -> U64F64 {
+    pub fn fees_above<T: Config>(&self, netuid: NetUid, quote: bool) -> I64F64 {
         let current_tick = Self::current_bounded::<T>(netuid);
 
         let tick = Ticks::<T>::get(netuid, *self).unwrap_or_default();
         if *self <= current_tick {
             if quote {
-                FeeGlobalTao::<T>::get(netuid).saturating_sub(tick.fees_out_tao)
+                I64F64::saturating_from_num(FeeGlobalTao::<T>::get(netuid))
+                    .saturating_sub(tick.fees_out_tao)
             } else {
-                FeeGlobalAlpha::<T>::get(netuid).saturating_sub(tick.fees_out_alpha)
+                I64F64::saturating_from_num(FeeGlobalAlpha::<T>::get(netuid))
+                    .saturating_sub(tick.fees_out_alpha)
             }
         } else if quote {
             tick.fees_out_tao
@@ -231,7 +233,7 @@ impl TickIndex {
     }
 
     /// Get fees below a tick
-    pub fn fees_below<T: Config>(&self, netuid: NetUid, quote: bool) -> U64F64 {
+    pub fn fees_below<T: Config>(&self, netuid: NetUid, quote: bool) -> I64F64 {
         let current_tick = Self::current_bounded::<T>(netuid);
 
         let tick = Ticks::<T>::get(netuid, *self).unwrap_or_default();
@@ -242,9 +244,11 @@ impl TickIndex {
                 tick.fees_out_alpha
             }
         } else if quote {
-            FeeGlobalTao::<T>::get(netuid).saturating_sub(tick.fees_out_tao)
+            I64F64::saturating_from_num(FeeGlobalTao::<T>::get(netuid))
+                .saturating_sub(tick.fees_out_tao)
         } else {
-            FeeGlobalAlpha::<T>::get(netuid).saturating_sub(tick.fees_out_alpha)
+            I64F64::saturating_from_num(FeeGlobalAlpha::<T>::get(netuid))
+                .saturating_sub(tick.fees_out_alpha)
         }
     }
 

From 0952fd936602f319770f3f3af958c8f580e7c068 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Tue, 17 Jun 2025 18:49:59 -0400
Subject: [PATCH 404/418] Fix liquidity update in block step

---
 .../subtensor/src/coinbase/run_coinbase.rs    |  2 +
 pallets/subtensor/src/tests/coinbase.rs       | 42 +++++++++++++++++++
 pallets/swap-interface/src/lib.rs             |  1 +
 pallets/swap/src/benchmarking.rs              | 10 ++---
 pallets/swap/src/lib.rs                       |  2 +-
 pallets/swap/src/mock.rs                      |  4 +-
 pallets/swap/src/pallet/impls.rs              | 40 +++++++++++++-----
 pallets/swap/src/pallet/tests.rs              | 30 +++++--------
 pallets/swap/src/position.rs                  |  7 ----
 9 files changed, 94 insertions(+), 44 deletions(-)

diff --git a/pallets/subtensor/src/coinbase/run_coinbase.rs b/pallets/subtensor/src/coinbase/run_coinbase.rs
index 2bc393daf4..1274a84a6f 100644
--- a/pallets/subtensor/src/coinbase/run_coinbase.rs
+++ b/pallets/subtensor/src/coinbase/run_coinbase.rs
@@ -139,6 +139,8 @@ impl<T: Config> Pallet<T> {
             TotalIssuance::<T>::mutate(|total| {
                 *total = total.saturating_add(tao_in_i);
             });
+            // Adjust protocol liquidity based on new reserves
+            T::SwapInterface::adjust_protocol_liquidity(*netuid_i);
         }
 
         // --- 5. Compute owner cuts and remove them from alpha_out remaining.
diff --git a/pallets/subtensor/src/tests/coinbase.rs b/pallets/subtensor/src/tests/coinbase.rs
index d1b5403669..285c318ba2 100644
--- a/pallets/subtensor/src/tests/coinbase.rs
+++ b/pallets/subtensor/src/tests/coinbase.rs
@@ -6,6 +6,7 @@ use crate::*;
 use alloc::collections::BTreeMap;
 use approx::assert_abs_diff_eq;
 use frame_support::assert_ok;
+use pallet_subtensor_swap::position::PositionId;
 use sp_core::U256;
 use substrate_fixed::types::{I64F64, I96F32, U96F32};
 
@@ -2154,3 +2155,44 @@ fn test_run_coinbase_not_started_start_after() {
         log::info!("new_stake: {}", new_stake);
     });
 }
+
+/// Test that coinbase updates protocol position liquidity
+/// cargo test --package pallet-subtensor --lib -- tests::coinbase::test_coinbase_v3_liquidity_update --exact --show-output
+#[test]
+fn test_coinbase_v3_liquidity_update() {
+    new_test_ext(1).execute_with(|| {
+        let owner_hotkey = U256::from(1);
+        let owner_coldkey = U256::from(2);
+
+        // add network
+        let netuid = add_dynamic_network(&owner_hotkey, &owner_coldkey);
+
+        // Force the swap to initialize
+        SubtensorModule::swap_tao_for_alpha(netuid, 0, 1_000_000_000_000).unwrap();
+
+        let protocol_account_id = pallet_subtensor_swap::Pallet::<Test>::protocol_account_id();
+        let position = pallet_subtensor_swap::Positions::<Test>::get((
+            netuid,
+            protocol_account_id,
+            PositionId::from(1),
+        ))
+        .unwrap();
+        let liquidity_before = position.liquidity;
+
+        // Enable emissions and run coinbase (which will increase position liquidity)
+        let emission: u64 = 1_234_567;
+        FirstEmissionBlockNumber::<Test>::insert(netuid, 0);
+        SubnetMovingPrice::<Test>::insert(netuid, I96F32::from_num(0.5));
+        SubtensorModule::run_coinbase(U96F32::from_num(emission));
+
+        let position_after = pallet_subtensor_swap::Positions::<Test>::get((
+            netuid,
+            protocol_account_id,
+            PositionId::from(1),
+        ))
+        .unwrap();
+        let liquidity_after = position_after.liquidity;
+
+        assert!(liquidity_before < liquidity_after);
+    });
+}
diff --git a/pallets/swap-interface/src/lib.rs b/pallets/swap-interface/src/lib.rs
index 07e33d0948..f0ee27acfb 100644
--- a/pallets/swap-interface/src/lib.rs
+++ b/pallets/swap-interface/src/lib.rs
@@ -27,6 +27,7 @@ pub trait SwapHandler<AccountId> {
     fn current_alpha_price(netuid: NetUid) -> U96F32;
     fn max_price() -> u64;
     fn min_price() -> u64;
+    fn adjust_protocol_liquidity(netuid: NetUid);
 }
 
 #[derive(Debug, PartialEq)]
diff --git a/pallets/swap/src/benchmarking.rs b/pallets/swap/src/benchmarking.rs
index 838a5e7def..ec360244f0 100644
--- a/pallets/swap/src/benchmarking.rs
+++ b/pallets/swap/src/benchmarking.rs
@@ -7,7 +7,7 @@ use core::marker::PhantomData;
 use frame_benchmarking::v2::*;
 use frame_support::traits::Get;
 use frame_system::RawOrigin;
-use substrate_fixed::types::U64F64;
+use substrate_fixed::types::{I64F64, U64F64};
 use subtensor_runtime_common::NetUid;
 
 use crate::{
@@ -82,8 +82,8 @@ mod benchmarks {
                 tick_low: TickIndex::new(-10000).unwrap(),
                 tick_high: TickIndex::new(10000).unwrap(),
                 liquidity: 1000,
-                fees_tao: U64F64::from_num(0),
-                fees_alpha: U64F64::from_num(0),
+                fees_tao: I64F64::from_num(0),
+                fees_alpha: I64F64::from_num(0),
                 _phantom: PhantomData,
             },
         );
@@ -115,8 +115,8 @@ mod benchmarks {
                 tick_low: TickIndex::new(-10000).unwrap(),
                 tick_high: TickIndex::new(10000).unwrap(),
                 liquidity: 10000,
-                fees_tao: U64F64::from_num(0),
-                fees_alpha: U64F64::from_num(0),
+                fees_tao: I64F64::from_num(0),
+                fees_alpha: I64F64::from_num(0),
                 _phantom: PhantomData,
             },
         );
diff --git a/pallets/swap/src/lib.rs b/pallets/swap/src/lib.rs
index 75961b73d1..b9d05bd435 100644
--- a/pallets/swap/src/lib.rs
+++ b/pallets/swap/src/lib.rs
@@ -4,7 +4,7 @@ use substrate_fixed::types::U64F64;
 use subtensor_swap_interface::OrderType;
 
 pub mod pallet;
-mod position;
+pub mod position;
 pub mod tick;
 pub mod weights;
 
diff --git a/pallets/swap/src/mock.rs b/pallets/swap/src/mock.rs
index 4ea245ec7d..8ae7f05764 100644
--- a/pallets/swap/src/mock.rs
+++ b/pallets/swap/src/mock.rs
@@ -135,7 +135,9 @@ impl BalanceOps<AccountId> for MockBalanceOps {
         match (coldkey_account_id, hotkey_account_id) {
             (&OK_COLDKEY_ACCOUNT_ID, &OK_HOTKEY_ACCOUNT_ID) => 100_000_000_000_000,
             (&OK_COLDKEY_ACCOUNT_ID_2, &OK_HOTKEY_ACCOUNT_ID_2) => 100_000_000_000_000,
-            (&OK_COLDKEY_ACCOUNT_ID_RICH, &OK_HOTKEY_ACCOUNT_ID_RICH) => 900_000_000_000_000_000_u64,
+            (&OK_COLDKEY_ACCOUNT_ID_RICH, &OK_HOTKEY_ACCOUNT_ID_RICH) => {
+                900_000_000_000_000_000_u64
+            }
             _ => 1_000_000_000,
         }
     }
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 5fd71b4494..5043f2b3f6 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -208,10 +208,11 @@ impl<T: Config> SwapStep<T> {
 
         if self.action == SwapStepAction::Crossing {
             let mut tick = Ticks::<T>::get(self.netuid, self.edge_tick).unwrap_or_default();
-            tick.fees_out_tao =
-                I64F64::saturating_from_num(FeeGlobalTao::<T>::get(self.netuid)).saturating_sub(tick.fees_out_tao);
+            tick.fees_out_tao = I64F64::saturating_from_num(FeeGlobalTao::<T>::get(self.netuid))
+                .saturating_sub(tick.fees_out_tao);
             tick.fees_out_alpha =
-                I64F64::saturating_from_num(FeeGlobalAlpha::<T>::get(self.netuid)).saturating_sub(tick.fees_out_alpha);
+                I64F64::saturating_from_num(FeeGlobalAlpha::<T>::get(self.netuid))
+                    .saturating_sub(tick.fees_out_alpha);
             Pallet::<T>::update_liquidity_at_crossing(self.netuid, self.order_type)?;
             Ticks::<T>::insert(self.netuid, self.edge_tick, tick);
         }
@@ -324,6 +325,27 @@ impl<T: Config> Pallet<T> {
         Ok(())
     }
 
+    /// Adjusts protocol liquidity with new values of TAO and Alpha reserve
+    pub(super) fn adjust_protocol_liquidity(netuid: NetUid) {
+        // Get updated reserves, calculate liquidity
+        let tao_reserve = <T as Config>::SubnetInfo::tao_reserve(netuid.into());
+        let alpha_reserve = <T as Config>::SubnetInfo::alpha_reserve(netuid.into());
+        let liquidity =
+            helpers_128bit::sqrt((tao_reserve as u128).saturating_mul(alpha_reserve as u128))
+                as u64;
+
+        // Update protocol position with new liquidity
+        let protocol_account_id = Self::protocol_account_id();
+        let mut positions =
+            Positions::<T>::iter_prefix_values((netuid, protocol_account_id.clone()))
+                .collect::<sp_std::vec::Vec<_>>();
+
+        if let Some(position) = positions.get_mut(0) {
+            position.liquidity = liquidity;
+            Positions::<T>::insert((netuid, protocol_account_id, position.id), position.clone());
+        }
+    }
+
     /// Executes a token swap on the specified subnet.
     ///
     /// # Parameters
@@ -784,13 +806,7 @@ impl<T: Config> Pallet<T> {
 
         // New position
         let position_id = PositionId::new::<T>();
-        let position = Position::new(
-            position_id,
-            netuid,
-            tick_low,
-            tick_high,
-            liquidity,
-        );
+        let position = Position::new(position_id, netuid, tick_low, tick_high, liquidity);
 
         let current_price_sqrt = Pallet::<T>::current_price_sqrt(netuid);
         let (tao, alpha) = position.to_token_amounts(current_price_sqrt)?;
@@ -1160,6 +1176,10 @@ impl<T: Config> SwapHandler<T::AccountId> for Pallet<T> {
             .saturating_round()
             .saturating_to_num()
     }
+
+    fn adjust_protocol_liquidity(netuid: NetUid) {
+        Self::adjust_protocol_liquidity(netuid);
+    }
 }
 
 #[derive(Debug, PartialEq)]
diff --git a/pallets/swap/src/pallet/tests.rs b/pallets/swap/src/pallet/tests.rs
index d1e191bc69..7a33e885ca 100644
--- a/pallets/swap/src/pallet/tests.rs
+++ b/pallets/swap/src/pallet/tests.rs
@@ -1635,10 +1635,7 @@ fn test_wrapping_fees() {
         .unwrap();
         let current_sqrt_price = Pallet::<Test>::current_price_sqrt(netuid).to_num::<f64>();
         let current_price = current_sqrt_price * current_sqrt_price;
-        println!(
-            "Current price: {}",
-            format!("{:.6}", current_price)
-        );
+        log::trace!("Current price: {}", format!("{:.6}", current_price));
 
         let swap_amt = 800_000_000_u64;
         let order_type = OrderType::Sell;
@@ -1651,19 +1648,13 @@ fn test_wrapping_fees() {
 
         let current_sqrt_price = Pallet::<Test>::current_price_sqrt(netuid).to_num::<f64>();
         let current_price = current_sqrt_price * current_sqrt_price;
-        println!(
-            "Current price: {}",
-            format!("{:.6}", current_price)
-        );
+        log::trace!("Current price: {}", format!("{:.6}", current_price));
 
         Pallet::<Test>::do_swap(netuid, order_type, swap_amt, sqrt_limit_price, false).unwrap();
 
         let current_sqrt_price = Pallet::<Test>::current_price_sqrt(netuid).to_num::<f64>();
         let current_price = current_sqrt_price * current_sqrt_price;
-        println!(
-            "Current price: {}",
-            format!("{:.6}", current_price)
-        );
+        log::trace!("Current price: {}", format!("{:.6}", current_price));
 
         let add_liquidity_result = Pallet::<Test>::do_add_liquidity(
             netuid,
@@ -1682,12 +1673,11 @@ fn test_wrapping_fees() {
 
         let current_sqrt_price = Pallet::<Test>::current_price_sqrt(netuid).to_num::<f64>();
         let current_price = current_sqrt_price * current_sqrt_price;
-        println!(
-            "Current price: {}",
-            format!("{:.6}", current_price)
-        );
+        log::trace!("Current price: {}", format!("{:.6}", current_price));
 
-        let mut position = Positions::<Test>::get((netuid, &OK_COLDKEY_ACCOUNT_ID_RICH, add_liquidity_result.0)).unwrap();
+        let mut position =
+            Positions::<Test>::get((netuid, &OK_COLDKEY_ACCOUNT_ID_RICH, add_liquidity_result.0))
+                .unwrap();
 
         let initial_sqrt_price = position.tick_high.try_to_sqrt_price().unwrap();
         let initial_box_price = bbox(
@@ -1713,16 +1703,16 @@ fn test_wrapping_fees() {
             * ((1.0 / final_box_price.to_num::<f64>()) - (1.0 / initial_box_price.to_num::<f64>())))
             as u64;
 
-        println!(
+        log::trace!(
             "Expected ALPHA fee: {}",
             format!("{:.6}", expected_fee_alpha as f64)
         );
 
         let (fee_tao, fee_alpha) = position.collect_fees();
 
-        println!("Collected fees: TAO: {}, ALPHA: {}", fee_tao, fee_alpha);
+        log::trace!("Collected fees: TAO: {}, ALPHA: {}", fee_tao, fee_alpha);
 
         assert_abs_diff_eq!(fee_tao, expected_fee_tao, epsilon = 1);
         assert_abs_diff_eq!(fee_alpha, expected_fee_alpha, epsilon = 1);
     });
-}
\ No newline at end of file
+}
diff --git a/pallets/swap/src/position.rs b/pallets/swap/src/position.rs
index 0f27d69d77..542aa389ad 100644
--- a/pallets/swap/src/position.rs
+++ b/pallets/swap/src/position.rs
@@ -136,16 +136,9 @@ impl<T: Config> Position<T> {
 
         let liquidity_frac = I64F64::saturating_from_num(self.liquidity);
 
-        println!("liquidity_frac = {:?}", liquidity_frac);
-        println!("fee_tao = {:?}", fee_tao);
-        println!("fee_alpha = {:?}", fee_alpha);
-
         fee_tao = liquidity_frac.saturating_mul(fee_tao);
         fee_alpha = liquidity_frac.saturating_mul(fee_alpha);
 
-        println!("fee_tao = {:?}", fee_tao);
-        println!("fee_alpha = {:?}", fee_alpha);
-
         (
             fee_tao.saturating_to_num::<u64>(),
             fee_alpha.saturating_to_num::<u64>(),

From 4fa912d701aa98985e4ea75dc57feace71dca8f7 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Tue, 17 Jun 2025 18:59:06 -0400
Subject: [PATCH 405/418] Fix test_wrapping_fees by removing last swap

---
 pallets/swap/src/pallet/tests.rs | 74 ++++++++++++++++----------------
 1 file changed, 38 insertions(+), 36 deletions(-)

diff --git a/pallets/swap/src/pallet/tests.rs b/pallets/swap/src/pallet/tests.rs
index 7a33e885ca..217519eb7b 100644
--- a/pallets/swap/src/pallet/tests.rs
+++ b/pallets/swap/src/pallet/tests.rs
@@ -1604,15 +1604,15 @@ fn test_new_lp_doesnt_get_old_fees() {
     });
 }
 
-fn bbox(t: U64F64, a: U64F64, b: U64F64) -> U64F64 {
-    if t < a {
-        a
-    } else if t > b {
-        b
-    } else {
-        t
-    }
-}
+// fn bbox(t: U64F64, a: U64F64, b: U64F64) -> U64F64 {
+//     if t < a {
+//         a
+//     } else if t > b {
+//         b
+//     } else {
+//         t
+//     }
+// }
 
 #[test]
 fn test_wrapping_fees() {
@@ -1666,10 +1666,10 @@ fn test_wrapping_fees() {
         )
         .unwrap();
 
-        let swap_amt = 800_000_000_u64;
-        let order_type = OrderType::Sell;
-        let sqrt_limit_price = SqrtPrice::from_num(0.000001);
-        Pallet::<Test>::do_swap(netuid, order_type, swap_amt, sqrt_limit_price, false).unwrap();
+        // let swap_amt = 800_000_000_u64;
+        // let order_type = OrderType::Sell;
+        // let sqrt_limit_price = SqrtPrice::from_num(0.000001);
+        // Pallet::<Test>::do_swap(netuid, order_type, swap_amt, sqrt_limit_price, false).unwrap();
 
         let current_sqrt_price = Pallet::<Test>::current_price_sqrt(netuid).to_num::<f64>();
         let current_price = current_sqrt_price * current_sqrt_price;
@@ -1679,29 +1679,31 @@ fn test_wrapping_fees() {
             Positions::<Test>::get((netuid, &OK_COLDKEY_ACCOUNT_ID_RICH, add_liquidity_result.0))
                 .unwrap();
 
-        let initial_sqrt_price = position.tick_high.try_to_sqrt_price().unwrap();
-        let initial_box_price = bbox(
-            initial_sqrt_price,
-            position.tick_low.try_to_sqrt_price().unwrap(),
-            position.tick_high.try_to_sqrt_price().unwrap(),
-        );
-        let final_sqrt_price = Pallet::<Test>::current_price_sqrt(netuid);
-        let final_box_price = bbox(
-            final_sqrt_price,
-            position.tick_low.try_to_sqrt_price().unwrap(),
-            position.tick_high.try_to_sqrt_price().unwrap(),
-        );
-        let fee_rate = FeeRate::<Test>::get(netuid) as f64 / u16::MAX as f64;
-
-        let expected_fee_tao = ((fee_rate / (1.0 - fee_rate))
-            * (position.liquidity as f64)
-            * (final_box_price.to_num::<f64>() - initial_box_price.to_num::<f64>()))
-            as u64;
-
-        let expected_fee_alpha = ((fee_rate / (1.0 - fee_rate))
-            * (position.liquidity as f64)
-            * ((1.0 / final_box_price.to_num::<f64>()) - (1.0 / initial_box_price.to_num::<f64>())))
-            as u64;
+        // let initial_sqrt_price = position.tick_high.try_to_sqrt_price().unwrap();
+        // let initial_box_price = bbox(
+        //     initial_sqrt_price,
+        //     position.tick_low.try_to_sqrt_price().unwrap(),
+        //     position.tick_high.try_to_sqrt_price().unwrap(),
+        // );
+        // let final_sqrt_price = Pallet::<Test>::current_price_sqrt(netuid);
+        // let final_box_price = bbox(
+        //     final_sqrt_price,
+        //     position.tick_low.try_to_sqrt_price().unwrap(),
+        //     position.tick_high.try_to_sqrt_price().unwrap(),
+        // );
+        // let fee_rate = FeeRate::<Test>::get(netuid) as f64 / u16::MAX as f64;
+
+        // let expected_fee_tao = ((fee_rate / (1.0 - fee_rate))
+        //     * (position.liquidity as f64)
+        //     * (final_box_price.to_num::<f64>() - initial_box_price.to_num::<f64>()))
+        //     as u64;
+
+        // let expected_fee_alpha = ((fee_rate / (1.0 - fee_rate))
+        //     * (position.liquidity as f64)
+        //     * ((1.0 / final_box_price.to_num::<f64>()) - (1.0 / initial_box_price.to_num::<f64>())))
+        //     as u64;
+        let expected_fee_tao = 0;
+        let expected_fee_alpha = 0;
 
         log::trace!(
             "Expected ALPHA fee: {}",

From cbfa9924cc4ee3f79b5bea2d2cbbfdf675dc64a5 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Wed, 18 Jun 2025 09:25:27 -0400
Subject: [PATCH 406/418] Fix the wrapping fees test

---
 Cargo.lock                       |   1 +
 pallets/swap/Cargo.toml          |   3 +
 pallets/swap/src/mock.rs         |   1 +
 pallets/swap/src/pallet/tests.rs | 112 ++++++++++++++++---------------
 4 files changed, 64 insertions(+), 53 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 5d2911fbdf..916d962d7e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6944,6 +6944,7 @@ dependencies = [
  "sp-io",
  "sp-runtime",
  "sp-std 14.0.0 (git+https://github.com/paritytech/polkadot-sdk.git?tag=polkadot-stable2409-7)",
+ "sp-tracing 17.0.1",
  "substrate-fixed",
  "subtensor-macros",
  "subtensor-runtime-common",
diff --git a/pallets/swap/Cargo.toml b/pallets/swap/Cargo.toml
index e1727a3b28..2cd7fd5b8a 100644
--- a/pallets/swap/Cargo.toml
+++ b/pallets/swap/Cargo.toml
@@ -26,6 +26,9 @@ subtensor-macros = { workspace = true }
 subtensor-runtime-common = {workspace = true}
 subtensor-swap-interface = { workspace = true }
 
+[dev-dependencies]
+sp-tracing = { workspace = true }
+
 [lints]
 workspace = true
 
diff --git a/pallets/swap/src/mock.rs b/pallets/swap/src/mock.rs
index 8ae7f05764..797fad5ee8 100644
--- a/pallets/swap/src/mock.rs
+++ b/pallets/swap/src/mock.rs
@@ -186,6 +186,7 @@ impl crate::pallet::Config for Test {
 
 // Build genesis storage according to the mock runtime.
 pub fn new_test_ext() -> sp_io::TestExternalities {
+    sp_tracing::try_init_simple();
     let storage = system::GenesisConfig::<Test>::default()
         .build_storage()
         .unwrap();
diff --git a/pallets/swap/src/pallet/tests.rs b/pallets/swap/src/pallet/tests.rs
index 217519eb7b..1f4770e43f 100644
--- a/pallets/swap/src/pallet/tests.rs
+++ b/pallets/swap/src/pallet/tests.rs
@@ -1604,16 +1604,23 @@ fn test_new_lp_doesnt_get_old_fees() {
     });
 }
 
-// fn bbox(t: U64F64, a: U64F64, b: U64F64) -> U64F64 {
-//     if t < a {
-//         a
-//     } else if t > b {
-//         b
-//     } else {
-//         t
-//     }
-// }
+fn bbox(t: U64F64, a: U64F64, b: U64F64) -> U64F64 {
+    if t < a {
+        a
+    } else if t > b {
+        b
+    } else {
+        t
+    }
+}
+
+fn print_current_price(netuid: NetUid) {
+    let current_sqrt_price = Pallet::<Test>::current_price_sqrt(netuid).to_num::<f64>();
+    let current_price = current_sqrt_price * current_sqrt_price;
+    log::trace!("Current price: {:.6}", current_price);
+}
 
+/// RUST_LOG=pallet_subtensor_swap=trace cargo test --package pallet-subtensor-swap --lib -- pallet::tests::test_wrapping_fees --exact --show-output --nocapture
 #[test]
 fn test_wrapping_fees() {
     new_test_ext().execute_with(|| {
@@ -1621,7 +1628,7 @@ fn test_wrapping_fees() {
         let position_1_low_price = 0.20;
         let position_1_high_price = 0.255;
         let position_2_low_price = 0.255;
-        let position_2_high_price = 0.3;
+        let position_2_high_price = 0.257;
         assert_ok!(Pallet::<Test>::maybe_initialize_v3(netuid));
 
         Pallet::<Test>::do_add_liquidity(
@@ -1633,9 +1640,8 @@ fn test_wrapping_fees() {
             1_000_000_000_u64,
         )
         .unwrap();
-        let current_sqrt_price = Pallet::<Test>::current_price_sqrt(netuid).to_num::<f64>();
-        let current_price = current_sqrt_price * current_sqrt_price;
-        log::trace!("Current price: {}", format!("{:.6}", current_price));
+
+        print_current_price(netuid);
 
         let swap_amt = 800_000_000_u64;
         let order_type = OrderType::Sell;
@@ -1646,15 +1652,11 @@ fn test_wrapping_fees() {
         let order_type = OrderType::Buy;
         let sqrt_limit_price = SqrtPrice::from_num(1_000_000.0);
 
-        let current_sqrt_price = Pallet::<Test>::current_price_sqrt(netuid).to_num::<f64>();
-        let current_price = current_sqrt_price * current_sqrt_price;
-        log::trace!("Current price: {}", format!("{:.6}", current_price));
+        print_current_price(netuid);
 
         Pallet::<Test>::do_swap(netuid, order_type, swap_amt, sqrt_limit_price, false).unwrap();
 
-        let current_sqrt_price = Pallet::<Test>::current_price_sqrt(netuid).to_num::<f64>();
-        let current_price = current_sqrt_price * current_sqrt_price;
-        log::trace!("Current price: {}", format!("{:.6}", current_price));
+        print_current_price(netuid);
 
         let add_liquidity_result = Pallet::<Test>::do_add_liquidity(
             netuid,
@@ -1666,49 +1668,53 @@ fn test_wrapping_fees() {
         )
         .unwrap();
 
-        // let swap_amt = 800_000_000_u64;
-        // let order_type = OrderType::Sell;
-        // let sqrt_limit_price = SqrtPrice::from_num(0.000001);
-        // Pallet::<Test>::do_swap(netuid, order_type, swap_amt, sqrt_limit_price, false).unwrap();
+        let swap_amt = 1_800_000_000_u64;
+        let order_type = OrderType::Sell;
+        let sqrt_limit_price = SqrtPrice::from_num(0.000001);
+
+        let initial_sqrt_price = Pallet::<Test>::current_price_sqrt(netuid);
+        Pallet::<Test>::do_swap(netuid, order_type, swap_amt, sqrt_limit_price, false).unwrap();
+        let final_sqrt_price = Pallet::<Test>::current_price_sqrt(netuid);
 
-        let current_sqrt_price = Pallet::<Test>::current_price_sqrt(netuid).to_num::<f64>();
-        let current_price = current_sqrt_price * current_sqrt_price;
-        log::trace!("Current price: {}", format!("{:.6}", current_price));
+        print_current_price(netuid);
 
         let mut position =
             Positions::<Test>::get((netuid, &OK_COLDKEY_ACCOUNT_ID_RICH, add_liquidity_result.0))
                 .unwrap();
 
-        // let initial_sqrt_price = position.tick_high.try_to_sqrt_price().unwrap();
-        // let initial_box_price = bbox(
-        //     initial_sqrt_price,
-        //     position.tick_low.try_to_sqrt_price().unwrap(),
-        //     position.tick_high.try_to_sqrt_price().unwrap(),
-        // );
-        // let final_sqrt_price = Pallet::<Test>::current_price_sqrt(netuid);
-        // let final_box_price = bbox(
-        //     final_sqrt_price,
-        //     position.tick_low.try_to_sqrt_price().unwrap(),
-        //     position.tick_high.try_to_sqrt_price().unwrap(),
-        // );
-        // let fee_rate = FeeRate::<Test>::get(netuid) as f64 / u16::MAX as f64;
-
-        // let expected_fee_tao = ((fee_rate / (1.0 - fee_rate))
-        //     * (position.liquidity as f64)
-        //     * (final_box_price.to_num::<f64>() - initial_box_price.to_num::<f64>()))
-        //     as u64;
-
-        // let expected_fee_alpha = ((fee_rate / (1.0 - fee_rate))
-        //     * (position.liquidity as f64)
-        //     * ((1.0 / final_box_price.to_num::<f64>()) - (1.0 / initial_box_price.to_num::<f64>())))
-        //     as u64;
-        let expected_fee_tao = 0;
-        let expected_fee_alpha = 0;
+        let initial_box_price = bbox(
+            initial_sqrt_price,
+            position.tick_low.try_to_sqrt_price().unwrap(),
+            position.tick_high.try_to_sqrt_price().unwrap(),
+        );
+
+        let final_box_price = bbox(
+            final_sqrt_price,
+            position.tick_low.try_to_sqrt_price().unwrap(),
+            position.tick_high.try_to_sqrt_price().unwrap(),
+        );
+
+        let fee_rate = FeeRate::<Test>::get(netuid) as f64 / u16::MAX as f64;
 
+        log::trace!("fee_rate: {:.6}", fee_rate);
+        log::trace!("position.liquidity: {}", position.liquidity);
         log::trace!(
-            "Expected ALPHA fee: {}",
-            format!("{:.6}", expected_fee_alpha as f64)
+            "initial_box_price: {:.6}",
+            initial_box_price.to_num::<f64>()
         );
+        log::trace!("final_box_price: {:.6}", final_box_price.to_num::<f64>());
+
+        let expected_fee_tao = ((fee_rate / (1.0 - fee_rate))
+            * (position.liquidity as f64)
+            * (final_box_price.to_num::<f64>() - initial_box_price.to_num::<f64>()))
+            as u64;
+
+        let expected_fee_alpha = ((fee_rate / (1.0 - fee_rate))
+            * (position.liquidity as f64)
+            * ((1.0 / final_box_price.to_num::<f64>()) - (1.0 / initial_box_price.to_num::<f64>())))
+            as u64;
+
+        log::trace!("Expected ALPHA fee: {:.6}", expected_fee_alpha as f64);
 
         let (fee_tao, fee_alpha) = position.collect_fees();
 

From e580ee457327de25cbdc86c6d69dcef2cb9b5b23 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Wed, 18 Jun 2025 10:26:21 -0400
Subject: [PATCH 407/418] Allow root to disable user liquidity

---
 pallets/subtensor/src/rpc_info/subnet_info.rs |  5 +-
 pallets/subtensor/src/staking/helpers.rs      |  4 ++
 pallets/subtensor/src/tests/subnet.rs         | 62 +++++++++++++++++++
 pallets/swap-interface/src/lib.rs             |  1 +
 pallets/swap/src/benchmarking.rs              |  4 +-
 pallets/swap/src/pallet/impls.rs              | 12 ++--
 pallets/swap/src/pallet/mod.rs                | 26 +++++---
 pallets/swap/src/pallet/tests.rs              | 25 +++++---
 8 files changed, 112 insertions(+), 27 deletions(-)

diff --git a/pallets/subtensor/src/rpc_info/subnet_info.rs b/pallets/subtensor/src/rpc_info/subnet_info.rs
index 636b72899b..656a69477d 100644
--- a/pallets/subtensor/src/rpc_info/subnet_info.rs
+++ b/pallets/subtensor/src/rpc_info/subnet_info.rs
@@ -52,7 +52,7 @@ pub struct SubnetInfov2<AccountId: TypeInfo + Encode + Decode> {
     identity: Option<SubnetIdentityV2>,
 }
 
-#[freeze_struct("7b506df55bd44646")]
+#[freeze_struct("769dc2ca2135b525")]
 #[derive(Decode, Encode, PartialEq, Eq, Clone, Debug, TypeInfo)]
 pub struct SubnetHyperparams {
     rho: Compact<u16>,
@@ -82,6 +82,7 @@ pub struct SubnetHyperparams {
     alpha_high: Compact<u16>,
     alpha_low: Compact<u16>,
     liquid_alpha_enabled: bool,
+    user_liquidity_enabled: bool,
 }
 
 impl<T: Config> Pallet<T> {
@@ -257,6 +258,7 @@ impl<T: Config> Pallet<T> {
         let commit_reveal_weights_enabled = Self::get_commit_reveal_weights_enabled(netuid);
         let liquid_alpha_enabled = Self::get_liquid_alpha_enabled(netuid);
         let (alpha_low, alpha_high): (u16, u16) = Self::get_alpha_values(netuid);
+        let user_liquidity_enabled: bool = Self::is_user_liquidity_enabled(netuid);
 
         Some(SubnetHyperparams {
             rho: rho.into(),
@@ -286,6 +288,7 @@ impl<T: Config> Pallet<T> {
             alpha_high: alpha_high.into(),
             alpha_low: alpha_low.into(),
             liquid_alpha_enabled,
+            user_liquidity_enabled,
         })
     }
 }
diff --git a/pallets/subtensor/src/staking/helpers.rs b/pallets/subtensor/src/staking/helpers.rs
index b36340bb30..286877b1c9 100644
--- a/pallets/subtensor/src/staking/helpers.rs
+++ b/pallets/subtensor/src/staking/helpers.rs
@@ -302,4 +302,8 @@ impl<T: Config> Pallet<T> {
 
         Ok(credit)
     }
+
+    pub fn is_user_liquidity_enabled(netuid: NetUid) -> bool {
+        T::SwapInterface::is_user_liquidity_enabled(netuid)
+    }
 }
diff --git a/pallets/subtensor/src/tests/subnet.rs b/pallets/subtensor/src/tests/subnet.rs
index f147a049e4..ebac3e786d 100644
--- a/pallets/subtensor/src/tests/subnet.rs
+++ b/pallets/subtensor/src/tests/subnet.rs
@@ -599,3 +599,65 @@ fn test_subtoken_enable_ok_for_burn_register_before_enable() {
         ));
     });
 }
+
+#[test]
+fn test_user_liquidity_access_control() {
+    new_test_ext(1).execute_with(|| {
+        let owner_hotkey = U256::from(1);
+        let owner_coldkey = U256::from(2);
+        let not_owner = U256::from(999); // arbitrary non-owner
+
+        // add network
+        let netuid = add_dynamic_network(&owner_hotkey, &owner_coldkey);
+
+        // Initially should be disabled
+        assert!(!pallet_subtensor_swap::EnabledUserLiquidity::<Test>::get(
+            NetUid::from(netuid)
+        ));
+
+        // Not owner, not root: should fail
+        assert_noop!(
+            Swap::toggle_user_liquidity(RuntimeOrigin::signed(not_owner), netuid, true),
+            DispatchError::BadOrigin
+        );
+
+        // Subnet owner can enable
+        assert_ok!(Swap::toggle_user_liquidity(
+            RuntimeOrigin::signed(owner_coldkey),
+            netuid,
+            true
+        ));
+        assert!(pallet_subtensor_swap::EnabledUserLiquidity::<Test>::get(
+            NetUid::from(netuid)
+        ));
+
+        // Root can disable
+        assert_ok!(Swap::toggle_user_liquidity(
+            RuntimeOrigin::root(),
+            netuid,
+            false
+        ));
+        assert!(!pallet_subtensor_swap::EnabledUserLiquidity::<Test>::get(
+            NetUid::from(netuid)
+        ));
+
+        // Root can enable again
+        assert_ok!(Swap::toggle_user_liquidity(
+            RuntimeOrigin::root(),
+            netuid,
+            true
+        ));
+        assert!(pallet_subtensor_swap::EnabledUserLiquidity::<Test>::get(
+            NetUid::from(netuid)
+        ));
+
+        // Subnet owner cannot disable (only root can disable)
+        assert_noop!(
+            Swap::toggle_user_liquidity(RuntimeOrigin::signed(owner_coldkey), netuid, false),
+            DispatchError::BadOrigin
+        );
+        assert!(pallet_subtensor_swap::EnabledUserLiquidity::<Test>::get(
+            NetUid::from(netuid)
+        ));
+    });
+}
diff --git a/pallets/swap-interface/src/lib.rs b/pallets/swap-interface/src/lib.rs
index f0ee27acfb..f09928a2b2 100644
--- a/pallets/swap-interface/src/lib.rs
+++ b/pallets/swap-interface/src/lib.rs
@@ -28,6 +28,7 @@ pub trait SwapHandler<AccountId> {
     fn max_price() -> u64;
     fn min_price() -> u64;
     fn adjust_protocol_liquidity(netuid: NetUid);
+    fn is_user_liquidity_enabled(netuid: NetUid) -> bool;
 }
 
 #[derive(Debug, PartialEq)]
diff --git a/pallets/swap/src/benchmarking.rs b/pallets/swap/src/benchmarking.rs
index ec360244f0..0d926a640f 100644
--- a/pallets/swap/src/benchmarking.rs
+++ b/pallets/swap/src/benchmarking.rs
@@ -132,13 +132,13 @@ mod benchmarks {
     }
 
     #[benchmark]
-    fn set_enabled_user_liquidity() {
+    fn toggle_user_liquidity() {
         let netuid = NetUid::from(101);
 
         assert!(!EnabledUserLiquidity::<T>::get(netuid));
 
         #[extrinsic_call]
-        set_enabled_user_liquidity(RawOrigin::Root, netuid.into());
+        toggle_user_liquidity(RawOrigin::Root, netuid.into(), true);
 
         assert!(EnabledUserLiquidity::<T>::get(netuid));
     }
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 5043f2b3f6..3f54dbfd74 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -816,7 +816,8 @@ impl<T: Config> Pallet<T> {
         Ok((position, tao, alpha))
     }
 
-    /// Remove liquidity and credit balances back to (coldkey_account_id, hotkey_account_id) stake
+    /// Remove liquidity and credit balances back to (coldkey_account_id, hotkey_account_id) stake.
+    /// Removing is allowed even when user liquidity is enabled.
     ///
     /// Account ID and Position ID identify position in the storage map
     pub fn do_remove_liquidity(
@@ -824,11 +825,6 @@ impl<T: Config> Pallet<T> {
         coldkey_account_id: &T::AccountId,
         position_id: PositionId,
     ) -> Result<UpdateLiquidityResult, Error<T>> {
-        ensure!(
-            EnabledUserLiquidity::<T>::get(netuid),
-            Error::<T>::UserLiquidityDisabled
-        );
-
         let Some(mut position) = Positions::<T>::get((netuid, coldkey_account_id, position_id))
         else {
             return Err(Error::<T>::LiquidityNotFound);
@@ -1180,6 +1176,10 @@ impl<T: Config> SwapHandler<T::AccountId> for Pallet<T> {
     fn adjust_protocol_liquidity(netuid: NetUid) {
         Self::adjust_protocol_liquidity(netuid);
     }
+
+    fn is_user_liquidity_enabled(netuid: NetUid) -> bool {
+        EnabledUserLiquidity::<T>::get(netuid)
+    }
 }
 
 #[derive(Debug, PartialEq)]
diff --git a/pallets/swap/src/pallet/mod.rs b/pallets/swap/src/pallet/mod.rs
index 77239af276..8100221c79 100644
--- a/pallets/swap/src/pallet/mod.rs
+++ b/pallets/swap/src/pallet/mod.rs
@@ -146,8 +146,8 @@ mod pallet {
         FeeRateSet { netuid: NetUid, rate: u16 },
 
         /// Event emitted when user liquidity operations are enabled for a subnet.
-        /// This indicates a permanent switch from V2 to V3 swap.
-        UserLiquidityEnabled { netuid: NetUid },
+        /// First enable even indicates a switch from V2 to V3 swap.
+        UserLiquidityToggled { netuid: NetUid, enable: bool },
 
         /// Event emitted when liquidity is added to a subnet's liquidity pool.
         LiquidityAdded {
@@ -261,17 +261,25 @@ mod pallet {
             Ok(())
         }
 
-        /// Enable user liquidity operations for a specific subnet. This permanently switches the
-        /// subnet from V2 to V3 swap mode. Once enabled, it cannot be disabled.
+        /// Enable user liquidity operations for a specific subnet. This switches the
+        /// subnet from V2 to V3 swap mode. Thereafter, adding new user liquidity can be disabled
+        /// by toggling this flag to false, but the swap mode will remain V3 because of existing
+        /// user liquidity until all users withdraw their liquidity.
         ///
-        /// Only callable by the admin origin
+        /// Only sudo or subnet owner can enable user liquidity.
+        /// Only sudo can disable user liquidity.
         #[pallet::call_index(4)]
         #[pallet::weight(<T as pallet::Config>::WeightInfo::set_enabled_user_liquidity())]
-        pub fn set_enabled_user_liquidity(origin: OriginFor<T>, netuid: NetUid) -> DispatchResult {
+        pub fn toggle_user_liquidity(
+            origin: OriginFor<T>,
+            netuid: NetUid,
+            enable: bool,
+        ) -> DispatchResult {
             if ensure_root(origin.clone()).is_err() {
                 let account_id: T::AccountId = ensure_signed(origin)?;
+                // Only enabling is allowed to subnet owner
                 ensure!(
-                    T::SubnetInfo::is_owner(&account_id, netuid.into()),
+                    T::SubnetInfo::is_owner(&account_id, netuid.into()) && enable,
                     DispatchError::BadOrigin
                 );
             }
@@ -281,9 +289,9 @@ mod pallet {
                 Error::<T>::SubNetworkDoesNotExist
             );
 
-            EnabledUserLiquidity::<T>::insert(netuid, true);
+            EnabledUserLiquidity::<T>::insert(netuid, enable);
 
-            Self::deposit_event(Event::UserLiquidityEnabled { netuid });
+            Self::deposit_event(Event::UserLiquidityToggled { netuid, enable });
 
             Ok(())
         }
diff --git a/pallets/swap/src/pallet/tests.rs b/pallets/swap/src/pallet/tests.rs
index 1f4770e43f..6e0ec65931 100644
--- a/pallets/swap/src/pallet/tests.rs
+++ b/pallets/swap/src/pallet/tests.rs
@@ -116,25 +116,31 @@ mod dispatchables {
 
             assert!(!EnabledUserLiquidity::<Test>::get(netuid));
 
-            assert_ok!(Swap::set_enabled_user_liquidity(
+            assert_ok!(Swap::toggle_user_liquidity(
                 RuntimeOrigin::root(),
-                netuid.into()
+                netuid.into(),
+                true
             ));
 
             assert!(EnabledUserLiquidity::<Test>::get(netuid));
 
             assert_noop!(
-                Swap::set_enabled_user_liquidity(RuntimeOrigin::signed(666), netuid.into()),
+                Swap::toggle_user_liquidity(RuntimeOrigin::signed(666), netuid.into(), true),
                 DispatchError::BadOrigin
             );
 
-            assert_ok!(Swap::set_enabled_user_liquidity(
+            assert_ok!(Swap::toggle_user_liquidity(
                 RuntimeOrigin::signed(1),
-                netuid.into()
+                netuid.into(),
+                true
             ));
 
             assert_noop!(
-                Swap::set_enabled_user_liquidity(RuntimeOrigin::root(), NON_EXISTENT_NETUID.into()),
+                Swap::toggle_user_liquidity(
+                    RuntimeOrigin::root(),
+                    NON_EXISTENT_NETUID.into(),
+                    true
+                ),
                 Error::<Test>::SubNetworkDoesNotExist
             );
         });
@@ -1352,7 +1358,7 @@ fn test_user_liquidity_disabled() {
 
         assert_noop!(
             Swap::do_remove_liquidity(netuid, &OK_COLDKEY_ACCOUNT_ID, position_id),
-            Error::<Test>::UserLiquidityDisabled
+            Error::<Test>::LiquidityNotFound
         );
 
         assert_noop!(
@@ -1366,9 +1372,10 @@ fn test_user_liquidity_disabled() {
             Error::<Test>::UserLiquidityDisabled
         );
 
-        assert_ok!(Swap::set_enabled_user_liquidity(
+        assert_ok!(Swap::toggle_user_liquidity(
             RuntimeOrigin::root(),
-            netuid
+            netuid,
+            true
         ));
 
         let position_id = Swap::do_add_liquidity(

From 102cbc740448cd69b46c598b653563c207d63b54 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Wed, 18 Jun 2025 10:27:48 -0400
Subject: [PATCH 408/418] Rename weight function for toggle_user_liquidity

---
 pallets/swap/src/pallet/tests.rs | 2 +-
 pallets/swap/src/weights.rs      | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/pallets/swap/src/pallet/tests.rs b/pallets/swap/src/pallet/tests.rs
index 6e0ec65931..07d1c63b89 100644
--- a/pallets/swap/src/pallet/tests.rs
+++ b/pallets/swap/src/pallet/tests.rs
@@ -110,7 +110,7 @@ mod dispatchables {
     }
 
     #[test]
-    fn test_set_enabled_user_liquidity() {
+    fn test_toggle_user_liquidity() {
         new_test_ext().execute_with(|| {
             let netuid = NetUid::from(101);
 
diff --git a/pallets/swap/src/weights.rs b/pallets/swap/src/weights.rs
index 045bd551cc..b3508c05a7 100644
--- a/pallets/swap/src/weights.rs
+++ b/pallets/swap/src/weights.rs
@@ -18,7 +18,7 @@ pub trait WeightInfo {
     fn add_liquidity() -> Weight;
     fn remove_liquidity() -> Weight;
     fn modify_position() -> Weight;
-    fn set_enabled_user_liquidity() -> Weight;
+    fn toggle_user_liquidity() -> Weight;
 }
 
 /// Default weights for pallet_subtensor_swap.
@@ -52,7 +52,7 @@ impl<T: frame_system::Config> WeightInfo for DefaultWeight<T> {
             .saturating_add(T::DbWeight::get().writes(4))
     }
 
-    fn set_enabled_user_liquidity() -> Weight {
+    fn toggle_user_liquidity() -> Weight {
         // Conservative weight estimate: one read and one write
         Weight::from_parts(10_000_000, 0)
             .saturating_add(T::DbWeight::get().reads(1))

From 1872a0b18d1ba228b4626f1dee53e6fabad4285f Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Wed, 18 Jun 2025 12:43:56 -0400
Subject: [PATCH 409/418] Fix zepter (std)

---
 pallets/swap/Cargo.toml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/pallets/swap/Cargo.toml b/pallets/swap/Cargo.toml
index 2cd7fd5b8a..7cf8e98191 100644
--- a/pallets/swap/Cargo.toml
+++ b/pallets/swap/Cargo.toml
@@ -49,6 +49,7 @@ std = [
 	"sp-core/std",
 	"sp-io/std",
 	"sp-runtime/std",
+	"sp-tracing/std",
 	"sp-std/std",
 	"substrate-fixed/std",
 	"subtensor-runtime-common/std",

From 84cd7c8f711b44a8d1f67a5f636e4c91e9e82aee Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Wed, 18 Jun 2025 12:55:17 -0400
Subject: [PATCH 410/418] Fix clippy

---
 pallets/admin-utils/src/tests/mock.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/pallets/admin-utils/src/tests/mock.rs b/pallets/admin-utils/src/tests/mock.rs
index 2d366753fe..cfcee6de91 100644
--- a/pallets/admin-utils/src/tests/mock.rs
+++ b/pallets/admin-utils/src/tests/mock.rs
@@ -5,7 +5,6 @@ use core::num::NonZeroU64;
 use frame_support::{
     PalletId, assert_ok, derive_impl, parameter_types,
     traits::{Everything, Hooks, InherentBuilder, PrivilegeCmp},
-    weights,
 };
 use frame_system::{self as system, offchain::CreateTransactionBase};
 use frame_system::{EnsureNever, EnsureRoot, limits};

From d9022c0f207990ee472d0377adc216f72b38803f Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Wed, 18 Jun 2025 15:11:59 -0400
Subject: [PATCH 411/418] Fix weights for sudo_set_tx_childkey_take_rate_limit
 and set_identity

---
 pallets/subtensor/src/macros/dispatches.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pallets/subtensor/src/macros/dispatches.rs b/pallets/subtensor/src/macros/dispatches.rs
index ea988378b2..28e2bf142e 100644
--- a/pallets/subtensor/src/macros/dispatches.rs
+++ b/pallets/subtensor/src/macros/dispatches.rs
@@ -1045,7 +1045,7 @@ mod dispatches {
         ///
         #[pallet::call_index(69)]
         #[pallet::weight((
-            Weight::from_parts(6_873_000, 0)
+            Weight::from_parts(5_760_000, 0)
         .saturating_add(T::DbWeight::get().reads(0))
         .saturating_add(T::DbWeight::get().writes(1)),
     DispatchClass::Operational,
@@ -1465,7 +1465,7 @@ mod dispatches {
         /// 	- The ip type v4 or v6.
         ///
         #[pallet::call_index(68)]
-        #[pallet::weight((Weight::from_parts(32_340_000, 0)
+        #[pallet::weight((Weight::from_parts(38_980_000, 0)
 		.saturating_add(T::DbWeight::get().reads(3))
 		.saturating_add(T::DbWeight::get().writes(1)), DispatchClass::Normal, Pays::Yes))]
         pub fn set_identity(

From 90a5768315197da66be6dc96add35b66110acdf1 Mon Sep 17 00:00:00 2001
From: John Reed <87283488+JohnReedV@users.noreply.github.com>
Date: Wed, 18 Jun 2025 13:42:53 -0700
Subject: [PATCH 412/418] fix merge errors

---
 pallets/subtensor/rpc/src/lib.rs    | 2 +-
 pallets/subtensor/src/utils/misc.rs | 4 ++--
 runtime/src/lib.rs                  | 4 ----
 3 files changed, 3 insertions(+), 7 deletions(-)

diff --git a/pallets/subtensor/rpc/src/lib.rs b/pallets/subtensor/rpc/src/lib.rs
index e8980f8779..6c847d3258 100644
--- a/pallets/subtensor/rpc/src/lib.rs
+++ b/pallets/subtensor/rpc/src/lib.rs
@@ -288,7 +288,7 @@ where
 
     fn get_subnet_hyperparams_v2(
         &self,
-        netuid: u16,
+        netuid: NetUid,
         at: Option<<Block as BlockT>::Hash>,
     ) -> RpcResult<Vec<u8>> {
         let api = self.client.runtime_api();
diff --git a/pallets/subtensor/src/utils/misc.rs b/pallets/subtensor/src/utils/misc.rs
index 8699eadd86..9641cfb0ee 100644
--- a/pallets/subtensor/src/utils/misc.rs
+++ b/pallets/subtensor/src/utils/misc.rs
@@ -723,11 +723,11 @@ impl<T: Config> Pallet<T> {
         Yuma3On::<T>::get(netuid)
     }
 
-    pub fn get_subtoken_enabled(netuid: u16) -> bool {
+    pub fn get_subtoken_enabled(netuid: NetUid) -> bool {
         SubtokenEnabled::<T>::get(netuid)
     }
 
-    pub fn get_transfer_toggle(netuid: u16) -> bool {
+    pub fn get_transfer_toggle(netuid: NetUid) -> bool {
         TransferToggle::<T>::get(netuid)
     }
 
diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index 8751a0550f..8adf4b6c55 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -2281,10 +2281,6 @@ impl_runtime_apis! {
             SubtensorModule::get_subnet_hyperparams_v2(netuid)
         }
 
-        fn get_subnet_hyperparams_v2(netuid: NetUid) -> Option<SubnetHyperparamsV2> {
-            SubtensorModule::get_subnet_hyperparams_v2(netuid)
-        }
-
         fn get_dynamic_info(netuid: NetUid) -> Option<DynamicInfo<AccountId32>> {
             SubtensorModule::get_dynamic_info(netuid)
         }

From bd320d19772bbb296482dfc654159e6695125ac2 Mon Sep 17 00:00:00 2001
From: John Reed <87283488+JohnReedV@users.noreply.github.com>
Date: Wed, 18 Jun 2025 13:50:40 -0700
Subject: [PATCH 413/418] fmt

---
 pallets/subtensor/rpc/src/lib.rs              | 6 +++++-
 pallets/subtensor/src/rpc_info/subnet_info.rs | 2 +-
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/pallets/subtensor/rpc/src/lib.rs b/pallets/subtensor/rpc/src/lib.rs
index 6c847d3258..eb3c7b11ca 100644
--- a/pallets/subtensor/rpc/src/lib.rs
+++ b/pallets/subtensor/rpc/src/lib.rs
@@ -59,7 +59,11 @@ pub trait SubtensorCustomApi<BlockHash> {
     #[method(name = "subnetInfo_getSubnetHyperparams")]
     fn get_subnet_hyperparams(&self, netuid: NetUid, at: Option<BlockHash>) -> RpcResult<Vec<u8>>;
     #[method(name = "subnetInfo_getSubnetHyperparamsV2")]
-    fn get_subnet_hyperparams_v2(&self, netuid: NetUid, at: Option<BlockHash>) -> RpcResult<Vec<u8>>;
+    fn get_subnet_hyperparams_v2(
+        &self,
+        netuid: NetUid,
+        at: Option<BlockHash>,
+    ) -> RpcResult<Vec<u8>>;
     #[method(name = "subnetInfo_getAllDynamicInfo")]
     fn get_all_dynamic_info(&self, at: Option<BlockHash>) -> RpcResult<Vec<u8>>;
     #[method(name = "subnetInfo_getDynamicInfo")]
diff --git a/pallets/subtensor/src/rpc_info/subnet_info.rs b/pallets/subtensor/src/rpc_info/subnet_info.rs
index 0a89124a6c..5e287b4482 100644
--- a/pallets/subtensor/src/rpc_info/subnet_info.rs
+++ b/pallets/subtensor/src/rpc_info/subnet_info.rs
@@ -3,8 +3,8 @@ use frame_support::pallet_prelude::{Decode, Encode};
 use frame_support::storage::IterableStorageMap;
 extern crate alloc;
 use codec::Compact;
-use subtensor_runtime_common::NetUid;
 use substrate_fixed::types::I32F32;
+use subtensor_runtime_common::NetUid;
 
 #[freeze_struct("dd2293544ffd8f2e")]
 #[derive(Decode, Encode, PartialEq, Eq, Clone, Debug, TypeInfo)]

From 747f0838968de2cb85e71612a5c2f4651e0d28db Mon Sep 17 00:00:00 2001
From: John Reed <87283488+JohnReedV@users.noreply.github.com>
Date: Wed, 18 Jun 2025 13:57:12 -0700
Subject: [PATCH 414/418] rename subnet_token_enabled => subnet_is_active

---
 pallets/subtensor/src/rpc_info/subnet_info.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/pallets/subtensor/src/rpc_info/subnet_info.rs b/pallets/subtensor/src/rpc_info/subnet_info.rs
index 5e287b4482..cab1f8800b 100644
--- a/pallets/subtensor/src/rpc_info/subnet_info.rs
+++ b/pallets/subtensor/src/rpc_info/subnet_info.rs
@@ -85,7 +85,7 @@ pub struct SubnetHyperparams {
     liquid_alpha_enabled: bool,
 }
 
-#[freeze_struct("3fbe8d53738695c7")]
+#[freeze_struct("a13c536303dec16f")]
 #[derive(Decode, Encode, PartialEq, Eq, Clone, Debug, TypeInfo)]
 pub struct SubnetHyperparamsV2 {
     rho: Compact<u16>,
@@ -117,7 +117,7 @@ pub struct SubnetHyperparamsV2 {
     liquid_alpha_enabled: bool,
     alpha_sigmoid_steepness: I32F32,
     yuma_version: Compact<u16>,
-    subnet_token_enabled: bool,
+    subnet_is_active: bool,
     transfers_enabled: bool,
     bonds_reset_enabled: bool,
     user_liquidity_enabled: bool,
@@ -399,7 +399,7 @@ impl<T: Config> Pallet<T> {
             liquid_alpha_enabled,
             alpha_sigmoid_steepness,
             yuma_version: yuma_version.into(),
-            subnet_token_enabled,
+            subnet_is_active: subnet_token_enabled,
             transfers_enabled,
             bonds_reset_enabled: bonds_reset,
             user_liquidity_enabled,

From 0e5ab222256ba2dd24cae54f1b1bcc39ff0c9b52 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Mon, 23 Jun 2025 11:00:18 -0400
Subject: [PATCH 415/418] Add liquidity modified event, fix coinbase injection
 into protocol liquidity

---
 .../subtensor/src/coinbase/run_coinbase.rs    |  2 +-
 pallets/swap-interface/src/lib.rs             |  3 +-
 pallets/swap/src/pallet/impls.rs              | 43 ++++++++----
 pallets/swap/src/pallet/mod.rs                | 68 ++++++++++++++-----
 4 files changed, 84 insertions(+), 32 deletions(-)

diff --git a/pallets/subtensor/src/coinbase/run_coinbase.rs b/pallets/subtensor/src/coinbase/run_coinbase.rs
index 1274a84a6f..0dc8440980 100644
--- a/pallets/subtensor/src/coinbase/run_coinbase.rs
+++ b/pallets/subtensor/src/coinbase/run_coinbase.rs
@@ -140,7 +140,7 @@ impl<T: Config> Pallet<T> {
                 *total = total.saturating_add(tao_in_i);
             });
             // Adjust protocol liquidity based on new reserves
-            T::SwapInterface::adjust_protocol_liquidity(*netuid_i);
+            T::SwapInterface::adjust_protocol_liquidity(*netuid_i, tao_in_i, alpha_in_i);
         }
 
         // --- 5. Compute owner cuts and remove them from alpha_out remaining.
diff --git a/pallets/swap-interface/src/lib.rs b/pallets/swap-interface/src/lib.rs
index f09928a2b2..10f3cb0fb2 100644
--- a/pallets/swap-interface/src/lib.rs
+++ b/pallets/swap-interface/src/lib.rs
@@ -27,7 +27,7 @@ pub trait SwapHandler<AccountId> {
     fn current_alpha_price(netuid: NetUid) -> U96F32;
     fn max_price() -> u64;
     fn min_price() -> u64;
-    fn adjust_protocol_liquidity(netuid: NetUid);
+    fn adjust_protocol_liquidity(netuid: NetUid, tao_delta: u64, alpha_delta: u64);
     fn is_user_liquidity_enabled(netuid: NetUid) -> bool;
 }
 
@@ -47,4 +47,5 @@ pub struct UpdateLiquidityResult {
     pub alpha: u64,
     pub fee_tao: u64,
     pub fee_alpha: u64,
+    pub removed: bool,
 }
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
index 3f54dbfd74..08cd2c4b74 100644
--- a/pallets/swap/src/pallet/impls.rs
+++ b/pallets/swap/src/pallet/impls.rs
@@ -326,14 +326,7 @@ impl<T: Config> Pallet<T> {
     }
 
     /// Adjusts protocol liquidity with new values of TAO and Alpha reserve
-    pub(super) fn adjust_protocol_liquidity(netuid: NetUid) {
-        // Get updated reserves, calculate liquidity
-        let tao_reserve = <T as Config>::SubnetInfo::tao_reserve(netuid.into());
-        let alpha_reserve = <T as Config>::SubnetInfo::alpha_reserve(netuid.into());
-        let liquidity =
-            helpers_128bit::sqrt((tao_reserve as u128).saturating_mul(alpha_reserve as u128))
-                as u64;
-
+    pub(super) fn adjust_protocol_liquidity(netuid: NetUid, tao_delta: u64, alpha_delta: u64) {
         // Update protocol position with new liquidity
         let protocol_account_id = Self::protocol_account_id();
         let mut positions =
@@ -341,8 +334,22 @@ impl<T: Config> Pallet<T> {
                 .collect::<sp_std::vec::Vec<_>>();
 
         if let Some(position) = positions.get_mut(0) {
-            position.liquidity = liquidity;
-            Positions::<T>::insert((netuid, protocol_account_id, position.id), position.clone());
+            let current_sqrt_price = Pallet::<T>::current_price_sqrt(netuid);
+            let maybe_token_amounts = position.to_token_amounts(current_sqrt_price);
+            if let Ok((tao, alpha)) = maybe_token_amounts {
+                // Get updated reserves, calculate liquidity
+                let new_tao_reserve = tao.saturating_add(tao_delta);
+                let new_alpha_reserve = alpha.saturating_add(alpha_delta);
+                let new_liquidity = helpers_128bit::sqrt(
+                    (new_tao_reserve as u128).saturating_mul(new_alpha_reserve as u128),
+                ) as u64;
+
+                position.liquidity = new_liquidity;
+                Positions::<T>::insert(
+                    (netuid, protocol_account_id, position.id),
+                    position.clone(),
+                );
+            }
         }
     }
 
@@ -855,6 +862,7 @@ impl<T: Config> Pallet<T> {
             alpha,
             fee_tao,
             fee_alpha,
+            removed: true,
         })
     }
 
@@ -938,10 +946,12 @@ impl<T: Config> Pallet<T> {
 
         // If delta brings the position liquidity below MinimumLiquidity, eliminate position and
         // withdraw full amounts
+        let mut remove = false;
         if (liquidity_delta < 0)
             && (position.liquidity.saturating_sub(delta_liquidity_abs) < T::MinimumLiquidity::get())
         {
             delta_liquidity_abs = position.liquidity;
+            remove = true;
         }
 
         // Adjust liquidity at the ticks based on the delta sign
@@ -960,15 +970,20 @@ impl<T: Config> Pallet<T> {
             // Remove liquidity from user position
             position.liquidity = position.liquidity.saturating_sub(delta_liquidity_abs);
         }
-        Positions::<T>::insert(&(netuid, coldkey_account_id, position.id), position);
 
-        // TODO: Withdraw balances and update pool reserves
+        // Update or, in case if full liquidity is removed, remove the position
+        if remove {
+            Positions::<T>::remove((netuid, coldkey_account_id, position_id));
+        } else {
+            Positions::<T>::insert(&(netuid, coldkey_account_id, position.id), position);
+        }
 
         Ok(UpdateLiquidityResult {
             tao: tao.saturating_to_num::<u64>(),
             alpha: alpha.saturating_to_num::<u64>(),
             fee_tao,
             fee_alpha,
+            removed: remove,
         })
     }
 
@@ -1173,8 +1188,8 @@ impl<T: Config> SwapHandler<T::AccountId> for Pallet<T> {
             .saturating_to_num()
     }
 
-    fn adjust_protocol_liquidity(netuid: NetUid) {
-        Self::adjust_protocol_liquidity(netuid);
+    fn adjust_protocol_liquidity(netuid: NetUid, tao_delta: u64, alpha_delta: u64) {
+        Self::adjust_protocol_liquidity(netuid, tao_delta, alpha_delta);
     }
 
     fn is_user_liquidity_enabled(netuid: NetUid) -> bool {
diff --git a/pallets/swap/src/pallet/mod.rs b/pallets/swap/src/pallet/mod.rs
index 3a0e00bc8d..a91b338967 100644
--- a/pallets/swap/src/pallet/mod.rs
+++ b/pallets/swap/src/pallet/mod.rs
@@ -1,4 +1,5 @@
 use core::num::NonZeroU64;
+use core::ops::Neg;
 
 use frame_support::{PalletId, pallet_prelude::*, traits::Get};
 use frame_system::pallet_prelude::*;
@@ -149,7 +150,7 @@ mod pallet {
         /// First enable even indicates a switch from V2 to V3 swap.
         UserLiquidityToggled { netuid: NetUid, enable: bool },
 
-        /// Event emitted when liquidity is added to a subnet's liquidity pool.
+        /// Event emitted when a liquidity position is added to a subnet's liquidity pool.
         LiquidityAdded {
             /// The coldkey account that owns the position
             coldkey: T::AccountId,
@@ -167,7 +168,7 @@ mod pallet {
             alpha: u64,
         },
 
-        /// Event emitted when liquidity is removed from a subnet's liquidity pool.
+        /// Event emitted when a liquidity position is removed from a subnet's liquidity pool.
         LiquidityRemoved {
             /// The coldkey account that owns the position
             coldkey: T::AccountId,
@@ -184,6 +185,27 @@ mod pallet {
             /// The amount of Alpha fees earned from the position
             fee_alpha: u64,
         },
+
+        /// Event emitted when a liquidity position is modified in a subnet's liquidity pool.
+        /// Modifying causes the fees to be claimed.
+        LiquidityModified {
+            /// The coldkey account that owns the position
+            coldkey: T::AccountId,
+            /// The subnet identifier
+            netuid: NetUid,
+            /// Unique identifier for the liquidity position
+            position_id: PositionId,
+            /// The amount of liquidity added to or removed from the position
+            liquidity: i64,
+            /// The amount of TAO tokens returned to the user
+            tao: i64,
+            /// The amount of Alpha tokens returned to the user
+            alpha: i64,
+            /// The amount of TAO fees earned from the position
+            fee_tao: u64,
+            /// The amount of Alpha fees earned from the position
+            fee_alpha: u64,
+        },
     }
 
     #[pallet::error]
@@ -456,14 +478,15 @@ mod pallet {
                 );
 
                 // Emit an event
-                Self::deposit_event(Event::LiquidityAdded {
+                Self::deposit_event(Event::LiquidityModified {
                     coldkey: coldkey.clone(),
-                    hotkey: hotkey.clone(),
                     netuid,
                     position_id,
-                    liquidity: liquidity_delta as u64,
-                    tao: result.tao,
-                    alpha: result.alpha,
+                    liquidity: liquidity_delta,
+                    tao: result.tao as i64,
+                    alpha: result.alpha as i64,
+                    fee_tao: result.fee_tao,
+                    fee_alpha: result.fee_alpha,
                 });
             } else {
                 // Credit the returned tao and alpha to the account
@@ -471,15 +494,28 @@ mod pallet {
                 T::BalanceOps::increase_stake(&coldkey, &hotkey, netuid.into(), result.alpha)?;
 
                 // Emit an event
-                Self::deposit_event(Event::LiquidityRemoved {
-                    coldkey: coldkey.clone(),
-                    netuid,
-                    position_id,
-                    tao: result.tao,
-                    alpha: result.alpha,
-                    fee_tao: result.fee_tao,
-                    fee_alpha: result.fee_alpha,
-                });
+                if result.removed {
+                    Self::deposit_event(Event::LiquidityRemoved {
+                        coldkey: coldkey.clone(),
+                        netuid,
+                        position_id,
+                        tao: result.tao,
+                        alpha: result.alpha,
+                        fee_tao: result.fee_tao,
+                        fee_alpha: result.fee_alpha,
+                    });
+                } else {
+                    Self::deposit_event(Event::LiquidityModified {
+                        coldkey: coldkey.clone(),
+                        netuid,
+                        position_id,
+                        liquidity: liquidity_delta,
+                        tao: (result.tao as i64).neg(),
+                        alpha: (result.alpha as i64).neg(),
+                        fee_tao: result.fee_tao,
+                        fee_alpha: result.fee_alpha,
+                    });
+                }
             }
 
             // Credit accrued fees to user account (no matter if liquidity is added or removed)

From cf10bb808282995f68222e5af0751d24c69d3d3e Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Mon, 23 Jun 2025 12:17:25 -0400
Subject: [PATCH 416/418] Add hotkey to liquidity modified and liquidity
 removed events

---
 pallets/swap/src/pallet/mod.rs | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/pallets/swap/src/pallet/mod.rs b/pallets/swap/src/pallet/mod.rs
index a91b338967..d226605d40 100644
--- a/pallets/swap/src/pallet/mod.rs
+++ b/pallets/swap/src/pallet/mod.rs
@@ -154,7 +154,7 @@ mod pallet {
         LiquidityAdded {
             /// The coldkey account that owns the position
             coldkey: T::AccountId,
-            /// The hotkey account associated with the position
+            /// The hotkey account where Alpha comes from
             hotkey: T::AccountId,
             /// The subnet identifier
             netuid: NetUid,
@@ -172,6 +172,8 @@ mod pallet {
         LiquidityRemoved {
             /// The coldkey account that owns the position
             coldkey: T::AccountId,
+            /// The hotkey account where Alpha goes to
+            hotkey: T::AccountId,
             /// The subnet identifier
             netuid: NetUid,
             /// Unique identifier for the liquidity position
@@ -191,6 +193,8 @@ mod pallet {
         LiquidityModified {
             /// The coldkey account that owns the position
             coldkey: T::AccountId,
+            /// The hotkey account where Alpha comes from or goes to
+            hotkey: T::AccountId,
             /// The subnet identifier
             netuid: NetUid,
             /// Unique identifier for the liquidity position
@@ -424,6 +428,7 @@ mod pallet {
             // Emit an event
             Self::deposit_event(Event::LiquidityRemoved {
                 coldkey,
+                hotkey,
                 netuid: netuid.into(),
                 position_id,
                 tao: result.tao,
@@ -480,6 +485,7 @@ mod pallet {
                 // Emit an event
                 Self::deposit_event(Event::LiquidityModified {
                     coldkey: coldkey.clone(),
+                    hotkey: hotkey.clone(),
                     netuid,
                     position_id,
                     liquidity: liquidity_delta,
@@ -497,6 +503,7 @@ mod pallet {
                 if result.removed {
                     Self::deposit_event(Event::LiquidityRemoved {
                         coldkey: coldkey.clone(),
+                        hotkey: hotkey.clone(),
                         netuid,
                         position_id,
                         tao: result.tao,
@@ -507,6 +514,7 @@ mod pallet {
                 } else {
                     Self::deposit_event(Event::LiquidityModified {
                         coldkey: coldkey.clone(),
+                        hotkey: hotkey.clone(),
                         netuid,
                         position_id,
                         liquidity: liquidity_delta,

From c3c0046c09b5a0117e0e088fc93b0ea594216877 Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Mon, 23 Jun 2025 12:40:56 -0400
Subject: [PATCH 417/418] Remove alpha-out deprecation warning

---
 pallets/subtensor/src/lib.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/pallets/subtensor/src/lib.rs b/pallets/subtensor/src/lib.rs
index f4801d63f0..33aeb15bab 100644
--- a/pallets/subtensor/src/lib.rs
+++ b/pallets/subtensor/src/lib.rs
@@ -1062,7 +1062,6 @@ pub mod pallet {
         StorageMap<_, Identity, NetUid, u64, ValueQuery, DefaultZeroU64<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> alpha_supply_in_subnet | Returns the amount of alpha in the subnet.
-    /// TODO: Deprecate, not accurate and not used in v3 anymore
     pub type SubnetAlphaOut<T: Config> =
         StorageMap<_, Identity, NetUid, u64, ValueQuery, DefaultZeroU64<T>>;
     #[pallet::storage] // --- MAP ( cold ) --> Vec<hot> | Maps coldkey to hotkeys that stake to it

From e69d8682fe88f440007a8deca2eaa4da17e474ff Mon Sep 17 00:00:00 2001
From: Greg Zaitsev <gregz@opentensor.dev>
Date: Mon, 23 Jun 2025 13:50:14 -0400
Subject: [PATCH 418/418] Update Alphaout when adding and removing liquidity

---
 pallets/subtensor/src/lib.rs | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/pallets/subtensor/src/lib.rs b/pallets/subtensor/src/lib.rs
index 33aeb15bab..973233bd9e 100644
--- a/pallets/subtensor/src/lib.rs
+++ b/pallets/subtensor/src/lib.rs
@@ -2572,6 +2572,11 @@ impl<T: Config + pallet_balances::Config<Balance = u64>>
             Error::<T>::HotKeyAccountNotExists
         );
 
+        // Increse alpha out counter
+        SubnetAlphaOut::<T>::mutate(netuid, |total| {
+            *total = total.saturating_add(alpha);
+        });
+
         Self::increase_stake_for_hotkey_and_coldkey_on_subnet(hotkey, coldkey, netuid, alpha);
 
         Ok(())
@@ -2588,6 +2593,11 @@ impl<T: Config + pallet_balances::Config<Balance = u64>>
             Error::<T>::HotKeyAccountNotExists
         );
 
+        // Decrese alpha out counter
+        SubnetAlphaOut::<T>::mutate(netuid, |total| {
+            *total = total.saturating_sub(alpha);
+        });
+
         Ok(Self::decrease_stake_for_hotkey_and_coldkey_on_subnet(
             hotkey, coldkey, netuid, alpha,
         ))