Enum gsdk::metadata::staking::Event

pub enum Event {
    EraPaid {
        era_index: u32,
        validator_payout: u128,
        remainder: u128,
    },
    Rewarded {
        stash: AccountId32,
        dest: RewardDestination<AccountId32>,
        amount: u128,
    },
    Slashed {
        staker: AccountId32,
        amount: u128,
    },
    SlashReported {
        validator: AccountId32,
        fraction: Perbill,
        slash_era: u32,
    },
    OldSlashingReportDiscarded {
        session_index: u32,
    },
    StakersElected,
    Bonded {
        stash: AccountId32,
        amount: u128,
    },
    Unbonded {
        stash: AccountId32,
        amount: u128,
    },
    Withdrawn {
        stash: AccountId32,
        amount: u128,
    },
    Kicked {
        nominator: AccountId32,
        stash: AccountId32,
    },
    StakingElectionFailed,
    Chilled {
        stash: AccountId32,
    },
    PayoutStarted {
        era_index: u32,
        validator_stash: AccountId32,
    },
    ValidatorPrefsSet {
        stash: AccountId32,
        prefs: ValidatorPrefs,
    },
    SnapshotVotersSizeExceeded {
        size: u32,
    },
    SnapshotTargetsSizeExceeded {
        size: u32,
    },
    ForceEra {
        mode: Forcing,
    },
    ControllerBatchDeprecated {
        failures: u32,
    },
}

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: u32

validator_payout: u128

remainder: u128

Rewarded

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

Fields

stash: AccountId32

dest: RewardDestination<AccountId32>

amount: u128

Slashed

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

Fields

staker: AccountId32

amount: u128

SlashReported

A slash for the given validator, for the given percentage of their stake, at the given era as been reported.

Fields

validator: AccountId32

fraction: Perbill

slash_era: u32

OldSlashingReportDiscarded

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

Fields

session_index: u32

StakersElected

A new set of stakers was elected.

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: AccountId32

amount: u128

Unbonded

An account has unbonded this amount.

Fields

stash: AccountId32

amount: u128

Withdrawn

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

Fields

stash: AccountId32

amount: u128

Kicked

A nominator has been kicked from a validator.

Fields

nominator: AccountId32

stash: AccountId32

StakingElectionFailed

The election failed. No new era is planned.

Chilled

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

Fields

stash: AccountId32

PayoutStarted

The stakers’ rewards are getting paid.

Fields

era_index: u32

validator_stash: AccountId32

ValidatorPrefsSet

A validator has set their preferences.

Fields

stash: AccountId32

prefs: ValidatorPrefs

SnapshotVotersSizeExceeded

Voters size limit reached.

Fields

size: u32

SnapshotTargetsSizeExceeded

Targets size limit reached.

Fields

size: u32

ForceEra

A new force era mode was set.

Fields

mode: Forcing

ControllerBatchDeprecated

Report of a controller batch deprecation.

Fields

failures: u32

Trait Implementations

impl Debug for Event

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

Formats the value using the given formatter.

impl Decode for Event

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 Encode for Event

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 IntoVisitor for Event

type AnyVisitor<ScaleDecodeTypeResolver: TypeResolver> = Visitor<ScaleDecodeTypeResolver>

The visitor type used to decode SCALE encoded bytes to Self.

fn into_visitor<ScaleDecodeTypeResolver: TypeResolver>() -> Self::AnyVisitor<ScaleDecodeTypeResolver>

A means of obtaining this visitor.

impl EncodeLike for Event