Enum pallet_staking::RawEvent

pub enum RawEvent<Balance, AccountId> {
    EraPayout(EraIndex, Balance, Balance),
    Reward(AccountId, Balance),
    Slash(AccountId, Balance),
    OldSlashingReportDiscarded(SessionIndex),
    StakingElection(ElectionCompute),
    SolutionStored(ElectionCompute),
    Bonded(AccountId, Balance),
    Unbonded(AccountId, Balance),
    Withdrawn(AccountId, Balance),
}

Events for this module.

Variants

EraPayout(EraIndex, Balance, Balance)

The era payout has been set; the first balance is the validator-payout; the second is the remainder from the maximum amount of reward.

Reward(AccountId, Balance)

The staker has been rewarded by this amount. AccountId is the stash account.

Slash(AccountId, Balance)

One validator (and its nominators) has been slashed by the given amount.

OldSlashingReportDiscarded(SessionIndex)

An old slashing report from a prior era was discarded because it could not be processed.

StakingElection(ElectionCompute)

A new set of stakers was elected with the given computation method.

SolutionStored(ElectionCompute)

A new solution for the upcoming election has been stored.

Bonded(AccountId, Balance)

An account has bonded this amount.

NOTE: This event is only emitted when funds are bonded via a dispatchable. Notably, it will not be emitted for staking rewards when they are added to stake.

Unbonded(AccountId, Balance)

An account has unbonded this amount.

Withdrawn(AccountId, Balance)

An account has called withdraw_unbonded and removed unbonding chunks worth Balance from the unlocking queue.

Trait Implementations

impl<Balance: Clone, AccountId: Clone> Clone for RawEvent<Balance, AccountId>

fn clone(&self) -> RawEvent<Balance, AccountId>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Balance, AccountId> Debug for RawEvent<Balance, AccountId> where
    Balance: Debug,
    AccountId: Debug, 

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

Formats the value using the given formatter.

impl<Balance, AccountId> Decode for RawEvent<Balance, AccountId> where
    Balance: Decode,
    Balance: Decode,
    Balance: Decode,
    Balance: Decode,
    AccountId: Decode,
    AccountId: Decode,
    Balance: Decode,
    Balance: Decode,
    AccountId: Decode,
    AccountId: Decode,
    Balance: Decode,
    Balance: Decode,
    AccountId: Decode,
    AccountId: Decode,
    Balance: Decode,
    Balance: Decode,
    AccountId: Decode,
    AccountId: Decode,
    Balance: Decode,
    Balance: Decode,
    AccountId: Decode,
    AccountId: Decode,
    Balance: Decode,
    Balance: Decode, 

fn decode<DecIn: Input>(input: &mut DecIn) -> Result<Self, Error>

Attempt to deserialise the value from input.

impl<Balance, AccountId> Encode for RawEvent<Balance, AccountId> where
    Balance: Encode,
    Balance: Encode,
    Balance: Encode,
    Balance: Encode,
    AccountId: Encode,
    AccountId: Encode,
    Balance: Encode,
    Balance: Encode,
    AccountId: Encode,
    AccountId: Encode,
    Balance: Encode,
    Balance: Encode,
    AccountId: Encode,
    AccountId: Encode,
    Balance: Encode,
    Balance: Encode,
    AccountId: Encode,
    AccountId: Encode,
    Balance: Encode,
    Balance: Encode,
    AccountId: Encode,
    AccountId: Encode,
    Balance: Encode,
    Balance: Encode, 

fn encode_to<EncOut: Output>(&self, dest: &mut EncOut)

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>

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.

impl<Balance, AccountId> EncodeLike<RawEvent<Balance, AccountId>> for RawEvent<Balance, AccountId> where
    Balance: Encode,
    Balance: Encode,
    Balance: Encode,
    Balance: Encode,
    AccountId: Encode,
    AccountId: Encode,
    Balance: Encode,
    Balance: Encode,
    AccountId: Encode,
    AccountId: Encode,
    Balance: Encode,
    Balance: Encode,
    AccountId: Encode,
    AccountId: Encode,
    Balance: Encode,
    Balance: Encode,
    AccountId: Encode,
    AccountId: Encode,
    Balance: Encode,
    Balance: Encode,
    AccountId: Encode,
    AccountId: Encode,
    Balance: Encode,
    Balance: Encode, 

impl<Balance: Eq, AccountId: Eq> Eq for RawEvent<Balance, AccountId>

impl<Balance, AccountId> From<RawEvent<Balance, AccountId>> for ()

fn from(_: RawEvent<Balance, AccountId>)

Performs the conversion.

impl<Balance: PartialEq, AccountId: PartialEq> PartialEq<RawEvent<Balance, AccountId>> for RawEvent<Balance, AccountId>

fn eq(&self, other: &RawEvent<Balance, AccountId>) -> bool

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

fn ne(&self, other: &RawEvent<Balance, AccountId>) -> bool

This method tests for !=.

impl<Balance, AccountId> StructuralEq for RawEvent<Balance, AccountId>

impl<Balance, AccountId> StructuralPartialEq for RawEvent<Balance, AccountId>