referrerpolicy=no-referrer-when-downgrade

pallet_staking_async/pallet/
mod.rs

1// This file is part of Substrate.
2
3// Copyright (C) Parity Technologies (UK) Ltd.
4// SPDX-License-Identifier: Apache-2.0
5
6// Licensed under the Apache License, Version 2.0 (the "License");
7// you may not use this file except in compliance with the License.
8// You may obtain a copy of the License at
9//
10// 	http://www.apache.org/licenses/LICENSE-2.0
11//
12// Unless required by applicable law or agreed to in writing, software
13// distributed under the License is distributed on an "AS IS" BASIS,
14// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15// See the License for the specific language governing permissions and
16// limitations under the License.
17
18//! `pallet-staking-async`'s main `pallet` module.
19
20use crate::{
21	asset, session_rotation::EraElectionPlanner, slashing, weights::WeightInfo, AccountIdLookupOf,
22	ActiveEraInfo, BalanceOf, EraPayout, EraRewardPoints, ExposurePage, Forcing,
23	LedgerIntegrityState, MaxNominationsOf, NegativeImbalanceOf, Nominations, NominationsQuota,
24	PositiveImbalanceOf, RewardDestination, StakingLedger, UnappliedSlash, UnlockChunk,
25	ValidatorPrefs,
26};
27use alloc::{format, vec::Vec};
28use codec::Codec;
29use frame_election_provider_support::{ElectionProvider, SortedListProvider, VoteWeight};
30use frame_support::{
31	assert_ok,
32	pallet_prelude::*,
33	traits::{
34		fungible::{
35			hold::{Balanced as FunHoldBalanced, Mutate as FunHoldMutate},
36			Mutate, Mutate as FunMutate,
37		},
38		Contains, Defensive, DefensiveSaturating, EnsureOrigin, Get, InspectLockableCurrency,
39		Nothing, OnUnbalanced,
40	},
41	weights::Weight,
42	BoundedBTreeSet, BoundedVec,
43};
44use frame_system::{ensure_root, ensure_signed, pallet_prelude::*};
45pub use impls::*;
46use rand::seq::SliceRandom;
47use rand_chacha::{
48	rand_core::{RngCore, SeedableRng},
49	ChaChaRng,
50};
51use sp_core::{sr25519::Pair as SrPair, Pair};
52use sp_runtime::{
53	traits::{StaticLookup, Zero},
54	ArithmeticError, Perbill, Percent,
55};
56use sp_staking::{
57	EraIndex, Page, ServiceKind, SessionIndex,
58	StakingAccount::{self, Controller, Stash},
59	StakingInterface,
60};
61
62mod impls;
63
64#[frame_support::pallet]
65pub mod pallet {
66	use core::ops::Deref;
67
68	use super::*;
69	use crate::{
70		session_rotation::{self, Eras, Rotator},
71		IsValidatorInactive, OnEraStart, PagedExposureMetadata, SnapshotStatus,
72	};
73	use codec::HasCompact;
74	use frame_election_provider_support::{ElectionDataProvider, PageIndex};
75	use frame_support::{traits::ConstBool, weights::WeightMeter, DefaultNoBound, PalletError};
76
77	/// Dimensionless weight from the validator self-stake incentive curve. Same underlying type as
78	/// `BalanceOf<T>` for arithmetic compatibility, but represents the output of the sqrt weight
79	/// function.
80	pub(crate) type IncentiveWeight<T> = BalanceOf<T>;
81
82	/// Represents the current step in the era pruning process
83	#[derive(Encode, Decode, Clone, Copy, PartialEq, Eq, Debug, TypeInfo, MaxEncodedLen)]
84	pub enum PruningStep {
85		/// Pruning ErasStakersPaged storage
86		ErasStakersPaged,
87		/// Pruning ErasStakersOverview storage
88		ErasStakersOverview,
89		/// Pruning ErasValidatorPrefs storage
90		ErasValidatorPrefs,
91		/// Pruning ClaimedRewards storage
92		ClaimedRewards,
93		/// Pruning ErasValidatorReward storage
94		ErasValidatorReward,
95		/// Pruning ErasRewardPoints storage
96		ErasRewardPoints,
97		/// Pruning single-entry storages
98		SingleEntryCleanups,
99		/// Pruning ValidatorSlashInEra storage
100		ValidatorSlashInEra,
101		/// Pruning ErasValidatorIncentiveWeight storage
102		ErasValidatorIncentiveWeight,
103	}
104
105	/// The in-code storage version.
106	const STORAGE_VERSION: StorageVersion = StorageVersion::new(18);
107
108	#[pallet::pallet]
109	#[pallet::storage_version(STORAGE_VERSION)]
110	pub struct Pallet<T>(_);
111
112	/// Possible operations on the configuration values of this pallet.
113	#[derive(TypeInfo, Debug, Clone, Encode, Decode, DecodeWithMemTracking, PartialEq)]
114	pub enum ConfigOp<T: Default + Codec> {
115		/// Don't change.
116		Noop,
117		/// Set the given value.
118		Set(T),
119		/// Remove from storage.
120		Remove,
121	}
122
123	#[pallet::config(with_default)]
124	pub trait Config: frame_system::Config {
125		/// The old trait for staking balance. Deprecated and only used for migrating old ledgers.
126		#[pallet::no_default]
127		type OldCurrency: InspectLockableCurrency<
128			Self::AccountId,
129			Moment = BlockNumberFor<Self>,
130			Balance = Self::CurrencyBalance,
131		>;
132
133		/// The staking balance.
134		#[pallet::no_default]
135		type Currency: FunHoldMutate<
136				Self::AccountId,
137				Reason = Self::RuntimeHoldReason,
138				Balance = Self::CurrencyBalance,
139			> + FunMutate<Self::AccountId, Balance = Self::CurrencyBalance>
140			+ FunHoldBalanced<Self::AccountId, Balance = Self::CurrencyBalance>;
141
142		/// Overarching hold reason.
143		#[pallet::no_default_bounds]
144		type RuntimeHoldReason: From<HoldReason>;
145
146		/// Just the `Currency::Balance` type; we have this item to allow us to constrain it to
147		/// `From<u64>`.
148		type CurrencyBalance: sp_runtime::traits::AtLeast32BitUnsigned
149			+ codec::FullCodec
150			+ DecodeWithMemTracking
151			+ HasCompact<Type: DecodeWithMemTracking>
152			+ Copy
153			+ MaybeSerializeDeserialize
154			+ core::fmt::Debug
155			+ Default
156			+ From<u64>
157			+ TypeInfo
158			+ Send
159			+ Sync
160			+ MaxEncodedLen;
161
162		/// Convert a balance into a number used for election calculation. This must fit into a
163		/// `u64` but is allowed to be sensibly lossy. The `u64` is used to communicate with the
164		/// [`frame_election_provider_support`] crate which accepts u64 numbers and does operations
165		/// in 128.
166		/// Consequently, the backward convert is used convert the u128s from sp-elections back to a
167		/// [`BalanceOf`].
168		#[pallet::no_default_bounds]
169		type CurrencyToVote: sp_staking::currency_to_vote::CurrencyToVote<BalanceOf<Self>>;
170
171		/// Something that provides the election functionality.
172		#[pallet::no_default]
173		type ElectionProvider: ElectionProvider<
174			AccountId = Self::AccountId,
175			BlockNumber = BlockNumberFor<Self>,
176			// we only accept an election provider that has staking as data provider.
177			DataProvider = Pallet<Self>,
178		>;
179
180		/// Something that defines the maximum number of nominations per nominator.
181		#[pallet::no_default_bounds]
182		type NominationsQuota: NominationsQuota<BalanceOf<Self>>;
183
184		/// Number of eras to keep in history.
185		///
186		/// Following information is kept for eras in `[current_era -
187		/// HistoryDepth, current_era]`: `ErasValidatorPrefs`, `ErasValidatorReward`,
188		/// `ErasRewardPoints`, `ErasTotalStake`, `ClaimedRewards`,
189		/// `ErasStakersPaged`, `ErasStakersOverview`.
190		///
191		/// Must be more than the number of eras delayed by session.
192		/// I.e. active era must always be in history. I.e. `active_era >
193		/// current_era - history_depth` must be guaranteed.
194		///
195		/// If migrating an existing pallet from storage value to config value,
196		/// this should be set to same value or greater as in storage.
197		#[pallet::constant]
198		type HistoryDepth: Get<u32>;
199
200		/// Tokens have been minted and are unused for validator-reward.
201		///
202		/// Only used in legacy minting mode (`DisableMinting = false`).
203		#[pallet::no_default_bounds]
204		type RewardRemainder: OnUnbalanced<NegativeImbalanceOf<Self>>;
205
206		/// Handler for the unbalanced reduction when slashing a staker.
207		#[pallet::no_default_bounds]
208		type Slash: OnUnbalanced<NegativeImbalanceOf<Self>>;
209
210		/// Handler for the unbalanced increment when rewarding a staker.
211		/// NOTE: in most cases, the implementation of `OnUnbalanced` should modify the total
212		/// issuance.
213		///
214		/// Only used in legacy minting mode (`DisableMinting = false`).
215		#[pallet::no_default_bounds]
216		type Reward: OnUnbalanced<PositiveImbalanceOf<Self>>;
217
218		/// Number of sessions per era, as per the preferences of the **relay chain**.
219		#[pallet::constant]
220		type SessionsPerEra: Get<SessionIndex>;
221
222		/// Number of sessions before the end of an era when the election for the next era will
223		/// start.
224		///
225		/// - This determines how many sessions **before** the last session of the era the staking
226		///   election process should begin.
227		/// - The value is bounded between **1** (election starts at the beginning of the last
228		///   session) and `SessionsPerEra` (election starts at the beginning of the first session
229		///   of the era).
230		///
231		/// ### Example:
232		/// - If `SessionsPerEra = 6` and `PlanningEraOffset = 1`, the election starts at the
233		///   beginning of session `6 - 1 = 5`.
234		/// - If `PlanningEraOffset = 6`, the election starts at the beginning of session `6 - 6 =
235		///   0`, meaning it starts at the very beginning of the era.
236		#[pallet::constant]
237		type PlanningEraOffset: Get<SessionIndex>;
238
239		/// Number of eras that staked funds must remain bonded for.
240		///
241		/// This is the bonding duration for validators. Nominators may have a shorter bonding
242		/// duration when [`AreNominatorsSlashable`] is set to `false` (see
243		/// [`StakingInterface::nominator_bonding_duration`]).
244		#[pallet::constant]
245		type BondingDuration: Get<EraIndex>;
246
247		/// Number of eras nominators must wait to unbond when they are not slashable.
248		///
249		/// This duration is used for nominators when [`AreNominatorsSlashable`] is `false`.
250		/// When nominators are slashable, they use the full [`Config::BondingDuration`] to ensure
251		/// slashes can be applied during the unbonding period.
252		///
253		/// Setting this to a lower value (e.g., 1 era) allows for faster withdrawals when
254		/// nominators are not subject to slashing risk.
255		#[pallet::constant]
256		type NominatorFastUnbondDuration: Get<EraIndex>;
257
258		/// Number of eras that slashes are deferred by, after computation.
259		///
260		/// This should be less than the bonding duration. Set to 0 if slashes
261		/// should be applied immediately, without opportunity for intervention.
262		#[pallet::constant]
263		type SlashDeferDuration: Get<EraIndex>;
264
265		/// The origin which can manage less critical staking parameters that does not require root.
266		///
267		/// Supported actions: (1) cancel deferred slash, (2) set minimum commission.
268		#[pallet::no_default]
269		type AdminOrigin: EnsureOrigin<Self::RuntimeOrigin>;
270
271		/// The payout for validators and the system for the current era.
272		/// See [Era payout](./index.html#era-payout).
273		///
274		/// Only used in legacy minting mode (`DisableMinting = false`).
275		/// Should be set to () in non-minting mode.
276		#[pallet::no_default]
277		type EraPayout: EraPayout<BalanceOf<Self>>;
278
279		/// When `true`, staking does not mint. It expects an external source to fund
280		/// the general reward pot. At era boundary, rewards are snapshotted from
281		/// the pot. `EraPayout` is not called.
282		///
283		/// When `false`, staking uses the legacy path: `EraPayout` computes inflation,
284		/// tokens are minted on-the-fly during payout.
285		///
286		/// **Irreversible**: once set to `true`, must never be switched back. Eras
287		/// created in non-minting mode have funded reward pots — switching to legacy
288		/// would orphan those pots and cause double-minting.
289		#[pallet::constant]
290		type DisableMinting: Get<bool>;
291
292		/// Handler for unclaimed era rewards (non-minting mode only).
293		///
294		/// When era pots are cleaned up past `HistoryDepth`, remaining funds are
295		/// withdrawn and passed to this handler.
296		#[pallet::no_default_bounds]
297		type UnclaimedRewardHandler: OnUnbalanced<NegativeImbalanceOf<Self>>;
298
299		/// Provider for generating reward pot account IDs (non-minting mode only).
300		///
301		/// Provides both general pots (funded by an external source like pallet-dap)
302		/// and era-specific pots (snapshotted at era boundaries).
303		#[pallet::no_default]
304		type RewardPots: crate::PotAccountProvider<Self::AccountId>;
305
306		/// Calculator for staker rewards.
307		///
308		/// Determines how staking rewards are distributed between validators and nominators.
309		#[pallet::no_default_bounds]
310		type StakerRewardCalculator: sp_staking::StakerRewardCalculator<BalanceOf<Self>>;
311
312		/// The maximum size of each `T::ExposurePage`.
313		///
314		/// An `ExposurePage` is weakly bounded to a maximum of `MaxExposurePageSize`
315		/// nominators.
316		///
317		/// For older non-paged exposure, a reward payout was restricted to the top
318		/// `MaxExposurePageSize` nominators. This is to limit the i/o cost for the
319		/// nominator payout.
320		///
321		/// Note: `MaxExposurePageSize` is used to bound `ClaimedRewards` and is unsafe to
322		/// reduce without handling it in a migration.
323		#[pallet::constant]
324		type MaxExposurePageSize: Get<u32>;
325
326		/// The absolute maximum of winner validators this pallet should return.
327		///
328		/// As this pallet supports multi-block election, the set of winner validators *per
329		/// election* is bounded by this type.
330		#[pallet::constant]
331		type MaxValidatorSet: Get<u32>;
332
333		/// Something that provides a best-effort sorted list of voters aka electing nominators,
334		/// used for NPoS election.
335		///
336		/// The changes to nominators are reported to this. Moreover, each validator's self-vote is
337		/// also reported as one independent vote.
338		///
339		/// To keep the load off the chain as much as possible, changes made to the staked amount
340		/// via rewards and slashes are not reported and thus need to be manually fixed by the
341		/// staker. In case of `bags-list`, this always means using `rebag` and `putInFrontOf`.
342		///
343		/// Invariant: what comes out of this list will always be a nominator.
344		#[pallet::no_default]
345		type VoterList: SortedListProvider<Self::AccountId, Score = VoteWeight>;
346
347		/// WIP: This is a noop as of now, the actual business logic that's described below is going
348		/// to be introduced in a follow-up PR.
349		///
350		/// Something that provides a best-effort sorted list of targets aka electable validators,
351		/// used for NPoS election.
352		///
353		/// The changes to the approval stake of each validator are reported to this. This means any
354		/// change to:
355		/// 1. The stake of any validator or nominator.
356		/// 2. The targets of any nominator
357		/// 3. The role of any staker (e.g. validator -> chilled, nominator -> validator, etc)
358		///
359		/// Unlike `VoterList`, the values in this list are always kept up to date with reward and
360		/// slash as well, and thus represent the accurate approval stake of all account being
361		/// nominated by nominators.
362		///
363		/// Note that while at the time of nomination, all targets are checked to be real
364		/// validators, they can chill at any point, and their approval stakes will still be
365		/// recorded. This implies that what comes out of iterating this list MIGHT NOT BE AN ACTIVE
366		/// VALIDATOR.
367		#[pallet::no_default]
368		type TargetList: SortedListProvider<Self::AccountId, Score = BalanceOf<Self>>;
369
370		/// The maximum number of `unlocking` chunks a [`StakingLedger`] can
371		/// have. Effectively determines how many unique eras a staker may be
372		/// unbonding in.
373		///
374		/// Note: `MaxUnlockingChunks` is used as the upper bound for the
375		/// `BoundedVec` item `StakingLedger.unlocking`. Setting this value
376		/// lower than the existing value can lead to inconsistencies in the
377		/// `StakingLedger` and will need to be handled properly in a runtime
378		/// migration. The test `reducing_max_unlocking_chunks_abrupt` shows
379		/// this effect.
380		#[pallet::constant]
381		type MaxUnlockingChunks: Get<u32>;
382
383		/// The maximum amount of controller accounts that can be deprecated in one call.
384		type MaxControllersInDeprecationBatch: Get<u32>;
385
386		/// Something that listens to staking updates and performs actions based on the data it
387		/// receives.
388		///
389		/// WARNING: this only reports slashing and withdraw events for the time being.
390		#[pallet::no_default_bounds]
391		type EventListeners: sp_staking::OnStakingUpdate<Self::AccountId, BalanceOf<Self>>;
392
393		/// Maximum allowed era duration in milliseconds.
394		///
395		/// This provides a defensive upper bound to cap the effective era duration, preventing
396		/// excessively long eras from causing runaway inflation (e.g., due to bugs). If the actual
397		/// era duration exceeds this value, it will be clamped to this maximum.
398		///
399		/// Example: For an ideal era duration of 24 hours (86,400,000 ms),
400		/// this can be set to 604,800,000 ms (7 days).
401		///
402		/// Only used in legacy minting mode (`DisableMinting = false`).
403		#[pallet::constant]
404		type MaxEraDuration: Get<u64>;
405
406		/// Maximum number of storage items that can be pruned in a single call.
407		///
408		/// This controls how many storage items can be deleted in each call to `prune_era_step`.
409		/// This should be set to a conservative value (e.g., 100-500 items) to ensure pruning
410		/// doesn't consume too much block space. The actual weight is determined by benchmarks.
411		#[pallet::constant]
412		type MaxPruningItems: Get<u32>;
413
414		/// Interface to talk to the RC-Client pallet, possibly sending election results to the
415		/// relay chain.
416		#[pallet::no_default]
417		type RcClientInterface: pallet_staking_async_rc_client::RcClientInterface<
418			AccountId = Self::AccountId,
419		>;
420
421		#[pallet::no_default_bounds]
422		/// Filter some accounts from participating in staking.
423		///
424		/// This is useful for example to blacklist an account that is participating in staking in
425		/// another way (such as pools).
426		type Filter: Contains<Self::AccountId>;
427
428		/// Weight information for extrinsics in this pallet.
429		type WeightInfo: WeightInfo;
430
431		/// Check if validator was inactive at some era.
432		///
433		/// This check is used by `chill_inactive` extrinsic to check which
434		/// validators can be chilled. See the implementors of [`IsValidatorInactive`] for the
435		/// available options.
436		type IsValidatorInactive: IsValidatorInactive<Self::AccountId>;
437
438		/// Notified with the validators of each era when it becomes active.
439		#[pallet::no_default_bounds]
440		type OnEraStart: OnEraStart<Self::AccountId>;
441	}
442
443	/// A reason for placing a hold on funds.
444	#[pallet::composite_enum]
445	pub enum HoldReason {
446		/// Funds on stake by a nominator or a validator.
447		#[codec(index = 0)]
448		Staking,
449	}
450
451	/// Default implementations of [`DefaultConfig`], which can be used to implement [`Config`].
452	pub mod config_preludes {
453		use super::*;
454		use frame_support::{derive_impl, parameter_types, traits::ConstU32};
455		pub struct TestDefaultConfig;
456
457		#[derive_impl(frame_system::config_preludes::TestDefaultConfig, no_aggregated_types)]
458		impl frame_system::DefaultConfig for TestDefaultConfig {}
459
460		parameter_types! {
461			pub const SessionsPerEra: SessionIndex = 3;
462			pub const BondingDuration: EraIndex = 3;
463			pub const NominatorFastUnbondDuration: EraIndex = 2;
464			pub const MaxPruningItems: u32 = 100;
465		}
466
467		#[frame_support::register_default_impl(TestDefaultConfig)]
468		impl DefaultConfig for TestDefaultConfig {
469			#[inject_runtime_type]
470			type RuntimeHoldReason = ();
471			type CurrencyBalance = u128;
472			type CurrencyToVote = ();
473			type NominationsQuota = crate::FixedNominationsQuota<16>;
474			type HistoryDepth = ConstU32<84>;
475			type RewardRemainder = ();
476			type Slash = ();
477			type Reward = ();
478			type UnclaimedRewardHandler = ();
479			type StakerRewardCalculator = ();
480			type DisableMinting = ConstBool<false>;
481			type SessionsPerEra = SessionsPerEra;
482			type BondingDuration = BondingDuration;
483			type NominatorFastUnbondDuration = NominatorFastUnbondDuration;
484			type PlanningEraOffset = ConstU32<1>;
485			type SlashDeferDuration = ();
486			type MaxExposurePageSize = ConstU32<64>;
487			type MaxUnlockingChunks = ConstU32<32>;
488			type MaxValidatorSet = ConstU32<100>;
489			type MaxControllersInDeprecationBatch = ConstU32<100>;
490			type MaxEraDuration = ();
491			type MaxPruningItems = MaxPruningItems;
492			type EventListeners = ();
493			type Filter = Nothing;
494			type WeightInfo = ();
495			type IsValidatorInactive = ();
496			type OnEraStart = ();
497		}
498	}
499
500	/// The ideal number of active validators.
501	#[pallet::storage]
502	pub type ValidatorCount<T> = StorageValue<_, u32, ValueQuery>;
503
504	/// Map from all locked "stash" accounts to the controller account.
505	///
506	/// TWOX-NOTE: SAFE since `AccountId` is a secure hash.
507	#[pallet::storage]
508	pub type Bonded<T: Config> = StorageMap<_, Twox64Concat, T::AccountId, T::AccountId>;
509
510	/// The minimum active bond to become and maintain the role of a nominator.
511	#[pallet::storage]
512	pub type MinNominatorBond<T: Config> = StorageValue<_, BalanceOf<T>, ValueQuery>;
513
514	/// The minimum active bond to become and maintain the role of a validator.
515	#[pallet::storage]
516	pub type MinValidatorBond<T: Config> = StorageValue<_, BalanceOf<T>, ValueQuery>;
517
518	/// The minimum active nominator stake of the last successful election.
519	#[pallet::storage]
520	pub type MinimumActiveStake<T> = StorageValue<_, BalanceOf<T>, ValueQuery>;
521
522	/// The minimum amount of commission that validators can set.
523	///
524	/// If set to `0`, no limit exists.
525	#[pallet::storage]
526	pub type MinCommission<T: Config> = StorageValue<_, Perbill, ValueQuery>;
527
528	/// The maximum commission that validators can set.
529	///
530	/// If not set, defaults to `Perbill::one()` (100%), i.e. no upper limit.
531	#[pallet::storage]
532	pub type MaxCommission<T: Config> = StorageValue<_, Perbill, ValueQuery, MaxCommissionDefault>;
533
534	/// Default for MaxCommission: 100% (no restriction).
535	pub struct MaxCommissionDefault;
536	impl Get<Perbill> for MaxCommissionDefault {
537		fn get() -> Perbill {
538			Perbill::one()
539		}
540	}
541
542	/// Safety guard: the era from which legacy minting is permanently disabled on the
543	/// payout side. **Irreversible** — once set, should never be cleared.
544	///
545	/// Separate from [`Config::DisableMinting`] which controls the `end_era` path.
546	/// This storage guards against minting during payout for eras that were created
547	/// in DAP mode. Set automatically by `end_era_dap` on first successful pot snapshot.
548	/// In legacy mode (Kusama), this is never set and the guard is inactive.
549	#[pallet::storage]
550	pub type DisableMintingGuard<T: Config> = StorageValue<_, EraIndex>;
551
552	/// Optimum self-stake threshold for validators.
553	///
554	/// Below this threshold, the incentive weight grows as `sqrt(self_stake)`.
555	/// Above it, growth is dampened by [`SelfStakeSlopeFactor`].
556	#[pallet::storage]
557	pub type OptimumSelfStake<T: Config> = StorageValue<_, BalanceOf<T>, ValueQuery>;
558
559	/// Hard cap on effective validator self-stake.
560	///
561	/// Self-stake above this value receives no additional reward benefit (plateau).
562	#[pallet::storage]
563	pub type HardCapSelfStake<T: Config> = StorageValue<_, BalanceOf<T>, ValueQuery>;
564
565	/// Slope factor controlling the discouragement rate for self-stake between optimum and cap.
566	///
567	/// Value between 0 and 1: k=1 means no discouragement, k=0 means immediate plateau.
568	#[pallet::storage]
569	pub type SelfStakeSlopeFactor<T: Config> = StorageValue<_, Perbill, ValueQuery>;
570
571	/// The total validator incentive budget for the given era, snapshotted at era end.
572	///
573	/// This is the similar to [`ErasValidatorReward`] but for the self-stake incentive pot.
574	#[pallet::storage]
575	pub type ErasValidatorIncentiveBudget<T: Config> =
576		StorageMap<_, Twox64Concat, EraIndex, BalanceOf<T>, ValueQuery>;
577
578	/// Sum of all validators' incentive weights for the era.
579	///
580	/// Directly linked to [`ErasValidatorIncentiveWeight`].
581	#[pallet::storage]
582	pub type ErasSumValidatorIncentiveWeight<T: Config> =
583		StorageMap<_, Twox64Concat, EraIndex, IncentiveWeight<T>, ValueQuery>;
584
585	/// Individual validator incentive weight per era.
586	/// Each validator's share of the incentive pot = `their_weight / sum_weight`.
587	#[pallet::storage]
588	pub type ErasValidatorIncentiveWeight<T: Config> = StorageDoubleMap<
589		_,
590		Twox64Concat,
591		EraIndex,
592		Twox64Concat,
593		T::AccountId,
594		IncentiveWeight<T>,
595		OptionQuery,
596	>;
597
598	/// Running sum of `validator_incentive_weight × era_points` across all validators
599	/// with non-zero era points for the era.
600	///
601	/// Maintained incrementally inside [`session_rotation::Eras::reward_active_era`] every
602	/// time validator points are credited. Used as the denominator of the weighted-points
603	/// share that determines each validator's slice of [`ErasValidatorIncentiveBudget`].
604	#[pallet::storage]
605	pub type ErasSumWeightedPoints<T: Config> =
606		StorageMap<_, Twox64Concat, EraIndex, IncentiveWeight<T>, ValueQuery>;
607
608	/// Cutoff era from which the validator self-stake incentive switches to the
609	/// weighted-points formula.
610	///
611	/// `None` is the pre-migration state for chains whose storage predates this item. Until the
612	/// migration records a cutoff, [`session_rotation::Eras::uses_weighted_points`] treats all
613	/// eras as weighted-points eras. Chains initialized with this storage item set the cutoff to
614	/// `0` in `genesis_build`, and the upgrade migration leaves any existing value untouched.
615	///
616	/// See [`session_rotation::Eras::uses_weighted_points`] for the exact semantics and
617	/// the rationale for the cutoff.
618	///
619	/// TODO(staking-async): remove this storage item, the legacy stake-only branch in
620	/// [`crate::Pallet::calculate_validator_incentive_for_page`], the
621	/// [`session_rotation::Eras::uses_weighted_points`] cutoff helper, and the
622	/// [`crate::migrations::SetWeightedPointsFormulaStartEra`] migration once
623	/// [`Config::HistoryDepth`] eras have elapsed since the upgrade — i.e. once the cutoff
624	/// satisfies `cutoff <= active_era - HistoryDepth`, at which point no pre-cutoff era
625	/// remains claimable and every live era uses the weighted-points formula.
626	#[pallet::storage]
627	pub type WeightedPointsFormulaStartEra<T: Config> = StorageValue<_, EraIndex, OptionQuery>;
628
629	/// Whether nominators are slashable or not.
630	///
631	/// - When set to `true` (default), nominators are slashed along with validators and must wait
632	///   the full [`Config::BondingDuration`] before withdrawing unbonded funds.
633	/// - When set to `false`, nominators are not slashed, and can unbond in
634	///   [`Config::NominatorFastUnbondDuration`] eras instead of the full
635	///   [`Config::BondingDuration`] (see [`StakingInterface::nominator_bonding_duration`]).
636	#[pallet::storage]
637	pub type AreNominatorsSlashable<T: Config> = StorageValue<_, bool, ValueQuery, ConstBool<true>>;
638
639	/// Per-era snapshot of whether nominators are slashable.
640	///
641	/// This is copied from [`AreNominatorsSlashable`] at the start of each era. When processing
642	/// offences, we use the value from this storage for the offence era to ensure that the
643	/// slashing rules at the time of the offence are applied, not the current rules.
644	///
645	/// If an entry does not exist for an era, nominators are assumed to be slashable (default).
646	#[pallet::storage]
647	pub type ErasNominatorsSlashable<T: Config> =
648		StorageMap<_, Twox64Concat, EraIndex, bool, OptionQuery>;
649
650	/// Map from all (unlocked) "controller" accounts to the info regarding the staking.
651	///
652	/// Note: All the reads and mutations to this storage *MUST* be done through the methods exposed
653	/// by [`StakingLedger`] to ensure data and lock consistency.
654	#[pallet::storage]
655	pub type Ledger<T: Config> = StorageMap<_, Blake2_128Concat, T::AccountId, StakingLedger<T>>;
656
657	/// Where the reward payment should be made. Keyed by stash.
658	///
659	/// TWOX-NOTE: SAFE since `AccountId` is a secure hash.
660	#[pallet::storage]
661	pub type Payee<T: Config> =
662		StorageMap<_, Twox64Concat, T::AccountId, RewardDestination<T::AccountId>, OptionQuery>;
663
664	/// The map from (wannabe) validator stash key to the preferences of that validator.
665	///
666	/// TWOX-NOTE: SAFE since `AccountId` is a secure hash.
667	#[pallet::storage]
668	pub type Validators<T: Config> =
669		CountedStorageMap<_, Twox64Concat, T::AccountId, ValidatorPrefs, ValueQuery>;
670
671	/// The maximum validator count before we stop allowing new validators to join.
672	///
673	/// When this value is not set, no limits are enforced.
674	#[pallet::storage]
675	pub type MaxValidatorsCount<T> = StorageValue<_, u32, OptionQuery>;
676
677	/// Tracks the last era in which an account was active as a validator (included in the era's
678	/// exposure/snapshot).
679	///
680	/// This is used to enforce that accounts who were recently validators must wait the full
681	/// [`Config::BondingDuration`] before their funds can be withdrawn, even if they switch to
682	/// nominator role. This prevents validators from:
683	/// 1. Committing a slashable offence in era N
684	/// 2. Switching to nominator role
685	/// 3. Using the shorter nominator unbonding duration to withdraw funds before being slashed
686	///
687	/// Updated when era snapshots are created (in `ErasStakersPaged`/`ErasStakersOverview`).
688	/// Cleaned up when the stash is killed (fully withdrawn/reaped).
689	#[pallet::storage]
690	pub type LastValidatorEra<T: Config> = StorageMap<_, Twox64Concat, T::AccountId, EraIndex>;
691
692	/// The map from nominator stash key to their nomination preferences, namely the validators that
693	/// they wish to support.
694	///
695	/// Note that the keys of this storage map might become non-decodable in case the
696	/// account's [`NominationsQuota::MaxNominations`] configuration is decreased.
697	/// In this rare case, these nominators
698	/// are still existent in storage, their key is correct and retrievable (i.e. `contains_key`
699	/// indicates that they exist), but their value cannot be decoded. Therefore, the non-decodable
700	/// nominators will effectively not-exist, until they re-submit their preferences such that it
701	/// is within the bounds of the newly set `Config::MaxNominations`.
702	///
703	/// This implies that `::iter_keys().count()` and `::iter().count()` might return different
704	/// values for this map. Moreover, the main `::count()` is aligned with the former, namely the
705	/// number of keys that exist.
706	///
707	/// Lastly, if any of the nominators become non-decodable, they can be chilled immediately via
708	/// [`Call::chill_other`] dispatchable by anyone.
709	///
710	/// TWOX-NOTE: SAFE since `AccountId` is a secure hash.
711	#[pallet::storage]
712	pub type Nominators<T: Config> =
713		CountedStorageMap<_, Twox64Concat, T::AccountId, Nominations<T>>;
714
715	/// Stakers whose funds are managed by other pallets.
716	///
717	/// This pallet does not apply any locks on them, therefore they are only virtually bonded. They
718	/// are expected to be keyless accounts and hence should not be allowed to mutate their ledger
719	/// directly via this pallet. Instead, these accounts are managed by other pallets and accessed
720	/// via low level apis. We keep track of them to do minimal integrity checks.
721	#[pallet::storage]
722	pub type VirtualStakers<T: Config> = CountedStorageMap<_, Twox64Concat, T::AccountId, ()>;
723
724	/// The maximum nominator count before we stop allowing new validators to join.
725	///
726	/// When this value is not set, no limits are enforced.
727	#[pallet::storage]
728	pub type MaxNominatorsCount<T> = StorageValue<_, u32, OptionQuery>;
729
730	// --- AUDIT NOTE: the following storage items should only be controlled by `Rotator`
731
732	/// The current planned era index.
733	///
734	/// This is the latest planned era, depending on how the Session pallet queues the validator
735	/// set, it might be active or not.
736	#[pallet::storage]
737	pub type CurrentEra<T> = StorageValue<_, EraIndex>;
738
739	/// The active era information, it holds index and start.
740	///
741	/// The active era is the era being currently rewarded. Validator set of this era must be
742	/// equal to what is RC's session pallet.
743	#[pallet::storage]
744	pub type ActiveEra<T> = StorageValue<_, ActiveEraInfo>;
745
746	/// Custom bound for [`BondedEras`] which is equal to [`Config::BondingDuration`] + 1.
747	pub struct BondedErasBound<T>(core::marker::PhantomData<T>);
748	impl<T: Config> Get<u32> for BondedErasBound<T> {
749		fn get() -> u32 {
750			T::BondingDuration::get().saturating_add(1)
751		}
752	}
753
754	const OFFENCE_QUEUE_ERAS_BOUND: u32 = 10;
755	/// Custom bound for [`OffenceQueueEras`] which is equal to `Config::BondingDuration +
756	/// OFFENCE_QUEUE_ERAS_BOUND`.
757	pub struct OffenceQueueErasBound<T>(core::marker::PhantomData<T>);
758	impl<T: Config> Get<u32> for OffenceQueueErasBound<T> {
759		fn get() -> u32 {
760			let bonding_duration = T::BondingDuration::get();
761			bonding_duration.saturating_add(OFFENCE_QUEUE_ERAS_BOUND) // adding OFFENCE_QUEUE_ERAS_BOUND eras
762			                                                 // to add headroom to
763			                                                 // the bound for runtime upgrades that
764			                                                 // lower BondingDuration so we avoid
765			                                                 // the try_into trap.
766		}
767	}
768
769	/// A mapping from still-bonded eras to the first session index of that era.
770	///
771	/// Must contains information for eras for the range:
772	/// `[active_era - bounding_duration; active_era]`
773	#[pallet::storage]
774	pub type BondedEras<T: Config> =
775		StorageValue<_, BoundedVec<(EraIndex, SessionIndex), BondedErasBound<T>>, ValueQuery>;
776
777	// --- AUDIT Note: end of storage items controlled by `Rotator`.
778
779	/// Summary of validator exposure at a given era.
780	///
781	/// This contains the total stake in support of the validator and their own stake. In addition,
782	/// it can also be used to get the number of nominators backing this validator and the number of
783	/// exposure pages they are divided into. The page count is useful to determine the number of
784	/// pages of rewards that needs to be claimed.
785	///
786	/// This is keyed first by the era index to allow bulk deletion and then the stash account.
787	/// Should only be accessed through `Eras`.
788	///
789	/// Is it removed after [`Config::HistoryDepth`] eras.
790	/// If stakers hasn't been set or has been removed then empty overview is returned.
791	#[pallet::storage]
792	pub type ErasStakersOverview<T: Config> = StorageDoubleMap<
793		_,
794		Twox64Concat,
795		EraIndex,
796		Twox64Concat,
797		T::AccountId,
798		PagedExposureMetadata<BalanceOf<T>>,
799		OptionQuery,
800	>;
801
802	/// A bounded wrapper for [`sp_staking::ExposurePage`].
803	///
804	/// It has `Deref` and `DerefMut` impls that map it back [`sp_staking::ExposurePage`] for all
805	/// purposes. This is done in such a way because we prefer to keep the types in [`sp_staking`]
806	/// pure, and not polluted by pallet-specific bounding logic.
807	///
808	/// It encoded and decodes exactly the same as [`sp_staking::ExposurePage`], and provides a
809	/// manual `MaxEncodedLen` implementation, to be used in benchmarking
810	#[derive(PartialEqNoBound, Encode, Decode, DebugNoBound, TypeInfo, DefaultNoBound)]
811	#[scale_info(skip_type_params(T))]
812	pub struct BoundedExposurePage<T: Config>(pub ExposurePage<T::AccountId, BalanceOf<T>>);
813	impl<T: Config> Deref for BoundedExposurePage<T> {
814		type Target = ExposurePage<T::AccountId, BalanceOf<T>>;
815
816		fn deref(&self) -> &Self::Target {
817			&self.0
818		}
819	}
820
821	impl<T: Config> core::ops::DerefMut for BoundedExposurePage<T> {
822		fn deref_mut(&mut self) -> &mut Self::Target {
823			&mut self.0
824		}
825	}
826
827	impl<T: Config> codec::MaxEncodedLen for BoundedExposurePage<T> {
828		fn max_encoded_len() -> usize {
829			let max_exposure_page_size = T::MaxExposurePageSize::get() as usize;
830			let individual_size =
831				T::AccountId::max_encoded_len() + BalanceOf::<T>::max_encoded_len();
832
833			// 1 balance for `total`
834			BalanceOf::<T>::max_encoded_len() +
835			// individual_size multiplied by page size
836				max_exposure_page_size.saturating_mul(individual_size)
837		}
838	}
839
840	impl<T: Config> From<ExposurePage<T::AccountId, BalanceOf<T>>> for BoundedExposurePage<T> {
841		fn from(value: ExposurePage<T::AccountId, BalanceOf<T>>) -> Self {
842			Self(value)
843		}
844	}
845
846	impl<T: Config> From<BoundedExposurePage<T>> for ExposurePage<T::AccountId, BalanceOf<T>> {
847		fn from(value: BoundedExposurePage<T>) -> Self {
848			value.0
849		}
850	}
851
852	impl<T: Config> codec::EncodeLike<BoundedExposurePage<T>>
853		for ExposurePage<T::AccountId, BalanceOf<T>>
854	{
855	}
856
857	/// Paginated exposure of a validator at given era.
858	///
859	/// This is keyed first by the era index to allow bulk deletion, then stash account and finally
860	/// the page. Should only be accessed through `Eras`.
861	///
862	/// This is cleared after [`Config::HistoryDepth`] eras.
863	#[pallet::storage]
864	pub type ErasStakersPaged<T: Config> = StorageNMap<
865		_,
866		(
867			NMapKey<Twox64Concat, EraIndex>,
868			NMapKey<Twox64Concat, T::AccountId>,
869			NMapKey<Twox64Concat, Page>,
870		),
871		BoundedExposurePage<T>,
872		OptionQuery,
873	>;
874
875	pub struct ClaimedRewardsBound<T>(core::marker::PhantomData<T>);
876	impl<T: Config> Get<u32> for ClaimedRewardsBound<T> {
877		fn get() -> u32 {
878			let max_total_nominators_per_validator =
879				<T::ElectionProvider as ElectionProvider>::MaxBackersPerWinnerFinal::get();
880			let exposure_page_size = T::MaxExposurePageSize::get();
881			max_total_nominators_per_validator
882				.saturating_div(exposure_page_size)
883				.saturating_add(1)
884		}
885	}
886
887	/// History of claimed paged rewards by era and validator.
888	///
889	/// This is keyed by era and validator stash which maps to the set of page indexes which have
890	/// been claimed.
891	///
892	/// It is removed after [`Config::HistoryDepth`] eras.
893	#[pallet::storage]
894	pub type ClaimedRewards<T: Config> = StorageDoubleMap<
895		_,
896		Twox64Concat,
897		EraIndex,
898		Twox64Concat,
899		T::AccountId,
900		WeakBoundedVec<Page, ClaimedRewardsBound<T>>,
901		ValueQuery,
902	>;
903
904	/// Exposure of validator at era with the preferences of validators.
905	///
906	/// This is keyed first by the era index to allow bulk deletion and then the stash account.
907	///
908	/// Is it removed after [`Config::HistoryDepth`] eras.
909	// If prefs hasn't been set or has been removed then 0 commission is returned.
910	#[pallet::storage]
911	pub type ErasValidatorPrefs<T: Config> = StorageDoubleMap<
912		_,
913		Twox64Concat,
914		EraIndex,
915		Twox64Concat,
916		T::AccountId,
917		ValidatorPrefs,
918		ValueQuery,
919	>;
920
921	/// The total staker reward budget for each era within [`Config::HistoryDepth`].
922	///
923	/// Set at era finalization:
924	/// - in non-minting mode this is the snapshot of the era pot balance before any payouts.
925	/// - in legacy mode it comes from `EraPayout`, with rewards minted on the fly.
926	#[pallet::storage]
927	pub type ErasValidatorReward<T: Config> = StorageMap<_, Twox64Concat, EraIndex, BalanceOf<T>>;
928
929	/// Rewards for the last [`Config::HistoryDepth`] eras.
930	/// If reward hasn't been set or has been removed then 0 reward is returned.
931	///
932	/// The same points split by the service that earned them are in [`ErasRewardPointsByService`].
933	/// This pot is essentially the _total_ points earned by the validator.
934	#[pallet::storage]
935	pub type ErasRewardPoints<T: Config> =
936		StorageMap<_, Twox64Concat, EraIndex, EraRewardPoints<T>, ValueQuery>;
937
938	/// The points of [`ErasRewardPoints`] split by the service that earned them.
939	///
940	/// Values are era points as credited, in the same unit as [`ErasRewardPoints`]. A service
941	/// measured in other units, such as blocks authored, is converted to points before it is
942	/// credited. Written with [`ErasRewardPoints`] and pruned with it. An entry never holds more
943	/// than the tally does for the same account.
944	#[pallet::storage]
945	pub type ErasRewardPointsByService<T: Config> = StorageDoubleMap<
946		_,
947		Twox64Concat,
948		EraIndex,
949		Twox64Concat,
950		ServiceKind,
951		EraRewardPoints<T>,
952		ValueQuery,
953	>;
954
955	/// The total amount staked for the last [`Config::HistoryDepth`] eras.
956	/// If total hasn't been set or has been removed then 0 stake is returned.
957	#[pallet::storage]
958	pub type ErasTotalStake<T: Config> =
959		StorageMap<_, Twox64Concat, EraIndex, BalanceOf<T>, ValueQuery>;
960
961	/// Mode of era forcing.
962	#[pallet::storage]
963	pub type ForceEra<T> = StorageValue<_, Forcing, ValueQuery>;
964
965	/// Maximum staked rewards, i.e. the percentage of the era inflation that
966	/// is used for stake rewards.
967	///
968	/// Only used in legacy minting mode (`DisableMinting = false`).
969	#[pallet::storage]
970	pub type MaxStakedRewards<T> = StorageValue<_, Percent, OptionQuery>;
971
972	/// The percentage of the slash that is distributed to reporters.
973	///
974	/// The rest of the slashed value is handled by the `Slash`.
975	#[pallet::storage]
976	pub type SlashRewardFraction<T> = StorageValue<_, Perbill, ValueQuery>;
977
978	/// The amount of currency given to reporters of a slash event which was
979	/// canceled by extraordinary circumstances (e.g. governance).
980	#[pallet::storage]
981	pub type CanceledSlashPayout<T: Config> = StorageValue<_, BalanceOf<T>, ValueQuery>;
982
983	/// Stores reported offences in a queue until they are processed in subsequent blocks.
984	///
985	/// Each offence is recorded under the corresponding era index and the offending validator's
986	/// account. If an offence spans multiple pages, only one page is processed at a time. Offences
987	/// are handled sequentially, with their associated slashes computed and stored in
988	/// `UnappliedSlashes`. These slashes are then applied in a future era as determined by
989	/// `SlashDeferDuration`.
990	///
991	/// Any offences tied to an era older than `BondingDuration` are automatically dropped.
992	/// Processing always prioritizes the oldest era first.
993	#[pallet::storage]
994	pub type OffenceQueue<T: Config> = StorageDoubleMap<
995		_,
996		Twox64Concat,
997		EraIndex,
998		Twox64Concat,
999		T::AccountId,
1000		slashing::OffenceRecord<T::AccountId>,
1001	>;
1002
1003	/// Tracks the eras that contain offences in `OffenceQueue`, sorted from **earliest to latest**.
1004	///
1005	/// - This ensures efficient retrieval of the oldest offence without iterating through
1006	/// `OffenceQueue`.
1007	/// - When a new offence is added to `OffenceQueue`, its era is **inserted in sorted order**
1008	/// if not already present.
1009	/// - When all offences for an era are processed, it is **removed** from this list.
1010	/// - The maximum length of this vector is bounded by `BondingDuration +
1011	///   OFFENCE_QUEUE_ERAS_BOUND`.
1012	///
1013	/// This eliminates the need for expensive iteration and sorting when fetching the next offence
1014	/// to process.
1015	#[pallet::storage]
1016	pub type OffenceQueueEras<T: Config> =
1017		StorageValue<_, WeakBoundedVec<u32, OffenceQueueErasBound<T>>>;
1018
1019	/// Tracks the currently processed offence record from the `OffenceQueue`.
1020	///
1021	/// - When processing offences, an offence record is **popped** from the oldest era in
1022	///   `OffenceQueue` and stored here.
1023	/// - The function `process_offence` reads from this storage, processing one page of exposure at
1024	///   a time.
1025	/// - After processing a page, the `exposure_page` count is **decremented** until it reaches
1026	///   zero.
1027	/// - Once fully processed, the offence record is removed from this storage.
1028	///
1029	/// This ensures that offences are processed incrementally, preventing excessive computation
1030	/// in a single block while maintaining correct slashing behavior.
1031	#[pallet::storage]
1032	pub type ProcessingOffence<T: Config> =
1033		StorageValue<_, (EraIndex, T::AccountId, slashing::OffenceRecord<T::AccountId>)>;
1034
1035	/// All unapplied slashes that are queued for later.
1036	#[pallet::storage]
1037	pub type UnappliedSlashes<T: Config> = StorageDoubleMap<
1038		_,
1039		Twox64Concat,
1040		EraIndex,
1041		Twox64Concat,
1042		// Unique key for unapplied slashes: (validator, slash fraction, page index).
1043		(T::AccountId, Perbill, u32),
1044		UnappliedSlash<T>,
1045		OptionQuery,
1046	>;
1047
1048	/// Cancelled slashes by era and validator with maximum slash fraction to be cancelled.
1049	///
1050	/// When slashes are cancelled by governance, this stores the era and the validators
1051	/// whose slashes should be cancelled, along with the maximum slash fraction that should
1052	/// be cancelled for each validator.
1053	#[pallet::storage]
1054	pub type CancelledSlashes<T: Config> = StorageMap<
1055		_,
1056		Twox64Concat,
1057		EraIndex,
1058		BoundedVec<(T::AccountId, Perbill), T::MaxValidatorSet>,
1059		ValueQuery,
1060	>;
1061
1062	/// All slashing events on validators, mapped by era to the highest slash proportion
1063	/// and slash value of the era.
1064	#[pallet::storage]
1065	pub type ValidatorSlashInEra<T: Config> = StorageDoubleMap<
1066		_,
1067		Twox64Concat,
1068		EraIndex,
1069		Twox64Concat,
1070		T::AccountId,
1071		(Perbill, BalanceOf<T>),
1072	>;
1073
1074	/// The threshold for when users can start calling `chill_other` for other validators /
1075	/// nominators. The threshold is compared to the actual number of validators / nominators
1076	/// (`CountFor*`) in the system compared to the configured max (`Max*Count`).
1077	#[pallet::storage]
1078	pub type ChillThreshold<T: Config> = StorageValue<_, Percent, OptionQuery>;
1079
1080	/// Voter snapshot progress status.
1081	///
1082	/// If the status is `Ongoing`, it keeps a cursor of the last voter retrieved to proceed when
1083	/// creating the next snapshot page.
1084	#[pallet::storage]
1085	pub type VoterSnapshotStatus<T: Config> =
1086		StorageValue<_, SnapshotStatus<T::AccountId>, ValueQuery>;
1087
1088	/// Keeps track of an ongoing multi-page election solution request.
1089	///
1090	/// If `Some(_)``, it is the next page that we intend to elect. If `None`, we are not in the
1091	/// election process.
1092	///
1093	/// This is only set in multi-block elections. Should always be `None` otherwise.
1094	#[pallet::storage]
1095	pub type NextElectionPage<T: Config> = StorageValue<_, PageIndex, OptionQuery>;
1096
1097	/// A bounded list of the "electable" stashes that resulted from a successful election.
1098	#[pallet::storage]
1099	pub type ElectableStashes<T: Config> =
1100		StorageValue<_, BoundedBTreeSet<T::AccountId, T::MaxValidatorSet>, ValueQuery>;
1101
1102	/// The validators elected for the planned era, kept from the moment its election completes
1103	/// until the era starts, for [`Config::OnEraStart`].
1104	///
1105	/// Only written when [`OnEraStart::enabled`] is true, and removed at the start of its era
1106	/// whether or not the hook is still enabled. An era whose election completed before the hook
1107	/// was enabled has no copy and is not notified.
1108	#[pallet::storage]
1109	pub type NextEraValidators<T: Config> =
1110		StorageValue<_, (EraIndex, BoundedVec<T::AccountId, T::MaxValidatorSet>), OptionQuery>;
1111
1112	/// Tracks the current step of era pruning process for each era being lazily pruned.
1113	#[pallet::storage]
1114	pub type EraPruningState<T: Config> = StorageMap<_, Twox64Concat, EraIndex, PruningStep>;
1115
1116	/// The number of eras a validator can remain inactive during the last
1117	/// [`Config::HistoryDepth`] before being subject to chilling because of inactivity.
1118	///
1119	/// This must be less than or equal [`Config::HistoryDepth`] and bigger than 1. The weight of
1120	/// `chill_inactive` with a proof of this length must fit in one normal extrinsic.
1121	///
1122	/// If `None`, the default, `chill_inactive` is disabled.
1123	#[pallet::storage]
1124	pub type ChillInactiveThreshold<T: Config> = StorageValue<_, u32, OptionQuery>;
1125
1126	#[pallet::genesis_config]
1127	#[derive(frame_support::DefaultNoBound, frame_support::DebugNoBound)]
1128	pub struct GenesisConfig<T: Config> {
1129		pub validator_count: u32,
1130		pub force_era: Forcing,
1131		pub slash_reward_fraction: Perbill,
1132		pub canceled_payout: BalanceOf<T>,
1133		pub stakers: Vec<(T::AccountId, BalanceOf<T>, crate::StakerStatus<T::AccountId>)>,
1134		pub min_nominator_bond: BalanceOf<T>,
1135		pub min_validator_bond: BalanceOf<T>,
1136		pub max_validator_count: Option<u32>,
1137		pub max_nominator_count: Option<u32>,
1138		/// Create the given number of validators and nominators.
1139		///
1140		/// These account need not be in the endowment list of balances, and are auto-topped up
1141		/// here.
1142		///
1143		/// Useful for testing genesis config.
1144		pub dev_stakers: Option<(u32, u32)>,
1145		/// initial active era, corresponding session index and start timestamp.
1146		pub active_era: (u32, u32, u64),
1147	}
1148
1149	impl<T: Config> GenesisConfig<T> {
1150		fn generate_endowed_bonded_account(derivation: &str, rng: &mut ChaChaRng) -> T::AccountId {
1151			let pair: SrPair = Pair::from_string(&derivation, None)
1152				.expect(&format!("Failed to parse derivation string: {derivation}"));
1153			let who = T::AccountId::decode(&mut &pair.public().encode()[..])
1154				.expect(&format!("Failed to decode public key from pair: {:?}", pair.public()));
1155
1156			let (min, max) = T::VoterList::range();
1157			let stake = BalanceOf::<T>::from(rng.next_u64().min(max).max(min));
1158			let two: BalanceOf<T> = 2u32.into();
1159
1160			assert_ok!(T::Currency::mint_into(&who, stake * two));
1161			assert_ok!(<Pallet<T>>::bond(
1162				T::RuntimeOrigin::from(Some(who.clone()).into()),
1163				stake,
1164				RewardDestination::Staked,
1165			));
1166			who
1167		}
1168	}
1169
1170	#[pallet::genesis_build]
1171	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
1172		fn build(&self) {
1173			crate::log!(trace, "initializing with {:?}", self);
1174			assert!(
1175				self.validator_count <=
1176					<T::ElectionProvider as ElectionProvider>::MaxWinnersPerPage::get() *
1177						<T::ElectionProvider as ElectionProvider>::Pages::get(),
1178				"validator count is too high, `ElectionProvider` can never fulfill this"
1179			);
1180			ValidatorCount::<T>::put(self.validator_count);
1181
1182			ForceEra::<T>::put(self.force_era);
1183			CanceledSlashPayout::<T>::put(self.canceled_payout);
1184			SlashRewardFraction::<T>::put(self.slash_reward_fraction);
1185			MinNominatorBond::<T>::put(self.min_nominator_bond);
1186			MinValidatorBond::<T>::put(self.min_validator_bond);
1187			if let Some(x) = self.max_validator_count {
1188				MaxValidatorsCount::<T>::put(x);
1189			}
1190			if let Some(x) = self.max_nominator_count {
1191				MaxNominatorsCount::<T>::put(x);
1192			}
1193
1194			// First pass: set up all validators and idle stakers
1195			for &(ref stash, balance, ref status) in &self.stakers {
1196				match status {
1197					crate::StakerStatus::Validator => {
1198						crate::log!(
1199							trace,
1200							"inserting genesis validator: {:?} => {:?} => {:?}",
1201							stash,
1202							balance,
1203							status
1204						);
1205						assert!(
1206							asset::free_to_stake::<T>(stash) >= balance,
1207							"Stash does not have enough balance to bond."
1208						);
1209						assert_ok!(<Pallet<T>>::bond(
1210							T::RuntimeOrigin::from(Some(stash.clone()).into()),
1211							balance,
1212							RewardDestination::Staked,
1213						));
1214						assert_ok!(<Pallet<T>>::validate(
1215							T::RuntimeOrigin::from(Some(stash.clone()).into()),
1216							Default::default(),
1217						));
1218					},
1219					crate::StakerStatus::Idle => {
1220						crate::log!(
1221							trace,
1222							"inserting genesis idle staker: {:?} => {:?} => {:?}",
1223							stash,
1224							balance,
1225							status
1226						);
1227						assert!(
1228							asset::free_to_stake::<T>(stash) >= balance,
1229							"Stash does not have enough balance to bond."
1230						);
1231						assert_ok!(<Pallet<T>>::bond(
1232							T::RuntimeOrigin::from(Some(stash.clone()).into()),
1233							balance,
1234							RewardDestination::Staked,
1235						));
1236					},
1237					_ => {},
1238				}
1239			}
1240
1241			// Second pass: set up all nominators (now that validators exist)
1242			for &(ref stash, balance, ref status) in &self.stakers {
1243				match status {
1244					crate::StakerStatus::Nominator(votes) => {
1245						crate::log!(
1246							trace,
1247							"inserting genesis nominator: {:?} => {:?} => {:?}",
1248							stash,
1249							balance,
1250							status
1251						);
1252						assert!(
1253							asset::free_to_stake::<T>(stash) >= balance,
1254							"Stash does not have enough balance to bond."
1255						);
1256						assert_ok!(<Pallet<T>>::bond(
1257							T::RuntimeOrigin::from(Some(stash.clone()).into()),
1258							balance,
1259							RewardDestination::Staked,
1260						));
1261						assert_ok!(<Pallet<T>>::nominate(
1262							T::RuntimeOrigin::from(Some(stash.clone()).into()),
1263							votes.iter().map(|l| T::Lookup::unlookup(l.clone())).collect(),
1264						));
1265					},
1266					_ => {},
1267				}
1268			}
1269
1270			// all voters are reported to the `VoterList`.
1271			assert_eq!(
1272				T::VoterList::count(),
1273				Nominators::<T>::count() + Validators::<T>::count(),
1274				"not all genesis stakers were inserted into sorted list provider, something is wrong."
1275			);
1276
1277			// now generate the dev stakers, after all else is setup
1278			if let Some((validators, nominators)) = self.dev_stakers {
1279				crate::log!(
1280					debug,
1281					"generating dev stakers: validators: {}, nominators: {}",
1282					validators,
1283					nominators
1284				);
1285				let base_derivation = "//staker//{}";
1286
1287				// it is okay for the randomness to be the same on every call. If we want different,
1288				// we can make `base_derivation` configurable.
1289				let mut rng = ChaChaRng::from_seed(
1290					base_derivation.using_encoded(sp_crypto_hashing::blake2_256),
1291				);
1292
1293				(0..validators).for_each(|index| {
1294					let derivation = base_derivation.replace("{}", &format!("validator{}", index));
1295					let who = Self::generate_endowed_bonded_account(&derivation, &mut rng);
1296					assert_ok!(<Pallet<T>>::validate(
1297						T::RuntimeOrigin::from(Some(who.clone()).into()),
1298						Default::default(),
1299					));
1300				});
1301
1302				// This allows us to work with configs like `dev_stakers: (0, 10)`. Don't create new
1303				// validators, just add a bunch of nominators. Useful for slashing tests.
1304				let all_validators = Validators::<T>::iter_keys().collect::<Vec<_>>();
1305
1306				(0..nominators).for_each(|index| {
1307					let derivation = base_derivation.replace("{}", &format!("nominator{}", index));
1308					let who = Self::generate_endowed_bonded_account(&derivation, &mut rng);
1309
1310					let random_nominations = all_validators
1311						.choose_multiple(&mut rng, MaxNominationsOf::<T>::get() as usize)
1312						.map(|v| v.clone())
1313						.collect::<Vec<_>>();
1314
1315					assert_ok!(<Pallet<T>>::nominate(
1316						T::RuntimeOrigin::from(Some(who.clone()).into()),
1317						random_nominations.iter().map(|l| T::Lookup::unlookup(l.clone())).collect(),
1318					));
1319				})
1320			}
1321
1322			// Chains initialized with this storage item maintain `ErasSumWeightedPoints` from
1323			// era 0. Pin the cutoff to the first era so every era uses the weighted-points formula
1324			// and the idempotent migration only acts on chains whose storage predates this item.
1325			WeightedPointsFormulaStartEra::<T>::put(0);
1326
1327			let (active_era, session_index, timestamp) = self.active_era;
1328			ActiveEra::<T>::put(ActiveEraInfo { index: active_era, start: Some(timestamp) });
1329			// at genesis, we do not have any new planned era.
1330			CurrentEra::<T>::put(active_era);
1331			// set the bonded genesis era
1332			BondedEras::<T>::put(
1333				BoundedVec::<_, BondedErasBound<T>>::try_from(
1334					alloc::vec![(active_era, session_index)]
1335				)
1336				.expect("bound for BondedEras is BondingDuration + 1; can contain at least one element; qed")
1337			);
1338		}
1339	}
1340
1341	#[pallet::event]
1342	#[pallet::generate_deposit(pub fn deposit_event)]
1343	pub enum Event<T: Config> {
1344		/// The era payout has been set.
1345		///
1346		/// In non-minting mode, `validator_payout` is the staker reward budget
1347		/// snapshotted from the general pot, and `remainder` is always zero.
1348		/// In legacy minting mode, both fields reflect the `EraPayout` computation.
1349		EraPaid {
1350			era_index: EraIndex,
1351			validator_payout: BalanceOf<T>,
1352			remainder: BalanceOf<T>,
1353		},
1354		/// The nominator has been rewarded by this amount to this destination.
1355		Rewarded {
1356			stash: T::AccountId,
1357			dest: RewardDestination<T::AccountId>,
1358			amount: BalanceOf<T>,
1359		},
1360		/// A staker (validator or nominator) has been slashed by the given amount.
1361		Slashed {
1362			staker: T::AccountId,
1363			amount: BalanceOf<T>,
1364		},
1365		/// An old slashing report from a prior era was discarded because it could
1366		/// not be processed.
1367		OldSlashingReportDiscarded {
1368			session_index: SessionIndex,
1369		},
1370		/// An account has bonded this amount. \[stash, amount\]
1371		///
1372		/// NOTE: This event is only emitted when funds are bonded via a dispatchable. Notably,
1373		/// it will not be emitted for staking rewards when they are added to stake.
1374		Bonded {
1375			stash: T::AccountId,
1376			amount: BalanceOf<T>,
1377		},
1378		/// An account has unbonded this amount.
1379		Unbonded {
1380			stash: T::AccountId,
1381			amount: BalanceOf<T>,
1382			/// The era at which `amount` becomes withdrawable.
1383			era: EraIndex,
1384		},
1385		/// An account has called `withdraw_unbonded` and removed unbonding chunks worth `Balance`
1386		/// from the unlocking queue.
1387		Withdrawn {
1388			stash: T::AccountId,
1389			amount: BalanceOf<T>,
1390		},
1391		/// A subsequent event of `Withdrawn`, indicating that `stash` was fully removed from the
1392		/// system.
1393		StakerRemoved {
1394			stash: T::AccountId,
1395		},
1396		/// A nominator has been kicked from a validator.
1397		Kicked {
1398			nominator: T::AccountId,
1399			stash: T::AccountId,
1400		},
1401		/// An account has stopped participating as either a validator or nominator.
1402		Chilled {
1403			stash: T::AccountId,
1404		},
1405		/// A Page of stakers rewards are getting paid. `next` is `None` if all pages are claimed.
1406		PayoutStarted {
1407			era_index: EraIndex,
1408			validator_stash: T::AccountId,
1409			page: Page,
1410			next: Option<Page>,
1411		},
1412		/// A validator has set their preferences.
1413		ValidatorPrefsSet {
1414			stash: T::AccountId,
1415			prefs: ValidatorPrefs,
1416		},
1417		/// Voters size limit reached.
1418		SnapshotVotersSizeExceeded {
1419			size: u32,
1420		},
1421		/// Targets size limit reached.
1422		SnapshotTargetsSizeExceeded {
1423			size: u32,
1424		},
1425		ForceEra {
1426			mode: Forcing,
1427		},
1428		/// Report of a controller batch deprecation.
1429		ControllerBatchDeprecated {
1430			failures: u32,
1431		},
1432		/// Staking balance migrated from locks to holds, with any balance that could not be held
1433		/// is force withdrawn.
1434		CurrencyMigrated {
1435			stash: T::AccountId,
1436			force_withdraw: BalanceOf<T>,
1437		},
1438		/// A page from a multi-page election was fetched. A number of these are followed by
1439		/// `StakersElected`.
1440		///
1441		/// `Ok(count)` indicates the give number of stashes were added.
1442		/// `Err(index)` indicates that the stashes after index were dropped.
1443		/// `Err(0)` indicates that an error happened but no stashes were dropped nor added.
1444		///
1445		/// The error indicates that a number of validators were dropped due to excess size, but
1446		/// the overall election will continue.
1447		PagedElectionProceeded {
1448			page: PageIndex,
1449			result: Result<u32, u32>,
1450		},
1451		/// An offence for the given validator, for the given percentage of their stake, at the
1452		/// given era as been reported.
1453		OffenceReported {
1454			offence_era: EraIndex,
1455			validator: T::AccountId,
1456			fraction: Perbill,
1457		},
1458		/// An offence has been processed and the corresponding slash has been computed.
1459		SlashComputed {
1460			offence_era: EraIndex,
1461			slash_era: EraIndex,
1462			offender: T::AccountId,
1463			page: u32,
1464		},
1465		/// An unapplied slash has been cancelled.
1466		SlashCancelled {
1467			slash_era: EraIndex,
1468			validator: T::AccountId,
1469		},
1470		/// Session change has been triggered.
1471		///
1472		/// If planned_era is one era ahead of active_era, it implies new era is being planned and
1473		/// election is ongoing.
1474		SessionRotated {
1475			starting_session: SessionIndex,
1476			active_era: EraIndex,
1477			planned_era: EraIndex,
1478		},
1479		/// Something occurred that should never happen under normal operation.
1480		/// Logged as an event for fail-safe observability.
1481		Unexpected(UnexpectedKind<T>),
1482		/// An offence was reported that was too old to be processed, and thus was dropped.
1483		OffenceTooOld {
1484			offence_era: EraIndex,
1485			validator: T::AccountId,
1486			fraction: Perbill,
1487		},
1488		/// An old era with the given index was pruned.
1489		EraPruned {
1490			index: EraIndex,
1491		},
1492		/// The validator has been paid their self-stake incentive bonus.
1493		ValidatorIncentivePaid {
1494			era: EraIndex,
1495			validator_stash: T::AccountId,
1496			dest: RewardDestination<T::AccountId>,
1497			amount: BalanceOf<T>,
1498		},
1499		/// Validator self-stake incentive configuration has been updated.
1500		ValidatorIncentiveConfigSet {
1501			optimum_self_stake: BalanceOf<T>,
1502			hard_cap_self_stake: BalanceOf<T>,
1503			slope_factor: Perbill,
1504		},
1505		/// Points earned for `service` were credited to `era`. `credited` entries were exposed in
1506		/// `era` and `dropped` entries were not.
1507		ServicePointsCredited {
1508			service: ServiceKind,
1509			era: EraIndex,
1510			credited: u32,
1511			dropped: u32,
1512		},
1513	}
1514
1515	/// Represents unexpected or invariant-breaking conditions encountered during execution.
1516	///
1517	/// These variants are emitted as [`Event::Unexpected`] and indicate a defensive check has
1518	/// failed. While these should never occur under normal operation, they are useful for
1519	/// diagnosing issues in production or test environments.
1520	#[derive(Clone, Encode, Decode, DecodeWithMemTracking, PartialEq, TypeInfo, DebugNoBound)]
1521	#[codec(mel_bound())]
1522	#[scale_info(skip_type_params(T))]
1523	pub enum UnexpectedKind<T: Config> {
1524		/// Emitted when calculated era duration exceeds the configured maximum.
1525		EraDurationBoundExceeded,
1526		/// Received a validator activation event that is not recognized.
1527		UnknownValidatorActivation,
1528		/// Failed to proceed paged election due to weight limits
1529		PagedElectionOutOfWeight { page: PageIndex, required: Weight, had: Weight },
1530		/// Payee not set for a staker when paying rewards.
1531		MissingPayee { era: EraIndex, stash: T::AccountId },
1532		/// Total validator weight is zero but incentive allocation exists.
1533		ValidatorIncentiveWeightMismatch { era: EraIndex },
1534		/// Validator incentive transfer from era pot failed.
1535		ValidatorIncentiveTransferFailed { era: EraIndex },
1536	}
1537
1538	#[pallet::error]
1539	#[derive(PartialEq)]
1540	pub enum Error<T> {
1541		/// Not a controller account.
1542		NotController,
1543		/// Not a stash account.
1544		NotStash,
1545		/// Stash is already bonded.
1546		AlreadyBonded,
1547		/// Controller is already paired.
1548		AlreadyPaired,
1549		/// Targets cannot be empty.
1550		EmptyTargets,
1551		/// Duplicate index.
1552		DuplicateIndex,
1553		/// Slash record not found.
1554		InvalidSlashRecord,
1555		/// Cannot bond, nominate or validate with value less than the minimum defined by
1556		/// governance (see `MinValidatorBond` and `MinNominatorBond`). If unbonding is the
1557		/// intention, `chill` first to remove one's role as validator/nominator.
1558		InsufficientBond,
1559		/// Can not schedule more unlock chunks.
1560		NoMoreChunks,
1561		/// Can not rebond without unlocking chunks.
1562		NoUnlockChunk,
1563		/// Attempting to target a stash that still has funds.
1564		FundedTarget,
1565		/// Invalid era to reward.
1566		InvalidEraToReward,
1567		/// Invalid number of nominations.
1568		InvalidNumberOfNominations,
1569		/// Rewards for this era have already been claimed for this validator.
1570		AlreadyClaimed,
1571		/// No nominators exist on this page.
1572		InvalidPage,
1573		/// Incorrect previous history depth input provided.
1574		IncorrectHistoryDepth,
1575		/// Internal state has become somehow corrupted and the operation cannot continue.
1576		BadState,
1577		/// Too many nomination targets supplied.
1578		TooManyTargets,
1579		/// A nomination target was supplied that was blocked or otherwise not a validator.
1580		BadTarget,
1581		/// The user has enough bond and thus cannot be chilled forcefully by an external person.
1582		CannotChillOther,
1583		/// There are too many nominators in the system. Governance needs to adjust the staking
1584		/// settings to keep things safe for the runtime.
1585		TooManyNominators,
1586		/// There are too many validator candidates in the system. Governance needs to adjust the
1587		/// staking settings to keep things safe for the runtime.
1588		TooManyValidators,
1589		/// Commission is too low. Must be at least `MinCommission`.
1590		CommissionTooLow,
1591		/// Some bound is not met.
1592		BoundNotMet,
1593		/// Used when attempting to use deprecated controller account logic.
1594		ControllerDeprecated,
1595		/// Cannot reset a ledger.
1596		CannotRestoreLedger,
1597		/// Provided reward destination is not allowed.
1598		RewardDestinationRestricted,
1599		/// Not enough funds available to withdraw.
1600		NotEnoughFunds,
1601		/// Operation not allowed for virtual stakers.
1602		VirtualStakerNotAllowed,
1603		/// Stash could not be reaped as other pallet might depend on it.
1604		CannotReapStash,
1605		/// The stake of this account is already migrated to `Fungible` holds.
1606		AlreadyMigrated,
1607		/// Era not yet started.
1608		EraNotStarted,
1609		/// Account is restricted from participation in staking. This may happen if the account is
1610		/// staking in another way already, such as via pool.
1611		Restricted,
1612		/// Unapplied slashes in the recently concluded era is blocking this operation.
1613		/// See `Call::apply_slash` to apply them.
1614		UnappliedSlashesInPreviousEra,
1615		/// The era is not eligible for pruning.
1616		EraNotPrunable,
1617		/// The slash has been cancelled and cannot be applied.
1618		CancelledSlash,
1619		/// Commission is higher than the allowed maximum `MaxCommission`.
1620		CommissionTooHigh,
1621		/// Optimum self-stake cannot be greater than hard cap.
1622		OptimumGreaterThanCap,
1623		/// Validator inactivity proof is invalid.
1624		InvalidInactivityProof(InvalidInactivityProofError),
1625		/// Cannot set [`ChillInactiveThreshold`] to the provided value.
1626		InvalidChillInactiveThreshold,
1627		/// `chill_inactive` is disabled, as [`ChillInactiveThreshold`] is not set.
1628		ChillInactiveDisabled,
1629	}
1630
1631	#[derive(Encode, Decode, DecodeWithMemTracking, PartialEq, Eq, TypeInfo, PalletError)]
1632	pub enum InvalidInactivityProofError {
1633		/// Invalid proof length.
1634		InvalidLen,
1635		/// Eras in proof are not sorted.
1636		NotSorted,
1637		/// Validator wasn't expected to validate at some era.
1638		ValidatorNotExposed,
1639		/// Validator wasn't inactive at some era.
1640		ValidatorActive,
1641		/// An invalid era was provided in the proof.
1642		InvalidEra,
1643	}
1644
1645	impl<T: Config> Pallet<T> {
1646		/// Apply previously-unapplied slashes on the beginning of a new era, after a delay.
1647		pub fn apply_unapplied_slashes(active_era: EraIndex) -> Weight {
1648			let mut slashes = UnappliedSlashes::<T>::iter_prefix(&active_era).take(1);
1649			if let Some((key, slash)) = slashes.next() {
1650				crate::log!(
1651					debug,
1652					"🦹 found slash {:?} scheduled to be executed in era {:?}",
1653					slash,
1654					active_era,
1655				);
1656
1657				let nominators_slashed = slash.others.len() as u32;
1658
1659				// Check if this slash has been cancelled
1660				if Self::check_slash_cancelled(active_era, &key.0, key.1) {
1661					crate::log!(
1662						debug,
1663						"🦹 slash for {:?} in era {:?} was cancelled, skipping",
1664						key.0,
1665						active_era,
1666					);
1667				} else {
1668					slashing::apply_slash::<T>(slash, Self::offence_era_of(active_era));
1669				}
1670
1671				// Always remove the slash from UnappliedSlashes
1672				UnappliedSlashes::<T>::remove(&active_era, &key);
1673
1674				// Check if there are more slashes for this era
1675				if UnappliedSlashes::<T>::iter_prefix(&active_era).next().is_none() {
1676					// No more slashes for this era, clear CancelledSlashes
1677					CancelledSlashes::<T>::remove(&active_era);
1678				}
1679
1680				T::WeightInfo::apply_slash(nominators_slashed)
1681			} else {
1682				// No slashes found for this era
1683				T::DbWeight::get().reads(1)
1684			}
1685		}
1686
1687		/// Execute one step of era pruning and get actual weight used
1688		fn do_prune_era_step(era: EraIndex) -> Result<Weight, DispatchError> {
1689			// Get current pruning state. If EraPruningState doesn't exist, it means:
1690			// - Era was never marked for pruning, OR
1691			// - Era was already fully pruned (pruning state was removed on final step)
1692			// In either case, this is an error - user should not call prune on non-prunable eras
1693			let current_step = EraPruningState::<T>::get(era).ok_or(Error::<T>::EraNotPrunable)?;
1694
1695			// Limit items to prevent deleting more than we can safely account for in weight
1696			// calculations
1697			let items_limit = T::MaxPruningItems::get().min(T::MaxValidatorSet::get());
1698
1699			let actual_weight = match current_step {
1700				PruningStep::ErasStakersPaged => {
1701					let result = ErasStakersPaged::<T>::clear_prefix((era,), items_limit, None);
1702					let items_deleted = result.backend as u32;
1703					result.maybe_cursor.is_none().then(|| {
1704						EraPruningState::<T>::insert(era, PruningStep::ErasStakersOverview)
1705					});
1706					T::WeightInfo::prune_era_stakers_paged(items_deleted)
1707				},
1708				PruningStep::ErasStakersOverview => {
1709					let result = ErasStakersOverview::<T>::clear_prefix(era, items_limit, None);
1710					let items_deleted = result.backend as u32;
1711					result.maybe_cursor.is_none().then(|| {
1712						EraPruningState::<T>::insert(era, PruningStep::ErasValidatorPrefs)
1713					});
1714					T::WeightInfo::prune_era_stakers_overview(items_deleted)
1715				},
1716				PruningStep::ErasValidatorPrefs => {
1717					let result = ErasValidatorPrefs::<T>::clear_prefix(era, items_limit, None);
1718					let items_deleted = result.backend as u32;
1719					result
1720						.maybe_cursor
1721						.is_none()
1722						.then(|| EraPruningState::<T>::insert(era, PruningStep::ClaimedRewards));
1723					T::WeightInfo::prune_era_validator_prefs(items_deleted)
1724				},
1725				PruningStep::ClaimedRewards => {
1726					let result = ClaimedRewards::<T>::clear_prefix(era, items_limit, None);
1727					let items_deleted = result.backend as u32;
1728					result.maybe_cursor.is_none().then(|| {
1729						EraPruningState::<T>::insert(era, PruningStep::ErasValidatorReward)
1730					});
1731					T::WeightInfo::prune_era_claimed_rewards(items_deleted)
1732				},
1733				PruningStep::ErasValidatorReward => {
1734					ErasValidatorReward::<T>::remove(era);
1735					EraPruningState::<T>::insert(era, PruningStep::ErasRewardPoints);
1736					T::WeightInfo::prune_era_validator_reward()
1737				},
1738				PruningStep::ErasRewardPoints => {
1739					ErasRewardPoints::<T>::remove(era);
1740					// At most one entry per `ServiceKind`.
1741					let _ = ErasRewardPointsByService::<T>::clear_prefix(era, u32::MAX, None);
1742					EraPruningState::<T>::insert(era, PruningStep::SingleEntryCleanups);
1743					T::WeightInfo::prune_era_reward_points()
1744				},
1745				PruningStep::SingleEntryCleanups => {
1746					ErasTotalStake::<T>::remove(era);
1747					ErasNominatorsSlashable::<T>::remove(era);
1748					ErasValidatorIncentiveBudget::<T>::remove(era);
1749					ErasSumValidatorIncentiveWeight::<T>::remove(era);
1750					ErasSumWeightedPoints::<T>::remove(era);
1751					EraPruningState::<T>::insert(era, PruningStep::ValidatorSlashInEra);
1752					T::WeightInfo::prune_era_single_entry_cleanups()
1753				},
1754				PruningStep::ValidatorSlashInEra => {
1755					let result = ValidatorSlashInEra::<T>::clear_prefix(era, items_limit, None);
1756					let items_deleted = result.backend as u32;
1757
1758					if result.maybe_cursor.is_none() {
1759						EraPruningState::<T>::insert(
1760							era,
1761							PruningStep::ErasValidatorIncentiveWeight,
1762						);
1763					}
1764
1765					T::WeightInfo::prune_era_validator_slash_in_era(items_deleted)
1766				},
1767				PruningStep::ErasValidatorIncentiveWeight => {
1768					let result =
1769						ErasValidatorIncentiveWeight::<T>::clear_prefix(era, items_limit, None);
1770					if result.maybe_cursor.is_none() {
1771						// Final step — remove pruning state.
1772						EraPruningState::<T>::remove(era);
1773					}
1774					T::WeightInfo::prune_era_validator_incentive_weight(result.backend as u32)
1775				},
1776			};
1777
1778			// Check if era is fully pruned (pruning state removed) and emit event
1779			if EraPruningState::<T>::get(era).is_none() {
1780				Self::deposit_event(Event::<T>::EraPruned { index: era });
1781			}
1782
1783			Ok(actual_weight)
1784		}
1785	}
1786
1787	#[pallet::hooks]
1788	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
1789		fn on_poll(_now: BlockNumberFor<T>, weight_meter: &mut WeightMeter) {
1790			let (weight, exec) = EraElectionPlanner::<T>::maybe_fetch_election_results();
1791			crate::log!(
1792				trace,
1793				"weight of fetching next election page is {:?}, have {:?}",
1794				weight,
1795				weight_meter.remaining()
1796			);
1797
1798			if weight_meter.can_consume(weight) {
1799				exec(weight_meter);
1800			} else {
1801				Self::deposit_event(Event::<T>::Unexpected(
1802					UnexpectedKind::PagedElectionOutOfWeight {
1803						page: NextElectionPage::<T>::get().unwrap_or(
1804							EraElectionPlanner::<T>::election_pages().defensive_saturating_sub(1),
1805						),
1806						required: weight,
1807						had: weight_meter.remaining(),
1808					},
1809				));
1810			}
1811		}
1812
1813		fn on_initialize(_now: BlockNumberFor<T>) -> Weight {
1814			// Process our queue, using the era-specific nominators slashable setting.
1815			let mut consumed_weight = slashing::process_offence_for_era::<T>();
1816
1817			// apply any pending slashes after `SlashDeferDuration`.
1818			consumed_weight.saturating_accrue(T::DbWeight::get().reads(1));
1819			if let Some(active_era) = ActiveEra::<T>::get() {
1820				let slash_weight = Self::apply_unapplied_slashes(active_era.index);
1821				consumed_weight.saturating_accrue(slash_weight);
1822			}
1823
1824			consumed_weight
1825		}
1826
1827		fn integrity_test() {
1828			// ensure that we funnel the correct value to the `DataProvider::MaxVotesPerVoter`;
1829			assert_eq!(
1830				MaxNominationsOf::<T>::get(),
1831				<Self as ElectionDataProvider>::MaxVotesPerVoter::get()
1832			);
1833
1834			// and that MaxNominations is always greater than 1, since we count on this.
1835			assert!(!MaxNominationsOf::<T>::get().is_zero());
1836
1837			assert!(
1838				T::SlashDeferDuration::get() < T::BondingDuration::get() || T::BondingDuration::get() == 0,
1839				"As per documentation, slash defer duration ({}) should be less than bonding duration ({}).",
1840				T::SlashDeferDuration::get(),
1841				T::BondingDuration::get(),
1842			);
1843
1844			// Ensure NominatorFastUnbondDuration is not greater than BondingDuration
1845			assert!(
1846				T::NominatorFastUnbondDuration::get() <= T::BondingDuration::get(),
1847				"NominatorFastUnbondDuration ({}) must not exceed BondingDuration ({}).",
1848				T::NominatorFastUnbondDuration::get(),
1849				T::BondingDuration::get(),
1850			);
1851			// Ensure MaxPruningItems is reasonable (minimum 100 for efficiency)
1852			assert!(
1853				T::MaxPruningItems::get() >= 100,
1854				"MaxPruningItems must be at least 100 for efficient pruning, got: {}",
1855				T::MaxPruningItems::get()
1856			);
1857
1858			assert!(
1859				crate::POT_POOL_SIZE > T::HistoryDepth::get(),
1860				"POT_POOL_SIZE ({}) must be strictly greater than HistoryDepth ({}) \
1861				 to avoid reusing a pot slot whose era is still in the active history.",
1862				crate::POT_POOL_SIZE,
1863				T::HistoryDepth::get(),
1864			);
1865
1866			// If minting is disabled, EraPayout must be a noop to prevent double-minting.
1867			if T::DisableMinting::get() {
1868				let (v, r) = T::EraPayout::era_payout(
1869					BalanceOf::<T>::from(1u64),
1870					BalanceOf::<T>::from(1u64),
1871					1000u64,
1872				);
1873				assert!(
1874					v.is_zero() && r.is_zero(),
1875					"DisableMinting is true but EraPayout returns non-zero. \
1876					 Set EraPayout = () when DisableMinting = true."
1877				);
1878			}
1879		}
1880
1881		#[cfg(feature = "try-runtime")]
1882		fn try_state(n: BlockNumberFor<T>) -> Result<(), sp_runtime::TryRuntimeError> {
1883			Self::do_try_state(n)
1884		}
1885	}
1886
1887	#[pallet::call]
1888	impl<T: Config> Pallet<T> {
1889		/// Take the origin account as a stash and lock up `value` of its balance. `controller` will
1890		/// be the account that controls it.
1891		///
1892		/// `value` must be more than the `minimum_balance` specified by `T::Currency`.
1893		///
1894		/// The dispatch origin for this call must be _Signed_ by the stash account.
1895		///
1896		/// Emits `Bonded`.
1897		///
1898		/// NOTE: Two of the storage writes (`Self::bonded`, `Self::payee`) are _never_ cleaned
1899		/// unless the `origin` falls below _existential deposit_ (or equal to 0) and gets removed
1900		/// as dust.
1901		#[pallet::call_index(0)]
1902		#[pallet::weight(T::WeightInfo::bond())]
1903		pub fn bond(
1904			origin: OriginFor<T>,
1905			#[pallet::compact] value: BalanceOf<T>,
1906			payee: RewardDestination<T::AccountId>,
1907		) -> DispatchResult {
1908			let stash = ensure_signed(origin)?;
1909
1910			ensure!(!T::Filter::contains(&stash), Error::<T>::Restricted);
1911
1912			if StakingLedger::<T>::is_bonded(StakingAccount::Stash(stash.clone())) {
1913				return Err(Error::<T>::AlreadyBonded.into());
1914			}
1915
1916			// An existing controller cannot become a stash.
1917			if StakingLedger::<T>::is_bonded(StakingAccount::Controller(stash.clone())) {
1918				return Err(Error::<T>::AlreadyPaired.into());
1919			}
1920
1921			// Reject a bond which is lower than the minimum bond.
1922			if value < Self::min_chilled_bond() {
1923				return Err(Error::<T>::InsufficientBond.into());
1924			}
1925
1926			let stash_balance = asset::free_to_stake::<T>(&stash);
1927			let value = value.min(stash_balance);
1928			Self::deposit_event(Event::<T>::Bonded { stash: stash.clone(), amount: value });
1929			let ledger = StakingLedger::<T>::new(stash.clone(), value);
1930
1931			// You're auto-bonded forever, here. We might improve this by only bonding when
1932			// you actually validate/nominate and remove once you unbond __everything__.
1933			ledger.bond(payee)?;
1934
1935			Ok(())
1936		}
1937
1938		/// Add some extra amount that have appeared in the stash `free_balance` into the balance up
1939		/// for staking.
1940		///
1941		/// The dispatch origin for this call must be _Signed_ by the stash, not the controller.
1942		///
1943		/// Use this if there are additional funds in your stash account that you wish to bond.
1944		/// Unlike [`bond`](Self::bond) or [`unbond`](Self::unbond) this function does not impose
1945		/// any limitation on the amount that can be added.
1946		///
1947		/// Emits `Bonded`.
1948		#[pallet::call_index(1)]
1949		#[pallet::weight(T::WeightInfo::bond_extra())]
1950		pub fn bond_extra(
1951			origin: OriginFor<T>,
1952			#[pallet::compact] max_additional: BalanceOf<T>,
1953		) -> DispatchResult {
1954			let stash = ensure_signed(origin)?;
1955			ensure!(!T::Filter::contains(&stash), Error::<T>::Restricted);
1956			Self::do_bond_extra(&stash, max_additional)
1957		}
1958
1959		/// Schedule a portion of the stash to be unlocked ready for transfer out after the bond
1960		/// period ends. If this leaves an amount actively bonded less than
1961		/// [`asset::existential_deposit`], then it is increased to the full amount.
1962		///
1963		/// The dispatch origin for this call must be _Signed_ by the controller, not the stash.
1964		///
1965		/// Once the unlock period is done, you can call `withdraw_unbonded` to actually move
1966		/// the funds out of management ready for transfer.
1967		///
1968		/// No more than a limited number of unlocking chunks (see `MaxUnlockingChunks`)
1969		/// can co-exists at the same time. If there are no unlocking chunks slots available
1970		/// [`Call::withdraw_unbonded`] is called to remove some of the chunks (if possible).
1971		///
1972		/// If a user encounters the `InsufficientBond` error when calling this extrinsic,
1973		/// they should call `chill` first in order to free up their bonded funds.
1974		///
1975		/// Emits `Unbonded`.
1976		///
1977		/// See also [`Call::withdraw_unbonded`].
1978		#[pallet::call_index(2)]
1979		#[pallet::weight(
1980            T::WeightInfo::withdraw_unbonded_kill().saturating_add(T::WeightInfo::unbond()))
1981        ]
1982		pub fn unbond(
1983			origin: OriginFor<T>,
1984			#[pallet::compact] value: BalanceOf<T>,
1985		) -> DispatchResultWithPostInfo {
1986			let controller = ensure_signed(origin)?;
1987			let unlocking =
1988				Self::ledger(Controller(controller.clone())).map(|l| l.unlocking.len())?;
1989
1990			// if there are no unlocking chunks available, try to remove any chunks by withdrawing
1991			// funds that have fully unbonded.
1992			let maybe_withdraw_weight = {
1993				if unlocking == T::MaxUnlockingChunks::get() as usize {
1994					Some(Self::do_withdraw_unbonded(&controller)?)
1995				} else {
1996					None
1997				}
1998			};
1999
2000			// we need to fetch the ledger again because it may have been mutated in the call
2001			// to `Self::do_withdraw_unbonded` above.
2002			let mut ledger = Self::ledger(Controller(controller))?;
2003			let mut value = value.min(ledger.active);
2004			let stash = ledger.stash.clone();
2005
2006			// If unbonding all active stake, chill the stash first to avoid `InsufficientBond`
2007			// errors. This matches the behavior of pallet-staking.
2008			let chill_weight = if value >= ledger.active {
2009				Self::chill_stash(&stash);
2010				T::WeightInfo::chill()
2011			} else {
2012				Weight::zero()
2013			};
2014
2015			ensure!(
2016				ledger.unlocking.len() < T::MaxUnlockingChunks::get() as usize,
2017				Error::<T>::NoMoreChunks,
2018			);
2019
2020			if !value.is_zero() {
2021				ledger.active -= value;
2022
2023				// Avoid there being a dust balance left in the staking system.
2024				if ledger.active < asset::existential_deposit::<T>() {
2025					value += ledger.active;
2026					ledger.active = Zero::zero();
2027				}
2028
2029				let is_nominator = Nominators::<T>::contains_key(&stash);
2030
2031				let min_active_bond = if is_nominator {
2032					Self::min_nominator_bond()
2033				} else if Validators::<T>::contains_key(&stash) {
2034					Self::min_validator_bond()
2035				} else {
2036					// staker is chilled, no min bond.
2037					Zero::zero()
2038				};
2039
2040				// Make sure that the user maintains enough active bond for their role.
2041				// If a user runs into this error, they should chill first.
2042				ensure!(ledger.active >= min_active_bond, Error::<T>::InsufficientBond);
2043
2044				// Determine unbonding duration based on validator history.
2045				// If the account was a validator in recent eras (within BondingDuration), they must
2046				// wait the full BondingDuration even if they've switched to nominator role.
2047				// This prevents validators from avoiding slashing by switching roles and using the
2048				// shorter nominator unbonding period.
2049				let active_era = session_rotation::Rotator::<T>::active_era();
2050				let was_recent_validator = LastValidatorEra::<T>::get(&stash)
2051					.map(|last_era| active_era.saturating_sub(last_era) < T::BondingDuration::get())
2052					.unwrap_or(false);
2053
2054				let unbond_duration = if was_recent_validator {
2055					// Use full bonding duration for recent validators
2056					T::BondingDuration::get()
2057				} else {
2058					// Use nominator bonding duration for pure nominators
2059					<Self as sp_staking::StakingInterface>::nominator_bonding_duration()
2060				};
2061
2062				let era =
2063					session_rotation::Rotator::<T>::active_era().saturating_add(unbond_duration);
2064				if let Some(chunk) = ledger.unlocking.last_mut().filter(|chunk| chunk.era == era) {
2065					// To keep the chunk count down, we only keep one chunk per era. Since
2066					// `unlocking` is a FiFo queue, if a chunk exists for `era` we know that it will
2067					// be the last one.
2068					chunk.value = chunk.value.defensive_saturating_add(value)
2069				} else {
2070					ledger
2071						.unlocking
2072						.try_push(UnlockChunk { value, era })
2073						.map_err(|_| Error::<T>::NoMoreChunks)?;
2074				};
2075				// NOTE: ledger must be updated prior to calling `Self::weight_of`.
2076				ledger.update()?;
2077
2078				// update this staker in the sorted list, if they exist in it.
2079				if T::VoterList::contains(&stash) {
2080					let _ = T::VoterList::on_update(&stash, Self::weight_of(&stash));
2081				}
2082
2083				Self::deposit_event(Event::<T>::Unbonded { stash, amount: value, era });
2084			}
2085
2086			let actual_weight = if let Some(withdraw_weight) = maybe_withdraw_weight {
2087				Some(
2088					T::WeightInfo::unbond()
2089						.saturating_add(withdraw_weight)
2090						.saturating_add(chill_weight),
2091				)
2092			} else {
2093				Some(T::WeightInfo::unbond().saturating_add(chill_weight))
2094			};
2095
2096			Ok(actual_weight.into())
2097		}
2098
2099		/// Remove any stake that has been fully unbonded and is ready for withdrawal.
2100		///
2101		/// Stake is considered fully unbonded once [`Config::BondingDuration`] has elapsed since
2102		/// the unbonding was initiated. In rare cases—such as when offences for the unbonded era
2103		/// have been reported but not yet processed—withdrawal is restricted to eras for which
2104		/// all offences have been processed.
2105		///
2106		/// The unlocked stake will be returned as free balance in the stash account.
2107		///
2108		/// The dispatch origin for this call must be _Signed_ by the controller.
2109		///
2110		/// Emits `Withdrawn`.
2111		///
2112		/// See also [`Call::unbond`].
2113		///
2114		/// ## Parameters
2115		///
2116		/// - `num_slashing_spans`: **Deprecated**. Retained only for backward compatibility; this
2117		///   parameter has no effect.
2118		#[pallet::call_index(3)]
2119		#[pallet::weight(T::WeightInfo::withdraw_unbonded_kill())]
2120		pub fn withdraw_unbonded(
2121			origin: OriginFor<T>,
2122			_num_slashing_spans: u32,
2123		) -> DispatchResultWithPostInfo {
2124			let controller = ensure_signed(origin)?;
2125
2126			let actual_weight = Self::do_withdraw_unbonded(&controller)?;
2127			Ok(Some(actual_weight).into())
2128		}
2129
2130		/// Declare the desire to validate for the origin controller.
2131		///
2132		/// Effects will be felt at the beginning of the next era.
2133		///
2134		/// The dispatch origin for this call must be _Signed_ by the controller, not the stash.
2135		#[pallet::call_index(4)]
2136		#[pallet::weight(T::WeightInfo::validate())]
2137		pub fn validate(origin: OriginFor<T>, prefs: ValidatorPrefs) -> DispatchResult {
2138			let controller = ensure_signed(origin)?;
2139
2140			let ledger = Self::ledger(Controller(controller))?;
2141
2142			ensure!(ledger.active >= Self::min_validator_bond(), Error::<T>::InsufficientBond);
2143			let stash = &ledger.stash;
2144
2145			// ensure their commission is correct.
2146			ensure!(prefs.commission >= MinCommission::<T>::get(), Error::<T>::CommissionTooLow);
2147			ensure!(prefs.commission <= MaxCommission::<T>::get(), Error::<T>::CommissionTooHigh);
2148
2149			// Only check limits if they are not already a validator.
2150			if !Validators::<T>::contains_key(stash) {
2151				// If this error is reached, we need to adjust the `MinValidatorBond` and start
2152				// calling `chill_other`. Until then, we explicitly block new validators to protect
2153				// the runtime.
2154				if let Some(max_validators) = MaxValidatorsCount::<T>::get() {
2155					ensure!(
2156						Validators::<T>::count() < max_validators,
2157						Error::<T>::TooManyValidators
2158					);
2159				}
2160			}
2161
2162			Self::do_remove_nominator(stash);
2163			Self::do_add_validator(stash, prefs.clone());
2164			Self::deposit_event(Event::<T>::ValidatorPrefsSet { stash: ledger.stash, prefs });
2165
2166			Ok(())
2167		}
2168
2169		/// Declare the desire to nominate `targets` for the origin controller.
2170		///
2171		/// Effects will be felt at the beginning of the next era.
2172		///
2173		/// The dispatch origin for this call must be _Signed_ by the controller, not the stash.
2174		#[pallet::call_index(5)]
2175		#[pallet::weight(T::WeightInfo::nominate(targets.len() as u32))]
2176		pub fn nominate(
2177			origin: OriginFor<T>,
2178			targets: Vec<AccountIdLookupOf<T>>,
2179		) -> DispatchResult {
2180			let controller = ensure_signed(origin)?;
2181
2182			let ledger = Self::ledger(StakingAccount::Controller(controller.clone()))?;
2183
2184			ensure!(ledger.active >= Self::min_nominator_bond(), Error::<T>::InsufficientBond);
2185			let stash = &ledger.stash;
2186
2187			// Only check limits if they are not already a nominator.
2188			if !Nominators::<T>::contains_key(stash) {
2189				// If this error is reached, we need to adjust the `MinNominatorBond` and start
2190				// calling `chill_other`. Until then, we explicitly block new nominators to protect
2191				// the runtime.
2192				if let Some(max_nominators) = MaxNominatorsCount::<T>::get() {
2193					ensure!(
2194						Nominators::<T>::count() < max_nominators,
2195						Error::<T>::TooManyNominators
2196					);
2197				}
2198			}
2199
2200			// dedup targets
2201			let mut targets = targets
2202				.into_iter()
2203				.map(|t| T::Lookup::lookup(t).map_err(DispatchError::from))
2204				.collect::<Result<Vec<_>, _>>()?;
2205			targets.sort();
2206			targets.dedup();
2207
2208			ensure!(!targets.is_empty(), Error::<T>::EmptyTargets);
2209			ensure!(
2210				targets.len() <= T::NominationsQuota::get_quota(ledger.active) as usize,
2211				Error::<T>::TooManyTargets
2212			);
2213
2214			let old = Nominators::<T>::get(stash).map_or_else(Vec::new, |x| x.targets.into_inner());
2215
2216			let targets: BoundedVec<_, _> = targets
2217				.into_iter()
2218				.map(|n| {
2219					if old.contains(&n) ||
2220						(Validators::<T>::contains_key(&n) && !Validators::<T>::get(&n).blocked)
2221					{
2222						Ok(n)
2223					} else {
2224						Err(Error::<T>::BadTarget.into())
2225					}
2226				})
2227				.collect::<Result<Vec<_>, DispatchError>>()?
2228				.try_into()
2229				.map_err(|_| Error::<T>::TooManyNominators)?;
2230
2231			let nominations = Nominations {
2232				targets,
2233				// Initial nominations are considered submitted at era 0. See `Nominations` doc.
2234				submitted_in: CurrentEra::<T>::get().unwrap_or(0),
2235				suppressed: false,
2236			};
2237
2238			Self::do_remove_validator(stash);
2239			Self::do_add_nominator(stash, nominations);
2240			Ok(())
2241		}
2242
2243		/// Declare no desire to either validate or nominate.
2244		///
2245		/// Effects will be felt at the beginning of the next era.
2246		///
2247		/// The dispatch origin for this call must be _Signed_ by the controller, not the stash.
2248		///
2249		/// ## Complexity
2250		/// - Independent of the arguments. Insignificant complexity.
2251		/// - Contains one read.
2252		/// - Writes are limited to the `origin` account key.
2253		#[pallet::call_index(6)]
2254		#[pallet::weight(T::WeightInfo::chill())]
2255		pub fn chill(origin: OriginFor<T>) -> DispatchResult {
2256			let controller = ensure_signed(origin)?;
2257
2258			let ledger = Self::ledger(StakingAccount::Controller(controller))?;
2259
2260			Self::chill_stash(&ledger.stash);
2261			Ok(())
2262		}
2263
2264		/// (Re-)set the payment target for a controller.
2265		///
2266		/// Effects will be felt instantly (as soon as this function is completed successfully).
2267		///
2268		/// The dispatch origin for this call must be _Signed_ by the controller, not the stash.
2269		#[pallet::call_index(7)]
2270		#[pallet::weight(T::WeightInfo::set_payee())]
2271		pub fn set_payee(
2272			origin: OriginFor<T>,
2273			payee: RewardDestination<T::AccountId>,
2274		) -> DispatchResult {
2275			let controller = ensure_signed(origin)?;
2276			let ledger = Self::ledger(Controller(controller.clone()))?;
2277
2278			ensure!(
2279				(payee != {
2280					#[allow(deprecated)]
2281					RewardDestination::Controller
2282				}),
2283				Error::<T>::ControllerDeprecated
2284			);
2285
2286			let _ = ledger
2287				.set_payee(payee)
2288				.defensive_proof("ledger was retrieved from storage, thus it's bonded; qed.")?;
2289
2290			Ok(())
2291		}
2292
2293		/// (Re-)sets the controller of a stash to the stash itself. This function previously
2294		/// accepted a `controller` argument to set the controller to an account other than the
2295		/// stash itself. This functionality has now been removed, now only setting the controller
2296		/// to the stash, if it is not already.
2297		///
2298		/// Effects will be felt instantly (as soon as this function is completed successfully).
2299		///
2300		/// The dispatch origin for this call must be _Signed_ by the stash, not the controller.
2301		#[pallet::call_index(8)]
2302		#[pallet::weight(T::WeightInfo::set_controller())]
2303		pub fn set_controller(origin: OriginFor<T>) -> DispatchResult {
2304			let stash = ensure_signed(origin)?;
2305
2306			Self::ledger(StakingAccount::Stash(stash.clone())).map(|ledger| {
2307				let controller = ledger.controller()
2308                    .defensive_proof("Ledger's controller field didn't exist. The controller should have been fetched using StakingLedger.")
2309                    .ok_or(Error::<T>::NotController)?;
2310
2311				if controller == stash {
2312					// Stash is already its own controller.
2313					return Err(Error::<T>::AlreadyPaired.into())
2314				}
2315
2316				let _ = ledger.set_controller_to_stash()?;
2317				Ok(())
2318			})?
2319		}
2320
2321		/// Sets the ideal number of validators.
2322		///
2323		/// The dispatch origin must be Root.
2324		#[pallet::call_index(9)]
2325		#[pallet::weight(T::WeightInfo::set_validator_count())]
2326		pub fn set_validator_count(
2327			origin: OriginFor<T>,
2328			#[pallet::compact] new: u32,
2329		) -> DispatchResult {
2330			ensure_root(origin)?;
2331
2332			ensure!(new <= T::MaxValidatorSet::get(), Error::<T>::TooManyValidators);
2333
2334			ValidatorCount::<T>::put(new);
2335			Ok(())
2336		}
2337
2338		/// Increments the ideal number of validators up to maximum of
2339		/// `T::MaxValidatorSet`.
2340		///
2341		/// The dispatch origin must be Root.
2342		#[pallet::call_index(10)]
2343		#[pallet::weight(T::WeightInfo::set_validator_count())]
2344		pub fn increase_validator_count(
2345			origin: OriginFor<T>,
2346			#[pallet::compact] additional: u32,
2347		) -> DispatchResult {
2348			ensure_root(origin)?;
2349			let old = ValidatorCount::<T>::get();
2350			let new = old.checked_add(additional).ok_or(ArithmeticError::Overflow)?;
2351
2352			ensure!(new <= T::MaxValidatorSet::get(), Error::<T>::TooManyValidators);
2353
2354			ValidatorCount::<T>::put(new);
2355			Ok(())
2356		}
2357
2358		/// Scale up the ideal number of validators by a factor up to maximum of
2359		/// `T::MaxValidatorSet`.
2360		///
2361		/// The dispatch origin must be Root.
2362		#[pallet::call_index(11)]
2363		#[pallet::weight(T::WeightInfo::set_validator_count())]
2364		pub fn scale_validator_count(origin: OriginFor<T>, factor: Percent) -> DispatchResult {
2365			ensure_root(origin)?;
2366			let old = ValidatorCount::<T>::get();
2367			let new = old.checked_add(factor.mul_floor(old)).ok_or(ArithmeticError::Overflow)?;
2368
2369			ensure!(new <= T::MaxValidatorSet::get(), Error::<T>::TooManyValidators);
2370
2371			ValidatorCount::<T>::put(new);
2372			Ok(())
2373		}
2374
2375		/// Force there to be no new eras indefinitely.
2376		///
2377		/// The dispatch origin must be Root.
2378		///
2379		/// # Warning
2380		///
2381		/// The election process starts multiple blocks before the end of the era.
2382		/// Thus the election process may be ongoing when this is called. In this case the
2383		/// election will continue until the next era is triggered.
2384		#[pallet::call_index(12)]
2385		#[pallet::weight(T::WeightInfo::force_no_eras())]
2386		pub fn force_no_eras(origin: OriginFor<T>) -> DispatchResult {
2387			ensure_root(origin)?;
2388			Self::set_force_era(Forcing::ForceNone);
2389			Ok(())
2390		}
2391
2392		/// Force there to be a new era at the end of the next session. After this, it will be
2393		/// reset to normal (non-forced) behaviour.
2394		///
2395		/// The dispatch origin must be Root.
2396		///
2397		/// # Warning
2398		///
2399		/// The election process starts multiple blocks before the end of the era.
2400		/// If this is called just before a new era is triggered, the election process may not
2401		/// have enough blocks to get a result.
2402		#[pallet::call_index(13)]
2403		#[pallet::weight(T::WeightInfo::force_new_era())]
2404		pub fn force_new_era(origin: OriginFor<T>) -> DispatchResult {
2405			ensure_root(origin)?;
2406			Self::set_force_era(Forcing::ForceNew);
2407			Ok(())
2408		}
2409
2410		/// Force a current staker to become completely unstaked, immediately.
2411		///
2412		/// The dispatch origin must be Root.
2413		/// ## Parameters
2414		///
2415		/// - `stash`: The stash account to be unstaked.
2416		/// - `num_slashing_spans`: **Deprecated**. This parameter is retained for backward
2417		/// compatibility. It no longer has any effect.
2418		#[pallet::call_index(15)]
2419		#[pallet::weight(T::WeightInfo::force_unstake())]
2420		pub fn force_unstake(
2421			origin: OriginFor<T>,
2422			stash: T::AccountId,
2423			_num_slashing_spans: u32,
2424		) -> DispatchResult {
2425			ensure_root(origin)?;
2426
2427			// Remove all staking-related information and lock.
2428			Self::kill_stash(&stash)?;
2429
2430			Ok(())
2431		}
2432
2433		/// Force there to be a new era at the end of sessions indefinitely.
2434		///
2435		/// The dispatch origin must be Root.
2436		///
2437		/// # Warning
2438		///
2439		/// The election process starts multiple blocks before the end of the era.
2440		/// If this is called just before a new era is triggered, the election process may not
2441		/// have enough blocks to get a result.
2442		#[pallet::call_index(16)]
2443		#[pallet::weight(T::WeightInfo::force_new_era_always())]
2444		pub fn force_new_era_always(origin: OriginFor<T>) -> DispatchResult {
2445			ensure_root(origin)?;
2446			Self::set_force_era(Forcing::ForceAlways);
2447			Ok(())
2448		}
2449
2450		/// Cancels scheduled slashes for a given era before they are applied.
2451		///
2452		/// This function allows `T::AdminOrigin` to cancel pending slashes for specified validators
2453		/// in a given era. The cancelled slashes are stored and will be checked when applying
2454		/// slashes.
2455		///
2456		/// ## Parameters
2457		/// - `era`: The staking era for which slashes should be cancelled. This is the era where
2458		///   the slash would be applied, not the era in which the offence was committed.
2459		/// - `validator_slashes`: A list of validator stash accounts and their slash fractions to
2460		///   be cancelled.
2461		#[pallet::call_index(17)]
2462		#[pallet::weight(T::WeightInfo::cancel_deferred_slash(validator_slashes.len() as u32))]
2463		pub fn cancel_deferred_slash(
2464			origin: OriginFor<T>,
2465			era: EraIndex,
2466			validator_slashes: Vec<(T::AccountId, Perbill)>,
2467		) -> DispatchResult {
2468			T::AdminOrigin::ensure_origin(origin)?;
2469			ensure!(!validator_slashes.is_empty(), Error::<T>::EmptyTargets);
2470
2471			// Get current cancelled slashes for this era
2472			let mut cancelled_slashes = CancelledSlashes::<T>::get(&era);
2473
2474			// Process each validator slash
2475			for (validator, slash_fraction) in validator_slashes {
2476				// Since this is gated by admin origin, we don't need to check if they are really
2477				// validators and trust governance to correctly set the parameters.
2478
2479				// Remove any existing entry for this validator
2480				cancelled_slashes.retain(|(v, _)| v != &validator);
2481
2482				// Add the validator with the specified slash fraction
2483				cancelled_slashes
2484					.try_push((validator.clone(), slash_fraction))
2485					.map_err(|_| Error::<T>::BoundNotMet)
2486					.defensive_proof("cancelled_slashes should have capacity for all validators")?;
2487
2488				Self::deposit_event(Event::<T>::SlashCancelled { slash_era: era, validator });
2489			}
2490
2491			// Update storage
2492			CancelledSlashes::<T>::insert(&era, cancelled_slashes);
2493
2494			Ok(())
2495		}
2496
2497		/// Pay out next page of the stakers behind a validator for the given era.
2498		///
2499		/// - `validator_stash` is the stash account of the validator.
2500		/// - `era` may be any era between `[current_era - history_depth; current_era]`.
2501		///
2502		/// The origin of this call must be _Signed_. Any account can call this function, even if
2503		/// it is not one of the stakers.
2504		///
2505		/// The reward payout could be paged in case there are too many nominators backing the
2506		/// `validator_stash`. This call will payout unpaid pages in an ascending order. To claim a
2507		/// specific page, use `payout_stakers_by_page`.`
2508		///
2509		/// If all pages are claimed, it returns an error `InvalidPage`.
2510		#[pallet::call_index(18)]
2511		#[pallet::weight(T::WeightInfo::payout_stakers_alive_staked(T::MaxExposurePageSize::get()))]
2512		pub fn payout_stakers(
2513			origin: OriginFor<T>,
2514			validator_stash: T::AccountId,
2515			era: EraIndex,
2516		) -> DispatchResultWithPostInfo {
2517			ensure_signed(origin)?;
2518
2519			Self::do_payout_stakers(validator_stash, era)
2520		}
2521
2522		/// Rebond a portion of the stash scheduled to be unlocked.
2523		///
2524		/// The dispatch origin must be signed by the controller.
2525		#[pallet::call_index(19)]
2526		#[pallet::weight(T::WeightInfo::rebond(T::MaxUnlockingChunks::get() as u32))]
2527		pub fn rebond(
2528			origin: OriginFor<T>,
2529			#[pallet::compact] value: BalanceOf<T>,
2530		) -> DispatchResultWithPostInfo {
2531			let controller = ensure_signed(origin)?;
2532			let ledger = Self::ledger(Controller(controller))?;
2533
2534			ensure!(!T::Filter::contains(&ledger.stash), Error::<T>::Restricted);
2535			ensure!(!ledger.unlocking.is_empty(), Error::<T>::NoUnlockChunk);
2536
2537			let initial_unlocking = ledger.unlocking.len() as u32;
2538			let (ledger, rebonded_value) = ledger.rebond(value);
2539			// Last check: the new active amount of ledger must be more than min bond.
2540			ensure!(ledger.active >= Self::min_chilled_bond(), Error::<T>::InsufficientBond);
2541
2542			Self::deposit_event(Event::<T>::Bonded {
2543				stash: ledger.stash.clone(),
2544				amount: rebonded_value,
2545			});
2546
2547			let stash = ledger.stash.clone();
2548			let final_unlocking = ledger.unlocking.len();
2549
2550			// NOTE: ledger must be updated prior to calling `Self::weight_of`.
2551			ledger.update()?;
2552			if T::VoterList::contains(&stash) {
2553				let _ = T::VoterList::on_update(&stash, Self::weight_of(&stash));
2554			}
2555
2556			let removed_chunks = 1u32 // for the case where the last iterated chunk is not removed
2557				.saturating_add(initial_unlocking)
2558				.saturating_sub(final_unlocking as u32);
2559			Ok(Some(T::WeightInfo::rebond(removed_chunks)).into())
2560		}
2561
2562		/// Remove all data structures concerning a staker/stash once it is at a state where it can
2563		/// be considered `dust` in the staking system. The requirements are:
2564		///
2565		/// 1. the `total_balance` of the stash is below the existential deposit.
2566		/// 2. or, the `ledger.total` of the stash is below the existential deposit.
2567		///
2568		/// The former can happen in cases like a slash; the latter when a fully unbonded account
2569		/// is still receiving staking rewards in `RewardDestination::Staked`.
2570		///
2571		/// The gate is intentionally the existential deposit and *not* `min_chilled_bond`: a
2572		/// governance change to `MinValidatorBond` / `MinNominatorBond` must not turn previously
2573		/// safe stashes into permissionlessly reapable ones. Accounts that fall below the new
2574		/// minimums after such a change should be `chill_other`-ed (which has a density gate and
2575		/// does not destroy the ledger), not reaped.
2576		///
2577		/// It can be called by anyone, as long as `stash` meets the above requirements.
2578		///
2579		/// Refunds the transaction fees upon successful execution.
2580		///
2581		/// ## Parameters
2582		///
2583		/// - `stash`: The stash account to be reaped.
2584		/// - `num_slashing_spans`: **Deprecated**. This parameter is retained for backward
2585		/// compatibility. It no longer has any effect.
2586		#[pallet::call_index(20)]
2587		#[pallet::weight(T::WeightInfo::reap_stash())]
2588		pub fn reap_stash(
2589			origin: OriginFor<T>,
2590			stash: T::AccountId,
2591			_num_slashing_spans: u32,
2592		) -> DispatchResultWithPostInfo {
2593			let _ = ensure_signed(origin)?;
2594
2595			// virtual stakers should not be allowed to be reaped.
2596			ensure!(!Self::is_virtual_staker(&stash), Error::<T>::VirtualStakerNotAllowed);
2597
2598			let ed = asset::existential_deposit::<T>();
2599			let origin_balance = asset::total_balance::<T>(&stash);
2600			let ledger_total =
2601				Self::ledger(Stash(stash.clone())).map(|l| l.total).unwrap_or_default();
2602			let reapable = origin_balance < ed ||
2603				origin_balance.is_zero() ||
2604				ledger_total < ed ||
2605				ledger_total.is_zero();
2606			ensure!(reapable, Error::<T>::FundedTarget);
2607
2608			// Remove all staking-related information and lock.
2609			Self::kill_stash(&stash)?;
2610
2611			Ok(Pays::No.into())
2612		}
2613
2614		/// Remove the given nominations from the calling validator.
2615		///
2616		/// Effects will be felt at the beginning of the next era.
2617		///
2618		/// The dispatch origin for this call must be _Signed_ by the controller, not the stash.
2619		///
2620		/// - `who`: A list of nominator stash accounts who are nominating this validator which
2621		///   should no longer be nominating this validator.
2622		///
2623		/// Note: Making this call only makes sense if you first set the validator preferences to
2624		/// block any further nominations.
2625		#[pallet::call_index(21)]
2626		#[pallet::weight(T::WeightInfo::kick(who.len() as u32))]
2627		pub fn kick(origin: OriginFor<T>, who: Vec<AccountIdLookupOf<T>>) -> DispatchResult {
2628			let controller = ensure_signed(origin)?;
2629			let ledger = Self::ledger(Controller(controller))?;
2630			let stash = &ledger.stash;
2631
2632			for nom_stash in who
2633				.into_iter()
2634				.map(T::Lookup::lookup)
2635				.collect::<Result<Vec<T::AccountId>, _>>()?
2636				.into_iter()
2637			{
2638				Nominators::<T>::mutate(&nom_stash, |maybe_nom| {
2639					if let Some(ref mut nom) = maybe_nom {
2640						if let Some(pos) = nom.targets.iter().position(|v| v == stash) {
2641							nom.targets.swap_remove(pos);
2642							Self::deposit_event(Event::<T>::Kicked {
2643								nominator: nom_stash.clone(),
2644								stash: stash.clone(),
2645							});
2646						}
2647					}
2648				});
2649			}
2650
2651			Ok(())
2652		}
2653
2654		/// Update the various staking configurations .
2655		///
2656		/// * `min_nominator_bond`: The minimum active bond needed to be a nominator.
2657		/// * `min_validator_bond`: The minimum active bond needed to be a validator.
2658		/// * `max_nominator_count`: The max number of users who can be a nominator at once. When
2659		///   set to `None`, no limit is enforced.
2660		/// * `max_validator_count`: The max number of users who can be a validator at once. When
2661		///   set to `None`, no limit is enforced.
2662		/// * `chill_threshold`: The ratio of `max_nominator_count` or `max_validator_count` which
2663		///   should be filled in order for the `chill_other` transaction to work.
2664		/// * `min_commission`: The minimum amount of commission that each validators must maintain.
2665		///   This is checked only upon calling `validate`. Existing validators are not affected.
2666		/// * `chill_inactive_threshold`: The number of eras a validator can remain inactive during
2667		///   the last [`Config::HistoryDepth`] eras before being subject to chilling becuase of
2668		///   inactivity. The weight of `chill_inactive` with a proof of this length must fit in one
2669		///   normal extrinsic. When removed, `chill_inactive` is disabled.
2670		///
2671		/// RuntimeOrigin must be Root to call this function.
2672		///
2673		/// NOTE: Existing nominators and validators will not be affected by this update.
2674		/// to kick people under the new limits, `chill_other` should be called.
2675		// We assume the worst case for this call is either: all items are set or all items are
2676		// removed.
2677		#[pallet::call_index(22)]
2678		#[pallet::weight(
2679			T::WeightInfo::set_staking_configs_all_set()
2680				.max(T::WeightInfo::set_staking_configs_all_remove())
2681		)]
2682		pub fn set_staking_configs(
2683			origin: OriginFor<T>,
2684			min_nominator_bond: ConfigOp<BalanceOf<T>>,
2685			min_validator_bond: ConfigOp<BalanceOf<T>>,
2686			max_nominator_count: ConfigOp<u32>,
2687			max_validator_count: ConfigOp<u32>,
2688			chill_threshold: ConfigOp<Percent>,
2689			min_commission: ConfigOp<Perbill>,
2690			max_staked_rewards: ConfigOp<Percent>,
2691			are_nominators_slashable: ConfigOp<bool>,
2692			chill_inactive_threshold: ConfigOp<u32>,
2693		) -> DispatchResult {
2694			ensure_root(origin)?;
2695
2696			if let ConfigOp::Set(threshold) = chill_inactive_threshold {
2697				ensure!(
2698					threshold > 1 && threshold <= T::HistoryDepth::get(),
2699					Error::<T>::InvalidChillInactiveThreshold
2700				);
2701				let block_weights = T::BlockWeights::get();
2702				let normal = block_weights.get(DispatchClass::Normal);
2703				let max_weight = normal.max_extrinsic.or(normal.max_total).unwrap_or(Weight::MAX);
2704				ensure!(
2705					T::WeightInfo::chill_inactive(threshold).all_lte(max_weight),
2706					Error::<T>::InvalidChillInactiveThreshold
2707				);
2708			}
2709
2710			macro_rules! config_op_exp {
2711				($storage:ty, $op:ident) => {
2712					match $op {
2713						ConfigOp::Noop => (),
2714						ConfigOp::Set(v) => <$storage>::put(v),
2715						ConfigOp::Remove => <$storage>::kill(),
2716					}
2717				};
2718			}
2719
2720			config_op_exp!(MinNominatorBond<T>, min_nominator_bond);
2721			config_op_exp!(MinValidatorBond<T>, min_validator_bond);
2722			config_op_exp!(MaxNominatorsCount<T>, max_nominator_count);
2723			config_op_exp!(MaxValidatorsCount<T>, max_validator_count);
2724			config_op_exp!(ChillThreshold<T>, chill_threshold);
2725			config_op_exp!(MinCommission<T>, min_commission);
2726			config_op_exp!(MaxStakedRewards<T>, max_staked_rewards);
2727			config_op_exp!(AreNominatorsSlashable<T>, are_nominators_slashable);
2728			config_op_exp!(ChillInactiveThreshold<T>, chill_inactive_threshold);
2729
2730			Ok(())
2731		}
2732		/// Declare a `controller` to stop participating as either a validator or nominator.
2733		///
2734		/// Effects will be felt at the beginning of the next era.
2735		///
2736		/// The dispatch origin for this call must be _Signed_, but can be called by anyone.
2737		///
2738		/// If the caller is the same as the controller being targeted, then no further checks are
2739		/// enforced, and this function behaves just like `chill`.
2740		///
2741		/// If the caller is different than the controller being targeted, the following conditions
2742		/// must be met:
2743		///
2744		/// * `controller` must belong to a nominator who has become non-decodable,
2745		///
2746		/// Or:
2747		///
2748		/// * A `ChillThreshold` must be set and checked which defines how close to the max
2749		///   nominators or validators we must reach before users can start chilling one-another.
2750		/// * A `MaxNominatorCount` and `MaxValidatorCount` must be set which is used to determine
2751		///   how close we are to the threshold.
2752		/// * A `MinNominatorBond` and `MinValidatorBond` must be set and checked, which determines
2753		///   if this is a person that should be chilled because they have not met the threshold
2754		///   bond required.
2755		///
2756		/// This can be helpful if bond requirements are updated, and we need to remove old users
2757		/// who do not satisfy these requirements.
2758		#[pallet::call_index(23)]
2759		#[pallet::weight(T::WeightInfo::chill_other())]
2760		pub fn chill_other(origin: OriginFor<T>, stash: T::AccountId) -> DispatchResult {
2761			// Anyone can call this function.
2762			let caller = ensure_signed(origin)?;
2763			let ledger = Self::ledger(Stash(stash.clone()))?;
2764			let controller = ledger
2765				.controller()
2766				.defensive_proof(
2767					"Ledger's controller field didn't exist. The controller should have been fetched using StakingLedger.",
2768				)
2769				.ok_or(Error::<T>::NotController)?;
2770
2771			// In order for one user to chill another user, the following conditions must be met:
2772			//
2773			// * `controller` belongs to a nominator who has become non-decodable,
2774			//
2775			// Or
2776			//
2777			// * A `ChillThreshold` is set which defines how close to the max nominators or
2778			//   validators we must reach before users can start chilling one-another.
2779			// * A `MaxNominatorCount` and `MaxValidatorCount` which is used to determine how close
2780			//   we are to the threshold.
2781			// * A `MinNominatorBond` and `MinValidatorBond` which is the final condition checked to
2782			//   determine this is a person that should be chilled because they have not met the
2783			//   threshold bond required.
2784			//
2785			// Otherwise, if caller is the same as the controller, this is just like `chill`.
2786
2787			if Nominators::<T>::contains_key(&stash) && Nominators::<T>::get(&stash).is_none() {
2788				Self::chill_stash(&stash);
2789				return Ok(());
2790			}
2791
2792			if caller != controller {
2793				let threshold = ChillThreshold::<T>::get().ok_or(Error::<T>::CannotChillOther)?;
2794				let min_active_bond = if Nominators::<T>::contains_key(&stash) {
2795					let max_nominator_count =
2796						MaxNominatorsCount::<T>::get().ok_or(Error::<T>::CannotChillOther)?;
2797					let current_nominator_count = Nominators::<T>::count();
2798					ensure!(
2799						threshold * max_nominator_count < current_nominator_count,
2800						Error::<T>::CannotChillOther
2801					);
2802					Self::min_nominator_bond()
2803				} else if Validators::<T>::contains_key(&stash) {
2804					let max_validator_count =
2805						MaxValidatorsCount::<T>::get().ok_or(Error::<T>::CannotChillOther)?;
2806					let current_validator_count = Validators::<T>::count();
2807					ensure!(
2808						threshold * max_validator_count < current_validator_count,
2809						Error::<T>::CannotChillOther
2810					);
2811					Self::min_validator_bond()
2812				} else {
2813					Zero::zero()
2814				};
2815
2816				ensure!(ledger.active < min_active_bond, Error::<T>::CannotChillOther);
2817			}
2818
2819			Self::chill_stash(&stash);
2820			Ok(())
2821		}
2822
2823		/// Clamps a validator's commission to the `[MinCommission, MaxCommission]` range.
2824		///
2825		/// Named `force_apply_min_commission` for legacy reasons — it also enforces the
2826		/// maximum. Any account can call this.
2827		#[pallet::call_index(24)]
2828		#[pallet::weight(T::WeightInfo::force_apply_min_commission())]
2829		pub fn force_apply_min_commission(
2830			origin: OriginFor<T>,
2831			validator_stash: T::AccountId,
2832		) -> DispatchResult {
2833			ensure_signed(origin)?;
2834			let min_commission = MinCommission::<T>::get();
2835			let max_commission = MaxCommission::<T>::get();
2836			Validators::<T>::try_mutate_exists(validator_stash, |maybe_prefs| {
2837				maybe_prefs
2838					.as_mut()
2839					.map(|prefs| {
2840						if prefs.commission < min_commission {
2841							prefs.commission = min_commission;
2842						}
2843						if prefs.commission > max_commission {
2844							prefs.commission = max_commission;
2845						}
2846					})
2847					.ok_or(Error::<T>::NotStash)
2848			})?;
2849			Ok(())
2850		}
2851
2852		/// Sets the minimum amount of commission that each validators must maintain.
2853		///
2854		/// This call has lower privilege requirements than `set_staking_config` and can be called
2855		/// by the `T::AdminOrigin`. Root can always call this.
2856		#[pallet::call_index(25)]
2857		#[pallet::weight(T::WeightInfo::set_min_commission())]
2858		pub fn set_min_commission(origin: OriginFor<T>, new: Perbill) -> DispatchResult {
2859			T::AdminOrigin::ensure_origin(origin)?;
2860			ensure!(new <= MaxCommission::<T>::get(), Error::<T>::CommissionTooHigh);
2861			MinCommission::<T>::put(new);
2862			Ok(())
2863		}
2864
2865		/// Pay out a page of the stakers behind a validator for the given era and page.
2866		///
2867		/// - `validator_stash` is the stash account of the validator.
2868		/// - `era` may be any era between `[current_era - history_depth; current_era]`.
2869		/// - `page` is the page index of nominators to pay out with value between 0 and
2870		///   `num_nominators / T::MaxExposurePageSize`.
2871		///
2872		/// The origin of this call must be _Signed_. Any account can call this function, even if
2873		/// it is not one of the stakers.
2874		///
2875		/// If a validator has more than [`Config::MaxExposurePageSize`] nominators backing
2876		/// them, then the list of nominators is paged, with each page being capped at
2877		/// [`Config::MaxExposurePageSize`]. If a validator has more than one page of nominators,
2878		/// the call needs to be made for each page separately in order for all the nominators
2879		/// backing a validator to receive the reward. The nominators are not sorted across pages
2880		/// and so it should not be assumed the highest staker would be on the topmost page and vice
2881		/// versa. If rewards are not claimed in [`Config::HistoryDepth`] eras, they are lost.
2882		///
2883		/// The validator's own reward (commission + own-stake share) is prorated across pages
2884		/// proportional to each page's stake. The full validator reward is the sum across all
2885		/// pages.
2886		#[pallet::call_index(26)]
2887		#[pallet::weight(T::WeightInfo::payout_stakers_alive_staked(T::MaxExposurePageSize::get()))]
2888		pub fn payout_stakers_by_page(
2889			origin: OriginFor<T>,
2890			validator_stash: T::AccountId,
2891			era: EraIndex,
2892			page: Page,
2893		) -> DispatchResultWithPostInfo {
2894			ensure_signed(origin)?;
2895			Self::do_payout_stakers_by_page(validator_stash, era, page)
2896		}
2897
2898		/// Migrates an account's `RewardDestination::Controller` to
2899		/// `RewardDestination::Account(controller)`.
2900		///
2901		/// Effects will be felt instantly (as soon as this function is completed successfully).
2902		///
2903		/// This will waive the transaction fee if the `payee` is successfully migrated.
2904		#[pallet::call_index(27)]
2905		#[pallet::weight(T::WeightInfo::update_payee())]
2906		pub fn update_payee(
2907			origin: OriginFor<T>,
2908			controller: T::AccountId,
2909		) -> DispatchResultWithPostInfo {
2910			let _ = ensure_signed(origin)?;
2911			let ledger = Self::ledger(StakingAccount::Controller(controller.clone()))?;
2912
2913			ensure!(
2914				(Payee::<T>::get(&ledger.stash) == {
2915					#[allow(deprecated)]
2916					Some(RewardDestination::Controller)
2917				}),
2918				Error::<T>::NotController
2919			);
2920
2921			let _ = ledger
2922				.set_payee(RewardDestination::Account(controller))
2923				.defensive_proof("ledger should have been previously retrieved from storage.")?;
2924
2925			Ok(Pays::No.into())
2926		}
2927
2928		/// Updates a batch of controller accounts to their corresponding stash account if they are
2929		/// not the same. Ignores any controller accounts that do not exist, and does not operate if
2930		/// the stash and controller are already the same.
2931		///
2932		/// Effects will be felt instantly (as soon as this function is completed successfully).
2933		///
2934		/// The dispatch origin must be `T::AdminOrigin`.
2935		#[pallet::call_index(28)]
2936		#[pallet::weight(T::WeightInfo::deprecate_controller_batch(controllers.len() as u32))]
2937		pub fn deprecate_controller_batch(
2938			origin: OriginFor<T>,
2939			controllers: BoundedVec<T::AccountId, T::MaxControllersInDeprecationBatch>,
2940		) -> DispatchResultWithPostInfo {
2941			T::AdminOrigin::ensure_origin(origin)?;
2942
2943			// Ignore controllers that do not exist or are already the same as stash.
2944			let filtered_batch_with_ledger: Vec<_> = controllers
2945				.iter()
2946				.filter_map(|controller| {
2947					let ledger = Self::ledger(StakingAccount::Controller(controller.clone()));
2948					ledger.ok().map_or(None, |ledger| {
2949						// If the controller `RewardDestination` is still the deprecated
2950						// `Controller` variant, skip deprecating this account.
2951						let payee_deprecated = Payee::<T>::get(&ledger.stash) == {
2952							#[allow(deprecated)]
2953							Some(RewardDestination::Controller)
2954						};
2955
2956						if ledger.stash != *controller && !payee_deprecated {
2957							Some(ledger)
2958						} else {
2959							None
2960						}
2961					})
2962				})
2963				.collect();
2964
2965			// Update unique pairs.
2966			let mut failures = 0;
2967			for ledger in filtered_batch_with_ledger {
2968				let _ = ledger.clone().set_controller_to_stash().map_err(|_| failures += 1);
2969			}
2970			Self::deposit_event(Event::<T>::ControllerBatchDeprecated { failures });
2971
2972			Ok(Some(T::WeightInfo::deprecate_controller_batch(controllers.len() as u32)).into())
2973		}
2974
2975		/// Restores the state of a ledger which is in an inconsistent state.
2976		///
2977		/// The requirements to restore a ledger are the following:
2978		/// * The stash is bonded; or
2979		/// * The stash is not bonded but it has a staking lock left behind; or
2980		/// * If the stash has an associated ledger and its state is inconsistent; or
2981		/// * If the ledger is not corrupted *but* its staking lock is out of sync.
2982		///
2983		/// The `maybe_*` input parameters will overwrite the corresponding data and metadata of the
2984		/// ledger associated with the stash. If the input parameters are not set, the ledger will
2985		/// be reset values from on-chain state.
2986		#[pallet::call_index(29)]
2987		#[pallet::weight(T::WeightInfo::restore_ledger())]
2988		pub fn restore_ledger(
2989			origin: OriginFor<T>,
2990			stash: T::AccountId,
2991			maybe_controller: Option<T::AccountId>,
2992			maybe_total: Option<BalanceOf<T>>,
2993			maybe_unlocking: Option<BoundedVec<UnlockChunk<BalanceOf<T>>, T::MaxUnlockingChunks>>,
2994		) -> DispatchResult {
2995			T::AdminOrigin::ensure_origin(origin)?;
2996
2997			// cannot restore ledger for virtual stakers.
2998			ensure!(!Self::is_virtual_staker(&stash), Error::<T>::VirtualStakerNotAllowed);
2999
3000			let current_lock = asset::staked::<T>(&stash);
3001			let stash_balance = asset::stakeable_balance::<T>(&stash);
3002
3003			let (new_controller, new_total) = match Self::inspect_bond_state(&stash) {
3004				Ok(LedgerIntegrityState::Corrupted) => {
3005					let new_controller = maybe_controller.unwrap_or(stash.clone());
3006
3007					let new_total = if let Some(total) = maybe_total {
3008						let new_total = total.min(stash_balance);
3009						// enforce hold == ledger.amount.
3010						asset::update_stake::<T>(&stash, new_total)?;
3011						new_total
3012					} else {
3013						current_lock
3014					};
3015
3016					Ok((new_controller, new_total))
3017				},
3018				Ok(LedgerIntegrityState::CorruptedKilled) => {
3019					if current_lock == Zero::zero() {
3020						// this case needs to restore both lock and ledger, so the new total needs
3021						// to be given by the called since there's no way to restore the total
3022						// on-chain.
3023						ensure!(maybe_total.is_some(), Error::<T>::CannotRestoreLedger);
3024						Ok((
3025							stash.clone(),
3026							maybe_total.expect("total exists as per the check above; qed."),
3027						))
3028					} else {
3029						Ok((stash.clone(), current_lock))
3030					}
3031				},
3032				Ok(LedgerIntegrityState::LockCorrupted) => {
3033					// ledger is not corrupted but its locks are out of sync. In this case, we need
3034					// to enforce a new ledger.total and staking lock for this stash.
3035					let new_total =
3036						maybe_total.ok_or(Error::<T>::CannotRestoreLedger)?.min(stash_balance);
3037					asset::update_stake::<T>(&stash, new_total)?;
3038
3039					Ok((stash.clone(), new_total))
3040				},
3041				Err(Error::<T>::BadState) => {
3042					// the stash and ledger do not exist but lock is lingering.
3043					asset::kill_stake::<T>(&stash)?;
3044					ensure!(
3045						Self::inspect_bond_state(&stash) == Err(Error::<T>::NotStash),
3046						Error::<T>::BadState
3047					);
3048
3049					return Ok(());
3050				},
3051				Ok(LedgerIntegrityState::Ok) | Err(_) => Err(Error::<T>::CannotRestoreLedger),
3052			}?;
3053
3054			// re-bond stash and controller tuple.
3055			Bonded::<T>::insert(&stash, &new_controller);
3056
3057			// resoter ledger state.
3058			let mut ledger = StakingLedger::<T>::new(stash.clone(), new_total);
3059			ledger.controller = Some(new_controller);
3060			ledger.unlocking = maybe_unlocking.unwrap_or_default();
3061			ledger.update()?;
3062
3063			ensure!(
3064				Self::inspect_bond_state(&stash) == Ok(LedgerIntegrityState::Ok),
3065				Error::<T>::BadState
3066			);
3067			Ok(())
3068		}
3069
3070		/// Migrates permissionlessly a stash from locks to holds.
3071		///
3072		/// This removes the old lock on the stake and creates a hold on it atomically. If all
3073		/// stake cannot be held, the best effort is made to hold as much as possible. The remaining
3074		/// stake is removed from the ledger.
3075		///
3076		/// The fee is waived if the migration is successful.
3077		#[pallet::call_index(30)]
3078		#[pallet::weight(T::WeightInfo::migrate_currency())]
3079		pub fn migrate_currency(
3080			origin: OriginFor<T>,
3081			stash: T::AccountId,
3082		) -> DispatchResultWithPostInfo {
3083			let _ = ensure_signed(origin)?;
3084			Self::do_migrate_currency(&stash)?;
3085
3086			// Refund the transaction fee if successful.
3087			Ok(Pays::No.into())
3088		}
3089
3090		/// Manually and permissionlessly applies a deferred slash for a given era.
3091		///
3092		/// Normally, slashes are automatically applied shortly after the start of the `slash_era`.
3093		/// The automatic application of slashes is handled by the pallet's internal logic, and it
3094		/// tries to apply one slash page per block of the era.
3095		/// If for some reason, one era is not enough for applying all slash pages, the remaining
3096		/// slashes need to be manually (permissionlessly) applied.
3097		///
3098		/// For a given era x, if at era x+1, slashes are still unapplied, all withdrawals get
3099		/// blocked, and these need to be manually applied by calling this function.
3100		/// This function exists as a **fallback mechanism** for this extreme situation, but we
3101		/// never expect to encounter this in normal scenarios.
3102		///
3103		/// The parameters for this call can be queried by looking at the `UnappliedSlashes` storage
3104		/// for eras older than the active era.
3105		///
3106		/// ## Parameters
3107		/// - `slash_era`: The application era (`offence_era + SlashDeferDuration`), i.e. the key
3108		///   into [`UnappliedSlashes`].
3109		/// - `slash_key`: A unique identifier for the slash, represented as a tuple:
3110		///   - `stash`: The stash account of the validator being slashed.
3111		///   - `slash_fraction`: The fraction of the stake that was slashed.
3112		///   - `page_index`: The index of the exposure page being processed.
3113		///
3114		/// ## Behavior
3115		/// - The function is **permissionless**—anyone can call it.
3116		/// - The `slash_era` **must be the current era or a past era**.
3117		/// If it is in the future, the
3118		///   call fails with `EraNotStarted`.
3119		/// - The fee is waived if the slash is successfully applied.
3120		///
3121		/// ## Future Improvement
3122		/// - Implement an **off-chain worker (OCW) task** to automatically apply slashes when there
3123		///   is unused block space, improving efficiency.
3124		#[pallet::call_index(31)]
3125		#[pallet::weight(T::WeightInfo::apply_slash(T::MaxExposurePageSize::get()))]
3126		pub fn apply_slash(
3127			origin: OriginFor<T>,
3128			slash_era: EraIndex,
3129			slash_key: (T::AccountId, Perbill, u32),
3130		) -> DispatchResultWithPostInfo {
3131			let _ = ensure_signed(origin)?;
3132			let active_era = ActiveEra::<T>::get().map(|a| a.index).unwrap_or_default();
3133			ensure!(slash_era <= active_era, Error::<T>::EraNotStarted);
3134
3135			// Check if this slash has been cancelled
3136			ensure!(
3137				!Self::check_slash_cancelled(slash_era, &slash_key.0, slash_key.1),
3138				Error::<T>::CancelledSlash
3139			);
3140
3141			let unapplied_slash = UnappliedSlashes::<T>::take(&slash_era, &slash_key)
3142				.ok_or(Error::<T>::InvalidSlashRecord)?;
3143			slashing::apply_slash::<T>(unapplied_slash, Self::offence_era_of(slash_era));
3144
3145			Ok(Pays::No.into())
3146		}
3147
3148		/// Perform one step of era pruning to prevent PoV size exhaustion from unbounded deletions.
3149		///
3150		/// This extrinsic enables permissionless lazy pruning of era data by performing
3151		/// incremental deletion of storage items. Each call processes a limited number
3152		/// of items based on available block weight to avoid exceeding block limits.
3153		///
3154		/// Returns `Pays::No` when work is performed to incentivize regular maintenance.
3155		/// Anyone can call this to help maintain the chain's storage health.
3156		///
3157		/// The era must be eligible for pruning (older than HistoryDepth + 1).
3158		/// Check `EraPruningState` storage to see if an era needs pruning before calling.
3159		#[pallet::call_index(32)]
3160		// NOTE: as pre-dispatch weight, use the maximum of all possible pruning step weights
3161		#[pallet::weight({
3162			let v = T::MaxValidatorSet::get();
3163			T::WeightInfo::prune_era_stakers_paged(v)
3164				.max(T::WeightInfo::prune_era_stakers_overview(v))
3165				.max(T::WeightInfo::prune_era_validator_prefs(v))
3166				.max(T::WeightInfo::prune_era_claimed_rewards(v))
3167				.max(T::WeightInfo::prune_era_validator_reward())
3168				.max(T::WeightInfo::prune_era_reward_points())
3169				.max(T::WeightInfo::prune_era_single_entry_cleanups())
3170				.max(T::WeightInfo::prune_era_validator_slash_in_era(v))
3171				.max(T::WeightInfo::prune_era_validator_incentive_weight(v))
3172		})]
3173		pub fn prune_era_step(origin: OriginFor<T>, era: EraIndex) -> DispatchResultWithPostInfo {
3174			let _ = ensure_signed(origin)?;
3175
3176			// Verify era is eligible for pruning: era <= active_era - history_depth - 1
3177			let active_era = crate::session_rotation::Rotator::<T>::active_era();
3178			let history_depth = T::HistoryDepth::get();
3179			let earliest_prunable_era = active_era.saturating_sub(history_depth).saturating_sub(1);
3180			ensure!(era <= earliest_prunable_era, Error::<T>::EraNotPrunable);
3181
3182			let actual_weight = Self::do_prune_era_step(era)?;
3183
3184			Ok(frame_support::dispatch::PostDispatchInfo {
3185				actual_weight: Some(actual_weight),
3186				pays_fee: frame_support::dispatch::Pays::No,
3187			})
3188		}
3189
3190		/// Sets the maximum commission that validators can set.
3191		///
3192		/// The dispatch origin must be `T::AdminOrigin`.
3193		#[pallet::call_index(33)]
3194		#[pallet::weight(T::WeightInfo::set_max_commission())]
3195		pub fn set_max_commission(origin: OriginFor<T>, new: Perbill) -> DispatchResult {
3196			T::AdminOrigin::ensure_origin(origin)?;
3197			ensure!(new >= MinCommission::<T>::get(), Error::<T>::CommissionTooLow);
3198			MaxCommission::<T>::put(new);
3199			Ok(())
3200		}
3201
3202		/// Configure the validator self-stake incentive parameters.
3203		///
3204		/// The dispatch origin must be `T::AdminOrigin`.
3205		///
3206		/// Changes take effect in the next era when rewards are calculated.
3207		#[pallet::call_index(34)]
3208		#[pallet::weight(T::WeightInfo::set_validator_self_stake_incentive_config())]
3209		pub fn set_validator_self_stake_incentive_config(
3210			origin: OriginFor<T>,
3211			optimum_self_stake: ConfigOp<BalanceOf<T>>,
3212			hard_cap_self_stake: ConfigOp<BalanceOf<T>>,
3213			self_stake_slope_factor: ConfigOp<Perbill>,
3214		) -> DispatchResult {
3215			T::AdminOrigin::ensure_origin(origin)?;
3216
3217			let new_optimum = match optimum_self_stake {
3218				ConfigOp::Noop => OptimumSelfStake::<T>::get(),
3219				ConfigOp::Set(v) => v,
3220				ConfigOp::Remove => BalanceOf::<T>::zero(),
3221			};
3222
3223			let new_cap = match hard_cap_self_stake {
3224				ConfigOp::Noop => HardCapSelfStake::<T>::get(),
3225				ConfigOp::Set(v) => v,
3226				ConfigOp::Remove => BalanceOf::<T>::zero(),
3227			};
3228
3229			ensure!(new_optimum <= new_cap, Error::<T>::OptimumGreaterThanCap);
3230
3231			let has_changes = !matches!(
3232				(&optimum_self_stake, &hard_cap_self_stake, &self_stake_slope_factor),
3233				(ConfigOp::Noop, ConfigOp::Noop, ConfigOp::Noop)
3234			);
3235
3236			macro_rules! config_op_exp {
3237				($storage:ty, $op:ident) => {
3238					match $op {
3239						ConfigOp::Noop => (),
3240						ConfigOp::Set(v) => <$storage>::put(v),
3241						ConfigOp::Remove => <$storage>::kill(),
3242					}
3243				};
3244			}
3245
3246			config_op_exp!(OptimumSelfStake<T>, optimum_self_stake);
3247			config_op_exp!(HardCapSelfStake<T>, hard_cap_self_stake);
3248			config_op_exp!(SelfStakeSlopeFactor<T>, self_stake_slope_factor);
3249
3250			if has_changes {
3251				Self::deposit_event(Event::<T>::ValidatorIncentiveConfigSet {
3252					optimum_self_stake: OptimumSelfStake::<T>::get(),
3253					hard_cap_self_stake: HardCapSelfStake::<T>::get(),
3254					slope_factor: SelfStakeSlopeFactor::<T>::get(),
3255				});
3256			}
3257
3258			Ok(())
3259		}
3260
3261		/// Chill an inactive validator.
3262		///
3263		/// This extrinsic can be called by anyone, given that the valid inactivity proof is
3264		/// provided. Inactivity proof is a vector of eras where the given validator was inactive.
3265		///
3266		/// Disabled while [`ChillInactiveThreshold`] is not set.
3267		///
3268		/// Requirements for the inactivity proof:
3269		/// - The length must be equal to [`ChillInactiveThreshold`].
3270		/// - It must be sorted in ascending order.
3271		/// - It must not contain duplicate entries.
3272		/// - For every era the `stash` account must be exposed.
3273		/// - Every item must pass the check provided by [`Config::IsValidatorInactive`].
3274		/// - Every era must be less than the active era.
3275		///
3276		/// On a successfull execution, caller doesn't pay fees.
3277		#[pallet::call_index(35)]
3278		#[pallet::weight(T::WeightInfo::chill_inactive(proof.len() as _))]
3279		pub fn chill_inactive(
3280			origin: OriginFor<T>,
3281			stash: T::AccountId,
3282			proof: BoundedVec<EraIndex, T::HistoryDepth>,
3283		) -> DispatchResultWithPostInfo {
3284			ensure_signed(origin)?;
3285
3286			let threshold =
3287				ChillInactiveThreshold::<T>::get().ok_or(Error::<T>::ChillInactiveDisabled)?;
3288			ensure!(
3289				proof.len() as EraIndex == threshold,
3290				Error::<T>::InvalidInactivityProof(InvalidInactivityProofError::InvalidLen)
3291			);
3292			ensure!(
3293				proof.is_sorted_by(|a, b| a < b),
3294				Error::<T>::InvalidInactivityProof(InvalidInactivityProofError::NotSorted)
3295			);
3296
3297			// All proof eras must fall in the retained window `[active_era - HistoryDepth,
3298			// active_era)`.
3299			let active_era = Rotator::<T>::active_era();
3300			let oldest_allowed_era = active_era.saturating_sub(T::HistoryDepth::get());
3301			let oldest_proof_era = proof.first().copied().unwrap_or(EraIndex::MAX);
3302			let most_recent_proof_era = proof.last().copied().unwrap_or(EraIndex::MAX);
3303			ensure!(
3304				oldest_proof_era >= oldest_allowed_era && most_recent_proof_era < active_era,
3305				Error::<T>::InvalidInactivityProof(InvalidInactivityProofError::InvalidEra)
3306			);
3307
3308			for era in proof {
3309				ensure!(
3310					Eras::<T>::was_validator_exposed(era, &stash),
3311					Error::<T>::InvalidInactivityProof(
3312						InvalidInactivityProofError::ValidatorNotExposed
3313					)
3314				);
3315
3316				let points = Eras::<T>::get_reward_points_by_service_for_validator(era, &stash);
3317
3318				ensure!(
3319					T::IsValidatorInactive::is_inactive(era, &stash, &points),
3320					Error::<T>::InvalidInactivityProof(
3321						InvalidInactivityProofError::ValidatorActive
3322					)
3323				);
3324			}
3325
3326			if Self::do_remove_validator(&stash) {
3327				Self::deposit_event(Event::<T>::Chilled { stash });
3328
3329				Ok(Pays::No.into())
3330			} else {
3331				Err(Error::<T>::BadTarget.into())
3332			}
3333		}
3334	}
3335
3336	#[pallet::view_functions]
3337	impl<T: Config> Pallet<T> {
3338		/// Resolve the account ID for a given reward pot.
3339		pub fn pot_account(pot: crate::RewardPot) -> T::AccountId {
3340			<T::RewardPots as crate::PotAccountProvider<T::AccountId>>::pot_account(pot)
3341		}
3342
3343		/// Current balance held in a given reward pot.
3344		pub fn pot_balance(pot: crate::RewardPot) -> BalanceOf<T> {
3345			let account =
3346				<T::RewardPots as crate::PotAccountProvider<T::AccountId>>::pot_account(pot);
3347			<T::Currency as frame_support::traits::fungible::Inspect<T::AccountId>>::balance(
3348				&account,
3349			)
3350		}
3351
3352		/// Per-era reward allocation (staker rewards + validator incentive budget).
3353		///
3354		/// Both fields are zero for eras created in legacy minting mode.
3355		pub fn era_reward_allocation(
3356			era: EraIndex,
3357		) -> crate::reward::EraRewardAllocation<BalanceOf<T>> {
3358			crate::reward::EraRewardAllocation {
3359				staker_rewards: ErasValidatorReward::<T>::get(era).unwrap_or_else(Zero::zero),
3360				validator_incentive: ErasValidatorIncentiveBudget::<T>::get(era),
3361			}
3362		}
3363	}
3364}