Merge pull request #240 from opentensor/subnet_dereg_automatic_weighing

Automatically set 0 to deregistered subnets

Author: shibshib

docs/running-subtensor-locally.md

@@ -74,5 +74,4 @@ sudo ./scripts/run/subtensor.sh -e docker --network testnet --node-type archive
 ```
 
 ## Running on cloud
-
 We have not tested these installation scripts on any cloud service. In addition, if you are using Runpod cloud service, then note that this service is already [containerized](https://docs.runpod.io/pods/overview). Hence, the only option available to you is to compile from the source, as described in the above [Compiling your own binary](#compiling-your-own-binary) section. Note that these scripts have not been tested on Runpod.

pallets/subtensor/src/lib.rs

@@ -861,7 +861,7 @@ pub mod pallet {
         PowRegistrationAllowed(u16, bool), // --- Event created when POW registration is allowed/disallowed for a subnet.
         TempoSet(u16, u16),             // --- Event created when setting tempo on a network
         RAORecycledForRegistrationSet(u16, u64), // Event created when setting the RAO recycled for registration.
-        WeightsMinStake(u64),
+        WeightsMinStake(u64),           // --- Event created when min stake is set for validators to set weights.
         SenateRequiredStakePercentSet(u64), // Event created when setting the minimum required stake amount for senate registration.
         AdjustmentAlphaSet(u16, u64), // Event created when setting the adjustment alpha on a subnet.
         Faucet(T::AccountId, u64), // Event created when the facuet it called on the test net.
@@ -1666,7 +1666,6 @@ pub mod pallet {
             if Uids::<T>::contains_key(netuid, &hotkey) {
                 let uid = Self::get_uid_for_net_and_hotkey(netuid, &hotkey.clone()).unwrap();
                 let stake = Self::get_total_stake_for_hotkey(&hotkey);
-                if stake <= 20_000_000_000_000_000 { return 0; } // Blacklist weights transactions for low stake peers.
                 let current_block_number: u64 = Self::get_current_block_as_u64();
                 let default_priority: u64 =
                     current_block_number - Self::get_last_update_for_uid(netuid, uid as u16);

pallets/subtensor/src/root.rs

@@ -178,7 +178,7 @@ impl<T: Config> Pallet<T> {
     //
     // # Returns:
     // A 2D vector ('Vec<Vec<I32F32>>') where each entry [i][j] represents the weight of subnetwork
-    // 'j' with according to the preferences of key. 'j' within the root network.
+    // 'j' with according to the preferences of key. Validator 'i' within the root network.
     //
     pub fn get_root_weights() -> Vec<Vec<I64F64>> {
         // --- 0. The number of validators on the root network.
@@ -625,6 +625,7 @@ impl<T: Config> Pallet<T> {
 
                 Self::remove_network(netuid_to_prune);
                 log::debug!("remove_network: {:?}", netuid_to_prune,);
+                Self::deposit_event(Event::NetworkRemoved(netuid));
                 netuid_to_prune
             }
         };
@@ -821,9 +822,26 @@ impl<T: Config> Pallet<T> {
         let _ = Uids::<T>::clear_prefix(netuid, u32::max_value(), None);
         let _ = Keys::<T>::clear_prefix(netuid, u32::max_value(), None);
         let _ = Bonds::<T>::clear_prefix(netuid, u32::max_value(), None);
-        let _ = Weights::<T>::clear_prefix(netuid, u32::max_value(), None);
+      
+        // --- 9. Iterate over stored weights and fill the matrix.
+        for (uid_i, weights_i) in
+        <Weights<T> as IterableStorageDoubleMap<u16, u16, Vec<(u16, u16)>>>::iter_prefix(
+            Self::get_root_netuid(),
+        )
+        {
+            // Create a new vector to hold modified weights.
+            let mut modified_weights = weights_i.clone();
+            // Iterate over each weight entry to potentially update it.
+            for (subnet_id, weight) in modified_weights.iter_mut() {
+                if subnet_id == &netuid {
+                    // If the condition matches, modify the weight
+                    *weight = 0; // Set weight to 0 for the matching subnet_id.
+                }
+            }
+            Weights::<T>::insert(Self::get_root_netuid(), uid_i, modified_weights);
+        }
 
-        // --- 9. Remove various network-related parameters.
+        // --- 10. Remove various network-related parameters.
         Rank::<T>::remove(netuid);
         Trust::<T>::remove(netuid);
         Active::<T>::remove(netuid);
@@ -836,7 +854,7 @@ impl<T: Config> Pallet<T> {
         ValidatorPermit::<T>::remove(netuid);
         ValidatorTrust::<T>::remove(netuid);
 
-        // --- 10. Erase network parameters.
+        // --- 11. Erase network parameters.
         Tempo::<T>::remove(netuid);
         Kappa::<T>::remove(netuid);
         Difficulty::<T>::remove(netuid);
@@ -850,7 +868,7 @@ impl<T: Config> Pallet<T> {
         POWRegistrationsThisInterval::<T>::remove(netuid);
         BurnRegistrationsThisInterval::<T>::remove(netuid);
 
-        // --- 11. Add the balance back to the owner.
+        // --- 12. Add the balance back to the owner.
         Self::add_balance_to_coldkey_account(&owner_coldkey, reserved_amount_as_bal.unwrap());
         Self::set_subnet_locked_balance(netuid, 0);
         SubnetOwner::<T>::remove(netuid);
@@ -940,7 +958,7 @@ impl<T: Config> Pallet<T> {
             }
         });
 
-        log::info!("{:?}", netuids);
+        log::info!("Netuids Order: {:?}", netuids);
 
         match netuids.last() {
             Some(netuid) => *netuid,

pallets/subtensor/tests/root.rs

@@ -573,4 +573,105 @@ fn test_network_prune_results() {
         SubtensorModule::set_emission_values(&vec![1u16, 2u16, 3u16], vec![4u64, 5u64, 5u64]);
         assert_eq!(SubtensorModule::get_subnet_to_prune(), 1u16);
     });
+}
+
+
+#[test]
+fn test_weights_after_network_pruning() {
+    new_test_ext().execute_with(|| {
+        migration::migrate_create_root_network::<Test>();
+
+        assert_eq!(SubtensorModule::get_total_issuance(), 0);
+
+        // Set up N subnets, with max N + 1 allowed UIDs
+        let n: usize = 2;
+        let root_netuid: u16 = 0;
+        SubtensorModule::set_network_immunity_period(3);
+        SubtensorModule::set_max_registrations_per_block(root_netuid, n as u16);
+        SubtensorModule::set_max_subnets(n as u16);
+        SubtensorModule::set_weights_set_rate_limit(root_netuid, 0 as u64);
+
+        // No validators yet.
+        assert_eq!(SubtensorModule::get_subnetwork_n(root_netuid), 0);
+
+        for i in 0..n {
+
+            // Register a validator
+            let hot: U256 = U256::from(i);
+            let cold: U256 = U256::from(i);
+
+            SubtensorModule::add_balance_to_coldkey_account(&cold, 1_000_000_000_000);
+
+            // Register a network
+            assert_ok!(SubtensorModule::register_network(
+                <<Test as Config>::RuntimeOrigin>::signed(cold)
+            ));
+            
+            log::debug!("Adding network with netuid: {}", (i as u16) + 1);
+            assert!(SubtensorModule::if_subnet_exist((i as u16) + 1));
+            step_block(3);
+        }
+
+        // Register a validator in subnet 0
+        let hot: U256 = U256::from((n as u64) - 1);
+        let cold: U256 = U256::from((n as u64) - 1);
+
+        assert_ok!(SubtensorModule::root_register(
+            <<Test as Config>::RuntimeOrigin>::signed(cold),
+            hot
+        ));
+        assert_ok!(SubtensorModule::add_stake(
+            <<Test as Config>::RuntimeOrigin>::signed(cold),
+            hot,
+            1_000
+        ));
+        
+        // Let's give these subnets some weights
+        let uids: Vec<u16> = (0..(n as u16)+1).collect();
+        let values: Vec<u16> = vec![4u16, 2u16, 6u16];
+        log::info!("uids set: {:?}", uids);
+        log::info!("values set: {:?}", values);
+        log::info!("In netuid: {:?}", root_netuid);
+        assert_ok!(SubtensorModule::set_weights(
+            <<Test as Config>::RuntimeOrigin>::signed(hot),
+            root_netuid,
+            uids,
+            values,
+            0
+        ));
+
+        log::info!("Root network weights before extra network registration: {:?}", SubtensorModule::get_root_weights()); 
+        log::info!("Max subnets: {:?}", SubtensorModule::get_max_subnets());
+        let i = (n as u16) + 1;
+        let hot: U256 = U256::from(i);
+        let cold: U256 = U256::from(i);
+
+        SubtensorModule::add_balance_to_coldkey_account(&cold, 1_000_000_000_000_000_000);
+        let subnet_to_prune = SubtensorModule::get_subnet_to_prune();
+
+        // Subnet 1 should be pruned here.
+        assert_eq!(subnet_to_prune, 1);
+        log::info!("Removing subnet: {:?}", subnet_to_prune);
+
+        // Check that the weights have been set appropriately.
+        let latest_weights = SubtensorModule::get_root_weights();
+        log::info!("Weights before register network: {:?}", latest_weights);
+        // We expect subnet 1 to be deregistered as it is oldest and has lowest emissions
+        assert_eq!(latest_weights[0][1], 21845);
+
+        assert_ok!(SubtensorModule::register_network( 
+            <<Test as Config>::RuntimeOrigin>::signed(cold)
+        ));
+
+        // Subnet should not exist, as it would replace a previous subnet.
+        assert!(!SubtensorModule::if_subnet_exist((i as u16) + 1));
+        
+        log::info!("Root network weights: {:?}", SubtensorModule::get_root_weights()); 
+        
+        let latest_weights = SubtensorModule::get_root_weights();
+        log::info!("Weights after register network: {:?}", SubtensorModule::get_root_weights());
+
+        // Subnet 0 should be kicked, and thus its weight should be 0
+        assert_eq!(latest_weights[0][1], 0);
+    });
 }

runtime/src/lib.rs

@@ -121,7 +121,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
     //   `spec_version`, and `authoring_version` are the same between Wasm and native.
     // This value is set to 100 to notify Polkadot-JS App (https://polkadot.js.org/apps) to use
     //   the compatible custom types.
-    spec_version: 141,
+    spec_version: 142,
     impl_version: 1,
     apis: RUNTIME_API_VERSIONS,
     transaction_version: 1,