Introduce root claim threshold for subnets.

Author: shamil-gadelshin

pallets/subtensor/src/benchmarks.rs

@@ -1656,4 +1656,23 @@ mod pallet_benchmarks {
         #[extrinsic_call]
         _(RawOrigin::Root, 100);
     }
+
+    #[benchmark]
+    fn sudo_set_root_claim_threshold() {
+        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, 100);
+    }
 }

pallets/subtensor/src/lib.rs

@@ -58,6 +58,8 @@ pub const ALPHA_MAP_BATCH_SIZE: usize = 30;
 
 pub const MAX_NUM_ROOT_CLAIMS: u64 = 50;
 
+pub const MAX_ROOT_CLAIM_THRESHOLD: u64 = 10_000_000;
+
 #[allow(deprecated)]
 #[deny(missing_docs)]
 #[import_section(errors::errors)]
@@ -350,8 +352,8 @@ pub mod pallet {
     /// Default minimum root claim amount.
     /// This is the minimum amount of root claim that can be made.
     /// Any amount less than this will not be claimed.
-    pub fn DefaultMinRootClaimAmount<T: Config>() -> u64 {
-        500_000
+    pub fn DefaultMinRootClaimAmount<T: Config>() -> I96F32 {
+        500_000u64.into()
     }
 
     #[pallet::type_value]
@@ -1901,6 +1903,10 @@ pub mod pallet {
         ValueQuery,
     >;
 
+    #[pallet::storage] // --- MAP(netuid ) --> Root claim threshold
+    pub type RootClaimableThreshold<T: Config> =
+        StorageMap<_, Blake2_128Concat, NetUid, I96F32, ValueQuery, DefaultMinRootClaimAmount<T>>;
+
     #[pallet::storage] // --- MAP ( hot ) --> MAP(netuid ) --> claimable_dividends | Root claimable dividends.
     pub type RootClaimable<T: Config> = StorageMap<
         _,

pallets/subtensor/src/macros/dispatches.rs

@@ -12,9 +12,9 @@ mod dispatches {
     use sp_core::ecdsa::Signature;
     use sp_runtime::{Percent, traits::Saturating};
 
-    use crate::MAX_NUM_ROOT_CLAIMS;
-
     use crate::MAX_CRV3_COMMIT_SIZE_BYTES;
+    use crate::MAX_NUM_ROOT_CLAIMS;
+    use crate::MAX_ROOT_CLAIM_THRESHOLD;
     /// Dispatchable functions allow users to interact with the pallet and invoke state changes.
     /// These functions materialize as "extrinsics", which are often compared to transactions.
     /// Dispatchable functions must be annotated with a weight and must return a DispatchResult.
@@ -2484,5 +2484,37 @@ mod dispatches {
 
             Ok(())
         }
+
+        /// --- Sets the root claim type for the coldkey.
+        /// # Args:
+        /// * 'origin': (<T as frame_system::Config>Origin):
+        /// 	- The signature of the caller's coldkey.
+        ///
+        /// # Event:
+        /// * RootClaimTypeSet;
+        /// 	- On the successfully setting the root claim type for the coldkey.
+        ///
+        #[pallet::call_index(124)]
+        #[pallet::weight((
+            Weight::from_parts(4_000_000, 0).saturating_add(T::DbWeight::get().writes(1_u64)),
+            DispatchClass::Operational,
+            Pays::Yes
+        ))]
+        pub fn sudo_set_root_claim_threshold(
+            origin: OriginFor<T>,
+            netuid: NetUid,
+            new_value: u64,
+        ) -> DispatchResult {
+            Self::ensure_subnet_owner_or_root(origin, netuid)?;
+
+            ensure!(
+                new_value <= I96F32::from(MAX_ROOT_CLAIM_THRESHOLD),
+                Error::<T>::InvalidRootClaimThreshold
+            );
+
+            RootClaimableThreshold::<T>::set(netuid, new_value.into());
+
+            Ok(())
+        }
     }
 }

pallets/subtensor/src/macros/errors.rs

@@ -266,5 +266,7 @@ mod errors {
         ChildParentInconsistency,
         /// Invalid number of root claims
         InvalidNumRootClaim,
+        /// Invalid value of root claim threshold
+        InvalidRootClaimThreshold,
     }
 }

pallets/subtensor/src/staking/claim_root.rs

@@ -135,7 +135,7 @@ impl<T: Config> Pallet<T> {
         let owed: I96F32 = Self::get_root_owed_for_hotkey_coldkey_float(hotkey, coldkey, netuid);
 
         if !ignore_minimum_condition
-            && owed < I96F32::saturating_from_num(DefaultMinRootClaimAmount::<T>::get())
+            && owed < I96F32::saturating_from_num(RootClaimableThreshold::<T>::get(&netuid))
         {
             log::debug!(
                 "root claim on subnet {netuid} is skipped: {owed:?} for h={hotkey:?},c={coldkey:?} "

pallets/subtensor/src/tests/claim_root.rs

@@ -4,14 +4,17 @@ use crate::tests::mock::{
     RuntimeOrigin, SubtensorModule, Test, add_dynamic_network, new_test_ext, run_to_block,
 };
 use crate::{
-    Error, MAX_NUM_ROOT_CLAIMS, NetworksAdded, NumRootClaim, NumStakingColdkeys,
-    PendingRootAlphaDivs, RootClaimable, StakingColdkeys, StakingColdkeysByIndex, SubnetAlphaIn,
-    SubnetMechanism, SubnetTAO, SubtokenEnabled, Tempo, pallet,
+    DefaultMinRootClaimAmount, Error, MAX_NUM_ROOT_CLAIMS, MAX_ROOT_CLAIM_THRESHOLD, NetworksAdded,
+    NumRootClaim, NumStakingColdkeys, PendingRootAlphaDivs, RootClaimable, RootClaimableThreshold,
+    StakingColdkeys, StakingColdkeysByIndex, SubnetAlphaIn, SubnetMechanism, SubnetTAO,
+    SubtokenEnabled, Tempo, pallet,
 };
 use crate::{RootClaimType, RootClaimTypeEnum, RootClaimed};
 use approx::assert_abs_diff_eq;
+use frame_support::dispatch::RawOrigin;
 use frame_support::pallet_prelude::Weight;
-use frame_support::{assert_noop, assert_ok};
+use frame_support::traits::Get;
+use frame_support::{assert_err, assert_noop, assert_ok};
 use sp_core::{H256, U256};
 use sp_runtime::DispatchError;
 use substrate_fixed::types::{I96F32, U96F32};
@@ -1297,6 +1300,61 @@ fn test_claim_root_on_network_deregistration() {
         assert!(!RootClaimed::<Test>::contains_key((
             &hotkey, &coldkey, netuid
         )));
-        assert!(!RootClaimable::<Test>::get(&hotkey).contains_key(&netuid));
+        assert!(!RootClaimable::<Test>::get(hotkey).contains_key(&netuid));
+    });
+}
+
+#[test]
+fn test_claim_root_threshold() {
+    new_test_ext(1).execute_with(|| {
+        let owner_coldkey = U256::from(1001);
+        let hotkey = U256::from(1002);
+        let netuid = add_dynamic_network(&hotkey, &owner_coldkey);
+
+        assert_eq!(
+            RootClaimableThreshold::<Test>::get(netuid),
+            DefaultMinRootClaimAmount::<Test>::get()
+        );
+
+        let threshold = 1000u64;
+        assert_ok!(SubtensorModule::sudo_set_root_claim_threshold(
+            RawOrigin::Root.into(),
+            netuid,
+            threshold
+        ));
+        assert_eq!(
+            RootClaimableThreshold::<Test>::get(netuid),
+            I96F32::from(threshold)
+        );
+
+        let threshold = 2000u64;
+        assert_ok!(SubtensorModule::sudo_set_root_claim_threshold(
+            RawOrigin::Signed(owner_coldkey).into(),
+            netuid,
+            threshold
+        ));
+        assert_eq!(
+            RootClaimableThreshold::<Test>::get(netuid),
+            I96F32::from(threshold)
+        );
+
+        // Errors
+        assert_err!(
+            SubtensorModule::sudo_set_root_claim_threshold(
+                RawOrigin::Signed(hotkey).into(),
+                netuid,
+                threshold
+            ),
+            DispatchError::BadOrigin,
+        );
+
+        assert_err!(
+            SubtensorModule::sudo_set_root_claim_threshold(
+                RawOrigin::Signed(owner_coldkey).into(),
+                netuid,
+                MAX_ROOT_CLAIM_THRESHOLD + 1
+            ),
+            Error::<Test>::InvalidRootClaimThreshold,
+        );
     });
 }