From 2c25945225f07227607d6b5ad5c82b4486bc9a5b Mon Sep 17 00:00:00 2001 From: John Reed <87283488+JohnReedV@users.noreply.github.com> Date: Wed, 13 May 2026 09:55:38 -0700 Subject: [PATCH 1/5] impl BurnRootProp --- pallets/subtensor/src/coinbase/block_step.rs | 17 ++++ .../subtensor/src/coinbase/run_coinbase.rs | 82 +++++++++++++------ pallets/subtensor/src/lib.rs | 4 + pallets/subtensor/src/macros/dispatches.rs | 14 ++++ pallets/subtensor/src/macros/events.rs | 6 ++ pallets/subtensor/src/staking/claim_root.rs | 26 ++++++ pallets/subtensor/src/tests/coinbase.rs | 79 ++++++++++++++++++ 7 files changed, 201 insertions(+), 27 deletions(-) diff --git a/pallets/subtensor/src/coinbase/block_step.rs b/pallets/subtensor/src/coinbase/block_step.rs index fac924ccf4..ab8d0bc5c5 100644 --- a/pallets/subtensor/src/coinbase/block_step.rs +++ b/pallets/subtensor/src/coinbase/block_step.rs @@ -3,6 +3,15 @@ use substrate_fixed::types::U96F32; use subtensor_runtime_common::NetUid; impl Pallet { + pub fn get_burn_root_prop() -> bool { + BurnRootProp::::get() + } + + pub fn set_burn_root_prop(enabled: bool) { + BurnRootProp::::put(enabled); + Self::deposit_event(Event::BurnRootPropSet { enabled }); + } + /// Executes the necessary operations for each block. pub fn block_step() -> Result<(), &'static str> { let block_number: u64 = Self::get_current_block_as_u64(); @@ -65,6 +74,14 @@ impl Pallet { } pub fn root_proportion(netuid: NetUid) -> U96F32 { + if Self::get_burn_root_prop() { + return U96F32::from_num(0.0); + } + + Self::raw_root_proportion(netuid) + } + + pub fn raw_root_proportion(netuid: NetUid) -> U96F32 { let alpha_issuance = U96F32::from_num(Self::get_alpha_issuance(netuid)); let root_tao: U96F32 = U96F32::from_num(Self::get_subnet_tao(NetUid::ROOT)); let tao_weight: U96F32 = root_tao.saturating_mul(Self::get_tao_weight()); diff --git a/pallets/subtensor/src/coinbase/run_coinbase.rs b/pallets/subtensor/src/coinbase/run_coinbase.rs index 2854777abc..4cdadf9a09 100644 --- a/pallets/subtensor/src/coinbase/run_coinbase.rs +++ b/pallets/subtensor/src/coinbase/run_coinbase.rs @@ -247,6 +247,7 @@ impl Pallet { // --- 3. Inject ALPHA for participants. let cut_percent: U96F32 = Self::get_float_subnet_owner_cut(); + let burn_root_prop = Self::get_burn_root_prop(); for netuid_i in subnets_to_emit_to.iter() { // Get alpha_out for this block. let mut alpha_out_i: U96F32 = *alpha_out.get(netuid_i).unwrap_or(&asfloat!(0)); @@ -268,7 +269,11 @@ impl Pallet { }); // Get root proportional dividends. - let root_proportion = Self::root_proportion(*netuid_i); + let root_proportion = if burn_root_prop { + Self::raw_root_proportion(*netuid_i) + } else { + Self::root_proportion(*netuid_i) + }; log::debug!("root_proportion: {root_proportion:?}"); // Get root alpha from root prop. @@ -297,14 +302,19 @@ impl Pallet { *total = total.saturating_add(tou64!(pending_validator_alpha).into()); }); - if root_sell_flag { + let root_alpha_amount = AlphaBalance::from(tou64!(root_alpha)); + + if burn_root_prop { + // Burn root yield unconditionally while the flag is enabled. + Self::burn_subnet_alpha(*netuid_i, root_alpha_amount); + } else if root_sell_flag { // Only accumulate root alpha divs if root sell is allowed. PendingRootAlphaDivs::::mutate(*netuid_i, |total| { - *total = total.saturating_add(tou64!(root_alpha).into()); + *total = total.saturating_add(root_alpha_amount); }); } else { // If we are not selling the root alpha, we should recycle it. - Self::recycle_subnet_alpha(*netuid_i, AlphaBalance::from(tou64!(root_alpha))); + Self::recycle_subnet_alpha(*netuid_i, root_alpha_amount); } } } @@ -676,31 +686,38 @@ impl Pallet { // Distribute root alpha divs. let _ = RootAlphaDividendsPerSubnet::::clear_prefix(netuid, u32::MAX, None); - for (hotkey, mut root_alpha) in root_alpha_dividends { - // Get take prop - let alpha_take: U96F32 = - Self::get_hotkey_take_float(&hotkey).saturating_mul(root_alpha); - // Remove take prop from root_alpha - root_alpha = root_alpha.saturating_sub(alpha_take); - // Give the validator their take. - log::debug!("hotkey: {hotkey:?} alpha_take: {alpha_take:?}"); - Self::increase_stake_for_hotkey_and_coldkey_on_subnet( - &hotkey, - &Owner::::get(hotkey.clone()), - netuid, - tou64!(alpha_take).into(), - ); + if Self::get_burn_root_prop() { + // Defense-in-depth: no call path may pay root while the flag is enabled. + for (_, root_alpha) in root_alpha_dividends { + Self::burn_subnet_alpha(netuid, AlphaBalance::from(tou64!(root_alpha))); + } + } else { + for (hotkey, mut root_alpha) in root_alpha_dividends { + // Get take prop + let alpha_take: U96F32 = + Self::get_hotkey_take_float(&hotkey).saturating_mul(root_alpha); + // Remove take prop from root_alpha + root_alpha = root_alpha.saturating_sub(alpha_take); + // Give the validator their take. + log::debug!("hotkey: {hotkey:?} alpha_take: {alpha_take:?}"); + Self::increase_stake_for_hotkey_and_coldkey_on_subnet( + &hotkey, + &Owner::::get(hotkey.clone()), + netuid, + tou64!(alpha_take).into(), + ); - Self::increase_root_claimable_for_hotkey_and_subnet( - &hotkey, - netuid, - tou64!(root_alpha).into(), - ); + Self::increase_root_claimable_for_hotkey_and_subnet( + &hotkey, + netuid, + tou64!(root_alpha).into(), + ); - // Record root alpha dividends for this validator on this subnet. - RootAlphaDividendsPerSubnet::::mutate(netuid, &hotkey, |divs| { - *divs = divs.saturating_add(tou64!(root_alpha).into()); - }); + // Record root alpha dividends for this validator on this subnet. + RootAlphaDividendsPerSubnet::::mutate(netuid, &hotkey, |divs| { + *divs = divs.saturating_add(tou64!(root_alpha).into()); + }); + } } } @@ -760,6 +777,17 @@ impl Pallet { ); let tao_weight = Self::get_tao_weight(); + let pending_root_alpha = if Self::get_burn_root_prop() { + // Drain-and-burn any root alpha accumulated before the flag was switched on + // or supplied by an internal caller. + if pending_root_alpha != AlphaBalance::ZERO { + Self::burn_subnet_alpha(netuid, pending_root_alpha); + } + AlphaBalance::ZERO + } else { + pending_root_alpha + }; + let total_alpha_minus_owner_cut = pending_server_alpha .saturating_add(pending_validator_alpha) .saturating_add(pending_root_alpha); diff --git a/pallets/subtensor/src/lib.rs b/pallets/subtensor/src/lib.rs index 75735c7471..ab862e7d60 100644 --- a/pallets/subtensor/src/lib.rs +++ b/pallets/subtensor/src/lib.rs @@ -1314,6 +1314,10 @@ pub mod pallet { pub type RootProp = StorageMap<_, Identity, NetUid, U96F32, ValueQuery, DefaultRootProp>; + /// --- ITEM --> burn_root_prop | Burn root-proportional subnet yield instead of paying it to root stakers. + #[pallet::storage] + pub type BurnRootProp = StorageValue<_, bool, ValueQuery, DefaultFalse>; + /// --- MAP ( netuid ) --> total_volume | The total amount of TAO bought and sold since the start of the network. #[pallet::storage] pub type SubnetVolume = diff --git a/pallets/subtensor/src/macros/dispatches.rs b/pallets/subtensor/src/macros/dispatches.rs index a98578d813..7ce116906e 100644 --- a/pallets/subtensor/src/macros/dispatches.rs +++ b/pallets/subtensor/src/macros/dispatches.rs @@ -2594,5 +2594,19 @@ mod dispatches { let coldkey = ensure_signed(origin)?; Self::do_move_lock(&coldkey, &destination_hotkey, netuid) } + + /// Sets whether root-proportional subnet yield is burned instead of paid to root stakers. + /// + /// This is root-only. When enabled, root stakers receive zero yield from the + /// root-proportional portion on every subnet; that alpha is burned instead. + #[pallet::call_index(139)] + #[pallet::weight( + Weight::from_parts(6_000, 0).saturating_add(T::DbWeight::get().writes(1)) + )] + pub fn sudo_set_burn_root_prop(origin: OriginFor, enabled: bool) -> DispatchResult { + ensure_root(origin)?; + Self::set_burn_root_prop(enabled); + Ok(()) + } } } diff --git a/pallets/subtensor/src/macros/events.rs b/pallets/subtensor/src/macros/events.rs index cdb37bb0dd..bdce2cc049 100644 --- a/pallets/subtensor/src/macros/events.rs +++ b/pallets/subtensor/src/macros/events.rs @@ -478,6 +478,12 @@ mod events { root_claim_type: RootClaimTypeEnum, }, + /// Root-proportional subnet yield burn mode has been toggled. + BurnRootPropSet { + /// Whether root-proportional yield is burned instead of paid to root stakers. + enabled: bool, + }, + /// Voting power tracking has been enabled for a subnet. VotingPowerTrackingEnabled { /// The subnet ID diff --git a/pallets/subtensor/src/staking/claim_root.rs b/pallets/subtensor/src/staking/claim_root.rs index 304eb37e5b..52a6b2a23e 100644 --- a/pallets/subtensor/src/staking/claim_root.rs +++ b/pallets/subtensor/src/staking/claim_root.rs @@ -42,6 +42,13 @@ impl Pallet { netuid: NetUid, amount: AlphaBalance, ) { + if Self::get_burn_root_prop() { + if amount != AlphaBalance::ZERO { + Self::burn_subnet_alpha(netuid, amount); + } + return; + } + // Get total stake on this hotkey on root. let total: I96F32 = I96F32::saturating_from_num(Self::get_stake_for_hotkey_on_subnet(hotkey, NetUid::ROOT)); @@ -131,6 +138,25 @@ impl Pallet { root_claim_type: RootClaimTypeEnum, ignore_minimum_condition: bool, ) { + if Self::get_burn_root_prop() { + // Existing unclaimed root yield should not be paid while burn mode is enabled. + // Burn it and advance RootClaimed so it cannot be claimed later through this path. + let owed: I96F32 = + Self::get_root_owed_for_hotkey_coldkey_float(hotkey, coldkey, netuid); + let owed_u64: u64 = if owed.is_negative() { + 0 + } else { + owed.saturating_to_num::() + }; + if owed_u64 > 0 { + Self::burn_subnet_alpha(netuid, AlphaBalance::from(owed_u64)); + RootClaimed::::mutate((netuid, hotkey, coldkey), |root_claimed| { + *root_claimed = root_claimed.saturating_add(u128::from(owed_u64)); + }); + } + return; + } + // Subtract the root claimed. let owed: I96F32 = Self::get_root_owed_for_hotkey_coldkey_float(hotkey, coldkey, netuid); diff --git a/pallets/subtensor/src/tests/coinbase.rs b/pallets/subtensor/src/tests/coinbase.rs index 6199aa9952..d1885dfd2c 100644 --- a/pallets/subtensor/src/tests/coinbase.rs +++ b/pallets/subtensor/src/tests/coinbase.rs @@ -4013,3 +4013,82 @@ fn test_get_subnet_terms_alpha_emissions_cap() { assert_eq!(alpha_in.get(&netuid).copied().unwrap(), tao_block_emission); }); } + +// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor --lib -- tests::coinbase::test_burn_root_prop_burns_instead_of_accumulating_root_alpha --exact --show-output --nocapture +#[test] +fn test_burn_root_prop_burns_instead_of_accumulating_root_alpha() { + new_test_ext(1).execute_with(|| { + let hotkey = U256::from(1); + let coldkey = U256::from(2); + let netuid = add_dynamic_network(&hotkey, &coldkey); + + remove_owner_registration_stake(netuid); + assert!( + SubtensorModule::sudo_set_burn_root_prop(RuntimeOrigin::signed(coldkey), true).is_err() + ); + assert_ok!(SubtensorModule::sudo_set_burn_root_prop( + RuntimeOrigin::root(), + true + )); + assert!(SubtensorModule::get_burn_root_prop()); + + Tempo::::insert(netuid, 1); + FirstEmissionBlockNumber::::insert(netuid, 0); + mock::setup_reserves(netuid, 1_000_000.into(), 1.into()); + + SubtensorModule::run_coinbase(SubtensorModule::mint_tao(0.into())); + SubnetTAO::::insert(NetUid::ROOT, TaoBalance::from(1_000_000_000)); + SubtensorModule::run_coinbase(SubtensorModule::mint_tao(0.into())); + + SubtensorModule::set_tempo(netuid, 10000); // Large number (dont drain) + SubtensorModule::set_tao_weight(u64::MAX); // Set TAO weight to 1.0 + SubnetMovingPrice::::insert(netuid, I96F32::from_num(2)); + + // Make sure this is the branch that would normally accumulate root alpha divs. + let root_sell_flag = SubtensorModule::get_network_root_sell_flag(&[netuid]); + assert!(root_sell_flag, "Root sell flag should be true"); + + // The public subnet root proportion and stored root prop are zeroed while enabled. + assert_eq!( + SubtensorModule::root_proportion(netuid), + U96F32::from_num(0) + ); + SubtensorModule::update_root_prop(); + assert_eq!(RootProp::::get(netuid), U96F32::from_num(0)); + + SubtensorModule::run_coinbase(SubtensorModule::mint_tao(0.into())); + + assert_abs_diff_eq!( + u64::from(PendingServerEmission::::get(netuid)), + 500_000_000, + epsilon = 1 + ); + assert_abs_diff_eq!( + u64::from(PendingValidatorEmission::::get(netuid)), + 500_000_000 - 125_000_000, + epsilon = 1 + ); + assert_eq!( + PendingRootAlphaDivs::::get(netuid), + AlphaBalance::ZERO + ); + + // Direct root-claimable writes should also burn instead of making root yield claimable. + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &hotkey, + &coldkey, + NetUid::ROOT, + AlphaBalance::from(1_000_000), + ); + SubtensorModule::increase_root_claimable_for_hotkey_and_subnet( + &hotkey, + netuid, + AlphaBalance::from(1_000), + ); + assert_eq!( + SubtensorModule::get_root_owed_for_hotkey_coldkey(&hotkey, &coldkey, netuid), + 0 + ); + assert!(RootClaimable::::get(hotkey).get(&netuid).is_none()); + }); +} From 6f0b2451110f89c232e1579637f37c3256e54067 Mon Sep 17 00:00:00 2001 From: John Reed <87283488+JohnReedV@users.noreply.github.com> Date: Thu, 14 May 2026 17:44:04 -0700 Subject: [PATCH 2/5] burn the tao after the pool, not alpha before --- .../subtensor/src/coinbase/run_coinbase.rs | 73 ++++---- pallets/subtensor/src/lib.rs | 2 +- pallets/subtensor/src/macros/dispatches.rs | 5 +- pallets/subtensor/src/macros/events.rs | 2 +- pallets/subtensor/src/staking/claim_root.rs | 125 +++++++------- pallets/subtensor/src/tests/claim_root.rs | 162 ++++++++++++++++++ pallets/subtensor/src/tests/coinbase.rs | 79 --------- 7 files changed, 260 insertions(+), 188 deletions(-) diff --git a/pallets/subtensor/src/coinbase/run_coinbase.rs b/pallets/subtensor/src/coinbase/run_coinbase.rs index 4cdadf9a09..f2d0920aa3 100644 --- a/pallets/subtensor/src/coinbase/run_coinbase.rs +++ b/pallets/subtensor/src/coinbase/run_coinbase.rs @@ -304,11 +304,8 @@ impl Pallet { let root_alpha_amount = AlphaBalance::from(tou64!(root_alpha)); - if burn_root_prop { - // Burn root yield unconditionally while the flag is enabled. - Self::burn_subnet_alpha(*netuid_i, root_alpha_amount); - } else if root_sell_flag { - // Only accumulate root alpha divs if root sell is allowed. + if burn_root_prop || root_sell_flag { + // Burn mode still creates root-sell pressure; the TAO proceeds are burned in root_claim_on_subnet. PendingRootAlphaDivs::::mutate(*netuid_i, |total| { *total = total.saturating_add(root_alpha_amount); }); @@ -685,39 +682,48 @@ impl Pallet { } // Distribute root alpha divs. + let burn_root_prop = Self::get_burn_root_prop(); let _ = RootAlphaDividendsPerSubnet::::clear_prefix(netuid, u32::MAX, None); - if Self::get_burn_root_prop() { - // Defense-in-depth: no call path may pay root while the flag is enabled. - for (_, root_alpha) in root_alpha_dividends { - Self::burn_subnet_alpha(netuid, AlphaBalance::from(tou64!(root_alpha))); - } - } else { - for (hotkey, mut root_alpha) in root_alpha_dividends { - // Get take prop - let alpha_take: U96F32 = - Self::get_hotkey_take_float(&hotkey).saturating_mul(root_alpha); - // Remove take prop from root_alpha - root_alpha = root_alpha.saturating_sub(alpha_take); - // Give the validator their take. - log::debug!("hotkey: {hotkey:?} alpha_take: {alpha_take:?}"); - Self::increase_stake_for_hotkey_and_coldkey_on_subnet( - &hotkey, - &Owner::::get(hotkey.clone()), - netuid, - tou64!(alpha_take).into(), - ); - + for (hotkey, mut root_alpha) in root_alpha_dividends { + if burn_root_prop { + // Keep root yield in the root-claim path so it is sold through the pool first. Self::increase_root_claimable_for_hotkey_and_subnet( &hotkey, netuid, tou64!(root_alpha).into(), ); - - // Record root alpha dividends for this validator on this subnet. RootAlphaDividendsPerSubnet::::mutate(netuid, &hotkey, |divs| { *divs = divs.saturating_add(tou64!(root_alpha).into()); }); + continue; } + + // Get take prop + let alpha_take: U96F32 = + Self::get_hotkey_take_float(&hotkey).saturating_mul(root_alpha); + + // Remove take prop from root_alpha + root_alpha = root_alpha.saturating_sub(alpha_take); + + // Give the validator their take. + log::debug!("hotkey: {hotkey:?} alpha_take: {alpha_take:?}"); + Self::increase_stake_for_hotkey_and_coldkey_on_subnet( + &hotkey, + &Owner::::get(hotkey.clone()), + netuid, + tou64!(alpha_take).into(), + ); + + Self::increase_root_claimable_for_hotkey_and_subnet( + &hotkey, + netuid, + tou64!(root_alpha).into(), + ); + + // Record root alpha dividends for this validator on this subnet. + RootAlphaDividendsPerSubnet::::mutate(netuid, &hotkey, |divs| { + *divs = divs.saturating_add(tou64!(root_alpha).into()); + }); } } @@ -777,17 +783,6 @@ impl Pallet { ); let tao_weight = Self::get_tao_weight(); - let pending_root_alpha = if Self::get_burn_root_prop() { - // Drain-and-burn any root alpha accumulated before the flag was switched on - // or supplied by an internal caller. - if pending_root_alpha != AlphaBalance::ZERO { - Self::burn_subnet_alpha(netuid, pending_root_alpha); - } - AlphaBalance::ZERO - } else { - pending_root_alpha - }; - let total_alpha_minus_owner_cut = pending_server_alpha .saturating_add(pending_validator_alpha) .saturating_add(pending_root_alpha); diff --git a/pallets/subtensor/src/lib.rs b/pallets/subtensor/src/lib.rs index ab862e7d60..c62cbb025c 100644 --- a/pallets/subtensor/src/lib.rs +++ b/pallets/subtensor/src/lib.rs @@ -1314,7 +1314,7 @@ pub mod pallet { pub type RootProp = StorageMap<_, Identity, NetUid, U96F32, ValueQuery, DefaultRootProp>; - /// --- ITEM --> burn_root_prop | Burn root-proportional subnet yield instead of paying it to root stakers. + /// --- ITEM --> burn_root_prop | Sell root-proportional subnet yield through subnet pools and burn the TAO proceeds. #[pallet::storage] pub type BurnRootProp = StorageValue<_, bool, ValueQuery, DefaultFalse>; diff --git a/pallets/subtensor/src/macros/dispatches.rs b/pallets/subtensor/src/macros/dispatches.rs index 7ce116906e..7ccc1d08cb 100644 --- a/pallets/subtensor/src/macros/dispatches.rs +++ b/pallets/subtensor/src/macros/dispatches.rs @@ -2595,10 +2595,11 @@ mod dispatches { Self::do_move_lock(&coldkey, &destination_hotkey, netuid) } - /// Sets whether root-proportional subnet yield is burned instead of paid to root stakers. + /// Sets whether root-proportional subnet yield is sold and burned instead of paid to root stakers. /// /// This is root-only. When enabled, root stakers receive zero yield from the - /// root-proportional portion on every subnet; that alpha is burned instead. + /// root-proportional portion on every subnet; root alpha is still sold through + /// the subnet pool and the resulting TAO is burned. #[pallet::call_index(139)] #[pallet::weight( Weight::from_parts(6_000, 0).saturating_add(T::DbWeight::get().writes(1)) diff --git a/pallets/subtensor/src/macros/events.rs b/pallets/subtensor/src/macros/events.rs index bdce2cc049..f3798a5c55 100644 --- a/pallets/subtensor/src/macros/events.rs +++ b/pallets/subtensor/src/macros/events.rs @@ -480,7 +480,7 @@ mod events { /// Root-proportional subnet yield burn mode has been toggled. BurnRootPropSet { - /// Whether root-proportional yield is burned instead of paid to root stakers. + /// Whether root-proportional yield is sold through subnet pools and burned instead of paid to root stakers. enabled: bool, }, diff --git a/pallets/subtensor/src/staking/claim_root.rs b/pallets/subtensor/src/staking/claim_root.rs index 52a6b2a23e..3e3590cfe3 100644 --- a/pallets/subtensor/src/staking/claim_root.rs +++ b/pallets/subtensor/src/staking/claim_root.rs @@ -42,13 +42,6 @@ impl Pallet { netuid: NetUid, amount: AlphaBalance, ) { - if Self::get_burn_root_prop() { - if amount != AlphaBalance::ZERO { - Self::burn_subnet_alpha(netuid, amount); - } - return; - } - // Get total stake on this hotkey on root. let total: I96F32 = I96F32::saturating_from_num(Self::get_stake_for_hotkey_on_subnet(hotkey, NetUid::ROOT)); @@ -59,7 +52,7 @@ impl Pallet { .unwrap_or(I96F32::saturating_from_num(0.0)); // Unlikely to happen. This is mostly for test environment sanity checks. - if u64::from(amount) > total.saturating_to_num::() { + if u64::from(amount) > total.saturating_to_num::() && !Self::get_burn_root_prop() { log::warn!("Not enough root stake. NetUID = {netuid}"); let owner = Owner::::get(hotkey); @@ -138,25 +131,6 @@ impl Pallet { root_claim_type: RootClaimTypeEnum, ignore_minimum_condition: bool, ) { - if Self::get_burn_root_prop() { - // Existing unclaimed root yield should not be paid while burn mode is enabled. - // Burn it and advance RootClaimed so it cannot be claimed later through this path. - let owed: I96F32 = - Self::get_root_owed_for_hotkey_coldkey_float(hotkey, coldkey, netuid); - let owed_u64: u64 = if owed.is_negative() { - 0 - } else { - owed.saturating_to_num::() - }; - if owed_u64 > 0 { - Self::burn_subnet_alpha(netuid, AlphaBalance::from(owed_u64)); - RootClaimed::::mutate((netuid, hotkey, coldkey), |root_claimed| { - *root_claimed = root_claimed.saturating_add(u128::from(owed_u64)); - }); - } - return; - } - // Subtract the root claimed. let owed: I96F32 = Self::get_root_owed_for_hotkey_coldkey_float(hotkey, coldkey, netuid); @@ -183,11 +157,14 @@ impl Pallet { return; // no-op } - let swap = match root_claim_type { - RootClaimTypeEnum::Swap => true, - RootClaimTypeEnum::Keep => false, - RootClaimTypeEnum::KeepSubnets { subnets } => !subnets.contains(&netuid), - }; + let burn_root_prop = Self::get_burn_root_prop(); + + let swap = burn_root_prop + || match root_claim_type { + RootClaimTypeEnum::Swap => true, + RootClaimTypeEnum::Keep => false, + RootClaimTypeEnum::KeepSubnets { subnets } => !subnets.contains(&netuid), + }; if swap { // Increase stake on root. Swap the alpha owed to TAO @@ -212,44 +189,60 @@ impl Pallet { }); Self::record_protocol_outflow(netuid, root_sell_tao); - // Transfer unstaked TAO from subnet account to the root subnet account - // and increase root stake. - if let Some(root_subnet_account_id) = Self::get_subnet_account_id(NetUid::ROOT) - && Self::transfer_tao_from_subnet( - netuid, - &root_subnet_account_id, - owed_tao.amount_paid_out.into(), - ) - .is_ok() - { - Self::increase_stake_for_hotkey_and_coldkey_on_subnet( + if burn_root_prop { + if let Some(subnet_account_id) = Self::get_subnet_account_id(netuid) { + if let Err(err) = + Self::burn_tao(&subnet_account_id, owed_tao.amount_paid_out.into()) + { + log::error!("Could not burn root prop TAO: {err:?}"); + return; + } + } else { + log::error!( + "Could not burn root prop TAO: subnet account does not exist for netuid {netuid}" + ); + return; + } + } else { + // Transfer unstaked TAO from subnet account to the root subnet account + // and increase root stake. + if let Some(root_subnet_account_id) = Self::get_subnet_account_id(NetUid::ROOT) + && Self::transfer_tao_from_subnet( + netuid, + &root_subnet_account_id, + owed_tao.amount_paid_out.into(), + ) + .is_ok() + { + Self::increase_stake_for_hotkey_and_coldkey_on_subnet( + hotkey, + coldkey, + NetUid::ROOT, + owed_tao.amount_paid_out.to_u64().into(), + ); + + // Increase root subnet SubnetTAO + SubnetTAO::::mutate(NetUid::ROOT, |total| { + *total = total.saturating_add(owed_tao.amount_paid_out.into()); + }); + + // Increase root SubnetAlphaOut + SubnetAlphaOut::::mutate(NetUid::ROOT, |total| { + *total = total.saturating_add(u64::from(owed_tao.amount_paid_out).into()); + }); + + // Increase Total Stake + TotalStake::::mutate(|total| { + *total = total.saturating_add(owed_tao.amount_paid_out.into()); + }); + } + + Self::add_stake_adjust_root_claimed_for_hotkey_and_coldkey( hotkey, coldkey, - NetUid::ROOT, - owed_tao.amount_paid_out.to_u64().into(), + owed_tao.amount_paid_out.into(), ); - - // Increase root subnet SubnetTAO - SubnetTAO::::mutate(NetUid::ROOT, |total| { - *total = total.saturating_add(owed_tao.amount_paid_out.into()); - }); - - // Increase root SubnetAlphaOut - SubnetAlphaOut::::mutate(NetUid::ROOT, |total| { - *total = total.saturating_add(u64::from(owed_tao.amount_paid_out).into()); - }); - - // Increase Total Stake - TotalStake::::mutate(|total| { - *total = total.saturating_add(owed_tao.amount_paid_out.into()); - }); } - - Self::add_stake_adjust_root_claimed_for_hotkey_and_coldkey( - hotkey, - coldkey, - owed_tao.amount_paid_out.into(), - ); } else /* Keep */ { diff --git a/pallets/subtensor/src/tests/claim_root.rs b/pallets/subtensor/src/tests/claim_root.rs index bd5761f376..70b69991c4 100644 --- a/pallets/subtensor/src/tests/claim_root.rs +++ b/pallets/subtensor/src/tests/claim_root.rs @@ -2056,3 +2056,165 @@ fn test_claim_root_with_moved_stake() { assert_abs_diff_eq!(bob_stake_diff2, estimated_stake as u64, epsilon = 100u64,); }); } + +// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor --lib -- tests::claim_root::test_burn_root_prop_sells_root_yield_then_burns_tao --exact --show-output --nocapture +#[test] +fn test_burn_root_prop_sells_root_yield_then_burns_tao() { + new_test_ext(1).execute_with(|| { + let owner_coldkey = U256::from(1001); + let other_coldkey = U256::from(10010); + let hotkey = U256::from(1002); + let coldkey = U256::from(1003); + let netuid = add_dynamic_network(&hotkey, &owner_coldkey); + + SubtensorModule::set_tao_weight(u64::MAX); // Set TAO weight to 1.0 + SubnetMechanism::::insert(netuid, 1); + + let tao_reserve = TaoBalance::from(50_000_000_000_u64); + let alpha_in = AlphaBalance::from(100_000_000_000_u64); + SubnetTAO::::insert(netuid, tao_reserve); + SubnetAlphaIn::::insert(netuid, alpha_in); + + let root_stake = 2_000_000u64; + mock_increase_stake_for_hotkey_and_coldkey_on_subnet( + &hotkey, + &coldkey, + NetUid::ROOT, + root_stake.into(), + ); + mock_increase_stake_for_hotkey_and_coldkey_on_subnet( + &hotkey, + &other_coldkey, + NetUid::ROOT, + (9 * root_stake).into(), + ); + + let initial_total_hotkey_alpha = 10_000_000u64; + mock_increase_stake_for_hotkey_and_coldkey_on_subnet( + &hotkey, + &owner_coldkey, + netuid, + initial_total_hotkey_alpha.into(), + ); + + assert_noop!( + SubtensorModule::sudo_set_burn_root_prop(RuntimeOrigin::signed(coldkey), true), + DispatchError::BadOrigin + ); + assert!(!crate::BurnRootProp::::get()); + + assert_ok!(SubtensorModule::sudo_set_burn_root_prop( + RuntimeOrigin::root(), + true, + )); + assert!(crate::BurnRootProp::::get()); + + // Public/stored root prop is zeroed while burn mode is enabled. + assert_eq!( + SubtensorModule::root_proportion(netuid), + substrate_fixed::types::U96F32::from_num(0.0) + ); + SubtensorModule::update_root_prop(); + assert_eq!( + crate::RootProp::::get(netuid), + substrate_fixed::types::U96F32::from_num(0.0) + ); + + let owner_stake_before = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet( + &hotkey, + &owner_coldkey, + netuid, + ); + let root_stake_before = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet( + &hotkey, + &coldkey, + NetUid::ROOT, + ); + let coldkey_subnet_stake_before = + SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid); + let root_subnet_tao_before = SubnetTAO::::get(NetUid::ROOT); + let total_stake_before = crate::TotalStake::::get(); + use sp_core::Get; + use sp_runtime::traits::AccountIdConversion; + let burn_account: U256 = + ::BurnAccountId::get().into_account_truncating(); + let burn_balance_before = SubtensorModule::get_coldkey_balance(&burn_account); + + // Distribute pending root alpha. Burn mode must not pay validator take here; + // it should create root claimable that will be sold and burned on claim. + let pending_root_alpha = 10_000_000u64; + SubtensorModule::distribute_emission( + netuid, + AlphaBalance::ZERO, + AlphaBalance::ZERO, + pending_root_alpha.into(), + AlphaBalance::ZERO, + ); + + assert_eq!( + SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet( + &hotkey, + &owner_coldkey, + netuid, + ), + owner_stake_before + ); + assert!( + crate::RootAlphaDividendsPerSubnet::::get(netuid, hotkey) > AlphaBalance::ZERO + ); + let owed_before = + SubtensorModule::get_root_owed_for_hotkey_coldkey(&hotkey, &coldkey, netuid); + assert!(owed_before > 0); + + // Even with claim type Keep, burn mode must force root yield to sell + // through the subnet pool and burn the TAO proceeds instead of staking/paying. + assert_ok!(SubtensorModule::set_root_claim_type( + RuntimeOrigin::signed(coldkey), + RootClaimTypeEnum::Keep + )); + assert_eq!(RootClaimType::::get(coldkey), RootClaimTypeEnum::Keep); + + let subnet_tao_before_claim = SubnetTAO::::get(netuid); + let root_sell_tao_before = crate::SubnetRootSellTao::::get(netuid); + assert_ok!(SubtensorModule::claim_root( + RuntimeOrigin::signed(coldkey), + BTreeSet::from([netuid]) + )); + + let root_sell_tao = + crate::SubnetRootSellTao::::get(netuid).saturating_sub(root_sell_tao_before); + assert!(root_sell_tao > TaoBalance::ZERO); + assert_eq!( + subnet_tao_before_claim.saturating_sub(SubnetTAO::::get(netuid)), + root_sell_tao + ); + assert_eq!( + SubtensorModule::get_coldkey_balance(&burn_account).saturating_sub(burn_balance_before), + root_sell_tao.into() + ); + + assert_eq!( + SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet( + &hotkey, + &coldkey, + NetUid::ROOT, + ), + root_stake_before + ); + assert_eq!( + SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid,), + coldkey_subnet_stake_before + ); + + // Base swap claims send sold TAO into root stake/accounting. Burn mode must not. + assert!(SubnetTAO::::get(NetUid::ROOT) <= root_subnet_tao_before); + assert_eq!( + total_stake_before.saturating_sub(crate::TotalStake::::get()), + root_sell_tao + ); + assert_eq!( + SubtensorModule::get_root_owed_for_hotkey_coldkey(&hotkey, &coldkey, netuid), + 0 + ); + }); +} diff --git a/pallets/subtensor/src/tests/coinbase.rs b/pallets/subtensor/src/tests/coinbase.rs index d1885dfd2c..6199aa9952 100644 --- a/pallets/subtensor/src/tests/coinbase.rs +++ b/pallets/subtensor/src/tests/coinbase.rs @@ -4013,82 +4013,3 @@ fn test_get_subnet_terms_alpha_emissions_cap() { assert_eq!(alpha_in.get(&netuid).copied().unwrap(), tao_block_emission); }); } - -// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor --lib -- tests::coinbase::test_burn_root_prop_burns_instead_of_accumulating_root_alpha --exact --show-output --nocapture -#[test] -fn test_burn_root_prop_burns_instead_of_accumulating_root_alpha() { - new_test_ext(1).execute_with(|| { - let hotkey = U256::from(1); - let coldkey = U256::from(2); - let netuid = add_dynamic_network(&hotkey, &coldkey); - - remove_owner_registration_stake(netuid); - assert!( - SubtensorModule::sudo_set_burn_root_prop(RuntimeOrigin::signed(coldkey), true).is_err() - ); - assert_ok!(SubtensorModule::sudo_set_burn_root_prop( - RuntimeOrigin::root(), - true - )); - assert!(SubtensorModule::get_burn_root_prop()); - - Tempo::::insert(netuid, 1); - FirstEmissionBlockNumber::::insert(netuid, 0); - mock::setup_reserves(netuid, 1_000_000.into(), 1.into()); - - SubtensorModule::run_coinbase(SubtensorModule::mint_tao(0.into())); - SubnetTAO::::insert(NetUid::ROOT, TaoBalance::from(1_000_000_000)); - SubtensorModule::run_coinbase(SubtensorModule::mint_tao(0.into())); - - SubtensorModule::set_tempo(netuid, 10000); // Large number (dont drain) - SubtensorModule::set_tao_weight(u64::MAX); // Set TAO weight to 1.0 - SubnetMovingPrice::::insert(netuid, I96F32::from_num(2)); - - // Make sure this is the branch that would normally accumulate root alpha divs. - let root_sell_flag = SubtensorModule::get_network_root_sell_flag(&[netuid]); - assert!(root_sell_flag, "Root sell flag should be true"); - - // The public subnet root proportion and stored root prop are zeroed while enabled. - assert_eq!( - SubtensorModule::root_proportion(netuid), - U96F32::from_num(0) - ); - SubtensorModule::update_root_prop(); - assert_eq!(RootProp::::get(netuid), U96F32::from_num(0)); - - SubtensorModule::run_coinbase(SubtensorModule::mint_tao(0.into())); - - assert_abs_diff_eq!( - u64::from(PendingServerEmission::::get(netuid)), - 500_000_000, - epsilon = 1 - ); - assert_abs_diff_eq!( - u64::from(PendingValidatorEmission::::get(netuid)), - 500_000_000 - 125_000_000, - epsilon = 1 - ); - assert_eq!( - PendingRootAlphaDivs::::get(netuid), - AlphaBalance::ZERO - ); - - // Direct root-claimable writes should also burn instead of making root yield claimable. - SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( - &hotkey, - &coldkey, - NetUid::ROOT, - AlphaBalance::from(1_000_000), - ); - SubtensorModule::increase_root_claimable_for_hotkey_and_subnet( - &hotkey, - netuid, - AlphaBalance::from(1_000), - ); - assert_eq!( - SubtensorModule::get_root_owed_for_hotkey_coldkey(&hotkey, &coldkey, netuid), - 0 - ); - assert!(RootClaimable::::get(hotkey).get(&netuid).is_none()); - }); -} From 35d1ba5c6108d6f91045b4ef00738c1f3e95f935 Mon Sep 17 00:00:00 2001 From: John Reed <87283488+JohnReedV@users.noreply.github.com> Date: Thu, 14 May 2026 19:27:09 -0700 Subject: [PATCH 3/5] clippy --- pallets/subtensor/src/tests/claim_root.rs | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/pallets/subtensor/src/tests/claim_root.rs b/pallets/subtensor/src/tests/claim_root.rs index 70b69991c4..b6dfdc355e 100644 --- a/pallets/subtensor/src/tests/claim_root.rs +++ b/pallets/subtensor/src/tests/claim_root.rs @@ -14,13 +14,12 @@ use frame_support::dispatch::RawOrigin; use frame_support::pallet_prelude::Weight; use frame_support::traits::Get; use frame_support::{assert_err, assert_noop, assert_ok}; -use sp_core::{H256, U256}; -use sp_runtime::DispatchError; +use sp_core::{Get, H256, U256}; +use sp_runtime::{DispatchError, traits::AccountIdConversion}; use std::collections::BTreeSet; use substrate_fixed::types::{I96F32, U64F64}; use subtensor_runtime_common::{AlphaBalance, NetUid, TaoBalance, Token}; use subtensor_swap_interface::SwapHandler; - #[test] fn test_claim_root_set_claim_type() { new_test_ext(1).execute_with(|| { @@ -2134,8 +2133,7 @@ fn test_burn_root_prop_sells_root_yield_then_burns_tao() { SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid); let root_subnet_tao_before = SubnetTAO::::get(NetUid::ROOT); let total_stake_before = crate::TotalStake::::get(); - use sp_core::Get; - use sp_runtime::traits::AccountIdConversion; + let burn_account: U256 = ::BurnAccountId::get().into_account_truncating(); let burn_balance_before = SubtensorModule::get_coldkey_balance(&burn_account); From 961c4fddebf359aa81052e7d3d082f16c2a62101 Mon Sep 17 00:00:00 2001 From: John Reed <87283488+JohnReedV@users.noreply.github.com> Date: Thu, 14 May 2026 19:35:37 -0700 Subject: [PATCH 4/5] fix compile --- pallets/subtensor/src/tests/claim_root.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pallets/subtensor/src/tests/claim_root.rs b/pallets/subtensor/src/tests/claim_root.rs index b6dfdc355e..069f74973c 100644 --- a/pallets/subtensor/src/tests/claim_root.rs +++ b/pallets/subtensor/src/tests/claim_root.rs @@ -14,7 +14,7 @@ use frame_support::dispatch::RawOrigin; use frame_support::pallet_prelude::Weight; use frame_support::traits::Get; use frame_support::{assert_err, assert_noop, assert_ok}; -use sp_core::{Get, H256, U256}; +use sp_core::{H256, U256}; use sp_runtime::{DispatchError, traits::AccountIdConversion}; use std::collections::BTreeSet; use substrate_fixed::types::{I96F32, U64F64}; From 5d2392b0c3cfa751eef2ef1573b62e5f394ab8f7 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Fri, 15 May 2026 13:20:13 +0000 Subject: [PATCH 5/5] auto-update benchmark weights --- pallets/proxy/src/weights.rs | 220 +++++----- pallets/subtensor/src/weights.rs | 732 ++++++++++++++++--------------- pallets/utility/src/weights.rs | 84 ++-- 3 files changed, 538 insertions(+), 498 deletions(-) diff --git a/pallets/proxy/src/weights.rs b/pallets/proxy/src/weights.rs index a3c4f86593..8fce95920c 100644 --- a/pallets/proxy/src/weights.rs +++ b/pallets/proxy/src/weights.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_subtensor_proxy` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 49.1.0 -//! DATE: 2026-05-04, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2026-05-15, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! HOSTNAME: `runnervmeorf1`, CPU: `AMD EPYC 7763 64-Core Processor` //! WASM-EXECUTION: `Compiled`, CHAIN: `None`, DB CACHE: `1024` @@ -22,7 +22,7 @@ // --no-storage-info // --no-min-squares // --no-median-slopes -// --output=/tmp/tmp.9knXnirNE8 +// --output=/tmp/tmp.WwgF6G3Iad // --template=/home/runner/work/subtensor/subtensor/.maintain/frame-weight-template.hbs #![cfg_attr(rustfmt, rustfmt_skip)] @@ -66,10 +66,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `637 + p * (37 ±0)` // Estimated: `4254 + p * (37 ±0)` - // Minimum execution time: 26_350_000 picoseconds. - Weight::from_parts(27_408_803, 4254) - // Standard Error: 3_640 - .saturating_add(Weight::from_parts(65_542, 0).saturating_mul(p.into())) + // Minimum execution time: 25_969_000 picoseconds. + Weight::from_parts(27_017_043, 4254) + // Standard Error: 3_646 + .saturating_add(Weight::from_parts(71_894, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(3_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 37).saturating_mul(p.into())) @@ -92,12 +92,12 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `894 + a * (68 ±0) + p * (37 ±0)` // Estimated: `8615 + a * (68 ±0) + p * (37 ±0)` - // Minimum execution time: 51_918_000 picoseconds. - Weight::from_parts(52_350_307, 8615) - // Standard Error: 1_900 - .saturating_add(Weight::from_parts(216_569, 0).saturating_mul(a.into())) - // Standard Error: 7_612 - .saturating_add(Weight::from_parts(48_719, 0).saturating_mul(p.into())) + // Minimum execution time: 51_617_000 picoseconds. + Weight::from_parts(52_570_925, 8615) + // Standard Error: 1_648 + .saturating_add(Weight::from_parts(210_833, 0).saturating_mul(a.into())) + // Standard Error: 6_601 + .saturating_add(Weight::from_parts(29_858, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(5_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 68).saturating_mul(a.into())) @@ -113,12 +113,12 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `299 + a * (68 ±0)` // Estimated: `8615` - // Minimum execution time: 25_298_000 picoseconds. - Weight::from_parts(25_519_010, 8615) - // Standard Error: 1_285 - .saturating_add(Weight::from_parts(199_662, 0).saturating_mul(a.into())) - // Standard Error: 5_148 - .saturating_add(Weight::from_parts(12_673, 0).saturating_mul(p.into())) + // Minimum execution time: 25_067_000 picoseconds. + Weight::from_parts(25_725_767, 8615) + // Standard Error: 1_283 + .saturating_add(Weight::from_parts(185_947, 0).saturating_mul(a.into())) + // Standard Error: 5_139 + .saturating_add(Weight::from_parts(23_996, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -132,12 +132,12 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `299 + a * (68 ±0)` // Estimated: `8615` - // Minimum execution time: 25_387_000 picoseconds. - Weight::from_parts(25_517_797, 8615) - // Standard Error: 1_246 - .saturating_add(Weight::from_parts(193_411, 0).saturating_mul(a.into())) - // Standard Error: 4_993 - .saturating_add(Weight::from_parts(29_999, 0).saturating_mul(p.into())) + // Minimum execution time: 24_997_000 picoseconds. + Weight::from_parts(26_074_628, 8615) + // Standard Error: 2_365 + .saturating_add(Weight::from_parts(181_218, 0).saturating_mul(a.into())) + // Standard Error: 9_472 + .saturating_add(Weight::from_parts(23_030, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -153,12 +153,12 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `308 + a * (68 ±0) + p * (37 ±0)` // Estimated: `8615` - // Minimum execution time: 32_732_000 picoseconds. - Weight::from_parts(33_019_988, 8615) - // Standard Error: 1_111 - .saturating_add(Weight::from_parts(194_225, 0).saturating_mul(a.into())) - // Standard Error: 4_452 - .saturating_add(Weight::from_parts(51_072, 0).saturating_mul(p.into())) + // Minimum execution time: 32_481_000 picoseconds. + Weight::from_parts(32_837_620, 8615) + // Standard Error: 1_165 + .saturating_add(Weight::from_parts(186_465, 0).saturating_mul(a.into())) + // Standard Error: 4_668 + .saturating_add(Weight::from_parts(66_402, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(3_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -169,10 +169,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `119 + p * (37 ±0)` // Estimated: `4254` - // Minimum execution time: 24_486_000 picoseconds. - Weight::from_parts(25_216_335, 4254) - // Standard Error: 2_643 - .saturating_add(Weight::from_parts(67_253, 0).saturating_mul(p.into())) + // Minimum execution time: 24_215_000 picoseconds. + Weight::from_parts(24_827_745, 4254) + // Standard Error: 2_299 + .saturating_add(Weight::from_parts(78_159, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -185,10 +185,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `119 + p * (37 ±0)` // Estimated: `4254` - // Minimum execution time: 25_999_000 picoseconds. - Weight::from_parts(27_109_216, 4254) - // Standard Error: 2_754 - .saturating_add(Weight::from_parts(71_289, 0).saturating_mul(p.into())) + // Minimum execution time: 25_639_000 picoseconds. + Weight::from_parts(26_656_735, 4254) + // Standard Error: 2_742 + .saturating_add(Weight::from_parts(82_743, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -199,10 +199,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `119 + p * (37 ±0)` // Estimated: `4254` - // Minimum execution time: 25_848_000 picoseconds. - Weight::from_parts(26_822_162, 4254) - // Standard Error: 4_056 - .saturating_add(Weight::from_parts(57_793, 0).saturating_mul(p.into())) + // Minimum execution time: 25_608_000 picoseconds. + Weight::from_parts(26_950_505, 4254) + // Standard Error: 5_165 + .saturating_add(Weight::from_parts(74_907, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -213,10 +213,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `139` // Estimated: `4254` - // Minimum execution time: 26_069_000 picoseconds. - Weight::from_parts(27_224_850, 4254) - // Standard Error: 2_890 - .saturating_add(Weight::from_parts(26_102, 0).saturating_mul(p.into())) + // Minimum execution time: 25_448_000 picoseconds. + Weight::from_parts(26_435_051, 4254) + // Standard Error: 2_848 + .saturating_add(Weight::from_parts(30_705, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -227,10 +227,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `156 + p * (37 ±0)` // Estimated: `4254` - // Minimum execution time: 24_847_000 picoseconds. - Weight::from_parts(25_942_688, 4254) - // Standard Error: 3_765 - .saturating_add(Weight::from_parts(50_048, 0).saturating_mul(p.into())) + // Minimum execution time: 24_597_000 picoseconds. + Weight::from_parts(25_553_393, 4254) + // Standard Error: 2_574 + .saturating_add(Weight::from_parts(46_519, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -244,8 +244,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `412` // Estimated: `8615` - // Minimum execution time: 44_584_000 picoseconds. - Weight::from_parts(45_826_000, 8615) + // Minimum execution time: 43_913_000 picoseconds. + Weight::from_parts(45_075_000, 8615) .saturating_add(T::DbWeight::get().reads(3_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } @@ -258,10 +258,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `119 + p * (37 ±0)` // Estimated: `4254` - // Minimum execution time: 13_766_000 picoseconds. - Weight::from_parts(14_373_774, 4254) - // Standard Error: 2_247 - .saturating_add(Weight::from_parts(42_752, 0).saturating_mul(p.into())) + // Minimum execution time: 13_485_000 picoseconds. + Weight::from_parts(14_271_847, 4254) + // Standard Error: 1_952 + .saturating_add(Weight::from_parts(35_084, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -282,10 +282,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `637 + p * (37 ±0)` // Estimated: `4254 + p * (37 ±0)` - // Minimum execution time: 26_350_000 picoseconds. - Weight::from_parts(27_408_803, 4254) - // Standard Error: 3_640 - .saturating_add(Weight::from_parts(65_542, 0).saturating_mul(p.into())) + // Minimum execution time: 25_969_000 picoseconds. + Weight::from_parts(27_017_043, 4254) + // Standard Error: 3_646 + .saturating_add(Weight::from_parts(71_894, 0).saturating_mul(p.into())) .saturating_add(RocksDbWeight::get().reads(3_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 37).saturating_mul(p.into())) @@ -308,12 +308,12 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `894 + a * (68 ±0) + p * (37 ±0)` // Estimated: `8615 + a * (68 ±0) + p * (37 ±0)` - // Minimum execution time: 51_918_000 picoseconds. - Weight::from_parts(52_350_307, 8615) - // Standard Error: 1_900 - .saturating_add(Weight::from_parts(216_569, 0).saturating_mul(a.into())) - // Standard Error: 7_612 - .saturating_add(Weight::from_parts(48_719, 0).saturating_mul(p.into())) + // Minimum execution time: 51_617_000 picoseconds. + Weight::from_parts(52_570_925, 8615) + // Standard Error: 1_648 + .saturating_add(Weight::from_parts(210_833, 0).saturating_mul(a.into())) + // Standard Error: 6_601 + .saturating_add(Weight::from_parts(29_858, 0).saturating_mul(p.into())) .saturating_add(RocksDbWeight::get().reads(5_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 68).saturating_mul(a.into())) @@ -329,12 +329,12 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `299 + a * (68 ±0)` // Estimated: `8615` - // Minimum execution time: 25_298_000 picoseconds. - Weight::from_parts(25_519_010, 8615) - // Standard Error: 1_285 - .saturating_add(Weight::from_parts(199_662, 0).saturating_mul(a.into())) - // Standard Error: 5_148 - .saturating_add(Weight::from_parts(12_673, 0).saturating_mul(p.into())) + // Minimum execution time: 25_067_000 picoseconds. + Weight::from_parts(25_725_767, 8615) + // Standard Error: 1_283 + .saturating_add(Weight::from_parts(185_947, 0).saturating_mul(a.into())) + // Standard Error: 5_139 + .saturating_add(Weight::from_parts(23_996, 0).saturating_mul(p.into())) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -348,12 +348,12 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `299 + a * (68 ±0)` // Estimated: `8615` - // Minimum execution time: 25_387_000 picoseconds. - Weight::from_parts(25_517_797, 8615) - // Standard Error: 1_246 - .saturating_add(Weight::from_parts(193_411, 0).saturating_mul(a.into())) - // Standard Error: 4_993 - .saturating_add(Weight::from_parts(29_999, 0).saturating_mul(p.into())) + // Minimum execution time: 24_997_000 picoseconds. + Weight::from_parts(26_074_628, 8615) + // Standard Error: 2_365 + .saturating_add(Weight::from_parts(181_218, 0).saturating_mul(a.into())) + // Standard Error: 9_472 + .saturating_add(Weight::from_parts(23_030, 0).saturating_mul(p.into())) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -369,12 +369,12 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `308 + a * (68 ±0) + p * (37 ±0)` // Estimated: `8615` - // Minimum execution time: 32_732_000 picoseconds. - Weight::from_parts(33_019_988, 8615) - // Standard Error: 1_111 - .saturating_add(Weight::from_parts(194_225, 0).saturating_mul(a.into())) - // Standard Error: 4_452 - .saturating_add(Weight::from_parts(51_072, 0).saturating_mul(p.into())) + // Minimum execution time: 32_481_000 picoseconds. + Weight::from_parts(32_837_620, 8615) + // Standard Error: 1_165 + .saturating_add(Weight::from_parts(186_465, 0).saturating_mul(a.into())) + // Standard Error: 4_668 + .saturating_add(Weight::from_parts(66_402, 0).saturating_mul(p.into())) .saturating_add(RocksDbWeight::get().reads(3_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -385,10 +385,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `119 + p * (37 ±0)` // Estimated: `4254` - // Minimum execution time: 24_486_000 picoseconds. - Weight::from_parts(25_216_335, 4254) - // Standard Error: 2_643 - .saturating_add(Weight::from_parts(67_253, 0).saturating_mul(p.into())) + // Minimum execution time: 24_215_000 picoseconds. + Weight::from_parts(24_827_745, 4254) + // Standard Error: 2_299 + .saturating_add(Weight::from_parts(78_159, 0).saturating_mul(p.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -401,10 +401,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `119 + p * (37 ±0)` // Estimated: `4254` - // Minimum execution time: 25_999_000 picoseconds. - Weight::from_parts(27_109_216, 4254) - // Standard Error: 2_754 - .saturating_add(Weight::from_parts(71_289, 0).saturating_mul(p.into())) + // Minimum execution time: 25_639_000 picoseconds. + Weight::from_parts(26_656_735, 4254) + // Standard Error: 2_742 + .saturating_add(Weight::from_parts(82_743, 0).saturating_mul(p.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -415,10 +415,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `119 + p * (37 ±0)` // Estimated: `4254` - // Minimum execution time: 25_848_000 picoseconds. - Weight::from_parts(26_822_162, 4254) - // Standard Error: 4_056 - .saturating_add(Weight::from_parts(57_793, 0).saturating_mul(p.into())) + // Minimum execution time: 25_608_000 picoseconds. + Weight::from_parts(26_950_505, 4254) + // Standard Error: 5_165 + .saturating_add(Weight::from_parts(74_907, 0).saturating_mul(p.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -429,10 +429,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `139` // Estimated: `4254` - // Minimum execution time: 26_069_000 picoseconds. - Weight::from_parts(27_224_850, 4254) - // Standard Error: 2_890 - .saturating_add(Weight::from_parts(26_102, 0).saturating_mul(p.into())) + // Minimum execution time: 25_448_000 picoseconds. + Weight::from_parts(26_435_051, 4254) + // Standard Error: 2_848 + .saturating_add(Weight::from_parts(30_705, 0).saturating_mul(p.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -443,10 +443,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `156 + p * (37 ±0)` // Estimated: `4254` - // Minimum execution time: 24_847_000 picoseconds. - Weight::from_parts(25_942_688, 4254) - // Standard Error: 3_765 - .saturating_add(Weight::from_parts(50_048, 0).saturating_mul(p.into())) + // Minimum execution time: 24_597_000 picoseconds. + Weight::from_parts(25_553_393, 4254) + // Standard Error: 2_574 + .saturating_add(Weight::from_parts(46_519, 0).saturating_mul(p.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -460,8 +460,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `412` // Estimated: `8615` - // Minimum execution time: 44_584_000 picoseconds. - Weight::from_parts(45_826_000, 8615) + // Minimum execution time: 43_913_000 picoseconds. + Weight::from_parts(45_075_000, 8615) .saturating_add(RocksDbWeight::get().reads(3_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } @@ -474,10 +474,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `119 + p * (37 ±0)` // Estimated: `4254` - // Minimum execution time: 13_766_000 picoseconds. - Weight::from_parts(14_373_774, 4254) - // Standard Error: 2_247 - .saturating_add(Weight::from_parts(42_752, 0).saturating_mul(p.into())) + // Minimum execution time: 13_485_000 picoseconds. + Weight::from_parts(14_271_847, 4254) + // Standard Error: 1_952 + .saturating_add(Weight::from_parts(35_084, 0).saturating_mul(p.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } diff --git a/pallets/subtensor/src/weights.rs b/pallets/subtensor/src/weights.rs index 4e759e12e0..2cbc5f70bf 100644 --- a/pallets/subtensor/src/weights.rs +++ b/pallets/subtensor/src/weights.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_subtensor` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 49.1.0 -//! DATE: 2026-05-04, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2026-05-15, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! HOSTNAME: `runnervmeorf1`, CPU: `AMD EPYC 7763 64-Core Processor` //! WASM-EXECUTION: `Compiled`, CHAIN: `None`, DB CACHE: `1024` @@ -22,7 +22,7 @@ // --no-storage-info // --no-min-squares // --no-median-slopes -// --output=/tmp/tmp.bgeSTyDtzW +// --output=/tmp/tmp.x62sZN5jH7 // --template=/home/runner/work/subtensor/subtensor/.maintain/frame-weight-template.hbs #![cfg_attr(rustfmt, rustfmt_skip)] @@ -180,6 +180,8 @@ impl WeightInfo for SubstrateWeight { /// Proof: `SubtensorModule::RegistrationsThisBlock` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::RAORecycledForRegistration` (r:1 w:1) /// Proof: `SubtensorModule::RAORecycledForRegistration` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `SubtensorModule::SubnetTaoFlow` (r:1 w:1) + /// Proof: `SubtensorModule::SubnetTaoFlow` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::BlockAtRegistration` (r:0 w:1) /// Proof: `SubtensorModule::BlockAtRegistration` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::Keys` (r:0 w:1) @@ -194,10 +196,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `1706` // Estimated: `13600` - // Minimum execution time: 355_490_000 picoseconds. - Weight::from_parts(364_739_000, 13600) - .saturating_add(T::DbWeight::get().reads(47_u64)) - .saturating_add(T::DbWeight::get().writes(39_u64)) + // Minimum execution time: 360_980_000 picoseconds. + Weight::from_parts(363_834_000, 13600) + .saturating_add(T::DbWeight::get().reads(48_u64)) + .saturating_add(T::DbWeight::get().writes(40_u64)) } /// Storage: `SubtensorModule::CommitRevealWeightsEnabled` (r:1 w:0) /// Proof: `SubtensorModule::CommitRevealWeightsEnabled` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -237,8 +239,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `188782` // Estimated: `10327372` - // Minimum execution time: 14_846_685_000 picoseconds. - Weight::from_parts(15_166_549_000, 10327372) + // Minimum execution time: 15_235_625_000 picoseconds. + Weight::from_parts(15_608_065_000, 10327372) .saturating_add(T::DbWeight::get().reads(4112_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -304,10 +306,10 @@ impl WeightInfo for SubstrateWeight { /// Proof: `SubtensorModule::LastColdkeyHotkeyStakeBlock` (`max_values`: None, `max_size`: None, mode: `Measured`) fn add_stake() -> Weight { // Proof Size summary in bytes: - // Measured: `2560` + // Measured: `2589` // Estimated: `8727` - // Minimum execution time: 431_592_000 picoseconds. - Weight::from_parts(453_283_000, 8727) + // Minimum execution time: 437_242_000 picoseconds. + Weight::from_parts(453_834_000, 8727) .saturating_add(T::DbWeight::get().reads(33_u64)) .saturating_add(T::DbWeight::get().writes(18_u64)) } @@ -321,8 +323,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `791` // Estimated: `6731` - // Minimum execution time: 34_354_000 picoseconds. - Weight::from_parts(34_836_000, 6731) + // Minimum execution time: 34_104_000 picoseconds. + Weight::from_parts(35_076_000, 6731) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -336,8 +338,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `764` // Estimated: `6704` - // Minimum execution time: 30_417_000 picoseconds. - Weight::from_parts(31_620_000, 6704) + // Minimum execution time: 30_077_000 picoseconds. + Weight::from_parts(30_989_000, 6704) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -423,6 +425,8 @@ impl WeightInfo for SubstrateWeight { /// Proof: `SubtensorModule::RegistrationsThisBlock` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::RAORecycledForRegistration` (r:1 w:1) /// Proof: `SubtensorModule::RAORecycledForRegistration` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `SubtensorModule::SubnetTaoFlow` (r:1 w:1) + /// Proof: `SubtensorModule::SubnetTaoFlow` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::BlockAtRegistration` (r:0 w:1) /// Proof: `SubtensorModule::BlockAtRegistration` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::Keys` (r:0 w:1) @@ -437,10 +441,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `1639` // Estimated: `13600` - // Minimum execution time: 364_917_000 picoseconds. - Weight::from_parts(368_714_000, 13600) - .saturating_add(T::DbWeight::get().reads(47_u64)) - .saturating_add(T::DbWeight::get().writes(39_u64)) + // Minimum execution time: 373_683_000 picoseconds. + Weight::from_parts(376_809_000, 13600) + .saturating_add(T::DbWeight::get().reads(48_u64)) + .saturating_add(T::DbWeight::get().writes(40_u64)) } /// Storage: `SubtensorModule::NetworksAdded` (r:1 w:0) /// Proof: `SubtensorModule::NetworksAdded` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -488,10 +492,10 @@ impl WeightInfo for SubstrateWeight { /// Proof: `SubtensorModule::IsNetworkMember` (`max_values`: None, `max_size`: None, mode: `Measured`) fn root_register() -> Weight { // Proof Size summary in bytes: - // Measured: `1415` - // Estimated: `4880` - // Minimum execution time: 100_830_000 picoseconds. - Weight::from_parts(102_322_000, 4880) + // Measured: `1444` + // Estimated: `4909` + // Minimum execution time: 100_919_000 picoseconds. + Weight::from_parts(103_335_000, 4909) .saturating_add(T::DbWeight::get().reads(19_u64)) .saturating_add(T::DbWeight::get().writes(16_u64)) } @@ -609,8 +613,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `1459` // Estimated: `9874` - // Minimum execution time: 268_496_000 picoseconds. - Weight::from_parts(273_143_000, 9874) + // Minimum execution time: 269_978_000 picoseconds. + Weight::from_parts(273_545_000, 9874) .saturating_add(T::DbWeight::get().reads(42_u64)) .saturating_add(T::DbWeight::get().writes(47_u64)) } @@ -638,8 +642,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `1061` // Estimated: `4526` - // Minimum execution time: 60_835_000 picoseconds. - Weight::from_parts(62_007_000, 4526) + // Minimum execution time: 60_774_000 picoseconds. + Weight::from_parts(61_927_000, 4526) .saturating_add(T::DbWeight::get().reads(10_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -683,8 +687,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `1579` // Estimated: `7519` - // Minimum execution time: 107_622_000 picoseconds. - Weight::from_parts(109_516_000, 7519) + // Minimum execution time: 107_792_000 picoseconds. + Weight::from_parts(109_586_000, 7519) .saturating_add(T::DbWeight::get().reads(18_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -694,8 +698,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_260_000 picoseconds. - Weight::from_parts(5_611_000, 0) + // Minimum execution time: 5_290_000 picoseconds. + Weight::from_parts(5_721_000, 0) .saturating_add(T::DbWeight::get().writes(1_u64)) } /// Storage: `SubtensorModule::Owner` (r:1 w:0) @@ -712,8 +716,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `938` // Estimated: `4403` - // Minimum execution time: 46_848_000 picoseconds. - Weight::from_parts(47_770_000, 4403) + // Minimum execution time: 46_488_000 picoseconds. + Weight::from_parts(47_350_000, 4403) .saturating_add(T::DbWeight::get().reads(5_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -729,8 +733,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `694` // Estimated: `4159` - // Minimum execution time: 45_235_000 picoseconds. - Weight::from_parts(46_999_000, 4159) + // Minimum execution time: 45_396_000 picoseconds. + Weight::from_parts(46_828_000, 4159) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } @@ -768,10 +772,10 @@ impl WeightInfo for SubstrateWeight { /// Proof: `SubtensorModule::LastRateLimitedBlock` (`max_values`: None, `max_size`: None, mode: `Measured`) fn swap_coldkey_announced() -> Weight { // Proof Size summary in bytes: - // Measured: `2117` - // Estimated: `13007` - // Minimum execution time: 267_614_000 picoseconds. - Weight::from_parts(273_394_000, 13007) + // Measured: `2150` + // Estimated: `13040` + // Minimum execution time: 271_611_000 picoseconds. + Weight::from_parts(273_435_000, 13040) .saturating_add(T::DbWeight::get().reads(33_u64)) .saturating_add(T::DbWeight::get().writes(15_u64)) } @@ -815,8 +819,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `2210` // Estimated: `13100` - // Minimum execution time: 289_935_000 picoseconds. - Weight::from_parts(294_274_000, 13100) + // Minimum execution time: 296_087_000 picoseconds. + Weight::from_parts(299_413_000, 13100) .saturating_add(T::DbWeight::get().reads(33_u64)) .saturating_add(T::DbWeight::get().writes(19_u64)) } @@ -828,8 +832,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `665` // Estimated: `4130` - // Minimum execution time: 22_412_000 picoseconds. - Weight::from_parts(23_364_000, 4130) + // Minimum execution time: 22_111_000 picoseconds. + Weight::from_parts(22_823_000, 4130) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -841,8 +845,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `613` // Estimated: `4078` - // Minimum execution time: 18_325_000 picoseconds. - Weight::from_parts(19_206_000, 4078) + // Minimum execution time: 18_565_000 picoseconds. + Weight::from_parts(19_056_000, 4078) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -854,8 +858,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 8_376_000 picoseconds. - Weight::from_parts(8_697_000, 0) + // Minimum execution time: 8_486_000 picoseconds. + Weight::from_parts(8_826_000, 0) .saturating_add(T::DbWeight::get().writes(2_u64)) } /// Storage: `SubtensorModule::CommitRevealWeightsEnabled` (r:1 w:0) @@ -898,8 +902,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `2084` // Estimated: `8024` - // Minimum execution time: 396_345_000 picoseconds. - Weight::from_parts(408_599_000, 8024) + // Minimum execution time: 408_699_000 picoseconds. + Weight::from_parts(419_189_000, 8024) .saturating_add(T::DbWeight::get().reads(18_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -925,14 +929,18 @@ impl WeightInfo for SubstrateWeight { /// Proof: `SubtensorModule::StakingHotkeys` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::Lock` (r:1 w:0) /// Proof: `SubtensorModule::Lock` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `AlphaAssets::AlphaRecycled` (r:1 w:1) + /// Proof: `AlphaAssets::AlphaRecycled` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `AlphaAssets::TotalAlphaIssuance` (r:1 w:1) + /// Proof: `AlphaAssets::TotalAlphaIssuance` (`max_values`: None, `max_size`: None, mode: `Measured`) fn recycle_alpha() -> Weight { // Proof Size summary in bytes: - // Measured: `1860` - // Estimated: `5325` - // Minimum execution time: 166_603_000 picoseconds. - Weight::from_parts(168_788_000, 5325) - .saturating_add(T::DbWeight::get().reads(11_u64)) - .saturating_add(T::DbWeight::get().writes(4_u64)) + // Measured: `1863` + // Estimated: `5328` + // Minimum execution time: 178_045_000 picoseconds. + Weight::from_parts(180_399_000, 5328) + .saturating_add(T::DbWeight::get().reads(13_u64)) + .saturating_add(T::DbWeight::get().writes(6_u64)) } /// Storage: `SubtensorModule::NetworksAdded` (r:1 w:0) /// Proof: `SubtensorModule::NetworksAdded` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -956,14 +964,16 @@ impl WeightInfo for SubstrateWeight { /// Proof: `SubtensorModule::StakingHotkeys` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::Lock` (r:1 w:0) /// Proof: `SubtensorModule::Lock` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `AlphaAssets::AlphaBurned` (r:1 w:1) + /// Proof: `AlphaAssets::AlphaBurned` (`max_values`: None, `max_size`: None, mode: `Measured`) fn burn_alpha() -> Weight { // Proof Size summary in bytes: - // Measured: `1860` - // Estimated: `5325` - // Minimum execution time: 164_650_000 picoseconds. - Weight::from_parts(166_603_000, 5325) - .saturating_add(T::DbWeight::get().reads(11_u64)) - .saturating_add(T::DbWeight::get().writes(3_u64)) + // Measured: `1863` + // Estimated: `5328` + // Minimum execution time: 176_372_000 picoseconds. + Weight::from_parts(178_245_000, 5328) + .saturating_add(T::DbWeight::get().reads(12_u64)) + .saturating_add(T::DbWeight::get().writes(4_u64)) } /// Storage: `SubtensorModule::NetworksAdded` (r:1 w:0) /// Proof: `SubtensorModule::NetworksAdded` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -979,10 +989,10 @@ impl WeightInfo for SubstrateWeight { /// Proof: `SubtensorModule::SubtokenEnabled` (`max_values`: None, `max_size`: None, mode: `Measured`) fn start_call() -> Weight { // Proof Size summary in bytes: - // Measured: `1079` - // Estimated: `4544` - // Minimum execution time: 38_783_000 picoseconds. - Weight::from_parts(40_136_000, 4544) + // Measured: `1108` + // Estimated: `4573` + // Minimum execution time: 38_301_000 picoseconds. + Weight::from_parts(39_484_000, 4573) .saturating_add(T::DbWeight::get().reads(5_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -1048,10 +1058,10 @@ impl WeightInfo for SubstrateWeight { /// Proof: `SubtensorModule::LastColdkeyHotkeyStakeBlock` (`max_values`: None, `max_size`: None, mode: `Measured`) fn add_stake_limit() -> Weight { // Proof Size summary in bytes: - // Measured: `2560` + // Measured: `2589` // Estimated: `8727` - // Minimum execution time: 465_225_000 picoseconds. - Weight::from_parts(485_933_000, 8727) + // Minimum execution time: 481_686_000 picoseconds. + Weight::from_parts(502_826_000, 8727) .saturating_add(T::DbWeight::get().reads(33_u64)) .saturating_add(T::DbWeight::get().writes(18_u64)) } @@ -1087,8 +1097,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `2002` // Estimated: `7942` - // Minimum execution time: 205_998_000 picoseconds. - Weight::from_parts(208_783_000, 7942) + // Minimum execution time: 211_418_000 picoseconds. + Weight::from_parts(214_463_000, 7942) .saturating_add(T::DbWeight::get().reads(19_u64)) .saturating_add(T::DbWeight::get().writes(7_u64)) } @@ -1142,6 +1152,8 @@ impl WeightInfo for SubstrateWeight { /// Proof: `SubtensorModule::SubnetVolume` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `System::Account` (r:2 w:2) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(104), added: 2579, mode: `MaxEncodedLen`) + /// Storage: `AlphaAssets::AlphaBurned` (r:1 w:1) + /// Proof: `AlphaAssets::AlphaBurned` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::SubnetTaoFlow` (r:1 w:1) /// Proof: `SubtensorModule::SubnetTaoFlow` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::StakeThreshold` (r:1 w:0) @@ -1150,12 +1162,12 @@ impl WeightInfo for SubstrateWeight { /// Proof: `SubtensorModule::LastColdkeyHotkeyStakeBlock` (`max_values`: None, `max_size`: None, mode: `Measured`) fn remove_stake() -> Weight { // Proof Size summary in bytes: - // Measured: `2536` - // Estimated: `10951` - // Minimum execution time: 412_326_000 picoseconds. - Weight::from_parts(433_846_000, 10951) - .saturating_add(T::DbWeight::get().reads(34_u64)) - .saturating_add(T::DbWeight::get().writes(14_u64)) + // Measured: `2539` + // Estimated: `10954` + // Minimum execution time: 424_639_000 picoseconds. + Weight::from_parts(434_648_000, 10954) + .saturating_add(T::DbWeight::get().reads(35_u64)) + .saturating_add(T::DbWeight::get().writes(15_u64)) } /// Storage: `SubtensorModule::SubnetMechanism` (r:2 w:0) /// Proof: `SubtensorModule::SubnetMechanism` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -1205,6 +1217,8 @@ impl WeightInfo for SubstrateWeight { /// Proof: `SubtensorModule::SubnetVolume` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `System::Account` (r:2 w:2) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(104), added: 2579, mode: `MaxEncodedLen`) + /// Storage: `AlphaAssets::AlphaBurned` (r:1 w:1) + /// Proof: `AlphaAssets::AlphaBurned` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::SubnetTaoFlow` (r:1 w:1) /// Proof: `SubtensorModule::SubnetTaoFlow` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::StakeThreshold` (r:1 w:0) @@ -1213,12 +1227,12 @@ impl WeightInfo for SubstrateWeight { /// Proof: `SubtensorModule::LastColdkeyHotkeyStakeBlock` (`max_values`: None, `max_size`: None, mode: `Measured`) fn remove_stake_limit() -> Weight { // Proof Size summary in bytes: - // Measured: `2536` - // Estimated: `10951` - // Minimum execution time: 445_979_000 picoseconds. - Weight::from_parts(451_159_000, 10951) - .saturating_add(T::DbWeight::get().reads(33_u64)) - .saturating_add(T::DbWeight::get().writes(14_u64)) + // Measured: `2539` + // Estimated: `10954` + // Minimum execution time: 457_902_000 picoseconds. + Weight::from_parts(480_153_000, 10954) + .saturating_add(T::DbWeight::get().reads(34_u64)) + .saturating_add(T::DbWeight::get().writes(15_u64)) } /// Storage: `SubtensorModule::Alpha` (r:2 w:0) /// Proof: `SubtensorModule::Alpha` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -1270,6 +1284,8 @@ impl WeightInfo for SubstrateWeight { /// Proof: `SubtensorModule::SubnetVolume` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `System::Account` (r:3 w:2) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(104), added: 2579, mode: `MaxEncodedLen`) + /// Storage: `AlphaAssets::AlphaBurned` (r:1 w:1) + /// Proof: `AlphaAssets::AlphaBurned` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::SubnetTaoFlow` (r:2 w:2) /// Proof: `SubtensorModule::SubnetTaoFlow` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::MaturityRate` (r:1 w:0) @@ -1282,12 +1298,12 @@ impl WeightInfo for SubstrateWeight { /// Proof: `SubtensorModule::LastColdkeyHotkeyStakeBlock` (`max_values`: None, `max_size`: None, mode: `Measured`) fn swap_stake_limit() -> Weight { // Proof Size summary in bytes: - // Measured: `2923` - // Estimated: `11338` - // Minimum execution time: 641_075_000 picoseconds. - Weight::from_parts(664_801_000, 11338) - .saturating_add(T::DbWeight::get().reads(48_u64)) - .saturating_add(T::DbWeight::get().writes(25_u64)) + // Measured: `2942` + // Estimated: `11357` + // Minimum execution time: 659_371_000 picoseconds. + Weight::from_parts(682_956_000, 11357) + .saturating_add(T::DbWeight::get().reads(49_u64)) + .saturating_add(T::DbWeight::get().writes(26_u64)) } /// Storage: `SubtensorModule::Alpha` (r:2 w:0) /// Proof: `SubtensorModule::Alpha` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -1325,8 +1341,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `1996` // Estimated: `7936` - // Minimum execution time: 240_382_000 picoseconds. - Weight::from_parts(243_919_000, 7936) + // Minimum execution time: 239_531_000 picoseconds. + Weight::from_parts(244_390_000, 7936) .saturating_add(T::DbWeight::get().reads(18_u64)) .saturating_add(T::DbWeight::get().writes(6_u64)) } @@ -1380,6 +1396,8 @@ impl WeightInfo for SubstrateWeight { /// Proof: `SubtensorModule::SubnetVolume` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `System::Account` (r:3 w:2) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(104), added: 2579, mode: `MaxEncodedLen`) + /// Storage: `AlphaAssets::AlphaBurned` (r:1 w:1) + /// Proof: `AlphaAssets::AlphaBurned` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::SubnetTaoFlow` (r:2 w:2) /// Proof: `SubtensorModule::SubnetTaoFlow` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::MaturityRate` (r:1 w:0) @@ -1392,12 +1410,12 @@ impl WeightInfo for SubstrateWeight { /// Proof: `SubtensorModule::LastColdkeyHotkeyStakeBlock` (`max_values`: None, `max_size`: None, mode: `Measured`) fn swap_stake() -> Weight { // Proof Size summary in bytes: - // Measured: `2785` - // Estimated: `11200` - // Minimum execution time: 591_602_000 picoseconds. - Weight::from_parts(613_634_000, 11200) - .saturating_add(T::DbWeight::get().reads(48_u64)) - .saturating_add(T::DbWeight::get().writes(25_u64)) + // Measured: `2788` + // Estimated: `11203` + // Minimum execution time: 605_570_000 picoseconds. + Weight::from_parts(628_203_000, 11203) + .saturating_add(T::DbWeight::get().reads(49_u64)) + .saturating_add(T::DbWeight::get().writes(26_u64)) } /// Storage: `SubtensorModule::NetworksAdded` (r:1 w:0) /// Proof: `SubtensorModule::NetworksAdded` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -1423,10 +1441,10 @@ impl WeightInfo for SubstrateWeight { /// Proof: `SubtensorModule::WeightsSetRateLimit` (`max_values`: None, `max_size`: None, mode: `Measured`) fn batch_commit_weights() -> Weight { // Proof Size summary in bytes: - // Measured: `1084` - // Estimated: `4549` - // Minimum execution time: 122_971_000 picoseconds. - Weight::from_parts(124_314_000, 4549) + // Measured: `1112` + // Estimated: `4577` + // Minimum execution time: 127_320_000 picoseconds. + Weight::from_parts(128_452_000, 4577) .saturating_add(T::DbWeight::get().reads(11_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -1466,8 +1484,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `1416` // Estimated: `7356` - // Minimum execution time: 100_659_000 picoseconds. - Weight::from_parts(101_972_000, 7356) + // Minimum execution time: 100_188_000 picoseconds. + Weight::from_parts(101_461_000, 7356) .saturating_add(T::DbWeight::get().reads(16_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -1483,8 +1501,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `793` // Estimated: `4258` - // Minimum execution time: 27_622_000 picoseconds. - Weight::from_parts(29_025_000, 4258) + // Minimum execution time: 27_993_000 picoseconds. + Weight::from_parts(28_644_000, 4258) .saturating_add(T::DbWeight::get().reads(3_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -1502,8 +1520,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `886` // Estimated: `4351` - // Minimum execution time: 34_876_000 picoseconds. - Weight::from_parts(35_297_000, 4351) + // Minimum execution time: 35_167_000 picoseconds. + Weight::from_parts(36_309_000, 4351) .saturating_add(T::DbWeight::get().reads(5_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -1621,8 +1639,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `1343` // Estimated: `9758` - // Minimum execution time: 263_716_000 picoseconds. - Weight::from_parts(267_293_000, 9758) + // Minimum execution time: 267_132_000 picoseconds. + Weight::from_parts(273_555_000, 9758) .saturating_add(T::DbWeight::get().reads(41_u64)) .saturating_add(T::DbWeight::get().writes(46_u64)) } @@ -1636,8 +1654,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `762` // Estimated: `6702` - // Minimum execution time: 33_633_000 picoseconds. - Weight::from_parts(34_445_000, 6702) + // Minimum execution time: 33_253_000 picoseconds. + Weight::from_parts(34_334_000, 6702) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -1651,8 +1669,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `842` // Estimated: `6782` - // Minimum execution time: 30_758_000 picoseconds. - Weight::from_parts(31_870_000, 6782) + // Minimum execution time: 30_838_000 picoseconds. + Weight::from_parts(31_640_000, 6782) .saturating_add(T::DbWeight::get().reads(3_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -1664,8 +1682,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `595` // Estimated: `4060` - // Minimum execution time: 17_412_000 picoseconds. - Weight::from_parts(17_964_000, 4060) + // Minimum execution time: 17_704_000 picoseconds. + Weight::from_parts(18_174_000, 4060) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -1739,8 +1757,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `3026` // Estimated: `28766` - // Minimum execution time: 1_118_497_000 picoseconds. - Weight::from_parts(1_127_995_000, 28766) + // Minimum execution time: 1_146_389_000 picoseconds. + Weight::from_parts(1_157_089_000, 28766) .saturating_add(T::DbWeight::get().reads(166_u64)) .saturating_add(T::DbWeight::get().writes(95_u64)) } @@ -1754,8 +1772,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `745` // Estimated: `4210` - // Minimum execution time: 23_785_000 picoseconds. - Weight::from_parts(24_536_000, 4210) + // Minimum execution time: 23_875_000 picoseconds. + Weight::from_parts(24_637_000, 4210) .saturating_add(T::DbWeight::get().reads(3_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } @@ -1769,8 +1787,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `740` // Estimated: `9155` - // Minimum execution time: 27_242_000 picoseconds. - Weight::from_parts(27_693_000, 9155) + // Minimum execution time: 26_370_000 picoseconds. + Weight::from_parts(27_101_000, 9155) .saturating_add(T::DbWeight::get().reads(6_u64)) } /// Storage: `SubtensorModule::Owner` (r:1 w:0) @@ -1823,6 +1841,8 @@ impl WeightInfo for SubstrateWeight { /// Proof: `SubtensorModule::SubnetVolume` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `System::Account` (r:4 w:3) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(104), added: 2579, mode: `MaxEncodedLen`) + /// Storage: `AlphaAssets::AlphaBurned` (r:1 w:1) + /// Proof: `AlphaAssets::AlphaBurned` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::SubnetTaoFlow` (r:2 w:2) /// Proof: `SubtensorModule::SubnetTaoFlow` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::RootClaimable` (r:1 w:0) @@ -1837,12 +1857,12 @@ impl WeightInfo for SubstrateWeight { /// Proof: `SubtensorModule::LastColdkeyHotkeyStakeBlock` (`max_values`: None, `max_size`: None, mode: `Measured`) fn unstake_all_alpha() -> Weight { // Proof Size summary in bytes: - // Measured: `2614` + // Measured: `2617` // Estimated: `11306` - // Minimum execution time: 545_167_000 picoseconds. - Weight::from_parts(569_493_000, 11306) - .saturating_add(T::DbWeight::get().reads(49_u64)) - .saturating_add(T::DbWeight::get().writes(26_u64)) + // Minimum execution time: 568_832_000 picoseconds. + Weight::from_parts(588_007_000, 11306) + .saturating_add(T::DbWeight::get().reads(50_u64)) + .saturating_add(T::DbWeight::get().writes(27_u64)) } /// Storage: `SubtensorModule::Alpha` (r:1 w:0) /// Proof: `SubtensorModule::Alpha` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -1892,6 +1912,8 @@ impl WeightInfo for SubstrateWeight { /// Proof: `SubtensorModule::SubnetVolume` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `System::Account` (r:2 w:2) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(104), added: 2579, mode: `MaxEncodedLen`) + /// Storage: `AlphaAssets::AlphaBurned` (r:1 w:1) + /// Proof: `AlphaAssets::AlphaBurned` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::SubnetTaoFlow` (r:1 w:1) /// Proof: `SubtensorModule::SubnetTaoFlow` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::StakeThreshold` (r:1 w:0) @@ -1900,12 +1922,12 @@ impl WeightInfo for SubstrateWeight { /// Proof: `SubtensorModule::LastColdkeyHotkeyStakeBlock` (`max_values`: None, `max_size`: None, mode: `Measured`) fn remove_stake_full_limit() -> Weight { // Proof Size summary in bytes: - // Measured: `2536` - // Estimated: `10951` - // Minimum execution time: 468_592_000 picoseconds. - Weight::from_parts(490_254_000, 10951) - .saturating_add(T::DbWeight::get().reads(33_u64)) - .saturating_add(T::DbWeight::get().writes(14_u64)) + // Measured: `2539` + // Estimated: `10954` + // Minimum execution time: 482_639_000 picoseconds. + Weight::from_parts(506_293_000, 10954) + .saturating_add(T::DbWeight::get().reads(34_u64)) + .saturating_add(T::DbWeight::get().writes(15_u64)) } /// Storage: `Crowdloan::CurrentCrowdloanId` (r:1 w:0) /// Proof: `Crowdloan::CurrentCrowdloanId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) @@ -2040,10 +2062,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `1762 + k * (44 ±0)` // Estimated: `10183 + k * (2579 ±0)` - // Minimum execution time: 468_092_000 picoseconds. - Weight::from_parts(285_158_564, 10183) - // Standard Error: 22_583 - .saturating_add(Weight::from_parts(45_494_972, 0).saturating_mul(k.into())) + // Minimum execution time: 476_848_000 picoseconds. + Weight::from_parts(298_586_627, 10183) + // Standard Error: 36_848 + .saturating_add(Weight::from_parts(45_631_078, 0).saturating_mul(k.into())) .saturating_add(T::DbWeight::get().reads(51_u64)) .saturating_add(T::DbWeight::get().reads((2_u64).saturating_mul(k.into()))) .saturating_add(T::DbWeight::get().writes(52_u64)) @@ -2073,10 +2095,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `1447 + k * (53 ±0)` // Estimated: `6148 + k * (2514 ±0)` - // Minimum execution time: 92_805_000 picoseconds. - Weight::from_parts(131_135_086, 6148) - // Standard Error: 6_682 - .saturating_add(Weight::from_parts(1_630_520, 0).saturating_mul(k.into())) + // Minimum execution time: 127_110_000 picoseconds. + Weight::from_parts(133_384_459, 6148) + // Standard Error: 6_097 + .saturating_add(Weight::from_parts(1_681_002, 0).saturating_mul(k.into())) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(k.into()))) .saturating_add(T::DbWeight::get().writes(7_u64)) @@ -2091,8 +2113,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `649` // Estimated: `9064` - // Minimum execution time: 27_632_000 picoseconds. - Weight::from_parts(29_085_000, 9064) + // Minimum execution time: 27_222_000 picoseconds. + Weight::from_parts(28_324_000, 9064) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -2120,8 +2142,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `1060` // Estimated: `4525` - // Minimum execution time: 73_969_000 picoseconds. - Weight::from_parts(76_133_000, 4525) + // Minimum execution time: 73_348_000 picoseconds. + Weight::from_parts(74_501_000, 4525) .saturating_add(T::DbWeight::get().reads(10_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -2137,8 +2159,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `799` // Estimated: `4264` - // Minimum execution time: 33_843_000 picoseconds. - Weight::from_parts(34_686_000, 4264) + // Minimum execution time: 33_543_000 picoseconds. + Weight::from_parts(34_035_000, 4264) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -2154,8 +2176,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `476` // Estimated: `3941` - // Minimum execution time: 17_483_000 picoseconds. - Weight::from_parts(17_994_000, 3941) + // Minimum execution time: 17_603_000 picoseconds. + Weight::from_parts(18_034_000, 3941) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } @@ -2181,13 +2203,15 @@ impl WeightInfo for SubstrateWeight { /// Proof: `SubtensorModule::RootClaimed` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::RootClaimableThreshold` (r:1 w:0) /// Proof: `SubtensorModule::RootClaimableThreshold` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `SubtensorModule::BurnRootProp` (r:1 w:0) + /// Proof: `SubtensorModule::BurnRootProp` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) fn claim_root() -> Weight { // Proof Size summary in bytes: // Measured: `1908` // Estimated: `7848` - // Minimum execution time: 132_329_000 picoseconds. - Weight::from_parts(134_352_000, 7848) - .saturating_add(T::DbWeight::get().reads(16_u64)) + // Minimum execution time: 133_292_000 picoseconds. + Weight::from_parts(135_557_000, 7848) + .saturating_add(T::DbWeight::get().reads(17_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } /// Storage: `SubtensorModule::NumRootClaim` (r:0 w:1) @@ -2196,8 +2220,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_595_000 picoseconds. - Weight::from_parts(2_805_000, 0) + // Minimum execution time: 2_705_000 picoseconds. + Weight::from_parts(2_926_000, 0) .saturating_add(T::DbWeight::get().writes(1_u64)) } /// Storage: `SubtensorModule::RootClaimableThreshold` (r:0 w:1) @@ -2206,8 +2230,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_180_000 picoseconds. - Weight::from_parts(5_821_000, 0) + // Minimum execution time: 5_170_000 picoseconds. + Weight::from_parts(5_691_000, 0) .saturating_add(T::DbWeight::get().writes(1_u64)) } /// Storage: `SubtensorModule::Owner` (r:1 w:0) @@ -2220,17 +2244,11 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `852` // Estimated: `4317` - // Minimum execution time: 27_352_000 picoseconds. - Weight::from_parts(28_503_000, 4317) + // Minimum execution time: 26_640_000 picoseconds. + Weight::from_parts(27_362_000, 4317) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } - /// Storage: `SubtensorModule::SubnetOwner` (r:1 w:0) - /// Proof: `SubtensorModule::SubnetOwner` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// Storage: `SubtensorModule::LastRateLimitedBlock` (r:1 w:1) - /// Proof: `SubtensorModule::LastRateLimitedBlock` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// Storage: `SubtensorModule::Tempo` (r:1 w:0) - /// Proof: `SubtensorModule::Tempo` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::SubnetMechanism` (r:1 w:0) /// Proof: `SubtensorModule::SubnetMechanism` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::SubnetAlphaIn` (r:1 w:1) @@ -2287,17 +2305,19 @@ impl WeightInfo for SubstrateWeight { /// Proof: `SubtensorModule::UnlockRate` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::HotkeyLock` (r:1 w:1) /// Proof: `SubtensorModule::HotkeyLock` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `AlphaAssets::AlphaBurned` (r:1 w:1) + /// Proof: `AlphaAssets::AlphaBurned` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::StakingOperationRateLimiter` (r:0 w:1) /// Proof: `SubtensorModule::StakingOperationRateLimiter` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::LastColdkeyHotkeyStakeBlock` (r:0 w:1) /// Proof: `SubtensorModule::LastColdkeyHotkeyStakeBlock` (`max_values`: None, `max_size`: None, mode: `Measured`) fn add_stake_burn() -> Weight { // Proof Size summary in bytes: - // Measured: `2617` + // Measured: `2592` // Estimated: `8727` - // Minimum execution time: 595_879_000 picoseconds. - Weight::from_parts(616_657_000, 8727) - .saturating_add(T::DbWeight::get().reads(36_u64)) + // Minimum execution time: 602_169_000 picoseconds. + Weight::from_parts(623_989_000, 8727) + .saturating_add(T::DbWeight::get().reads(34_u64)) .saturating_add(T::DbWeight::get().writes(19_u64)) } /// Storage: `SubtensorModule::PendingChildKeyCooldown` (r:0 w:1) @@ -2306,8 +2326,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_575_000 picoseconds. - Weight::from_parts(2_725_000, 0) + // Minimum execution time: 2_875_000 picoseconds. + Weight::from_parts(3_016_000, 0) .saturating_add(T::DbWeight::get().writes(1_u64)) } /// Storage: `SubtensorModule::StakingHotkeys` (r:1 w:0) @@ -2330,8 +2350,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `1463` // Estimated: `4928` - // Minimum execution time: 90_731_000 picoseconds. - Weight::from_parts(92_755_000, 4928) + // Minimum execution time: 91_683_000 picoseconds. + Weight::from_parts(93_107_000, 4928) .saturating_add(T::DbWeight::get().reads(8_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -2347,8 +2367,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `978` // Estimated: `6918` - // Minimum execution time: 70_652_000 picoseconds. - Weight::from_parts(72_135_000, 6918) + // Minimum execution time: 70_593_000 picoseconds. + Weight::from_parts(72_246_000, 6918) .saturating_add(T::DbWeight::get().reads(5_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -2366,8 +2386,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `1302` // Estimated: `7242` - // Minimum execution time: 93_155_000 picoseconds. - Weight::from_parts(94_457_000, 7242) + // Minimum execution time: 92_866_000 picoseconds. + Weight::from_parts(94_739_000, 7242) .saturating_add(T::DbWeight::get().reads(8_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } @@ -2457,6 +2477,8 @@ impl WeightInfo for () { /// Proof: `SubtensorModule::RegistrationsThisBlock` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::RAORecycledForRegistration` (r:1 w:1) /// Proof: `SubtensorModule::RAORecycledForRegistration` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `SubtensorModule::SubnetTaoFlow` (r:1 w:1) + /// Proof: `SubtensorModule::SubnetTaoFlow` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::BlockAtRegistration` (r:0 w:1) /// Proof: `SubtensorModule::BlockAtRegistration` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::Keys` (r:0 w:1) @@ -2471,10 +2493,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `1706` // Estimated: `13600` - // Minimum execution time: 355_490_000 picoseconds. - Weight::from_parts(364_739_000, 13600) - .saturating_add(RocksDbWeight::get().reads(47_u64)) - .saturating_add(RocksDbWeight::get().writes(39_u64)) + // Minimum execution time: 360_980_000 picoseconds. + Weight::from_parts(363_834_000, 13600) + .saturating_add(RocksDbWeight::get().reads(48_u64)) + .saturating_add(RocksDbWeight::get().writes(40_u64)) } /// Storage: `SubtensorModule::CommitRevealWeightsEnabled` (r:1 w:0) /// Proof: `SubtensorModule::CommitRevealWeightsEnabled` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -2514,8 +2536,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `188782` // Estimated: `10327372` - // Minimum execution time: 14_846_685_000 picoseconds. - Weight::from_parts(15_166_549_000, 10327372) + // Minimum execution time: 15_235_625_000 picoseconds. + Weight::from_parts(15_608_065_000, 10327372) .saturating_add(RocksDbWeight::get().reads(4112_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -2581,10 +2603,10 @@ impl WeightInfo for () { /// Proof: `SubtensorModule::LastColdkeyHotkeyStakeBlock` (`max_values`: None, `max_size`: None, mode: `Measured`) fn add_stake() -> Weight { // Proof Size summary in bytes: - // Measured: `2560` + // Measured: `2589` // Estimated: `8727` - // Minimum execution time: 431_592_000 picoseconds. - Weight::from_parts(453_283_000, 8727) + // Minimum execution time: 437_242_000 picoseconds. + Weight::from_parts(453_834_000, 8727) .saturating_add(RocksDbWeight::get().reads(33_u64)) .saturating_add(RocksDbWeight::get().writes(18_u64)) } @@ -2598,8 +2620,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `791` // Estimated: `6731` - // Minimum execution time: 34_354_000 picoseconds. - Weight::from_parts(34_836_000, 6731) + // Minimum execution time: 34_104_000 picoseconds. + Weight::from_parts(35_076_000, 6731) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -2613,8 +2635,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `764` // Estimated: `6704` - // Minimum execution time: 30_417_000 picoseconds. - Weight::from_parts(31_620_000, 6704) + // Minimum execution time: 30_077_000 picoseconds. + Weight::from_parts(30_989_000, 6704) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -2700,6 +2722,8 @@ impl WeightInfo for () { /// Proof: `SubtensorModule::RegistrationsThisBlock` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::RAORecycledForRegistration` (r:1 w:1) /// Proof: `SubtensorModule::RAORecycledForRegistration` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `SubtensorModule::SubnetTaoFlow` (r:1 w:1) + /// Proof: `SubtensorModule::SubnetTaoFlow` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::BlockAtRegistration` (r:0 w:1) /// Proof: `SubtensorModule::BlockAtRegistration` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::Keys` (r:0 w:1) @@ -2714,10 +2738,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `1639` // Estimated: `13600` - // Minimum execution time: 364_917_000 picoseconds. - Weight::from_parts(368_714_000, 13600) - .saturating_add(RocksDbWeight::get().reads(47_u64)) - .saturating_add(RocksDbWeight::get().writes(39_u64)) + // Minimum execution time: 373_683_000 picoseconds. + Weight::from_parts(376_809_000, 13600) + .saturating_add(RocksDbWeight::get().reads(48_u64)) + .saturating_add(RocksDbWeight::get().writes(40_u64)) } /// Storage: `SubtensorModule::NetworksAdded` (r:1 w:0) /// Proof: `SubtensorModule::NetworksAdded` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -2765,10 +2789,10 @@ impl WeightInfo for () { /// Proof: `SubtensorModule::IsNetworkMember` (`max_values`: None, `max_size`: None, mode: `Measured`) fn root_register() -> Weight { // Proof Size summary in bytes: - // Measured: `1415` - // Estimated: `4880` - // Minimum execution time: 100_830_000 picoseconds. - Weight::from_parts(102_322_000, 4880) + // Measured: `1444` + // Estimated: `4909` + // Minimum execution time: 100_919_000 picoseconds. + Weight::from_parts(103_335_000, 4909) .saturating_add(RocksDbWeight::get().reads(19_u64)) .saturating_add(RocksDbWeight::get().writes(16_u64)) } @@ -2886,8 +2910,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `1459` // Estimated: `9874` - // Minimum execution time: 268_496_000 picoseconds. - Weight::from_parts(273_143_000, 9874) + // Minimum execution time: 269_978_000 picoseconds. + Weight::from_parts(273_545_000, 9874) .saturating_add(RocksDbWeight::get().reads(42_u64)) .saturating_add(RocksDbWeight::get().writes(47_u64)) } @@ -2915,8 +2939,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `1061` // Estimated: `4526` - // Minimum execution time: 60_835_000 picoseconds. - Weight::from_parts(62_007_000, 4526) + // Minimum execution time: 60_774_000 picoseconds. + Weight::from_parts(61_927_000, 4526) .saturating_add(RocksDbWeight::get().reads(10_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -2960,8 +2984,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `1579` // Estimated: `7519` - // Minimum execution time: 107_622_000 picoseconds. - Weight::from_parts(109_516_000, 7519) + // Minimum execution time: 107_792_000 picoseconds. + Weight::from_parts(109_586_000, 7519) .saturating_add(RocksDbWeight::get().reads(18_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -2971,8 +2995,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_260_000 picoseconds. - Weight::from_parts(5_611_000, 0) + // Minimum execution time: 5_290_000 picoseconds. + Weight::from_parts(5_721_000, 0) .saturating_add(RocksDbWeight::get().writes(1_u64)) } /// Storage: `SubtensorModule::Owner` (r:1 w:0) @@ -2989,8 +3013,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `938` // Estimated: `4403` - // Minimum execution time: 46_848_000 picoseconds. - Weight::from_parts(47_770_000, 4403) + // Minimum execution time: 46_488_000 picoseconds. + Weight::from_parts(47_350_000, 4403) .saturating_add(RocksDbWeight::get().reads(5_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -3006,8 +3030,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `694` // Estimated: `4159` - // Minimum execution time: 45_235_000 picoseconds. - Weight::from_parts(46_999_000, 4159) + // Minimum execution time: 45_396_000 picoseconds. + Weight::from_parts(46_828_000, 4159) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } @@ -3045,10 +3069,10 @@ impl WeightInfo for () { /// Proof: `SubtensorModule::LastRateLimitedBlock` (`max_values`: None, `max_size`: None, mode: `Measured`) fn swap_coldkey_announced() -> Weight { // Proof Size summary in bytes: - // Measured: `2117` - // Estimated: `13007` - // Minimum execution time: 267_614_000 picoseconds. - Weight::from_parts(273_394_000, 13007) + // Measured: `2150` + // Estimated: `13040` + // Minimum execution time: 271_611_000 picoseconds. + Weight::from_parts(273_435_000, 13040) .saturating_add(RocksDbWeight::get().reads(33_u64)) .saturating_add(RocksDbWeight::get().writes(15_u64)) } @@ -3092,8 +3116,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `2210` // Estimated: `13100` - // Minimum execution time: 289_935_000 picoseconds. - Weight::from_parts(294_274_000, 13100) + // Minimum execution time: 296_087_000 picoseconds. + Weight::from_parts(299_413_000, 13100) .saturating_add(RocksDbWeight::get().reads(33_u64)) .saturating_add(RocksDbWeight::get().writes(19_u64)) } @@ -3105,8 +3129,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `665` // Estimated: `4130` - // Minimum execution time: 22_412_000 picoseconds. - Weight::from_parts(23_364_000, 4130) + // Minimum execution time: 22_111_000 picoseconds. + Weight::from_parts(22_823_000, 4130) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -3118,8 +3142,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `613` // Estimated: `4078` - // Minimum execution time: 18_325_000 picoseconds. - Weight::from_parts(19_206_000, 4078) + // Minimum execution time: 18_565_000 picoseconds. + Weight::from_parts(19_056_000, 4078) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -3131,8 +3155,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 8_376_000 picoseconds. - Weight::from_parts(8_697_000, 0) + // Minimum execution time: 8_486_000 picoseconds. + Weight::from_parts(8_826_000, 0) .saturating_add(RocksDbWeight::get().writes(2_u64)) } /// Storage: `SubtensorModule::CommitRevealWeightsEnabled` (r:1 w:0) @@ -3175,8 +3199,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `2084` // Estimated: `8024` - // Minimum execution time: 396_345_000 picoseconds. - Weight::from_parts(408_599_000, 8024) + // Minimum execution time: 408_699_000 picoseconds. + Weight::from_parts(419_189_000, 8024) .saturating_add(RocksDbWeight::get().reads(18_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -3202,14 +3226,18 @@ impl WeightInfo for () { /// Proof: `SubtensorModule::StakingHotkeys` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::Lock` (r:1 w:0) /// Proof: `SubtensorModule::Lock` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `AlphaAssets::AlphaRecycled` (r:1 w:1) + /// Proof: `AlphaAssets::AlphaRecycled` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `AlphaAssets::TotalAlphaIssuance` (r:1 w:1) + /// Proof: `AlphaAssets::TotalAlphaIssuance` (`max_values`: None, `max_size`: None, mode: `Measured`) fn recycle_alpha() -> Weight { // Proof Size summary in bytes: - // Measured: `1860` - // Estimated: `5325` - // Minimum execution time: 166_603_000 picoseconds. - Weight::from_parts(168_788_000, 5325) - .saturating_add(RocksDbWeight::get().reads(11_u64)) - .saturating_add(RocksDbWeight::get().writes(4_u64)) + // Measured: `1863` + // Estimated: `5328` + // Minimum execution time: 178_045_000 picoseconds. + Weight::from_parts(180_399_000, 5328) + .saturating_add(RocksDbWeight::get().reads(13_u64)) + .saturating_add(RocksDbWeight::get().writes(6_u64)) } /// Storage: `SubtensorModule::NetworksAdded` (r:1 w:0) /// Proof: `SubtensorModule::NetworksAdded` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -3233,14 +3261,16 @@ impl WeightInfo for () { /// Proof: `SubtensorModule::StakingHotkeys` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::Lock` (r:1 w:0) /// Proof: `SubtensorModule::Lock` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `AlphaAssets::AlphaBurned` (r:1 w:1) + /// Proof: `AlphaAssets::AlphaBurned` (`max_values`: None, `max_size`: None, mode: `Measured`) fn burn_alpha() -> Weight { // Proof Size summary in bytes: - // Measured: `1860` - // Estimated: `5325` - // Minimum execution time: 164_650_000 picoseconds. - Weight::from_parts(166_603_000, 5325) - .saturating_add(RocksDbWeight::get().reads(11_u64)) - .saturating_add(RocksDbWeight::get().writes(3_u64)) + // Measured: `1863` + // Estimated: `5328` + // Minimum execution time: 176_372_000 picoseconds. + Weight::from_parts(178_245_000, 5328) + .saturating_add(RocksDbWeight::get().reads(12_u64)) + .saturating_add(RocksDbWeight::get().writes(4_u64)) } /// Storage: `SubtensorModule::NetworksAdded` (r:1 w:0) /// Proof: `SubtensorModule::NetworksAdded` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -3256,10 +3286,10 @@ impl WeightInfo for () { /// Proof: `SubtensorModule::SubtokenEnabled` (`max_values`: None, `max_size`: None, mode: `Measured`) fn start_call() -> Weight { // Proof Size summary in bytes: - // Measured: `1079` - // Estimated: `4544` - // Minimum execution time: 38_783_000 picoseconds. - Weight::from_parts(40_136_000, 4544) + // Measured: `1108` + // Estimated: `4573` + // Minimum execution time: 38_301_000 picoseconds. + Weight::from_parts(39_484_000, 4573) .saturating_add(RocksDbWeight::get().reads(5_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -3325,10 +3355,10 @@ impl WeightInfo for () { /// Proof: `SubtensorModule::LastColdkeyHotkeyStakeBlock` (`max_values`: None, `max_size`: None, mode: `Measured`) fn add_stake_limit() -> Weight { // Proof Size summary in bytes: - // Measured: `2560` + // Measured: `2589` // Estimated: `8727` - // Minimum execution time: 465_225_000 picoseconds. - Weight::from_parts(485_933_000, 8727) + // Minimum execution time: 481_686_000 picoseconds. + Weight::from_parts(502_826_000, 8727) .saturating_add(RocksDbWeight::get().reads(33_u64)) .saturating_add(RocksDbWeight::get().writes(18_u64)) } @@ -3364,8 +3394,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `2002` // Estimated: `7942` - // Minimum execution time: 205_998_000 picoseconds. - Weight::from_parts(208_783_000, 7942) + // Minimum execution time: 211_418_000 picoseconds. + Weight::from_parts(214_463_000, 7942) .saturating_add(RocksDbWeight::get().reads(19_u64)) .saturating_add(RocksDbWeight::get().writes(7_u64)) } @@ -3419,6 +3449,8 @@ impl WeightInfo for () { /// Proof: `SubtensorModule::SubnetVolume` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `System::Account` (r:2 w:2) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(104), added: 2579, mode: `MaxEncodedLen`) + /// Storage: `AlphaAssets::AlphaBurned` (r:1 w:1) + /// Proof: `AlphaAssets::AlphaBurned` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::SubnetTaoFlow` (r:1 w:1) /// Proof: `SubtensorModule::SubnetTaoFlow` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::StakeThreshold` (r:1 w:0) @@ -3427,12 +3459,12 @@ impl WeightInfo for () { /// Proof: `SubtensorModule::LastColdkeyHotkeyStakeBlock` (`max_values`: None, `max_size`: None, mode: `Measured`) fn remove_stake() -> Weight { // Proof Size summary in bytes: - // Measured: `2536` - // Estimated: `10951` - // Minimum execution time: 412_326_000 picoseconds. - Weight::from_parts(433_846_000, 10951) - .saturating_add(RocksDbWeight::get().reads(34_u64)) - .saturating_add(RocksDbWeight::get().writes(14_u64)) + // Measured: `2539` + // Estimated: `10954` + // Minimum execution time: 424_639_000 picoseconds. + Weight::from_parts(434_648_000, 10954) + .saturating_add(RocksDbWeight::get().reads(35_u64)) + .saturating_add(RocksDbWeight::get().writes(15_u64)) } /// Storage: `SubtensorModule::SubnetMechanism` (r:2 w:0) /// Proof: `SubtensorModule::SubnetMechanism` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -3482,6 +3514,8 @@ impl WeightInfo for () { /// Proof: `SubtensorModule::SubnetVolume` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `System::Account` (r:2 w:2) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(104), added: 2579, mode: `MaxEncodedLen`) + /// Storage: `AlphaAssets::AlphaBurned` (r:1 w:1) + /// Proof: `AlphaAssets::AlphaBurned` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::SubnetTaoFlow` (r:1 w:1) /// Proof: `SubtensorModule::SubnetTaoFlow` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::StakeThreshold` (r:1 w:0) @@ -3490,12 +3524,12 @@ impl WeightInfo for () { /// Proof: `SubtensorModule::LastColdkeyHotkeyStakeBlock` (`max_values`: None, `max_size`: None, mode: `Measured`) fn remove_stake_limit() -> Weight { // Proof Size summary in bytes: - // Measured: `2536` - // Estimated: `10951` - // Minimum execution time: 445_979_000 picoseconds. - Weight::from_parts(451_159_000, 10951) - .saturating_add(RocksDbWeight::get().reads(33_u64)) - .saturating_add(RocksDbWeight::get().writes(14_u64)) + // Measured: `2539` + // Estimated: `10954` + // Minimum execution time: 457_902_000 picoseconds. + Weight::from_parts(480_153_000, 10954) + .saturating_add(RocksDbWeight::get().reads(34_u64)) + .saturating_add(RocksDbWeight::get().writes(15_u64)) } /// Storage: `SubtensorModule::Alpha` (r:2 w:0) /// Proof: `SubtensorModule::Alpha` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -3547,6 +3581,8 @@ impl WeightInfo for () { /// Proof: `SubtensorModule::SubnetVolume` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `System::Account` (r:3 w:2) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(104), added: 2579, mode: `MaxEncodedLen`) + /// Storage: `AlphaAssets::AlphaBurned` (r:1 w:1) + /// Proof: `AlphaAssets::AlphaBurned` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::SubnetTaoFlow` (r:2 w:2) /// Proof: `SubtensorModule::SubnetTaoFlow` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::MaturityRate` (r:1 w:0) @@ -3559,12 +3595,12 @@ impl WeightInfo for () { /// Proof: `SubtensorModule::LastColdkeyHotkeyStakeBlock` (`max_values`: None, `max_size`: None, mode: `Measured`) fn swap_stake_limit() -> Weight { // Proof Size summary in bytes: - // Measured: `2923` - // Estimated: `11338` - // Minimum execution time: 641_075_000 picoseconds. - Weight::from_parts(664_801_000, 11338) - .saturating_add(RocksDbWeight::get().reads(48_u64)) - .saturating_add(RocksDbWeight::get().writes(25_u64)) + // Measured: `2942` + // Estimated: `11357` + // Minimum execution time: 659_371_000 picoseconds. + Weight::from_parts(682_956_000, 11357) + .saturating_add(RocksDbWeight::get().reads(49_u64)) + .saturating_add(RocksDbWeight::get().writes(26_u64)) } /// Storage: `SubtensorModule::Alpha` (r:2 w:0) /// Proof: `SubtensorModule::Alpha` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -3602,8 +3638,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `1996` // Estimated: `7936` - // Minimum execution time: 240_382_000 picoseconds. - Weight::from_parts(243_919_000, 7936) + // Minimum execution time: 239_531_000 picoseconds. + Weight::from_parts(244_390_000, 7936) .saturating_add(RocksDbWeight::get().reads(18_u64)) .saturating_add(RocksDbWeight::get().writes(6_u64)) } @@ -3657,6 +3693,8 @@ impl WeightInfo for () { /// Proof: `SubtensorModule::SubnetVolume` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `System::Account` (r:3 w:2) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(104), added: 2579, mode: `MaxEncodedLen`) + /// Storage: `AlphaAssets::AlphaBurned` (r:1 w:1) + /// Proof: `AlphaAssets::AlphaBurned` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::SubnetTaoFlow` (r:2 w:2) /// Proof: `SubtensorModule::SubnetTaoFlow` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::MaturityRate` (r:1 w:0) @@ -3669,12 +3707,12 @@ impl WeightInfo for () { /// Proof: `SubtensorModule::LastColdkeyHotkeyStakeBlock` (`max_values`: None, `max_size`: None, mode: `Measured`) fn swap_stake() -> Weight { // Proof Size summary in bytes: - // Measured: `2785` - // Estimated: `11200` - // Minimum execution time: 591_602_000 picoseconds. - Weight::from_parts(613_634_000, 11200) - .saturating_add(RocksDbWeight::get().reads(48_u64)) - .saturating_add(RocksDbWeight::get().writes(25_u64)) + // Measured: `2788` + // Estimated: `11203` + // Minimum execution time: 605_570_000 picoseconds. + Weight::from_parts(628_203_000, 11203) + .saturating_add(RocksDbWeight::get().reads(49_u64)) + .saturating_add(RocksDbWeight::get().writes(26_u64)) } /// Storage: `SubtensorModule::NetworksAdded` (r:1 w:0) /// Proof: `SubtensorModule::NetworksAdded` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -3700,10 +3738,10 @@ impl WeightInfo for () { /// Proof: `SubtensorModule::WeightsSetRateLimit` (`max_values`: None, `max_size`: None, mode: `Measured`) fn batch_commit_weights() -> Weight { // Proof Size summary in bytes: - // Measured: `1084` - // Estimated: `4549` - // Minimum execution time: 122_971_000 picoseconds. - Weight::from_parts(124_314_000, 4549) + // Measured: `1112` + // Estimated: `4577` + // Minimum execution time: 127_320_000 picoseconds. + Weight::from_parts(128_452_000, 4577) .saturating_add(RocksDbWeight::get().reads(11_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -3743,8 +3781,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `1416` // Estimated: `7356` - // Minimum execution time: 100_659_000 picoseconds. - Weight::from_parts(101_972_000, 7356) + // Minimum execution time: 100_188_000 picoseconds. + Weight::from_parts(101_461_000, 7356) .saturating_add(RocksDbWeight::get().reads(16_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -3760,8 +3798,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `793` // Estimated: `4258` - // Minimum execution time: 27_622_000 picoseconds. - Weight::from_parts(29_025_000, 4258) + // Minimum execution time: 27_993_000 picoseconds. + Weight::from_parts(28_644_000, 4258) .saturating_add(RocksDbWeight::get().reads(3_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -3779,8 +3817,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `886` // Estimated: `4351` - // Minimum execution time: 34_876_000 picoseconds. - Weight::from_parts(35_297_000, 4351) + // Minimum execution time: 35_167_000 picoseconds. + Weight::from_parts(36_309_000, 4351) .saturating_add(RocksDbWeight::get().reads(5_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -3898,8 +3936,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `1343` // Estimated: `9758` - // Minimum execution time: 263_716_000 picoseconds. - Weight::from_parts(267_293_000, 9758) + // Minimum execution time: 267_132_000 picoseconds. + Weight::from_parts(273_555_000, 9758) .saturating_add(RocksDbWeight::get().reads(41_u64)) .saturating_add(RocksDbWeight::get().writes(46_u64)) } @@ -3913,8 +3951,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `762` // Estimated: `6702` - // Minimum execution time: 33_633_000 picoseconds. - Weight::from_parts(34_445_000, 6702) + // Minimum execution time: 33_253_000 picoseconds. + Weight::from_parts(34_334_000, 6702) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -3928,8 +3966,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `842` // Estimated: `6782` - // Minimum execution time: 30_758_000 picoseconds. - Weight::from_parts(31_870_000, 6782) + // Minimum execution time: 30_838_000 picoseconds. + Weight::from_parts(31_640_000, 6782) .saturating_add(RocksDbWeight::get().reads(3_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -3941,8 +3979,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `595` // Estimated: `4060` - // Minimum execution time: 17_412_000 picoseconds. - Weight::from_parts(17_964_000, 4060) + // Minimum execution time: 17_704_000 picoseconds. + Weight::from_parts(18_174_000, 4060) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -4016,8 +4054,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `3026` // Estimated: `28766` - // Minimum execution time: 1_118_497_000 picoseconds. - Weight::from_parts(1_127_995_000, 28766) + // Minimum execution time: 1_146_389_000 picoseconds. + Weight::from_parts(1_157_089_000, 28766) .saturating_add(RocksDbWeight::get().reads(166_u64)) .saturating_add(RocksDbWeight::get().writes(95_u64)) } @@ -4031,8 +4069,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `745` // Estimated: `4210` - // Minimum execution time: 23_785_000 picoseconds. - Weight::from_parts(24_536_000, 4210) + // Minimum execution time: 23_875_000 picoseconds. + Weight::from_parts(24_637_000, 4210) .saturating_add(RocksDbWeight::get().reads(3_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } @@ -4046,8 +4084,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `740` // Estimated: `9155` - // Minimum execution time: 27_242_000 picoseconds. - Weight::from_parts(27_693_000, 9155) + // Minimum execution time: 26_370_000 picoseconds. + Weight::from_parts(27_101_000, 9155) .saturating_add(RocksDbWeight::get().reads(6_u64)) } /// Storage: `SubtensorModule::Owner` (r:1 w:0) @@ -4100,6 +4138,8 @@ impl WeightInfo for () { /// Proof: `SubtensorModule::SubnetVolume` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `System::Account` (r:4 w:3) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(104), added: 2579, mode: `MaxEncodedLen`) + /// Storage: `AlphaAssets::AlphaBurned` (r:1 w:1) + /// Proof: `AlphaAssets::AlphaBurned` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::SubnetTaoFlow` (r:2 w:2) /// Proof: `SubtensorModule::SubnetTaoFlow` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::RootClaimable` (r:1 w:0) @@ -4114,12 +4154,12 @@ impl WeightInfo for () { /// Proof: `SubtensorModule::LastColdkeyHotkeyStakeBlock` (`max_values`: None, `max_size`: None, mode: `Measured`) fn unstake_all_alpha() -> Weight { // Proof Size summary in bytes: - // Measured: `2614` + // Measured: `2617` // Estimated: `11306` - // Minimum execution time: 545_167_000 picoseconds. - Weight::from_parts(569_493_000, 11306) - .saturating_add(RocksDbWeight::get().reads(49_u64)) - .saturating_add(RocksDbWeight::get().writes(26_u64)) + // Minimum execution time: 568_832_000 picoseconds. + Weight::from_parts(588_007_000, 11306) + .saturating_add(RocksDbWeight::get().reads(50_u64)) + .saturating_add(RocksDbWeight::get().writes(27_u64)) } /// Storage: `SubtensorModule::Alpha` (r:1 w:0) /// Proof: `SubtensorModule::Alpha` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -4169,6 +4209,8 @@ impl WeightInfo for () { /// Proof: `SubtensorModule::SubnetVolume` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `System::Account` (r:2 w:2) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(104), added: 2579, mode: `MaxEncodedLen`) + /// Storage: `AlphaAssets::AlphaBurned` (r:1 w:1) + /// Proof: `AlphaAssets::AlphaBurned` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::SubnetTaoFlow` (r:1 w:1) /// Proof: `SubtensorModule::SubnetTaoFlow` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::StakeThreshold` (r:1 w:0) @@ -4177,12 +4219,12 @@ impl WeightInfo for () { /// Proof: `SubtensorModule::LastColdkeyHotkeyStakeBlock` (`max_values`: None, `max_size`: None, mode: `Measured`) fn remove_stake_full_limit() -> Weight { // Proof Size summary in bytes: - // Measured: `2536` - // Estimated: `10951` - // Minimum execution time: 468_592_000 picoseconds. - Weight::from_parts(490_254_000, 10951) - .saturating_add(RocksDbWeight::get().reads(33_u64)) - .saturating_add(RocksDbWeight::get().writes(14_u64)) + // Measured: `2539` + // Estimated: `10954` + // Minimum execution time: 482_639_000 picoseconds. + Weight::from_parts(506_293_000, 10954) + .saturating_add(RocksDbWeight::get().reads(34_u64)) + .saturating_add(RocksDbWeight::get().writes(15_u64)) } /// Storage: `Crowdloan::CurrentCrowdloanId` (r:1 w:0) /// Proof: `Crowdloan::CurrentCrowdloanId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) @@ -4317,10 +4359,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `1762 + k * (44 ±0)` // Estimated: `10183 + k * (2579 ±0)` - // Minimum execution time: 468_092_000 picoseconds. - Weight::from_parts(285_158_564, 10183) - // Standard Error: 22_583 - .saturating_add(Weight::from_parts(45_494_972, 0).saturating_mul(k.into())) + // Minimum execution time: 476_848_000 picoseconds. + Weight::from_parts(298_586_627, 10183) + // Standard Error: 36_848 + .saturating_add(Weight::from_parts(45_631_078, 0).saturating_mul(k.into())) .saturating_add(RocksDbWeight::get().reads(51_u64)) .saturating_add(RocksDbWeight::get().reads((2_u64).saturating_mul(k.into()))) .saturating_add(RocksDbWeight::get().writes(52_u64)) @@ -4350,10 +4392,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `1447 + k * (53 ±0)` // Estimated: `6148 + k * (2514 ±0)` - // Minimum execution time: 92_805_000 picoseconds. - Weight::from_parts(131_135_086, 6148) - // Standard Error: 6_682 - .saturating_add(Weight::from_parts(1_630_520, 0).saturating_mul(k.into())) + // Minimum execution time: 127_110_000 picoseconds. + Weight::from_parts(133_384_459, 6148) + // Standard Error: 6_097 + .saturating_add(Weight::from_parts(1_681_002, 0).saturating_mul(k.into())) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(k.into()))) .saturating_add(RocksDbWeight::get().writes(7_u64)) @@ -4368,8 +4410,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `649` // Estimated: `9064` - // Minimum execution time: 27_632_000 picoseconds. - Weight::from_parts(29_085_000, 9064) + // Minimum execution time: 27_222_000 picoseconds. + Weight::from_parts(28_324_000, 9064) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -4397,8 +4439,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `1060` // Estimated: `4525` - // Minimum execution time: 73_969_000 picoseconds. - Weight::from_parts(76_133_000, 4525) + // Minimum execution time: 73_348_000 picoseconds. + Weight::from_parts(74_501_000, 4525) .saturating_add(RocksDbWeight::get().reads(10_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -4414,8 +4456,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `799` // Estimated: `4264` - // Minimum execution time: 33_843_000 picoseconds. - Weight::from_parts(34_686_000, 4264) + // Minimum execution time: 33_543_000 picoseconds. + Weight::from_parts(34_035_000, 4264) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -4431,8 +4473,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `476` // Estimated: `3941` - // Minimum execution time: 17_483_000 picoseconds. - Weight::from_parts(17_994_000, 3941) + // Minimum execution time: 17_603_000 picoseconds. + Weight::from_parts(18_034_000, 3941) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } @@ -4458,13 +4500,15 @@ impl WeightInfo for () { /// Proof: `SubtensorModule::RootClaimed` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::RootClaimableThreshold` (r:1 w:0) /// Proof: `SubtensorModule::RootClaimableThreshold` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `SubtensorModule::BurnRootProp` (r:1 w:0) + /// Proof: `SubtensorModule::BurnRootProp` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) fn claim_root() -> Weight { // Proof Size summary in bytes: // Measured: `1908` // Estimated: `7848` - // Minimum execution time: 132_329_000 picoseconds. - Weight::from_parts(134_352_000, 7848) - .saturating_add(RocksDbWeight::get().reads(16_u64)) + // Minimum execution time: 133_292_000 picoseconds. + Weight::from_parts(135_557_000, 7848) + .saturating_add(RocksDbWeight::get().reads(17_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } /// Storage: `SubtensorModule::NumRootClaim` (r:0 w:1) @@ -4473,8 +4517,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_595_000 picoseconds. - Weight::from_parts(2_805_000, 0) + // Minimum execution time: 2_705_000 picoseconds. + Weight::from_parts(2_926_000, 0) .saturating_add(RocksDbWeight::get().writes(1_u64)) } /// Storage: `SubtensorModule::RootClaimableThreshold` (r:0 w:1) @@ -4483,8 +4527,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_180_000 picoseconds. - Weight::from_parts(5_821_000, 0) + // Minimum execution time: 5_170_000 picoseconds. + Weight::from_parts(5_691_000, 0) .saturating_add(RocksDbWeight::get().writes(1_u64)) } /// Storage: `SubtensorModule::Owner` (r:1 w:0) @@ -4497,17 +4541,11 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `852` // Estimated: `4317` - // Minimum execution time: 27_352_000 picoseconds. - Weight::from_parts(28_503_000, 4317) + // Minimum execution time: 26_640_000 picoseconds. + Weight::from_parts(27_362_000, 4317) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } - /// Storage: `SubtensorModule::SubnetOwner` (r:1 w:0) - /// Proof: `SubtensorModule::SubnetOwner` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// Storage: `SubtensorModule::LastRateLimitedBlock` (r:1 w:1) - /// Proof: `SubtensorModule::LastRateLimitedBlock` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// Storage: `SubtensorModule::Tempo` (r:1 w:0) - /// Proof: `SubtensorModule::Tempo` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::SubnetMechanism` (r:1 w:0) /// Proof: `SubtensorModule::SubnetMechanism` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::SubnetAlphaIn` (r:1 w:1) @@ -4564,17 +4602,19 @@ impl WeightInfo for () { /// Proof: `SubtensorModule::UnlockRate` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::HotkeyLock` (r:1 w:1) /// Proof: `SubtensorModule::HotkeyLock` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `AlphaAssets::AlphaBurned` (r:1 w:1) + /// Proof: `AlphaAssets::AlphaBurned` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::StakingOperationRateLimiter` (r:0 w:1) /// Proof: `SubtensorModule::StakingOperationRateLimiter` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `SubtensorModule::LastColdkeyHotkeyStakeBlock` (r:0 w:1) /// Proof: `SubtensorModule::LastColdkeyHotkeyStakeBlock` (`max_values`: None, `max_size`: None, mode: `Measured`) fn add_stake_burn() -> Weight { // Proof Size summary in bytes: - // Measured: `2617` + // Measured: `2592` // Estimated: `8727` - // Minimum execution time: 595_879_000 picoseconds. - Weight::from_parts(616_657_000, 8727) - .saturating_add(RocksDbWeight::get().reads(36_u64)) + // Minimum execution time: 602_169_000 picoseconds. + Weight::from_parts(623_989_000, 8727) + .saturating_add(RocksDbWeight::get().reads(34_u64)) .saturating_add(RocksDbWeight::get().writes(19_u64)) } /// Storage: `SubtensorModule::PendingChildKeyCooldown` (r:0 w:1) @@ -4583,8 +4623,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_575_000 picoseconds. - Weight::from_parts(2_725_000, 0) + // Minimum execution time: 2_875_000 picoseconds. + Weight::from_parts(3_016_000, 0) .saturating_add(RocksDbWeight::get().writes(1_u64)) } /// Storage: `SubtensorModule::StakingHotkeys` (r:1 w:0) @@ -4607,8 +4647,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `1463` // Estimated: `4928` - // Minimum execution time: 90_731_000 picoseconds. - Weight::from_parts(92_755_000, 4928) + // Minimum execution time: 91_683_000 picoseconds. + Weight::from_parts(93_107_000, 4928) .saturating_add(RocksDbWeight::get().reads(8_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -4624,8 +4664,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `978` // Estimated: `6918` - // Minimum execution time: 70_652_000 picoseconds. - Weight::from_parts(72_135_000, 6918) + // Minimum execution time: 70_593_000 picoseconds. + Weight::from_parts(72_246_000, 6918) .saturating_add(RocksDbWeight::get().reads(5_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -4643,8 +4683,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `1302` // Estimated: `7242` - // Minimum execution time: 93_155_000 picoseconds. - Weight::from_parts(94_457_000, 7242) + // Minimum execution time: 92_866_000 picoseconds. + Weight::from_parts(94_739_000, 7242) .saturating_add(RocksDbWeight::get().reads(8_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } diff --git a/pallets/utility/src/weights.rs b/pallets/utility/src/weights.rs index 462804199f..1e88a56baf 100644 --- a/pallets/utility/src/weights.rs +++ b/pallets/utility/src/weights.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_subtensor_utility` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 49.1.0 -//! DATE: 2026-05-05, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2026-05-15, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! HOSTNAME: `runnervmeorf1`, CPU: `AMD EPYC 7763 64-Core Processor` //! WASM-EXECUTION: `Compiled`, CHAIN: `None`, DB CACHE: `1024` @@ -22,7 +22,7 @@ // --no-storage-info // --no-min-squares // --no-median-slopes -// --output=/tmp/tmp.4nwfKx4NPm +// --output=/tmp/tmp.cqTGG4k34D // --template=/home/runner/work/subtensor/subtensor/.maintain/frame-weight-template.hbs #![cfg_attr(rustfmt, rustfmt_skip)] @@ -57,10 +57,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `518` // Estimated: `3983` - // Minimum execution time: 4_859_000 picoseconds. - Weight::from_parts(28_407_150, 3983) - // Standard Error: 6_395 - .saturating_add(Weight::from_parts(5_254_263, 0).saturating_mul(c.into())) + // Minimum execution time: 4_879_000 picoseconds. + Weight::from_parts(16_305_907, 3983) + // Standard Error: 2_117 + .saturating_add(Weight::from_parts(5_599_112, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(2_u64)) } /// Storage: `SafeMode::EnteredUntil` (r:1 w:0) @@ -71,8 +71,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `518` // Estimated: `3983` - // Minimum execution time: 14_828_000 picoseconds. - Weight::from_parts(15_318_000, 3983) + // Minimum execution time: 14_918_000 picoseconds. + Weight::from_parts(15_419_000, 3983) .saturating_add(T::DbWeight::get().reads(2_u64)) } /// Storage: `SafeMode::EnteredUntil` (r:1 w:0) @@ -84,18 +84,18 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `518` // Estimated: `3983` - // Minimum execution time: 4_528_000 picoseconds. - Weight::from_parts(18_871_700, 3983) - // Standard Error: 1_818 - .saturating_add(Weight::from_parts(5_525_521, 0).saturating_mul(c.into())) + // Minimum execution time: 4_899_000 picoseconds. + Weight::from_parts(21_919_381, 3983) + // Standard Error: 2_421 + .saturating_add(Weight::from_parts(5_788_376, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(2_u64)) } fn dispatch_as() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_562_000 picoseconds. - Weight::from_parts(6_823_000, 0) + // Minimum execution time: 6_612_000 picoseconds. + Weight::from_parts(7_083_000, 0) } /// Storage: `SafeMode::EnteredUntil` (r:1 w:0) /// Proof: `SafeMode::EnteredUntil` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) @@ -106,18 +106,18 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `518` // Estimated: `3983` - // Minimum execution time: 4_939_000 picoseconds. - Weight::from_parts(12_544_904, 3983) - // Standard Error: 3_006 - .saturating_add(Weight::from_parts(5_296_996, 0).saturating_mul(c.into())) + // Minimum execution time: 4_759_000 picoseconds. + Weight::from_parts(11_867_704, 3983) + // Standard Error: 2_613 + .saturating_add(Weight::from_parts(5_617_108, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(2_u64)) } fn dispatch_as_fallible() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_472_000 picoseconds. - Weight::from_parts(6_862_000, 0) + // Minimum execution time: 6_753_000 picoseconds. + Weight::from_parts(7_013_000, 0) } /// Storage: `SafeMode::EnteredUntil` (r:1 w:0) /// Proof: `SafeMode::EnteredUntil` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) @@ -127,8 +127,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `518` // Estimated: `3983` - // Minimum execution time: 21_039_000 picoseconds. - Weight::from_parts(21_600_000, 3983) + // Minimum execution time: 21_200_000 picoseconds. + Weight::from_parts(21_921_000, 3983) .saturating_add(T::DbWeight::get().reads(2_u64)) } } @@ -144,10 +144,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `518` // Estimated: `3983` - // Minimum execution time: 4_859_000 picoseconds. - Weight::from_parts(28_407_150, 3983) - // Standard Error: 6_395 - .saturating_add(Weight::from_parts(5_254_263, 0).saturating_mul(c.into())) + // Minimum execution time: 4_879_000 picoseconds. + Weight::from_parts(16_305_907, 3983) + // Standard Error: 2_117 + .saturating_add(Weight::from_parts(5_599_112, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(2_u64)) } /// Storage: `SafeMode::EnteredUntil` (r:1 w:0) @@ -158,8 +158,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `518` // Estimated: `3983` - // Minimum execution time: 14_828_000 picoseconds. - Weight::from_parts(15_318_000, 3983) + // Minimum execution time: 14_918_000 picoseconds. + Weight::from_parts(15_419_000, 3983) .saturating_add(RocksDbWeight::get().reads(2_u64)) } /// Storage: `SafeMode::EnteredUntil` (r:1 w:0) @@ -171,18 +171,18 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `518` // Estimated: `3983` - // Minimum execution time: 4_528_000 picoseconds. - Weight::from_parts(18_871_700, 3983) - // Standard Error: 1_818 - .saturating_add(Weight::from_parts(5_525_521, 0).saturating_mul(c.into())) + // Minimum execution time: 4_899_000 picoseconds. + Weight::from_parts(21_919_381, 3983) + // Standard Error: 2_421 + .saturating_add(Weight::from_parts(5_788_376, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(2_u64)) } fn dispatch_as() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_562_000 picoseconds. - Weight::from_parts(6_823_000, 0) + // Minimum execution time: 6_612_000 picoseconds. + Weight::from_parts(7_083_000, 0) } /// Storage: `SafeMode::EnteredUntil` (r:1 w:0) /// Proof: `SafeMode::EnteredUntil` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) @@ -193,18 +193,18 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `518` // Estimated: `3983` - // Minimum execution time: 4_939_000 picoseconds. - Weight::from_parts(12_544_904, 3983) - // Standard Error: 3_006 - .saturating_add(Weight::from_parts(5_296_996, 0).saturating_mul(c.into())) + // Minimum execution time: 4_759_000 picoseconds. + Weight::from_parts(11_867_704, 3983) + // Standard Error: 2_613 + .saturating_add(Weight::from_parts(5_617_108, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(2_u64)) } fn dispatch_as_fallible() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_472_000 picoseconds. - Weight::from_parts(6_862_000, 0) + // Minimum execution time: 6_753_000 picoseconds. + Weight::from_parts(7_013_000, 0) } /// Storage: `SafeMode::EnteredUntil` (r:1 w:0) /// Proof: `SafeMode::EnteredUntil` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) @@ -214,8 +214,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `518` // Estimated: `3983` - // Minimum execution time: 21_039_000 picoseconds. - Weight::from_parts(21_600_000, 3983) + // Minimum execution time: 21_200_000 picoseconds. + Weight::from_parts(21_921_000, 3983) .saturating_add(RocksDbWeight::get().reads(2_u64)) } }