Change root claim data maps and add an event.

shamil-gadelshin · shamil-gadelshin · commit 7645958547ef · 2025-12-16T19:29:55.000+03:00
diff --git a/pallets/subtensor/src/lib.rs b/pallets/subtensor/src/lib.rs
@@ -324,6 +324,20 @@ pub mod pallet {
     /// ==== Staking + Accounts ====
     /// ============================
 
+    #[crate::freeze_struct("e453805be107a384")]
+    #[derive(
+        Encode, Decode, Default, TypeInfo, Clone, PartialEq, Eq, Debug, DecodeWithMemTracking,
+    )]
+    /// Accounting root claim data per subnet per block.
+    pub struct PendingRootClaimedData {
+        /// Total alpha kept this block
+        pub alpha_kept: AlphaCurrency,
+        /// Total alpha swapped this block
+        pub alpha_swapped: AlphaCurrency,
+        /// Total TAO swapped this block
+        pub tao_swapped: TaoCurrency,
+    }
+
     #[derive(
         Encode, Decode, Default, TypeInfo, Clone, PartialEq, Eq, Debug, DecodeWithMemTracking,
     )]
@@ -357,6 +371,12 @@ pub mod pallet {
         RootClaimTypeEnum::default()
     }
 
+    /// Default root claim accounting data.
+    #[pallet::type_value]
+    pub fn DefaultRootClaimedData<T: Config>() -> PendingRootClaimedData {
+        PendingRootClaimedData::default()
+    }
+
     /// Default number of root claims per claim call.
     /// Ideally this is calculated using the number of staking coldkey
     /// and the block time.
@@ -2254,15 +2274,16 @@ pub mod pallet {
     #[pallet::storage] // --- Value --> num_root_claim | Number of coldkeys to claim each auto-claim.
     pub type NumRootClaim<T: Config> = StorageValue<_, u64, ValueQuery, DefaultNumRootClaim<T>>;
 
-    /// --- MAP ( subnet ) --> claimed root alpha (kept)
+    /// --- MAP ( subnet ) --> pending accounting root claimed data. In-block storage only - to be cleaned each block.
     #[pallet::storage]
-    pub type SubnetRootClaimKeep<T: Config> =
-        StorageMap<_, Blake2_128Concat, NetUid, AlphaCurrency, ValueQuery, DefaultZeroAlpha<T>>;
-
-    /// --- MAP ( subnet ) --> claimed root alpha (swapped)
-    #[pallet::storage]
-    pub type SubnetRootClaimSwap<T: Config> =
-        StorageMap<_, Blake2_128Concat, NetUid, AlphaCurrency, ValueQuery, DefaultZeroAlpha<T>>;
+    pub type PendingSubnetRootClaimData<T: Config> = StorageMap<
+        _,
+        Blake2_128Concat,
+        NetUid,
+        PendingRootClaimedData,
+        ValueQuery,
+        DefaultRootClaimedData<T>,
+    >;
 
     /// =============================
     /// ==== EVM related storage ====
diff --git a/pallets/subtensor/src/macros/events.rs b/pallets/subtensor/src/macros/events.rs
@@ -479,5 +479,11 @@ mod events {
             /// The amount of alpha distributed
             alpha: AlphaCurrency,
         },
+
+        /// Root claimed data for this block.
+        RootClaimedData {
+            /// Root claim data for this block
+            data: BTreeMap<NetUid, PendingRootClaimedData>,
+        },
     }
 }
diff --git a/pallets/subtensor/src/macros/hooks.rs b/pallets/subtensor/src/macros/hooks.rs
@@ -47,6 +47,8 @@ mod hooks {
             for _ in StakingOperationRateLimiter::<T>::drain() {
                 // Clear all entries each block
             }
+
+            Self::deposit_root_claim_accounting_event();
         }
 
         fn on_runtime_upgrade() -> frame_support::weights::Weight {
diff --git a/pallets/subtensor/src/staking/claim_root.rs b/pallets/subtensor/src/staking/claim_root.rs
@@ -1,6 +1,7 @@
 use super::*;
 use frame_support::weights::Weight;
 use sp_core::Get;
+use sp_std::collections::btree_map::BTreeMap;
 use sp_std::collections::btree_set::BTreeSet;
 use substrate_fixed::types::I96F32;
 use subtensor_swap_interface::SwapHandler;
@@ -192,9 +193,11 @@ impl<T: Config> Pallet<T> {
                 owed_tao.amount_paid_out.into(),
             );
 
-            SubnetRootClaimSwap::<T>::mutate(netuid, |alpha| {
-                *alpha = alpha.saturating_add(owed_u64.into());
-            });
+            Self::register_root_claim_swapped_alpha(
+                netuid,
+                owed_u64.into(),
+                owed_tao.amount_paid_out,
+            );
         } else
         /* Keep */
         {
@@ -205,15 +208,25 @@ impl<T: Config> Pallet<T> {
                 netuid,
                 owed_u64.into(),
             );
+
+            Self::register_root_claim_kept_alpha(netuid, owed_u64.into());
         }
 
         // Increase root claimed by owed amount.
         RootClaimed::<T>::mutate((netuid, hotkey, coldkey), |root_claimed| {
             *root_claimed = root_claimed.saturating_add(owed_u64.into());
         });
+    }
 
-        SubnetRootClaimKeep::<T>::mutate(netuid, |alpha| {
-            *alpha = alpha.saturating_add(owed_u64.into());
+    fn register_root_claim_swapped_alpha(netuid: NetUid, alpha: AlphaCurrency, tao: TaoCurrency) {
+        PendingSubnetRootClaimData::<T>::mutate(netuid, |data| {
+            data.alpha_swapped = data.alpha_swapped.saturating_add(alpha);
+            data.tao_swapped = data.tao_swapped.saturating_add(tao);
+        });
+    }
+    fn register_root_claim_kept_alpha(netuid: NetUid, alpha: AlphaCurrency) {
+        PendingSubnetRootClaimData::<T>::mutate(netuid, |data| {
+            data.alpha_kept = data.alpha_kept.saturating_add(alpha);
         });
     }
 
@@ -355,6 +368,17 @@ impl<T: Config> Pallet<T> {
         weight
     }
 
+    pub fn deposit_root_claim_accounting_event() {
+        let root_claim_data = PendingSubnetRootClaimData::<T>::iter().collect::<BTreeMap<_, _>>();
+
+        Self::deposit_event(Event::RootClaimedData {
+            data: root_claim_data,
+        });
+
+        // Subnet Number = 100+
+        let _ = PendingSubnetRootClaimData::<T>::clear(u32::MAX, None);
+    }
+
     pub fn change_root_claim_type(coldkey: &T::AccountId, new_type: RootClaimTypeEnum) {
         RootClaimType::<T>::insert(coldkey.clone(), new_type.clone());
 
@@ -407,8 +431,5 @@ impl<T: Config> Pallet<T> {
         }
 
         let _ = RootClaimed::<T>::clear_prefix((netuid,), u32::MAX, None);
-
-        SubnetRootClaimKeep::<T>::remove(&netuid);
-        SubnetRootClaimSwap::<T>::remove(&netuid);
     }
 }
diff --git a/pallets/subtensor/src/tests/claim_root.rs b/pallets/subtensor/src/tests/claim_root.rs
@@ -1,15 +1,16 @@
 #![allow(clippy::expect_used)]
 
 use crate::tests::mock::{
-    RuntimeOrigin, SubtensorModule, Test, add_dynamic_network, new_test_ext, run_to_block,
+    RuntimeEvent, RuntimeOrigin, SubtensorModule, System, Test, add_dynamic_network, new_test_ext,
+    run_to_block, step_block,
 };
 use crate::{
-    DefaultMinRootClaimAmount, Error, MAX_NUM_ROOT_CLAIMS, MAX_ROOT_CLAIM_THRESHOLD, NetworksAdded,
-    NumRootClaim, NumStakingColdkeys, PendingRootAlphaDivs, RootClaimable, RootClaimableThreshold,
-    StakingColdkeys, StakingColdkeysByIndex, SubnetAlphaIn, SubnetMechanism, SubnetMovingPrice,
-    SubnetTAO, SubnetTaoFlow, SubtokenEnabled, Tempo, pallet,
+    DefaultMinRootClaimAmount, Error, Event, MAX_NUM_ROOT_CLAIMS, MAX_ROOT_CLAIM_THRESHOLD,
+    NetworksAdded, NumRootClaim, NumStakingColdkeys, PendingRootAlphaDivs, PendingRootClaimedData,
+    RootClaimable, RootClaimableThreshold, StakingColdkeys, StakingColdkeysByIndex, SubnetAlphaIn,
+    SubnetMechanism, SubnetMovingPrice, SubnetTAO, SubnetTaoFlow, SubtokenEnabled, Tempo, pallet,
 };
-use crate::{RootAlphaDividendsPerSubnet, SubnetRootClaimKeep, SubnetRootClaimSwap};
+use crate::{PendingSubnetRootClaimData, RootAlphaDividendsPerSubnet};
 use crate::{RootClaimType, RootClaimTypeEnum, RootClaimed};
 use approx::assert_abs_diff_eq;
 use frame_support::dispatch::RawOrigin;
@@ -18,7 +19,7 @@ use frame_support::traits::Get;
 use frame_support::{assert_err, assert_noop, assert_ok};
 use sp_core::{H256, U256};
 use sp_runtime::DispatchError;
-use std::collections::BTreeSet;
+use std::collections::{BTreeMap, BTreeSet};
 use substrate_fixed::types::{I96F32, U64F64, U96F32};
 use subtensor_runtime_common::{AlphaCurrency, Currency, NetUid, TaoCurrency};
 use subtensor_swap_interface::SwapHandler;
@@ -1861,7 +1862,7 @@ fn test_claim_root_subnet_root_claim_map_keep() {
             RootClaimTypeEnum::Keep
         ),);
         assert_eq!(RootClaimType::<Test>::get(coldkey), RootClaimTypeEnum::Keep);
-        assert!(!SubnetRootClaimKeep::<Test>::contains_key(netuid));
+        assert!(!PendingSubnetRootClaimData::<Test>::contains_key(netuid));
 
         assert_ok!(SubtensorModule::claim_root(
             RuntimeOrigin::signed(coldkey),
@@ -1873,12 +1874,46 @@ fn test_claim_root_subnet_root_claim_map_keep() {
         let new_stake =
             SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid);
 
-        assert_eq!(new_stake, SubnetRootClaimKeep::<Test>::get(netuid),);
+        assert!(PendingSubnetRootClaimData::<Test>::contains_key(netuid));
 
-        // Check SubnetRootClaimKeep after network deregistration
+        let root_claim_data = PendingSubnetRootClaimData::<Test>::get(netuid);
 
-        assert_ok!(SubtensorModule::do_dissolve_network(netuid));
-        assert!(!SubnetRootClaimKeep::<Test>::contains_key(netuid));
+        assert_eq!(new_stake, root_claim_data.alpha_kept);
+
+        assert_eq!(root_claim_data.alpha_swapped, AlphaCurrency::ZERO);
+        assert_eq!(root_claim_data.tao_swapped, TaoCurrency::ZERO);
+
+        // Check PendingSubnetRootClaimData after on_finalize()
+
+        step_block(1);
+        assert!(!PendingSubnetRootClaimData::<Test>::contains_key(netuid));
+
+        // Check for the event
+        let event = System::events()
+            .into_iter()
+            .find(|e| {
+                matches!(
+                    &e.event,
+                    RuntimeEvent::SubtensorModule(Event::RootClaimedData { .. })
+                )
+            })
+            .expect("Event must be found");
+
+        let RuntimeEvent::SubtensorModule(Event::RootClaimedData { data }) = event.event else {
+            panic!("Event must be RootClaimedData")
+        };
+
+        assert_eq!(
+            BTreeMap::from([(
+                netuid,
+                PendingRootClaimedData {
+                    alpha_swapped: AlphaCurrency::ZERO,
+                    tao_swapped: TaoCurrency::ZERO,
+                    alpha_kept: new_stake,
+                }
+            )]),
+            data
+        );
     });
 }
 
@@ -1946,7 +1981,7 @@ fn test_claim_root_subnet_root_claim_map_swap() {
             RootClaimTypeEnum::Swap
         ),);
         assert_eq!(RootClaimType::<Test>::get(coldkey), RootClaimTypeEnum::Swap);
-        assert!(!SubnetRootClaimSwap::<Test>::contains_key(netuid));
+        assert!(!PendingSubnetRootClaimData::<Test>::contains_key(netuid));
 
         assert_ok!(SubtensorModule::claim_root(
             RuntimeOrigin::signed(coldkey),
@@ -1975,18 +2010,52 @@ fn test_claim_root_subnet_root_claim_map_swap() {
 
         // Check SubnetRootClaimSwap
 
-        let saved_swapped_alpha: u64 = SubnetRootClaimSwap::<Test>::get(netuid).into();
+        let root_claim_data = PendingSubnetRootClaimData::<Test>::get(netuid);
+
+        let saved_swapped_alpha: u64 = root_claim_data.alpha_swapped.into();
+
+        let saved_swapped_tao: u64 = root_claim_data.tao_swapped.into();
+
+        assert_eq!(root_claim_data.alpha_kept, AlphaCurrency::ZERO);
+
+        assert_abs_diff_eq!(
+            estimated_stake_increment,
+            saved_swapped_tao as f64,
+            epsilon = 10f64,
+        );
 
         assert_abs_diff_eq!(
-            estimated_stake_increment as f64 / current_price,
+            estimated_stake_increment / current_price,
             saved_swapped_alpha as f64,
             epsilon = 10f64,
         );
 
-        // Check SubnetRootClaimSwap after network deregistration
+        // Check PendingSubnetRootClaimData after block finalization
 
-        assert_ok!(SubtensorModule::do_dissolve_network(netuid));
-        assert!(!SubnetRootClaimSwap::<Test>::contains_key(netuid));
+        step_block(1);
+        assert!(!PendingSubnetRootClaimData::<Test>::contains_key(netuid));
+
+        // Check for the event
+        let event = System::events()
+            .into_iter()
+            .find(|e| {
+                matches!(
+                    &e.event,
+                    RuntimeEvent::SubtensorModule(Event::RootClaimedData { .. })
+                )
+            })
+            .expect("Event must be found");
+
+        let RuntimeEvent::SubtensorModule(Event::RootClaimedData { data }) = event.event else {
+            panic!("Event must be RootClaimedData")
+        };
+
+        for (event_netuid, root_claim_data) in data.into_iter() {
+            assert_eq!(event_netuid, netuid);
+            assert_eq!(root_claim_data.alpha_kept, AlphaCurrency::ZERO);
+            assert_eq!(root_claim_data.alpha_swapped, saved_swapped_alpha.into());
+            assert_eq!(root_claim_data.tao_swapped, saved_swapped_tao.into());
+        }
     });
 }
 

Original file line number	Diff line number	Diff line change
`@@ -479,5 +479,11 @@ mod events {`
`479`	`479`	`/// The amount of alpha distributed`
`480`	`480`	`alpha: AlphaCurrency,`
`481`	`481`	`},`
	`482`	`+`
	`483`	`+ /// Root claimed data for this block.`
	`484`	`+ RootClaimedData {`
	`485`	`+ /// Root claim data for this block`
	`486`	`+ data: BTreeMap<NetUid, PendingRootClaimedData>,`
	`487`	`+ },`
`482`	`488`	`}`
`483`	`489`	`}`
Original file line number	Diff line number	Diff line change
`@@ -47,6 +47,8 @@ mod hooks {`
`47`	`47`	`for _ in StakingOperationRateLimiter::<T>::drain() {`
`48`	`48`	`// Clear all entries each block`
`49`	`49`	`}`
	`50`	`+`
	`51`	`+ Self::deposit_root_claim_accounting_event();`
`50`	`52`	`}`
`51`	`53`
`52`	`54`	`fn on_runtime_upgrade() -> frame_support::weights::Weight {`