Add override-only emission suppression for testnet

pallets/subtensor/src/benchmarks.rs

@@ -1666,4 +1666,23 @@ mod pallet_benchmarks {
         #[extrinsic_call]
         _(RawOrigin::Root, netuid, 100);
     }
+
+    #[benchmark]
+    fn sudo_set_emission_suppression_override() {
+        let coldkey: T::AccountId = whitelisted_caller();
+        let hotkey: T::AccountId = account("A", 0, 1);
+
+        let netuid = Subtensor::<T>::get_next_netuid();
+
+        let lock_cost = Subtensor::<T>::get_network_lock_cost();
+        Subtensor::<T>::add_balance_to_coldkey_account(&coldkey, lock_cost.into());
+
+        assert_ok!(Subtensor::<T>::register_network(
+            RawOrigin::Signed(coldkey.clone()).into(),
+            hotkey.clone()
+        ));
+
+        #[extrinsic_call]
+        _(RawOrigin::Root, netuid, Some(true));
+    }
 }

pallets/subtensor/src/coinbase/root.rs

@@ -302,6 +302,9 @@ impl<T: Config> Pallet<T> {
         SubnetEmaTaoFlow::<T>::remove(netuid);
         SubnetTaoProvided::<T>::remove(netuid);
 
+        // --- 12b. Emission suppression.
+        EmissionSuppressionOverride::<T>::remove(netuid);
+
         // --- 13. Token / mechanism / registration toggles.
         TokenSymbol::<T>::remove(netuid);
         SubnetMechanism::<T>::remove(netuid);

pallets/subtensor/src/coinbase/run_coinbase.rs

@@ -235,7 +235,7 @@ impl<T: Config> Pallet<T> {
             });
 
             if root_sell_flag {
-                // Only accumulate root alpha divs if root sell is allowed.
+                // Accumulate root alpha divs for root validators.
                 PendingRootAlphaDivs::<T>::mutate(*netuid_i, |total| {
                     *total = total.saturating_add(tou64!(root_alpha).into());
                 });

pallets/subtensor/src/coinbase/subnet_emissions.rs

@@ -27,7 +27,8 @@ impl<T: Config> Pallet<T> {
         block_emission: U96F32,
     ) -> BTreeMap<NetUid, U96F32> {
         // Get subnet TAO emissions.
-        let shares = Self::get_shares(subnets_to_emit_to);
+        let mut shares = Self::get_shares(subnets_to_emit_to);
+        Self::apply_emission_suppression(&mut shares);
         log::debug!("Subnet emission shares = {shares:?}");
 
         shares
@@ -246,4 +247,40 @@ impl<T: Config> Pallet<T> {
             })
             .collect::<BTreeMap<NetUid, U64F64>>()
     }
+
+    /// Normalize shares so they sum to 1.0.
+    pub(crate) fn normalize_shares(shares: &mut BTreeMap<NetUid, U64F64>) {
+        let sum: U64F64 = shares
+            .values()
+            .copied()
+            .fold(U64F64::saturating_from_num(0), |acc, v| {
+                acc.saturating_add(v)
+            });
+        if sum > U64F64::saturating_from_num(0) {
+            for s in shares.values_mut() {
+                *s = s.safe_div(sum);
+            }
+        }
+    }
+
+    /// Check if a subnet is currently emission-suppressed via the root override.
+    pub(crate) fn is_subnet_emission_suppressed(netuid: NetUid) -> bool {
+        matches!(EmissionSuppressionOverride::<T>::get(netuid), Some(true))
+    }
+
+    /// Zero the emission share of any subnet that is force-suppressed via override,
+    /// then re-normalize the remaining shares.
+    pub(crate) fn apply_emission_suppression(shares: &mut BTreeMap<NetUid, U64F64>) {
+        let zero = U64F64::saturating_from_num(0);
+        let mut any_zeroed = false;
+        for (netuid, share) in shares.iter_mut() {
+            if Self::is_subnet_emission_suppressed(*netuid) {
+                *share = zero;
+                any_zeroed = true;
+            }
+        }
+        if any_zeroed {
+            Self::normalize_shares(shares);
+        }
+    }
 }

pallets/subtensor/src/lib.rs

@@ -2375,6 +2375,15 @@ pub mod pallet {
     pub type PendingChildKeyCooldown<T: Config> =
         StorageValue<_, u64, ValueQuery, DefaultPendingChildKeyCooldown<T>>;
 
+    /// Root override for emission suppression per subnet.
+    /// Some(true) = force suppressed; None or Some(false) = not suppressed.
+    /// Some(false) is functionally identical to None today and is reserved for
+    /// future use (e.g. an automatic suppression mechanism whose effect
+    /// Some(false) could explicitly override).
+    #[pallet::storage]
+    pub type EmissionSuppressionOverride<T: Config> =
+        StorageMap<_, Identity, NetUid, bool, OptionQuery>;
+
     #[pallet::genesis_config]
     pub struct GenesisConfig<T: Config> {
         /// Stakes record in genesis.

pallets/subtensor/src/macros/dispatches.rs

@@ -2416,5 +2416,36 @@ mod dispatches {
 
             Ok(())
         }
+
+        /// --- Set or clear the root override for emission suppression on a subnet.
+        /// Some(true) forces suppression. None removes the override (subnet is not
+        /// suppressed). Some(false) is accepted and stored but is currently
+        /// functionally identical to None; it is reserved for future use.
+        #[pallet::call_index(133)]
+        #[pallet::weight((
+            Weight::from_parts(5_000_000, 0)
+                .saturating_add(T::DbWeight::get().reads(2))
+                .saturating_add(T::DbWeight::get().writes(1)),
+            DispatchClass::Operational,
+            Pays::No
+        ))]
+        pub fn sudo_set_emission_suppression_override(
+            origin: OriginFor<T>,
+            netuid: NetUid,
+            override_value: Option<bool>,
+        ) -> DispatchResult {
+            ensure_root(origin)?;
+            ensure!(Self::if_subnet_exist(netuid), Error::<T>::SubnetNotExists);
+            ensure!(!netuid.is_root(), Error::<T>::CannotSuppressRootSubnet);
+            match override_value {
+                Some(val) => EmissionSuppressionOverride::<T>::insert(netuid, val),
+                None => EmissionSuppressionOverride::<T>::remove(netuid),
+            }
+            Self::deposit_event(Event::EmissionSuppressionOverrideSet {
+                netuid,
+                override_value,
+            });
+            Ok(())
+        }
     }
 }

pallets/subtensor/src/macros/errors.rs

@@ -268,5 +268,7 @@ mod errors {
         InvalidSubnetNumber,
         /// Unintended precision loss when unstaking alpha
         PrecisionLoss,
+        /// Cannot set emission suppression override for the root subnet.
+        CannotSuppressRootSubnet,
     }
 }

pallets/subtensor/src/macros/events.rs

@@ -481,5 +481,14 @@ mod events {
             /// The amount of alpha distributed
             alpha: AlphaCurrency,
         },
+
+        /// Root set or cleared the emission suppression override for a subnet.
+        EmissionSuppressionOverrideSet {
+            /// The subnet affected
+            netuid: NetUid,
+            /// The override value: Some(true) = force suppress, None = cleared/not suppressed,
+            /// Some(false) = stored but currently identical to None (reserved for future use)
+            override_value: Option<bool>,
+        },
     }
 }