Merge branch 'devnet-ready' into auto_stake

Author: JohnReedV

common/src/lib.rs

@@ -154,7 +154,7 @@ pub enum ProxyType {
     Registration,
     Transfer,
     SmallTransfer,
-    RootWeights,
+    RootWeights, // deprecated
     ChildKeys,
     SudoUncheckedSetCode,
     SwapHotkey,

pallets/admin-utils/src/lib.rs

@@ -957,21 +957,6 @@ pub mod pallet {
             Ok(())
         }
 
-        /// The extrinsic sets the subnet limit for the network.
-        /// It is only callable by the root account.
-        /// The extrinsic will call the Subtensor pallet to set the subnet limit.
-        #[pallet::call_index(37)]
-        #[pallet::weight((
-			Weight::from_parts(14_000_000, 0)
-				.saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1)),
-			DispatchClass::Operational,
-			Pays::No
-		))]
-        pub fn sudo_set_subnet_limit(origin: OriginFor<T>, _max_subnets: u16) -> DispatchResult {
-            ensure_root(origin)?;
-            Ok(())
-        }
-
         /// The extrinsic sets the lock reduction interval for the network.
         /// It is only callable by the root account.
         /// The extrinsic will call the Subtensor pallet to set the lock reduction interval.
@@ -1076,26 +1061,6 @@ pub mod pallet {
             Ok(())
         }
 
-        // The extrinsic sets the target stake per interval.
-        // It is only callable by the root account.
-        // The extrinsic will call the Subtensor pallet to set target stake per interval.
-        // #[pallet::call_index(47)]
-        // #[pallet::weight((0, DispatchClass::Operational, Pays::No))]
-        // pub fn sudo_set_target_stakes_per_interval(
-        //     origin: OriginFor<T>,
-        //     target_stakes_per_interval: u64,
-        // ) -> DispatchResult {
-        //     ensure_root(origin)?;
-        //     pallet_subtensor::Pallet::<T>::set_target_stakes_per_interval(
-        //         target_stakes_per_interval,
-        //     );
-        //     log::debug!(
-        //         "TxTargetStakesPerIntervalSet( set_target_stakes_per_interval: {:?} ) ",
-        //         target_stakes_per_interval
-        //     ); (DEPRECATED)
-        //     Ok(())
-        // } (DEPRECATED)
-
         /// The extrinsic enabled/disables commit/reaveal for a given subnet.
         /// It is only callable by the root account or subnet owner.
         /// The extrinsic will call the Subtensor pallet to set the value.
@@ -1157,62 +1122,6 @@ pub mod pallet {
             )
         }
 
-        // DEPRECATED
-        // #[pallet::call_index(52)]
-        // #[pallet::weight((0, DispatchClass::Operational, Pays::No))]
-        // pub fn sudo_set_hotkey_emission_tempo(
-        //     origin: OriginFor<T>,
-        //     emission_tempo: u64,
-        // ) -> DispatchResult {
-        //     ensure_root(origin)?;
-        //     pallet_subtensor::Pallet::<T>::set_hotkey_emission_tempo(emission_tempo);
-        //     log::debug!(
-        //         "HotkeyEmissionTempoSet( emission_tempo: {:?} )",
-        //         emission_tempo
-        //     );
-        //     Ok(())
-        // }
-
-        /// Sets the maximum stake allowed for a specific network.
-        ///
-        /// This function allows the root account to set the maximum stake for a given network.
-        /// It updates the network's maximum stake value and logs the change.
-        ///
-        /// # Arguments
-        ///
-        /// * `origin` - The origin of the call, which must be the root account.
-        /// * `netuid` - The unique identifier of the network.
-        /// * `max_stake` - The new maximum stake value to set.
-        ///
-        /// # Returns
-        ///
-        /// Returns `Ok(())` if the operation is successful, or an error if it fails.
-        ///
-        /// # Example
-        ///
-        ///
-        /// # Notes
-        ///
-        /// - This function can only be called by the root account.
-        /// - The `netuid` should correspond to an existing network.
-        ///
-        /// # TODO
-        ///
-        // - Consider adding a check to ensure the `netuid` corresponds to an existing network.
-        // - Implement a mechanism to gradually adjust the max stake to prevent sudden changes.
-        // #[pallet::weight(<T as Config>::WeightInfo::sudo_set_network_max_stake())]
-        #[pallet::call_index(53)]
-        #[pallet::weight((0, DispatchClass::Operational, Pays::No))]
-        pub fn sudo_set_network_max_stake(
-            origin: OriginFor<T>,
-            _netuid: NetUid,
-            _max_stake: u64,
-        ) -> DispatchResult {
-            // Ensure the call is made by the root account
-            ensure_root(origin)?;
-            Ok(())
-        }
-
         /// Sets the duration of the coldkey swap schedule.
         ///
         /// This extrinsic allows the root account to set the duration for the coldkey swap schedule.

pallets/commitments/src/lib.rs

@@ -15,10 +15,13 @@ pub use types::*;
 pub use weights::WeightInfo;
 
 use ark_serialize::CanonicalDeserialize;
-use frame_support::{BoundedVec, traits::Currency};
+use frame_support::{
+    BoundedVec,
+    traits::{Currency, Get},
+};
 use scale_info::prelude::collections::BTreeSet;
 use sp_runtime::SaturatedConversion;
-use sp_runtime::{Saturating, traits::Zero};
+use sp_runtime::{Saturating, Weight, traits::Zero};
 use sp_std::{boxed::Box, vec::Vec};
 use subtensor_runtime_common::NetUid;
 use tle::{
@@ -325,21 +328,6 @@ pub mod pallet {
             Ok(())
         }
 
-        /// *DEPRECATED* Sudo-set the commitment rate limit
-        #[pallet::call_index(1)]
-        #[pallet::weight((
-            Weight::from_parts(3_596_000, 0)
-        	.saturating_add(T::DbWeight::get().reads(0_u64))
-        	.saturating_add(T::DbWeight::get().writes(1_u64)),
-        	DispatchClass::Operational,
-        	Pays::No
-        ))]
-        pub fn set_rate_limit(origin: OriginFor<T>, _rate_limit_blocks: u32) -> DispatchResult {
-            ensure_root(origin)?;
-            // RateLimit::<T>::set(rate_limit_blocks.into());
-            Ok(())
-        }
-
         /// Sudo-set MaxSpace
         #[pallet::call_index(2)]
         #[pallet::weight((
@@ -359,10 +347,13 @@ pub mod pallet {
     #[pallet::hooks]
     impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
         fn on_initialize(n: BlockNumberFor<T>) -> Weight {
-            if let Err(e) = Self::reveal_timelocked_commitments() {
-                log::debug!("Failed to unveil matured commitments on block {n:?}: {e:?}");
+            match Self::reveal_timelocked_commitments() {
+                Ok(w) => w,
+                Err(e) => {
+                    log::debug!("Failed to unveil matured commitments on block {n:?}: {e:?}");
+                    Weight::from_parts(0, 0)
+                }
             }
-            Weight::from_parts(0, 0)
         }
     }
 }
@@ -399,13 +390,22 @@ pub enum CallType {
 use frame_support::{dispatch::DispatchResult, pallet_prelude::TypeInfo};
 
 impl<T: Config> Pallet<T> {
-    pub fn reveal_timelocked_commitments() -> DispatchResult {
+    pub fn reveal_timelocked_commitments() -> Result<Weight, sp_runtime::DispatchError> {
+        let mut total_weight = Weight::from_parts(0, 0);
+
         let index = TimelockedIndex::<T>::get();
+        total_weight = total_weight.saturating_add(T::DbWeight::get().reads(1));
+
         for (netuid, who) in index.clone() {
-            let Some(mut registration) = <CommitmentOf<T>>::get(netuid, &who) else {
+            let maybe_registration = <CommitmentOf<T>>::get(netuid, &who);
+            total_weight = total_weight.saturating_add(T::DbWeight::get().reads(1));
+
+            let Some(mut registration) = maybe_registration else {
                 TimelockedIndex::<T>::mutate(|idx| {
                     idx.remove(&(netuid, who.clone()));
                 });
+
+                total_weight = total_weight.saturating_add(T::DbWeight::get().reads_writes(1, 1));
                 continue;
             };
 
@@ -419,6 +419,7 @@ impl<T: Config> Pallet<T> {
                         encrypted,
                         reveal_round,
                     } => {
+                        total_weight = total_weight.saturating_add(T::DbWeight::get().reads(1));
                         let pulse = match pallet_drand::Pulses::<T>::get(reveal_round) {
                             Some(p) => p,
                             None => {
@@ -486,6 +487,7 @@ impl<T: Config> Pallet<T> {
             if !revealed_fields.is_empty() {
                 let mut existing_reveals =
                     RevealedCommitments::<T>::get(netuid, &who).unwrap_or_default();
+                total_weight = total_weight.saturating_add(T::DbWeight::get().reads(1));
 
                 let current_block = <frame_system::Pallet<T>>::block_number();
                 let block_u64 = current_block.saturated_into::<u64>();
@@ -507,6 +509,7 @@ impl<T: Config> Pallet<T> {
                 }
 
                 RevealedCommitments::<T>::insert(netuid, &who, existing_reveals);
+                total_weight = total_weight.saturating_add(T::DbWeight::get().writes(1));
             }
 
             registration.info.fields = BoundedVec::try_from(remain_fields)
@@ -515,12 +518,19 @@ impl<T: Config> Pallet<T> {
             match registration.info.fields.is_empty() {
                 true => {
                     <CommitmentOf<T>>::remove(netuid, &who);
+                    total_weight = total_weight.saturating_add(T::DbWeight::get().writes(1));
+
                     TimelockedIndex::<T>::mutate(|idx| {
                         idx.remove(&(netuid, who.clone()));
                     });
+
+                    total_weight =
+                        total_weight.saturating_add(T::DbWeight::get().reads_writes(1, 1));
                 }
                 false => {
                     <CommitmentOf<T>>::insert(netuid, &who, &registration);
+                    total_weight = total_weight.saturating_add(T::DbWeight::get().writes(1));
+
                     let has_timelock = registration
                         .info
                         .fields
@@ -530,11 +540,14 @@ impl<T: Config> Pallet<T> {
                         TimelockedIndex::<T>::mutate(|idx| {
                             idx.remove(&(netuid, who.clone()));
                         });
+
+                        total_weight =
+                            total_weight.saturating_add(T::DbWeight::get().reads_writes(1, 1));
                     }
                 }
             }
         }
 
-        Ok(())
+        Ok(total_weight)
     }
 }

pallets/subtensor/src/benchmarks.rs

@@ -98,33 +98,6 @@ mod pallet_benchmarks {
         );
     }
 
-    #[benchmark]
-    fn become_delegate() {
-        let netuid = NetUid::from(1);
-        let tempo: u16 = 1;
-
-        Subtensor::<T>::init_new_network(netuid, tempo);
-        SubtokenEnabled::<T>::insert(netuid, true);
-        Subtensor::<T>::set_burn(netuid, 1.into());
-        Subtensor::<T>::set_max_allowed_uids(netuid, 4096);
-        Subtensor::<T>::set_network_registration_allowed(netuid, true);
-
-        let seed: u32 = 1;
-        let coldkey: T::AccountId = account("Test", 0, seed);
-        let hotkey: T::AccountId = account("Alice", 0, seed);
-        let amount_to_be_staked: u64 = 1_000_000_000;
-
-        Subtensor::<T>::add_balance_to_coldkey_account(&coldkey, amount_to_be_staked);
-        assert_ok!(Subtensor::<T>::do_burned_registration(
-            RawOrigin::Signed(coldkey.clone()).into(),
-            netuid,
-            hotkey.clone()
-        ));
-
-        #[extrinsic_call]
-        _(RawOrigin::Signed(coldkey.clone()), hotkey.clone());
-    }
-
     #[benchmark]
     fn add_stake() {
         let netuid = NetUid::from(1);
@@ -1280,27 +1253,6 @@ mod pallet_benchmarks {
         );
     }
 
-    #[benchmark]
-    fn set_tao_weights() {
-        let netuid = NetUid::from(1);
-        let hotkey: T::AccountId = account("A", 0, 6);
-        let dests = vec![0u16];
-        let weights = vec![0u16];
-        let version: u64 = 1;
-
-        Subtensor::<T>::init_new_network(netuid, 1);
-
-        #[extrinsic_call]
-        _(
-            RawOrigin::None,
-            netuid,
-            hotkey.clone(),
-            dests.clone(),
-            weights.clone(),
-            version,
-        );
-    }
-
     #[benchmark]
     fn swap_hotkey() {
         let coldkey: T::AccountId = whitelisted_caller();