Struct StakingLedger 

pub struct StakingLedger<T: Config> {
    pub stash: T::AccountId,
    pub total: BalanceOf<T>,
    pub active: BalanceOf<T>,
    pub unlocking: BoundedVec<UnlockChunk<BalanceOf<T>>, T::MaxUnlockingChunks>,
    pub controller: Option<T::AccountId>,
}

The ledger of a (bonded) stash.

Note: All the reads and mutations to the Ledger, Bonded and Payee storage items MUST be performed through the methods exposed by this struct, to ensure the consistency of ledger’s data and corresponding staking lock

TODO: move struct definition and full implementation into /src/ledger.rs. Currently leaving here to enforce a clean PR diff, given how critical this logic is. Tracking issue https://github.com/paritytech/substrate/issues/14749.

Fields

stash: T::AccountId

The stash account whose balance is actually locked and at stake.

total: BalanceOf<T>

The total amount of the stash’s balance that we are currently accounting for. It’s just active plus all the unlocking balances.

active: BalanceOf<T>

The total amount of the stash’s balance that will be at stake in any forthcoming rounds.

unlocking: BoundedVec<UnlockChunk<BalanceOf<T>>, T::MaxUnlockingChunks>

Any balance that is becoming free, which may eventually be transferred out of the stash (assuming it doesn’t get slashed first). It is assumed that this will be treated as a first in, first out queue where the new (higher value) eras get pushed on the back.

controller: Option<T::AccountId>

The controller associated with this ledger’s stash.

This is not stored on-chain, and is only bundled when the ledger is read from storage. Use Self::controller() function to get the controller associated with the ledger.

Implementations

impl<T: Config> StakingLedger<T>

pub fn new(stash: T::AccountId, stake: BalanceOf<T>) -> Self

Returns a new instance of a staking ledger.

The Ledger storage is not mutated. In order to store, StakingLedger::update must be called on the returned staking ledger.

Note: as the controller accounts are being deprecated, the stash account is the same as the controller account.

pub fn controller(&self) -> Option<T::AccountId>

Returns the controller account of a staking ledger.

Note: it will fallback into querying the Bonded storage with the ledger stash if the controller is not set in self, which most likely means that self was fetched directly from Ledger instead of through the methods exposed in StakingLedger. If the ledger does not exist in storage, it returns None.

pub fn slash( &mut self, slash_amount: BalanceOf<T>, minimum_balance: BalanceOf<T>, slash_era: EraIndex, ) -> BalanceOf<T>

Slash the staker for a given amount of balance.

This implements a proportional slashing system, whereby we set our preference to slash as such:

• If any unlocking chunks exist that are scheduled to be unlocked at slash_era + bonding_duration and onwards, the slash is divided equally between the active ledger and the unlocking chunks.
• If no such chunks exist, then only the active balance is slashed.

Note that the above is only a preference. If for any reason the active ledger, with or without some portion of the unlocking chunks that are more justified to be slashed are not enough, then the slashing will continue and will consume as much of the active and unlocking chunks as needed.

This will never slash more than the given amount. If any of the chunks become dusted, the last chunk is slashed slightly less to compensate. Returns the amount of funds actually slashed.

slash_era is the era in which the slash (which is being enacted now) actually happened.

This calls Config::OnStakingUpdate::on_slash with information as to how the slash was applied.

Trait Implementations

impl<T: Config> Clone for StakingLedger<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Config> Debug for StakingLedger<T>

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Config> Decode for StakingLedger<T>

where T::AccountId: Decode, BoundedVec<UnlockChunk<BalanceOf<T>>, T::MaxUnlockingChunks>: Decode, BalanceOf<T>: HasCompact, Option<T::AccountId>: Default,

fn decode<__CodecInputEdqy: Input>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self>, ) -> Result<DecodeFinished, Error>

where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

fn skip<I>(input: &mut I) -> Result<(), Error>

where I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<T: Config> Encode for StakingLedger<T>

where T::AccountId: Encode, BoundedVec<UnlockChunk<BalanceOf<T>>, T::MaxUnlockingChunks>: Encode, BalanceOf<T>: HasCompact,

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode_to<__CodecOutputEdqy: Output + ?Sized>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

Convert self to a slice and append it to the destination.

fn encode(&self) -> Vec<u8>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl<T: Config> MaxEncodedLen for StakingLedger<T>

where T::AccountId: MaxEncodedLen, BoundedVec<UnlockChunk<BalanceOf<T>>, T::MaxUnlockingChunks>: MaxEncodedLen, BalanceOf<T>: HasCompact,

fn max_encoded_len() -> usize

Upper bound, in bytes, of the maximum encoded size of this item.

impl<T: Config> PartialEq for StakingLedger<T>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> TypeInfo for StakingLedger<T>

where T::AccountId: TypeInfo + 'static, BalanceOf<T>: HasCompact, BoundedVec<UnlockChunk<BalanceOf<T>>, T::MaxUnlockingChunks>: TypeInfo + 'static, Option<T::AccountId>: TypeInfo + 'static, T: Config + 'static,

type Identity = StakingLedger<T>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<T: Config> DecodeWithMemTracking for StakingLedger<T>

where T::AccountId: DecodeWithMemTracking, BoundedVec<UnlockChunk<BalanceOf<T>>, T::MaxUnlockingChunks>: DecodeWithMemTracking, BalanceOf<T>: HasCompact, <BalanceOf<T> as HasCompact>::Type: DecodeWithMemTracking, Option<T::AccountId>: Default,

impl<T: Config> EncodeLike for StakingLedger<T>

where T::AccountId: Encode, BoundedVec<UnlockChunk<BalanceOf<T>>, T::MaxUnlockingChunks>: Encode, BalanceOf<T>: HasCompact,

impl<T: Config> Eq for StakingLedger<T>