Merge pull request #2192 from opentensor/hotfix/sn-to-emit-to

Hotfix/sn to emit to

Author: sam0x17

evm-tests/test/neuron.precompile.emission-check.test.ts

@@ -63,7 +63,7 @@ describe("Test the Neuron precompile with emission", () => {
 
         let i = 0;
         while (i < 10) {
-            const emission = await api.query.SubtensorModule.PendingEmission.getValue(netuid)
+            const emission = await api.query.SubtensorModule.ServerEmission.getValue(netuid)
 
             console.log("emission is ", emission);
             await new Promise((resolve) => setTimeout(resolve, 2000));

evm-tests/test/staking.precompile.reward.test.ts

@@ -74,14 +74,14 @@ describe("Test neuron precompile reward", () => {
 
         let index = 0;
         while (index < 60) {
-            const pending = await api.query.SubtensorModule.PendingEmission.getValue(netuid);
+            const pending = await api.query.SubtensorModule.ValidatorEmission.getValue(netuid);
             if (pending > 0) {
                 console.log("pending amount is ", pending);
                 break;
             }
 
             await new Promise((resolve) => setTimeout(resolve, 1000));
-            console.log("wait for the pendingEmission update");
+            console.log("wait for the ValidatorEmission update");
             index += 1;
         }
 

pallets/subtensor/src/coinbase/run_coinbase.rs

@@ -31,9 +31,12 @@ impl<T: Config> Pallet<T> {
             .collect();
         log::debug!("All subnet netuids: {subnets:?}");
 
+        let subnets_to_emit_to: Vec<NetUid> = Self::get_subnets_to_emit_to(&subnets);
+        log::debug!("Subnets to emit to: {subnets_to_emit_to:?}");
+
         // 2. Get subnets to emit to and emissions
-        let subnet_emissions = Self::get_subnet_block_emissions(&subnets, block_emission);
-        let subnets_to_emit_to: Vec<NetUid> = subnet_emissions.keys().copied().collect();
+        let subnet_emissions =
+            Self::get_subnet_block_emissions(&subnets_to_emit_to, block_emission);
         let root_sell_flag = Self::get_network_root_sell_flag(&subnets_to_emit_to);
 
         // --- 3. Get subnet terms (tao_in, alpha_in, and alpha_out)

pallets/subtensor/src/macros/hooks.rs

@@ -72,9 +72,6 @@ mod hooks {
                 .saturating_add(migrations::migrate_delete_subnet_21::migrate_delete_subnet_21::<T>())
                 // Storage version v4 -> v5
                 .saturating_add(migrations::migrate_delete_subnet_3::migrate_delete_subnet_3::<T>())
-                // Doesn't check storage version. TODO: Remove after upgrade
-                // Storage version v5 -> v6
-                .saturating_add(migrations::migrate_total_issuance::migrate_total_issuance::<T>(false))
                 // Populate OwnedHotkeys map for coldkey swap. Doesn't update storage vesion.
                 // Storage version v6 -> v7
                 .saturating_add(migrations::migrate_populate_owned_hotkeys::migrate_populate_owned::<T>())
@@ -163,7 +160,9 @@ mod hooks {
                 // Re-init tao flows
                 .saturating_add(migrations::migrate_init_tao_flow::migrate_init_tao_flow::<T>())
                 // Migrate pending emissions
-                .saturating_add(migrations::migrate_pending_emissions::migrate_pending_emissions::<T>());
+                .saturating_add(migrations::migrate_pending_emissions::migrate_pending_emissions::<T>())
+                // Reset unactive subnets
+                .saturating_add(migrations::migrate_reset_unactive_sn::migrate_reset_unactive_sn::<T>());
             weight
         }
 

pallets/subtensor/src/migrations/migrate_reset_unactive_sn.rs

@@ -0,0 +1,73 @@
+use super::*;
+
+pub fn get_unactive_sn_netuids<T: Config>(
+    pool_initial_alpha: AlphaCurrency,
+) -> (Vec<NetUid>, Weight) {
+    // Loop over all subnets, if the AlphaIssuance is > pool_initial_alpha
+    // but FirstEmissionBlockNumber is None
+    // then this subnet should be reset
+    let mut weight = T::DbWeight::get().reads(1);
+    let unactive_netuids = Pallet::<T>::get_all_subnet_netuids()
+        .iter()
+        .filter(|&netuid| !netuid.is_root())
+        .filter(|&netuid| {
+            let alpha_issuance = Pallet::<T>::get_alpha_issuance(*netuid);
+            let first_emission_block_number = FirstEmissionBlockNumber::<T>::get(*netuid);
+            alpha_issuance != pool_initial_alpha && first_emission_block_number.is_none()
+        })
+        .copied()
+        .collect::<Vec<_>>();
+    weight = weight
+        .saturating_add(T::DbWeight::get().reads(unactive_netuids.len().saturating_mul(3) as u64));
+
+    (unactive_netuids, weight)
+}
+
+pub fn migrate_reset_unactive_sn<T: Config>() -> Weight {
+    let migration_name = b"migrate_reset_unactive_sn".to_vec();
+    let mut weight: Weight = T::DbWeight::get().reads(1);
+
+    // Skip if already executed
+    if HasMigrationRun::<T>::get(&migration_name) {
+        log::info!(
+            target: "runtime",
+            "Migration '{}' already run - skipping.",
+            String::from_utf8_lossy(&migration_name)
+        );
+        return weight;
+    }
+    log::info!(
+        "Running migration '{}'",
+        String::from_utf8_lossy(&migration_name)
+    );
+
+    // From init_new_network
+    let pool_initial_tao: TaoCurrency = Pallet::<T>::get_network_min_lock();
+    let pool_initial_alpha: AlphaCurrency = pool_initial_tao.to_u64().into();
+
+    let (unactive_netuids, w) = get_unactive_sn_netuids::<T>(pool_initial_alpha);
+    weight = weight.saturating_add(w);
+
+    for netuid in unactive_netuids.iter() {
+        // Reset the subnet as it shouldn't have any emissions
+        PendingServerEmission::<T>::remove(*netuid);
+        PendingValidatorEmission::<T>::remove(*netuid);
+        PendingRootAlphaDivs::<T>::remove(*netuid);
+        PendingOwnerCut::<T>::remove(*netuid);
+        SubnetTaoInEmission::<T>::remove(*netuid);
+        SubnetAlphaInEmission::<T>::remove(*netuid);
+        SubnetAlphaOutEmission::<T>::remove(*netuid);
+        weight = weight.saturating_add(T::DbWeight::get().writes(7));
+    }
+
+    // Mark Migration as Completed
+    HasMigrationRun::<T>::insert(&migration_name, true);
+    weight = weight.saturating_add(T::DbWeight::get().writes(1));
+
+    log::info!(
+        "Migration '{:?}' completed successfully.",
+        String::from_utf8_lossy(&migration_name)
+    );
+
+    weight
+}

pallets/subtensor/src/migrations/migrate_total_issuance.rs

@@ -51,14 +51,6 @@ pub fn migrate_total_issuance<T: Config>(test: bool) -> Weight {
             T::DbWeight::get().reads((Owner::<T>::iter().count() as u64).saturating_mul(2)),
         );
 
-        // Calculate the sum of all locked subnet values
-        let locked_sum = SubnetLocked::<T>::iter().fold(TaoCurrency::ZERO, |acc, (_, locked)| {
-            acc.saturating_add(locked)
-        });
-        // Add weight for reading all subnet locked entries
-        weight = weight
-            .saturating_add(T::DbWeight::get().reads(SubnetLocked::<T>::iter().count() as u64));
-
         // Retrieve the total balance sum
         let total_balance = <T as Config>::Currency::total_issuance();
         // Add weight for reading total issuance
@@ -69,8 +61,7 @@ pub fn migrate_total_issuance<T: Config>(test: bool) -> Weight {
             Ok(total_balance_sum) => {
                 // Compute the total issuance value
                 let total_issuance_value = stake_sum
-                    .saturating_add(total_balance_sum.into())
-                    .saturating_add(locked_sum.into());
+                    .saturating_add(total_balance_sum.into());
 
                 // Update the total issuance in storage
                 TotalIssuance::<T>::put(total_issuance_value);

pallets/subtensor/src/migrations/mod.rs

@@ -41,6 +41,7 @@ pub mod migrate_remove_unused_maps_and_values;
 pub mod migrate_remove_zero_total_hotkey_alpha;
 pub mod migrate_reset_bonds_moving_average;
 pub mod migrate_reset_max_burn;
+pub mod migrate_reset_unactive_sn;
 pub mod migrate_set_first_emission_block_number;
 pub mod migrate_set_min_burn;
 pub mod migrate_set_min_difficulty;
@@ -55,7 +56,6 @@ pub mod migrate_subnet_symbols;
 pub mod migrate_subnet_volume;
 pub mod migrate_to_v1_separate_emission;
 pub mod migrate_to_v2_fixed_total_stake;
-pub mod migrate_total_issuance;
 pub mod migrate_transfer_ownership_to_foundation;
 pub mod migrate_upgrade_revealed_commitments;
 

pallets/subtensor/src/tests/coinbase.rs

@@ -89,12 +89,16 @@ fn test_coinbase_tao_issuance_base() {
         let subnet_owner_ck = U256::from(1001);
         let subnet_owner_hk = U256::from(1002);
         let netuid = add_dynamic_network(&subnet_owner_hk, &subnet_owner_ck);
+        let total_issuance_before = TotalIssuance::<Test>::get();
         SubnetMovingPrice::<Test>::insert(netuid, I96F32::from(3141) / I96F32::from(1000));
         let tao_in_before = SubnetTAO::<Test>::get(netuid);
         let total_stake_before = TotalStake::<Test>::get();
         SubtensorModule::run_coinbase(U96F32::from_num(emission));
         assert_eq!(SubnetTAO::<Test>::get(netuid), tao_in_before + emission);
-        assert_eq!(TotalIssuance::<Test>::get(), emission);
+        assert_eq!(
+            TotalIssuance::<Test>::get(),
+            total_issuance_before + emission
+        );
         assert_eq!(TotalStake::<Test>::get(), total_stake_before + emission);
     });
 }
@@ -3317,3 +3321,86 @@ fn test_mining_emission_distribution_with_root_sell() {
         );
     });
 }
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor --lib -- tests::coinbase::test_pending_emission_start_call_not_done --exact --show-output --nocapture
+#[test]
+fn test_pending_emission_start_call_not_done() {
+    new_test_ext(1).execute_with(|| {
+        let validator_coldkey = U256::from(1);
+        let validator_hotkey = U256::from(2);
+        let subnet_tempo = 10;
+        let stake: u64 = 100_000_000_000;
+        let root_stake: u64 = 200_000_000_000; // 200 TAO
+
+        // Create root network
+        NetworksAdded::<Test>::insert(NetUid::ROOT, true);
+        // enabled root
+        SubtokenEnabled::<Test>::insert(NetUid::ROOT, true);
+
+        // Add network, register hotkeys, and setup network parameters
+        let owner_hotkey = U256::from(10);
+        let owner_coldkey = U256::from(11);
+        let netuid = add_dynamic_network(&owner_hotkey, &owner_coldkey);
+        // Remove FirstEmissionBlockNumber
+        FirstEmissionBlockNumber::<Test>::remove(netuid);
+        Tempo::<Test>::insert(netuid, subnet_tempo);
+
+        register_ok_neuron(netuid, validator_hotkey, validator_coldkey, 0);
+        SubtensorModule::add_balance_to_coldkey_account(
+            &validator_coldkey,
+            stake + ExistentialDeposit::get(),
+        );
+        SubtensorModule::set_weights_set_rate_limit(netuid, 0);
+        step_block(subnet_tempo);
+        SubnetOwnerCut::<Test>::set(u16::MAX / 10);
+        // There are two validators and three neurons
+        MaxAllowedUids::<Test>::set(netuid, 3);
+        SubtensorModule::set_max_allowed_validators(netuid, 2);
+
+        // Add stake to validator so it has root stake
+        SubtensorModule::add_balance_to_coldkey_account(&validator_coldkey, root_stake.into());
+        // init root
+        assert_ok!(SubtensorModule::add_stake(
+            RuntimeOrigin::signed(validator_coldkey),
+            validator_hotkey,
+            NetUid::ROOT,
+            root_stake.into()
+        ));
+        // Set tao weight non zero
+        SubtensorModule::set_tao_weight(u64::MAX / 10);
+
+        // Make root sell happen
+        // Set moving price > 1.0
+        // Set price > 1.0
+        pallet_subtensor_swap::AlphaSqrtPrice::<Test>::insert(
+            netuid,
+            U64F64::saturating_from_num(10.0),
+        );
+
+        SubnetMovingPrice::<Test>::insert(netuid, I96F32::from_num(2));
+
+        // Make sure we are root selling, so we have root alpha divs.
+        let root_sell_flag = SubtensorModule::get_network_root_sell_flag(&[netuid]);
+        assert!(root_sell_flag, "Root sell flag should be true");
+
+        // !!! Check that the subnet FirstEmissionBlockNumber is None -- no entry
+        assert!(FirstEmissionBlockNumber::<Test>::get(netuid).is_none());
+
+        // Run run_coinbase until emissions are accumulated
+        step_block(subnet_tempo - 2);
+
+        // Verify that all pending emissions are zero
+        assert_eq!(
+            PendingServerEmission::<Test>::get(netuid),
+            AlphaCurrency::ZERO
+        );
+        assert_eq!(
+            PendingValidatorEmission::<Test>::get(netuid),
+            AlphaCurrency::ZERO
+        );
+        assert_eq!(
+            PendingRootAlphaDivs::<Test>::get(netuid),
+            AlphaCurrency::ZERO
+        );
+    });
+}