Automatic withdraw_unbonded upon unbond (#12582)

* Prevents max unbonding chunk slots from being filled when unbonding in the staking pallet

* hardcode num_slashing to unlock chunks automatically

* refactor withdraw logic to do_withdraw; idiomatic rust improvements

* a

* callable unbond() to return a DispatchWithPostInfo to dynamically update the consumed weight

* refunds overpaid fees when unbond with withdraw

* fetches real slashing spans before withdrawal call

* nits

* addresses PR comments

* Adds more testing

* fixes doc comments

* Fixes weight refunding logic for fn unbond

* generalizes  to return used weight or dispatch error

* Update frame/staking/src/pallet/mod.rs

Co-authored-by: Kian Paimani <5588131+kianenigma@users.noreply.github.com>

* Update frame/staking/src/pallet/mod.rs

Co-authored-by: Kian Paimani <5588131+kianenigma@users.noreply.github.com>

* Addresses PR comments

* Add comment to speculative num spans

* adds missing add_slashing_spans in withdraw_unbonded_kill benchmarks

* ".git/.scripts/bench-bot.sh" pallet dev pallet_staking

* fix publish

Co-authored-by: Kian Paimani <5588131+kianenigma@users.noreply.github.com>
Co-authored-by: command-bot <>

substrate/frame/nomination-pools/src/lib.rs

@@ -1644,9 +1644,12 @@ pub mod pallet {
 		/// # Note
 		///
 		/// If there are too many unlocking chunks to unbond with the pool account,
-		/// [`Call::pool_withdraw_unbonded`] can be called to try and minimize unlocking chunks. If
-		/// there are too many unlocking chunks, the result of this call will likely be the
-		/// `NoMoreChunks` error from the staking system.
+		/// [`Call::pool_withdraw_unbonded`] can be called to try and minimize unlocking chunks.
+		/// The [`StakingInterface::unbond`] will implicitly call [`Call::pool_withdraw_unbonded`]
+		/// to try to free chunks if necessary (ie. if unbound was called and no unlocking chunks
+		/// are available). However, it may not be possible to release the current unlocking chunks,
+		/// in which case, the result of this call will likely be the `NoMoreChunks` error from the
+		/// staking system.
 		#[pallet::call_index(3)]
 		#[pallet::weight(T::WeightInfo::unbond())]
 		pub fn unbond(

substrate/frame/staking/src/benchmarking.rs

@@ -316,6 +316,7 @@ benchmarks! {
 		let scenario = ListScenario::<T>::new(origin_weight, true)?;
 		let controller = scenario.origin_controller1.clone();
 		let stash = scenario.origin_stash1;
+		add_slashing_spans::<T>(&stash, s);
 		assert!(T::VoterList::contains(&stash));
 
 		let ed = T::Currency::minimum_balance();

substrate/frame/staking/src/pallet/impls.rs

@@ -92,6 +92,45 @@ impl<T: Config> Pallet<T> {
 		Self::slashable_balance_of_vote_weight(who, issuance)
 	}
 
+	pub(super) fn do_withdraw_unbonded(
+		controller: &T::AccountId,
+		num_slashing_spans: u32,
+	) -> Result<Weight, DispatchError> {
+		let mut ledger = Self::ledger(&controller).ok_or(Error::<T>::NotController)?;
+		let (stash, old_total) = (ledger.stash.clone(), ledger.total);
+		if let Some(current_era) = Self::current_era() {
+			ledger = ledger.consolidate_unlocked(current_era)
+		}
+
+		let used_weight =
+			if ledger.unlocking.is_empty() && ledger.active < T::Currency::minimum_balance() {
+				// This account must have called `unbond()` with some value that caused the active
+				// portion to fall below existential deposit + will have no more unlocking chunks
+				// left. We can now safely remove all staking-related information.
+				Self::kill_stash(&stash, num_slashing_spans)?;
+				// Remove the lock.
+				T::Currency::remove_lock(STAKING_ID, &stash);
+
+				T::WeightInfo::withdraw_unbonded_kill(num_slashing_spans)
+			} else {
+				// This was the consequence of a partial unbond. just update the ledger and move on.
+				Self::update_ledger(&controller, &ledger);
+
+				// This is only an update, so we use less overall weight.
+				T::WeightInfo::withdraw_unbonded_update(num_slashing_spans)
+			};
+
+		// `old_total` should never be less than the new total because
+		// `consolidate_unlocked` strictly subtracts balance.
+		if ledger.total < old_total {
+			// Already checked that this won't overflow by entry condition.
+			let value = old_total - ledger.total;
+			Self::deposit_event(Event::<T>::Withdrawn { stash, amount: value });
+		}
+
+		Ok(used_weight)
+	}
+
 	pub(super) fn do_payout_stakers(
 		validator_stash: T::AccountId,
 		era: EraIndex,
@@ -1568,6 +1607,8 @@ impl<T: Config> StakingInterface for Pallet<T> {
 	fn unbond(who: &Self::AccountId, value: Self::Balance) -> DispatchResult {
 		let ctrl = Self::bonded(who).ok_or(Error::<T>::NotStash)?;
 		Self::unbond(RawOrigin::Signed(ctrl).into(), value)
+			.map_err(|with_post| with_post.error)
+			.map(|_| ())
 	}
 
 	fn chill(who: &Self::AccountId) -> DispatchResult {

substrate/frame/staking/src/pallet/mod.rs

@@ -51,6 +51,10 @@ use crate::{
 };
 
 const STAKING_ID: LockIdentifier = *b"staking ";
+// The speculative number of spans are used as an input of the weight annotation of
+// [`Call::unbond`], as the post dipatch weight may depend on the number of slashing span on the
+// account which is not provided as an input. The value set should be conservative but sensible.
+pub(crate) const SPECULATIVE_NUM_SPANS: u32 = 32;
 
 #[frame_support::pallet]
 pub mod pallet {
@@ -115,7 +119,6 @@ pub mod pallet {
 			// we only accept an election provider that has staking as data provider.
 			DataProvider = Pallet<Self>,
 		>;
-
 		/// Something that provides the election functionality at genesis.
 		type GenesisElectionProvider: ElectionProvider<
 			AccountId = Self::AccountId,
@@ -953,8 +956,8 @@ pub mod pallet {
 		/// the funds out of management ready for transfer.
 		///
 		/// No more than a limited number of unlocking chunks (see `MaxUnlockingChunks`)
-		/// can co-exists at the same time. In that case, [`Call::withdraw_unbonded`] need
-		/// to be called first to remove some of the chunks (if possible).
+		/// can co-exists at the same time. If there are no unlocking chunks slots available
+		/// [`Call::withdraw_unbonded`] is called to remove some of the chunks (if possible).
 		///
 		/// If a user encounters the `InsufficientBond` error when calling this extrinsic,
 		/// they should call `chill` first in order to free up their bonded funds.
@@ -963,20 +966,39 @@ pub mod pallet {
 		///
 		/// See also [`Call::withdraw_unbonded`].
 		#[pallet::call_index(2)]
-		#[pallet::weight(T::WeightInfo::unbond())]
+		#[pallet::weight(
+            T::WeightInfo::withdraw_unbonded_kill(SPECULATIVE_NUM_SPANS).saturating_add(T::WeightInfo::unbond()))
+        ]
 		pub fn unbond(
 			origin: OriginFor<T>,
 			#[pallet::compact] value: BalanceOf<T>,
-		) -> DispatchResult {
+		) -> DispatchResultWithPostInfo {
 			let controller = ensure_signed(origin)?;
+			let unlocking = Self::ledger(&controller)
+				.map(|l| l.unlocking.len())
+				.ok_or(Error::<T>::NotController)?;
+
+			// if there are no unlocking chunks available, try to withdraw chunks older than
+			// `BondingDuration` to proceed with the unbonding.
+			let maybe_withdraw_weight = {
+				if unlocking == T::MaxUnlockingChunks::get() as usize {
+					let real_num_slashing_spans = Self::slashing_spans(&controller).iter().count();
+					Some(Self::do_withdraw_unbonded(&controller, real_num_slashing_spans as u32)?)
+				} else {
+					None
+				}
+			};
+
+			// we need to fetch the ledger again because it may have been mutated in the call
+			// to `Self::do_withdraw_unbonded` above.
 			let mut ledger = Self::ledger(&controller).ok_or(Error::<T>::NotController)?;
+			let mut value = value.min(ledger.active);
+
 			ensure!(
 				ledger.unlocking.len() < T::MaxUnlockingChunks::get() as usize,
 				Error::<T>::NoMoreChunks,
 			);
 
-			let mut value = value.min(ledger.active);
-
 			if !value.is_zero() {
 				ledger.active -= value;
 
@@ -1024,7 +1046,14 @@ pub mod pallet {
 
 				Self::deposit_event(Event::<T>::Unbonded { stash: ledger.stash, amount: value });
 			}
-			Ok(())
+
+			let actual_weight = if let Some(withdraw_weight) = maybe_withdraw_weight {
+				Some(T::WeightInfo::unbond().saturating_add(withdraw_weight))
+			} else {
+				Some(T::WeightInfo::unbond())
+			};
+
+			Ok(actual_weight.into())
 		}
 
 		/// Remove any unlocked chunks from the `unlocking` queue from our management.
@@ -1049,40 +1078,9 @@ pub mod pallet {
 			num_slashing_spans: u32,
 		) -> DispatchResultWithPostInfo {
 			let controller = ensure_signed(origin)?;
-			let mut ledger = Self::ledger(&controller).ok_or(Error::<T>::NotController)?;
-			let (stash, old_total) = (ledger.stash.clone(), ledger.total);
-			if let Some(current_era) = Self::current_era() {
-				ledger = ledger.consolidate_unlocked(current_era)
-			}
 
-			let post_info_weight = if ledger.unlocking.is_empty() &&
-				ledger.active < T::Currency::minimum_balance()
-			{
-				// This account must have called `unbond()` with some value that caused the active
-				// portion to fall below existential deposit + will have no more unlocking chunks
-				// left. We can now safely remove all staking-related information.
-				Self::kill_stash(&stash, num_slashing_spans)?;
-				// Remove the lock.
-				T::Currency::remove_lock(STAKING_ID, &stash);
-				// This is worst case scenario, so we use the full weight and return None
-				None
-			} else {
-				// This was the consequence of a partial unbond. just update the ledger and move on.
-				Self::update_ledger(&controller, &ledger);
-
-				// This is only an update, so we use less overall weight.
-				Some(T::WeightInfo::withdraw_unbonded_update(num_slashing_spans))
-			};
-
-			// `old_total` should never be less than the new total because
-			// `consolidate_unlocked` strictly subtracts balance.
-			if ledger.total < old_total {
-				// Already checked that this won't overflow by entry condition.
-				let value = old_total - ledger.total;
-				Self::deposit_event(Event::<T>::Withdrawn { stash, amount: value });
-			}
-
-			Ok(post_info_weight.into())
+			let actual_weight = Self::do_withdraw_unbonded(&controller, num_slashing_spans)?;
+			Ok(Some(actual_weight).into())
 		}
 
 		/// Declare the desire to validate for the origin controller.

substrate/frame/staking/src/tests.rs

@@ -1350,12 +1350,14 @@ fn bond_extra_and_withdraw_unbonded_works() {
 }
 
 #[test]
-fn too_many_unbond_calls_should_not_work() {
+fn many_unbond_calls_should_work() {
 	ExtBuilder::default().build_and_execute(|| {
 		let mut current_era = 0;
 		// locked at era MaxUnlockingChunks - 1 until 3
 
-		for i in 0..<<Test as Config>::MaxUnlockingChunks as Get<u32>>::get() - 1 {
+		let max_unlocking_chunks = <<Test as Config>::MaxUnlockingChunks as Get<u32>>::get();
+
+		for i in 0..max_unlocking_chunks - 1 {
 			// There is only 1 chunk per era, so we need to be in a new era to create a chunk.
 			current_era = i as u32;
 			mock::start_active_era(current_era);
@@ -1365,27 +1367,57 @@ fn too_many_unbond_calls_should_not_work() {
 		current_era += 1;
 		mock::start_active_era(current_era);
 
-		// This chunk is locked at `current_era` through `current_era + 2` (because BondingDuration
-		// == 3).
+		// This chunk is locked at `current_era` through `current_era + 2` (because
+		// `BondingDuration` == 3).
 		assert_ok!(Staking::unbond(RuntimeOrigin::signed(10), 1));
 		assert_eq!(
-			Staking::ledger(&10).unwrap().unlocking.len(),
+			Staking::ledger(&10).map(|l| l.unlocking.len()).unwrap(),
 			<<Test as Config>::MaxUnlockingChunks as Get<u32>>::get() as usize
 		);
-		// can't do more.
-		assert_noop!(Staking::unbond(RuntimeOrigin::signed(10), 1), Error::<Test>::NoMoreChunks);
 
-		current_era += 2;
+		// even though the number of unlocked chunks is the same as `MaxUnlockingChunks`,
+		// unbonding works as expected.
+		for i in current_era..(current_era + max_unlocking_chunks) - 1 {
+			// There is only 1 chunk per era, so we need to be in a new era to create a chunk.
+			current_era = i as u32;
+			mock::start_active_era(current_era);
+			assert_ok!(Staking::unbond(RuntimeOrigin::signed(10), 1));
+		}
+
+		// only slots within last `BondingDuration` are filled.
+		assert_eq!(
+			Staking::ledger(&10).map(|l| l.unlocking.len()).unwrap(),
+			<<Test as Config>::BondingDuration>::get() as usize
+		);
+	})
+}
+
+#[test]
+fn auto_withdraw_may_not_unlock_all_chunks() {
+	ExtBuilder::default().build_and_execute(|| {
+		// set `MaxUnlockingChunks` to a low number to test case when the unbonding period
+		// is larger than the number of unlocking chunks available, which may result on a
+		// `Error::NoMoreChunks`, even when the auto-withdraw tries to release locked chunks.
+		MaxUnlockingChunks::set(1);
+
+		let mut current_era = 0;
+
+		// fills the chunking slots for account
+		mock::start_active_era(current_era);
+		assert_ok!(Staking::unbond(RuntimeOrigin::signed(10), 1));
+
+		current_era += 1;
 		mock::start_active_era(current_era);
 
+		// unbonding will fail because i) there are no remaining chunks and ii) no filled chunks
+		// can be released because current chunk hasn't stay in the queue for at least
+		// `BondingDuration`
 		assert_noop!(Staking::unbond(RuntimeOrigin::signed(10), 1), Error::<Test>::NoMoreChunks);
-		// free up everything except the most recently added chunk.
-		assert_ok!(Staking::withdraw_unbonded(RuntimeOrigin::signed(10), 0));
-		assert_eq!(Staking::ledger(&10).unwrap().unlocking.len(), 1);
 
-		// Can add again.
+		// fast-forward a few eras for unbond to be successful with implicit withdraw
+		current_era += 10;
+		mock::start_active_era(current_era);
 		assert_ok!(Staking::unbond(RuntimeOrigin::signed(10), 1));
-		assert_eq!(Staking::ledger(&10).unwrap().unlocking.len(), 2);
 	})
 }
 

substrate/frame/staking/src/weights.rs

@@ -18,7 +18,7 @@
 //! Autogenerated weights for pallet_staking
 //!
 //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
-//! DATE: 2022-12-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! DATE: 2022-12-14, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]`
 //! HOSTNAME: `bm3`, CPU: `Intel(R) Core(TM) i7-7700K CPU @ 4.20GHz`
 //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
 
@@ -88,8 +88,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	// Storage: Balances Locks (r:1 w:1)
 	// Storage: Staking Payee (r:0 w:1)
 	fn bond() -> Weight {
-		// Minimum execution time: 56_034 nanoseconds.
-		Weight::from_ref_time(56_646_000)
+		// Minimum execution time: 54_402 nanoseconds.
+		Weight::from_ref_time(55_096_000)
 			.saturating_add(T::DbWeight::get().reads(4))
 			.saturating_add(T::DbWeight::get().writes(4))
 	}
@@ -99,8 +99,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	// Storage: VoterList ListNodes (r:3 w:3)
 	// Storage: VoterList ListBags (r:2 w:2)
 	fn bond_extra() -> Weight {
-		// Minimum execution time: 94_354 nanoseconds.
-		Weight::from_ref_time(95_318_000)
+		// Minimum execution time: 94_407 nanoseconds.
+		Weight::from_ref_time(95_209_000)
 			.saturating_add(T::DbWeight::get().reads(8))
 			.saturating_add(T::DbWeight::get().writes(7))
 	}
@@ -114,8 +114,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	// Storage: Staking Bonded (r:1 w:0)
 	// Storage: VoterList ListBags (r:2 w:2)
 	fn unbond() -> Weight {
-		// Minimum execution time: 99_960 nanoseconds.
-		Weight::from_ref_time(101_022_000)
+		// Minimum execution time: 101_046 nanoseconds.
+		Weight::from_ref_time(101_504_000)
 			.saturating_add(T::DbWeight::get().reads(12))
 			.saturating_add(T::DbWeight::get().writes(8))
 	}
@@ -125,10 +125,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	// Storage: System Account (r:1 w:1)
 	/// The range of component `s` is `[0, 100]`.
 	fn withdraw_unbonded_update(s: u32, ) -> Weight {
-		// Minimum execution time: 45_819 nanoseconds.
-		Weight::from_ref_time(48_073_614)
-			// Standard Error: 1_410
-			.saturating_add(Weight::from_ref_time(62_881).saturating_mul(s.into()))
+		// Minimum execution time: 45_452 nanoseconds.
+		Weight::from_ref_time(47_031_537)
+			// Standard Error: 491
+			.saturating_add(Weight::from_ref_time(67_148).saturating_mul(s.into()))
 			.saturating_add(T::DbWeight::get().reads(4))
 			.saturating_add(T::DbWeight::get().writes(3))
 	}
@@ -145,12 +145,16 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	// Storage: System Account (r:1 w:1)
 	// Storage: Balances Locks (r:1 w:1)
 	// Storage: Staking Payee (r:0 w:1)
+	// Storage: Staking SpanSlash (r:0 w:2)
 	/// The range of component `s` is `[0, 100]`.
-	fn withdraw_unbonded_kill(_s: u32, ) -> Weight {
-		// Minimum execution time: 86_035 nanoseconds.
-		Weight::from_ref_time(89_561_735)
+	fn withdraw_unbonded_kill(s: u32, ) -> Weight {
+		// Minimum execution time: 88_067 nanoseconds.
+		Weight::from_ref_time(93_309_587)
+			// Standard Error: 4_762
+			.saturating_add(Weight::from_ref_time(1_114_938).saturating_mul(s.into()))
 			.saturating_add(T::DbWeight::get().reads(13))
-			.saturating_add(T::DbWeight::get().writes(11))
+			.saturating_add(T::DbWeight::get().writes(12))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(s.into())))
 	}
 	// Storage: Staking Ledger (r:1 w:0)
 	// Storage: Staking MinValidatorBond (r:1 w:0)
@@ -164,8 +168,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	// Storage: VoterList CounterForListNodes (r:1 w:1)
 	// Storage: Staking CounterForValidators (r:1 w:1)
 	fn validate() -> Weight {
-		// Minimum execution time: 68_748 nanoseconds.
-		Weight::from_ref_time(69_285_000)
+		// Minimum execution time: 67_308 nanoseconds.
+		Weight::from_ref_time(68_266_000)
 			.saturating_add(T::DbWeight::get().reads(11))
 			.saturating_add(T::DbWeight::get().writes(5))
 	}
@@ -173,10 +177,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	// Storage: Staking Nominators (r:1 w:1)
 	/// The range of component `k` is `[1, 128]`.
 	fn kick(k: u32, ) -> Weight {
-		// Minimum execution time: 41_641 nanoseconds.
-		Weight::from_ref_time(48_919_231)
-			// Standard Error: 11_548
-			.saturating_add(Weight::from_ref_time(6_901_201).saturating_mul(k.into()))
+		// Minimum execution time: 40_913 nanoseconds.
+		Weight::from_ref_time(48_140_584)
+			// Standard Error: 13_396
+			.saturating_add(Weight::from_ref_time(6_862_893).saturating_mul(k.into()))
 			.saturating_add(T::DbWeight::get().reads(1))
 			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(k.into())))
 			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(k.into())))
@@ -194,10 +198,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	// Storage: Staking CounterForNominators (r:1 w:1)
 	/// The range of component `n` is `[1, 16]`.
 	fn nominate(n: u32, ) -> Weight {
-		// Minimum execution time: 75_097 nanoseconds.
-		Weight::from_ref_time(74_052_497)
-			// Standard Error: 6_784
-			.saturating_add(Weight::from_ref_time(2_842_146).saturating_mul(n.into()))
+		// Minimum execution time: 73_490 nanoseconds.
+		Weight::from_ref_time(72_520_864)
+			// Standard Error: 7_090
+			.saturating_add(Weight::from_ref_time(2_800_566).saturating_mul(n.into()))
 			.saturating_add(T::DbWeight::get().reads(12))
 			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(n.into())))
 			.saturating_add(T::DbWeight::get().writes(6))
@@ -210,58 +214,58 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	// Storage: VoterList ListBags (r:1 w:1)
 	// Storage: VoterList CounterForListNodes (r:1 w:1)
 	fn chill() -> Weight {
-		// Minimum execution time: 67_307 nanoseconds.
-		Weight::from_ref_time(67_838_000)
+		// Minimum execution time: 66_293 nanoseconds.
+		Weight::from_ref_time(66_946_000)
 			.saturating_add(T::DbWeight::get().reads(8))
 			.saturating_add(T::DbWeight::get().writes(6))
 	}
 	// Storage: Staking Ledger (r:1 w:0)
 	// Storage: Staking Payee (r:0 w:1)
 	fn set_payee() -> Weight {
-		// Minimum execution time: 18_831 nanoseconds.
-		Weight::from_ref_time(19_047_000)
+		// Minimum execution time: 18_134 nanoseconds.
+		Weight::from_ref_time(18_497_000)
 			.saturating_add(T::DbWeight::get().reads(1))
 			.saturating_add(T::DbWeight::get().writes(1))
 	}
 	// Storage: Staking Bonded (r:1 w:1)
 	// Storage: Staking Ledger (r:2 w:2)
 	fn set_controller() -> Weight {
-		// Minimum execution time: 27_534 nanoseconds.
-		Weight::from_ref_time(27_806_000)
+		// Minimum execution time: 26_728 nanoseconds.
+		Weight::from_ref_time(27_154_000)
 			.saturating_add(T::DbWeight::get().reads(3))
 			.saturating_add(T::DbWeight::get().writes(3))
 	}
 	// Storage: Staking ValidatorCount (r:0 w:1)
 	fn set_validator_count() -> Weight {
-		// Minimum execution time: 5_211 nanoseconds.
-		Weight::from_ref_time(5_372_000)
+		// Minimum execution time: 4_877 nanoseconds.
+		Weight::from_ref_time(5_028_000)
 			.saturating_add(T::DbWeight::get().writes(1))
 	}
 	// Storage: Staking ForceEra (r:0 w:1)
 	fn force_no_eras() -> Weight {
-		// Minimum execution time: 5_382 nanoseconds.
-		Weight::from_ref_time(5_654_000)
+		// Minimum execution time: 5_000 nanoseconds.
+		Weight::from_ref_time(5_290_000)
 			.saturating_add(T::DbWeight::get().writes(1))
 	}
 	// Storage: Staking ForceEra (r:0 w:1)
 	fn force_new_era() -> Weight {
-		// Minimum execution time: 5_618 nanoseconds.
-		Weight::from_ref_time(5_714_000)
+		// Minimum execution time: 5_093 nanoseconds.
+		Weight::from_ref_time(5_378_000)
 			.saturating_add(T::DbWeight::get().writes(1))
 	}
 	// Storage: Staking ForceEra (r:0 w:1)
 	fn force_new_era_always() -> Weight {
-		// Minimum execution time: 5_589 nanoseconds.
-		Weight::from_ref_time(5_776_000)
+		// Minimum execution time: 5_144 nanoseconds.
+		Weight::from_ref_time(5_454_000)
 			.saturating_add(T::DbWeight::get().writes(1))
 	}
 	// Storage: Staking Invulnerables (r:0 w:1)
 	/// The range of component `v` is `[0, 1000]`.
 	fn set_invulnerables(v: u32, ) -> Weight {
-		// Minimum execution time: 5_541 nanoseconds.
-		Weight::from_ref_time(6_479_253)
-			// Standard Error: 49
-			.saturating_add(Weight::from_ref_time(10_125).saturating_mul(v.into()))
+		// Minimum execution time: 5_190 nanoseconds.
+		Weight::from_ref_time(5_960_962)
+			// Standard Error: 41
+			.saturating_add(Weight::from_ref_time(10_329).saturating_mul(v.into()))
 			.saturating_add(T::DbWeight::get().writes(1))
 	}
 	// Storage: Staking Bonded (r:1 w:1)
@@ -279,10 +283,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	// Storage: Staking SpanSlash (r:0 w:2)
 	/// The range of component `s` is `[0, 100]`.
 	fn force_unstake(s: u32, ) -> Weight {
-		// Minimum execution time: 81_041 nanoseconds.
-		Weight::from_ref_time(88_526_481)
-			// Standard Error: 11_494
-			.saturating_add(Weight::from_ref_time(1_095_933).saturating_mul(s.into()))
+		// Minimum execution time: 80_516 nanoseconds.
+		Weight::from_ref_time(86_317_884)
+			// Standard Error: 2_212
+			.saturating_add(Weight::from_ref_time(1_103_962).saturating_mul(s.into()))
 			.saturating_add(T::DbWeight::get().reads(11))
 			.saturating_add(T::DbWeight::get().writes(12))
 			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(s.into())))
@@ -290,10 +294,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	// Storage: Staking UnappliedSlashes (r:1 w:1)
 	/// The range of component `s` is `[1, 1000]`.
 	fn cancel_deferred_slash(s: u32, ) -> Weight {
-		// Minimum execution time: 92_308 nanoseconds.
-		Weight::from_ref_time(900_351_007)
-			// Standard Error: 59_145
-			.saturating_add(Weight::from_ref_time(4_944_988).saturating_mul(s.into()))
+		// Minimum execution time: 91_795 nanoseconds.
+		Weight::from_ref_time(904_524_900)
+			// Standard Error: 59_193
+			.saturating_add(Weight::from_ref_time(4_944_680).saturating_mul(s.into()))
 			.saturating_add(T::DbWeight::get().reads(1))
 			.saturating_add(T::DbWeight::get().writes(1))
 	}
@@ -308,10 +312,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	// Storage: System Account (r:1 w:1)
 	/// The range of component `n` is `[0, 256]`.
 	fn payout_stakers_dead_controller(n: u32, ) -> Weight {
-		// Minimum execution time: 131_855 nanoseconds.
-		Weight::from_ref_time(197_412_779)
-			// Standard Error: 21_283
-			.saturating_add(Weight::from_ref_time(22_093_758).saturating_mul(n.into()))
+		// Minimum execution time: 127_774 nanoseconds.
+		Weight::from_ref_time(178_857_156)
+			// Standard Error: 15_229
+			.saturating_add(Weight::from_ref_time(22_112_174).saturating_mul(n.into()))
 			.saturating_add(T::DbWeight::get().reads(9))
 			.saturating_add(T::DbWeight::get().reads((3_u64).saturating_mul(n.into())))
 			.saturating_add(T::DbWeight::get().writes(2))
@@ -329,10 +333,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	// Storage: Balances Locks (r:1 w:1)
 	/// The range of component `n` is `[0, 256]`.
 	fn payout_stakers_alive_staked(n: u32, ) -> Weight {
-		// Minimum execution time: 163_118 nanoseconds.
-		Weight::from_ref_time(229_356_697)
-			// Standard Error: 30_740
-			.saturating_add(Weight::from_ref_time(31_575_360).saturating_mul(n.into()))
+		// Minimum execution time: 161_910 nanoseconds.
+		Weight::from_ref_time(217_635_072)
+			// Standard Error: 30_726
+			.saturating_add(Weight::from_ref_time(31_244_329).saturating_mul(n.into()))
 			.saturating_add(T::DbWeight::get().reads(10))
 			.saturating_add(T::DbWeight::get().reads((5_u64).saturating_mul(n.into())))
 			.saturating_add(T::DbWeight::get().writes(3))
@@ -346,10 +350,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	// Storage: VoterList ListBags (r:2 w:2)
 	/// The range of component `l` is `[1, 32]`.
 	fn rebond(l: u32, ) -> Weight {
-		// Minimum execution time: 94_048 nanoseconds.
-		Weight::from_ref_time(95_784_236)
-			// Standard Error: 2_313
-			.saturating_add(Weight::from_ref_time(52_798).saturating_mul(l.into()))
+		// Minimum execution time: 92_986 nanoseconds.
+		Weight::from_ref_time(94_880_481)
+			// Standard Error: 2_007
+			.saturating_add(Weight::from_ref_time(31_421).saturating_mul(l.into()))
 			.saturating_add(T::DbWeight::get().reads(9))
 			.saturating_add(T::DbWeight::get().writes(8))
 	}
@@ -368,10 +372,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	// Storage: Staking SpanSlash (r:0 w:1)
 	/// The range of component `s` is `[1, 100]`.
 	fn reap_stash(s: u32, ) -> Weight {
-		// Minimum execution time: 93_342 nanoseconds.
-		Weight::from_ref_time(95_756_184)
-			// Standard Error: 2_067
-			.saturating_add(Weight::from_ref_time(1_090_785).saturating_mul(s.into()))
+		// Minimum execution time: 92_750 nanoseconds.
+		Weight::from_ref_time(95_115_568)
+			// Standard Error: 2_037
+			.saturating_add(Weight::from_ref_time(1_086_488).saturating_mul(s.into()))
 			.saturating_add(T::DbWeight::get().reads(12))
 			.saturating_add(T::DbWeight::get().writes(12))
 			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(s.into())))
@@ -395,12 +399,12 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// The range of component `v` is `[1, 10]`.
 	/// The range of component `n` is `[0, 100]`.
 	fn new_era(v: u32, n: u32, ) -> Weight {
-		// Minimum execution time: 506_874 nanoseconds.
-		Weight::from_ref_time(507_798_000)
-			// Standard Error: 1_802_261
-			.saturating_add(Weight::from_ref_time(59_874_736).saturating_mul(v.into()))
-			// Standard Error: 179_585
-			.saturating_add(Weight::from_ref_time(13_668_574).saturating_mul(n.into()))
+		// Minimum execution time: 506_543 nanoseconds.
+		Weight::from_ref_time(507_261_000)
+			// Standard Error: 1_766_631
+			.saturating_add(Weight::from_ref_time(59_139_153).saturating_mul(v.into()))
+			// Standard Error: 176_035
+			.saturating_add(Weight::from_ref_time(13_512_781).saturating_mul(n.into()))
 			.saturating_add(T::DbWeight::get().reads(206))
 			.saturating_add(T::DbWeight::get().reads((5_u64).saturating_mul(v.into())))
 			.saturating_add(T::DbWeight::get().reads((4_u64).saturating_mul(n.into())))
@@ -417,12 +421,12 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// The range of component `v` is `[500, 1000]`.
 	/// The range of component `n` is `[500, 1000]`.
 	fn get_npos_voters(v: u32, n: u32, ) -> Weight {
-		// Minimum execution time: 24_634_585 nanoseconds.
-		Weight::from_ref_time(24_718_377_000)
-			// Standard Error: 324_839
-			.saturating_add(Weight::from_ref_time(3_654_508).saturating_mul(v.into()))
-			// Standard Error: 324_839
-			.saturating_add(Weight::from_ref_time(2_927_535).saturating_mul(n.into()))
+		// Minimum execution time: 24_155_382 nanoseconds.
+		Weight::from_ref_time(24_252_568_000)
+			// Standard Error: 319_250
+			.saturating_add(Weight::from_ref_time(3_596_056).saturating_mul(v.into()))
+			// Standard Error: 319_250
+			.saturating_add(Weight::from_ref_time(2_852_023).saturating_mul(n.into()))
 			.saturating_add(T::DbWeight::get().reads(201))
 			.saturating_add(T::DbWeight::get().reads((5_u64).saturating_mul(v.into())))
 			.saturating_add(T::DbWeight::get().reads((4_u64).saturating_mul(n.into())))
@@ -431,10 +435,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	// Storage: Staking Validators (r:501 w:0)
 	/// The range of component `v` is `[500, 1000]`.
 	fn get_npos_targets(v: u32, ) -> Weight {
-		// Minimum execution time: 4_805_490 nanoseconds.
-		Weight::from_ref_time(118_475_494)
-			// Standard Error: 26_332
-			.saturating_add(Weight::from_ref_time(9_635_188).saturating_mul(v.into()))
+		// Minimum execution time: 4_741_111 nanoseconds.
+		Weight::from_ref_time(113_360_179)
+			// Standard Error: 25_375
+			.saturating_add(Weight::from_ref_time(9_494_142).saturating_mul(v.into()))
 			.saturating_add(T::DbWeight::get().reads(2))
 			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(v.into())))
 	}
@@ -445,8 +449,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	// Storage: Staking MaxNominatorsCount (r:0 w:1)
 	// Storage: Staking MinNominatorBond (r:0 w:1)
 	fn set_staking_configs_all_set() -> Weight {
-		// Minimum execution time: 10_816 nanoseconds.
-		Weight::from_ref_time(11_242_000)
+		// Minimum execution time: 11_074 nanoseconds.
+		Weight::from_ref_time(11_312_000)
 			.saturating_add(T::DbWeight::get().writes(6))
 	}
 	// Storage: Staking MinCommission (r:0 w:1)
@@ -456,8 +460,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	// Storage: Staking MaxNominatorsCount (r:0 w:1)
 	// Storage: Staking MinNominatorBond (r:0 w:1)
 	fn set_staking_configs_all_remove() -> Weight {
-		// Minimum execution time: 9_581 nanoseconds.
-		Weight::from_ref_time(10_383_000)
+		// Minimum execution time: 9_795 nanoseconds.
+		Weight::from_ref_time(10_116_000)
 			.saturating_add(T::DbWeight::get().writes(6))
 	}
 	// Storage: Staking Ledger (r:1 w:0)
@@ -471,16 +475,16 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	// Storage: VoterList ListBags (r:1 w:1)
 	// Storage: VoterList CounterForListNodes (r:1 w:1)
 	fn chill_other() -> Weight {
-		// Minimum execution time: 83_669 nanoseconds.
-		Weight::from_ref_time(84_772_000)
+		// Minimum execution time: 82_914 nanoseconds.
+		Weight::from_ref_time(83_848_000)
 			.saturating_add(T::DbWeight::get().reads(11))
 			.saturating_add(T::DbWeight::get().writes(6))
 	}
 	// Storage: Staking MinCommission (r:1 w:0)
 	// Storage: Staking Validators (r:1 w:1)
 	fn force_apply_min_commission() -> Weight {
-		// Minimum execution time: 20_553 nanoseconds.
-		Weight::from_ref_time(20_933_000)
+		// Minimum execution time: 20_317 nanoseconds.
+		Weight::from_ref_time(20_639_000)
 			.saturating_add(T::DbWeight::get().reads(2))
 			.saturating_add(T::DbWeight::get().writes(1))
 	}
@@ -494,8 +498,8 @@ impl WeightInfo for () {
 	// Storage: Balances Locks (r:1 w:1)
 	// Storage: Staking Payee (r:0 w:1)
 	fn bond() -> Weight {
-		// Minimum execution time: 56_034 nanoseconds.
-		Weight::from_ref_time(56_646_000)
+		// Minimum execution time: 54_402 nanoseconds.
+		Weight::from_ref_time(55_096_000)
 			.saturating_add(RocksDbWeight::get().reads(4))
 			.saturating_add(RocksDbWeight::get().writes(4))
 	}
@@ -505,8 +509,8 @@ impl WeightInfo for () {
 	// Storage: VoterList ListNodes (r:3 w:3)
 	// Storage: VoterList ListBags (r:2 w:2)
 	fn bond_extra() -> Weight {
-		// Minimum execution time: 94_354 nanoseconds.
-		Weight::from_ref_time(95_318_000)
+		// Minimum execution time: 94_407 nanoseconds.
+		Weight::from_ref_time(95_209_000)
 			.saturating_add(RocksDbWeight::get().reads(8))
 			.saturating_add(RocksDbWeight::get().writes(7))
 	}
@@ -520,8 +524,8 @@ impl WeightInfo for () {
 	// Storage: Staking Bonded (r:1 w:0)
 	// Storage: VoterList ListBags (r:2 w:2)
 	fn unbond() -> Weight {
-		// Minimum execution time: 99_960 nanoseconds.
-		Weight::from_ref_time(101_022_000)
+		// Minimum execution time: 101_046 nanoseconds.
+		Weight::from_ref_time(101_504_000)
 			.saturating_add(RocksDbWeight::get().reads(12))
 			.saturating_add(RocksDbWeight::get().writes(8))
 	}
@@ -531,10 +535,10 @@ impl WeightInfo for () {
 	// Storage: System Account (r:1 w:1)
 	/// The range of component `s` is `[0, 100]`.
 	fn withdraw_unbonded_update(s: u32, ) -> Weight {
-		// Minimum execution time: 45_819 nanoseconds.
-		Weight::from_ref_time(48_073_614)
-			// Standard Error: 1_410
-			.saturating_add(Weight::from_ref_time(62_881).saturating_mul(s.into()))
+		// Minimum execution time: 45_452 nanoseconds.
+		Weight::from_ref_time(47_031_537)
+			// Standard Error: 491
+			.saturating_add(Weight::from_ref_time(67_148).saturating_mul(s.into()))
 			.saturating_add(RocksDbWeight::get().reads(4))
 			.saturating_add(RocksDbWeight::get().writes(3))
 	}
@@ -551,12 +555,16 @@ impl WeightInfo for () {
 	// Storage: System Account (r:1 w:1)
 	// Storage: Balances Locks (r:1 w:1)
 	// Storage: Staking Payee (r:0 w:1)
+	// Storage: Staking SpanSlash (r:0 w:2)
 	/// The range of component `s` is `[0, 100]`.
-	fn withdraw_unbonded_kill(_s: u32, ) -> Weight {
-		// Minimum execution time: 86_035 nanoseconds.
-		Weight::from_ref_time(89_561_735)
+	fn withdraw_unbonded_kill(s: u32, ) -> Weight {
+		// Minimum execution time: 88_067 nanoseconds.
+		Weight::from_ref_time(93_309_587)
+			// Standard Error: 4_762
+			.saturating_add(Weight::from_ref_time(1_114_938).saturating_mul(s.into()))
 			.saturating_add(RocksDbWeight::get().reads(13))
-			.saturating_add(RocksDbWeight::get().writes(11))
+			.saturating_add(RocksDbWeight::get().writes(12))
+			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(s.into())))
 	}
 	// Storage: Staking Ledger (r:1 w:0)
 	// Storage: Staking MinValidatorBond (r:1 w:0)
@@ -570,8 +578,8 @@ impl WeightInfo for () {
 	// Storage: VoterList CounterForListNodes (r:1 w:1)
 	// Storage: Staking CounterForValidators (r:1 w:1)
 	fn validate() -> Weight {
-		// Minimum execution time: 68_748 nanoseconds.
-		Weight::from_ref_time(69_285_000)
+		// Minimum execution time: 67_308 nanoseconds.
+		Weight::from_ref_time(68_266_000)
 			.saturating_add(RocksDbWeight::get().reads(11))
 			.saturating_add(RocksDbWeight::get().writes(5))
 	}
@@ -579,10 +587,10 @@ impl WeightInfo for () {
 	// Storage: Staking Nominators (r:1 w:1)
 	/// The range of component `k` is `[1, 128]`.
 	fn kick(k: u32, ) -> Weight {
-		// Minimum execution time: 41_641 nanoseconds.
-		Weight::from_ref_time(48_919_231)
-			// Standard Error: 11_548
-			.saturating_add(Weight::from_ref_time(6_901_201).saturating_mul(k.into()))
+		// Minimum execution time: 40_913 nanoseconds.
+		Weight::from_ref_time(48_140_584)
+			// Standard Error: 13_396
+			.saturating_add(Weight::from_ref_time(6_862_893).saturating_mul(k.into()))
 			.saturating_add(RocksDbWeight::get().reads(1))
 			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(k.into())))
 			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(k.into())))
@@ -600,10 +608,10 @@ impl WeightInfo for () {
 	// Storage: Staking CounterForNominators (r:1 w:1)
 	/// The range of component `n` is `[1, 16]`.
 	fn nominate(n: u32, ) -> Weight {
-		// Minimum execution time: 75_097 nanoseconds.
-		Weight::from_ref_time(74_052_497)
-			// Standard Error: 6_784
-			.saturating_add(Weight::from_ref_time(2_842_146).saturating_mul(n.into()))
+		// Minimum execution time: 73_490 nanoseconds.
+		Weight::from_ref_time(72_520_864)
+			// Standard Error: 7_090
+			.saturating_add(Weight::from_ref_time(2_800_566).saturating_mul(n.into()))
 			.saturating_add(RocksDbWeight::get().reads(12))
 			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(n.into())))
 			.saturating_add(RocksDbWeight::get().writes(6))
@@ -616,58 +624,58 @@ impl WeightInfo for () {
 	// Storage: VoterList ListBags (r:1 w:1)
 	// Storage: VoterList CounterForListNodes (r:1 w:1)
 	fn chill() -> Weight {
-		// Minimum execution time: 67_307 nanoseconds.
-		Weight::from_ref_time(67_838_000)
+		// Minimum execution time: 66_293 nanoseconds.
+		Weight::from_ref_time(66_946_000)
 			.saturating_add(RocksDbWeight::get().reads(8))
 			.saturating_add(RocksDbWeight::get().writes(6))
 	}
 	// Storage: Staking Ledger (r:1 w:0)
 	// Storage: Staking Payee (r:0 w:1)
 	fn set_payee() -> Weight {
-		// Minimum execution time: 18_831 nanoseconds.
-		Weight::from_ref_time(19_047_000)
+		// Minimum execution time: 18_134 nanoseconds.
+		Weight::from_ref_time(18_497_000)
 			.saturating_add(RocksDbWeight::get().reads(1))
 			.saturating_add(RocksDbWeight::get().writes(1))
 	}
 	// Storage: Staking Bonded (r:1 w:1)
 	// Storage: Staking Ledger (r:2 w:2)
 	fn set_controller() -> Weight {
-		// Minimum execution time: 27_534 nanoseconds.
-		Weight::from_ref_time(27_806_000)
+		// Minimum execution time: 26_728 nanoseconds.
+		Weight::from_ref_time(27_154_000)
 			.saturating_add(RocksDbWeight::get().reads(3))
 			.saturating_add(RocksDbWeight::get().writes(3))
 	}
 	// Storage: Staking ValidatorCount (r:0 w:1)
 	fn set_validator_count() -> Weight {
-		// Minimum execution time: 5_211 nanoseconds.
-		Weight::from_ref_time(5_372_000)
+		// Minimum execution time: 4_877 nanoseconds.
+		Weight::from_ref_time(5_028_000)
 			.saturating_add(RocksDbWeight::get().writes(1))
 	}
 	// Storage: Staking ForceEra (r:0 w:1)
 	fn force_no_eras() -> Weight {
-		// Minimum execution time: 5_382 nanoseconds.
-		Weight::from_ref_time(5_654_000)
+		// Minimum execution time: 5_000 nanoseconds.
+		Weight::from_ref_time(5_290_000)
 			.saturating_add(RocksDbWeight::get().writes(1))
 	}
 	// Storage: Staking ForceEra (r:0 w:1)
 	fn force_new_era() -> Weight {
-		// Minimum execution time: 5_618 nanoseconds.
-		Weight::from_ref_time(5_714_000)
+		// Minimum execution time: 5_093 nanoseconds.
+		Weight::from_ref_time(5_378_000)
 			.saturating_add(RocksDbWeight::get().writes(1))
 	}
 	// Storage: Staking ForceEra (r:0 w:1)
 	fn force_new_era_always() -> Weight {
-		// Minimum execution time: 5_589 nanoseconds.
-		Weight::from_ref_time(5_776_000)
+		// Minimum execution time: 5_144 nanoseconds.
+		Weight::from_ref_time(5_454_000)
 			.saturating_add(RocksDbWeight::get().writes(1))
 	}
 	// Storage: Staking Invulnerables (r:0 w:1)
 	/// The range of component `v` is `[0, 1000]`.
 	fn set_invulnerables(v: u32, ) -> Weight {
-		// Minimum execution time: 5_541 nanoseconds.
-		Weight::from_ref_time(6_479_253)
-			// Standard Error: 49
-			.saturating_add(Weight::from_ref_time(10_125).saturating_mul(v.into()))
+		// Minimum execution time: 5_190 nanoseconds.
+		Weight::from_ref_time(5_960_962)
+			// Standard Error: 41
+			.saturating_add(Weight::from_ref_time(10_329).saturating_mul(v.into()))
 			.saturating_add(RocksDbWeight::get().writes(1))
 	}
 	// Storage: Staking Bonded (r:1 w:1)
@@ -685,10 +693,10 @@ impl WeightInfo for () {
 	// Storage: Staking SpanSlash (r:0 w:2)
 	/// The range of component `s` is `[0, 100]`.
 	fn force_unstake(s: u32, ) -> Weight {
-		// Minimum execution time: 81_041 nanoseconds.
-		Weight::from_ref_time(88_526_481)
-			// Standard Error: 11_494
-			.saturating_add(Weight::from_ref_time(1_095_933).saturating_mul(s.into()))
+		// Minimum execution time: 80_516 nanoseconds.
+		Weight::from_ref_time(86_317_884)
+			// Standard Error: 2_212
+			.saturating_add(Weight::from_ref_time(1_103_962).saturating_mul(s.into()))
 			.saturating_add(RocksDbWeight::get().reads(11))
 			.saturating_add(RocksDbWeight::get().writes(12))
 			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(s.into())))
@@ -696,10 +704,10 @@ impl WeightInfo for () {
 	// Storage: Staking UnappliedSlashes (r:1 w:1)
 	/// The range of component `s` is `[1, 1000]`.
 	fn cancel_deferred_slash(s: u32, ) -> Weight {
-		// Minimum execution time: 92_308 nanoseconds.
-		Weight::from_ref_time(900_351_007)
-			// Standard Error: 59_145
-			.saturating_add(Weight::from_ref_time(4_944_988).saturating_mul(s.into()))
+		// Minimum execution time: 91_795 nanoseconds.
+		Weight::from_ref_time(904_524_900)
+			// Standard Error: 59_193
+			.saturating_add(Weight::from_ref_time(4_944_680).saturating_mul(s.into()))
 			.saturating_add(RocksDbWeight::get().reads(1))
 			.saturating_add(RocksDbWeight::get().writes(1))
 	}
@@ -714,10 +722,10 @@ impl WeightInfo for () {
 	// Storage: System Account (r:1 w:1)
 	/// The range of component `n` is `[0, 256]`.
 	fn payout_stakers_dead_controller(n: u32, ) -> Weight {
-		// Minimum execution time: 131_855 nanoseconds.
-		Weight::from_ref_time(197_412_779)
-			// Standard Error: 21_283
-			.saturating_add(Weight::from_ref_time(22_093_758).saturating_mul(n.into()))
+		// Minimum execution time: 127_774 nanoseconds.
+		Weight::from_ref_time(178_857_156)
+			// Standard Error: 15_229
+			.saturating_add(Weight::from_ref_time(22_112_174).saturating_mul(n.into()))
 			.saturating_add(RocksDbWeight::get().reads(9))
 			.saturating_add(RocksDbWeight::get().reads((3_u64).saturating_mul(n.into())))
 			.saturating_add(RocksDbWeight::get().writes(2))
@@ -735,10 +743,10 @@ impl WeightInfo for () {
 	// Storage: Balances Locks (r:1 w:1)
 	/// The range of component `n` is `[0, 256]`.
 	fn payout_stakers_alive_staked(n: u32, ) -> Weight {
-		// Minimum execution time: 163_118 nanoseconds.
-		Weight::from_ref_time(229_356_697)
-			// Standard Error: 30_740
-			.saturating_add(Weight::from_ref_time(31_575_360).saturating_mul(n.into()))
+		// Minimum execution time: 161_910 nanoseconds.
+		Weight::from_ref_time(217_635_072)
+			// Standard Error: 30_726
+			.saturating_add(Weight::from_ref_time(31_244_329).saturating_mul(n.into()))
 			.saturating_add(RocksDbWeight::get().reads(10))
 			.saturating_add(RocksDbWeight::get().reads((5_u64).saturating_mul(n.into())))
 			.saturating_add(RocksDbWeight::get().writes(3))
@@ -752,10 +760,10 @@ impl WeightInfo for () {
 	// Storage: VoterList ListBags (r:2 w:2)
 	/// The range of component `l` is `[1, 32]`.
 	fn rebond(l: u32, ) -> Weight {
-		// Minimum execution time: 94_048 nanoseconds.
-		Weight::from_ref_time(95_784_236)
-			// Standard Error: 2_313
-			.saturating_add(Weight::from_ref_time(52_798).saturating_mul(l.into()))
+		// Minimum execution time: 92_986 nanoseconds.
+		Weight::from_ref_time(94_880_481)
+			// Standard Error: 2_007
+			.saturating_add(Weight::from_ref_time(31_421).saturating_mul(l.into()))
 			.saturating_add(RocksDbWeight::get().reads(9))
 			.saturating_add(RocksDbWeight::get().writes(8))
 	}
@@ -774,10 +782,10 @@ impl WeightInfo for () {
 	// Storage: Staking SpanSlash (r:0 w:1)
 	/// The range of component `s` is `[1, 100]`.
 	fn reap_stash(s: u32, ) -> Weight {
-		// Minimum execution time: 93_342 nanoseconds.
-		Weight::from_ref_time(95_756_184)
-			// Standard Error: 2_067
-			.saturating_add(Weight::from_ref_time(1_090_785).saturating_mul(s.into()))
+		// Minimum execution time: 92_750 nanoseconds.
+		Weight::from_ref_time(95_115_568)
+			// Standard Error: 2_037
+			.saturating_add(Weight::from_ref_time(1_086_488).saturating_mul(s.into()))
 			.saturating_add(RocksDbWeight::get().reads(12))
 			.saturating_add(RocksDbWeight::get().writes(12))
 			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(s.into())))
@@ -801,12 +809,12 @@ impl WeightInfo for () {
 	/// The range of component `v` is `[1, 10]`.
 	/// The range of component `n` is `[0, 100]`.
 	fn new_era(v: u32, n: u32, ) -> Weight {
-		// Minimum execution time: 506_874 nanoseconds.
-		Weight::from_ref_time(507_798_000)
-			// Standard Error: 1_802_261
-			.saturating_add(Weight::from_ref_time(59_874_736).saturating_mul(v.into()))
-			// Standard Error: 179_585
-			.saturating_add(Weight::from_ref_time(13_668_574).saturating_mul(n.into()))
+		// Minimum execution time: 506_543 nanoseconds.
+		Weight::from_ref_time(507_261_000)
+			// Standard Error: 1_766_631
+			.saturating_add(Weight::from_ref_time(59_139_153).saturating_mul(v.into()))
+			// Standard Error: 176_035
+			.saturating_add(Weight::from_ref_time(13_512_781).saturating_mul(n.into()))
 			.saturating_add(RocksDbWeight::get().reads(206))
 			.saturating_add(RocksDbWeight::get().reads((5_u64).saturating_mul(v.into())))
 			.saturating_add(RocksDbWeight::get().reads((4_u64).saturating_mul(n.into())))
@@ -823,12 +831,12 @@ impl WeightInfo for () {
 	/// The range of component `v` is `[500, 1000]`.
 	/// The range of component `n` is `[500, 1000]`.
 	fn get_npos_voters(v: u32, n: u32, ) -> Weight {
-		// Minimum execution time: 24_634_585 nanoseconds.
-		Weight::from_ref_time(24_718_377_000)
-			// Standard Error: 324_839
-			.saturating_add(Weight::from_ref_time(3_654_508).saturating_mul(v.into()))
-			// Standard Error: 324_839
-			.saturating_add(Weight::from_ref_time(2_927_535).saturating_mul(n.into()))
+		// Minimum execution time: 24_155_382 nanoseconds.
+		Weight::from_ref_time(24_252_568_000)
+			// Standard Error: 319_250
+			.saturating_add(Weight::from_ref_time(3_596_056).saturating_mul(v.into()))
+			// Standard Error: 319_250
+			.saturating_add(Weight::from_ref_time(2_852_023).saturating_mul(n.into()))
 			.saturating_add(RocksDbWeight::get().reads(201))
 			.saturating_add(RocksDbWeight::get().reads((5_u64).saturating_mul(v.into())))
 			.saturating_add(RocksDbWeight::get().reads((4_u64).saturating_mul(n.into())))
@@ -837,10 +845,10 @@ impl WeightInfo for () {
 	// Storage: Staking Validators (r:501 w:0)
 	/// The range of component `v` is `[500, 1000]`.
 	fn get_npos_targets(v: u32, ) -> Weight {
-		// Minimum execution time: 4_805_490 nanoseconds.
-		Weight::from_ref_time(118_475_494)
-			// Standard Error: 26_332
-			.saturating_add(Weight::from_ref_time(9_635_188).saturating_mul(v.into()))
+		// Minimum execution time: 4_741_111 nanoseconds.
+		Weight::from_ref_time(113_360_179)
+			// Standard Error: 25_375
+			.saturating_add(Weight::from_ref_time(9_494_142).saturating_mul(v.into()))
 			.saturating_add(RocksDbWeight::get().reads(2))
 			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(v.into())))
 	}
@@ -851,8 +859,8 @@ impl WeightInfo for () {
 	// Storage: Staking MaxNominatorsCount (r:0 w:1)
 	// Storage: Staking MinNominatorBond (r:0 w:1)
 	fn set_staking_configs_all_set() -> Weight {
-		// Minimum execution time: 10_816 nanoseconds.
-		Weight::from_ref_time(11_242_000)
+		// Minimum execution time: 11_074 nanoseconds.
+		Weight::from_ref_time(11_312_000)
 			.saturating_add(RocksDbWeight::get().writes(6))
 	}
 	// Storage: Staking MinCommission (r:0 w:1)
@@ -862,8 +870,8 @@ impl WeightInfo for () {
 	// Storage: Staking MaxNominatorsCount (r:0 w:1)
 	// Storage: Staking MinNominatorBond (r:0 w:1)
 	fn set_staking_configs_all_remove() -> Weight {
-		// Minimum execution time: 9_581 nanoseconds.
-		Weight::from_ref_time(10_383_000)
+		// Minimum execution time: 9_795 nanoseconds.
+		Weight::from_ref_time(10_116_000)
 			.saturating_add(RocksDbWeight::get().writes(6))
 	}
 	// Storage: Staking Ledger (r:1 w:0)
@@ -877,16 +885,16 @@ impl WeightInfo for () {
 	// Storage: VoterList ListBags (r:1 w:1)
 	// Storage: VoterList CounterForListNodes (r:1 w:1)
 	fn chill_other() -> Weight {
-		// Minimum execution time: 83_669 nanoseconds.
-		Weight::from_ref_time(84_772_000)
+		// Minimum execution time: 82_914 nanoseconds.
+		Weight::from_ref_time(83_848_000)
 			.saturating_add(RocksDbWeight::get().reads(11))
 			.saturating_add(RocksDbWeight::get().writes(6))
 	}
 	// Storage: Staking MinCommission (r:1 w:0)
 	// Storage: Staking Validators (r:1 w:1)
 	fn force_apply_min_commission() -> Weight {
-		// Minimum execution time: 20_553 nanoseconds.
-		Weight::from_ref_time(20_933_000)
+		// Minimum execution time: 20_317 nanoseconds.
+		Weight::from_ref_time(20_639_000)
 			.saturating_add(RocksDbWeight::get().reads(2))
 			.saturating_add(RocksDbWeight::get().writes(1))
 	}