Added root_claim_for

pallets/subtensor/src/macros/dispatches.rs

@@ -14,7 +14,6 @@ mod dispatches {
     use crate::MAX_CRV3_COMMIT_SIZE_BYTES;
     use crate::MAX_NUM_ROOT_CLAIMS;
     use crate::MAX_ROOT_CLAIM_THRESHOLD;
-    use crate::MAX_SUBNET_CLAIMS;
 
     /// Dispatchable functions allow users to interact with the pallet and invoke state changes.
     /// These functions materialize as "extrinsics", which are often compared to transactions.
@@ -2169,15 +2168,29 @@ mod dispatches {
         ) -> DispatchResultWithPostInfo {
             let coldkey: T::AccountId = ensure_signed(origin)?;
 
-            ensure!(!subnets.is_empty(), Error::<T>::InvalidSubnetNumber);
-            ensure!(
-                subnets.len() <= MAX_SUBNET_CLAIMS,
-                Error::<T>::InvalidSubnetNumber
-            );
+            let weight = Self::do_root_claim_checked(coldkey, subnets)?;
+            Ok((Some(weight), Pays::Yes).into())
+        }
 
-            Self::maybe_add_coldkey_index(&coldkey);
+        /// --- Claims the root emissions on behalf of any coldkey.
+        /// # Args:
+        /// * 'origin': any signed account; only authorizes (and pays for) the call.
+        /// * 'coldkey': the coldkey whose claims are settled; all realized value is credited here.
+        /// * 'subnets': the subnets to claim on (1..=MAX_SUBNET_CLAIMS).
+        ///
+        /// # Event:
+        /// * RootClaimed;
+        /// 	- On successfully claiming the root emissions for `coldkey`.
+        #[pallet::call_index(142)]
+        #[pallet::weight(<T as crate::pallet::Config>::WeightInfo::claim_root())]
+        pub fn claim_root_for(
+            origin: OriginFor<T>,
+            coldkey: T::AccountId,
+            subnets: BTreeSet<NetUid>,
+        ) -> DispatchResultWithPostInfo {
+            let _who: T::AccountId = ensure_signed(origin)?;
 
-            let weight = Self::do_root_claim(coldkey, Some(subnets))?;
+            let weight = Self::do_root_claim_checked(coldkey, subnets)?;
             Ok((Some(weight), Pays::Yes).into())
         }
 

pallets/subtensor/src/staking/claim_root.rs

@@ -345,6 +345,21 @@ impl<T: Config> Pallet<T> {
         }
     }
 
+    pub fn do_root_claim_checked(
+        coldkey: T::AccountId,
+        subnets: BTreeSet<NetUid>,
+    ) -> Result<Weight, DispatchError> {
+        ensure!(!subnets.is_empty(), Error::<T>::InvalidSubnetNumber);
+        ensure!(
+            subnets.len() <= crate::MAX_SUBNET_CLAIMS,
+            Error::<T>::InvalidSubnetNumber
+        );
+
+        Self::maybe_add_coldkey_index(&coldkey);
+
+        Self::do_root_claim(coldkey, Some(subnets))
+    }
+
     pub fn do_root_claim(
         coldkey: T::AccountId,
         subnets: Option<BTreeSet<NetUid>>,

pallets/subtensor/src/tests/claim_root.rs

@@ -588,6 +588,69 @@ fn test_claim_root_with_changed_stake() {
     });
 }
 
+#[test]
+fn test_claim_root_for_credits_target_not_caller() {
+    new_test_ext(1).execute_with(|| {
+        let owner_coldkey = U256::from(1001);
+        let hotkey = U256::from(1002);
+        let contract_coldkey = U256::from(1003);
+        let keeper = U256::from(2099);
+        let netuid = add_dynamic_network(&hotkey, &owner_coldkey);
+        remove_owner_registration_stake(netuid);
+
+        SubtensorModule::set_tao_weight(u64::MAX);
+
+        let root_stake = 2_000_000u64;
+        mock_increase_stake_for_hotkey_and_coldkey_on_subnet(
+            &hotkey,
+            &contract_coldkey,
+            NetUid::ROOT,
+            root_stake.into(),
+        );
+        mock_increase_stake_for_hotkey_and_coldkey_on_subnet(
+            &hotkey,
+            &owner_coldkey,
+            netuid,
+            10_000_000u64.into(),
+        );
+
+        SubtensorModule::distribute_emission(
+            netuid,
+            AlphaBalance::ZERO,
+            AlphaBalance::ZERO,
+            1_000_000u64.into(),
+            AlphaBalance::ZERO,
+        );
+        assert!(
+            RootClaimable::<Test>::get(hotkey).contains_key(&netuid),
+            "claimable must have accrued"
+        );
+
+        let root_of = |coldkey: &U256| -> u64 {
+            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+                &hotkey,
+                coldkey,
+                NetUid::ROOT,
+            )
+            .into()
+        };
+        let contract_root_before = root_of(&contract_coldkey);
+        assert_eq!(contract_root_before, root_stake);
+        assert_eq!(root_of(&keeper), 0);
+
+        assert_ok!(SubtensorModule::claim_root_for(
+            RuntimeOrigin::signed(keeper),
+            contract_coldkey,
+            BTreeSet::from([netuid])
+        ));
+
+        assert!(root_of(&contract_coldkey) > contract_root_before);
+        assert_eq!(root_of(&keeper), 0);
+        assert!(RootClaimed::<Test>::get((netuid, &hotkey, &contract_coldkey)) > 0);
+        assert_eq!(RootClaimed::<Test>::get((netuid, &hotkey, &keeper)), 0);
+    });
+}
+
 #[test]
 fn test_claim_root_with_drain_emissions_and_swap_claim_type() {
     new_test_ext(1).execute_with(|| {