release-root-reborn

pallets/subtensor/rpc/src/lib.rs

@@ -14,8 +14,8 @@ use subtensor_runtime_common::{MechId, NetUid, TaoBalance};
 use sp_api::ProvideRuntimeApi;
 
 pub use subtensor_custom_rpc_runtime_api::{
-    DelegateInfoRuntimeApi, NeuronInfoRuntimeApi, StakeInfoRuntimeApi, SubnetInfoRuntimeApi,
-    SubnetRegistrationRuntimeApi,
+    BetaBasketRuntimeApi, DelegateInfoRuntimeApi, NeuronInfoRuntimeApi, StakeInfoRuntimeApi,
+    SubnetInfoRuntimeApi, SubnetRegistrationRuntimeApi,
 };
 
 #[rpc(client, server)]
@@ -121,6 +121,38 @@ pub trait SubtensorCustomApi<BlockHash> {
         netuid: NetUid,
         at: Option<BlockHash>,
     ) -> RpcResult<Vec<u8>>;
+
+    /// Total TAO a staker (coldkey) would realize by redeeming all its root beta baskets.
+    #[method(name = "betaBasket_getStakerOwed")]
+    fn get_root_basket_owed(
+        &self,
+        coldkey: AccountId32,
+        at: Option<BlockHash>,
+    ) -> RpcResult<TaoBalance>;
+    /// A validator's beta basket net asset value, in TAO.
+    #[method(name = "betaBasket_getValidatorNav")]
+    fn get_validator_basket_nav(
+        &self,
+        hotkey: AccountId32,
+        at: Option<BlockHash>,
+    ) -> RpcResult<TaoBalance>;
+    /// A validator's full basket breakdown: SCALE-encoded `Vec<(NetUid, AlphaBalance, TaoBalance)>`.
+    #[method(name = "betaBasket_getValidatorBasket")]
+    fn get_validator_basket(
+        &self,
+        hotkey: AccountId32,
+        at: Option<BlockHash>,
+    ) -> RpcResult<Vec<u8>>;
+    /// Network-wide total beta basket NAV across all validators, in TAO.
+    #[method(name = "betaBasket_getTotalNav")]
+    fn get_root_basket_total_nav(&self, at: Option<BlockHash>) -> RpcResult<TaoBalance>;
+    /// A validator's basket weight vector: SCALE-encoded `Vec<(NetUid, u16)>` (its strategy).
+    #[method(name = "betaBasket_getValidatorWeights")]
+    fn get_validator_weights(
+        &self,
+        hotkey: AccountId32,
+        at: Option<BlockHash>,
+    ) -> RpcResult<Vec<u8>>;
 }
 
 pub struct SubtensorCustom<C, P> {
@@ -170,6 +202,7 @@ where
     C::Api: SubnetInfoRuntimeApi<Block>,
     C::Api: StakeInfoRuntimeApi<Block>,
     C::Api: SubnetRegistrationRuntimeApi<Block>,
+    C::Api: BetaBasketRuntimeApi<Block>,
 {
     fn get_delegates(&self, at: Option<<Block as BlockT>::Hash>) -> RpcResult<Vec<u8>> {
         let api = self.client.runtime_api();
@@ -583,4 +616,84 @@ where
             Err(e) => Err(Error::RuntimeError(format!("Unable to get coldkey lock: {e:?}")).into()),
         }
     }
+
+    fn get_root_basket_owed(
+        &self,
+        coldkey: AccountId32,
+        at: Option<<Block as BlockT>::Hash>,
+    ) -> RpcResult<TaoBalance> {
+        let api = self.client.runtime_api();
+        let at = at.unwrap_or_else(|| self.client.info().best_hash);
+
+        match api.get_root_basket_owed(at, coldkey) {
+            Ok(result) => Ok(result),
+            Err(e) => {
+                Err(Error::RuntimeError(format!("Unable to get root basket owed: {e:?}")).into())
+            }
+        }
+    }
+
+    fn get_validator_basket_nav(
+        &self,
+        hotkey: AccountId32,
+        at: Option<<Block as BlockT>::Hash>,
+    ) -> RpcResult<TaoBalance> {
+        let api = self.client.runtime_api();
+        let at = at.unwrap_or_else(|| self.client.info().best_hash);
+
+        match api.get_validator_basket_nav(at, hotkey) {
+            Ok(result) => Ok(result),
+            Err(e) => Err(Error::RuntimeError(format!(
+                "Unable to get validator basket NAV: {e:?}"
+            ))
+            .into()),
+        }
+    }
+
+    fn get_validator_basket(
+        &self,
+        hotkey: AccountId32,
+        at: Option<<Block as BlockT>::Hash>,
+    ) -> RpcResult<Vec<u8>> {
+        let api = self.client.runtime_api();
+        let at = at.unwrap_or_else(|| self.client.info().best_hash);
+
+        match api.get_validator_basket(at, hotkey) {
+            Ok(result) => Ok(result.encode()),
+            Err(e) => {
+                Err(Error::RuntimeError(format!("Unable to get validator basket: {e:?}")).into())
+            }
+        }
+    }
+
+    fn get_root_basket_total_nav(
+        &self,
+        at: Option<<Block as BlockT>::Hash>,
+    ) -> RpcResult<TaoBalance> {
+        let api = self.client.runtime_api();
+        let at = at.unwrap_or_else(|| self.client.info().best_hash);
+
+        match api.get_root_basket_total_nav(at) {
+            Ok(result) => Ok(result),
+            Err(e) => {
+                Err(Error::RuntimeError(format!("Unable to get total basket NAV: {e:?}")).into())
+            }
+        }
+    }
+
+    fn get_validator_weights(
+        &self,
+        hotkey: AccountId32,
+        at: Option<<Block as BlockT>::Hash>,
+    ) -> RpcResult<Vec<u8>> {
+        let api = self.client.runtime_api();
+        let at = at.unwrap_or_else(|| self.client.info().best_hash);
+
+        match api.get_validator_weights(at, hotkey) {
+            Ok(result) => Ok(result.encode()),
+            Err(e) => {
+                Err(Error::RuntimeError(format!("Unable to get validator weights: {e:?}")).into())
+            }
+        }
+    }
 }

pallets/subtensor/runtime-api/src/lib.rs

@@ -83,4 +83,17 @@ sp_api::decl_runtime_apis! {
         fn get_proxy_types() -> Vec<ProxyTypeInfo>;
         fn get_proxy_filters(proxy_types: Option<Vec<u8>>) -> Vec<ProxyFilterInfo>;
     }
+
+    pub trait BetaBasketRuntimeApi {
+        /// Total TAO a coldkey would realize by redeeming all its root beta baskets (marked).
+        fn get_root_basket_owed(coldkey: AccountId32) -> TaoBalance;
+        /// A validator's beta basket net asset value, in TAO (marked).
+        fn get_validator_basket_nav(hotkey: AccountId32) -> TaoBalance;
+        /// A validator's basket breakdown: (subnet, alpha held, TAO value) per subnet.
+        fn get_validator_basket(hotkey: AccountId32) -> Vec<(NetUid, AlphaBalance, TaoBalance)>;
+        /// Network-wide total beta basket NAV across all validators, in TAO (marked).
+        fn get_root_basket_total_nav() -> TaoBalance;
+        /// A validator's basket weight vector `w`: (subnet, weight) it deploys dividends into.
+        fn get_validator_weights(hotkey: AccountId32) -> Vec<(NetUid, u16)>;
+    }
 }

pallets/subtensor/src/benchmarks/benchmarks.rs

@@ -25,7 +25,7 @@ use sp_runtime::{
     BoundedVec, PerU16, Percent,
     traits::{BlakeTwo256, Dispatchable, Hash},
 };
-use sp_std::collections::{btree_set::BTreeSet, vec_deque::VecDeque};
+use sp_std::collections::vec_deque::VecDeque;
 use sp_std::vec;
 use substrate_fixed::types::{I96F32, U64F64};
 use subtensor_runtime_common::{AlphaBalance, NetUid, NetUidStorageIndex, TaoBalance};
@@ -1961,14 +1961,6 @@ mod pallet_benchmarks {
         _(RawOrigin::Signed(coldkey.clone()), netuid, hotkey.clone());
     }
 
-    #[benchmark]
-    fn set_root_claim_type() {
-        let coldkey: T::AccountId = whitelisted_caller();
-
-        #[extrinsic_call]
-        _(RawOrigin::Signed(coldkey.clone()), RootClaimTypeEnum::Keep);
-    }
-
     #[benchmark]
     fn claim_root() {
         let coldkey: T::AccountId = whitelisted_caller();
@@ -2011,6 +2003,16 @@ mod pallet_benchmarks {
             initial_total_hotkey_alpha.into(),
         );
 
+        // Point the validator's basket weight vector at the subnet so the distributed root
+        // dividend is deposited into its fund (instead of being recycled for lack of weights).
+        if let Ok(root_uid) = Uids::<T>::try_get(NetUid::ROOT, &hotkey) {
+            Weights::<T>::insert(
+                NetUidStorageIndex::ROOT,
+                root_uid,
+                vec![(u16::from(netuid), 1u16)],
+            );
+        }
+
         let pending_root_alpha = 10_000_000u64;
         Subtensor::<T>::distribute_emission(
             netuid,
@@ -2020,29 +2022,25 @@ mod pallet_benchmarks {
             AlphaBalance::ZERO,
         );
 
-        let initial_stake =
-            Subtensor::<T>::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid);
-
-        assert_ok!(Subtensor::<T>::set_root_claim_type(
-            RawOrigin::Signed(coldkey.clone()).into(),
-            RootClaimTypeEnum::Keep
-        ));
+        let initial_stake = Subtensor::<T>::get_stake_for_hotkey_and_coldkey_on_subnet(
+            &hotkey,
+            &coldkey,
+            NetUid::ROOT,
+        );
 
         #[extrinsic_call]
-        _(RawOrigin::Signed(coldkey.clone()), BTreeSet::from([netuid]));
+        _(RawOrigin::Signed(coldkey.clone()));
 
-        let new_stake =
-            Subtensor::<T>::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid);
+        let new_stake = Subtensor::<T>::get_stake_for_hotkey_and_coldkey_on_subnet(
+            &hotkey,
+            &coldkey,
+            NetUid::ROOT,
+        );
 
+        // The claim must actually pay out (strict: a no-op claim is a broken benchmark).
         assert!(new_stake > initial_stake);
     }
 
-    #[benchmark]
-    fn sudo_set_num_root_claims() {
-        #[extrinsic_call]
-        _(RawOrigin::Root, 40);
-    }
-
     #[benchmark]
     fn sudo_set_root_claim_threshold() {
         let coldkey: T::AccountId = whitelisted_caller();

pallets/subtensor/src/coinbase/block_step.rs

@@ -6,7 +6,6 @@ impl<T: Config + pallet_drand::Config> Pallet<T> {
     /// Executes the necessary operations for each block.
     pub fn block_step() -> Result<(), &'static str> {
         let block_number: u64 = Self::get_current_block_as_u64();
-        let last_block_hash: T::Hash = <frame_system::Pallet<T>>::parent_hash();
 
         // --- 1. Update registration burn prices.
         Self::update_registration_prices_for_networks();
@@ -25,8 +24,7 @@ impl<T: Config + pallet_drand::Config> Pallet<T> {
         Self::update_root_prop();
         // --- 7. Set pending children on the epoch; but only after the coinbase has been run.
         Self::try_set_pending_children(block_number);
-        // --- 8. Run auto-claim root divs.
-        Self::run_auto_claim_root_divs(last_block_hash);
+        // --- 8. Beta baskets are redeemed on-demand by stakers via `claim_root`; no auto-swap.
         // --- 9. Populate root coldkey maps.
         Self::populate_root_coldkey_staking_maps();
         Self::populate_root_coldkey_staking_maps_v2();

pallets/subtensor/src/coinbase/run_coinbase.rs

@@ -837,11 +837,11 @@ impl<T: Config> Pallet<T> {
 
             let root_claimable_alpha: AlphaBalance = tou64!(root_claimable).into();
             if !root_claimable_alpha.is_zero() {
-                Self::increase_root_claimable_for_hotkey_and_subnet(
-                    &hotkey,
-                    netuid,
-                    root_claimable_alpha,
-                );
+                // Distribute the validator's root dividend into its beta basket across subnets
+                // per the validator's root weight vector (set on subnet 0). The bought basket
+                // alpha is staked to the validator under the global escrow coldkey, so it counts
+                // toward the validator's stake and compounds; stakers accrue a claimable rate.
+                Self::distribute_root_alpha_to_basket(&hotkey, netuid, root_claimable_alpha);
 
                 RootAlphaDividendsPerSubnet::<T>::mutate(netuid, &hotkey, |divs| {
                     *divs = divs.saturating_add(root_claimable_alpha);