Enum Event 

pub enum Event<T: Config> {
    EraPaid {
        era_index: EraIndex,
        validator_payout: BalanceOf<T>,
        remainder: BalanceOf<T>,
    },
    Rewarded {
        stash: T::AccountId,
        dest: RewardDestination<T::AccountId>,
        amount: BalanceOf<T>,
    },
    Slashed {
        staker: T::AccountId,
        amount: BalanceOf<T>,
    },
    OldSlashingReportDiscarded {
        session_index: SessionIndex,
    },
    Bonded {
        stash: T::AccountId,
        amount: BalanceOf<T>,
    },
    Unbonded {
        stash: T::AccountId,
        amount: BalanceOf<T>,
    },
    Withdrawn {
        stash: T::AccountId,
        amount: BalanceOf<T>,
    },
    StakerRemoved {
        stash: T::AccountId,
    },
    Kicked {
        nominator: T::AccountId,
        stash: T::AccountId,
    },
    Chilled {
        stash: T::AccountId,
    },
    PayoutStarted {
        era_index: EraIndex,
        validator_stash: T::AccountId,
        page: Page,
        next: Option<Page>,
    },
    ValidatorPrefsSet {
        stash: T::AccountId,
        prefs: ValidatorPrefs,
    },
    SnapshotVotersSizeExceeded {
        size: u32,
    },
    SnapshotTargetsSizeExceeded {
        size: u32,
    },
    ForceEra {
        mode: Forcing,
    },
    ControllerBatchDeprecated {
        failures: u32,
    },
    CurrencyMigrated {
        stash: T::AccountId,
        force_withdraw: BalanceOf<T>,
    },
    PagedElectionProceeded {
        page: PageIndex,
        result: Result<u32, u32>,
    },
    OffenceReported {
        offence_era: EraIndex,
        validator: T::AccountId,
        fraction: Perbill,
    },
    SlashComputed {
        offence_era: EraIndex,
        slash_era: EraIndex,
        offender: T::AccountId,
        page: u32,
    },
    SlashCancelled {
        slash_era: EraIndex,
        validator: T::AccountId,
    },
    SessionRotated {
        starting_session: SessionIndex,
        active_era: EraIndex,
        planned_era: EraIndex,
    },
    Unexpected(UnexpectedKind),
    OffenceTooOld {
        offence_era: EraIndex,
        validator: T::AccountId,
        fraction: Perbill,
    },
    EraPruned {
        index: EraIndex,
    },
    // some variants omitted
}

The Event enum of this pallet

Variants

EraPaid

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

Fields

era_index: EraIndex

validator_payout: BalanceOf<T>

remainder: BalanceOf<T>

Rewarded

The nominator has been rewarded by this amount to this destination.

Fields

stash: T::AccountId

dest: RewardDestination<T::AccountId>

amount: BalanceOf<T>

Slashed

A staker (validator or nominator) has been slashed by the given amount.

Fields

staker: T::AccountId

amount: BalanceOf<T>

OldSlashingReportDiscarded

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

Fields

session_index: SessionIndex

Bonded

An account has bonded this amount. [stash, 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.

Fields

stash: T::AccountId

amount: BalanceOf<T>

Unbonded

An account has unbonded this amount.

Fields

stash: T::AccountId

amount: BalanceOf<T>

Withdrawn

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

Fields

stash: T::AccountId

amount: BalanceOf<T>

StakerRemoved

A subsequent event of Withdrawn, indicating that stash was fully removed from the system.

Fields

stash: T::AccountId

Kicked

A nominator has been kicked from a validator.

Fields

nominator: T::AccountId

stash: T::AccountId

Chilled

An account has stopped participating as either a validator or nominator.

Fields

stash: T::AccountId

PayoutStarted

A Page of stakers rewards are getting paid. next is None if all pages are claimed.

Fields

era_index: EraIndex

validator_stash: T::AccountId

page: Page

next: Option<Page>

ValidatorPrefsSet

A validator has set their preferences.

Fields

stash: T::AccountId

prefs: ValidatorPrefs

SnapshotVotersSizeExceeded

Voters size limit reached.

Fields

size: u32

SnapshotTargetsSizeExceeded

Targets size limit reached.

Fields

size: u32

ForceEra

Fields

mode: Forcing

ControllerBatchDeprecated

Report of a controller batch deprecation.

Fields

failures: u32

CurrencyMigrated

Staking balance migrated from locks to holds, with any balance that could not be held is force withdrawn.

Fields

stash: T::AccountId

force_withdraw: BalanceOf<T>

PagedElectionProceeded

A page from a multi-page election was fetched. A number of these are followed by StakersElected.

Ok(count) indicates the give number of stashes were added. Err(index) indicates that the stashes after index were dropped. Err(0) indicates that an error happened but no stashes were dropped nor added.

The error indicates that a number of validators were dropped due to excess size, but the overall election will continue.

Fields

page: PageIndex

result: Result<u32, u32>

OffenceReported

An offence for the given validator, for the given percentage of their stake, at the given era as been reported.

Fields

offence_era: EraIndex

validator: T::AccountId

fraction: Perbill

SlashComputed

An offence has been processed and the corresponding slash has been computed.

Fields

offence_era: EraIndex

slash_era: EraIndex

offender: T::AccountId

page: u32

SlashCancelled

An unapplied slash has been cancelled.

Fields

slash_era: EraIndex

validator: T::AccountId

SessionRotated

Session change has been triggered.

If planned_era is one era ahead of active_era, it implies new era is being planned and election is ongoing.

Fields

starting_session: SessionIndex

active_era: EraIndex

planned_era: EraIndex

Unexpected(UnexpectedKind)

Something occurred that should never happen under normal operation. Logged as an event for fail-safe observability.

OffenceTooOld

An offence was reported that was too old to be processed, and thus was dropped.

Fields

offence_era: EraIndex

validator: T::AccountId

fraction: Perbill

EraPruned

An old era with the given index was pruned.

Fields

index: EraIndex

Trait Implementations

impl<T: Config> Clone for Event<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 Event<T>

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

Formats the value using the given formatter.

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

where BalanceOf<T>: Decode, T::AccountId: Decode, RewardDestination<T::AccountId>: Decode,

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 Event<T>

where BalanceOf<T>: Encode, T::AccountId: Encode, RewardDestination<T::AccountId>: Encode,

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> From<Event<T>> for ()

fn from(_: Event<T>)

Converts to this type from the input type.

impl<T: Config> PartialEq for Event<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 Event<T>

where BalanceOf<T>: TypeInfo + 'static, T::AccountId: TypeInfo + 'static, RewardDestination<T::AccountId>: TypeInfo + 'static, PhantomData<T>: TypeInfo + 'static, T: Config + 'static,

type Identity = Event<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 Event<T>

where BalanceOf<T>: DecodeWithMemTracking, T::AccountId: DecodeWithMemTracking, RewardDestination<T::AccountId>: DecodeWithMemTracking,

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

where BalanceOf<T>: Encode, T::AccountId: Encode, RewardDestination<T::AccountId>: Encode,

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