feat: add sudo call to disable emissions for a subnet

Closes #2287

This PR adds a new sudo call `sudo_set_emissions_disabled` that allows
root to disable or enable emissions for a specific subnet.

Changes:
- Add EmissionsDisabled storage item in subtensor pallet
- Add EmissionsDisabledSet event
- Add getter/setter functions for EmissionsDisabled
- Add sudo_set_emissions_disabled call in admin-utils pallet (call_index 84)
- Update get_subnets_to_emit_to to filter out subnets with emissions disabled
- Add cleanup for EmissionsDisabled in remove_network
- Add benchmark for the new extrinsic
- Add tests for the new functionality

Author: MkDev11

pallets/admin-utils/src/benchmarking.rs

@@ -645,5 +645,17 @@ mod benchmarks {
         ); /* sudo_set_min_non_immune_uids() */
     }
 
+    #[benchmark]
+    fn sudo_set_emissions_disabled() {
+        pallet_subtensor::Pallet::<T>::set_admin_freeze_window(0);
+        pallet_subtensor::Pallet::<T>::init_new_network(
+            1u16.into(), /*netuid*/
+            1u16,        /*tempo*/
+        );
+
+        #[extrinsic_call]
+        _(RawOrigin::Root, 1u16.into()/*netuid*/, true/*disabled*/)/*sudo_set_emissions_disabled*/;
+    }
+
     //impl_benchmark_test_suite!(AdminUtils, crate::mock::new_test_ext(), crate::mock::Test);
 }

pallets/admin-utils/src/lib.rs

@@ -2240,6 +2240,34 @@ pub mod pallet {
             pallet_subtensor::Pallet::<T>::set_min_non_immune_uids(netuid, min);
             Ok(())
         }
+
+        /// Enables or disables emissions for a specific subnet.
+        /// It is only callable by the root account (sudo).
+        /// When emissions are disabled, the subnet will not receive any TAO emissions.
+        #[pallet::call_index(85)]
+        #[pallet::weight((
+            Weight::from_parts(7_343_000, 0)
+                .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(1))
+                .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1)),
+            DispatchClass::Operational,
+            Pays::Yes
+        ))]
+        pub fn sudo_set_emissions_disabled(
+            origin: OriginFor<T>,
+            netuid: NetUid,
+            disabled: bool,
+        ) -> DispatchResult {
+            ensure_root(origin)?;
+            ensure!(
+                pallet_subtensor::Pallet::<T>::if_subnet_exist(netuid),
+                Error::<T>::SubnetDoesNotExist
+            );
+            pallet_subtensor::Pallet::<T>::set_emissions_disabled(netuid, disabled);
+            log::debug!(
+                "sudo_set_emissions_disabled( netuid: {netuid:?}, disabled: {disabled:?} ) "
+            );
+            Ok(())
+        }
     }
 }
 

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

@@ -2887,3 +2887,59 @@ fn test_sudo_set_min_non_immune_uids() {
         assert_eq!(SubtensorModule::get_min_non_immune_uids(netuid), to_be_set);
     });
 }
+
+#[test]
+fn test_sudo_set_emissions_disabled() {
+    new_test_ext().execute_with(|| {
+        let netuid = NetUid::from(1);
+        add_network(netuid, 10);
+
+        // Check default value is false (emissions enabled)
+        let init_value: bool = SubtensorModule::get_emissions_disabled(netuid);
+        assert!(!init_value);
+
+        // Non-root cannot call
+        assert_eq!(
+            AdminUtils::sudo_set_emissions_disabled(
+                <<Test as Config>::RuntimeOrigin>::signed(U256::from(1)),
+                netuid,
+                true
+            ),
+            Err(DispatchError::BadOrigin)
+        );
+        assert_eq!(SubtensorModule::get_emissions_disabled(netuid), init_value);
+
+        // Root can disable emissions
+        assert_ok!(AdminUtils::sudo_set_emissions_disabled(
+            <<Test as Config>::RuntimeOrigin>::root(),
+            netuid,
+            true
+        ));
+        assert!(SubtensorModule::get_emissions_disabled(netuid));
+
+        // Root can re-enable emissions
+        assert_ok!(AdminUtils::sudo_set_emissions_disabled(
+            <<Test as Config>::RuntimeOrigin>::root(),
+            netuid,
+            false
+        ));
+        assert!(!SubtensorModule::get_emissions_disabled(netuid));
+    });
+}
+
+#[test]
+fn test_sudo_set_emissions_disabled_subnet_not_exist() {
+    new_test_ext().execute_with(|| {
+        let netuid = NetUid::from(99);
+
+        // Subnet does not exist
+        assert_err!(
+            AdminUtils::sudo_set_emissions_disabled(
+                <<Test as Config>::RuntimeOrigin>::root(),
+                netuid,
+                true
+            ),
+            Error::<Test>::SubnetDoesNotExist
+        );
+    });
+}

pallets/subtensor/src/coinbase/root.rs

@@ -314,6 +314,7 @@ impl<T: Config> Pallet<T> {
 
         // --- 15. Mechanism step / emissions bookkeeping.
         FirstEmissionBlockNumber::<T>::remove(netuid);
+        EmissionsDisabled::<T>::remove(netuid);
         PendingValidatorEmission::<T>::remove(netuid);
         PendingServerEmission::<T>::remove(netuid);
         PendingRootAlphaDivs::<T>::remove(netuid);

pallets/subtensor/src/coinbase/subnet_emissions.rs

@@ -8,11 +8,13 @@ impl<T: Config> Pallet<T> {
     pub fn get_subnets_to_emit_to(subnets: &[NetUid]) -> Vec<NetUid> {
         // Filter out root subnet.
         // Filter out subnets with no first emission block number.
+        // Filter out subnets with emissions disabled.
         subnets
             .iter()
             .filter(|netuid| !netuid.is_root())
             .filter(|netuid| FirstEmissionBlockNumber::<T>::get(*netuid).is_some())
             .filter(|netuid| SubtokenEnabled::<T>::get(*netuid))
+            .filter(|netuid| !EmissionsDisabled::<T>::get(*netuid))
             .filter(|&netuid| {
                 // Only emit TAO if the subnetwork allows registration.
                 Self::get_network_registration_allowed(*netuid)

pallets/subtensor/src/lib.rs

@@ -1587,6 +1587,11 @@ pub mod pallet {
     pub type FirstEmissionBlockNumber<T: Config> =
         StorageMap<_, Identity, NetUid, u64, OptionQuery>;
 
+    /// --- MAP ( netuid ) --> emissions_disabled | Whether emissions are disabled for this subnet
+    #[pallet::storage]
+    pub type EmissionsDisabled<T: Config> =
+        StorageMap<_, Identity, NetUid, bool, ValueQuery, DefaultFalse<T>>;
+
     /// --- MAP ( netuid ) --> subnet mechanism
     #[pallet::storage]
     pub type SubnetMechanism<T: Config> =

pallets/subtensor/src/macros/events.rs

@@ -131,6 +131,8 @@ mod events {
         RegistrationAllowed(NetUid, bool),
         /// POW registration is allowed/disallowed for a subnet.
         PowRegistrationAllowed(NetUid, bool),
+        /// emissions are enabled/disabled for a subnet.
+        EmissionsDisabledSet(NetUid, bool),
         /// setting tempo on a network
         TempoSet(NetUid, u16),
         /// setting the RAO recycled for registration.

pallets/subtensor/src/tests/coinbase.rs

@@ -4016,3 +4016,35 @@ fn test_get_subnet_terms_alpha_emissions_cap() {
         assert_eq!(alpha_in.get(&netuid).copied().unwrap(), tao_block_emission);
     });
 }
+
+#[test]
+fn test_get_subnets_to_emit_to_filters_emissions_disabled() {
+    new_test_ext(1).execute_with(|| {
+        let netuid0 = add_dynamic_network(&U256::from(1), &U256::from(2));
+        let netuid1 = add_dynamic_network(&U256::from(3), &U256::from(4));
+
+        // Both subnets should be in the list initially
+        let subnets_to_emit_to_0 = SubtensorModule::get_subnets_to_emit_to(&[netuid0, netuid1]);
+        assert_eq!(subnets_to_emit_to_0.len(), 2);
+        assert!(subnets_to_emit_to_0.contains(&netuid0));
+        assert!(subnets_to_emit_to_0.contains(&netuid1));
+
+        // Disable emissions for netuid0
+        EmissionsDisabled::<Test>::insert(netuid0, true);
+
+        // Check that netuid0 is not in the list
+        let subnets_to_emit_to_1 = SubtensorModule::get_subnets_to_emit_to(&[netuid0, netuid1]);
+        assert_eq!(subnets_to_emit_to_1.len(), 1);
+        assert!(!subnets_to_emit_to_1.contains(&netuid0));
+        assert!(subnets_to_emit_to_1.contains(&netuid1));
+
+        // Re-enable emissions for netuid0
+        EmissionsDisabled::<Test>::insert(netuid0, false);
+
+        // Check that netuid0 is back in the list
+        let subnets_to_emit_to_2 = SubtensorModule::get_subnets_to_emit_to(&[netuid0, netuid1]);
+        assert_eq!(subnets_to_emit_to_2.len(), 2);
+        assert!(subnets_to_emit_to_2.contains(&netuid0));
+        assert!(subnets_to_emit_to_2.contains(&netuid1));
+    });
+}

pallets/subtensor/src/utils/misc.rs

@@ -596,6 +596,15 @@ impl<T: Config> Pallet<T> {
         Self::deposit_event(Event::PowRegistrationAllowed(netuid, registration_allowed));
     }
 
+    // Emissions Disabled utils
+    pub fn get_emissions_disabled(netuid: NetUid) -> bool {
+        EmissionsDisabled::<T>::get(netuid)
+    }
+    pub fn set_emissions_disabled(netuid: NetUid, disabled: bool) {
+        EmissionsDisabled::<T>::insert(netuid, disabled);
+        Self::deposit_event(Event::EmissionsDisabledSet(netuid, disabled));
+    }
+
     pub fn get_target_registrations_per_interval(netuid: NetUid) -> u16 {
         TargetRegistrationsPerInterval::<T>::get(netuid)
     }