Merge pull request #1358 from opentensor/cleanup/remove-unused-after-rao

Cleanup/remove unused after rao

Author: sam0x17

pallets/admin-utils/src/benchmarking.rs

@@ -272,13 +272,5 @@ mod benchmarks {
 		_(RawOrigin::Root, 1u16/*netuid*/, true/*enabled*/)/*set_commit_reveal_weights_enabled*/;
     }
 
-    #[benchmark]
-    fn sudo_set_network_max_stake() {
-        pallet_subtensor::Pallet::<T>::init_new_network(1u16 /*netuid*/, 1u16 /*tempo*/);
-
-        #[extrinsic_call]
-        _(RawOrigin::Root, 1u16/*netuid*/, 1_000_000_000_000_000u64/*max_stake*/)/*sudo_set_network_max_stake*/;
-    }
-
     //impl_benchmark_test_suite!(AdminUtils, crate::mock::new_test_ext(), crate::mock::Test);
 }

pallets/admin-utils/src/lib.rs

@@ -910,12 +910,8 @@ pub mod pallet {
 			DispatchClass::Operational,
 			Pays::No
 		))]
-        pub fn sudo_set_subnet_limit(origin: OriginFor<T>, max_subnets: u16) -> DispatchResult {
+        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!("SubnetLimit( max_subnets: {:?} ) ", max_subnets);
-
             Ok(())
         }
 
@@ -1155,22 +1151,11 @@ pub mod pallet {
         #[pallet::weight((0, DispatchClass::Operational, Pays::No))]
         pub fn sudo_set_network_max_stake(
             origin: OriginFor<T>,
-            netuid: u16,
-            max_stake: u64,
+            _netuid: u16,
+            _max_stake: u64,
         ) -> DispatchResult {
             // Ensure the call is made by the root account
             ensure_root(origin)?;
-
-            // Set the new maximum stake for the specified network
-            pallet_subtensor::Pallet::<T>::set_network_max_stake(netuid, max_stake);
-
-            // Log the change
-            log::trace!(
-                "NetworkMaxStakeSet( netuid: {:?}, max_stake: {:?} )",
-                netuid,
-                max_stake
-            );
-
             Ok(())
         }
 

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

@@ -123,14 +123,14 @@ parameter_types! {
     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.
-    pub const InitialSubnetLimit: u16 = 10; // Max 10 subnets.
+    // pub const InitialSubnetLimit: u16 = 10; // (DEPRECATED)
     pub const InitialNetworkRateLimit: u64 = 0;
     pub const InitialKeySwapCost: u64 = 1_000_000_000;
     pub const InitialAlphaHigh: u16 = 58982; // Represents 0.9 as per the production default
     pub const InitialAlphaLow: u16 = 45875; // Represents 0.7 as per the production default
     pub const InitialLiquidAlphaOn: bool = false; // Default value for LiquidAlphaOn
     // pub const InitialHotkeyEmissionTempo: u64 = 1; // (DEPRECATED)
-    pub const InitialNetworkMaxStake: u64 = u64::MAX; // Maximum possible value for u64, this make the make stake infinity
+    // pub const InitialNetworkMaxStake: u64 = u64::MAX; // (DEPRECATED)
     pub const InitialColdkeySwapScheduleDuration: u64 = 5 * 24 * 60 * 60 / 12; // 5 days
     pub const InitialDissolveNetworkScheduleDuration: u64 = 5 * 24 * 60 * 60 / 12; // 5 days
     pub const InitialTaoWeight: u64 = u64::MAX/10; // 10% global weight.
@@ -188,14 +188,11 @@ impl pallet_subtensor::Config for Test {
     type InitialNetworkMinLockCost = InitialNetworkMinLockCost;
     type InitialSubnetOwnerCut = InitialSubnetOwnerCut;
     type InitialNetworkLockReductionInterval = InitialNetworkLockReductionInterval;
-    type InitialSubnetLimit = InitialSubnetLimit;
     type InitialNetworkRateLimit = InitialNetworkRateLimit;
     type KeySwapCost = InitialKeySwapCost;
     type AlphaHigh = InitialAlphaHigh;
     type AlphaLow = InitialAlphaLow;
     type LiquidAlphaOn = InitialLiquidAlphaOn;
-    // type InitialHotkeyEmissionTempo = InitialHotkeyEmissionTempo; // (DEPRECATED)
-    type InitialNetworkMaxStake = InitialNetworkMaxStake;
     type Preimages = ();
     type InitialColdkeySwapScheduleDuration = InitialColdkeySwapScheduleDuration;
     type InitialDissolveNetworkScheduleDuration = InitialDissolveNetworkScheduleDuration;

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

@@ -850,30 +850,6 @@ fn test_sudo_set_rao_recycled() {
     });
 }
 
-#[test]
-fn test_sudo_set_subnet_limit() {
-    new_test_ext().execute_with(|| {
-        let netuid: u16 = 1;
-        let to_be_set: u16 = 10;
-        add_network(netuid, 10);
-
-        let init_value: u16 = SubtensorModule::get_max_subnets();
-        assert_eq!(
-            AdminUtils::sudo_set_subnet_limit(
-                <<Test as Config>::RuntimeOrigin>::signed(U256::from(1)),
-                to_be_set
-            ),
-            Err(DispatchError::BadOrigin)
-        );
-        assert_eq!(SubtensorModule::get_max_subnets(), init_value);
-        assert_ok!(AdminUtils::sudo_set_subnet_limit(
-            <<Test as Config>::RuntimeOrigin>::root(),
-            to_be_set
-        ));
-        assert_eq!(SubtensorModule::get_max_subnets(), to_be_set);
-    });
-}
-
 #[test]
 fn test_sudo_set_network_lock_reduction_interval() {
     new_test_ext().execute_with(|| {

pallets/subtensor/src/coinbase/root.rs

@@ -70,31 +70,6 @@ impl<T: Config> Pallet<T> {
         false
     }
 
-    /// Sets the emission values for each netuid
-    ///
-    pub fn set_emission_values(netuids: &[u16], emission: Vec<u64>) -> Result<(), &'static str> {
-        log::debug!(
-            "set_emission_values: netuids: {:?} emission:{:?}",
-            netuids,
-            emission
-        );
-
-        // Be careful this function can fail.
-        if Self::contains_invalid_root_uids(netuids) {
-            log::error!("set_emission_values: contains_invalid_root_uids");
-            return Err("Invalid netuids");
-        }
-        if netuids.len() != emission.len() {
-            log::error!("set_emission_values: netuids.len() != emission.len()");
-            return Err("netuids and emission must have the same length");
-        }
-        for (netuid_i, emission_i) in netuids.iter().zip(emission) {
-            log::debug!("set netuid:{:?} emission:{:?}", netuid_i, emission_i);
-            EmissionValues::<T>::insert(*netuid_i, emission_i);
-        }
-        Ok(())
-    }
-
     /// Retrieves weight matrix associated with the root network.
     ///  Weights represent the preferences for each subnetwork.
     ///
@@ -577,7 +552,6 @@ impl<T: Config> Pallet<T> {
         MaxAllowedUids::<T>::remove(netuid);
         ImmunityPeriod::<T>::remove(netuid);
         ActivityCutoff::<T>::remove(netuid);
-        EmissionValues::<T>::remove(netuid);
         MaxWeightsLimit::<T>::remove(netuid);
         MinAllowedWeights::<T>::remove(netuid);
         RegistrationsThisInterval::<T>::remove(netuid);
@@ -647,55 +621,6 @@ impl<T: Config> Pallet<T> {
         lock_cost
     }
 
-    /// This function is used to determine which subnet to prune when the total number of networks has reached the limit.
-    /// It iterates over all the networks and finds the oldest subnet with the minimum emission value that is not in the immunity period.
-    ///
-    /// # Returns:
-    /// * 'u16':
-    ///     - The uid of the network to be pruned.
-    ///
-    pub fn get_subnet_to_prune() -> u16 {
-        let mut netuids: Vec<u16> = vec![];
-        let current_block = Self::get_current_block_as_u64();
-
-        // Even if we don't have a root subnet, this still works
-        for netuid in NetworksAdded::<T>::iter_keys_from(NetworksAdded::<T>::hashed_key_for(0)) {
-            if current_block.saturating_sub(Self::get_network_registered_block(netuid))
-                < Self::get_network_immunity_period()
-            {
-                continue;
-            }
-
-            // This iterator seems to return them in order anyways, so no need to sort by key
-            netuids.push(netuid);
-        }
-
-        // Now we sort by emission, and then by subnet creation time.
-        netuids.sort_by(|a, b| {
-            use sp_std::cmp::Ordering;
-
-            match Self::get_emission_value(*b).cmp(&Self::get_emission_value(*a)) {
-                Ordering::Equal => {
-                    if Self::get_network_registered_block(*b)
-                        < Self::get_network_registered_block(*a)
-                    {
-                        Ordering::Less
-                    } else {
-                        Ordering::Equal
-                    }
-                }
-                v => v,
-            }
-        });
-
-        log::debug!("Netuids Order: {:?}", netuids);
-
-        match netuids.last() {
-            Some(netuid) => *netuid,
-            None => 0,
-        }
-    }
-
     pub fn get_network_registered_block(netuid: u16) -> u64 {
         NetworkRegisteredAt::<T>::get(netuid)
     }

pallets/subtensor/src/lib.rs

@@ -501,11 +501,6 @@ pub mod pallet {
         T::InitialSubnetOwnerCut::get()
     }
     #[pallet::type_value]
-    /// Default value for subnet limit.
-    pub fn DefaultSubnetLimit<T: Config>() -> u16 {
-        T::InitialSubnetLimit::get()
-    }
-    #[pallet::type_value]
     /// Default value for network rate limit.
     pub fn DefaultNetworkRateLimit<T: Config>() -> u64 {
         if cfg!(feature = "pow-faucet") {
@@ -514,11 +509,6 @@ pub mod pallet {
         T::InitialNetworkRateLimit::get()
     }
     #[pallet::type_value]
-    /// Default value for emission values.
-    pub fn DefaultEmissionValues<T: Config>() -> u64 {
-        0
-    }
-    #[pallet::type_value]
     /// Default value for pending emission.
     pub fn DefaultPendingEmission<T: Config>() -> u64 {
         0
@@ -728,11 +718,6 @@ pub mod pallet {
     pub fn DefaultAlphaValues<T: Config>() -> (u16, u16) {
         (45875, 58982)
     }
-    #[pallet::type_value]
-    /// Default value for network max stake.
-    pub fn DefaultNetworkMaxStake<T: Config>() -> u64 {
-        T::InitialNetworkMaxStake::get()
-    }
 
     #[pallet::type_value]
     /// Default value for coldkey swap schedule duration
@@ -1055,9 +1040,6 @@ pub mod pallet {
     pub type MaxRegistrationsPerBlock<T> =
         StorageMap<_, Identity, u16, u16, ValueQuery, DefaultMaxRegistrationsPerBlock<T>>;
     #[pallet::storage]
-    /// --- ITEM( maximum_number_of_networks )
-    pub type SubnetLimit<T> = StorageValue<_, u16, ValueQuery, DefaultSubnetLimit<T>>;
-    #[pallet::storage]
     /// --- ITEM( total_number_of_existing_networks )
     pub type TotalNetworks<T> = StorageValue<_, u16, ValueQuery>;
     #[pallet::storage]
@@ -1152,10 +1134,6 @@ pub mod pallet {
     pub type NetworkRegisteredAt<T: Config> =
         StorageMap<_, Identity, u16, u64, ValueQuery, DefaultNetworkRegisteredAt<T>>;
     #[pallet::storage]
-    /// --- MAP ( netuid ) --> emission_values
-    pub type EmissionValues<T> =
-        StorageMap<_, Identity, u16, u64, ValueQuery, DefaultEmissionValues<T>>;
-    #[pallet::storage]
     /// --- MAP ( netuid ) --> pending_emission
     pub type PendingEmission<T> =
         StorageMap<_, Identity, u16, u64, ValueQuery, DefaultPendingEmission<T>>;
@@ -1324,10 +1302,6 @@ pub mod pallet {
     ///  MAP ( netuid ) --> (alpha_low, alpha_high)
     pub type AlphaValues<T> =
         StorageMap<_, Identity, u16, (u16, u16), ValueQuery, DefaultAlphaValues<T>>;
-    /// MAP ( netuid ) --> max stake allowed on a subnet.
-    #[pallet::storage]
-    pub type NetworkMaxStake<T> =
-        StorageMap<_, Identity, u16, u64, ValueQuery, DefaultNetworkMaxStake<T>>;
 
     /// =======================================
     /// ==== Subnetwork Consensus Storage  ====

pallets/subtensor/src/macros/config.rs

@@ -180,9 +180,6 @@ mod config {
         /// Initial lock reduction interval.
         #[pallet::constant]
         type InitialNetworkLockReductionInterval: Get<u64>;
-        /// Initial max allowed subnets
-        #[pallet::constant]
-        type InitialSubnetLimit: Get<u16>;
         /// Initial network creation rate limit
         #[pallet::constant]
         type InitialNetworkRateLimit: Get<u64>;
@@ -198,9 +195,6 @@ mod config {
         /// A flag to indicate if Liquid Alpha is enabled.
         #[pallet::constant]
         type LiquidAlphaOn: Get<bool>;
-        /// Initial network max stake.
-        #[pallet::constant]
-        type InitialNetworkMaxStake: Get<u64>;
         // /// Initial hotkey emission tempo.
         // #[pallet::constant]
         // type InitialHotkeyEmissionTempo: Get<u64>;

pallets/subtensor/src/macros/events.rs

@@ -65,8 +65,6 @@ mod events {
         AxonServed(u16, T::AccountId),
         /// the prometheus server information is added to the network.
         PrometheusServed(u16, T::AccountId),
-        /// emission ratios for all networks is set.
-        EmissionValuesSet(),
         /// a hotkey has become a delegate.
         DelegateAdded(T::AccountId, T::AccountId, u16),
         /// the default take is set.
@@ -124,7 +122,7 @@ mod events {
         /// the network minimum locking cost is set.
         NetworkMinLockCostSet(u64),
         /// the maximum number of subnets is set
-        SubnetLimitSet(u16),
+        // SubnetLimitSet(u16),
         /// the lock cost reduction is set
         NetworkLockCostReductionIntervalSet(u64),
         /// the take for a delegate is decreased.
@@ -193,8 +191,8 @@ mod events {
         SetChildren(T::AccountId, u16, Vec<(u64, T::AccountId)>),
         // /// The hotkey emission tempo has been set
         // HotkeyEmissionTempoSet(u64),
-        /// The network maximum stake has been set
-        NetworkMaxStakeSet(u16, u64),
+        // /// The network maximum stake has been set
+        // NetworkMaxStakeSet(u16, u64),
         /// The identity of a coldkey has been set
         ChainIdentitySet(T::AccountId),
         /// The identity of a subnet has been set

pallets/subtensor/src/macros/hooks.rs

@@ -79,7 +79,9 @@ mod hooks {
 				// Set the min difficulty across all subnets to a new minimum
 				.saturating_add(migrations::migrate_set_min_difficulty::migrate_set_min_difficulty::<T>())
                 // Remove Stake map entries
-				.saturating_add(migrations::migrate_remove_stake_map::migrate_remove_stake_map::<T>());
+				.saturating_add(migrations::migrate_remove_stake_map::migrate_remove_stake_map::<T>())
+                // Remove unused maps entries
+				.saturating_add(migrations::migrate_remove_unused_maps_and_values::migrate_remove_unused_maps_and_values::<T>());
             weight
         }
 

pallets/subtensor/src/migrations/migrate_delete_subnet_21.rs

@@ -103,7 +103,6 @@ pub fn migrate_delete_subnet_21<T: Config>() -> Weight {
         MaxAllowedUids::<T>::remove(netuid);
         ImmunityPeriod::<T>::remove(netuid);
         ActivityCutoff::<T>::remove(netuid);
-        EmissionValues::<T>::remove(netuid);
         MaxWeightsLimit::<T>::remove(netuid);
         MinAllowedWeights::<T>::remove(netuid);
         RegistrationsThisInterval::<T>::remove(netuid);