Merge remote-tracking branch 'origin/devnet-ready' into feat/batch-set-weights

Author: sam0x17

Cargo.lock

@@ -29,9 +29,9 @@ log = { workspace = true }
 pallet-subtensor = { version = "4.0.0-dev", default-features = false, path = "../subtensor" }
 sp-weights = { workspace = true }
 substrate-fixed = { workspace = true }
+pallet-evm-chain-id = { workspace = true }
 pallet-drand = { workspace = true, default-features = false }
 
-
 [dev-dependencies]
 sp-core = { workspace = true }
 sp-io = { workspace = true }
@@ -52,6 +52,7 @@ std = [
 	"pallet-subtensor/std",
 	"sp-consensus-aura/std",
 	"pallet-balances/std",
+	"pallet-evm-chain-id/std",
 	"pallet-scheduler/std",
 	"sp-runtime/std",
 	"sp-tracing/std",
@@ -77,6 +78,7 @@ try-runtime = [
 	"frame-support/try-runtime",
 	"frame-system/try-runtime",
 	"pallet-balances/try-runtime",
+	"pallet-evm-chain-id/try-runtime",
 	"pallet-scheduler/try-runtime",
 	"sp-runtime/try-runtime",
 	"pallet-subtensor/try-runtime",

pallets/admin-utils/Cargo.toml

@@ -20,6 +20,7 @@ pub mod pallet {
     use frame_support::pallet_prelude::*;
     use frame_support::traits::tokens::Balance;
     use frame_system::pallet_prelude::*;
+    use pallet_evm_chain_id::{self, ChainId};
     use sp_runtime::BoundedVec;
 
     /// The main data structure of the module.
@@ -29,7 +30,11 @@ pub mod pallet {
 
     /// Configure the pallet by specifying the parameters and types on which it depends.
     #[pallet::config]
-    pub trait Config: frame_system::Config + pallet_subtensor::pallet::Config {
+    pub trait Config:
+        frame_system::Config
+        + pallet_subtensor::pallet::Config
+        + pallet_evm_chain_id::pallet::Config
+    {
         /// Because this pallet emits events, it depends on the runtime's definition of an event.
         type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
 
@@ -885,9 +890,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(())
         }
 
@@ -1212,6 +1217,27 @@ pub mod pallet {
             );
             Ok(())
         }
+
+        /// Sets the EVM ChainID.
+        ///
+        /// # Arguments
+        /// * `origin` - The origin of the call, which must be the subnet owner or the root account.
+        /// * `chainId` - The u64 chain ID
+        ///
+        /// # Errors
+        /// * `BadOrigin` - If the caller is neither the subnet owner nor the root account.
+        ///
+        /// # Weight
+        /// Weight is handled by the `#[pallet::weight]` attribute.
+        #[pallet::call_index(58)]
+        #[pallet::weight(<T as Config>::WeightInfo::sudo_set_evm_chain_id())]
+        pub fn sudo_set_evm_chain_id(origin: OriginFor<T>, chain_id: u64) -> DispatchResult {
+            // Ensure the call is made by the root account
+            ensure_root(origin)?;
+
+            ChainId::<T>::set(chain_id);
+            Ok(())
+        }
     }
 }
 

pallets/admin-utils/src/lib.rs

@@ -29,6 +29,7 @@ frame_support::construct_runtime!(
         SubtensorModule: pallet_subtensor::{Pallet, Call, Storage, Event<T>, Error<T>} = 4,
         Scheduler: pallet_scheduler::{Pallet, Call, Storage, Event<T>} = 5,
         Drand: pallet_drand::{Pallet, Call, Storage, Event<T>} = 6,
+        EVMChainId: pallet_evm_chain_id = 7,
     }
 );
 
@@ -277,6 +278,7 @@ impl pallet_scheduler::Config for Test {
     type Preimages = ();
 }
 
+impl pallet_evm_chain_id::Config for Test {}
 impl pallet_drand::Config for Test {
     type RuntimeEvent = RuntimeEvent;
     type WeightInfo = pallet_drand::weights::SubstrateWeight<Test>;

pallets/admin-utils/src/tests/mock.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);
     });
 }
 
@@ -1433,3 +1433,36 @@ fn sudo_set_commit_reveal_weights_interval() {
         assert_eq!(SubtensorModule::get_reveal_period(netuid), to_be_set);
     });
 }
+
+#[test]
+fn test_sudo_root_sets_evm_chain_id() {
+    new_test_ext().execute_with(|| {
+        let chain_id: u64 = 945;
+        assert_eq!(pallet_evm_chain_id::ChainId::<Test>::get(), 0);
+
+        assert_ok!(AdminUtils::sudo_set_evm_chain_id(
+            <<Test as Config>::RuntimeOrigin>::root(),
+            chain_id
+        ));
+
+        assert_eq!(pallet_evm_chain_id::ChainId::<Test>::get(), chain_id);
+    });
+}
+
+#[test]
+fn test_sudo_non_root_cannot_set_evm_chain_id() {
+    new_test_ext().execute_with(|| {
+        let chain_id: u64 = 945;
+        assert_eq!(pallet_evm_chain_id::ChainId::<Test>::get(), 0);
+
+        assert_eq!(
+            AdminUtils::sudo_set_evm_chain_id(
+                <<Test as Config>::RuntimeOrigin>::signed(U256::from(0)),
+                chain_id
+            ),
+            Err(DispatchError::BadOrigin)
+        );
+
+        assert_eq!(pallet_evm_chain_id::ChainId::<Test>::get(), 0);
+    });
+}

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

@@ -62,6 +62,7 @@ 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_evm_chain_id() -> Weight;
 }
 
 /// Weights for `pallet_admin_utils` using the Substrate node and recommended hardware.
@@ -431,6 +432,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
+	fn sudo_set_evm_chain_id() -> Weight {
+		Weight::from_parts(20_200_000, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
 }
 
 // For backwards compatibility and tests.
@@ -805,4 +810,8 @@ impl WeightInfo for () {
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
+	fn sudo_set_evm_chain_id() -> Weight {
+		Weight::from_parts(20_200_000, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
 }

pallets/admin-utils/src/weights.rs

@@ -784,7 +784,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/coinbase/root.rs

@@ -166,6 +166,9 @@ impl<T: Config> Pallet<T> {
                     );
                     log::debug!("Accumulated emissions on hotkey {:?} for netuid {:?}: mining {:?}, validator {:?}", hotkey, *netuid, mining_emission, validator_emission);
                 }
+
+                // 4.5 Apply pending childkeys of this subnet for the next epoch
+                Self::do_set_pending_children(*netuid);
             } else {
                 // No epoch, increase blocks since last step and continue
                 Self::set_blocks_since_last_step(

pallets/subtensor/src/coinbase/run_coinbase.rs

@@ -311,6 +311,11 @@ pub mod pallet {
         vec![]
     }
     #[pallet::type_value]
+    /// Default pending childkeys
+    pub fn DefaultPendingChildkeys<T: Config>() -> (Vec<(u64, T::AccountId)>, u64) {
+        (vec![], 0)
+    }
+    #[pallet::type_value]
     /// Default account linkage
     pub fn DefaultProportion<T: Config>() -> u64 {
         0
@@ -576,7 +581,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]
@@ -677,6 +682,18 @@ pub mod pallet {
         T::InitialColdkeySwapScheduleDuration::get()
     }
 
+    #[pallet::type_value]
+    /// Default value for applying pending items (e.g. childkeys).
+    pub fn DefaultPendingCooldown<T: Config>() -> u64 {
+        7200
+    }
+
+    #[pallet::type_value]
+    /// Default minimum stake for setting childkeys.
+    pub fn DefaultChildkeysMinStake<T: Config>() -> u64 {
+        1_000_000_000_000
+    }
+
     #[pallet::storage]
     pub type ColdkeySwapScheduleDuration<T: Config> =
         StorageValue<_, BlockNumberFor<T>, ValueQuery, DefaultColdkeySwapScheduleDuration<T>>;
@@ -824,6 +841,18 @@ pub mod pallet {
         DefaultStakeDelta<T>,
     >;
     #[pallet::storage]
+    /// DMAP ( netuid, parent ) --> (Vec<(proportion,child)>, cool_down_block)
+    pub type PendingChildKeys<T: Config> = StorageDoubleMap<
+        _,
+        Identity,
+        u16,
+        Blake2_128Concat,
+        T::AccountId,
+        (Vec<(u64, T::AccountId)>, u64),
+        ValueQuery,
+        DefaultPendingChildkeys<T>,
+    >;
+    #[pallet::storage]
     /// DMAP ( parent, netuid ) --> Vec<(proportion,child)>
     pub type ChildKeys<T: Config> = StorageDoubleMap<
         _,
@@ -1270,7 +1299,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>>;
+    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<
@@ -1342,7 +1371,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/lib.rs

@@ -1269,7 +1269,7 @@ mod dispatches {
             netuid: u16,
             children: Vec<(u64, T::AccountId)>,
         ) -> DispatchResultWithPostInfo {
-            Self::do_set_children(origin, hotkey, netuid, children)?;
+            Self::do_schedule_children(origin, hotkey, netuid, children)?;
             Ok(().into())
         }