Struct pallet_staking::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 claimed_rewards: BoundedVec<EraIndex, T::HistoryDepth>,
}

The ledger of a (bonded) stash.

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.

claimed_rewards: BoundedVec<EraIndex, T::HistoryDepth>

List of eras for which the stakers behind a validator have claimed rewards. Only updated for validators.

Implementations

impl<T: Config> StakingLedger<T>

pub fn default_from(stash: T::AccountId) -> Self

Initializes the default object using the given validator.

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::OnStakerSlash::on_slash with information as to how the slash was applied.

Examples found in repository

src/slashing.rs (line 611)

pub fn do_slash<T: Config>(
	stash: &T::AccountId,
	value: BalanceOf<T>,
	reward_payout: &mut BalanceOf<T>,
	slashed_imbalance: &mut NegativeImbalanceOf<T>,
	slash_era: EraIndex,
) {
	let controller = match <Pallet<T>>::bonded(stash).defensive() {
		None => return,
		Some(c) => c,
	};

	let mut ledger = match <Pallet<T>>::ledger(&controller) {
		Some(ledger) => ledger,
		None => return, // nothing to do.
	};

	let value = ledger.slash(value, T::Currency::minimum_balance(), slash_era);

	if !value.is_zero() {
		let (imbalance, missing) = T::Currency::slash(stash, value);
		slashed_imbalance.subsume(imbalance);

		if !missing.is_zero() {
			// deduct overslash from the reward payout
			*reward_payout = reward_payout.saturating_sub(missing);
		}

		<Pallet<T>>::update_ledger(&controller, &ledger);

		// trigger the event
		<Pallet<T>>::deposit_event(super::Event::<T>::Slashed {
			staker: stash.clone(),
			amount: value,
		});
	}
}

Trait Implementations

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

fn clone(&self) -> Self

Returns a copy 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,
    BoundedVec<EraIndex, T::HistoryDepth>: Decode,
    BalanceOf<T>: HasCompact,

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

Attempt to deserialise the value from input.

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,
    BoundedVec<EraIndex, T::HistoryDepth>: Encode,
    BalanceOf<T>: HasCompact,

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

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

fn size_hint(&self) -> usize

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

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

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> Rwhere
    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,
    BoundedVec<EraIndex, T::HistoryDepth>: 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<StakingLedger<T>> for StakingLedger<T>

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

This method tests for self and other values to be equal, and is used by ==.

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

This method 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,
    BoundedVec<EraIndex, T::HistoryDepth>: 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> EncodeLike<StakingLedger<T>> for StakingLedger<T>where
    T::AccountId: Encode,
    BoundedVec<UnlockChunk<BalanceOf<T>>, T::MaxUnlockingChunks>: Encode,
    BoundedVec<EraIndex, T::HistoryDepth>: Encode,
    BalanceOf<T>: HasCompact,

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