dTao-Compatible Subnet Deregistration

pallets/admin-utils/src/lib.rs

@@ -1084,6 +1084,23 @@ pub mod pallet {
             Ok(())
         }
 
+        /// The extrinsic sets the subnet limit for the network.
+        /// It is only callable by the root account.
+        /// The extrinsic will call the Subtensor pallet to set the subnet limit.
+        #[pallet::call_index(37)]
+        #[pallet::weight((
+			Weight::from_parts(14_000_000, 0)
+				.saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1)),
+			DispatchClass::Operational,
+			Pays::No
+		))]
+        pub fn sudo_set_subnet_limit(origin: OriginFor<T>, max_subnets: u16) -> DispatchResult {
+            ensure_root(origin)?;
+            pallet_subtensor::Pallet::<T>::set_max_subnets(max_subnets);
+            log::debug!("MaxSubnets ( max_subnets: {max_subnets:?} ) ");
+            Ok(())
+        }
+
         /// The extrinsic sets the lock reduction interval for the network.
         /// It is only callable by the root account.
         /// The extrinsic will call the Subtensor pallet to set the lock reduction interval.

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

@@ -129,7 +129,7 @@ parameter_types! {
     pub const InitialMaxDifficulty: u64 = u64::MAX;
     pub const InitialRAORecycledForRegistration: u64 = 0;
     pub const InitialSenateRequiredStakePercentage: u64 = 2; // 2 percent of total stake
-    pub const InitialNetworkImmunityPeriod: u64 = 7200 * 7;
+    pub const InitialNetworkImmunityPeriod: u64 = 1_296_000;
     pub const InitialNetworkMinLockCost: u64 = 100_000_000_000;
     pub const InitialSubnetOwnerCut: u16 = 0; // 0%. 100% of rewards go to validators + miners.
     pub const InitialNetworkLockReductionInterval: u64 = 2; // 2 blocks.
@@ -230,6 +230,7 @@ impl pallet_subtensor::Config for Test {
     type LeaseDividendsDistributionInterval = LeaseDividendsDistributionInterval;
     type GetCommitments = ();
     type MaxImmuneUidsPercentage = MaxImmuneUidsPercentage;
+    type CommitmentsInterface = CommitmentsI;
 }
 
 parameter_types! {
@@ -356,6 +357,11 @@ impl PrivilegeCmp<OriginCaller> for OriginPrivilegeCmp {
     }
 }
 
+pub struct CommitmentsI;
+impl pallet_subtensor::CommitmentsInterface for CommitmentsI {
+    fn purge_netuid(_netuid: NetUid) {}
+}
+
 pub struct GrandpaInterfaceImpl;
 impl crate::GrandpaInterface<Test> for GrandpaInterfaceImpl {
     fn schedule_change(

pallets/commitments/src/lib.rs

@@ -566,6 +566,18 @@ impl<T: Config> Pallet<T> {
             .collect();
         commitments
     }
+
+    pub fn purge_netuid(netuid: NetUid) {
+        let _ = CommitmentOf::<T>::clear_prefix(netuid, u32::MAX, None);
+        let _ = LastCommitment::<T>::clear_prefix(netuid, u32::MAX, None);
+        let _ = LastBondsReset::<T>::clear_prefix(netuid, u32::MAX, None);
+        let _ = RevealedCommitments::<T>::clear_prefix(netuid, u32::MAX, None);
+        let _ = UsedSpaceOf::<T>::clear_prefix(netuid, u32::MAX, None);
+
+        TimelockedIndex::<T>::mutate(|index| {
+            index.retain(|(n, _)| *n != netuid);
+        });
+    }
 }
 
 pub trait GetCommitments<AccountId> {

pallets/commitments/src/tests.rs

@@ -4,8 +4,9 @@ use subtensor_runtime_common::NetUid;
 
 #[cfg(test)]
 use crate::{
-    BalanceOf, CommitmentInfo, CommitmentOf, Config, Data, Error, Event, MaxSpace, Pallet,
-    Registration, RevealedCommitments, TimelockedIndex, UsedSpaceOf,
+    BalanceOf, CommitmentInfo, CommitmentOf, Config, Data, Error, Event, LastBondsReset,
+    LastCommitment, MaxSpace, Pallet, Registration, RevealedCommitments, TimelockedIndex,
+    UsageTracker, UsedSpaceOf,
     mock::{
         Balances, DRAND_QUICKNET_SIG_2000_HEX, DRAND_QUICKNET_SIG_HEX, RuntimeEvent, RuntimeOrigin,
         Test, TestMaxFields, insert_drand_pulse, new_test_ext, produce_ciphertext,
@@ -2185,3 +2186,119 @@ fn mixed_timelocked_and_raw_fields_works() {
         );
     });
 }
+
+#[test]
+fn purge_netuid_clears_only_that_netuid() {
+    new_test_ext().execute_with(|| {
+        // Setup
+        System::<Test>::set_block_number(1);
+
+        let net_a = NetUid::from(42);
+        let net_b = NetUid::from(43);
+        let who_a1: u64 = 1001;
+        let who_a2: u64 = 1002;
+        let who_b: u64 = 2001;
+
+        // Minimal commitment payload
+        let empty_fields: BoundedVec<Data, <Test as Config>::MaxFields> = BoundedVec::default();
+        let info_empty: CommitmentInfo<<Test as Config>::MaxFields> = CommitmentInfo {
+            fields: empty_fields,
+        };
+        let bn = System::<Test>::block_number();
+
+        // Seed NET A with two accounts across all tracked storages
+        let reg_a1 = Registration {
+            deposit: Default::default(),
+            block: bn,
+            info: info_empty.clone(),
+        };
+        let reg_a2 = Registration {
+            deposit: Default::default(),
+            block: bn,
+            info: info_empty.clone(),
+        };
+        CommitmentOf::<Test>::insert(net_a, who_a1, reg_a1);
+        CommitmentOf::<Test>::insert(net_a, who_a2, reg_a2);
+        LastCommitment::<Test>::insert(net_a, who_a1, bn);
+        LastCommitment::<Test>::insert(net_a, who_a2, bn);
+        LastBondsReset::<Test>::insert(net_a, who_a1, bn);
+        RevealedCommitments::<Test>::insert(net_a, who_a1, vec![(b"a".to_vec(), 7u64)]);
+        UsedSpaceOf::<Test>::insert(
+            net_a,
+            who_a1,
+            UsageTracker {
+                last_epoch: 1,
+                used_space: 123,
+            },
+        );
+
+        // Seed NET B with one account that must remain intact
+        let reg_b = Registration {
+            deposit: Default::default(),
+            block: bn,
+            info: info_empty,
+        };
+        CommitmentOf::<Test>::insert(net_b, who_b, reg_b);
+        LastCommitment::<Test>::insert(net_b, who_b, bn);
+        LastBondsReset::<Test>::insert(net_b, who_b, bn);
+        RevealedCommitments::<Test>::insert(net_b, who_b, vec![(b"b".to_vec(), 8u64)]);
+        UsedSpaceOf::<Test>::insert(
+            net_b,
+            who_b,
+            UsageTracker {
+                last_epoch: 9,
+                used_space: 999,
+            },
+        );
+
+        // Timelocked index contains both nets
+        TimelockedIndex::<Test>::mutate(|idx| {
+            idx.insert((net_a, who_a1));
+            idx.insert((net_a, who_a2));
+            idx.insert((net_b, who_b));
+        });
+
+        // Sanity pre-checks
+        assert!(CommitmentOf::<Test>::get(net_a, who_a1).is_some());
+        assert!(CommitmentOf::<Test>::get(net_b, who_b).is_some());
+        assert!(TimelockedIndex::<Test>::get().contains(&(net_a, who_a1)));
+
+        // Act
+        Pallet::<Test>::purge_netuid(net_a);
+
+        // NET A: everything cleared
+        assert_eq!(CommitmentOf::<Test>::iter_prefix(net_a).count(), 0);
+        assert!(CommitmentOf::<Test>::get(net_a, who_a1).is_none());
+        assert!(CommitmentOf::<Test>::get(net_a, who_a2).is_none());
+
+        assert_eq!(LastCommitment::<Test>::iter_prefix(net_a).count(), 0);
+        assert!(LastCommitment::<Test>::get(net_a, who_a1).is_none());
+        assert!(LastCommitment::<Test>::get(net_a, who_a2).is_none());
+
+        assert_eq!(LastBondsReset::<Test>::iter_prefix(net_a).count(), 0);
+        assert!(LastBondsReset::<Test>::get(net_a, who_a1).is_none());
+
+        assert_eq!(RevealedCommitments::<Test>::iter_prefix(net_a).count(), 0);
+        assert!(RevealedCommitments::<Test>::get(net_a, who_a1).is_none());
+
+        assert_eq!(UsedSpaceOf::<Test>::iter_prefix(net_a).count(), 0);
+        assert!(UsedSpaceOf::<Test>::get(net_a, who_a1).is_none());
+
+        let idx_after = TimelockedIndex::<Test>::get();
+        assert!(!idx_after.contains(&(net_a, who_a1)));
+        assert!(!idx_after.contains(&(net_a, who_a2)));
+
+        // NET B: untouched
+        assert!(CommitmentOf::<Test>::get(net_b, who_b).is_some());
+        assert!(LastCommitment::<Test>::get(net_b, who_b).is_some());
+        assert!(LastBondsReset::<Test>::get(net_b, who_b).is_some());
+        assert!(RevealedCommitments::<Test>::get(net_b, who_b).is_some());
+        assert!(UsedSpaceOf::<Test>::get(net_b, who_b).is_some());
+        assert!(idx_after.contains(&(net_b, who_b)));
+
+        // Idempotency
+        Pallet::<Test>::purge_netuid(net_a);
+        assert_eq!(CommitmentOf::<Test>::iter_prefix(net_a).count(), 0);
+        assert!(!TimelockedIndex::<Test>::get().contains(&(net_a, who_a1)));
+    });
+}

pallets/subtensor/rpc/src/lib.rs

@@ -100,6 +100,8 @@ pub trait SubtensorCustomApi<BlockHash> {
         metagraph_index: Vec<u16>,
         at: Option<BlockHash>,
     ) -> RpcResult<Vec<u8>>;
+    #[method(name = "subnetInfo_getSubnetToPrune")]
+    fn get_subnet_to_prune(&self, at: Option<BlockHash>) -> RpcResult<Option<NetUid>>;
 }
 
 pub struct SubtensorCustom<C, P> {
@@ -489,4 +491,19 @@ where
             }
         }
     }
+
+    fn get_subnet_to_prune(
+        &self,
+        at: Option<<Block as BlockT>::Hash>,
+    ) -> RpcResult<Option<NetUid>> {
+        let api = self.client.runtime_api();
+        let at = at.unwrap_or_else(|| self.client.info().best_hash);
+
+        match api.get_subnet_to_prune(at) {
+            Ok(result) => Ok(result),
+            Err(e) => {
+                Err(Error::RuntimeError(format!("Unable to get subnet to prune: {e:?}")).into())
+            }
+        }
+    }
 }

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

@@ -46,6 +46,7 @@ sp_api::decl_runtime_apis! {
         fn get_subnet_state(netuid: NetUid) -> Option<SubnetState<AccountId32>>;
         fn get_selective_metagraph(netuid: NetUid, metagraph_indexes: Vec<u16>) -> Option<SelectiveMetagraph<AccountId32>>;
         fn get_selective_submetagraph(netuid: NetUid, subid: SubId, metagraph_indexes: Vec<u16>) -> Option<SelectiveMetagraph<AccountId32>>;
+        fn get_subnet_to_prune() -> Option<NetUid>;
     }
 
     pub trait StakeInfoRuntimeApi {