Trait Config

pub trait Config: Config + Config<RuntimeEvent: From<Event<Self>>> {
    type OldCurrency: InspectLockableCurrency<Self::AccountId, Moment = BlockNumberFor<Self>, Balance = Self::CurrencyBalance>;
    type Currency: FunHoldMutate<Self::AccountId, Reason = Self::RuntimeHoldReason, Balance = Self::CurrencyBalance> + FunMutate<Self::AccountId, Balance = Self::CurrencyBalance> + FunHoldBalanced<Self::AccountId, Balance = Self::CurrencyBalance>;
    type RuntimeHoldReason: From<HoldReason>;
    type CurrencyBalance: AtLeast32BitUnsigned + FullCodec + DecodeWithMemTracking + HasCompact<Type: DecodeWithMemTracking> + Copy + MaybeSerializeDeserialize + Debug + Default + From<u64> + TypeInfo + Send + Sync + MaxEncodedLen;
    type CurrencyToVote: CurrencyToVote<BalanceOf<Self>>;
    type ElectionProvider: ElectionProvider<AccountId = Self::AccountId, BlockNumber = BlockNumberFor<Self>, DataProvider = Pallet<Self>>;
    type NominationsQuota: NominationsQuota<BalanceOf<Self>>;
    type HistoryDepth: Get<u32>;
    type RewardRemainder: OnUnbalanced<NegativeImbalanceOf<Self>>;
    type Slash: OnUnbalanced<NegativeImbalanceOf<Self>>;
    type Reward: OnUnbalanced<Debt<<Self as Config>::AccountId, <Self as Config>::Currency>>;
    type SessionsPerEra: Get<SessionIndex>;
    type PlanningEraOffset: Get<SessionIndex>;
    type BondingDuration: Get<EraIndex>;
    type SlashDeferDuration: Get<EraIndex>;
    type AdminOrigin: EnsureOrigin<Self::RuntimeOrigin>;
    type EraPayout: EraPayout<BalanceOf<Self>>;
    type MaxExposurePageSize: Get<u32>;
    type MaxValidatorSet: Get<u32>;
    type VoterList: SortedListProvider<Self::AccountId, Score = VoteWeight>;
    type TargetList: SortedListProvider<Self::AccountId, Score = BalanceOf<Self>>;
    type MaxUnlockingChunks: Get<u32>;
    type MaxControllersInDeprecationBatch: Get<u32>;
    type EventListeners: OnStakingUpdate<Self::AccountId, BalanceOf<Self>>;
    type MaxInvulnerables: Get<u32>;
    type MaxDisabledValidators: Get<u32>;
    type RcClientInterface: RcClientInterface<AccountId = Self::AccountId>;
    type Filter: Contains<Self::AccountId>;
    type WeightInfo: WeightInfo;
}

Configuration trait of this pallet.

The main purpose of this trait is to act as an interface between this pallet and the runtime in which it is embedded in. A type, function, or constant in this trait is essentially left to be configured by the runtime that includes this pallet.

Consequently, a runtime that wants to include this pallet must implement this trait.

Required Associated Types

type OldCurrency: InspectLockableCurrency<Self::AccountId, Moment = BlockNumberFor<Self>, Balance = Self::CurrencyBalance>

The old trait for staking balance. Deprecated and only used for migrating old ledgers.

type Currency: FunHoldMutate<Self::AccountId, Reason = Self::RuntimeHoldReason, Balance = Self::CurrencyBalance> + FunMutate<Self::AccountId, Balance = Self::CurrencyBalance> + FunHoldBalanced<Self::AccountId, Balance = Self::CurrencyBalance>

The staking balance.

type RuntimeHoldReason: From<HoldReason>

Overarching hold reason.

type CurrencyBalance: AtLeast32BitUnsigned + FullCodec + DecodeWithMemTracking + HasCompact<Type: DecodeWithMemTracking> + Copy + MaybeSerializeDeserialize + Debug + Default + From<u64> + TypeInfo + Send + Sync + MaxEncodedLen

Just the Currency::Balance type; we have this item to allow us to constrain it to From<u64>.

type CurrencyToVote: CurrencyToVote<BalanceOf<Self>>

Convert a balance into a number used for election calculation. This must fit into a u64 but is allowed to be sensibly lossy. The u64 is used to communicate with the [frame_election_provider_support] crate which accepts u64 numbers and does operations in 128. Consequently, the backward convert is used convert the u128s from sp-elections back to a BalanceOf.

type ElectionProvider: ElectionProvider<AccountId = Self::AccountId, BlockNumber = BlockNumberFor<Self>, DataProvider = Pallet<Self>>

Something that provides the election functionality.

type NominationsQuota: NominationsQuota<BalanceOf<Self>>

Something that defines the maximum number of nominations per nominator.

type HistoryDepth: Get<u32>

Number of eras to keep in history.

Following information is kept for eras in [current_era - HistoryDepth, current_era]: ErasValidatorPrefs, ErasValidatorReward, ErasRewardPoints, ErasTotalStake, ErasClaimedRewards, ErasStakersPaged, ErasStakersOverview.

Must be more than the number of eras delayed by session. I.e. active era must always be in history. I.e. active_era > current_era - history_depth must be guaranteed.

If migrating an existing pallet from storage value to config value, this should be set to same value or greater as in storage.

type RewardRemainder: OnUnbalanced<NegativeImbalanceOf<Self>>

Tokens have been minted and are unused for validator-reward. See Era payout.

type Slash: OnUnbalanced<NegativeImbalanceOf<Self>>

Handler for the unbalanced reduction when slashing a staker.

type Reward: OnUnbalanced<Debt<<Self as Config>::AccountId, <Self as Config>::Currency>>

Handler for the unbalanced increment when rewarding a staker. NOTE: in most cases, the implementation of OnUnbalanced should modify the total issuance.

type SessionsPerEra: Get<SessionIndex>

Number of sessions per era.

type PlanningEraOffset: Get<SessionIndex>

Number of sessions before the end of an era when the election for the next era will start.

• This determines how many sessions before the last session of the era the staking election process should begin.
• The value is bounded between 1 (election starts at the beginning of the last session) and SessionsPerEra (election starts at the beginning of the first session of the era).

Example:

• If SessionsPerEra = 6 and PlanningEraOffset = 1, the election starts at the beginning of session 6 - 1 = 5.
• If PlanningEraOffset = 6, the election starts at the beginning of session 6 - 6 = 0, meaning it starts at the very beginning of the era.

type BondingDuration: Get<EraIndex>

Number of eras that staked funds must remain bonded for.

type SlashDeferDuration: Get<EraIndex>

Number of eras that slashes are deferred by, after computation.

This should be less than the bonding duration. Set to 0 if slashes should be applied immediately, without opportunity for intervention.

type AdminOrigin: EnsureOrigin<Self::RuntimeOrigin>

The origin which can manage less critical staking parameters that does not require root.

Supported actions: (1) cancel deferred slash, (2) set minimum commission.

type EraPayout: EraPayout<BalanceOf<Self>>

The payout for validators and the system for the current era. See Era payout.

type MaxExposurePageSize: Get<u32>

The maximum size of each T::ExposurePage.

An ExposurePage is weakly bounded to a maximum of MaxExposurePageSize nominators.

For older non-paged exposure, a reward payout was restricted to the top MaxExposurePageSize nominators. This is to limit the i/o cost for the nominator payout.

Note: MaxExposurePageSize is used to bound ErasClaimedRewards and is unsafe to reduce without handling it in a migration.

type MaxValidatorSet: Get<u32>

The absolute maximum of winner validators this pallet should return.

As this pallet supports multi-block election, the set of winner validators per election is bounded by this type.

type VoterList: SortedListProvider<Self::AccountId, Score = VoteWeight>

Something that provides a best-effort sorted list of voters aka electing nominators, used for NPoS election.

The changes to nominators are reported to this. Moreover, each validator’s self-vote is also reported as one independent vote.

To keep the load off the chain as much as possible, changes made to the staked amount via rewards and slashes are not reported and thus need to be manually fixed by the staker. In case of bags-list, this always means using rebag and putInFrontOf.

Invariant: what comes out of this list will always be a nominator.

type TargetList: SortedListProvider<Self::AccountId, Score = BalanceOf<Self>>

WIP: This is a noop as of now, the actual business logic that’s described below is going to be introduced in a follow-up PR.

Something that provides a best-effort sorted list of targets aka electable validators, used for NPoS election.

The changes to the approval stake of each validator are reported to this. This means any change to:

1. The stake of any validator or nominator.
2. The targets of any nominator
3. The role of any staker (e.g. validator -> chilled, nominator -> validator, etc)

Unlike VoterList, the values in this list are always kept up to date with reward and slash as well, and thus represent the accurate approval stake of all account being nominated by nominators.

Note that while at the time of nomination, all targets are checked to be real validators, they can chill at any point, and their approval stakes will still be recorded. This implies that what comes out of iterating this list MIGHT NOT BE AN ACTIVE VALIDATOR.

type MaxUnlockingChunks: Get<u32>

The maximum number of unlocking chunks a StakingLedger can have. Effectively determines how many unique eras a staker may be unbonding in.

Note: MaxUnlockingChunks is used as the upper bound for the BoundedVec item StakingLedger.unlocking. Setting this value lower than the existing value can lead to inconsistencies in the StakingLedger and will need to be handled properly in a runtime migration. The test reducing_max_unlocking_chunks_abrupt shows this effect.

type MaxControllersInDeprecationBatch: Get<u32>

The maximum amount of controller accounts that can be deprecated in one call.

type EventListeners: OnStakingUpdate<Self::AccountId, BalanceOf<Self>>

Something that listens to staking updates and performs actions based on the data it receives.

WARNING: this only reports slashing and withdraw events for the time being.

type MaxInvulnerables: Get<u32>

Maximum number of invulnerable validators.

type MaxDisabledValidators: Get<u32>

Maximum number of disabled validators.

type RcClientInterface: RcClientInterface<AccountId = Self::AccountId>

Interface to talk to the RC-Client pallet, possibly sending election results to the relay chain.

type Filter: Contains<Self::AccountId>

Filter some accounts from participating in staking.

This is useful for example to blacklist an account that is participating in staking in another way (such as pools).

type WeightInfo: WeightInfo

Weight information for extrinsics in this pallet.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl Config for Runtime