Delegate set claim type

pallets/subtensor/src/lib.rs

@@ -339,6 +339,8 @@ pub mod pallet {
             /// Subnets to keep alpha emissions (swap everything else).
             subnets: BTreeSet<NetUid>,
         },
+        /// Delegate choice to subnet.
+        Delegated,
     }
 
     /// Default minimum root claim amount.
@@ -354,7 +356,12 @@ 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
+    }
+    /// Default value for delegate claim type storage
+    #[pallet::type_value]
+    pub fn DefaultValidatorClaimType<T: Config>() -> RootClaimTypeEnum {
+        RootClaimTypeEnum::Keep
     }
 
     /// Default number of root claims per claim call.
@@ -2237,6 +2244,17 @@ pub mod pallet {
         ValueQuery,
         DefaultRootClaimType<T>,
     >;
+    #[pallet::storage] // -- MAP ( hotkey, netuid ) --> delegate_claim_type enum
+    pub type ValidatorClaimType<T: Config> = StorageDoubleMap<
+        _,
+        Blake2_128Concat,
+        T::AccountId,
+        Identity,
+        NetUid,
+        RootClaimTypeEnum,
+        ValueQuery,
+        DefaultValidatorClaimType<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

@@ -2431,5 +2431,42 @@ 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_validator_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, &hotkey),
+                Error::<T>::NonAssociatedColdKey
+            );
+
+            // Ensure the delegate claim type is not Delegated.
+            ensure!(
+                matches!(
+                    new_claim_type,
+                    RootClaimTypeEnum::Keep | RootClaimTypeEnum::Swap
+                ),
+                Error::<T>::InvalidRootClaimType
+            );
+
+            ValidatorClaimType::<T>::insert(hotkey.clone(), netuid, new_claim_type.clone());
+            Self::deposit_event(Event::ValidatorClaimTypeSet {
+                hotkey: hotkey.clone(),
+                root_claim_type: new_claim_type,
+                netuid,
+            });
+            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,18 @@ mod events {
             root_claim_type: RootClaimTypeEnum,
         },
 
+        /// Root claim type for a coldkey has been set.
+        /// Parameters:
+        /// (coldkey, u8)
+        ValidatorClaimTypeSet {
+            /// delegate hotkey
+            hotkey: T::AccountId,
+            /// root claim type enum
+            root_claim_type: RootClaimTypeEnum,
+            /// subnet UID
+            netuid: NetUid,
+        },
+
         /// Subnet lease dividends have been distributed.
         SubnetLeaseDividendsDistributed {
             /// The lease ID

pallets/subtensor/src/staking/claim_root.rs

@@ -2,7 +2,7 @@ use super::*;
 use frame_support::weights::Weight;
 use sp_core::Get;
 use sp_std::collections::btree_set::BTreeSet;
-use substrate_fixed::types::I96F32;
+use substrate_fixed::types::{I96F32, U96F32};
 use subtensor_swap_interface::SwapHandler;
 
 impl<T: Config> Pallet<T> {
@@ -157,10 +157,21 @@ impl<T: Config> Pallet<T> {
             return; // no-op
         }
 
-        let swap = match root_claim_type {
+        let mut actual_root_claim = root_claim_type;
+        // If root_claim_type is Delegated, switch to the delegate's actual claim type.
+        if actual_root_claim == RootClaimTypeEnum::Delegated {
+            actual_root_claim = ValidatorClaimType::<T>::get(hotkey, netuid);
+        }
+
+        let swap = match actual_root_claim {
             RootClaimTypeEnum::Swap => true,
             RootClaimTypeEnum::Keep => false,
             RootClaimTypeEnum::KeepSubnets { subnets } => !subnets.contains(&netuid),
+            RootClaimTypeEnum::Delegated => {
+                // Should not reach here. Added for completeness.
+                log::error!("Delegated root_claim_type should have been switched. Skipping.");
+                return;
+            }
         };
 
         if swap {
@@ -179,6 +190,12 @@ impl<T: Config> Pallet<T> {
                 }
             };
 
+            let recorded_tao_outflow =
+                Self::calculate_tao_outflow(netuid, owed_tao.amount_paid_out);
+
+            // Importantly measures swap as flow.
+            Self::record_tao_outflow(netuid, recorded_tao_outflow.into());
+
             Self::increase_stake_for_hotkey_and_coldkey_on_subnet(
                 hotkey,
                 coldkey,
@@ -194,7 +211,7 @@ impl<T: Config> Pallet<T> {
         } else
         /* 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,
@@ -209,6 +226,35 @@ impl<T: Config> Pallet<T> {
         });
     }
 
+    // Calculates root proportion for subnet, uses "1 / root_prop" (with 10 as an upper bound) as
+    // a multiplier for provided Tao amount.
+    pub(crate) fn calculate_tao_outflow(netuid: NetUid, amount: TaoCurrency) -> TaoCurrency {
+        let root_tao: U96F32 = U96F32::saturating_from_num(SubnetTAO::<T>::get(NetUid::ROOT));
+        let tao_weight: U96F32 = root_tao.saturating_mul(Self::get_tao_weight());
+        let alpha_issuance: U96F32 = U96F32::saturating_from_num(Self::get_alpha_issuance(netuid));
+        let root_proportion: U96F32 = tao_weight
+            .checked_div(tao_weight.saturating_add(alpha_issuance))
+            .unwrap_or(U96F32::saturating_from_num(0));
+
+        let root_prop_multiplier = {
+            let root_prop_multiplier = U96F32::saturating_from_num(1)
+                .checked_div(root_proportion)
+                .unwrap_or(U96F32::saturating_from_num(0.0));
+            let upper_bound = U96F32::saturating_from_num(10);
+
+            if root_prop_multiplier < upper_bound {
+                root_prop_multiplier
+            } else {
+                upper_bound
+            }
+        };
+
+        let tao = U96F32::saturating_from_num(amount.to_u64());
+        let recorded_tao_outflow: u64 = tao.saturating_mul(root_prop_multiplier).to_num();
+
+        recorded_tao_outflow.into()
+    }
+
     fn root_claim_on_subnet_weight(_root_claim_type: RootClaimTypeEnum) -> Weight {
         Weight::from_parts(60_000_000, 6987)
             .saturating_add(T::DbWeight::get().reads(7_u64))