Delegate set claim type

pallets/subtensor/src/lib.rs

@@ -334,6 +334,8 @@ pub mod pallet {
         Swap,
         /// Keep all alpha emission.
         Keep,
+        /// Delegate choice to subnet.
+        Delegated,
     }
 
     /// Enum for the per-coldkey root claim frequency setting.
@@ -359,7 +361,11 @@ pub mod pallet {
     /// This is set by the user. Either swap to TAO or keep as alpha.
     #[pallet::type_value]
     pub fn DefaultRootClaimType<T: Config>() -> RootClaimTypeEnum {
-        RootClaimTypeEnum::default()
+        RootClaimTypeEnum::Delegated
+    }
+    #[pallet::type_value]
+    pub fn DefaultDelegateClaimType<T: Config>() -> RootClaimTypeEnum {
+        RootClaimTypeEnum::Keep
     }
 
     /// Default number of root claims per claim call.
@@ -2244,6 +2250,17 @@ pub mod pallet {
         ValueQuery,
         DefaultRootClaimType<T>,
     >;
+    #[pallet::storage] // -- MAP ( hotkey, netuid ) --> delegate_claim_type enum
+    pub type DelegateClaimType<T: Config> = StorageMap<
+        _,
+        Blake2_128Concat,
+        T::AccountId,
+        Identity,
+        u16,
+        RootClaimTypeEnum,
+        ValueQuery,
+        DefaultRootClaimType<T>,
+    >;
     #[pallet::storage] // --- MAP ( u64 ) --> coldkey | Maps coldkeys that have stake to an index
     pub type StakingColdkeysByIndex<T: Config> =
         StorageMap<_, Identity, u64, T::AccountId, OptionQuery>;

pallets/subtensor/src/macros/dispatches.rs

@@ -2421,5 +2421,41 @@ mod dispatches {
 
             Ok(())
         }
+
+        /// --- Sets delegate claim type for a hotkey on a subnet.
+        #[pallet::call_index(125)]
+        #[pallet::weight((
+            Weight::from_parts(5_711_000, 0).saturating_add(T::DbWeight::get().writes(1_u64)),
+            DispatchClass::Operational,
+            Pays::Yes
+        ))]
+        pub fn set_delegate_claim_type(
+            origin: OriginFor<T>,
+            hotkey: T::AccountId,
+            netuid: NetUid,
+            new_claim_type: RootClaimTypeEnum,
+        ) -> DispatchResult {
+            let coldkey: T::AccountId = ensure_signed(origin)?;
+            ensure!(
+                Self::coldkey_owns_hotkey(coldkey.clone(), hotkey.clone()),
+                Error::<T>::NonAssociatedColdKey
+            );
+
+            // Ensure the delegate claim type is not Delegated.
+            ensure!(
+                matches!(
+                    new_claim_type,
+                    RootClaimTypeEnum::Swap | RootClaimTypeEnum::Keep
+                ),
+                Error::<T>::InvalidRootClaimType
+            );
+
+            DelegateClaimType::<T>::insert((hotkey.clone(), netuid), new_claim_type.clone());
+            Self::deposit_event(Event::DelegateClaimTypeSet {
+                hotkey: hotkey.clone(),
+                root_claim_type: new_claim_type,
+            });
+            Ok(())
+        }
     }
 }

pallets/subtensor/src/macros/errors.rs

@@ -266,5 +266,7 @@ mod errors {
         InvalidRootClaimThreshold,
         /// Exceeded subnet limit number or zero.
         InvalidSubnetNumber,
+        /// Delegates cant set delegated as claim type
+        InvalidRootClaimType,
     }
 }

pallets/subtensor/src/macros/events.rs

@@ -468,6 +468,15 @@ mod events {
             root_claim_type: RootClaimTypeEnum,
         },
 
+        /// Root claim type for a coldkey has been set.
+        /// Parameters:
+        /// (coldkey, u8)
+        DelegateClaimTypeSet {
+            /// delegate hotkey
+            hotkey: T::AccountId,
+            root_claim_type: RootClaimTypeEnum,
+        },
+
         /// Subnet lease dividends have been distributed.
         SubnetLeaseDividendsDistributed {
             /// The lease ID

pallets/subtensor/src/staking/claim_root.rs

@@ -128,7 +128,7 @@ impl<T: Config> Pallet<T> {
         hotkey: &T::AccountId,
         coldkey: &T::AccountId,
         netuid: NetUid,
-        root_claim_type: RootClaimTypeEnum,
+        mut root_claim_type: RootClaimTypeEnum,
         ignore_minimum_condition: bool,
     ) {
         // Subtract the root claimed.
@@ -157,6 +157,11 @@ impl<T: Config> Pallet<T> {
             return; // no-op
         }
 
+        // If root_claim_type is Delegated, switch to the delegate's actual claim type.
+        if (root_claim_type == RootClaimTypeEnum::Delegated) {
+            root_claim_type = DelegateClaimType::<T>::get(hotkey, netuid);
+        }
+
         match root_claim_type {
             //  Increase stake on root
             RootClaimTypeEnum::Swap => {
@@ -170,11 +175,13 @@ impl<T: Config> Pallet<T> {
                     Ok(owed_tao) => owed_tao,
                     Err(err) => {
                         log::error!("Error swapping alpha for TAO: {err:?}");
-
                         return;
                     }
                 };
 
+                // Importantly measures swap as flow.
+                Self::record_tao_outflow(netuid, owed_tao);
+
                 Self::increase_stake_for_hotkey_and_coldkey_on_subnet(
                     hotkey,
                     coldkey,
@@ -189,14 +196,20 @@ impl<T: Config> Pallet<T> {
                 );
             }
             RootClaimTypeEnum::Keep => {
-                // Increase the stake with the alpha owned
+                // Increase the stake with the alpha owed
                 Self::increase_stake_for_hotkey_and_coldkey_on_subnet(
                     hotkey,
                     coldkey,
                     netuid,
                     owed_u64.into(),
                 );
             }
+            // Add Delegated arm for completeness, but it should never reach here due to switch above.
+            RootClaimTypeEnum::Delegated => {
+                // Should not reach here. Added for completeness.
+                log::error!("Delegated root_claim_type should have been switched. Skipping.");
+                return;
+            }
         };
 
         // Increase root claimed by owed amount.