Merge pull request #1334 from opentensor/devnet-ready

devnet deploy 2/24/2025

Author: sam0x17

pallets/admin-utils/src/lib.rs

@@ -29,6 +29,7 @@ pub mod pallet {
     use frame_system::pallet_prelude::*;
     use pallet_evm_chain_id::{self, ChainId};
     use sp_runtime::BoundedVec;
+    use substrate_fixed::types::I96F32;
 
     /// The main data structure of the module.
     #[pallet::pallet]
@@ -1377,6 +1378,28 @@ pub mod pallet {
             }
             Ok(())
         }
+
+        ///
+        ///
+        /// # Arguments
+        /// * `origin` - The origin of the call, which must be the root account.
+        /// * `precompile_id` - The identifier of the EVM precompile to toggle.
+        /// * `enabled` - The new enablement state of the precompile.
+        ///
+        /// # Errors
+        /// * `BadOrigin` - If the caller is not the root account.
+        ///
+        /// # Weight
+        /// Weight is handled by the `#[pallet::weight]` attribute.
+        #[pallet::call_index(63)]
+        #[pallet::weight((0, DispatchClass::Operational, Pays::No))]
+        pub fn sudo_set_subnet_moving_alpha(origin: OriginFor<T>, alpha: I96F32) -> DispatchResult {
+            ensure_root(origin)?;
+            pallet_subtensor::SubnetMovingAlpha::<T>::set(alpha);
+
+            log::debug!("SubnetMovingAlphaSet( alpha: {:?} )", alpha);
+            Ok(())
+        }
     }
 }
 

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

@@ -10,6 +10,7 @@ use pallet_subtensor::Error as SubtensorError;
 use pallet_subtensor::Event;
 use sp_consensus_grandpa::AuthorityId as GrandpaId;
 use sp_core::{Pair, U256, ed25519};
+use substrate_fixed::types::I96F32;
 
 use crate::Error;
 use crate::pallet::PrecompileEnable;
@@ -1449,3 +1450,19 @@ fn test_sudo_toggle_evm_precompile() {
         assert!(final_enabled);
     });
 }
+
+#[test]
+fn test_sudo_root_sets_subnet_moving_alpha() {
+    new_test_ext().execute_with(|| {
+        let alpha: I96F32 = I96F32::saturating_from_num(0.5);
+        let initial = pallet_subtensor::SubnetMovingAlpha::<Test>::get();
+        assert!(initial != alpha);
+
+        assert_ok!(AdminUtils::sudo_set_subnet_moving_alpha(
+            <<Test as Config>::RuntimeOrigin>::root(),
+            alpha
+        ));
+
+        assert_eq!(pallet_subtensor::SubnetMovingAlpha::<Test>::get(), alpha);
+    });
+}

pallets/subtensor/src/epoch/run_epoch.rs

@@ -390,7 +390,7 @@ impl<T: Config> Pallet<T> {
             .iter()
             .map(|updated| updated.saturating_add(activity_cutoff) < current_block)
             .collect();
-        log::trace!("Inactive: {:?}", inactive.clone());
+        log::debug!("Inactive: {:?}", inactive.clone());
 
         // Logical negation of inactive.
         let active: Vec<bool> = inactive.iter().map(|&b| !b).collect();
@@ -406,14 +406,14 @@ impl<T: Config> Pallet<T> {
         let hotkeys: Vec<(u16, T::AccountId)> =
             <Keys<T> as IterableStorageDoubleMap<u16, u16, T::AccountId>>::iter_prefix(netuid)
                 .collect();
-        log::trace!("hotkeys: {:?}", &hotkeys);
+        log::debug!("hotkeys: {:?}", &hotkeys);
 
         // Access network stake as normalized vector.
         let (mut total_stake, _alpha_stake, _tao_stake): (Vec<I64F64>, Vec<I64F64>, Vec<I64F64>) =
             Self::get_stake_weights_for_network(netuid);
         inplace_normalize_64(&mut total_stake);
         let stake: Vec<I32F32> = vec_fixed64_to_fixed32(total_stake);
-        log::trace!("Normalised Stake: {:?}", &stake);
+        log::debug!("Normalised Stake: {:?}", &stake);
 
         // =======================
         // == Validator permits ==
@@ -448,7 +448,7 @@ impl<T: Config> Pallet<T> {
 
         // Normalize active stake.
         inplace_normalize(&mut active_stake);
-        log::trace!("Active Stake:\n{:?}\n", &active_stake);
+        log::debug!("Active Stake:\n{:?}\n", &active_stake);
 
         // =============
         // == Weights ==

pallets/subtensor/src/lib.rs

@@ -998,18 +998,6 @@ pub mod pallet {
     #[pallet::storage] // --- MAP ( cold ) --> Vec<hot> | Returns the vector of hotkeys controlled by this coldkey.
     pub type OwnedHotkeys<T: Config> =
         StorageMap<_, Blake2_128Concat, T::AccountId, Vec<T::AccountId>, ValueQuery>;
-    #[pallet::storage]
-    /// (DEPRECATED) DMAP ( hot, cold ) --> stake | Returns the stake under a coldkey prefixed by hotkey.
-    pub type Stake<T: Config> = StorageDoubleMap<
-        _,
-        Blake2_128Concat,
-        T::AccountId,
-        Identity,
-        T::AccountId,
-        u64,
-        ValueQuery,
-        DefaultZeroU64<T>,
-    >;
 
     #[pallet::storage] // --- DMAP ( cold ) --> () | Maps coldkey to if a coldkey swap is scheduled.
     pub type ColdkeySwapScheduled<T: Config> =

pallets/subtensor/src/macros/hooks.rs

@@ -63,12 +63,6 @@ mod hooks {
                 // 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>())
-                // Populate StakingHotkeys map for coldkey swap. Doesn't update storage vesion.
-                // Storage version v7 -> v8
-                .saturating_add(migrations::migrate_populate_staking_hotkeys::migrate_populate_staking_hotkeys::<T>())
-                // Fix total coldkey stake.
-                // Storage version v8 -> v9
-                .saturating_add(migrations::migrate_fix_total_coldkey_stake::migrate_fix_total_coldkey_stake::<T>())
                 // Migrate Delegate Ids on chain
                 .saturating_add(migrations::migrate_chain_identity::migrate_set_hotkey_identities::<T>())
                 // Migrate Commit-Reval 2.0
@@ -83,7 +77,9 @@ mod hooks {
 				// Set the min burn across all subnets to a new minimum
 				.saturating_add(migrations::migrate_set_min_burn::migrate_set_min_burn::<T>())
 				// Set the min difficulty across all subnets to a new minimum
-				.saturating_add(migrations::migrate_set_min_difficulty::migrate_set_min_difficulty::<T>());
+				.saturating_add(migrations::migrate_set_min_difficulty::migrate_set_min_difficulty::<T>())
+                // Remove Stake map entries
+				.saturating_add(migrations::migrate_remove_stake_map::migrate_remove_stake_map::<T>());
             weight
         }
 

pallets/subtensor/src/migrations/migrate_fix_total_coldkey_stake.rs

@@ -4,7 +4,6 @@ use frame_support::IterableStorageMap;
 use frame_support::{traits::Get, weights::Weight};
 use sp_runtime::format;
 use substrate_fixed::types::I96F32;
-use substrate_fixed::types::U64F64;
 
 use super::*;
 
@@ -36,29 +35,30 @@ pub fn migrate_rao<T: Config>() -> Weight {
     DynamicBlock::<T>::set(Pallet::<T>::get_current_block_as_u64());
 
     // Migrate all TAO to root.
-    Stake::<T>::iter().for_each(|(hotkey, coldkey, stake)| {
-        // Increase SubnetTAO on root.
-        SubnetTAO::<T>::mutate(0, |total| {
-            *total = total.saturating_add(stake);
-        });
-        // Increase SubnetAlphaOut on root.
-        SubnetAlphaOut::<T>::mutate(0, |total| {
-            *total = total.saturating_add(stake);
-        });
-        // Set all the stake on root 0 subnet.
-        Alpha::<T>::mutate((hotkey.clone(), coldkey.clone(), 0), |total| {
-            *total = total.saturating_add(U64F64::saturating_from_num(stake))
-        });
-        TotalHotkeyShares::<T>::mutate(hotkey.clone(), 0, |total| {
-            *total = total.saturating_add(U64F64::saturating_from_num(stake))
-        });
-        // Set the total stake on the hotkey
-        TotalHotkeyAlpha::<T>::mutate(hotkey.clone(), 0, |total| {
-            *total = total.saturating_add(stake)
-        });
-        // 6 reads and 6 writes.
-        weight = weight.saturating_add(T::DbWeight::get().reads_writes(6, 6));
-    });
+    // This migration has already run, leaving this only for reference for now, since this is a recent migration
+    // Stake::<T>::iter().for_each(|(hotkey, coldkey, stake)| {
+    //     // Increase SubnetTAO on root.
+    //     SubnetTAO::<T>::mutate(0, |total| {
+    //         *total = total.saturating_add(stake);
+    //     });
+    //     // Increase SubnetAlphaOut on root.
+    //     SubnetAlphaOut::<T>::mutate(0, |total| {
+    //         *total = total.saturating_add(stake);
+    //     });
+    //     // Set all the stake on root 0 subnet.
+    //     Alpha::<T>::mutate((hotkey.clone(), coldkey.clone(), 0), |total| {
+    //         *total = total.saturating_add(U64F64::saturating_from_num(stake))
+    //     });
+    //     TotalHotkeyShares::<T>::mutate(hotkey.clone(), 0, |total| {
+    //         *total = total.saturating_add(U64F64::saturating_from_num(stake))
+    //     });
+    //     // Set the total stake on the hotkey
+    //     TotalHotkeyAlpha::<T>::mutate(hotkey.clone(), 0, |total| {
+    //         *total = total.saturating_add(stake)
+    //     });
+    //     // 6 reads and 6 writes.
+    //     weight = weight.saturating_add(T::DbWeight::get().reads_writes(6, 6));
+    // });
 
     // Convert subnets and give them lock.
     // Set global weight to 18% from the start