Merge branch 'main' of https://github.com/opentensor/subtensor into improved_subnet_owener_power

Author: unconst

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/admin-utils/src/lib.rs

@@ -701,6 +701,16 @@ pub mod pallet {
 			T::Subtensor::set_rao_recycled(netuid, rao_recycled);
 			Ok(())
 		}
+
+		#[pallet::call_index(42)]
+		#[pallet::weight((0, DispatchClass::Operational, Pays::No))]
+		pub fn sudo_set_weights_min_stake( origin: OriginFor<T>, min_stake: u64 ) -> DispatchResult 
+		{
+			ensure_root(origin)?;
+			T::Subtensor::set_weights_min_stake(min_stake);
+			Ok(())
+		}
+
     }
 }
 
@@ -785,4 +795,5 @@ pub trait SubtensorInterface<AccountId, Balance, RuntimeOrigin>
 	fn set_adjustment_interval(netuid: u16, adjustment_interval: u16);
 	fn set_weights_set_rate_limit(netuid: u16, weights_set_rate_limit: u64);
 	fn init_new_network(netuid: u16, tempo: u16);
+	fn set_weights_min_stake(min_stake: u64);
 }

pallets/admin-utils/tests/mock.rs

@@ -478,6 +478,11 @@ impl pallet_admin_utils::SubtensorInterface<AccountId, Balance, RuntimeOrigin> f
     {
         SubtensorModule::init_new_network(netuid, tempo);
     }
+
+    fn set_weights_min_stake( min_stake: u64 )
+    {
+        SubtensorModule::set_weights_min_stake( min_stake );
+    }
 }
 
 impl pallet_admin_utils::Config for Test {

pallets/admin-utils/tests/tests.rs

@@ -684,6 +684,34 @@ fn test_sudo_set_max_allowed_validators() {
     });
 }
 
+
+#[test]
+fn test_sudo_set_weights_min_stake() {
+    new_test_ext().execute_with(|| {
+        let to_be_set: u64 = 10;
+        let init_value: u64 = SubtensorModule::get_weights_min_stake();
+        assert_eq!(
+            AdminUtils::sudo_set_weights_min_stake(
+                <<Test as Config>::RuntimeOrigin>::signed(U256::from(1)),
+                to_be_set
+            ),
+            Err(DispatchError::BadOrigin.into())
+        );
+        assert_eq!(
+            SubtensorModule::get_weights_min_stake(),
+            init_value
+        );
+        assert_ok!(AdminUtils::sudo_set_weights_min_stake(
+            <<Test as Config>::RuntimeOrigin>::root(),
+            to_be_set
+        ));
+        assert_eq!(
+            SubtensorModule::get_weights_min_stake(),
+            to_be_set
+        );
+    });
+}
+
 #[test]
 fn test_sudo_set_bonds_moving_average() {
     new_test_ext().execute_with(|| {

pallets/subtensor/src/lib.rs

@@ -16,6 +16,7 @@ use frame_support::{
 
 use codec::{Decode, Encode};
 use frame_support::sp_runtime::transaction_validity::ValidTransaction;
+use frame_support::sp_runtime::transaction_validity::InvalidTransaction;
 use scale_info::TypeInfo;
 use sp_runtime::{
     traits::{DispatchInfoOf, Dispatchable, PostDispatchInfoOf, SignedExtension},
@@ -641,7 +642,13 @@ pub mod pallet {
     pub fn DefaultAdjustmentAlpha<T: Config>() -> u64 {
         T::InitialAdjustmentAlpha::get()
     }
+    #[pallet::type_value]
+    pub fn DefaultWeightsMinStake<T: Config>() -> u64 {
+        0
+    }
 
+    #[pallet::storage] // ITEM( weights_min_stake ) 
+    pub type WeightsMinStake<T> = StorageValue<_, u64, ValueQuery, DefaultWeightsMinStake<T>>;
     #[pallet::storage] // --- MAP ( netuid ) --> Rho
     pub type Rho<T> = StorageMap<_, Identity, u16, u16, ValueQuery, DefaultRho<T>>;
     #[pallet::storage] // --- MAP ( netuid ) --> Kappa
@@ -854,6 +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),           // --- 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.
@@ -878,6 +886,7 @@ pub mod pallet {
         NotRegistered, // ---- Thrown when the caller requests setting or removing data from a neuron which does not exist in the active set.
         NonAssociatedColdKey, // ---- Thrown when a stake, unstake or subscribe request is made by a coldkey which is not associated with the hotkey account.
         NotEnoughStaketoWithdraw, // ---- Thrown when the caller requests removing more stake than there exists in the staking account. See: fn remove_stake.
+        NotEnoughStakeToSetWeights, // ---- Thrown when the caller requests to set weights but has less than WeightsMinStake
         NotEnoughBalanceToStake, //  ---- Thrown when the caller requests adding more stake than there exists in the cold key account. See: fn add_stake
         BalanceWithdrawalError, // ---- Thrown when the caller tries to add stake, but for some reason the requested amount could not be withdrawn from the coldkey account.
         NoValidatorPermit, // ---- Thrown when the caller attempts to set non-self weights without being a permitted validator.
@@ -1656,13 +1665,43 @@ pub mod pallet {
         pub fn get_priority_set_weights(hotkey: &T::AccountId, netuid: u16) -> u64 {
             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);
                 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);
                 return default_priority + u32::max_value() as u64;
             }
             return 0;
         }
+
+        // --- Is the caller allowed to set weights
+        pub fn check_weights_min_stake(hotkey: &T::AccountId) -> bool {
+            // Blacklist weights transactions for low stake peers.
+            if Self::get_total_stake_for_hotkey(&hotkey) >= Self::get_weights_min_stake() { 
+                return true; 
+            } else {
+                return false;
+            } 
+        }
+
+        pub fn checked_allowed_register( netuid: u16 ) -> bool {
+            if netuid == Self::get_root_netuid() {
+                return false;
+            }
+            if !Self::if_subnet_exist(netuid) {
+                return false;
+            }
+            if !Self::get_network_registration_allowed(netuid) {
+                return false;
+            }
+            if Self::get_registrations_this_block(netuid) >= Self::get_max_registrations_per_block(netuid) {
+                return false;
+            }
+            if Self::get_registrations_this_interval(netuid) >= Self::get_target_registrations_per_interval(netuid) * 3 {
+                return false;
+            }
+            true
+        }
     }
 }
 
@@ -1705,11 +1744,13 @@ where
     }
 
     pub fn get_priority_set_weights(who: &T::AccountId, netuid: u16) -> u64 {
-        // Return the non vanilla priority for a set weights call.
-
         return Pallet::<T>::get_priority_set_weights(who, netuid);
     }
 
+    pub fn check_weights_min_stake( who: &T::AccountId ) -> bool {
+        Pallet::<T>::check_weights_min_stake(who)
+    }
+
     pub fn u64_to_balance(
         input: u64,
     ) -> Option<
@@ -1750,12 +1791,16 @@ where
     ) -> TransactionValidity {
         match call.is_sub_type() {
             Some(Call::set_weights { netuid, .. }) => {
-                let priority: u64 = Self::get_priority_set_weights(who, *netuid);
-                Ok(ValidTransaction {
-                    priority: priority,
-                    longevity: 1,
-                    ..Default::default()
-                })
+                if Self::check_weights_min_stake( who ) {
+                    let priority: u64 = Self::get_priority_set_weights(who, *netuid);
+                    Ok(ValidTransaction {
+                        priority: priority,
+                        longevity: 1,
+                        ..Default::default()
+                    })
+                } else {
+                    return Err(InvalidTransaction::Call.into());
+                }
             }
             Some(Call::add_stake { .. }) => Ok(ValidTransaction {
                 priority: Self::get_priority_vanilla(),
@@ -1925,4 +1970,4 @@ impl<T, H, P> CollectiveInterface<T, H, P> for () {
     fn add_vote(_: &T, _: H, _: P, _: bool) -> Result<bool, DispatchError> {
         Ok(true)
     }
-}
+}

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_to_prune));
                 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/src/utils.rs

@@ -133,6 +133,10 @@ impl<T: Config> Pallet<T> {
             ValidatorPermit::<T>::insert(netuid, updated_validator_permit);
         }
     }
+    pub fn set_weights_min_stake( min_stake: u64 ) {
+        WeightsMinStake::<T>::put( min_stake );
+        Self::deposit_event(Event::WeightsMinStake(min_stake));
+    }
 
     pub fn get_rank_for_uid(netuid: u16, uid: u16) -> u16 {
         let vec = Rank::<T>::get(netuid);
@@ -222,6 +226,9 @@ impl<T: Config> Pallet<T> {
             return false;
         }
     }
+    pub fn get_weights_min_stake( ) -> u64 {
+        WeightsMinStake::<T>::get()
+    }
 
     // ============================
     // ==== Subnetwork Getters ====