Merge branch 'devnet-ready' into feat/ema-slowdown-hyperparam

Author: gztensor

pallets/admin-utils/src/lib.rs

@@ -25,9 +25,13 @@ pub mod pallet {
     use super::*;
     use frame_support::pallet_prelude::*;
     use frame_support::traits::tokens::Balance;
-    use frame_support::{dispatch::DispatchResult, pallet_prelude::StorageMap};
+    use frame_support::{
+        dispatch::{DispatchResult, RawOrigin},
+        pallet_prelude::StorageMap,
+    };
     use frame_system::pallet_prelude::*;
     use pallet_evm_chain_id::{self, ChainId};
+    use pallet_subtensor::utils::rate_limiting::TransactionType;
     use sp_runtime::BoundedVec;
     use substrate_fixed::types::I96F32;
 
@@ -249,12 +253,35 @@ pub mod pallet {
             netuid: u16,
             weights_version_key: u64,
         ) -> DispatchResult {
-            pallet_subtensor::Pallet::<T>::ensure_subnet_owner_or_root(origin, netuid)?;
+            pallet_subtensor::Pallet::<T>::ensure_subnet_owner_or_root(origin.clone(), netuid)?;
 
             ensure!(
                 pallet_subtensor::Pallet::<T>::if_subnet_exist(netuid),
                 Error::<T>::SubnetDoesNotExist
             );
+
+            if let Ok(RawOrigin::Signed(who)) = origin.into() {
+                // SN Owner
+                // Ensure the origin passes the rate limit.
+                ensure!(
+                    pallet_subtensor::Pallet::<T>::passes_rate_limit_on_subnet(
+                        &TransactionType::SetWeightsVersionKey,
+                        &who,
+                        netuid,
+                    ),
+                    pallet_subtensor::Error::<T>::TxRateLimitExceeded
+                );
+
+                // Set last transaction block
+                let current_block = pallet_subtensor::Pallet::<T>::get_current_block_as_u64();
+                pallet_subtensor::Pallet::<T>::set_last_transaction_block_on_subnet(
+                    &who,
+                    netuid,
+                    &TransactionType::SetWeightsVersionKey,
+                    current_block,
+                );
+            }
+
             pallet_subtensor::Pallet::<T>::set_weights_version_key(netuid, weights_version_key);
             log::debug!(
                 "WeightsVersionKeySet( netuid: {:?} weights_version_key: {:?} ) ",

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

@@ -5,7 +5,7 @@ use frame_support::{
     traits::Hooks,
 };
 use frame_system::Config;
-use pallet_subtensor::Error as SubtensorError;
+use pallet_subtensor::{Error as SubtensorError, SubnetOwner, Tempo, WeightsVersionKeyRateLimit};
 // use pallet_subtensor::{migrations, Event};
 use pallet_subtensor::Event;
 use sp_consensus_grandpa::AuthorityId as GrandpaId;
@@ -162,6 +162,107 @@ fn test_sudo_set_weights_version_key() {
     });
 }
 
+#[test]
+fn test_sudo_set_weights_version_key_rate_limit() {
+    new_test_ext().execute_with(|| {
+        let netuid: u16 = 1;
+        let to_be_set: u64 = 10;
+
+        let sn_owner = U256::from(1);
+        add_network(netuid, 10);
+        // Set the Subnet Owner
+        SubnetOwner::<Test>::insert(netuid, sn_owner);
+
+        let rate_limit = WeightsVersionKeyRateLimit::<Test>::get();
+        let tempo: u16 = Tempo::<Test>::get(netuid);
+
+        let rate_limit_period = rate_limit * (tempo as u64);
+
+        assert_ok!(AdminUtils::sudo_set_weights_version_key(
+            <<Test as Config>::RuntimeOrigin>::signed(sn_owner),
+            netuid,
+            to_be_set
+        ));
+        assert_eq!(SubtensorModule::get_weights_version_key(netuid), to_be_set);
+
+        // Try to set again with
+        // Assert rate limit not passed
+        assert!(!SubtensorModule::passes_rate_limit_on_subnet(
+            &pallet_subtensor::utils::rate_limiting::TransactionType::SetWeightsVersionKey,
+            &sn_owner,
+            netuid
+        ));
+
+        // Try transaction
+        assert_noop!(
+            AdminUtils::sudo_set_weights_version_key(
+                <<Test as Config>::RuntimeOrigin>::signed(sn_owner),
+                netuid,
+                to_be_set + 1
+            ),
+            pallet_subtensor::Error::<Test>::TxRateLimitExceeded
+        );
+
+        // Wait for rate limit to pass
+        run_to_block(rate_limit_period + 2);
+        assert!(SubtensorModule::passes_rate_limit_on_subnet(
+            &pallet_subtensor::utils::rate_limiting::TransactionType::SetWeightsVersionKey,
+            &sn_owner,
+            netuid
+        ));
+
+        // Try transaction
+        assert_ok!(AdminUtils::sudo_set_weights_version_key(
+            <<Test as Config>::RuntimeOrigin>::signed(sn_owner),
+            netuid,
+            to_be_set + 1
+        ));
+        assert_eq!(
+            SubtensorModule::get_weights_version_key(netuid),
+            to_be_set + 1
+        );
+    });
+}
+
+#[test]
+fn test_sudo_set_weights_version_key_rate_limit_root() {
+    // root should not be effected by rate limit
+    new_test_ext().execute_with(|| {
+        let netuid: u16 = 1;
+        let to_be_set: u64 = 10;
+
+        let sn_owner = U256::from(1);
+        add_network(netuid, 10);
+        // Set the Subnet Owner
+        SubnetOwner::<Test>::insert(netuid, sn_owner);
+
+        let rate_limit = WeightsVersionKeyRateLimit::<Test>::get();
+        let tempo: u16 = Tempo::<Test>::get(netuid);
+
+        let rate_limit_period = rate_limit * (tempo as u64);
+        // Verify the rate limit is more than 0 blocks
+        assert!(rate_limit_period > 0);
+
+        assert_ok!(AdminUtils::sudo_set_weights_version_key(
+            <<Test as Config>::RuntimeOrigin>::root(),
+            netuid,
+            to_be_set
+        ));
+        assert_eq!(SubtensorModule::get_weights_version_key(netuid), to_be_set);
+
+        // Try transaction
+        assert_ok!(AdminUtils::sudo_set_weights_version_key(
+            <<Test as Config>::RuntimeOrigin>::signed(sn_owner),
+            netuid,
+            to_be_set + 1
+        ));
+        assert_eq!(
+            SubtensorModule::get_weights_version_key(netuid),
+            to_be_set + 1
+        );
+    });
+}
+
 #[test]
 fn test_sudo_set_weights_set_rate_limit() {
     new_test_ext().execute_with(|| {

pallets/subtensor/src/lib.rs

@@ -514,6 +514,12 @@ pub mod pallet {
         T::InitialNetworkRateLimit::get()
     }
     #[pallet::type_value]
+    /// Default value for weights version key rate limit.
+    /// In units of tempos.
+    pub fn DefaultWeightsVersionKeyRateLimit<T: Config>() -> u64 {
+        5 // 5 tempos
+    }
+    #[pallet::type_value]
     /// Default value for pending emission.
     pub fn DefaultPendingEmission<T: Config>() -> u64 {
         0
@@ -1082,6 +1088,10 @@ pub mod pallet {
     pub type NetworkRateLimit<T> = StorageValue<_, u64, ValueQuery, DefaultNetworkRateLimit<T>>;
     #[pallet::storage] // --- ITEM( nominator_min_required_stake )
     pub type NominatorMinRequiredStake<T> = StorageValue<_, u64, ValueQuery, DefaultZeroU64<T>>;
+    #[pallet::storage]
+    /// ITEM( weights_version_key_rate_limit ) --- Rate limit in tempos.
+    pub type WeightsVersionKeyRateLimit<T> =
+        StorageValue<_, u64, ValueQuery, DefaultWeightsVersionKeyRateLimit<T>>;
 
     /// ============================
     /// ==== Subnet Locks =====

pallets/subtensor/src/staking/add_stake.rs

@@ -1,5 +1,5 @@
 use super::*;
-use sp_core::Get;
+use substrate_fixed::types::I96F32;
 
 impl<T: Config> Pallet<T> {
     /// ---- The implementation for the extrinsic add_stake: Adds stake to a hotkey account.
@@ -58,13 +58,19 @@ impl<T: Config> Pallet<T> {
         )?;
 
         // 3. Ensure the remove operation from the coldkey is a success.
-        let tao_staked: u64 =
-            Self::remove_balance_from_coldkey_account(&coldkey, stake_to_be_added)?;
+        let tao_staked: I96F32 =
+            Self::remove_balance_from_coldkey_account(&coldkey, stake_to_be_added)?.into();
 
         // 4. Swap the stake into alpha on the subnet and increase counters.
         // Emit the staking event.
         let fee = DefaultStakingFee::<T>::get();
-        Self::stake_into_subnet(&hotkey, &coldkey, netuid, tao_staked, fee);
+        Self::stake_into_subnet(
+            &hotkey,
+            &coldkey,
+            netuid,
+            tao_staked.saturating_to_num::<u64>(),
+            fee,
+        );
 
         // Ok and return.
         Ok(())
@@ -148,12 +154,19 @@ impl<T: Config> Pallet<T> {
         }
 
         // 5. Ensure the remove operation from the coldkey is a success.
-        let tao_staked: u64 = Self::remove_balance_from_coldkey_account(&coldkey, possible_stake)?;
+        let tao_staked: I96F32 =
+            Self::remove_balance_from_coldkey_account(&coldkey, possible_stake)?.into();
 
         // 6. Swap the stake into alpha on the subnet and increase counters.
         // Emit the staking event.
         let fee = DefaultStakingFee::<T>::get();
-        Self::stake_into_subnet(&hotkey, &coldkey, netuid, tao_staked, fee);
+        Self::stake_into_subnet(
+            &hotkey,
+            &coldkey,
+            netuid,
+            tao_staked.saturating_to_num::<u64>(),
+            fee,
+        );
 
         // Ok and return.
         Ok(())

pallets/subtensor/src/staking/move_stake.rs

@@ -1,7 +1,7 @@
 use super::*;
 use safe_math::*;
 use sp_core::Get;
-use substrate_fixed::types::U64F64;
+use substrate_fixed::types::{I96F32, U64F64};
 
 impl<T: Config> Pallet<T> {
     /// Moves stake from one hotkey to another across subnets.
@@ -338,7 +338,13 @@ impl<T: Config> Pallet<T> {
         };
 
         // Unstake from the origin subnet, returning TAO (or a 1:1 equivalent).
-        let fee = DefaultStakingFee::<T>::get().safe_div(2);
+        let fee = Self::calculate_staking_fee(
+            origin_netuid,
+            origin_hotkey,
+            I96F32::saturating_from_num(alpha_amount),
+        )
+        .safe_div(2);
+
         let tao_unstaked = Self::unstake_from_subnet(
             origin_hotkey,
             origin_coldkey,

pallets/subtensor/src/staking/remove_stake.rs

@@ -1,5 +1,5 @@
 use super::*;
-use sp_core::Get;
+use substrate_fixed::types::I96F32;
 
 impl<T: Config> Pallet<T> {
     /// ---- The implementation for the extrinsic remove_stake: Removes stake from a hotkey account and adds it onto a coldkey.
@@ -58,7 +58,11 @@ impl<T: Config> Pallet<T> {
         )?;
 
         // 3. Swap the alpba to tao and update counters for this subnet.
-        let fee = DefaultStakingFee::<T>::get();
+        let fee = Self::calculate_staking_fee(
+            netuid,
+            &hotkey,
+            I96F32::saturating_from_num(alpha_unstaked),
+        );
         let tao_unstaked: u64 =
             Self::unstake_from_subnet(&hotkey, &coldkey, netuid, alpha_unstaked, fee);
 
@@ -109,8 +113,6 @@ impl<T: Config> Pallet<T> {
         origin: T::RuntimeOrigin,
         hotkey: T::AccountId,
     ) -> dispatch::DispatchResult {
-        let fee = DefaultStakingFee::<T>::get();
-
         // 1. We check the transaction is signed by the caller and retrieve the T::AccountId coldkey information.
         let coldkey = ensure_signed(origin)?;
         log::info!("do_unstake_all( origin:{:?} hotkey:{:?} )", coldkey, hotkey);
@@ -126,20 +128,26 @@ impl<T: Config> Pallet<T> {
         log::debug!("All subnet netuids: {:?}", netuids);
 
         // 4. Iterate through all subnets and remove stake.
-        for netuid in netuids.iter() {
+        for netuid in netuids.into_iter() {
             // Ensure that the hotkey has enough stake to withdraw.
             let alpha_unstaked =
-                Self::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, *netuid);
+                Self::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid);
+            let fee = Self::calculate_staking_fee(
+                netuid,
+                &hotkey,
+                I96F32::saturating_from_num(alpha_unstaked),
+            );
+
             if alpha_unstaked > 0 {
                 // Swap the alpha to tao and update counters for this subnet.
                 let tao_unstaked: u64 =
-                    Self::unstake_from_subnet(&hotkey, &coldkey, *netuid, alpha_unstaked, fee);
+                    Self::unstake_from_subnet(&hotkey, &coldkey, netuid, alpha_unstaked, fee);
 
                 // Add the balance to the coldkey. If the above fails we will not credit this coldkey.
                 Self::add_balance_to_coldkey_account(&coldkey, tao_unstaked);
 
                 // If the stake is below the minimum, we clear the nomination from storage.
-                Self::clear_small_nomination_if_required(&hotkey, &coldkey, *netuid);
+                Self::clear_small_nomination_if_required(&hotkey, &coldkey, netuid);
             }
         }
 
@@ -177,8 +185,6 @@ impl<T: Config> Pallet<T> {
         origin: T::RuntimeOrigin,
         hotkey: T::AccountId,
     ) -> dispatch::DispatchResult {
-        let fee = DefaultStakingFee::<T>::get();
-
         // 1. We check the transaction is signed by the caller and retrieve the T::AccountId coldkey information.
         let coldkey = ensure_signed(origin)?;
         log::info!("do_unstake_all( origin:{:?} hotkey:{:?} )", coldkey, hotkey);
@@ -195,22 +201,28 @@ impl<T: Config> Pallet<T> {
 
         // 4. Iterate through all subnets and remove stake.
         let mut total_tao_unstaked: u64 = 0;
-        for netuid in netuids.iter() {
+        for netuid in netuids.into_iter() {
             // If not Root network.
-            if *netuid != Self::get_root_netuid() {
+            if netuid != Self::get_root_netuid() {
                 // Ensure that the hotkey has enough stake to withdraw.
                 let alpha_unstaked =
-                    Self::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, *netuid);
+                    Self::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid);
+                let fee = Self::calculate_staking_fee(
+                    netuid,
+                    &hotkey,
+                    I96F32::saturating_from_num(alpha_unstaked),
+                );
+
                 if alpha_unstaked > 0 {
                     // Swap the alpha to tao and update counters for this subnet.
-                    let tao_unstaked: u64 =
-                        Self::unstake_from_subnet(&hotkey, &coldkey, *netuid, alpha_unstaked, fee);
+                    let tao_unstaked =
+                        Self::unstake_from_subnet(&hotkey, &coldkey, netuid, alpha_unstaked, fee);
 
                     // Increment total
                     total_tao_unstaked = total_tao_unstaked.saturating_add(tao_unstaked);
 
                     // If the stake is below the minimum, we clear the nomination from storage.
-                    Self::clear_small_nomination_if_required(&hotkey, &coldkey, *netuid);
+                    Self::clear_small_nomination_if_required(&hotkey, &coldkey, netuid);
                 }
             }
         }
@@ -302,8 +314,12 @@ impl<T: Config> Pallet<T> {
         )?;
 
         // 4. Swap the alpha to tao and update counters for this subnet.
-        let fee = DefaultStakingFee::<T>::get();
-        let tao_unstaked: u64 =
+        let fee = Self::calculate_staking_fee(
+            netuid,
+            &hotkey,
+            I96F32::saturating_from_num(alpha_unstaked),
+        );
+        let tao_unstaked =
             Self::unstake_from_subnet(&hotkey, &coldkey, netuid, possible_alpha, fee);
 
         // 5. We add the balance to the coldkey. If the above fails we will not credit this coldkey.