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}