Balancer swap

Cargo.toml

@@ -61,6 +61,7 @@ pallet-subtensor-swap-runtime-api = { path = "pallets/swap/runtime-api", default
 pallet-subtensor-swap-rpc = { path = "pallets/swap/rpc", default-features = false }
 procedural-fork = { path = "support/procedural-fork", default-features = false }
 safe-math = { path = "primitives/safe-math", default-features = false }
+safe-bigmath = { package = "safe-bigmath", default-features = false, git = "https://github.com/sam0x17/safe-bigmath" }
 share-pool = { path = "primitives/share-pool", default-features = false }
 subtensor-macros = { path = "support/macros", default-features = false }
 subtensor-custom-rpc = { default-features = false, path = "pallets/subtensor/rpc" }

chain-extensions/src/lib.rs

@@ -18,7 +18,7 @@ use pallet_subtensor_proxy as pallet_proxy;
 use pallet_subtensor_proxy::WeightInfo;
 use sp_runtime::{DispatchError, Weight, traits::StaticLookup};
 use sp_std::marker::PhantomData;
-use substrate_fixed::types::U96F32;
+use substrate_fixed::types::U64F64;
 use subtensor_runtime_common::{AlphaCurrency, NetUid, ProxyType, TaoCurrency};
 use subtensor_swap_interface::SwapHandler;
 
@@ -520,7 +520,7 @@ where
                         netuid.into(),
                     );
 
-                let price = current_alpha_price.saturating_mul(U96F32::from_num(1_000_000_000));
+                let price = current_alpha_price.saturating_mul(U64F64::from_num(1_000_000_000));
                 let price: u64 = price.saturating_to_num();
 
                 let encoded_result = price.encode();

chain-extensions/src/mock.rs

@@ -417,7 +417,6 @@ impl pallet_subtensor::Config for Test {
 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 const SwapMinimumReserve: NonZeroU64 = NonZeroU64::new(100).unwrap();
 }
@@ -429,7 +428,6 @@ impl pallet_subtensor_swap::Config for Test {
     type TaoReserve = TaoCurrencyReserve<Self>;
     type AlphaReserve = AlphaCurrencyReserve<Self>;
     type MaxFeeRate = SwapMaxFeeRate;
-    type MaxPositions = SwapMaxPositions;
     type MinimumLiquidity = SwapMinimumLiquidity;
     type MinimumReserve = SwapMinimumReserve;
     type WeightInfo = ();

chain-extensions/src/tests.rs

@@ -10,7 +10,7 @@ use pallet_subtensor::DefaultMinStake;
 use sp_core::Get;
 use sp_core::U256;
 use sp_runtime::DispatchError;
-use substrate_fixed::types::U96F32;
+use substrate_fixed::types::U64F64;
 use subtensor_runtime_common::{AlphaCurrency, Currency as CurrencyTrait, NetUid, TaoCurrency};
 use subtensor_swap_interface::SwapHandler;
 
@@ -985,7 +985,7 @@ fn get_alpha_price_returns_encoded_price() {
             <pallet_subtensor_swap::Pallet<mock::Test> as SwapHandler>::current_alpha_price(
                 netuid.into(),
             );
-        let expected_price_scaled = expected_price.saturating_mul(U96F32::from_num(1_000_000_000));
+        let expected_price_scaled = expected_price.saturating_mul(U64F64::from_num(1_000_000_000));
         let expected_price_u64: u64 = expected_price_scaled.saturating_to_num();
 
         let mut env = MockEnv::new(FunctionId::GetAlphaPriceV1, caller, netuid.encode());

pallets/admin-utils/src/tests/mock.rs

@@ -322,7 +322,6 @@ impl pallet_balances::Config for Test {
 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 const SwapMinimumReserve: NonZeroU64 = NonZeroU64::new(1_000_000).unwrap();
 }
@@ -334,7 +333,6 @@ impl pallet_subtensor_swap::Config for Test {
     type TaoReserve = pallet_subtensor::TaoCurrencyReserve<Self>;
     type AlphaReserve = pallet_subtensor::AlphaCurrencyReserve<Self>;
     type MaxFeeRate = SwapMaxFeeRate;
-    type MaxPositions = SwapMaxPositions;
     type MinimumLiquidity = SwapMinimumLiquidity;
     type MinimumReserve = SwapMinimumReserve;
     type WeightInfo = ();

pallets/subtensor/src/benchmarks.rs

@@ -16,7 +16,9 @@ use sp_runtime::{
 };
 use sp_std::collections::btree_set::BTreeSet;
 use sp_std::vec;
+use substrate_fixed::types::U64F64;
 use subtensor_runtime_common::{AlphaCurrency, NetUid, TaoCurrency};
+use subtensor_swap_interface::SwapHandler;
 
 #[benchmarks(
     where
@@ -66,6 +68,8 @@ mod pallet_benchmarks {
         Subtensor::<T>::set_max_registrations_per_block(netuid, 4096);
         Subtensor::<T>::set_target_registrations_per_interval(netuid, 4096);
         Subtensor::<T>::set_commit_reveal_weights_enabled(netuid, false);
+        SubnetTAO::<T>::insert(netuid, TaoCurrency::from(1_000_000_000_000_u64));
+        SubnetAlphaIn::<T>::insert(netuid, AlphaCurrency::from(1_000_000_000_000_000_u64));
 
         let mut seed: u32 = 1;
         let mut dests = Vec::new();
@@ -729,13 +733,12 @@ mod pallet_benchmarks {
         let coldkey: T::AccountId = account("Test", 0, seed);
         let hotkey: T::AccountId = account("Alice", 0, seed);
 
-        let amount = 900_000_000_000;
-        let limit = TaoCurrency::from(6_000_000_000);
-        let amount_to_be_staked = TaoCurrency::from(44_000_000_000);
-        Subtensor::<T>::add_balance_to_coldkey_account(&coldkey.clone(), amount);
+        let initial_balance = 900_000_000_000;
+        Subtensor::<T>::add_balance_to_coldkey_account(&coldkey.clone(), initial_balance);
 
-        let tao_reserve = TaoCurrency::from(150_000_000_000);
-        let alpha_in = AlphaCurrency::from(100_000_000_000);
+        // Price = 0.01
+        let tao_reserve = TaoCurrency::from(1_000_000_000_000);
+        let alpha_in = AlphaCurrency::from(100_000_000_000_000);
         SubnetTAO::<T>::insert(netuid, tao_reserve);
         SubnetAlphaIn::<T>::insert(netuid, alpha_in);
 
@@ -745,14 +748,23 @@ mod pallet_benchmarks {
             hotkey.clone()
         ));
 
+        // Read current price and set limit price 0.1% higher, which is certainly getting hit
+        // by swapping 100 TAO
+        let current_price = T::SwapInterface::current_alpha_price(netuid);
+        let limit = current_price
+            .saturating_mul(U64F64::saturating_from_num(1_001_000_000))
+            .saturating_to_num::<u64>();
+        let amount_to_be_staked = TaoCurrency::from(100_000_000_000);
+
+        // Allow partial (worst case)
         #[extrinsic_call]
         _(
             RawOrigin::Signed(coldkey.clone()),
             hotkey,
             netuid,
             amount_to_be_staked,
-            limit,
-            false,
+            limit.into(),
+            true,
         );
     }
 
@@ -829,9 +841,9 @@ mod pallet_benchmarks {
         let hotkey: T::AccountId = account("Alice", 0, seed);
         Subtensor::<T>::set_burn(netuid, 1.into());
 
-        let limit = TaoCurrency::from(1_000_000_000);
-        let tao_reserve = TaoCurrency::from(150_000_000_000);
-        let alpha_in = AlphaCurrency::from(100_000_000_000);
+        // Price = 0.01
+        let tao_reserve = TaoCurrency::from(1_000_000_000_000);
+        let alpha_in = AlphaCurrency::from(100_000_000_000_000);
         SubnetTAO::<T>::insert(netuid, tao_reserve);
         SubnetAlphaIn::<T>::insert(netuid, alpha_in);
 
@@ -854,7 +866,13 @@ mod pallet_benchmarks {
             u64_staked_amt.into()
         ));
 
-        let amount_unstaked = AlphaCurrency::from(30_000_000_000);
+        // Read current price and set limit price 0.01% lower, which is certainly getting hit
+        // by swapping 100 Alpha
+        let current_price = T::SwapInterface::current_alpha_price(netuid);
+        let limit = current_price
+            .saturating_mul(U64F64::saturating_from_num(999_900_000))
+            .saturating_to_num::<u64>();
+        let amount_unstaked = AlphaCurrency::from(100_000_000_000);
 
         // Remove stake limit for benchmark
         StakingOperationRateLimiter::<T>::remove((hotkey.clone(), coldkey.clone(), netuid));
@@ -865,8 +883,8 @@ mod pallet_benchmarks {
             hotkey.clone(),
             netuid,
             amount_unstaked,
-            limit,
-            false,
+            limit.into(),
+            true,
         );
     }
 
@@ -1320,8 +1338,9 @@ mod pallet_benchmarks {
         let hotkey: T::AccountId = account("Alice", 0, seed);
         Subtensor::<T>::set_burn(netuid, 1.into());
 
-        SubnetTAO::<T>::insert(netuid, TaoCurrency::from(150_000_000_000));
-        SubnetAlphaIn::<T>::insert(netuid, AlphaCurrency::from(100_000_000_000));
+        // Price = 0.01
+        SubnetTAO::<T>::insert(netuid, TaoCurrency::from(1_000_000_000_000));
+        SubnetAlphaIn::<T>::insert(netuid, AlphaCurrency::from(100_000_000_000_000));
 
         Subtensor::<T>::add_balance_to_coldkey_account(&coldkey.clone(), 1000000u32.into());
 
@@ -1368,9 +1387,8 @@ mod pallet_benchmarks {
         let hotkey: T::AccountId = account("Alice", 0, seed);
         Subtensor::<T>::set_burn(netuid, 1.into());
 
-        let limit = TaoCurrency::from(1_000_000_000);
-        let tao_reserve = TaoCurrency::from(150_000_000_000);
-        let alpha_in = AlphaCurrency::from(100_000_000_000);
+        let tao_reserve = TaoCurrency::from(1_000_000_000_000);
+        let alpha_in = AlphaCurrency::from(100_000_000_000_000);
         SubnetTAO::<T>::insert(netuid, tao_reserve);
         SubnetAlphaIn::<T>::insert(netuid, alpha_in);
 
@@ -1383,7 +1401,13 @@ mod pallet_benchmarks {
             hotkey.clone()
         ));
 
-        let u64_staked_amt = 100_000_000_000;
+        // Read current price and set limit price 50% lower, which is not getting hit
+        // by swapping 1 TAO
+        let current_price = T::SwapInterface::current_alpha_price(netuid);
+        let limit = current_price
+            .saturating_mul(U64F64::saturating_from_num(500_000_000))
+            .saturating_to_num::<u64>();
+        let u64_staked_amt = 1_000_000_000;
         Subtensor::<T>::add_balance_to_coldkey_account(&coldkey.clone(), u64_staked_amt);
 
         assert_ok!(Subtensor::<T>::add_stake(
@@ -1400,7 +1424,7 @@ mod pallet_benchmarks {
             RawOrigin::Signed(coldkey.clone()),
             hotkey.clone(),
             netuid,
-            Some(limit),
+            Some(limit.into()),
         );
     }
 
@@ -1730,7 +1754,7 @@ mod pallet_benchmarks {
 
         Subtensor::<T>::init_new_network(netuid, tempo);
         SubtokenEnabled::<T>::insert(netuid, true);
-        Subtensor::<T>::set_burn(netuid, 1.into());
+        Subtensor::<T>::set_burn(netuid, 1000.into());
         Subtensor::<T>::set_network_registration_allowed(netuid, true);
         Subtensor::<T>::set_max_allowed_uids(netuid, 4096);
 

pallets/subtensor/src/coinbase/block_emission.rs

@@ -1,10 +1,90 @@
 use super::*;
 use frame_support::traits::Get;
 use safe_math::*;
-use substrate_fixed::{transcendental::log2, types::I96F32};
-use subtensor_runtime_common::TaoCurrency;
+use substrate_fixed::{
+    transcendental::log2,
+    types::{I96F32, U64F64},
+};
+use subtensor_runtime_common::{NetUid, TaoCurrency};
+use subtensor_swap_interface::SwapHandler;
 
 impl<T: Config> Pallet<T> {
+    /// Calculates the dynamic TAO emission for a given subnet.
+    ///
+    /// This function determines the three terms tao_in, alpha_in, alpha_out
+    /// which are consecutively, 1) the amount of tao injected into the pool
+    /// 2) the amount of alpha injected into the pool, and 3) the amount of alpha
+    /// left to be distributed towards miners/validators/owners per block.
+    ///
+    /// # Arguments
+    /// * `netuid` - The unique identifier of the subnet.
+    /// * `tao_emission` - The amount of tao to distribute for this subnet.
+    /// * `alpha_block_emission` - The maximum alpha emission allowed for the block.
+    ///
+    /// # Returns
+    /// * `(u64, u64, u64)` - A tuple containing:
+    ///   - `tao_in_emission`: The adjusted TAO emission always lower or equal to tao_emission
+    ///   - `alpha_in_emission`: The adjusted alpha emission amount to be added into the pool.
+    ///   - `alpha_out_emission`: The remaining alpha emission after adjustments to be distributed to miners/validators.
+    ///
+    /// The algorithm ensures that the pool injection of tao_in_emission, alpha_in_emission does not effect the pool price
+    /// 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: NetUid,
+        tao_emission: u64,
+        alpha_block_emission: u64,
+    ) -> (u64, u64, u64) {
+        // Init terms.
+        let mut tao_in_emission: U64F64 = U64F64::saturating_from_num(tao_emission);
+        let float_alpha_block_emission: U64F64 = U64F64::saturating_from_num(alpha_block_emission);
+
+        // Get alpha price for subnet.
+        let alpha_price = T::SwapInterface::current_alpha_price(netuid.into());
+        log::debug!("{netuid:?} - alpha_price: {alpha_price:?}");
+
+        // Get initial alpha_in
+        let mut alpha_in_emission: U64F64 = U64F64::saturating_from_num(tao_emission)
+            .checked_div(alpha_price)
+            .unwrap_or(float_alpha_block_emission);
+
+        // Check if we are emitting too much alpha_in
+        if alpha_in_emission >= float_alpha_block_emission {
+            log::debug!(
+                "{netuid:?} - alpha_in_emission: {alpha_in_emission:?} > alpha_block_emission: {float_alpha_block_emission:?}"
+            );
+
+            // Scale down tao_in
+            // tao_in_emission = alpha_price.saturating_mul(float_alpha_block_emission);
+
+            // Set to max alpha_block_emission
+            alpha_in_emission = float_alpha_block_emission;
+        }
+
+        // Avoid rounding errors.
+        let zero = U64F64::saturating_from_num(0);
+        let one = U64F64::saturating_from_num(1);
+        if tao_in_emission < one || alpha_in_emission < one {
+            alpha_in_emission = zero;
+            tao_in_emission = zero;
+        }
+
+        // Set Alpha in emission.
+        let alpha_out_emission = float_alpha_block_emission;
+
+        // Log results.
+        log::debug!("{netuid:?} - tao_in_emission: {tao_in_emission:?}");
+        log::debug!("{netuid:?} - alpha_in_emission: {alpha_in_emission:?}");
+        log::debug!("{netuid:?} - alpha_out_emission: {alpha_out_emission:?}");
+
+        // Return result.
+        (
+            tao_in_emission.saturating_to_num::<u64>(),
+            alpha_in_emission.saturating_to_num::<u64>(),
+            alpha_out_emission.saturating_to_num::<u64>(),
+        )
+    }
+
     /// Calculates the block emission based on the total issuance.
     ///
     /// This function computes the block emission by applying a logarithmic function

pallets/subtensor/src/coinbase/root.rs

@@ -213,7 +213,6 @@ impl<T: Config> Pallet<T> {
         Self::finalize_all_subnet_root_dividends(netuid);
 
         // --- Perform the cleanup before removing the network.
-        T::SwapInterface::dissolve_all_liquidity_providers(netuid)?;
         Self::destroy_alpha_in_out_stakes(netuid)?;
         T::SwapInterface::clear_protocol_liquidity(netuid)?;
         T::CommitmentsInterface::purge_netuid(netuid);
@@ -300,7 +299,6 @@ impl<T: Config> Pallet<T> {
         SubnetMovingPrice::<T>::remove(netuid);
         SubnetTaoFlow::<T>::remove(netuid);
         SubnetEmaTaoFlow::<T>::remove(netuid);
-        SubnetTaoProvided::<T>::remove(netuid);
 
         // --- 13. Token / mechanism / registration toggles.
         TokenSymbol::<T>::remove(netuid);

pallets/subtensor/src/coinbase/run_coinbase.rs

@@ -67,7 +67,8 @@ impl<T: Config> Pallet<T> {
             let tao_to_swap_with: TaoCurrency =
                 tou64!(excess_tao.get(netuid_i).unwrap_or(&asfloat!(0))).into();
 
-            T::SwapInterface::adjust_protocol_liquidity(*netuid_i, tao_in_i, alpha_in_i);
+            let (actual_injected_tao, actual_injected_alpha) =
+                T::SwapInterface::adjust_protocol_liquidity(*netuid_i, tao_in_i, alpha_in_i);
 
             if tao_to_swap_with > TaoCurrency::ZERO {
                 let buy_swap_result = Self::swap_tao_for_alpha(
@@ -87,15 +88,17 @@ impl<T: Config> Pallet<T> {
                 AlphaCurrency::from(tou64!(*alpha_in.get(netuid_i).unwrap_or(&asfloat!(0))));
             SubnetAlphaInEmission::<T>::insert(*netuid_i, alpha_in_i);
             SubnetAlphaIn::<T>::mutate(*netuid_i, |total| {
-                *total = total.saturating_add(alpha_in_i);
+                // Reserves also received fees in addition to alpha_in_i
+                *total = total.saturating_add(actual_injected_alpha);
             });
 
             // Inject TAO in.
             let injected_tao: TaoCurrency =
                 tou64!(*tao_in.get(netuid_i).unwrap_or(&asfloat!(0))).into();
             SubnetTaoInEmission::<T>::insert(*netuid_i, injected_tao);
             SubnetTAO::<T>::mutate(*netuid_i, |total| {
-                *total = total.saturating_add(injected_tao);
+                // Reserves also received fees in addition to injected_tao
+                *total = total.saturating_add(actual_injected_tao);
             });
             TotalStake::<T>::mutate(|total| {
                 *total = total.saturating_add(injected_tao);
@@ -140,7 +143,8 @@ impl<T: Config> Pallet<T> {
             log::debug!("alpha_emission_i: {alpha_emission_i:?}");
 
             // Get subnet price.
-            let price_i: U96F32 = T::SwapInterface::current_alpha_price(netuid_i.into());
+            let price_i: U96F32 =
+                U96F32::saturating_from_num(T::SwapInterface::current_alpha_price(netuid_i.into()));
             log::debug!("price_i: {price_i:?}");
 
             let mut tao_in_i: U96F32 = tao_emission_i;