Fast Unstake Pallet (#12129)

* add failing test for itamar * an ugly example of fast unstake * Revert "add failing test for itamar" This reverts commit 16c4d8015698a0684c090c54fce8b470a2d2feb2. * fast unstake wip * clean it up a bit * some comments * on_idle logic * fix * comment * new working version, checks all pass, looking good * some notes * add mock boilerplate * more boilerplate * simplify the weight stuff * ExtBuilder for pools * fmt * rm bags-list, simplify setup_works * mock + tests boilerplate * make some benchmarks work * mock boilerplate * tests boilerplate * run_to_block works * add Error enums * add test * note * make UnstakeRequest fields pub * some tests * fix origin * fmt * add fast_unstake_events_since_last_call * text * rewrite some benchmes and fix them -- the outcome is still strange * Fix weights * cleanup * Update frame/election-provider-support/solution-type/src/single_page.rs * fix build * Fix pools tests * iterate teset + mock * test unfinished * cleanup and add some tests * add test successful_multi_queue * comment * rm Head check * add TODO * complete successful_multi_queue * + test early_exit * fix a lot of things above the beautiful atlantic ocean 🌊 * seemingly it is finished now * Fix build * ".git/.scripts/fmt.sh" 1 * Fix slashing amount as well * better docs * abstract types * rm use * import * Update frame/nomination-pools/benchmarking/src/lib.rs Co-authored-by: Nitwit <47109040+nitwit69@users.noreply.github.com> * Update frame/fast-unstake/src/types.rs Co-authored-by: Nitwit <47109040+nitwit69@users.noreply.github.com> * Fix build * fmt * Update frame/fast-unstake/src/lib.rs Co-authored-by: Keith Yeung <kungfukeith11@gmail.com> * make bounded * feedback from code review with Ankan * Update frame/fast-unstake/src/lib.rs Co-authored-by: Roman Useinov <roman.useinov@gmail.com> * Update frame/fast-unstake/src/lib.rs Co-authored-by: Roman Useinov <roman.useinov@gmail.com> * Update frame/fast-unstake/src/lib.rs Co-authored-by: Roman Useinov <roman.useinov@gmail.com> * Update frame/fast-unstake/src/lib.rs Co-authored-by: Roman Useinov <roman.useinov@gmail.com> * Update frame/fast-unstake/src/lib.rs Co-authored-by: Roman Useinov <roman.useinov@gmail.com> * Update frame/fast-unstake/src/lib.rs Co-authored-by: Roman Useinov <roman.useinov@gmail.com> * Update frame/fast-unstake/src/lib.rs Co-authored-by: Roman Useinov <roman.useinov@gmail.com> * Update frame/fast-unstake/src/lib.rs Co-authored-by: Roman Useinov <roman.useinov@gmail.com> * Update frame/fast-unstake/src/lib.rs Co-authored-by: Roman Useinov <roman.useinov@gmail.com> * Update frame/fast-unstake/src/mock.rs * update to master * some final review comments * fmt * fix clippy * remove unused * ".git/.scripts/fmt.sh" 1 * make it all build again * fmt * undo fishy change Co-authored-by: Ross Bulat <ross@jkrbinvestments.com> Co-authored-by: command-bot <> Co-authored-by: Nitwit <47109040+nitwit69@users.noreply.github.com> Co-authored-by: Keith Yeung <kungfukeith11@gmail.com> Co-authored-by: Roman Useinov <roman.useinov@gmail.com>
2026-06-15 18:31:05 +00:00 · 2022-09-23 10:36:33 +01:00
parent 34bfd2ad00
commit b56c0e4cb6
21 changed files with 2650 additions and 29 deletions
@@ -0,0 +1,228 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2022 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Benchmarking for pallet-fast-unstake.
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use crate::{types::*, Pallet as FastUnstake, *};
+use frame_benchmarking::{benchmarks, whitelist_account};
+use frame_support::{
+	assert_ok,
+	traits::{Currency, EnsureOrigin, Get, Hooks},
+};
+use frame_system::RawOrigin;
+use pallet_nomination_pools::{Pallet as Pools, PoolId};
+use pallet_staking::Pallet as Staking;
+use sp_runtime::traits::{StaticLookup, Zero};
+use sp_staking::EraIndex;
+use sp_std::prelude::*;
+
+const USER_SEED: u32 = 0;
+const DEFAULT_BACKER_PER_VALIDATOR: u32 = 128;
+const MAX_VALIDATORS: u32 = 128;
+
+type CurrencyOf<T> = <T as pallet_staking::Config>::Currency;
+
+fn l<T: Config>(
+	who: T::AccountId,
+) -> <<T as frame_system::Config>::Lookup as StaticLookup>::Source {
+	T::Lookup::unlookup(who)
+}
+
+fn create_unexposed_nominator<T: Config>() -> T::AccountId {
+	let account = frame_benchmarking::account::<T::AccountId>("nominator_42", 0, USER_SEED);
+	fund_and_bond_account::<T>(&account);
+	account
+}
+
+fn fund_and_bond_account<T: Config>(account: &T::AccountId) {
+	let stake = CurrencyOf::<T>::minimum_balance() * 100u32.into();
+	CurrencyOf::<T>::make_free_balance_be(&account, stake * 10u32.into());
+
+	let account_lookup = l::<T>(account.clone());
+	// bond and nominate ourselves, this will guarantee that we are not backing anyone.
+	assert_ok!(Staking::<T>::bond(
+		RawOrigin::Signed(account.clone()).into(),
+		account_lookup.clone(),
+		stake,
+		pallet_staking::RewardDestination::Controller,
+	));
+	assert_ok!(Staking::<T>::nominate(
+		RawOrigin::Signed(account.clone()).into(),
+		vec![account_lookup]
+	));
+}
+
+pub(crate) fn fast_unstake_events<T: Config>() -> Vec<crate::Event<T>> {
+	frame_system::Pallet::<T>::events()
+		.into_iter()
+		.map(|r| r.event)
+		.filter_map(|e| <T as Config>::RuntimeEvent::from(e).try_into().ok())
+		.collect::<Vec<_>>()
+}
+
+fn setup_pool<T: Config>() -> PoolId {
+	let depositor = frame_benchmarking::account::<T::AccountId>("depositor_42", 0, USER_SEED);
+	let depositor_lookup = l::<T>(depositor.clone());
+
+	let stake = Pools::<T>::depositor_min_bond();
+	CurrencyOf::<T>::make_free_balance_be(&depositor, stake * 10u32.into());
+
+	Pools::<T>::create(
+		RawOrigin::Signed(depositor.clone()).into(),
+		stake,
+		depositor_lookup.clone(),
+		depositor_lookup.clone(),
+		depositor_lookup,
+	)
+	.unwrap();
+
+	pallet_nomination_pools::LastPoolId::<T>::get()
+}
+
+fn setup_staking<T: Config>(v: u32, until: EraIndex) {
+	let ed = CurrencyOf::<T>::minimum_balance();
+
+	log!(debug, "registering {} validators and {} eras.", v, until);
+
+	// our validators don't actually need to registered in staking -- just generate `v` random
+	// accounts.
+	let validators = (0..v)
+		.map(|x| frame_benchmarking::account::<T::AccountId>("validator", x, USER_SEED))
+		.collect::<Vec<_>>();
+
+	for era in 0..=until {
+		let others = (0..DEFAULT_BACKER_PER_VALIDATOR)
+			.map(|s| {
+				let who = frame_benchmarking::account::<T::AccountId>("nominator", era, s);
+				let value = ed;
+				pallet_staking::IndividualExposure { who, value }
+			})
+			.collect::<Vec<_>>();
+		let exposure =
+			pallet_staking::Exposure { total: Default::default(), own: Default::default(), others };
+		validators.iter().for_each(|v| {
+			Staking::<T>::add_era_stakers(era, v.clone(), exposure.clone());
+		});
+	}
+}
+
+fn on_idle_full_block<T: Config>() {
+	let remaining_weight = <T as frame_system::Config>::BlockWeights::get().max_block;
+	FastUnstake::<T>::on_idle(Zero::zero(), remaining_weight);
+}
+
+benchmarks! {
+	// on_idle, we we don't check anyone, but fully unbond and move them to another pool.
+	on_idle_unstake {
+		let who = create_unexposed_nominator::<T>();
+		let pool_id = setup_pool::<T>();
+		assert_ok!(FastUnstake::<T>::register_fast_unstake(
+			RawOrigin::Signed(who.clone()).into(),
+			Some(pool_id)
+		));
+		ErasToCheckPerBlock::<T>::put(1);
+
+		// run on_idle once. This will check era 0.
+		assert_eq!(Head::<T>::get(), None);
+		on_idle_full_block::<T>();
+		assert_eq!(
+			Head::<T>::get(),
+			Some(UnstakeRequest { stash: who.clone(), checked: vec![0].try_into().unwrap(), maybe_pool_id: Some(pool_id) })
+		);
+	}
+	: {
+		on_idle_full_block::<T>();
+	}
+	verify {
+		assert!(matches!(
+			fast_unstake_events::<T>().last(),
+			Some(Event::Unstaked { .. })
+		));
+	}
+
+	// on_idle, when we check some number of eras,
+	on_idle_check {
+		// number of eras multiplied by validators in that era.
+		let x in (<T as pallet_staking::Config>::BondingDuration::get() * 1) .. (<T as pallet_staking::Config>::BondingDuration::get() * MAX_VALIDATORS);
+
+		let v = x / <T as pallet_staking::Config>::BondingDuration::get();
+		let u = <T as pallet_staking::Config>::BondingDuration::get();
+
+		ErasToCheckPerBlock::<T>::put(u);
+		pallet_staking::CurrentEra::<T>::put(u);
+
+		// setup staking with v validators and u eras of data (0..=u)
+		setup_staking::<T>(v, u);
+		let who = create_unexposed_nominator::<T>();
+		assert_ok!(FastUnstake::<T>::register_fast_unstake(
+			RawOrigin::Signed(who.clone()).into(),
+			None,
+		));
+
+		// no one is queued thus far.
+		assert_eq!(Head::<T>::get(), None);
+	}
+	: {
+		on_idle_full_block::<T>();
+	}
+	verify {
+		let checked: frame_support::BoundedVec<_, _> = (1..=u).rev().collect::<Vec<EraIndex>>().try_into().unwrap();
+		assert_eq!(
+			Head::<T>::get(),
+			Some(UnstakeRequest { stash: who.clone(), checked, maybe_pool_id: None })
+		);
+		assert!(matches!(
+			fast_unstake_events::<T>().last(),
+			Some(Event::Checking { .. })
+		));
+	}
+
+	register_fast_unstake {
+		let who = create_unexposed_nominator::<T>();
+		whitelist_account!(who);
+		assert_eq!(Queue::<T>::count(), 0);
+
+	}
+	:_(RawOrigin::Signed(who.clone()), None)
+	verify {
+		assert_eq!(Queue::<T>::count(), 1);
+	}
+
+	deregister {
+		let who = create_unexposed_nominator::<T>();
+		assert_ok!(FastUnstake::<T>::register_fast_unstake(
+			RawOrigin::Signed(who.clone()).into(),
+			None
+		));
+		assert_eq!(Queue::<T>::count(), 1);
+		whitelist_account!(who);
+	}
+	:_(RawOrigin::Signed(who.clone()))
+	verify {
+		assert_eq!(Queue::<T>::count(), 0);
+	}
+
+	control {
+		let origin = <T as Config>::ControlOrigin::successful_origin();
+	}
+	: _<T::RuntimeOrigin>(origin, 128)
+	verify {}
+
+	impl_benchmark_test_suite!(Pallet, crate::mock::ExtBuilder::default().build(), crate::mock::Runtime)
+}
@@ -0,0 +1,505 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2022 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! A pallet that's designed to JUST do the following:
+//!
+//! If a nominator is not exposed in any `ErasStakers` (i.e. "has not actively backed any
+//! validators in the last `BondingDuration` days"), then they can register themselves in this
+//! pallet, unstake faster than having to wait an entire bonding duration, and potentially move
+//! into a nomination pool.
+//!
+//! Appearing in the exposure of a validator means being exposed equal to that validator from the
+//! point of view of the staking system. This usually means earning rewards with the validator, and
+//! also being at the risk of slashing with the validator. This is equivalent to the "Active
+//! Nominator" role explained in the
+//! [February Staking Update](https://polkadot.network/blog/staking-update-february-2022/).
+//!
+//! This pallet works off the basis of `on_idle`, meaning that it provides no guarantee about when
+//! it will succeed, if at all. Moreover, the queue implementation is unordered. In case of
+//! congestion, no FIFO ordering is provided.
+//!
+//! Stakers who are certain about NOT being exposed can register themselves with
+//! [`Call::register_fast_unstake`]. This will chill, and fully unbond the staker, and place them in
+//! the queue to be checked.
+//!
+//! Once queued, but not being actively processed, stakers can withdraw their request via
+//! [`Call::deregister`].
+//!
+//! Once queued, a staker wishing to unbond can perform no further action in pallet-staking. This is
+//! to prevent them from accidentally exposing themselves behind a validator etc.
+//!
+//! Once processed, if successful, no additional fee for the checking process is taken, and the
+//! staker is instantly unbonded. Optionally, if they have asked to join a pool, their *entire*
+//! stake is joined into their pool of choice.
+//!
+//! If unsuccessful, meaning that the staker was exposed sometime in the last `BondingDuration` eras
+//! they will end up being slashed for the amount of wasted work they have inflicted on the chian.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+pub use pallet::*;
+
+#[cfg(test)]
+mod mock;
+
+#[cfg(test)]
+mod tests;
+
+// NOTE: enable benchmarking in tests as well.
+#[cfg(feature = "runtime-benchmarks")]
+mod benchmarking;
+mod types;
+pub mod weights;
+
+pub const LOG_TARGET: &'static str = "runtime::fast-unstake";
+
+// syntactic sugar for logging.
+#[macro_export]
+macro_rules! log {
+	($level:tt, $patter:expr $(, $values:expr)* $(,)?) => {
+		log::$level!(
+			target: crate::LOG_TARGET,
+			concat!("[{:?}] 💨 ", $patter), <frame_system::Pallet<T>>::block_number() $(, $values)*
+		)
+	};
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use crate::types::*;
+	use frame_election_provider_support::ElectionProvider;
+	use frame_support::pallet_prelude::*;
+	use frame_system::{pallet_prelude::*, RawOrigin};
+	use pallet_nomination_pools::PoolId;
+	use pallet_staking::Pallet as Staking;
+	use sp_runtime::{
+		traits::{Saturating, Zero},
+		DispatchResult,
+	};
+	use sp_staking::EraIndex;
+	use sp_std::{prelude::*, vec::Vec};
+	use weights::WeightInfo;
+
+	#[derive(scale_info::TypeInfo, codec::Encode, codec::Decode, codec::MaxEncodedLen)]
+	#[codec(mel_bound(T: Config))]
+	#[scale_info(skip_type_params(T))]
+	pub struct MaxChecking<T: Config>(sp_std::marker::PhantomData<T>);
+	impl<T: Config> frame_support::traits::Get<u32> for MaxChecking<T> {
+		fn get() -> u32 {
+			<T as pallet_staking::Config>::BondingDuration::get() + 1
+		}
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	pub trait Config:
+		frame_system::Config
+		+ pallet_staking::Config<
+			CurrencyBalance = <Self as pallet_nomination_pools::Config>::CurrencyBalance,
+		> + pallet_nomination_pools::Config
+	{
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self>>
+			+ IsType<<Self as frame_system::Config>::RuntimeEvent>
+			+ TryInto<Event<Self>>;
+
+		/// The amount of balance slashed per each era that was wastefully checked.
+		///
+		/// A reasonable value could be `runtime_weight_to_fee(weight_per_era_check)`.
+		type SlashPerEra: Get<BalanceOf<Self>>;
+
+		/// The origin that can control this pallet.
+		type ControlOrigin: frame_support::traits::EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// The weight information of this pallet.
+		type WeightInfo: WeightInfo;
+	}
+
+	/// The current "head of the queue" being unstaked.
+	#[pallet::storage]
+	pub type Head<T: Config> =
+		StorageValue<_, UnstakeRequest<T::AccountId, MaxChecking<T>>, OptionQuery>;
+
+	/// The map of all accounts wishing to be unstaked.
+	///
+	/// Points the `AccountId` wishing to unstake to the optional `PoolId` they wish to join
+	/// thereafter.
+	#[pallet::storage]
+	pub type Queue<T: Config> = CountedStorageMap<_, Twox64Concat, T::AccountId, Option<PoolId>>;
+
+	/// Number of eras to check per block.
+	///
+	/// If set to 0, this pallet does absolutely nothing.
+	///
+	/// Based on the amount of weight available at `on_idle`, up to this many eras of a single
+	/// nominator might be checked.
+	#[pallet::storage]
+	pub type ErasToCheckPerBlock<T: Config> = StorageValue<_, u32, ValueQuery>;
+
+	/// The events of this pallet.
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// A staker was unstaked.
+		Unstaked { stash: T::AccountId, maybe_pool_id: Option<PoolId>, result: DispatchResult },
+		/// A staker was slashed for requesting fast-unstake whilst being exposed.
+		Slashed { stash: T::AccountId, amount: BalanceOf<T> },
+		/// A staker was partially checked for the given eras, but the process did not finish.
+		Checking { stash: T::AccountId, eras: Vec<EraIndex> },
+		/// Some internal error happened while migrating stash. They are removed as head as a
+		/// consequence.
+		Errored { stash: T::AccountId },
+		/// An internal error happened. Operations will be paused now.
+		InternalError,
+	}
+
+	#[pallet::error]
+	#[cfg_attr(test, derive(PartialEq))]
+	pub enum Error<T> {
+		/// The provided Controller account was not found.
+		///
+		/// This means that the given account is not bonded.
+		NotController,
+		/// The bonded account has already been queued.
+		AlreadyQueued,
+		/// The bonded account has active unlocking chunks.
+		NotFullyBonded,
+		/// The provided un-staker is not in the `Queue`.
+		NotQueued,
+		/// The provided un-staker is already in Head, and cannot deregister.
+		AlreadyHead,
+	}
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<T::BlockNumber> for Pallet<T> {
+		fn on_idle(_: T::BlockNumber, remaining_weight: Weight) -> Weight {
+			if remaining_weight.any_lt(T::DbWeight::get().reads(2)) {
+				return Weight::from_ref_time(0)
+			}
+
+			Self::do_on_idle(remaining_weight)
+		}
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Register oneself for fast-unstake.
+		///
+		/// The dispatch origin of this call must be signed by the controller account, similar to
+		/// `staking::unbond`.
+		///
+		/// The stash associated with the origin must have no ongoing unlocking chunks. If
+		/// successful, this will fully unbond and chill the stash. Then, it will enqueue the stash
+		/// to be checked in further blocks.
+		///
+		/// If by the time this is called, the stash is actually eligible for fast-unstake, then
+		/// they are guaranteed to remain eligible, because the call will chill them as well.
+		///
+		/// If the check works, the entire staking data is removed, i.e. the stash is fully
+		/// unstaked, and they potentially join a pool with their entire bonded stake.
+		///
+		/// If the check fails, the stash remains chilled and waiting for being unbonded as in with
+		/// the normal staking system, but they lose part of their unbonding chunks due to consuming
+		/// the chain's resources.
+		#[pallet::weight(<T as Config>::WeightInfo::register_fast_unstake())]
+		pub fn register_fast_unstake(
+			origin: OriginFor<T>,
+			maybe_pool_id: Option<PoolId>,
+		) -> DispatchResult {
+			let ctrl = ensure_signed(origin)?;
+
+			let ledger =
+				pallet_staking::Ledger::<T>::get(&ctrl).ok_or(Error::<T>::NotController)?;
+			ensure!(!Queue::<T>::contains_key(&ledger.stash), Error::<T>::AlreadyQueued);
+			ensure!(
+				Head::<T>::get().map_or(true, |UnstakeRequest { stash, .. }| stash != ledger.stash),
+				Error::<T>::AlreadyHead
+			);
+			// second part of the && is defensive.
+			ensure!(
+				ledger.active == ledger.total && ledger.unlocking.is_empty(),
+				Error::<T>::NotFullyBonded
+			);
+
+			// chill and fully unstake.
+			Staking::<T>::chill(RawOrigin::Signed(ctrl.clone()).into())?;
+			Staking::<T>::unbond(RawOrigin::Signed(ctrl).into(), ledger.total)?;
+
+			// enqueue them.
+			Queue::<T>::insert(ledger.stash, maybe_pool_id);
+			Ok(())
+		}
+
+		/// Deregister oneself from the fast-unstake (also cancels joining the pool if that was
+		/// supplied on `register_fast_unstake` .
+		///
+		/// This is useful if one is registered, they are still waiting, and they change their mind.
+		///
+		/// Note that the associated stash is still fully unbonded and chilled as a consequence of
+		/// calling `register_fast_unstake`. This should probably be followed by a call to
+		/// `Staking::rebond`.
+		#[pallet::weight(<T as Config>::WeightInfo::deregister())]
+		pub fn deregister(origin: OriginFor<T>) -> DispatchResult {
+			let ctrl = ensure_signed(origin)?;
+			let stash = pallet_staking::Ledger::<T>::get(&ctrl)
+				.map(|l| l.stash)
+				.ok_or(Error::<T>::NotController)?;
+			ensure!(Queue::<T>::contains_key(&stash), Error::<T>::NotQueued);
+			ensure!(
+				Head::<T>::get().map_or(true, |UnstakeRequest { stash, .. }| stash != stash),
+				Error::<T>::AlreadyHead
+			);
+			Queue::<T>::remove(stash);
+			Ok(())
+		}
+
+		/// Control the operation of this pallet.
+		///
+		/// Dispatch origin must be signed by the [`Config::ControlOrigin`].
+		#[pallet::weight(<T as Config>::WeightInfo::control())]
+		pub fn control(origin: OriginFor<T>, unchecked_eras_to_check: EraIndex) -> DispatchResult {
+			let _ = T::ControlOrigin::ensure_origin(origin)?;
+			ErasToCheckPerBlock::<T>::put(unchecked_eras_to_check);
+			Ok(())
+		}
+	}
+
+	impl<T: Config> Pallet<T> {
+		/// process up to `remaining_weight`.
+		///
+		/// Returns the actual weight consumed.
+		///
+		/// Written for readability in mind, not efficiency. For example:
+		///
+		/// 1. We assume this is only ever called once per `on_idle`. This is because we know that
+		/// in all use cases, even a single nominator cannot be unbonded in a single call. Multiple
+		/// calls to this function are thus not needed.
+		///
+		/// 2. We will only mark a staker as unstaked if at the beginning of a check cycle, they are
+		/// found out to have no eras to check. At the end of a check cycle, even if they are fully
+		/// checked, we don't finish the process.
+		pub(crate) fn do_on_idle(remaining_weight: Weight) -> Weight {
+			let mut eras_to_check_per_block = ErasToCheckPerBlock::<T>::get();
+			if eras_to_check_per_block.is_zero() {
+				return T::DbWeight::get().reads(1)
+			}
+
+			// NOTE: here we're assuming that the number of validators has only ever increased,
+			// meaning that the number of exposures to check is either this per era, or less.
+			let validator_count = pallet_staking::ValidatorCount::<T>::get();
+
+			// determine the number of eras to check. This is based on both `ErasToCheckPerBlock`
+			// and `remaining_weight` passed on to us from the runtime executive.
+			let max_weight = |v, u| {
+				<T as Config>::WeightInfo::on_idle_check(v * u)
+					.max(<T as Config>::WeightInfo::on_idle_unstake())
+			};
+			while max_weight(validator_count, eras_to_check_per_block).any_gt(remaining_weight) {
+				eras_to_check_per_block.saturating_dec();
+				if eras_to_check_per_block.is_zero() {
+					log!(debug, "early existing because eras_to_check_per_block is zero");
+					return T::DbWeight::get().reads(2)
+				}
+			}
+
+			if <T as pallet_staking::Config>::ElectionProvider::ongoing() {
+				// NOTE: we assume `ongoing` does not consume any weight.
+				// there is an ongoing election -- we better not do anything. Imagine someone is not
+				// exposed anywhere in the last era, and the snapshot for the election is already
+				// taken. In this time period, we don't want to accidentally unstake them.
+				return T::DbWeight::get().reads(2)
+			}
+
+			let UnstakeRequest { stash, mut checked, maybe_pool_id } = match Head::<T>::take()
+				.or_else(|| {
+					// NOTE: there is no order guarantees in `Queue`.
+					Queue::<T>::drain()
+						.map(|(stash, maybe_pool_id)| UnstakeRequest {
+							stash,
+							maybe_pool_id,
+							checked: Default::default(),
+						})
+						.next()
+				}) {
+				None => {
+					// There's no `Head` and nothing in the `Queue`, nothing to do here.
+					return T::DbWeight::get().reads(4)
+				},
+				Some(head) => head,
+			};
+
+			log!(
+				debug,
+				"checking {:?}, eras_to_check_per_block = {:?}, remaining_weight = {:?}",
+				stash,
+				eras_to_check_per_block,
+				remaining_weight
+			);
+
+			// the range that we're allowed to check in this round.
+			let current_era = pallet_staking::CurrentEra::<T>::get().unwrap_or_default();
+			let bonding_duration = <T as pallet_staking::Config>::BondingDuration::get();
+			// prune all the old eras that we don't care about. This will help us keep the bound
+			// of `checked`.
+			checked.retain(|e| *e >= current_era.saturating_sub(bonding_duration));
+			let unchecked_eras_to_check = {
+				// get the last available `bonding_duration` eras up to current era in reverse
+				// order.
+				let total_check_range = (current_era.saturating_sub(bonding_duration)..=
+					current_era)
+					.rev()
+					.collect::<Vec<_>>();
+				debug_assert!(
+					total_check_range.len() <= (bonding_duration + 1) as usize,
+					"{:?}",
+					total_check_range
+				);
+
+				// remove eras that have already been checked, take a maximum of
+				// eras_to_check_per_block.
+				total_check_range
+					.into_iter()
+					.filter(|e| !checked.contains(e))
+					.take(eras_to_check_per_block as usize)
+					.collect::<Vec<_>>()
+			};
+
+			log!(
+				debug,
+				"{} eras to check: {:?}",
+				unchecked_eras_to_check.len(),
+				unchecked_eras_to_check
+			);
+
+			if unchecked_eras_to_check.is_empty() {
+				// `stash` is not exposed in any era now -- we can let go of them now.
+				let num_slashing_spans = Staking::<T>::slashing_spans(&stash).iter().count() as u32;
+
+				let ctrl = match pallet_staking::Bonded::<T>::get(&stash) {
+					Some(ctrl) => ctrl,
+					None => {
+						Self::deposit_event(Event::<T>::Errored { stash });
+						return <T as Config>::WeightInfo::on_idle_unstake()
+					},
+				};
+
+				let ledger = match pallet_staking::Ledger::<T>::get(ctrl) {
+					Some(ledger) => ledger,
+					None => {
+						Self::deposit_event(Event::<T>::Errored { stash });
+						return <T as Config>::WeightInfo::on_idle_unstake()
+					},
+				};
+
+				let unstake_result = pallet_staking::Pallet::<T>::force_unstake(
+					RawOrigin::Root.into(),
+					stash.clone(),
+					num_slashing_spans,
+				);
+
+				let pool_stake_result = if let Some(pool_id) = maybe_pool_id {
+					pallet_nomination_pools::Pallet::<T>::join(
+						RawOrigin::Signed(stash.clone()).into(),
+						ledger.total,
+						pool_id,
+					)
+				} else {
+					Ok(())
+				};
+
+				let result = unstake_result.and(pool_stake_result);
+				log!(
+					info,
+					"unstaked {:?}, maybe_pool {:?}, outcome: {:?}",
+					stash,
+					maybe_pool_id,
+					result
+				);
+
+				Self::deposit_event(Event::<T>::Unstaked { stash, maybe_pool_id, result });
+				<T as Config>::WeightInfo::on_idle_unstake()
+			} else {
+				// eras remaining to be checked.
+				let mut eras_checked = 0u32;
+				let is_exposed = unchecked_eras_to_check.iter().any(|e| {
+					eras_checked.saturating_inc();
+					Self::is_exposed_in_era(&stash, e)
+				});
+
+				log!(
+					debug,
+					"checked {:?} eras, exposed? {}, (v: {:?}, u: {:?})",
+					eras_checked,
+					is_exposed,
+					validator_count,
+					unchecked_eras_to_check.len()
+				);
+
+				// NOTE: you can be extremely unlucky and get slashed here: You are not exposed in
+				// the last 28 eras, have registered yourself to be unstaked, midway being checked,
+				// you are exposed.
+				if is_exposed {
+					let amount = T::SlashPerEra::get()
+						.saturating_mul(eras_checked.saturating_add(checked.len() as u32).into());
+					pallet_staking::slashing::do_slash::<T>(
+						&stash,
+						amount,
+						&mut Default::default(),
+						&mut Default::default(),
+						current_era,
+					);
+					log!(info, "slashed {:?} by {:?}", stash, amount);
+					Self::deposit_event(Event::<T>::Slashed { stash, amount });
+				} else {
+					// Not exposed in these eras.
+					match checked.try_extend(unchecked_eras_to_check.clone().into_iter()) {
+						Ok(_) => {
+							Head::<T>::put(UnstakeRequest {
+								stash: stash.clone(),
+								checked,
+								maybe_pool_id,
+							});
+							Self::deposit_event(Event::<T>::Checking {
+								stash,
+								eras: unchecked_eras_to_check,
+							});
+						},
+						Err(_) => {
+							// don't put the head back in -- there is an internal error in the
+							// pallet.
+							frame_support::defensive!("`checked is pruned via retain above`");
+							ErasToCheckPerBlock::<T>::put(0);
+							Self::deposit_event(Event::<T>::InternalError);
+						},
+					}
+				}
+
+				<T as Config>::WeightInfo::on_idle_check(validator_count * eras_checked)
+			}
+		}
+
+		/// Checks whether an account `staker` has been exposed in an era.
+		fn is_exposed_in_era(staker: &T::AccountId, era: &EraIndex) -> bool {
+			pallet_staking::ErasStakers::<T>::iter_prefix(era).any(|(validator, exposures)| {
+				validator == *staker || exposures.others.iter().any(|i| i.who == *staker)
+			})
+		}
+	}
+}
@@ -0,0 +1,387 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2022 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use crate::{self as fast_unstake};
+use frame_support::{
+	assert_ok,
+	pallet_prelude::*,
+	parameter_types,
+	traits::{ConstU64, ConstU8, Currency},
+	weights::constants::WEIGHT_PER_SECOND,
+	PalletId,
+};
+use sp_runtime::{
+	traits::{Convert, IdentityLookup},
+	FixedU128,
+};
+
+use frame_system::RawOrigin;
+use pallet_staking::{Exposure, IndividualExposure, StakerStatus};
+use sp_std::prelude::*;
+
+pub type AccountId = u128;
+pub type AccountIndex = u32;
+pub type BlockNumber = u64;
+pub type Balance = u128;
+pub type T = Runtime;
+
+parameter_types! {
+	pub BlockWeights: frame_system::limits::BlockWeights =
+		frame_system::limits::BlockWeights::simple_max(2u64 * WEIGHT_PER_SECOND);
+}
+
+impl frame_system::Config for Runtime {
+	type BaseCallFilter = frame_support::traits::Everything;
+	type BlockWeights = BlockWeights;
+	type BlockLength = ();
+	type DbWeight = ();
+	type RuntimeOrigin = RuntimeOrigin;
+	type Index = AccountIndex;
+	type BlockNumber = BlockNumber;
+	type RuntimeCall = RuntimeCall;
+	type Hash = sp_core::H256;
+	type Hashing = sp_runtime::traits::BlakeTwo256;
+	type AccountId = AccountId;
+	type Lookup = IdentityLookup<Self::AccountId>;
+	type Header = sp_runtime::testing::Header;
+	type RuntimeEvent = RuntimeEvent;
+	type BlockHashCount = ();
+	type Version = ();
+	type PalletInfo = PalletInfo;
+	type AccountData = pallet_balances::AccountData<Balance>;
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type SystemWeightInfo = ();
+	type SS58Prefix = ();
+	type OnSetCode = ();
+	type MaxConsumers = frame_support::traits::ConstU32<16>;
+}
+
+impl pallet_timestamp::Config for Runtime {
+	type Moment = u64;
+	type OnTimestampSet = ();
+	type MinimumPeriod = ConstU64<5>;
+	type WeightInfo = ();
+}
+
+parameter_types! {
+	pub static ExistentialDeposit: Balance = 1;
+}
+
+impl pallet_balances::Config for Runtime {
+	type MaxLocks = ConstU32<128>;
+	type MaxReserves = ();
+	type ReserveIdentifier = [u8; 8];
+	type Balance = Balance;
+	type RuntimeEvent = RuntimeEvent;
+	type DustRemoval = ();
+	type ExistentialDeposit = ExistentialDeposit;
+	type AccountStore = System;
+	type WeightInfo = ();
+}
+
+pallet_staking_reward_curve::build! {
+	const I_NPOS: sp_runtime::curve::PiecewiseLinear<'static> = curve!(
+		min_inflation: 0_025_000,
+		max_inflation: 0_100_000,
+		ideal_stake: 0_500_000,
+		falloff: 0_050_000,
+		max_piece_count: 40,
+		test_precision: 0_005_000,
+	);
+}
+
+parameter_types! {
+	pub const RewardCurve: &'static sp_runtime::curve::PiecewiseLinear<'static> = &I_NPOS;
+	pub static BondingDuration: u32 = 3;
+	pub static CurrentEra: u32 = 0;
+	pub static Ongoing: bool = false;
+}
+
+pub struct MockElection;
+impl frame_election_provider_support::ElectionProvider for MockElection {
+	type AccountId = AccountId;
+	type BlockNumber = BlockNumber;
+	type DataProvider = Staking;
+	type Error = ();
+
+	fn ongoing() -> bool {
+		Ongoing::get()
+	}
+
+	fn elect() -> Result<frame_election_provider_support::Supports<AccountId>, Self::Error> {
+		Err(())
+	}
+}
+
+impl pallet_staking::Config for Runtime {
+	type MaxNominations = ConstU32<16>;
+	type Currency = Balances;
+	type CurrencyBalance = Balance;
+	type UnixTime = pallet_timestamp::Pallet<Self>;
+	type CurrencyToVote = frame_support::traits::SaturatingCurrencyToVote;
+	type RewardRemainder = ();
+	type RuntimeEvent = RuntimeEvent;
+	type Slash = ();
+	type Reward = ();
+	type SessionsPerEra = ();
+	type SlashDeferDuration = ();
+	type SlashCancelOrigin = frame_system::EnsureRoot<Self::AccountId>;
+	type BondingDuration = BondingDuration;
+	type SessionInterface = ();
+	type EraPayout = pallet_staking::ConvertCurve<RewardCurve>;
+	type NextNewSession = ();
+	type HistoryDepth = ConstU32<84>;
+	type MaxNominatorRewardedPerValidator = ConstU32<64>;
+	type OffendingValidatorsThreshold = ();
+	type ElectionProvider = MockElection;
+	type GenesisElectionProvider = Self::ElectionProvider;
+	type VoterList = pallet_staking::UseNominatorsAndValidatorsMap<Self>;
+	type TargetList = pallet_staking::UseValidatorsMap<Self>;
+	type MaxUnlockingChunks = ConstU32<32>;
+	type OnStakerSlash = Pools;
+	type BenchmarkingConfig = pallet_staking::TestBenchmarkingConfig;
+	type WeightInfo = ();
+}
+
+pub struct BalanceToU256;
+impl Convert<Balance, sp_core::U256> for BalanceToU256 {
+	fn convert(n: Balance) -> sp_core::U256 {
+		n.into()
+	}
+}
+
+pub struct U256ToBalance;
+impl Convert<sp_core::U256, Balance> for U256ToBalance {
+	fn convert(n: sp_core::U256) -> Balance {
+		n.try_into().unwrap()
+	}
+}
+
+parameter_types! {
+	pub const PostUnbondingPoolsWindow: u32 = 10;
+	pub const PoolsPalletId: PalletId = PalletId(*b"py/nopls");
+	pub static MaxMetadataLen: u32 = 10;
+	pub static CheckLevel: u8 = 255;
+}
+
+impl pallet_nomination_pools::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type WeightInfo = ();
+	type Currency = Balances;
+	type CurrencyBalance = Balance;
+	type RewardCounter = FixedU128;
+	type BalanceToU256 = BalanceToU256;
+	type U256ToBalance = U256ToBalance;
+	type StakingInterface = Staking;
+	type PostUnbondingPoolsWindow = PostUnbondingPoolsWindow;
+	type MaxMetadataLen = MaxMetadataLen;
+	type MaxUnbonding = ConstU32<8>;
+	type MaxPointsToBalance = ConstU8<10>;
+	type PalletId = PoolsPalletId;
+}
+
+parameter_types! {
+	pub static SlashPerEra: u32 = 100;
+}
+
+impl fast_unstake::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type SlashPerEra = SlashPerEra;
+	type ControlOrigin = frame_system::EnsureRoot<Self::AccountId>;
+	type WeightInfo = ();
+}
+
+type Block = frame_system::mocking::MockBlock<Runtime>;
+type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic<Runtime>;
+frame_support::construct_runtime!(
+	pub enum Runtime where
+		Block = Block,
+		NodeBlock = Block,
+		UncheckedExtrinsic = UncheckedExtrinsic
+	{
+		System: frame_system,
+		Timestamp: pallet_timestamp,
+		Balances: pallet_balances,
+		Staking: pallet_staking,
+		Pools: pallet_nomination_pools,
+		FastUnstake: fast_unstake,
+	}
+);
+
+parameter_types! {
+	static FastUnstakeEvents: u32 = 0;
+}
+
+pub(crate) fn fast_unstake_events_since_last_call() -> Vec<super::Event<Runtime>> {
+	let events = System::events()
+		.into_iter()
+		.map(|r| r.event)
+		.filter_map(|e| if let RuntimeEvent::FastUnstake(inner) = e { Some(inner) } else { None })
+		.collect::<Vec<_>>();
+	let already_seen = FastUnstakeEvents::get();
+	FastUnstakeEvents::set(events.len() as u32);
+	events.into_iter().skip(already_seen as usize).collect()
+}
+
+pub struct ExtBuilder {
+	exposed_nominators: Vec<(AccountId, AccountId, Balance)>,
+}
+
+impl Default for ExtBuilder {
+	fn default() -> Self {
+		Self {
+			exposed_nominators: vec![
+				(1, 2, 100),
+				(3, 4, 100),
+				(5, 6, 100),
+				(7, 8, 100),
+				(9, 10, 100),
+			],
+		}
+	}
+}
+
+pub(crate) const VALIDATORS_PER_ERA: AccountId = 32;
+pub(crate) const VALIDATOR_PREFIX: AccountId = 100;
+pub(crate) const NOMINATORS_PER_VALIDATOR_PER_ERA: AccountId = 4;
+pub(crate) const NOMINATOR_PREFIX: AccountId = 1000;
+
+impl ExtBuilder {
+	pub(crate) fn register_stakers_for_era(era: u32) {
+		// validators are prefixed with 100 and nominators with 1000 to prevent conflict. Make sure
+		// all the other accounts used in tests are below 100. Also ensure here that we don't
+		// overlap.
+		assert!(VALIDATOR_PREFIX + VALIDATORS_PER_ERA < NOMINATOR_PREFIX);
+
+		(VALIDATOR_PREFIX..VALIDATOR_PREFIX + VALIDATORS_PER_ERA)
+			.map(|v| {
+				// for the sake of sanity, let's register this taker as an actual validator.
+				let others = (NOMINATOR_PREFIX..
+					(NOMINATOR_PREFIX + NOMINATORS_PER_VALIDATOR_PER_ERA))
+					.map(|n| IndividualExposure { who: n, value: 0 as Balance })
+					.collect::<Vec<_>>();
+				(v, Exposure { total: 0, own: 0, others })
+			})
+			.for_each(|(validator, exposure)| {
+				pallet_staking::ErasStakers::<T>::insert(era, validator, exposure);
+			});
+	}
+
+	pub(crate) fn build(self) -> sp_io::TestExternalities {
+		sp_tracing::try_init_simple();
+		let mut storage =
+			frame_system::GenesisConfig::default().build_storage::<Runtime>().unwrap();
+
+		// create one default pool.
+		let _ = pallet_nomination_pools::GenesisConfig::<Runtime> { ..Default::default() }
+			.assimilate_storage(&mut storage);
+
+		let validators_range = VALIDATOR_PREFIX..VALIDATOR_PREFIX + VALIDATORS_PER_ERA;
+		let nominators_range =
+			NOMINATOR_PREFIX..NOMINATOR_PREFIX + NOMINATORS_PER_VALIDATOR_PER_ERA;
+
+		let _ = pallet_balances::GenesisConfig::<Runtime> {
+			balances: self
+				.exposed_nominators
+				.clone()
+				.into_iter()
+				.map(|(stash, _, balance)| (stash, balance * 2))
+				.chain(
+					self.exposed_nominators
+						.clone()
+						.into_iter()
+						.map(|(_, ctrl, balance)| (ctrl, balance * 2)),
+				)
+				.chain(validators_range.clone().map(|x| (x, 100)))
+				.chain(nominators_range.clone().map(|x| (x, 100)))
+				.collect::<Vec<_>>(),
+		}
+		.assimilate_storage(&mut storage);
+
+		let _ = pallet_staking::GenesisConfig::<Runtime> {
+			stakers: self
+				.exposed_nominators
+				.into_iter()
+				.map(|(x, y, z)| (x, y, z, pallet_staking::StakerStatus::Nominator(vec![42])))
+				.chain(validators_range.map(|x| (x, x, 100, StakerStatus::Validator)))
+				.chain(nominators_range.map(|x| (x, x, 100, StakerStatus::Nominator(vec![x]))))
+				.collect::<Vec<_>>(),
+			..Default::default()
+		}
+		.assimilate_storage(&mut storage);
+
+		let mut ext = sp_io::TestExternalities::from(storage);
+
+		ext.execute_with(|| {
+			// for events to be deposited.
+			frame_system::Pallet::<Runtime>::set_block_number(1);
+
+			for era in 0..=(BondingDuration::get()) {
+				Self::register_stakers_for_era(era);
+			}
+
+			// because we read this value as a measure of how many validators we have.
+			pallet_staking::ValidatorCount::<Runtime>::put(VALIDATORS_PER_ERA as u32);
+
+			// make a pool
+			let amount_to_bond = Pools::depositor_min_bond();
+			Balances::make_free_balance_be(&10, amount_to_bond * 5);
+			assert_ok!(Pools::create(RawOrigin::Signed(10).into(), amount_to_bond, 900, 901, 902));
+		});
+		ext
+	}
+
+	pub fn build_and_execute(self, test: impl FnOnce() -> ()) {
+		self.build().execute_with(|| {
+			test();
+		})
+	}
+}
+
+pub(crate) fn run_to_block(n: u64, on_idle: bool) {
+	let current_block = System::block_number();
+	assert!(n > current_block);
+	while System::block_number() < n {
+		Balances::on_finalize(System::block_number());
+		Staking::on_finalize(System::block_number());
+		Pools::on_finalize(System::block_number());
+		FastUnstake::on_finalize(System::block_number());
+
+		System::set_block_number(System::block_number() + 1);
+
+		Balances::on_initialize(System::block_number());
+		Staking::on_initialize(System::block_number());
+		Pools::on_initialize(System::block_number());
+		FastUnstake::on_initialize(System::block_number());
+		if on_idle {
+			FastUnstake::on_idle(System::block_number(), BlockWeights::get().max_block);
+		}
+	}
+}
+
+pub(crate) fn next_block(on_idle: bool) {
+	let current = System::block_number();
+	run_to_block(current + 1, on_idle);
+}
+
+pub fn assert_unstaked(stash: &AccountId) {
+	assert!(!pallet_staking::Bonded::<T>::contains_key(stash));
+	assert!(!pallet_staking::Payee::<T>::contains_key(stash));
+	assert!(!pallet_staking::Validators::<T>::contains_key(stash));
+	assert!(!pallet_staking::Nominators::<T>::contains_key(stash));
+}
@@ -0,0 +1,119 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2022 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Types used in the Fast Unstake pallet.
+
+use crate::*;
+use codec::{Decode, Encode, MaxEncodedLen};
+use frame_support::{
+	traits::{Currency, Get, IsSubType},
+	BoundedVec, EqNoBound, PartialEqNoBound, RuntimeDebugNoBound,
+};
+use pallet_nomination_pools::PoolId;
+use scale_info::TypeInfo;
+use sp_runtime::transaction_validity::{InvalidTransaction, TransactionValidityError};
+use sp_staking::EraIndex;
+use sp_std::{fmt::Debug, prelude::*};
+
+pub type BalanceOf<T> = <<T as pallet_staking::Config>::Currency as Currency<
+	<T as frame_system::Config>::AccountId,
+>>::Balance;
+
+/// An unstake request.
+#[derive(
+	Encode, Decode, EqNoBound, PartialEqNoBound, Clone, TypeInfo, RuntimeDebugNoBound, MaxEncodedLen,
+)]
+pub struct UnstakeRequest<AccountId: Eq + PartialEq + Debug, MaxChecked: Get<u32>> {
+	/// Their stash account.
+	pub(crate) stash: AccountId,
+	/// The list of eras for which they have been checked.
+	pub(crate) checked: BoundedVec<EraIndex, MaxChecked>,
+	/// The pool they wish to join, if any.
+	pub(crate) maybe_pool_id: Option<PoolId>,
+}
+
+#[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo, RuntimeDebugNoBound)]
+#[scale_info(skip_type_params(T))]
+pub struct PreventStakingOpsIfUnbonding<T: Config + Send + Sync>(sp_std::marker::PhantomData<T>);
+
+#[cfg(test)]
+impl<T: Config + Send + Sync> PreventStakingOpsIfUnbonding<T> {
+	pub fn new() -> Self {
+		Self(Default::default())
+	}
+}
+
+impl<T: Config + Send + Sync> sp_runtime::traits::SignedExtension
+	for PreventStakingOpsIfUnbonding<T>
+where
+	<T as frame_system::Config>::RuntimeCall: IsSubType<pallet_staking::Call<T>>,
+{
+	type AccountId = T::AccountId;
+	type Call = <T as frame_system::Config>::RuntimeCall;
+	type AdditionalSigned = ();
+	type Pre = ();
+	const IDENTIFIER: &'static str = "PreventStakingOpsIfUnbonding";
+
+	fn additional_signed(&self) -> Result<Self::AdditionalSigned, TransactionValidityError> {
+		Ok(())
+	}
+
+	fn pre_dispatch(
+		self,
+		// NOTE: we want to prevent this stash-controller pair from doing anything in the
+		// staking system as long as they are registered here.
+		stash_or_controller: &Self::AccountId,
+		call: &Self::Call,
+		_info: &sp_runtime::traits::DispatchInfoOf<Self::Call>,
+		_len: usize,
+	) -> Result<Self::Pre, TransactionValidityError> {
+		// we don't check this in the tx-pool as it requires a storage read.
+		if <Self::Call as IsSubType<pallet_staking::Call<T>>>::is_sub_type(call).is_some() {
+			let check_stash = |stash: &T::AccountId| {
+				if Queue::<T>::contains_key(&stash) ||
+					Head::<T>::get().map_or(false, |u| &u.stash == stash)
+				{
+					Err(TransactionValidityError::Invalid(InvalidTransaction::Call))
+				} else {
+					Ok(())
+				}
+			};
+			match (
+				// mapped from controller.
+				pallet_staking::Ledger::<T>::get(&stash_or_controller),
+				// mapped from stash.
+				pallet_staking::Bonded::<T>::get(&stash_or_controller),
+			) {
+				(Some(ledger), None) => {
+					// it is a controller.
+					check_stash(&ledger.stash)
+				},
+				(_, Some(_)) => {
+					// it's a stash.
+					let stash = stash_or_controller;
+					check_stash(stash)
+				},
+				(None, None) => {
+					// They are not a staker -- let them execute.
+					Ok(())
+				},
+			}
+		} else {
+			Ok(())
+		}
+	}
+}
@@ -0,0 +1,210 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2022 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Autogenerated weights for pallet_fast_unstake
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2022-09-07, STEPS: `10`, REPEAT: 1, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! HOSTNAME: `Kians-MacBook-Pro-2.local`, CPU: `<UNKNOWN>`
+//! EXECUTION: Some(Native), WASM-EXECUTION: Compiled, CHAIN: None, DB CACHE: 1024
+
+// Executed Command:
+// target/release/substrate
+// benchmark
+// pallet
+// --steps=10
+// --repeat=1
+// --pallet=pallet_fast_unstake
+// --extrinsic=*
+// --execution=native
+// --output
+// weight.rs
+// --template
+// ./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use sp_std::marker::PhantomData;
+
+/// Weight functions needed for pallet_fast_unstake.
+pub trait WeightInfo {
+	fn on_idle_unstake() -> Weight;
+	fn on_idle_check(x: u32, ) -> Weight;
+	fn register_fast_unstake() -> Weight;
+	fn deregister() -> Weight;
+	fn control() -> Weight;
+}
+
+/// Weights for pallet_fast_unstake using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	// Storage: FastUnstake ErasToCheckPerBlock (r:1 w:0)
+	// Storage: Staking ValidatorCount (r:1 w:0)
+	// Storage: ElectionProviderMultiPhase CurrentPhase (r:1 w:0)
+	// Storage: FastUnstake Head (r:1 w:1)
+	// Storage: Staking CurrentEra (r:1 w:0)
+	// Storage: Staking SlashingSpans (r:1 w:0)
+	// Storage: Staking Bonded (r:2 w:1)
+	// Storage: Staking Ledger (r:2 w:2)
+	// Storage: Staking Validators (r:1 w:0)
+	// Storage: Staking Nominators (r:1 w:0)
+	// Storage: System Account (r:3 w:2)
+	// Storage: Balances Locks (r:2 w:2)
+	// Storage: NominationPools MinJoinBond (r:1 w:0)
+	// Storage: NominationPools PoolMembers (r:1 w:1)
+	// Storage: NominationPools BondedPools (r:1 w:1)
+	// Storage: NominationPools RewardPools (r:1 w:1)
+	// Storage: NominationPools MaxPoolMembersPerPool (r:1 w:0)
+	// Storage: NominationPools MaxPoolMembers (r:1 w:0)
+	// Storage: NominationPools CounterForPoolMembers (r:1 w:1)
+	// Storage: BagsList ListNodes (r:1 w:0)
+	// Storage: Staking Payee (r:0 w:1)
+	fn on_idle_unstake() -> Weight {
+		Weight::from_ref_time(102_000_000 as u64)
+			.saturating_add(T::DbWeight::get().reads(25 as u64))
+			.saturating_add(T::DbWeight::get().writes(13 as u64))
+	}
+	// Storage: FastUnstake ErasToCheckPerBlock (r:1 w:0)
+	// Storage: Staking ValidatorCount (r:1 w:0)
+	// Storage: ElectionProviderMultiPhase CurrentPhase (r:1 w:0)
+	// Storage: FastUnstake Head (r:1 w:1)
+	// Storage: FastUnstake Queue (r:2 w:1)
+	// Storage: FastUnstake CounterForQueue (r:1 w:1)
+	// Storage: Staking CurrentEra (r:1 w:0)
+	// Storage: Staking ErasStakers (r:1344 w:0)
+	/// The range of component `x` is `[672, 86016]`.
+	fn on_idle_check(x: u32, ) -> Weight {
+		Weight::from_ref_time(0 as u64)
+			// Standard Error: 244_000
+			.saturating_add(Weight::from_ref_time(13_913_000 as u64).saturating_mul(x as u64))
+			.saturating_add(T::DbWeight::get().reads(585 as u64))
+			.saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(x as u64)))
+			.saturating_add(T::DbWeight::get().writes(3 as u64))
+	}
+	// Storage: Staking Ledger (r:1 w:1)
+	// Storage: Staking Nominators (r:1 w:1)
+	// Storage: FastUnstake Queue (r:1 w:1)
+	// Storage: FastUnstake Head (r:1 w:0)
+	// Storage: Staking Validators (r:1 w:0)
+	// Storage: Staking CounterForNominators (r:1 w:1)
+	// Storage: BagsList ListNodes (r:1 w:1)
+	// Storage: BagsList ListBags (r:1 w:1)
+	// Storage: BagsList CounterForListNodes (r:1 w:1)
+	// Storage: Staking CurrentEra (r:1 w:0)
+	// Storage: Balances Locks (r:1 w:1)
+	// Storage: FastUnstake CounterForQueue (r:1 w:1)
+	fn register_fast_unstake() -> Weight {
+		Weight::from_ref_time(57_000_000 as u64)
+			.saturating_add(T::DbWeight::get().reads(12 as u64))
+			.saturating_add(T::DbWeight::get().writes(9 as u64))
+	}
+	// Storage: Staking Ledger (r:1 w:0)
+	// Storage: FastUnstake Queue (r:1 w:1)
+	// Storage: FastUnstake Head (r:1 w:0)
+	// Storage: FastUnstake CounterForQueue (r:1 w:1)
+	fn deregister() -> Weight {
+		Weight::from_ref_time(15_000_000 as u64)
+			.saturating_add(T::DbWeight::get().reads(4 as u64))
+			.saturating_add(T::DbWeight::get().writes(2 as u64))
+	}
+	// Storage: FastUnstake ErasToCheckPerBlock (r:0 w:1)
+	fn control() -> Weight {
+		Weight::from_ref_time(3_000_000 as u64)
+			.saturating_add(T::DbWeight::get().writes(1 as u64))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	// Storage: FastUnstake ErasToCheckPerBlock (r:1 w:0)
+	// Storage: Staking ValidatorCount (r:1 w:0)
+	// Storage: ElectionProviderMultiPhase CurrentPhase (r:1 w:0)
+	// Storage: FastUnstake Head (r:1 w:1)
+	// Storage: Staking CurrentEra (r:1 w:0)
+	// Storage: Staking SlashingSpans (r:1 w:0)
+	// Storage: Staking Bonded (r:2 w:1)
+	// Storage: Staking Ledger (r:2 w:2)
+	// Storage: Staking Validators (r:1 w:0)
+	// Storage: Staking Nominators (r:1 w:0)
+	// Storage: System Account (r:3 w:2)
+	// Storage: Balances Locks (r:2 w:2)
+	// Storage: NominationPools MinJoinBond (r:1 w:0)
+	// Storage: NominationPools PoolMembers (r:1 w:1)
+	// Storage: NominationPools BondedPools (r:1 w:1)
+	// Storage: NominationPools RewardPools (r:1 w:1)
+	// Storage: NominationPools MaxPoolMembersPerPool (r:1 w:0)
+	// Storage: NominationPools MaxPoolMembers (r:1 w:0)
+	// Storage: NominationPools CounterForPoolMembers (r:1 w:1)
+	// Storage: BagsList ListNodes (r:1 w:0)
+	// Storage: Staking Payee (r:0 w:1)
+	fn on_idle_unstake() -> Weight {
+		Weight::from_ref_time(102_000_000 as u64)
+			.saturating_add(RocksDbWeight::get().reads(25 as u64))
+			.saturating_add(RocksDbWeight::get().writes(13 as u64))
+	}
+	// Storage: FastUnstake ErasToCheckPerBlock (r:1 w:0)
+	// Storage: Staking ValidatorCount (r:1 w:0)
+	// Storage: ElectionProviderMultiPhase CurrentPhase (r:1 w:0)
+	// Storage: FastUnstake Head (r:1 w:1)
+	// Storage: FastUnstake Queue (r:2 w:1)
+	// Storage: FastUnstake CounterForQueue (r:1 w:1)
+	// Storage: Staking CurrentEra (r:1 w:0)
+	// Storage: Staking ErasStakers (r:1344 w:0)
+	/// The range of component `x` is `[672, 86016]`.
+	fn on_idle_check(x: u32, ) -> Weight {
+		Weight::from_ref_time(0 as u64)
+			// Standard Error: 244_000
+			.saturating_add(Weight::from_ref_time(13_913_000 as u64).saturating_mul(x as u64))
+			.saturating_add(RocksDbWeight::get().reads(585 as u64))
+			.saturating_add(RocksDbWeight::get().reads((1 as u64).saturating_mul(x as u64)))
+			.saturating_add(RocksDbWeight::get().writes(3 as u64))
+	}
+	// Storage: Staking Ledger (r:1 w:1)
+	// Storage: Staking Nominators (r:1 w:1)
+	// Storage: FastUnstake Queue (r:1 w:1)
+	// Storage: FastUnstake Head (r:1 w:0)
+	// Storage: Staking Validators (r:1 w:0)
+	// Storage: Staking CounterForNominators (r:1 w:1)
+	// Storage: BagsList ListNodes (r:1 w:1)
+	// Storage: BagsList ListBags (r:1 w:1)
+	// Storage: BagsList CounterForListNodes (r:1 w:1)
+	// Storage: Staking CurrentEra (r:1 w:0)
+	// Storage: Balances Locks (r:1 w:1)
+	// Storage: FastUnstake CounterForQueue (r:1 w:1)
+	fn register_fast_unstake() -> Weight {
+		Weight::from_ref_time(57_000_000 as u64)
+			.saturating_add(RocksDbWeight::get().reads(12 as u64))
+			.saturating_add(RocksDbWeight::get().writes(9 as u64))
+	}
+	// Storage: Staking Ledger (r:1 w:0)
+	// Storage: FastUnstake Queue (r:1 w:1)
+	// Storage: FastUnstake Head (r:1 w:0)
+	// Storage: FastUnstake CounterForQueue (r:1 w:1)
+	fn deregister() -> Weight {
+		Weight::from_ref_time(15_000_000 as u64)
+			.saturating_add(RocksDbWeight::get().reads(4 as u64))
+			.saturating_add(RocksDbWeight::get().writes(2 as u64))
+	}
+	// Storage: FastUnstake ErasToCheckPerBlock (r:0 w:1)
+	fn control() -> Weight {
+		Weight::from_ref_time(3_000_000 as u64)
+			.saturating_add(RocksDbWeight::get().writes(1 as u64))
+	}
+}