Use StakeThreshold instead of WeightsMinStake and ChildkeyMinStake

Author: gztensor

pallets/admin-utils/src/lib.rs

@@ -885,9 +885,9 @@ pub mod pallet {
         /// The extrinsic will call the Subtensor pallet to set the weights min stake.
         #[pallet::call_index(42)]
         #[pallet::weight((0, DispatchClass::Operational, Pays::No))]
-        pub fn sudo_set_weights_min_stake(origin: OriginFor<T>, min_stake: u64) -> DispatchResult {
+        pub fn sudo_set_stake_threshold(origin: OriginFor<T>, min_stake: u64) -> DispatchResult {
             ensure_root(origin)?;
-            pallet_subtensor::Pallet::<T>::set_weights_min_stake(min_stake);
+            pallet_subtensor::Pallet::<T>::set_stake_threshold(min_stake);
             Ok(())
         }
 

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

@@ -682,23 +682,23 @@ fn test_sudo_set_max_allowed_validators() {
 }
 
 #[test]
-fn test_sudo_set_weights_min_stake() {
+fn test_sudo_set_stake_threshold() {
     new_test_ext().execute_with(|| {
         let to_be_set: u64 = 10;
-        let init_value: u64 = SubtensorModule::get_weights_min_stake();
+        let init_value: u64 = SubtensorModule::get_stake_threshold();
         assert_eq!(
-            AdminUtils::sudo_set_weights_min_stake(
+            AdminUtils::sudo_set_stake_threshold(
                 <<Test as Config>::RuntimeOrigin>::signed(U256::from(1)),
                 to_be_set
             ),
             Err(DispatchError::BadOrigin)
         );
-        assert_eq!(SubtensorModule::get_weights_min_stake(), init_value);
-        assert_ok!(AdminUtils::sudo_set_weights_min_stake(
+        assert_eq!(SubtensorModule::get_stake_threshold(), init_value);
+        assert_ok!(AdminUtils::sudo_set_stake_threshold(
             <<Test as Config>::RuntimeOrigin>::root(),
             to_be_set
         ));
-        assert_eq!(SubtensorModule::get_weights_min_stake(), to_be_set);
+        assert_eq!(SubtensorModule::get_stake_threshold(), to_be_set);
     });
 }
 

pallets/subtensor/src/coinbase/root.rs

@@ -783,7 +783,7 @@ impl<T: Config> Pallet<T> {
 
         // Check to see if the hotkey has enough stake to set weights.
         ensure!(
-            Self::get_total_stake_for_hotkey(&hotkey) >= Self::get_weights_min_stake(),
+            Self::get_total_stake_for_hotkey(&hotkey) >= Self::get_stake_threshold(),
             Error::<T>::NotEnoughStakeToSetWeights
         );
 

pallets/subtensor/src/lib.rs

@@ -578,7 +578,7 @@ pub mod pallet {
     }
     #[pallet::type_value]
     /// Default minimum stake for weights.
-    pub fn DefaultWeightsMinStake<T: Config>() -> u64 {
+    pub fn DefaultStakeThreshold<T: Config>() -> u64 {
         0
     }
     #[pallet::type_value]
@@ -1296,10 +1296,7 @@ pub mod pallet {
         StorageMap<_, Identity, T::AccountId, u64, ValueQuery, DefaultLastTxBlock<T>>;
     #[pallet::storage]
     /// ITEM( weights_min_stake )
-    pub type WeightsMinStake<T> = StorageValue<_, u64, ValueQuery, DefaultWeightsMinStake<T>>;
-    #[pallet::storage]
-    /// ITEM( childkeys_min_stake )
-    pub type ChildkeysMinStake<T> = StorageValue<_, u64, ValueQuery, DefaultChildkeysMinStake<T>>;
+    pub type StakeThreshold<T> = StorageValue<_, u64, ValueQuery, DefaultStakeThreshold<T>>;
     #[pallet::storage]
     /// --- MAP (netuid, who) --> VecDeque<(hash, commit_block, first_reveal_block, last_reveal_block)> | Stores a queue of commits for an account on a given netuid.
     pub type WeightCommits<T: Config> = StorageDoubleMap<
@@ -1356,7 +1353,7 @@ pub mod pallet {
         /// Is the caller allowed to set weights
         pub fn check_weights_min_stake(hotkey: &T::AccountId, netuid: u16) -> bool {
             // Blacklist weights transactions for low stake peers.
-            Self::get_stake_for_hotkey_on_subnet(hotkey, netuid) >= Self::get_weights_min_stake()
+            Self::get_stake_for_hotkey_on_subnet(hotkey, netuid) >= Self::get_stake_threshold()
         }
 
         /// Helper function to check if register is allowed

pallets/subtensor/src/macros/events.rs

@@ -102,7 +102,7 @@ mod events {
         /// setting the RAO recycled for registration.
         RAORecycledForRegistrationSet(u16, u64),
         /// min stake is set for validators to set weights.
-        WeightsMinStake(u64),
+        StakeThresholdSet(u64),
         /// setting the minimum required stake amount for senate registration.
         SenateRequiredStakePercentSet(u64),
         /// setting the adjustment alpha on a subnet.

pallets/subtensor/src/migrations/migrate_stake_threshold.rs

@@ -0,0 +1,45 @@
+use super::*;
+use crate::HasMigrationRun;
+use frame_support::pallet_prelude::ValueQuery;
+use frame_support::storage_alias;
+use frame_support::{traits::Get, weights::Weight};
+use scale_info::prelude::string::String;
+
+/// Module containing deprecated storage format for WeightsMinStake
+pub mod deprecated_weights_min_stake {
+    use super::*;
+
+    #[storage_alias]
+    pub(super) type WeightsMinStake<T: Config> = StorageValue<Pallet<T>, u64, ValueQuery>;
+}
+
+pub fn migrate_stake_threshold<T: Config>() -> Weight {
+    let migration_name = b"migrate_stake_threshold".to_vec();
+    let mut weight = T::DbWeight::get().reads(1);
+
+    if HasMigrationRun::<T>::get(&migration_name) {
+        log::info!(
+            "Migration '{:?}' has already run. Skipping.",
+            migration_name
+        );
+        return weight;
+    }
+
+    log::info!(
+        "Running migration '{}'",
+        String::from_utf8_lossy(&migration_name)
+    );
+
+    let min_stake = deprecated_weights_min_stake::WeightsMinStake::<T>::get();
+    StakeThreshold::<T>::set(min_stake);
+    deprecated_weights_min_stake::WeightsMinStake::<T>::kill();
+
+    weight = weight.saturating_add(T::DbWeight::get().reads_writes(1, 1));
+
+    log::info!(
+        "Migration '{:?}' completed successfully.",
+        String::from_utf8_lossy(&migration_name)
+    );
+
+    weight
+}

pallets/subtensor/src/migrations/mod.rs

@@ -9,6 +9,7 @@ pub mod migrate_fix_total_coldkey_stake;
 pub mod migrate_init_total_issuance;
 pub mod migrate_populate_owned_hotkeys;
 pub mod migrate_populate_staking_hotkeys;
+pub mod migrate_stake_threshold;
 pub mod migrate_to_v1_separate_emission;
 pub mod migrate_to_v2_fixed_total_stake;
 pub mod migrate_total_issuance;

pallets/subtensor/src/staking/remove_stake.rs

@@ -91,7 +91,7 @@ impl<T: Config> Pallet<T> {
         Self::clear_small_nomination_if_required(&hotkey, &coldkey, new_stake);
 
         // Check if stake lowered below MinStake and remove Pending children if it did
-        if Self::get_total_stake_for_hotkey(&hotkey) < ChildkeysMinStake::<T>::get() {
+        if Self::get_total_stake_for_hotkey(&hotkey) < StakeThreshold::<T>::get() {
             Self::get_all_subnet_netuids().iter().for_each(|netuid| {
                 PendingChildKeys::<T>::remove(netuid, &hotkey);
             })

pallets/subtensor/src/staking/set_children.rs

@@ -113,7 +113,7 @@ impl<T: Config> Pallet<T> {
         // (checking with check_weights_min_stake wouldn't work because it considers
         // grandparent stake in this case)
         ensure!(
-            Self::get_total_stake_for_hotkey(&hotkey) >= ChildkeysMinStake::<T>::get(),
+            Self::get_total_stake_for_hotkey(&hotkey) >= StakeThreshold::<T>::get(),
             Error::<T>::NotEnoughStakeToSetChildkeys
         );
 

pallets/subtensor/src/tests/children.rs

@@ -3169,12 +3169,12 @@ fn test_childkey_set_weights_single_parent() {
         ));
 
         // Set the min stake very high
-        SubtensorModule::set_weights_min_stake(stake_to_give_child * 5);
+        SubtensorModule::set_stake_threshold(stake_to_give_child * 5);
 
         // Check the child has less stake than required
         assert!(
             SubtensorModule::get_stake_for_hotkey_on_subnet(&child, netuid)
-                < SubtensorModule::get_weights_min_stake()
+                < SubtensorModule::get_stake_threshold()
         );
 
         // Check the child cannot set weights
@@ -3192,12 +3192,12 @@ fn test_childkey_set_weights_single_parent() {
         assert!(!SubtensorModule::check_weights_min_stake(&child, netuid));
 
         // Set a minimum stake to set weights
-        SubtensorModule::set_weights_min_stake(stake_to_give_child - 5);
+        SubtensorModule::set_stake_threshold(stake_to_give_child - 5);
 
         // Check if the stake for the child is above
         assert!(
             SubtensorModule::get_stake_for_hotkey_on_subnet(&child, netuid)
-                >= SubtensorModule::get_weights_min_stake()
+                >= SubtensorModule::get_stake_threshold()
         );
 
         // Check the child can set weights
@@ -3252,12 +3252,12 @@ fn test_set_weights_no_parent() {
         let version_key = SubtensorModule::get_weights_version_key(netuid);
 
         // Set the min stake very high
-        SubtensorModule::set_weights_min_stake(stake_to_give_child * 5);
+        SubtensorModule::set_stake_threshold(stake_to_give_child * 5);
 
         // Check the key has less stake than required
         assert!(
             SubtensorModule::get_stake_for_hotkey_on_subnet(&hotkey, netuid)
-                < SubtensorModule::get_weights_min_stake()
+                < SubtensorModule::get_stake_threshold()
         );
 
         // Check the hotkey cannot set weights
@@ -3275,12 +3275,12 @@ fn test_set_weights_no_parent() {
         assert!(!SubtensorModule::check_weights_min_stake(&hotkey, netuid));
 
         // Set a minimum stake to set weights
-        SubtensorModule::set_weights_min_stake(stake_to_give_child - 5);
+        SubtensorModule::set_stake_threshold(stake_to_give_child - 5);
 
         // Check if the stake for the hotkey is above
         assert!(
             SubtensorModule::get_stake_for_hotkey_on_subnet(&hotkey, netuid)
-                >= SubtensorModule::get_weights_min_stake()
+                >= SubtensorModule::get_stake_threshold()
         );
 
         // Check the hotkey can set weights
@@ -3643,6 +3643,7 @@ fn test_do_set_child_below_min_stake() {
         // Add network and register hotkey
         add_network(netuid, 13, 0);
         register_ok_neuron(netuid, hotkey, coldkey, 0);
+        StakeThreshold::<Test>::set(1_000_000_000_000);
 
         // Attempt to set child
         assert_err!(
@@ -3671,10 +3672,13 @@ fn test_do_remove_stake_clears_pending_childkeys() {
         add_network(netuid, 13, 0);
         register_ok_neuron(netuid, hotkey, coldkey, 0);
 
+        // Set non-default value for childkey stake threshold
+        StakeThreshold::<Test>::set(1_000_000_000_000);
+
         SubtensorModule::increase_stake_on_coldkey_hotkey_account(
             &coldkey,
             &hotkey,
-            ChildkeysMinStake::<Test>::get(),
+            StakeThreshold::<Test>::get(),
         );
 
         // Attempt to set child
@@ -3720,7 +3724,7 @@ fn test_do_set_child_cooldown_period() {
 
         // Set minimum stake for setting children
         let parent_total_stake_original = TotalHotkeyStake::<Test>::get(parent);
-        TotalHotkeyStake::<Test>::insert(parent, ChildkeysMinStake::<Test>::get());
+        TotalHotkeyStake::<Test>::insert(parent, StakeThreshold::<Test>::get());
 
         // Schedule parent-child relationship
         assert_ok!(SubtensorModule::do_schedule_children(