Merge branch 'devnet' into devnet-ready

Author: camfairchild

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/benchmarks.rs

@@ -1615,11 +1615,11 @@ mod pallet_benchmarks {
         );
 
         let pending_root_alpha = 10_000_000u64;
-        Subtensor::<T>::drain_pending_emission(
+        Subtensor::<T>::distribute_emission(
             netuid,
             AlphaCurrency::ZERO,
             pending_root_alpha.into(),
-            pending_root_alpha.into(), // alpha out
+            pending_root_alpha.into(),
             AlphaCurrency::ZERO,
         );
 

pallets/subtensor/src/coinbase/root.rs

@@ -314,7 +314,8 @@ impl<T: Config> Pallet<T> {
 
         // --- 15. Mechanism step / emissions bookkeeping.
         FirstEmissionBlockNumber::<T>::remove(netuid);
-        PendingEmission::<T>::remove(netuid);
+        PendingValidatorEmission::<T>::remove(netuid);
+        PendingServerEmission::<T>::remove(netuid);
         PendingRootAlphaDivs::<T>::remove(netuid);
         PendingOwnerCut::<T>::remove(netuid);
         BlocksSinceLastStep::<T>::remove(netuid);

pallets/subtensor/src/coinbase/run_coinbase.rs

@@ -1,27 +1,26 @@
 use super::*;
-use crate::alloc::borrow::ToOwned;
 use alloc::collections::BTreeMap;
 use safe_math::FixedExt;
 use substrate_fixed::transcendental::{exp, ln};
 use substrate_fixed::types::{I32F32, I64F64, U64F64, U96F32};
 use subtensor_swap_interface::SwapHandler;
 
 impl<T: Config> Pallet<T> {
-    pub fn get_subnet_block_emissions(
-        subnets: &[NetUid],
-        block_emission: U96F32,
-    ) -> BTreeMap<NetUid, U96F32> {
+    pub fn get_subnets_to_emit_to(subnets: &[NetUid]) -> Vec<NetUid> {
         // Filter out subnets with no first emission block number.
-        let subnets_to_emit_to: Vec<NetUid> = subnets
-            .to_owned()
-            .clone()
-            .into_iter()
+        subnets
+            .iter()
             .filter(|netuid| FirstEmissionBlockNumber::<T>::get(*netuid).is_some())
-            .collect();
-        log::debug!("Subnets to emit to: {subnets_to_emit_to:?}");
+            .copied()
+            .collect()
+    }
 
+    pub fn get_subnet_block_emissions(
+        subnets_to_emit_to: &[NetUid],
+        block_emission: U96F32,
+    ) -> BTreeMap<NetUid, U96F32> {
         // Get subnet TAO emissions.
-        let shares = Self::get_shares(&subnets_to_emit_to);
+        let shares = Self::get_shares(subnets_to_emit_to);
         log::debug!("Subnet emission shares = {shares:?}");
 
         shares

pallets/subtensor/src/coinbase/subnet_emissions.rs

@@ -1430,9 +1430,13 @@ pub mod pallet {
     pub type NetworkRegisteredAt<T: Config> =
         StorageMap<_, Identity, NetUid, u64, ValueQuery, DefaultNetworkRegisteredAt<T>>;
     #[pallet::storage]
-    /// --- MAP ( netuid ) --> pending_emission
-    pub type PendingEmission<T> =
-        StorageMap<_, Identity, NetUid, AlphaCurrency, ValueQuery, DefaultPendingEmission<T>>;
+    /// --- MAP ( netuid ) --> pending_server_emission
+    pub type PendingServerEmission<T> =
+        StorageMap<_, Identity, NetUid, AlphaCurrency, ValueQuery, DefaultZeroAlpha<T>>;
+    /// --- MAP ( netuid ) --> pending_validator_emission
+    #[pallet::storage]
+    pub type PendingValidatorEmission<T> =
+        StorageMap<_, Identity, NetUid, AlphaCurrency, ValueQuery, DefaultZeroAlpha<T>>;
     /// --- MAP ( netuid ) --> pending_root_alpha_emission
     #[pallet::storage]
     pub type PendingRootAlphaDivs<T> =

pallets/subtensor/src/lib.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>())
@@ -161,7 +158,11 @@ mod hooks {
                 // Remove obsolete map entries
                 .saturating_add(migrations::migrate_remove_tao_dividends::migrate_remove_tao_dividends::<T>())
                 // Re-init tao flows
-                .saturating_add(migrations::migrate_init_tao_flow::migrate_init_tao_flow::<T>());
+                .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>())
+                // Reset unactive subnets
+                .saturating_add(migrations::migrate_reset_unactive_sn::migrate_reset_unactive_sn::<T>());
             weight
         }
 

pallets/subtensor/src/macros/hooks.rs

@@ -0,0 +1,73 @@
+use super::*;
+use frame_support::{storage_alias, traits::Get, weights::Weight};
+use substrate_fixed::types::U96F32;
+
+pub mod deprecated_pending_emission_format {
+    use super::*;
+
+    #[storage_alias]
+    pub(super) type PendingEmission<T: Config> =
+        StorageMap<Pallet<T>, Identity, NetUid, AlphaCurrency, ValueQuery>;
+}
+
+pub fn migrate_pending_emissions<T: Config>() -> Weight {
+    let migration_name = b"migrate_pending_emissions".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)
+    );
+
+    // Pull from PendingEmission and distribute to PendingValidatorEmission and PendingServerEmission
+    for (netuid, pending_emission) in
+        deprecated_pending_emission_format::PendingEmission::<T>::iter()
+    {
+        // Split up the pending emission into server and validator emission
+        // Server emission is pending+root_alpha times the 50% miner cut.
+        let root_alpha: U96F32 =
+            U96F32::saturating_from_num(PendingRootAlphaDivs::<T>::get(netuid).to_u64());
+        let server_emission_float: U96F32 = U96F32::saturating_from_num(pending_emission.to_u64())
+            .saturating_add(root_alpha)
+            .saturating_div(U96F32::saturating_from_num(2));
+        let server_emission: AlphaCurrency =
+            server_emission_float.saturating_to_num::<u64>().into();
+        let validator_emission = pending_emission.saturating_sub(server_emission);
+
+        PendingValidatorEmission::<T>::mutate(netuid, |total| {
+            *total = total.saturating_add(validator_emission)
+        });
+        PendingServerEmission::<T>::mutate(netuid, |total| {
+            *total = total.saturating_add(server_emission)
+        });
+
+        weight = weight.saturating_add(T::DbWeight::get().reads_writes(1, 2));
+    }
+
+    // Kill the map
+    let removal_result =
+        deprecated_pending_emission_format::PendingEmission::<T>::clear(u32::MAX, None);
+    weight = weight.saturating_add(
+        T::DbWeight::get().reads_writes(removal_result.loops as u64, removal_result.backend as u64),
+    );
+
+    // 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_pending_emissions.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
+}