Merge pull request #1892 from opentensor/fix/v3_emission_devnet_ready

sam0x17 · web-flow · commit 3d6b0a6615fe · 2025-07-29T17:09:59.000-04:00
Fix v3 emissions on low prices
diff --git a/pallets/subtensor/src/coinbase/run_coinbase.rs b/pallets/subtensor/src/coinbase/run_coinbase.rs
@@ -53,6 +53,7 @@ impl<T: Config> Pallet<T> {
         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();
+        let mut is_subsidized: BTreeMap<NetUid, bool> = BTreeMap::new();
         // Only calculate for subnets that we are emitting to.
         for netuid_i in subnets_to_emit_to.iter() {
             // Get subnet price.
@@ -62,23 +63,50 @@ impl<T: Config> Pallet<T> {
             let moving_price_i: U96F32 = Self::get_moving_alpha_price(*netuid_i);
             log::debug!("moving_price_i: {:?}", moving_price_i);
             // Emission is price over total.
-            let mut tao_in_i: U96F32 = block_emission
+            let default_tao_in_i: U96F32 = block_emission
                 .saturating_mul(moving_price_i)
                 .checked_div(total_moving_prices)
                 .unwrap_or(asfloat!(0.0));
-            log::debug!("tao_in_i: {:?}", tao_in_i);
+            log::debug!("default_tao_in_i: {:?}", default_tao_in_i);
             // Get alpha_emission total
             let alpha_emission_i: U96F32 = asfloat!(
                 Self::get_block_emission_for_issuance(Self::get_alpha_issuance(*netuid_i).into())
                     .unwrap_or(0)
             );
             log::debug!("alpha_emission_i: {:?}", alpha_emission_i);
+
             // Get initial alpha_in
-            let alpha_in_i: U96F32 = tao_in_i
-                .checked_div(price_i)
-                .unwrap_or(alpha_emission_i)
-                .min(alpha_emission_i);
+            let alpha_in_i: U96F32;
+            let mut tao_in_i: U96F32;
+            let tao_in_ratio: U96F32 = default_tao_in_i.safe_div_or(
+                U96F32::saturating_from_num(block_emission),
+                U96F32::saturating_from_num(0.0),
+            );
+            if price_i < tao_in_ratio {
+                tao_in_i = price_i.saturating_mul(U96F32::saturating_from_num(block_emission));
+                alpha_in_i = alpha_emission_i;
+                let difference_tao: U96F32 = default_tao_in_i.saturating_sub(tao_in_i);
+                // Difference becomes buy.
+                let buy_swap_result = Self::swap_tao_for_alpha(
+                    *netuid_i,
+                    tou64!(difference_tao),
+                    T::SwapInterface::max_price(),
+                    true,
+                );
+                if let Ok(buy_swap_result_ok) = buy_swap_result {
+                    let bought_alpha = AlphaCurrency::from(buy_swap_result_ok.amount_paid_out);
+                    SubnetAlphaOut::<T>::mutate(*netuid_i, |total| {
+                        *total = total.saturating_sub(bought_alpha);
+                    });
+                }
+                is_subsidized.insert(*netuid_i, true);
+            } else {
+                tao_in_i = default_tao_in_i;
+                alpha_in_i = tao_in_i.safe_div_or(price_i, alpha_emission_i);
+                is_subsidized.insert(*netuid_i, false);
+            }
             log::debug!("alpha_in_i: {:?}", alpha_in_i);
+
             // Get alpha_out.
             let alpha_out_i = alpha_emission_i;
             // Only emit TAO if the subnetwork allows registration.
@@ -101,15 +129,15 @@ impl<T: Config> Pallet<T> {
         // This operation changes the pool liquidity each block.
         for netuid_i in subnets_to_emit_to.iter() {
             // Inject Alpha in.
-            let alpha_in_i: AlphaCurrency =
-                tou64!(*alpha_in.get(netuid_i).unwrap_or(&asfloat!(0))).into();
+            let alpha_in_i =
+                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);
             });
             // Injection Alpha out.
-            let alpha_out_i: AlphaCurrency =
-                tou64!(*alpha_out.get(netuid_i).unwrap_or(&asfloat!(0))).into();
+            let alpha_out_i =
+                AlphaCurrency::from(tou64!(*alpha_out.get(netuid_i).unwrap_or(&asfloat!(0))));
             SubnetAlphaOutEmission::<T>::insert(*netuid_i, alpha_out_i);
             SubnetAlphaOut::<T>::mutate(*netuid_i, |total| {
                 *total = total.saturating_add(alpha_out_i);
@@ -182,29 +210,30 @@ 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 (do not pay fees)
-            let swap_result = Self::swap_alpha_for_tao(
-                *netuid_i,
-                tou64!(root_alpha).into(),
-                T::SwapInterface::min_price(),
-                true,
-            );
-            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).into());
-                });
-                // Accumulate alpha emission in pending.
-                PendingEmission::<T>::mutate(*netuid_i, |total| {
-                    *total = total.saturating_add(tou64!(pending_alpha).into());
-                });
-                // Accumulate root divs for subnet.
-                PendingRootDivs::<T>::mutate(*netuid_i, |total| {
-                    *total = total.saturating_add(root_tao);
-                });
+            let subsidized: bool = *is_subsidized.get(netuid_i).unwrap_or(&false);
+            if !subsidized {
+                let swap_result = Self::swap_alpha_for_tao(
+                    *netuid_i,
+                    tou64!(root_alpha).into(),
+                    T::SwapInterface::min_price(),
+                    true,
+                );
+                if let Ok(ok_result) = swap_result {
+                    let root_tao: u64 = ok_result.amount_paid_out;
+                    // Accumulate root divs for subnet.
+                    PendingRootDivs::<T>::mutate(*netuid_i, |total| {
+                        *total = total.saturating_add(root_tao);
+                    });
+                }
             }
+            // Accumulate alpha emission in pending.
+            PendingAlphaSwapped::<T>::mutate(*netuid_i, |total| {
+                *total = total.saturating_add(tou64!(root_alpha).into());
+            });
+            // Accumulate alpha emission in pending.
+            PendingEmission::<T>::mutate(*netuid_i, |total| {
+                *total = total.saturating_add(tou64!(pending_alpha).into());
+            });
         }
 
         // --- 7 Update moving prices after using them in the emission calculation.
@@ -236,7 +265,7 @@ impl<T: Config> Pallet<T> {
                 PendingEmission::<T>::insert(netuid, AlphaCurrency::ZERO);
 
                 // Get and drain the subnet pending root divs.
-                let pending_tao: u64 = PendingRootDivs::<T>::get(netuid);
+                let pending_tao = PendingRootDivs::<T>::get(netuid);
                 PendingRootDivs::<T>::insert(netuid, 0);
 
                 // Get this amount as alpha that was swapped for pending root divs.
diff --git a/pallets/subtensor/src/staking/stake_utils.rs b/pallets/subtensor/src/staking/stake_utils.rs
@@ -629,6 +629,7 @@ impl<T: Config> Pallet<T> {
         netuid: NetUid,
         tao: u64,
         price_limit: u64,
+        drop_fees: bool,
     ) -> 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);
@@ -638,7 +639,7 @@ impl<T: Config> Pallet<T> {
                 OrderType::Buy,
                 tao,
                 price_limit,
-                false,
+                drop_fees,
                 false,
             )?;
             let alpha_decrease =
@@ -821,7 +822,7 @@ impl<T: Config> Pallet<T> {
         set_limit: bool,
     ) -> Result<AlphaCurrency, DispatchError> {
         // Swap the tao to alpha.
-        let swap_result = Self::swap_tao_for_alpha(netuid, tao, price_limit)?;
+        let swap_result = Self::swap_tao_for_alpha(netuid, tao, price_limit, false)?;
 
         ensure!(swap_result.amount_paid_out > 0, Error::<T>::AmountTooLow);
 
diff --git a/pallets/subtensor/src/subnets/registration.rs b/pallets/subtensor/src/subnets/registration.rs
@@ -141,9 +141,13 @@ impl<T: Config> Pallet<T> {
             Self::remove_balance_from_coldkey_account(&coldkey, registration_cost)?;
 
         // Tokens are swapped and then burned.
-        let burned_alpha =
-            Self::swap_tao_for_alpha(netuid, actual_burn_amount, T::SwapInterface::max_price())?
-                .amount_paid_out;
+        let burned_alpha = Self::swap_tao_for_alpha(
+            netuid,
+            actual_burn_amount,
+            T::SwapInterface::max_price(),
+            false,
+        )?
+        .amount_paid_out;
         SubnetAlphaOut::<T>::mutate(netuid, |total| {
             *total = total.saturating_sub(burned_alpha.into())
         });
diff --git a/pallets/subtensor/src/tests/children.rs b/pallets/subtensor/src/tests/children.rs
@@ -3031,6 +3031,7 @@ fn test_parent_child_chain_emission() {
                 netuid,
                 total_tao.to_num::<u64>(),
                 <Test as Config>::SwapInterface::max_price(),
+                false,
             )
             .unwrap()
             .amount_paid_out,
diff --git a/pallets/subtensor/src/tests/coinbase.rs b/pallets/subtensor/src/tests/coinbase.rs
@@ -10,6 +10,7 @@ use pallet_subtensor_swap::position::PositionId;
 use sp_core::U256;
 use substrate_fixed::types::{I64F64, I96F32, U96F32};
 use subtensor_runtime_common::AlphaCurrency;
+use subtensor_swap_interface::SwapHandler;
 
 #[allow(clippy::arithmetic_side_effects)]
 fn close(value: u64, target: u64, eps: u64) {
@@ -158,22 +159,49 @@ fn test_coinbase_tao_issuance_different_prices() {
         let emission: u64 = 100_000_000;
         add_network(netuid1, 1, 0);
         add_network(netuid2, 1, 0);
+
+        // Setup prices 0.1 and 0.2
+        let initial_tao: u64 = 100_000_u64;
+        let initial_alpha1: u64 = initial_tao * 10;
+        let initial_alpha2: u64 = initial_tao * 5;
+        mock::setup_reserves(netuid1, initial_tao, initial_alpha1.into());
+        mock::setup_reserves(netuid2, initial_tao, initial_alpha2.into());
+
+        // Force the swap to initialize
+        SubtensorModule::swap_tao_for_alpha(netuid1, 0, 1_000_000_000_000, false).unwrap();
+        SubtensorModule::swap_tao_for_alpha(netuid2, 0, 1_000_000_000_000, false).unwrap();
+
         // Make subnets dynamic.
         SubnetMechanism::<Test>::insert(netuid1, 1);
         SubnetMechanism::<Test>::insert(netuid2, 1);
+
         // Set subnet prices.
         SubnetMovingPrice::<Test>::insert(netuid1, I96F32::from_num(1));
         SubnetMovingPrice::<Test>::insert(netuid2, I96F32::from_num(2));
+
         // Assert initial TAO reserves.
-        assert_eq!(SubnetTAO::<Test>::get(netuid1), 0);
-        assert_eq!(SubnetTAO::<Test>::get(netuid2), 0);
+        assert_eq!(SubnetTAO::<Test>::get(netuid1), initial_tao);
+        assert_eq!(SubnetTAO::<Test>::get(netuid2), initial_tao);
+
         // Run the coinbase with the emission amount.
         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);
-        close(TotalIssuance::<Test>::get(), emission, 2);
-        close(TotalStake::<Test>::get(), emission, 2);
+        assert_abs_diff_eq!(
+            SubnetTAO::<Test>::get(netuid1),
+            initial_tao + emission / 3,
+            epsilon = 1,
+        );
+        assert_abs_diff_eq!(
+            SubnetTAO::<Test>::get(netuid2),
+            initial_tao + 2 * emission / 3,
+            epsilon = 1,
+        );
+
+        // Prices are low => we limit tao issued (buy alpha with it)
+        let tao_issued = ((0.1 + 0.2) * emission as f64) as u64;
+        assert_abs_diff_eq!(TotalIssuance::<Test>::get(), tao_issued, epsilon = 10);
+        assert_abs_diff_eq!(TotalStake::<Test>::get(), emission, epsilon = 10);
     });
 }
 
@@ -391,17 +419,11 @@ fn test_coinbase_alpha_issuance_with_cap_trigger() {
         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!(
-            SubnetAlphaIn::<Test>::get(netuid1),
-            (initial_alpha + 1_000_000_000).into()
-        );
+        assert!(SubnetAlphaIn::<Test>::get(netuid1) < (initial_alpha + 1_000_000_000).into());
         assert_eq!(SubnetAlphaOut::<Test>::get(netuid2), 1_000_000_000.into());
         // tao_in = 666_666
         // alpha_in = 666_666/price > 1_000_000_000 --> 1_000_000_000 + initial_alpha
-        assert_eq!(
-            SubnetAlphaIn::<Test>::get(netuid2),
-            (initial_alpha + 1_000_000_000).into()
-        );
+        assert!(SubnetAlphaIn::<Test>::get(netuid2) < (initial_alpha + 1_000_000_000).into());
         assert_eq!(SubnetAlphaOut::<Test>::get(netuid2), 1_000_000_000.into()); // Gets full block emission.
     });
 }
@@ -415,39 +437,56 @@ fn test_coinbase_alpha_issuance_with_cap_trigger_and_block_emission() {
         let emission: u64 = 1_000_000;
         add_network(netuid1, 1, 0);
         add_network(netuid2, 1, 0);
+
         // Make subnets dynamic.
         SubnetMechanism::<Test>::insert(netuid1, 1);
         SubnetMechanism::<Test>::insert(netuid2, 1);
-        // Setup prices 1000000
-        let initial: u64 = 1_000;
-        let initial_alpha = AlphaCurrency::from(initial * 1000000);
-        SubnetTAO::<Test>::insert(netuid1, initial);
-        SubnetAlphaIn::<Test>::insert(netuid1, initial_alpha); // Make price extremely low.
-        SubnetTAO::<Test>::insert(netuid2, initial);
-        SubnetAlphaIn::<Test>::insert(netuid2, initial_alpha); // Make price extremely low.
-        // Set issuance to greater than 21M
-        SubnetAlphaOut::<Test>::insert(netuid1, AlphaCurrency::from(22_000_000_000_000_000)); // Set issuance above 21M
-        SubnetAlphaOut::<Test>::insert(netuid2, AlphaCurrency::from(22_000_000_000_000_000)); // Set issuance above 21M
-        // Set subnet prices.
+
+        // Setup prices 0.000001
+        let initial_tao: u64 = 10_000_u64;
+        let initial_alpha: u64 = initial_tao * 100_000_u64;
+        mock::setup_reserves(netuid1, initial_tao, initial_alpha.into());
+        mock::setup_reserves(netuid2, initial_tao, initial_alpha.into());
+
+        // Enable emission
+        FirstEmissionBlockNumber::<Test>::insert(netuid1, 0);
+        FirstEmissionBlockNumber::<Test>::insert(netuid2, 0);
         SubnetMovingPrice::<Test>::insert(netuid1, I96F32::from_num(1));
         SubnetMovingPrice::<Test>::insert(netuid2, I96F32::from_num(2));
+
+        // Force the swap to initialize
+        SubtensorModule::swap_tao_for_alpha(netuid1, 0, 1_000_000_000_000, false).unwrap();
+        SubtensorModule::swap_tao_for_alpha(netuid2, 0, 1_000_000_000_000, false).unwrap();
+
+        // Get the prices before the run_coinbase
+        let price_1_before = <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid1);
+        let price_2_before = <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid2);
+
+        // Set issuance at 21M
+        SubnetAlphaOut::<Test>::insert(netuid1, AlphaCurrency::from(21_000_000_000_000_000)); // Set issuance above 21M
+        SubnetAlphaOut::<Test>::insert(netuid2, AlphaCurrency::from(21_000_000_000_000_000)); // Set issuance above 21M
+
         // Run coinbase
         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);
+
+        // Get the prices after the run_coinbase
+        let price_1_after = <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid1);
+        let price_2_after = <Test as pallet::Config>::SwapInterface::current_alpha_price(netuid2);
+
+        // AlphaIn gets decreased beacuse of a buy
+        assert!(u64::from(SubnetAlphaIn::<Test>::get(netuid1)) < initial_alpha);
         assert_eq!(
-            SubnetAlphaOut::<Test>::get(netuid2),
-            22_000_000_000_000_000.into()
+            u64::from(SubnetAlphaOut::<Test>::get(netuid2)),
+            21_000_000_000_000_000_u64
         );
-        // tao_in = 666_666
-        // alpha_in = 666_666/price > 1_000_000_000 --> 0 + initial_alpha
-        assert_eq!(SubnetAlphaIn::<Test>::get(netuid2), initial_alpha);
+        assert!(u64::from(SubnetAlphaIn::<Test>::get(netuid2)) < initial_alpha);
         assert_eq!(
-            SubnetAlphaOut::<Test>::get(netuid2),
-            22_000_000_000_000_000.into()
+            u64::from(SubnetAlphaOut::<Test>::get(netuid2)),
+            21_000_000_000_000_000_u64
         );
-        // No emission.
+
+        assert!(price_1_after > price_1_before);
+        assert!(price_2_after > price_2_before);
     });
 }
 
@@ -2388,7 +2427,7 @@ fn test_coinbase_v3_liquidity_update() {
         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();
+        SubtensorModule::swap_tao_for_alpha(netuid, 0, 1_000_000_000_000, false).unwrap();
 
         let protocol_account_id = pallet_subtensor_swap::Pallet::<Test>::protocol_account_id();
         let position = pallet_subtensor_swap::Positions::<Test>::get((
diff --git a/pallets/subtensor/src/tests/staking.rs b/pallets/subtensor/src/tests/staking.rs
@@ -565,7 +565,7 @@ fn test_add_stake_partial_below_min_stake_fails() {
         mock::setup_reserves(netuid, amount * 10, (amount * 10).into());
 
         // 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, false).unwrap();
 
         // Get the current price (should be 1.0)
         let current_price =
@@ -3306,7 +3306,7 @@ fn test_max_amount_add_dynamic() {
             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, false).unwrap();
 
             if !alpha_in.is_zero() {
                 let expected_price = U96F32::from_num(tao_in) / U96F32::from_num(alpha_in);
@@ -5705,7 +5705,7 @@ fn test_large_swap() {
         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();
+        SubtensorModule::swap_tao_for_alpha(netuid, 0, 1_000_000_000_000, false).unwrap();
 
         setup_positions(netuid.into());
 
diff --git a/pallets/subtensor/src/tests/staking2.rs b/pallets/subtensor/src/tests/staking2.rs

Original file line number	Diff line number	Diff line change
`@@ -3031,6 +3031,7 @@ fn test_parent_child_chain_emission() {`
`3031`	`3031`	`netuid,`
`3032`	`3032`	`total_tao.to_num::<u64>(),`
`3033`	`3033`	`<Test as Config>::SwapInterface::max_price(),`
	`3034`	`+ false,`
`3034`	`3035`	`)`
`3035`	`3036`	`.unwrap()`
`3036`	`3037`	`.amount_paid_out,`