merge childkeys

Author: const

pallets/admin-utils/src/benchmarking.rs

@@ -248,5 +248,13 @@ mod benchmarks {
         _(RawOrigin::Root, 1u64/*emission_tempo*/)/*set_hotkey_emission_tempo*/;
     }
 
+    #[benchmark]
+    fn sudo_set_network_max_stake() {
+        T::Subtensor::init_new_network(1u16 /*netuid*/, 1u16 /*tempo*/);
+
+        #[extrinsic_call]
+        _(RawOrigin::Root, 1u16/*netuid*/, 1_000_000_000_000_000u64/*max_stake*/)/*sudo_set_network_max_stake*/;
+    }
+
     //impl_benchmark_test_suite!(AdminUtils, crate::mock::new_test_ext(), crate::mock::Test);
 }

pallets/admin-utils/src/lib.rs

@@ -1050,8 +1050,9 @@ pub mod pallet {
         ///
         /// # Errors
         /// * `DispatchError::BadOrigin` - If the origin is not the root account.
+        // #[pallet::weight(T::WeightInfo::sudo_set_hotkey_emission_tempo())]
         #[pallet::call_index(52)]
-        #[pallet::weight(T::WeightInfo::sudo_set_hotkey_emission_tempo())]
+        #[pallet::weight((0, DispatchClass::Operational, Pays::No))]
         pub fn sudo_set_hotkey_emission_tempo(
             origin: OriginFor<T>,
             emission_tempo: u64,
@@ -1064,6 +1065,57 @@ pub mod pallet {
             );
             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::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: u16,
+            max_stake: u64,
+        ) -> DispatchResult {
+            // Ensure the call is made by the root account
+            ensure_root(origin)?;
+
+            // Set the new maximum stake for the specified network
+            T::Subtensor::set_network_max_stake(netuid, max_stake);
+
+            // Log the change
+            log::trace!(
+                "NetworkMaxStakeSet( netuid: {:?}, max_stake: {:?} )",
+                netuid,
+                max_stake
+            );
+
+            Ok(())
+        }
     }
 }
 
@@ -1167,4 +1219,5 @@ pub trait SubtensorInterface<AccountId, Balance, RuntimeOrigin> {
         alpha_high: u16,
     ) -> Result<(), DispatchError>;
     fn set_hotkey_emission_tempo(emission_tempo: u64);
+    fn set_network_max_stake(netuid: u16, max_stake: u64);
 }

pallets/admin-utils/src/weights.rs

@@ -62,8 +62,6 @@ pub trait WeightInfo {
 	fn sudo_set_tempo() -> Weight;
 	fn sudo_set_commit_reveal_weights_interval() -> Weight;
 	fn sudo_set_commit_reveal_weights_enabled() -> Weight;
-	fn sudo_set_hotkey_emission_tempo() -> Weight;
-	
 }
 
 /// Weights for `pallet_admin_utils` using the Substrate node and recommended hardware.
@@ -807,14 +805,4 @@ impl WeightInfo for () {
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
-	/// Storage: `SubtensorModule::HotkeyEmissionTempo` (r:0 w:1)
-	/// Proof: `SubtensorModule::HotkeyEmissionTempo` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
-	fn sudo_set_hotkey_emission_tempo() -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `0`
-		//  Estimated: `0`
-		// Minimum execution time: 5_000_000 picoseconds.
-		Weight::from_parts(6_000_000, 0)
-			.saturating_add(T::DbWeight::get().writes(1_u64))
-	}
 }

pallets/admin-utils/tests/mock.rs

@@ -114,6 +114,8 @@ parameter_types! {
     pub const InitialAlphaHigh: u16 = 58982; // Represents 0.9 as per the production default
     pub const InitialAlphaLow: u16 = 45875; // Represents 0.7 as per the production default
     pub const InitialLiquidAlphaOn: bool = false; // Default value for LiquidAlphaOn
+    pub const InitialHotkeyEmissionTempo: u64 = 1;
+    pub const InitialNetworkMaxStake: u64 = 500_000_000_000_000; // 500_000 TAO
 }
 
 impl pallet_subtensor::Config for Test {
@@ -169,6 +171,8 @@ impl pallet_subtensor::Config for Test {
     type AlphaHigh = InitialAlphaHigh;
     type AlphaLow = InitialAlphaLow;
     type LiquidAlphaOn = InitialLiquidAlphaOn;
+    type InitialHotkeyEmissionTempo = InitialHotkeyEmissionTempo;
+    type InitialNetworkMaxStake = InitialNetworkMaxStake;
 }
 
 #[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
@@ -478,6 +482,10 @@ impl pallet_admin_utils::SubtensorInterface<AccountId, Balance, RuntimeOrigin> f
     fn set_hotkey_emission_tempo(emission_tempo: u64) {
         SubtensorModule::set_hotkey_emission_tempo(emission_tempo)
     }
+    fn set_network_max_stake(netuid: u16, max_stake: u64) {
+        SubtensorModule::set_network_max_stake(netuid, max_stake)
+    }
+
     fn do_set_alpha_values(
         origin: RuntimeOrigin,
         netuid: u16,

pallets/subtensor/src/coinbase/block_step.rs

@@ -1,10 +1,6 @@
 use super::*;
-use frame_support::storage::IterableStorageDoubleMap;
 use frame_support::storage::IterableStorageMap;
-use sp_runtime::Saturating;
 use substrate_fixed::types::I110F18;
-use substrate_fixed::types::I64F64;
-use substrate_fixed::types::I96F32;
 
 impl<T: Config> Pallet<T> {
     /// Executes the necessary operations for each block.

pallets/subtensor/src/coinbase/run_coinbase.rs

@@ -1,8 +1,5 @@
 use super::*;
 use frame_support::storage::IterableStorageDoubleMap;
-use frame_support::storage::IterableStorageMap;
-use sp_runtime::Saturating;
-use substrate_fixed::types::I110F18;
 use substrate_fixed::types::I64F64;
 use substrate_fixed::types::I96F32;
 
@@ -190,8 +187,8 @@ impl<T: Config> Pallet<T> {
         mining_emission: u64,
     ) {
         // --- 1. First, calculate the hotkey's share of the emission.
-        let take_proportion: I64F64 =
-            I64F64::from_num(Delegates::<T>::get(hotkey)).saturating_div(I64F64::from_num(u16::MAX));
+        let take_proportion: I64F64 = I64F64::from_num(Delegates::<T>::get(hotkey))
+            .saturating_div(I64F64::from_num(u16::MAX));
         let hotkey_take: u64 = take_proportion
             .saturating_mul(I64F64::from_num(validating_emission))
             .to_num::<u64>();
@@ -274,8 +271,8 @@ impl<T: Config> Pallet<T> {
         let total_hotkey_stake: u64 = Self::get_total_stake_for_hotkey(hotkey);
 
         // --- 5 Calculate the emission take for the hotkey.
-        let take_proportion: I64F64 =
-            I64F64::from_num(Delegates::<T>::get(hotkey)).saturating_div(I64F64::from_num(u16::MAX));
+        let take_proportion: I64F64 = I64F64::from_num(Delegates::<T>::get(hotkey))
+            .saturating_div(I64F64::from_num(u16::MAX));
         let hotkey_take: u64 =
             (take_proportion.saturating_mul(I64F64::from_num(emission))).to_num::<u64>();
 
@@ -287,11 +284,15 @@ impl<T: Config> Pallet<T> {
 
         // --- 8 Iterate over each nominator.
         for (nominator, nominator_stake) in
-            <Stake<T> as IterableStorageDoubleMap<T::AccountId, T::AccountId, u64>>::iter_prefix(hotkey)
+            <Stake<T> as IterableStorageDoubleMap<T::AccountId, T::AccountId, u64>>::iter_prefix(
+                hotkey,
+            )
         {
             // --- 9 Check if the stake was manually increased by the user since the last emission drain for this hotkey.
             // If it was, skip this nominator as they will not receive their proportion of the emission.
-            if LastAddStakeIncrease::<T>::get(hotkey, nominator.clone()) > last_hotkey_emission_drain {
+            if LastAddStakeIncrease::<T>::get(hotkey, nominator.clone())
+                > last_hotkey_emission_drain
+            {
                 continue;
             }
 
@@ -365,9 +366,10 @@ impl<T: Config> Pallet<T> {
         if tempo == 0 {
             return u64::MAX;
         }
-        (tempo as u64).saturating_sub(
-            (block_number.saturating_add((netuid as u64).saturating_add(1)))
-                % (tempo as u64).saturating_add(1),
-        )
+        let netuid_plus_one = (netuid as u64).saturating_add(1);
+        let block_plus_netuid = block_number.saturating_add(netuid_plus_one);
+        let tempo_plus_one = (tempo as u64).saturating_add(1);
+        let remainder = block_plus_netuid.rem_euclid(tempo_plus_one);
+        (tempo as u64).saturating_sub(remainder)
     }
 }

pallets/subtensor/src/lib.rs

@@ -502,7 +502,7 @@ pub mod pallet {
     #[pallet::type_value]
     /// Default value for network immunity period.
     pub fn DefaultHotkeyEmissionTempo<T: Config>() -> u64 {
-        7200
+        T::InitialHotkeyEmissionTempo::get()
     }
     #[pallet::type_value]
     /// Default value for rate limiting
@@ -549,6 +549,11 @@ pub mod pallet {
     pub fn DefaultAlphaValues<T: Config>() -> (u16, u16) {
         (45875, 58982)
     }
+    #[pallet::type_value]
+    /// Default value for network max stake.
+    pub fn DefaultNetworkMaxStake<T: Config>() -> u64 {
+        T::InitialNetworkMaxStake::get()
+    }
 
     #[pallet::storage]
     pub type SenateRequiredStakePercentage<T> =
@@ -926,6 +931,10 @@ pub mod pallet {
     ///  MAP ( netuid ) --> (alpha_low, alpha_high)
     pub type AlphaValues<T> =
         StorageMap<_, Identity, u16, (u16, u16), ValueQuery, DefaultAlphaValues<T>>;
+    /// MAP ( netuid ) --> max stake allowed on a subnet.
+    #[pallet::storage]
+    pub type NetworkMaxStake<T> =
+        StorageMap<_, Identity, u16, u64, ValueQuery, DefaultNetworkMaxStake<T>>;
 
     /// =======================================
     /// ==== Subnetwork Consensus Storage  ====

pallets/subtensor/src/macros/config.rs

@@ -168,5 +168,11 @@ mod config {
         /// A flag to indicate if Liquid Alpha is enabled.
         #[pallet::constant]
         type LiquidAlphaOn: Get<bool>;
+        /// Initial network max stake.
+        #[pallet::constant]
+        type InitialNetworkMaxStake: Get<u64>;
+        /// Initial hotkey emission tempo.
+        #[pallet::constant]
+        type InitialHotkeyEmissionTempo: Get<u64>;
     }
 }

pallets/subtensor/src/macros/events.rs

@@ -171,6 +171,11 @@ mod events {
             /// The account ID of the coldkey
             coldkey: T::AccountId,
         },
+        /// The children of a hotkey have been set
         SetChildren(T::AccountId, u16, Vec<(u64, T::AccountId)>),
+        /// The hotkey emission tempo has been set
+        HotkeyEmissionTempoSet(u64),
+        /// The network maximum stake has been set
+        NetworkMaxStakeSet(u16, u64),
     }
 }

pallets/subtensor/src/rpc_info/neuron_info.rs

@@ -118,8 +118,8 @@ impl<T: Config> Pallet<T> {
             })
             .collect::<Vec<(Compact<u16>, Compact<u16>)>>();
         let stake: Vec<(T::AccountId, Compact<u64>)> = vec![(
-            coldkey,
-            Self::get_stake_for_hotkey_on_subnet(hotkey, netuid).into(),
+            coldkey.clone(),
+            Self::get_stake_for_hotkey_on_subnet(&hotkey, netuid).into(),
         )];
         let neuron = NeuronInfo {
             hotkey: hotkey.clone(),

pallets/subtensor/src/staking/set_children.rs

@@ -1,5 +1,4 @@
 use super::*;
-use substrate_fixed::types::I96F32;
 
 impl<T: Config> Pallet<T> {
     /// ---- The implementation for the extrinsic do_set_child_singular: Sets a single child.

pallets/subtensor/src/subnets/registration.rs

@@ -550,10 +550,10 @@ impl<T: Config> Pallet<T> {
         // Copy the hotkey_bytes into the first half of full_bytes
         full_bytes[..32].copy_from_slice(hotkey_bytes);
         let keccak_256_seal_hash_vec: [u8; 32] = keccak_256(&full_bytes[..]);
-        let hash_u64: u64 = u64::from_le_bytes(keccak_256_seal_hash_vec[0..8].try_into().unwrap());
+        let hash_u64: u64 = u64::from_le_bytes(keccak_256_seal_hash_vec[0..8].try_into().unwrap_or_default());
         hash_u64
     }
-    
+
     pub fn create_seal_hash(block_number_u64: u64, nonce_u64: u64, hotkey: &T::AccountId) -> H256 {
         let nonce = nonce_u64.to_le_bytes();
         let block_hash_at_number: H256 = Self::get_block_hash_from_u64(block_number_u64);

pallets/subtensor/src/utils.rs

@@ -703,6 +703,7 @@ impl<T: Config> Pallet<T> {
     pub fn get_hotkey_emission_tempo() -> u64 {
         HotkeyEmissionTempo::<T>::get()
     }
+
     /// Sets the hotkey emission tempo.
     ///
     /// # Arguments
@@ -711,4 +712,40 @@ impl<T: Config> Pallet<T> {
         HotkeyEmissionTempo::<T>::set(emission_tempo);
         Self::deposit_event(Event::HotkeyEmissionTempoSet(emission_tempo));
     }
+
+    pub fn get_pending_hotkey_emission(hotkey: &T::AccountId) -> u64 {
+        PendingdHotkeyEmission::<T>::get(hotkey)
+    }
+
+    /// Retrieves the maximum stake allowed for a given network.
+    ///
+    /// # Arguments
+    ///
+    /// * `netuid` - The unique identifier of the network.
+    ///
+    /// # Returns
+    ///
+    /// * `u64` - The maximum stake allowed for the specified network.
+    pub fn get_network_max_stake(netuid: u16) -> u64 {
+        NetworkMaxStake::<T>::get(netuid)
+    }
+
+    /// Sets the maximum stake allowed for a given network.
+    ///
+    /// # Arguments
+    ///
+    /// * `netuid` - The unique identifier of the network.
+    /// * `max_stake` - The new maximum stake value to set.
+    ///
+    /// # Effects
+    ///
+    /// * Updates the NetworkMaxStake storage.
+    /// * Emits a NetworkMaxStakeSet event.
+    pub fn set_network_max_stake(netuid: u16, max_stake: u64) {
+        // Update the NetworkMaxStake storage with the new max_stake value
+        NetworkMaxStake::<T>::insert(netuid, max_stake);
+
+        // Emit an event to notify listeners about the change
+        Self::deposit_event(Event::NetworkMaxStakeSet(netuid, max_stake));
+    }
 }