From e0cf426ccda18bbcb1a488d238328525f3f575b0 Mon Sep 17 00:00:00 2001 From: Shamil Gadelshin Date: Wed, 4 Jun 2025 18:41:38 +0400 Subject: [PATCH 01/10] Introduce remove_stake_full_limit extrinsic. --- pallets/subtensor/src/macros/dispatches.rs | 16 ++++++++++++++++ pallets/subtensor/src/staking/remove_stake.rs | 14 ++++++++++++++ 2 files changed, 30 insertions(+) diff --git a/pallets/subtensor/src/macros/dispatches.rs b/pallets/subtensor/src/macros/dispatches.rs index ad76d90ae2..37648fb84a 100644 --- a/pallets/subtensor/src/macros/dispatches.rs +++ b/pallets/subtensor/src/macros/dispatches.rs @@ -2056,5 +2056,21 @@ mod dispatches { ) -> DispatchResult { Self::do_burn_alpha(origin, hotkey, amount, netuid) } + + /// Removes all stake from a hotkey on a subnet with a price limit. + /// This extrinsic allows to specify the limit price for alpha token + /// at which or better (higher) the staking should execute. + #[pallet::call_index(103)] + #[pallet::weight((Weight::from_parts(192_600_000, 0) + .saturating_add(T::DbWeight::get().reads(18)) + .saturating_add(T::DbWeight::get().writes(10)), DispatchClass::Normal, Pays::No))] + pub fn remove_stake_full_limit( + origin: T::RuntimeOrigin, + hotkey: T::AccountId, + netuid: NetUid, + limit_price: u64, + ) -> DispatchResult { + Self::do_remove_stake_full_limit(origin, hotkey, netuid, limit_price) + } } } diff --git a/pallets/subtensor/src/staking/remove_stake.rs b/pallets/subtensor/src/staking/remove_stake.rs index 0fa7e94977..ebcf6fbf21 100644 --- a/pallets/subtensor/src/staking/remove_stake.rs +++ b/pallets/subtensor/src/staking/remove_stake.rs @@ -458,4 +458,18 @@ impl Pallet { Ok(u64::MAX) } } + + pub fn do_remove_stake_full_limit( + origin: T::RuntimeOrigin, + hotkey: T::AccountId, + netuid: NetUid, + limit_price: u64, + ) -> DispatchResult { + let coldkey = ensure_signed(origin.clone())?; + + let alpha_unstaked = + Self::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid); + + Self::do_remove_stake_limit(origin, hotkey, netuid, alpha_unstaked, limit_price, false) + } } From e0100d79b09793683084536c6c50da8c592f8b29 Mon Sep 17 00:00:00 2001 From: Shamil Gadelshin Date: Thu, 12 Jun 2025 16:53:31 +0400 Subject: [PATCH 02/10] Add tests for remove_stake_full_limit. --- pallets/subtensor/src/tests/staking.rs | 92 ++++++++++++++++++++++++++ 1 file changed, 92 insertions(+) diff --git a/pallets/subtensor/src/tests/staking.rs b/pallets/subtensor/src/tests/staking.rs index b0fc25fc8c..caf5c57834 100644 --- a/pallets/subtensor/src/tests/staking.rs +++ b/pallets/subtensor/src/tests/staking.rs @@ -4599,3 +4599,95 @@ fn test_increase_stake_for_hotkey_and_coldkey_on_subnet_adds_to_staking_hotkeys_ assert!(StakingHotkeys::::get(coldkey1).contains(&hotkey)); }); } + +#[test] +fn test_remove_stake_full_limit_ok() { + new_test_ext(1).execute_with(|| { + let hotkey_account_id = U256::from(1); + let coldkey_account_id = U256::from(2); + let stake_amount = 10_000_000_000; + + // add network + let netuid = add_dynamic_network(&hotkey_account_id, &coldkey_account_id); + + // Give the neuron some stake to remove + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &hotkey_account_id, + &coldkey_account_id, + netuid, + stake_amount, + ); + + let tao_reserve: U96F32 = U96F32::from_num(100_000_000_000_u64); + let alpha_in: U96F32 = U96F32::from_num(100_000_000_000_u64); + SubnetTAO::::insert(netuid, tao_reserve.to_num::()); + SubnetAlphaIn::::insert(netuid, alpha_in.to_num::()); + + // Reserves 100 Alpha and 100 TAO, unstake 10. Expected value ~ 9.09 + // 10_000_000_000 + // 9_090_454_547 + let limit_price = 909_000_000; + + // Remove stake with slippage safety + assert_ok!(SubtensorModule::remove_stake_full_limit( + RuntimeOrigin::signed(coldkey_account_id), + hotkey_account_id, + netuid, + limit_price, + )); + + // Check if stake has decreased only by + assert_eq!( + SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet( + &hotkey_account_id, + &coldkey_account_id, + netuid + ), + 0 + ); + + let new_balance = SubtensorModule::get_coldkey_balance(&coldkey_account_id); + assert_abs_diff_eq!(new_balance, 9_090_000_000, epsilon = 1_000_000); + }); +} + +#[test] +fn test_remove_stake_full_limit_fails_slippage_too_high() { + new_test_ext(1).execute_with(|| { + let hotkey_account_id = U256::from(1); + let coldkey_account_id = U256::from(2); + let stake_amount = 10_000_000_000; + + // add network + let netuid = add_dynamic_network(&hotkey_account_id, &coldkey_account_id); + + // Give the neuron some stake to remove + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &hotkey_account_id, + &coldkey_account_id, + netuid, + stake_amount, + ); + + let tao_reserve: U96F32 = U96F32::from_num(100_000_000_000_u64); + let alpha_in: U96F32 = U96F32::from_num(100_000_000_000_u64); + SubnetTAO::::insert(netuid, tao_reserve.to_num::()); + SubnetAlphaIn::::insert(netuid, alpha_in.to_num::()); + + // Reserves 100 Alpha and 100 TAO, unstake 10. Expected value ~ 9.09 + // 10_000_000_000 + // 9_090_454_547 + let invalid_limit_price = 910_000_000; + + // Remove stake with slippage safety + assert_err!( + SubtensorModule::remove_stake_full_limit( + RuntimeOrigin::signed(coldkey_account_id), + hotkey_account_id, + netuid, + invalid_limit_price, + ), + Error::::SlippageTooHigh + ); + }); +} From 95b48e5009a6a10eee4139ccfad2fc8263604f6a Mon Sep 17 00:00:00 2001 From: Shamil Gadelshin Date: Thu, 12 Jun 2025 17:50:40 +0400 Subject: [PATCH 03/10] Add benchmark for remove_stake_full_limit --- pallets/subtensor/src/benchmarks.rs | 54 ++++++++++++++++++++++ pallets/subtensor/src/macros/dispatches.rs | 6 +-- 2 files changed, 57 insertions(+), 3 deletions(-) diff --git a/pallets/subtensor/src/benchmarks.rs b/pallets/subtensor/src/benchmarks.rs index f1c7fc4625..0e9411ba3f 100644 --- a/pallets/subtensor/src/benchmarks.rs +++ b/pallets/subtensor/src/benchmarks.rs @@ -1321,4 +1321,58 @@ mod pallet_benchmarks { #[extrinsic_call] _(RawOrigin::Signed(coldkey.clone()), hotkey.clone()); } + + #[benchmark] + fn remove_stake_full_limit() { + let netuid = NetUid::from(1); + let tempo: u16 = 1; + let seed: u32 = 1; + + // Set our total stake to 1000 TAO + Subtensor::::increase_total_stake(1_000_000_000_000); + + Subtensor::::init_new_network(netuid, tempo); + Subtensor::::set_network_registration_allowed(netuid, true); + SubtokenEnabled::::insert(netuid, true); + + Subtensor::::set_max_allowed_uids(netuid, 4096); + assert_eq!(Subtensor::::get_max_allowed_uids(netuid), 4096); + + let coldkey: T::AccountId = account("Test", 0, seed); + let hotkey: T::AccountId = account("Alice", 0, seed); + Subtensor::::set_burn(netuid, 1); + + let limit: u64 = 1_000_000_000; + let tao_reserve = 150_000_000_000_u64; + let alpha_in = 100_000_000_000_u64; + SubnetTAO::::insert(netuid, tao_reserve); + SubnetAlphaIn::::insert(netuid, alpha_in); + + let wallet_bal = 1000000u32.into(); + Subtensor::::add_balance_to_coldkey_account(&coldkey.clone(), wallet_bal); + + assert_ok!(Subtensor::::do_burned_registration( + RawOrigin::Signed(coldkey.clone()).into(), + netuid, + hotkey.clone() + )); + + let u64_staked_amt = 100_000_000_000; + Subtensor::::add_balance_to_coldkey_account(&coldkey.clone(), u64_staked_amt); + + assert_ok!(Subtensor::::add_stake( + RawOrigin::Signed(coldkey.clone()).into(), + hotkey.clone(), + netuid, + u64_staked_amt + )); + + #[extrinsic_call] + _( + RawOrigin::Signed(coldkey.clone()), + hotkey.clone(), + netuid, + limit, + ); + } } diff --git a/pallets/subtensor/src/macros/dispatches.rs b/pallets/subtensor/src/macros/dispatches.rs index 37648fb84a..ef0b8c2852 100644 --- a/pallets/subtensor/src/macros/dispatches.rs +++ b/pallets/subtensor/src/macros/dispatches.rs @@ -2061,9 +2061,9 @@ mod dispatches { /// This extrinsic allows to specify the limit price for alpha token /// at which or better (higher) the staking should execute. #[pallet::call_index(103)] - #[pallet::weight((Weight::from_parts(192_600_000, 0) - .saturating_add(T::DbWeight::get().reads(18)) - .saturating_add(T::DbWeight::get().writes(10)), DispatchClass::Normal, Pays::No))] + #[pallet::weight((Weight::from_parts(147_000_000, 10142) + .saturating_add(T::DbWeight::get().reads(18_u64)) + .saturating_add(T::DbWeight::get().writes(10_u64)), DispatchClass::Normal, Pays::No))] pub fn remove_stake_full_limit( origin: T::RuntimeOrigin, hotkey: T::AccountId, From ed226a35d3788c32265d90166b9e9709697cca87 Mon Sep 17 00:00:00 2001 From: Shamil Gadelshin Date: Fri, 13 Jun 2025 14:22:37 +0400 Subject: [PATCH 04/10] Add proxy filter. --- runtime/src/lib.rs | 31 +++++++------------------------ 1 file changed, 7 insertions(+), 24 deletions(-) diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs index 581e3d2252..e6d98eec93 100644 --- a/runtime/src/lib.rs +++ b/runtime/src/lib.rs @@ -697,18 +697,9 @@ impl InstanceFilter for ProxyType { | RuntimeCall::SubtensorModule( pallet_subtensor::Call::remove_stake_limit { .. } ) - // | RuntimeCall::SubtensorModule( - // pallet_subtensor::Call::add_stake_aggregate { .. } - // ) - // | RuntimeCall::SubtensorModule( - // pallet_subtensor::Call::add_stake_limit_aggregate { .. } - // ) - // | RuntimeCall::SubtensorModule( - // pallet_subtensor::Call::remove_stake_aggregate { .. } - // ) - // | RuntimeCall::SubtensorModule( - // pallet_subtensor::Call::remove_stake_limit_aggregate { .. } - // ) + | RuntimeCall::SubtensorModule( + pallet_subtensor::Call::remove_stake_full_limit { .. } + ) | RuntimeCall::SubtensorModule(pallet_subtensor::Call::unstake_all { .. }) | RuntimeCall::SubtensorModule( pallet_subtensor::Call::unstake_all_alpha { .. } @@ -789,18 +780,10 @@ impl InstanceFilter for ProxyType { | RuntimeCall::SubtensorModule(pallet_subtensor::Call::add_stake_limit { .. }) | RuntimeCall::SubtensorModule( pallet_subtensor::Call::remove_stake_limit { .. } - ) // | RuntimeCall::SubtensorModule( - // pallet_subtensor::Call::add_stake_aggregate { .. } - // ) - // | RuntimeCall::SubtensorModule( - // pallet_subtensor::Call::add_stake_limit_aggregate { .. } - // ) - // | RuntimeCall::SubtensorModule( - // pallet_subtensor::Call::remove_stake_aggregate { .. } - // ) - // | RuntimeCall::SubtensorModule( - // pallet_subtensor::Call::remove_stake_limit_aggregate { .. } - // ) + ) + | RuntimeCall::SubtensorModule( + pallet_subtensor::Call::remove_stake_full_limit { .. } + ) ), ProxyType::Registration => matches!( c, From b095b5e1cb52b5109523fbe170a4b281944f32da Mon Sep 17 00:00:00 2001 From: Shamil Gadelshin Date: Fri, 13 Jun 2025 18:44:06 +0400 Subject: [PATCH 05/10] Fix benchmark --- pallets/subtensor/src/macros/dispatches.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pallets/subtensor/src/macros/dispatches.rs b/pallets/subtensor/src/macros/dispatches.rs index ef0b8c2852..3034d5151f 100644 --- a/pallets/subtensor/src/macros/dispatches.rs +++ b/pallets/subtensor/src/macros/dispatches.rs @@ -2061,7 +2061,7 @@ mod dispatches { /// This extrinsic allows to specify the limit price for alpha token /// at which or better (higher) the staking should execute. #[pallet::call_index(103)] - #[pallet::weight((Weight::from_parts(147_000_000, 10142) + #[pallet::weight((Weight::from_parts(206_700_000, 10142) .saturating_add(T::DbWeight::get().reads(18_u64)) .saturating_add(T::DbWeight::get().writes(10_u64)), DispatchClass::Normal, Pays::No))] pub fn remove_stake_full_limit( From d8f92c7bc37164cd9e7bd448d9cf59f8d4039832 Mon Sep 17 00:00:00 2001 From: gztensor <166415444+gztensor@users.noreply.github.com> Date: Fri, 13 Jun 2025 08:39:10 -0700 Subject: [PATCH 06/10] Update comment in test_remove_stake_full_limit_ok --- pallets/subtensor/src/tests/staking.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pallets/subtensor/src/tests/staking.rs b/pallets/subtensor/src/tests/staking.rs index caf5c57834..4ffbd5f785 100644 --- a/pallets/subtensor/src/tests/staking.rs +++ b/pallets/subtensor/src/tests/staking.rs @@ -4636,7 +4636,7 @@ fn test_remove_stake_full_limit_ok() { limit_price, )); - // Check if stake has decreased only by + // Check if stake has decreased to zero assert_eq!( SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet( &hotkey_account_id, From bba685d9d1d1cc7b6b60ecbf678170977701a79d Mon Sep 17 00:00:00 2001 From: Shamil Gadelshin Date: Thu, 19 Jun 2025 17:36:50 +0400 Subject: [PATCH 07/10] Make price limit optional. --- pallets/subtensor/src/benchmarks.rs | 2 +- pallets/subtensor/src/macros/dispatches.rs | 3 +- pallets/subtensor/src/staking/remove_stake.rs | 8 ++- pallets/subtensor/src/tests/staking.rs | 50 ++++++++++++++++++- 4 files changed, 57 insertions(+), 6 deletions(-) diff --git a/pallets/subtensor/src/benchmarks.rs b/pallets/subtensor/src/benchmarks.rs index 5425fb892d..7a47e21cbf 100644 --- a/pallets/subtensor/src/benchmarks.rs +++ b/pallets/subtensor/src/benchmarks.rs @@ -1374,7 +1374,7 @@ mod pallet_benchmarks { RawOrigin::Signed(coldkey.clone()), hotkey.clone(), netuid, - limit, + Some(limit), ); } } diff --git a/pallets/subtensor/src/macros/dispatches.rs b/pallets/subtensor/src/macros/dispatches.rs index b2772a84dd..1c3dbbf485 100644 --- a/pallets/subtensor/src/macros/dispatches.rs +++ b/pallets/subtensor/src/macros/dispatches.rs @@ -2074,6 +2074,7 @@ mod dispatches { /// Removes all stake from a hotkey on a subnet with a price limit. /// This extrinsic allows to specify the limit price for alpha token /// at which or better (higher) the staking should execute. + /// Without limit_price it remove all the stake similar to `remove_stake` extrinsic #[pallet::call_index(103)] #[pallet::weight((Weight::from_parts(206_700_000, 10142) .saturating_add(T::DbWeight::get().reads(18_u64)) @@ -2082,7 +2083,7 @@ mod dispatches { origin: T::RuntimeOrigin, hotkey: T::AccountId, netuid: NetUid, - limit_price: u64, + limit_price: Option, ) -> DispatchResult { Self::do_remove_stake_full_limit(origin, hotkey, netuid, limit_price) } diff --git a/pallets/subtensor/src/staking/remove_stake.rs b/pallets/subtensor/src/staking/remove_stake.rs index ebcf6fbf21..09643d8875 100644 --- a/pallets/subtensor/src/staking/remove_stake.rs +++ b/pallets/subtensor/src/staking/remove_stake.rs @@ -463,13 +463,17 @@ impl Pallet { origin: T::RuntimeOrigin, hotkey: T::AccountId, netuid: NetUid, - limit_price: u64, + limit_price: Option, ) -> DispatchResult { let coldkey = ensure_signed(origin.clone())?; let alpha_unstaked = Self::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid); - Self::do_remove_stake_limit(origin, hotkey, netuid, alpha_unstaked, limit_price, false) + if let Some(limit_price) = limit_price { + Self::do_remove_stake_limit(origin, hotkey, netuid, alpha_unstaked, limit_price, false) + } else { + Self::do_remove_stake(origin, hotkey, netuid, alpha_unstaked) + } } } diff --git a/pallets/subtensor/src/tests/staking.rs b/pallets/subtensor/src/tests/staking.rs index 5042c1d20b..c1fec5542c 100644 --- a/pallets/subtensor/src/tests/staking.rs +++ b/pallets/subtensor/src/tests/staking.rs @@ -4687,7 +4687,7 @@ fn test_remove_stake_full_limit_ok() { RuntimeOrigin::signed(coldkey_account_id), hotkey_account_id, netuid, - limit_price, + Some(limit_price), )); // Check if stake has decreased to zero @@ -4739,9 +4739,55 @@ fn test_remove_stake_full_limit_fails_slippage_too_high() { RuntimeOrigin::signed(coldkey_account_id), hotkey_account_id, netuid, - invalid_limit_price, + Some(invalid_limit_price), ), Error::::SlippageTooHigh ); }); } + +#[test] +fn test_remove_stake_full_limit_ok_with_no_limit_price() { + new_test_ext(1).execute_with(|| { + let hotkey_account_id = U256::from(1); + let coldkey_account_id = U256::from(2); + let stake_amount = 10_000_000_000; + + // add network + let netuid = add_dynamic_network(&hotkey_account_id, &coldkey_account_id); + + // Give the neuron some stake to remove + SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet( + &hotkey_account_id, + &coldkey_account_id, + netuid, + stake_amount, + ); + + let tao_reserve: U96F32 = U96F32::from_num(100_000_000_000_u64); + let alpha_in: U96F32 = U96F32::from_num(100_000_000_000_u64); + SubnetTAO::::insert(netuid, tao_reserve.to_num::()); + SubnetAlphaIn::::insert(netuid, alpha_in.to_num::()); + + // Remove stake with slippage safety + assert_ok!(SubtensorModule::remove_stake_full_limit( + RuntimeOrigin::signed(coldkey_account_id), + hotkey_account_id, + netuid, + None, + )); + + // Check if stake has decreased to zero + assert_eq!( + SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet( + &hotkey_account_id, + &coldkey_account_id, + netuid + ), + 0 + ); + + let new_balance = SubtensorModule::get_coldkey_balance(&coldkey_account_id); + assert_abs_diff_eq!(new_balance, 9_090_000_000, epsilon = 1_000_000); + }); +} From d5e7d0b0c65c9b23111eca9ef7aaf2416eea8dd5 Mon Sep 17 00:00:00 2001 From: Shamil Gadelshin Date: Thu, 19 Jun 2025 18:07:09 +0400 Subject: [PATCH 08/10] Update tests. --- pallets/subtensor/src/tests/staking.rs | 12 +++--------- 1 file changed, 3 insertions(+), 9 deletions(-) diff --git a/pallets/subtensor/src/tests/staking.rs b/pallets/subtensor/src/tests/staking.rs index 1e883f10e8..21fe4a4869 100644 --- a/pallets/subtensor/src/tests/staking.rs +++ b/pallets/subtensor/src/tests/staking.rs @@ -5078,10 +5078,7 @@ fn test_remove_stake_full_limit_ok() { SubnetTAO::::insert(netuid, tao_reserve.to_num::()); SubnetAlphaIn::::insert(netuid, alpha_in.to_num::()); - // Reserves 100 Alpha and 100 TAO, unstake 10. Expected value ~ 9.09 - // 10_000_000_000 - // 9_090_454_547 - let limit_price = 909_000_000; + let limit_price = 90_000_000; // Remove stake with slippage safety assert_ok!(SubtensorModule::remove_stake_full_limit( @@ -5102,7 +5099,7 @@ fn test_remove_stake_full_limit_ok() { ); let new_balance = SubtensorModule::get_coldkey_balance(&coldkey_account_id); - assert_abs_diff_eq!(new_balance, 9_090_000_000, epsilon = 1_000_000); + assert_abs_diff_eq!(new_balance, 9_066_000_000, epsilon = 1_000_000); }); } @@ -5129,9 +5126,6 @@ fn test_remove_stake_full_limit_fails_slippage_too_high() { SubnetTAO::::insert(netuid, tao_reserve.to_num::()); SubnetAlphaIn::::insert(netuid, alpha_in.to_num::()); - // Reserves 100 Alpha and 100 TAO, unstake 10. Expected value ~ 9.09 - // 10_000_000_000 - // 9_090_454_547 let invalid_limit_price = 910_000_000; // Remove stake with slippage safety @@ -5189,7 +5183,7 @@ fn test_remove_stake_full_limit_ok_with_no_limit_price() { ); let new_balance = SubtensorModule::get_coldkey_balance(&coldkey_account_id); - assert_abs_diff_eq!(new_balance, 9_090_000_000, epsilon = 1_000_000); + assert_abs_diff_eq!(new_balance, 9_066_000_000, epsilon = 1_000_000); }); } /// This test verifies that minimum stake amount is sufficient to move price and apply From 2db246fcf894f802554b3fe1c3c3f092425d2a3d Mon Sep 17 00:00:00 2001 From: Shamil Gadelshin Date: Tue, 24 Jun 2025 14:56:52 +0400 Subject: [PATCH 09/10] Update spec version. --- runtime/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs index e0685c88d3..4089522ee4 100644 --- a/runtime/src/lib.rs +++ b/runtime/src/lib.rs @@ -217,7 +217,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion { // `spec_version`, and `authoring_version` are the same between Wasm and native. // This value is set to 100 to notify Polkadot-JS App (https://polkadot.js.org/apps) to use // the compatible custom types. - spec_version: 279, + spec_version: 280, impl_version: 1, apis: RUNTIME_API_VERSIONS, transaction_version: 1, From 707c00126464fc1d8e5ed7c921fc6a008ba608c4 Mon Sep 17 00:00:00 2001 From: Shamil Gadelshin Date: Tue, 24 Jun 2025 20:21:59 +0400 Subject: [PATCH 10/10] Update benchmarks. --- pallets/subtensor/src/macros/dispatches.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/pallets/subtensor/src/macros/dispatches.rs b/pallets/subtensor/src/macros/dispatches.rs index 50cdef128c..838aa1c715 100644 --- a/pallets/subtensor/src/macros/dispatches.rs +++ b/pallets/subtensor/src/macros/dispatches.rs @@ -2075,9 +2075,9 @@ mod dispatches { /// at which or better (higher) the staking should execute. /// Without limit_price it remove all the stake similar to `remove_stake` extrinsic #[pallet::call_index(103)] - #[pallet::weight((Weight::from_parts(206_700_000, 10142) - .saturating_add(T::DbWeight::get().reads(18_u64)) - .saturating_add(T::DbWeight::get().writes(10_u64)), DispatchClass::Normal, Pays::No))] + #[pallet::weight((Weight::from_parts(398_000_000, 10142) + .saturating_add(T::DbWeight::get().reads(29_u64)) + .saturating_add(T::DbWeight::get().writes(14_u64)), DispatchClass::Normal, Pays::No))] pub fn remove_stake_full_limit( origin: T::RuntimeOrigin, hotkey: T::AccountId,