[Feature] Configurable Tempo & Owner-Triggered Epochs

chain-extensions/src/mock.rs

@@ -353,6 +353,7 @@ parameter_types! {
     pub const EvmKeyAssociateRateLimit: u64 = 10;
     pub const SubtensorPalletId: PalletId = PalletId(*b"subtensr");
     pub const BurnAccountId: PalletId = PalletId(*b"burntnsr");
+    pub const MaxEpochsPerBlock: u32 = 32;
 }
 
 impl pallet_subtensor::Config for Test {
@@ -431,6 +432,7 @@ impl pallet_subtensor::Config for Test {
     type AuthorshipProvider = MockAuthorshipProvider;
     type SubtensorPalletId = SubtensorPalletId;
     type BurnAccountId = BurnAccountId;
+    type MaxEpochsPerBlock = MaxEpochsPerBlock;
     type WeightInfo = ();
 }
 

eco-tests/src/helpers.rs

@@ -87,9 +87,9 @@ pub fn next_block_no_epoch(netuid: NetUid) -> u64 {
     let high_tempo: u16 = u16::MAX - 1;
     let old_tempo: u16 = SubtensorModule::get_tempo(netuid);
 
-    SubtensorModule::set_tempo(netuid, high_tempo);
+    SubtensorModule::set_tempo_unchecked(netuid, high_tempo);
     let new_block = next_block();
-    SubtensorModule::set_tempo(netuid, old_tempo);
+    SubtensorModule::set_tempo_unchecked(netuid, old_tempo);
 
     new_block
 }
@@ -99,14 +99,14 @@ pub fn run_to_block_no_epoch(netuid: NetUid, n: u64) {
     let high_tempo: u16 = u16::MAX - 1;
     let old_tempo: u16 = SubtensorModule::get_tempo(netuid);
 
-    SubtensorModule::set_tempo(netuid, high_tempo);
+    SubtensorModule::set_tempo_unchecked(netuid, high_tempo);
     run_to_block(n);
-    SubtensorModule::set_tempo(netuid, old_tempo);
+    SubtensorModule::set_tempo_unchecked(netuid, old_tempo);
 }
 
 pub fn step_epochs(count: u16, netuid: NetUid) {
     for _ in 0..count {
-        let blocks_to_next_epoch = SubtensorModule::blocks_until_next_epoch(
+        let blocks_to_next_epoch = SubtensorModule::blocks_until_next_auto_epoch(
             netuid,
             SubtensorModule::get_tempo(netuid),
             SubtensorModule::get_current_block_as_u64(),

eco-tests/src/mock.rs

@@ -236,6 +236,7 @@ parameter_types! {
     pub const EvmKeyAssociateRateLimit: u64 = 10;
     pub const SubtensorPalletId: PalletId = PalletId(*b"subtensr");
     pub const BurnAccountId: PalletId = PalletId(*b"burntnsr");
+    pub const MaxEpochsPerBlock: u32 = 32;
 }
 
 impl pallet_subtensor::Config for Test {
@@ -313,6 +314,7 @@ impl pallet_subtensor::Config for Test {
     type AuthorshipProvider = MockAuthorshipProvider;
     type SubtensorPalletId = SubtensorPalletId;
     type BurnAccountId = BurnAccountId;
+    type MaxEpochsPerBlock = MaxEpochsPerBlock;
     type WeightInfo = ();
     type AlphaAssets = AlphaAssets;
 }

pallets/admin-utils/src/lib.rs

@@ -611,6 +611,9 @@ pub mod pallet {
         /// The extrinsic sets the activity cutoff for a subnet.
         /// It is only callable by the root account or subnet owner.
         /// The extrinsic will call the Subtensor pallet to set the activity cutoff.
+        // #[deprecated(
+        //     note = "Please use set_activity_cutoff_factor instead. This extrinsic will be removed soon."
+        // )]
         #[pallet::call_index(18)]
         #[pallet::weight(<T as pallet::Config>::WeightInfo::sudo_set_activity_cutoff())]
         pub fn sudo_set_activity_cutoff(
@@ -983,7 +986,7 @@ pub mod pallet {
                 pallet_subtensor::Pallet::<T>::if_subnet_exist(netuid),
                 Error::<T>::SubnetDoesNotExist
             );
-            pallet_subtensor::Pallet::<T>::set_tempo(netuid, tempo);
+            pallet_subtensor::Pallet::<T>::apply_tempo_with_cycle_reset(netuid, tempo);
             log::debug!("TempoSet( netuid: {netuid:?} tempo: {tempo:?} ) ");
             Ok(())
         }

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

@@ -160,6 +160,7 @@ parameter_types! {
     pub const EvmKeyAssociateRateLimit: u64 = 0;
     pub const SubtensorPalletId: PalletId = PalletId(*b"subtensr");
     pub const BurnAccountId: PalletId = PalletId(*b"burntnsr");
+    pub const MaxEpochsPerBlock: u32 = 32;
 }
 
 impl pallet_subtensor::Config for Test {
@@ -238,6 +239,7 @@ impl pallet_subtensor::Config for Test {
     type AuthorshipProvider = MockAuthorshipProvider;
     type SubtensorPalletId = SubtensorPalletId;
     type BurnAccountId = BurnAccountId;
+    type MaxEpochsPerBlock = MaxEpochsPerBlock;
     type WeightInfo = ();
 }
 

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

@@ -2042,16 +2042,20 @@ fn test_sudo_set_admin_freeze_window_and_rate() {
 fn test_freeze_window_blocks_root_and_owner() {
     new_test_ext().execute_with(|| {
         let netuid = NetUid::from(1);
-        let tempo = 10;
+        let tempo: u16 = 10;
         // Create subnet with tempo 10
         add_network(netuid, tempo);
         // Set freeze window to 3 blocks
         assert_ok!(AdminUtils::sudo_set_admin_freeze_window(
             <<Test as Config>::RuntimeOrigin>::root(),
             3
         ));
-        // Advance to a block where remaining < 3
-        run_to_block((tempo - 2).into());
+        // Pin the state-based scheduler so the next auto-epoch lands at
+        // `LastEpochBlock + tempo`. Freeze window covers blocks (next_auto - 3, next_auto].
+        pallet_subtensor::LastEpochBlock::<Test>::insert(netuid, 0);
+        let next_auto = tempo as u64;
+        // Advance to a block inside the freeze window (remaining < 3).
+        run_to_block(next_auto - 2);
 
         // Root should be blocked during freeze window
         assert_noop!(
@@ -2147,7 +2151,7 @@ fn test_owner_hyperparam_update_rate_limit_enforced() {
         SubnetOwner::<Test>::insert(netuid, owner);
 
         // Set tempo to 1 so owner hyperparam RL = 2 tempos = 2 blocks
-        SubtensorModule::set_tempo(netuid, 1);
+        SubtensorModule::set_tempo_unchecked(netuid, 1);
         // Disable admin freeze window to avoid blocking on small tempo
         assert_ok!(AdminUtils::sudo_set_admin_freeze_window(
             <<Test as Config>::RuntimeOrigin>::root(),
@@ -2202,7 +2206,7 @@ fn test_hyperparam_rate_limit_enforced_by_tempo() {
         SubnetOwner::<Test>::insert(netuid, owner);
 
         // Set tempo to 1 so RL = 2 blocks
-        SubtensorModule::set_tempo(netuid, 1);
+        SubtensorModule::set_tempo_unchecked(netuid, 1);
         // Disable admin freeze window to avoid blocking on small tempo
         assert_ok!(AdminUtils::sudo_set_admin_freeze_window(
             <<Test as Config>::RuntimeOrigin>::root(),
@@ -2250,7 +2254,7 @@ fn test_owner_hyperparam_rate_limit_independent_per_param() {
         SubnetOwner::<Test>::insert(netuid, owner);
 
         // Use small tempo to make RL short and deterministic (2 blocks when tempo=1)
-        SubtensorModule::set_tempo(netuid, 1);
+        SubtensorModule::set_tempo_unchecked(netuid, 1);
         // Disable admin freeze window so it doesn't interfere with small tempo
         assert_ok!(AdminUtils::sudo_set_admin_freeze_window(
             <<Test as Config>::RuntimeOrigin>::root(),

pallets/subtensor/runtime-api/src/lib.rs

@@ -51,6 +51,7 @@ sp_api::decl_runtime_apis! {
         fn get_selective_mechagraph(netuid: NetUid, subid: MechId, metagraph_indexes: Vec<u16>) -> Option<SelectiveMetagraph<AccountId32>>;
         fn get_subnet_to_prune() -> Option<NetUid>;
         fn get_subnet_account_id(netuid: NetUid) -> Option<AccountId32>;
+        fn get_next_epoch_start_block(netuid: NetUid) -> Option<u64>;
     }
 
     pub trait StakeInfoRuntimeApi {

pallets/subtensor/src/benchmarks.rs

@@ -440,19 +440,15 @@ mod pallet_benchmarks {
             salt.clone(),
             version_key,
         ));
-        let commit_block = Subtensor::<T>::get_current_block_as_u64();
         assert_ok!(Subtensor::<T>::commit_weights(
             RawOrigin::Signed(hotkey.clone()).into(),
             netuid,
             commit_hash,
         ));
 
-        let (first_reveal_block, _) = Subtensor::<T>::get_reveal_blocks(netuid, commit_block);
-        let reveal_block: BlockNumberFor<T> = first_reveal_block
-            .try_into()
-            .ok()
-            .expect("can't convert to block number");
-        frame_system::Pallet::<T>::set_block_number(reveal_block);
+        // Advance the epoch counter into the commit's reveal window.
+        let reveal_period = Subtensor::<T>::get_reveal_period(netuid);
+        SubnetEpochIndex::<T>::mutate(netuid, |e| *e = e.saturating_add(reveal_period));
 
         #[extrinsic_call]
         _(
@@ -676,7 +672,6 @@ mod pallet_benchmarks {
         let mut salts_list = Vec::new();
         let mut version_keys = Vec::new();
 
-        let commit_block = Subtensor::<T>::get_current_block_as_u64();
         for i in 0..num_commits {
             let uids = vec![0u16];
             let values = vec![i as u16];
@@ -704,12 +699,9 @@ mod pallet_benchmarks {
             version_keys.push(version_key_i);
         }
 
-        let (first_reveal_block, _) = Subtensor::<T>::get_reveal_blocks(netuid, commit_block);
-        let reveal_block: BlockNumberFor<T> = first_reveal_block
-            .try_into()
-            .ok()
-            .expect("can't convert to block number");
-        frame_system::Pallet::<T>::set_block_number(reveal_block);
+        // Advance the epoch counter into the reveal window for these commits.
+        let reveal_period = Subtensor::<T>::get_reveal_period(netuid);
+        SubnetEpochIndex::<T>::mutate(netuid, |e| *e = e.saturating_add(reveal_period));
 
         #[extrinsic_call]
         _(
@@ -2148,6 +2140,54 @@ mod pallet_benchmarks {
         );
     }
 
+    #[benchmark]
+    fn set_tempo() {
+        let netuid = NetUid::from(1);
+        let coldkey: T::AccountId = account("Owner", 0, 1);
+
+        Subtensor::<T>::init_new_network(netuid, 1u16);
+        SubnetOwner::<T>::insert(netuid, coldkey.clone());
+        SubtokenEnabled::<T>::insert(netuid, true);
+        Subtensor::<T>::set_commit_reveal_weights_enabled(netuid, false);
+        Subtensor::<T>::set_admin_freeze_window(0);
+
+        #[extrinsic_call]
+        _(RawOrigin::Signed(coldkey.clone()), netuid, MIN_TEMPO);
+    }
+
+    #[benchmark]
+    fn set_activity_cutoff_factor() {
+        let netuid = NetUid::from(1);
+        let coldkey: T::AccountId = account("Owner", 0, 1);
+
+        Subtensor::<T>::init_new_network(netuid, 1u16);
+        SubnetOwner::<T>::insert(netuid, coldkey.clone());
+        SubtokenEnabled::<T>::insert(netuid, true);
+        Subtensor::<T>::set_admin_freeze_window(0);
+
+        #[extrinsic_call]
+        _(
+            RawOrigin::Signed(coldkey.clone()),
+            netuid,
+            INITIAL_ACTIVITY_CUTOFF_FACTOR_MILLI,
+        );
+    }
+
+    #[benchmark]
+    fn trigger_epoch() {
+        let netuid = NetUid::from(1);
+        let coldkey: T::AccountId = account("Owner", 0, 1);
+
+        Subtensor::<T>::init_new_network(netuid, 1u16);
+        SubnetOwner::<T>::insert(netuid, coldkey.clone());
+        SubtokenEnabled::<T>::insert(netuid, true);
+        Subtensor::<T>::set_commit_reveal_weights_enabled(netuid, false);
+        Subtensor::<T>::set_admin_freeze_window(0);
+
+        #[extrinsic_call]
+        _(RawOrigin::Signed(coldkey.clone()), netuid);
+    }
+
     impl_benchmark_test_suite!(
         Subtensor,
         crate::tests::mock::new_test_ext(1),

pallets/subtensor/src/coinbase/block_step.rs

@@ -36,9 +36,11 @@ impl<T: Config + pallet_drand::Config> Pallet<T> {
     }
 
     fn try_set_pending_children(block_number: u64) {
+        // Called *after* `run_coinbase` has advanced `LastEpochBlock` for any
+        // subnet whose epoch slot fired this block — `should_run_epoch` is no
+        // longer true. Detect "epoch just fired" by `LastEpochBlock == block`.
         for netuid in Self::get_all_subnet_netuids() {
-            if Self::should_run_epoch(netuid, block_number) {
-                // Set pending children on the epoch.
+            if LastEpochBlock::<T>::get(netuid) == block_number {
                 Self::do_set_pending_children(netuid);
             }
         }

pallets/subtensor/src/coinbase/mod.rs

@@ -7,3 +7,4 @@ pub mod root;
 pub mod run_coinbase;
 pub mod subnet_emissions;
 pub mod tao;
+pub mod tempo_control;

pallets/subtensor/src/coinbase/reveal_commits.rs

@@ -38,8 +38,9 @@ impl<T: Config> Pallet<T> {
     /// The `reveal_crv3_commits` function is run at the very beginning of epoch `n`,
     pub fn reveal_crv3_commits_for_subnet(netuid: NetUid) -> dispatch::DispatchResult {
         let reveal_period = Self::get_reveal_period(netuid);
-        let cur_block = Self::get_current_block_as_u64();
-        let cur_epoch = Self::get_epoch_index(netuid, cur_block);
+        // If the subnet is deferred past this block the
+        // commits are taken once here and the later block(s) become no-ops.
+        let cur_epoch = Self::current_epoch_with_lookahead(netuid);
 
         // Weights revealed must have been committed during epoch `cur_epoch - reveal_period`.
         let reveal_epoch = cur_epoch.saturating_sub(reveal_period);

pallets/subtensor/src/coinbase/root.rs

@@ -284,6 +284,10 @@ impl<T: Config> Pallet<T> {
         MaxAllowedUids::<T>::remove(netuid);
         ImmunityPeriod::<T>::remove(netuid);
         ActivityCutoff::<T>::remove(netuid);
+        ActivityCutoffFactorMilli::<T>::remove(netuid);
+        LastEpochBlock::<T>::remove(netuid);
+        PendingEpochAt::<T>::remove(netuid);
+        SubnetEpochIndex::<T>::remove(netuid);
         MinAllowedWeights::<T>::remove(netuid);
         RegistrationsThisInterval::<T>::remove(netuid);
         POWRegistrationsThisInterval::<T>::remove(netuid);