Enum pallet_parachain_staking::pallet::Event

pub enum Event<T: Config> {
    NewRound {
        starting_block: BlockNumberFor<T>,
        round: RoundIndex,
        selected_collators_number: u32,
        total_balance: BalanceOf<T>,
    },
    JoinedCollatorCandidates {
        account: T::AccountId,
        amount_locked: BalanceOf<T>,
        new_total_amt_locked: BalanceOf<T>,
    },
    CollatorChosen {
        round: RoundIndex,
        collator_account: T::AccountId,
        total_exposed_amount: BalanceOf<T>,
    },
    CandidateBondLessRequested {
        candidate: T::AccountId,
        amount_to_decrease: BalanceOf<T>,
        execute_round: RoundIndex,
    },
    CandidateBondedMore {
        candidate: T::AccountId,
        amount: BalanceOf<T>,
        new_total_bond: BalanceOf<T>,
    },
    CandidateBondedLess {
        candidate: T::AccountId,
        amount: BalanceOf<T>,
        new_bond: BalanceOf<T>,
    },
    CandidateWentOffline {
        candidate: T::AccountId,
    },
    CandidateBackOnline {
        candidate: T::AccountId,
    },
    CandidateScheduledExit {
        exit_allowed_round: RoundIndex,
        candidate: T::AccountId,
        scheduled_exit: RoundIndex,
    },
    CancelledCandidateExit {
        candidate: T::AccountId,
    },
    CancelledCandidateBondLess {
        candidate: T::AccountId,
        amount: BalanceOf<T>,
        execute_round: RoundIndex,
    },
    CandidateLeft {
        ex_candidate: T::AccountId,
        unlocked_amount: BalanceOf<T>,
        new_total_amt_locked: BalanceOf<T>,
    },
    DelegationDecreaseScheduled {
        delegator: T::AccountId,
        candidate: T::AccountId,
        amount_to_decrease: BalanceOf<T>,
        execute_round: RoundIndex,
    },
    DelegationIncreased {
        delegator: T::AccountId,
        candidate: T::AccountId,
        amount: BalanceOf<T>,
        in_top: bool,
    },
    DelegationDecreased {
        delegator: T::AccountId,
        candidate: T::AccountId,
        amount: BalanceOf<T>,
        in_top: bool,
    },
    DelegatorExitScheduled {
        round: RoundIndex,
        delegator: T::AccountId,
        scheduled_exit: RoundIndex,
    },
    DelegationRevocationScheduled {
        round: RoundIndex,
        delegator: T::AccountId,
        candidate: T::AccountId,
        scheduled_exit: RoundIndex,
    },
    DelegatorLeft {
        delegator: T::AccountId,
        unstaked_amount: BalanceOf<T>,
    },
    DelegationRevoked {
        delegator: T::AccountId,
        candidate: T::AccountId,
        unstaked_amount: BalanceOf<T>,
    },
    DelegationKicked {
        delegator: T::AccountId,
        candidate: T::AccountId,
        unstaked_amount: BalanceOf<T>,
    },
    DelegatorExitCancelled {
        delegator: T::AccountId,
    },
    CancelledDelegationRequest {
        delegator: T::AccountId,
        cancelled_request: CancelledScheduledRequest<BalanceOf<T>>,
        collator: T::AccountId,
    },
    Delegation {
        delegator: T::AccountId,
        locked_amount: BalanceOf<T>,
        candidate: T::AccountId,
        delegator_position: DelegatorAdded<BalanceOf<T>>,
        auto_compound: Percent,
    },
    DelegatorLeftCandidate {
        delegator: T::AccountId,
        candidate: T::AccountId,
        unstaked_amount: BalanceOf<T>,
        total_candidate_staked: BalanceOf<T>,
    },
    Rewarded {
        account: T::AccountId,
        rewards: BalanceOf<T>,
    },
    InflationDistributed {
        index: u32,
        account: T::AccountId,
        value: BalanceOf<T>,
    },
    InflationDistributionConfigUpdated {
        old: InflationDistributionConfig<T::AccountId>,
        new: InflationDistributionConfig<T::AccountId>,
    },
    InflationSet {
        annual_min: Perbill,
        annual_ideal: Perbill,
        annual_max: Perbill,
        round_min: Perbill,
        round_ideal: Perbill,
        round_max: Perbill,
    },
    StakeExpectationsSet {
        expect_min: BalanceOf<T>,
        expect_ideal: BalanceOf<T>,
        expect_max: BalanceOf<T>,
    },
    TotalSelectedSet {
        old: u32,
        new: u32,
    },
    CollatorCommissionSet {
        old: Perbill,
        new: Perbill,
    },
    BlocksPerRoundSet {
        current_round: RoundIndex,
        first_block: BlockNumberFor<T>,
        old: u32,
        new: u32,
        new_per_round_inflation_min: Perbill,
        new_per_round_inflation_ideal: Perbill,
        new_per_round_inflation_max: Perbill,
    },
    AutoCompoundSet {
        candidate: T::AccountId,
        delegator: T::AccountId,
        value: Percent,
    },
    Compounded {
        candidate: T::AccountId,
        delegator: T::AccountId,
        amount: BalanceOf<T>,
    },
    // some variants omitted
}

The Event enum of this pallet

Variants

NewRound

Fields

starting_block: BlockNumberFor<T>

round: RoundIndex

selected_collators_number: u32

total_balance: BalanceOf<T>

Started new round.

JoinedCollatorCandidates

Fields

account: T::AccountId

amount_locked: BalanceOf<T>

new_total_amt_locked: BalanceOf<T>

Account joined the set of collator candidates.

CollatorChosen

Fields

round: RoundIndex

collator_account: T::AccountId

total_exposed_amount: BalanceOf<T>

Candidate selected for collators. Total Exposed Amount includes all delegations.

CandidateBondLessRequested

Fields

candidate: T::AccountId

amount_to_decrease: BalanceOf<T>

execute_round: RoundIndex

Candidate requested to decrease a self bond.

CandidateBondedMore

Fields

candidate: T::AccountId

amount: BalanceOf<T>

new_total_bond: BalanceOf<T>

Candidate has increased a self bond.

CandidateBondedLess

Fields

candidate: T::AccountId

amount: BalanceOf<T>

new_bond: BalanceOf<T>

Candidate has decreased a self bond.

CandidateWentOffline

Fields

candidate: T::AccountId

Candidate temporarily leave the set of collator candidates without unbonding.

CandidateBackOnline

Fields

candidate: T::AccountId

Candidate rejoins the set of collator candidates.

CandidateScheduledExit

Fields

exit_allowed_round: RoundIndex

candidate: T::AccountId

scheduled_exit: RoundIndex

Candidate has requested to leave the set of candidates.

CancelledCandidateExit

Fields

candidate: T::AccountId

Cancelled request to leave the set of candidates.

CancelledCandidateBondLess

Fields

candidate: T::AccountId

amount: BalanceOf<T>

execute_round: RoundIndex

Cancelled request to decrease candidate’s bond.

CandidateLeft

Fields

ex_candidate: T::AccountId

unlocked_amount: BalanceOf<T>

new_total_amt_locked: BalanceOf<T>

Candidate has left the set of candidates.

DelegationDecreaseScheduled

Fields

delegator: T::AccountId

candidate: T::AccountId

amount_to_decrease: BalanceOf<T>

execute_round: RoundIndex

Delegator requested to decrease a bond for the collator candidate.

DelegationIncreased

Fields

delegator: T::AccountId

candidate: T::AccountId

amount: BalanceOf<T>

in_top: bool

DelegationDecreased

Fields

delegator: T::AccountId

candidate: T::AccountId

amount: BalanceOf<T>

in_top: bool

DelegatorExitScheduled

Fields

round: RoundIndex

delegator: T::AccountId

scheduled_exit: RoundIndex

Delegator requested to leave the set of delegators.

DelegationRevocationScheduled

Fields

round: RoundIndex

delegator: T::AccountId

candidate: T::AccountId

scheduled_exit: RoundIndex

Delegator requested to revoke delegation.

DelegatorLeft

Fields

delegator: T::AccountId

unstaked_amount: BalanceOf<T>

Delegator has left the set of delegators.

DelegationRevoked

Fields

delegator: T::AccountId

candidate: T::AccountId

unstaked_amount: BalanceOf<T>

Delegation revoked.

DelegationKicked

Fields

delegator: T::AccountId

candidate: T::AccountId

unstaked_amount: BalanceOf<T>

Delegation kicked.

DelegatorExitCancelled

Fields

delegator: T::AccountId

Cancelled a pending request to exit the set of delegators.

CancelledDelegationRequest

Fields

delegator: T::AccountId

cancelled_request: CancelledScheduledRequest<BalanceOf<T>>

collator: T::AccountId

Cancelled request to change an existing delegation.

Delegation

Fields

delegator: T::AccountId

locked_amount: BalanceOf<T>

candidate: T::AccountId

delegator_position: DelegatorAdded<BalanceOf<T>>

auto_compound: Percent

New delegation (increase of the existing one).

DelegatorLeftCandidate

Fields

delegator: T::AccountId

candidate: T::AccountId

unstaked_amount: BalanceOf<T>

total_candidate_staked: BalanceOf<T>

Delegation from candidate state has been remove.

Rewarded

Fields

account: T::AccountId

rewards: BalanceOf<T>

Paid the account (delegator or collator) the balance as liquid rewards.

InflationDistributed

Fields

index: u32

account: T::AccountId

value: BalanceOf<T>

Transferred to account which holds funds reserved for parachain bond.

InflationDistributionConfigUpdated

Fields

old: InflationDistributionConfig<T::AccountId>

new: InflationDistributionConfig<T::AccountId>

InflationSet

Fields

annual_min: Perbill

annual_ideal: Perbill

annual_max: Perbill

round_min: Perbill

round_ideal: Perbill

round_max: Perbill

Annual inflation input (first 3) was used to derive new per-round inflation (last 3)

StakeExpectationsSet

Fields

expect_min: BalanceOf<T>

expect_ideal: BalanceOf<T>

expect_max: BalanceOf<T>

Staking expectations set.

TotalSelectedSet

Fields

old: u32

new: u32

Set total selected candidates to this value.

CollatorCommissionSet

Fields

old: Perbill

new: Perbill

Set collator commission to this value.

BlocksPerRoundSet

Fields

current_round: RoundIndex

first_block: BlockNumberFor<T>

old: u32

new: u32

new_per_round_inflation_min: Perbill

new_per_round_inflation_ideal: Perbill

new_per_round_inflation_max: Perbill

Set blocks per round

AutoCompoundSet

Fields

candidate: T::AccountId

delegator: T::AccountId

value: Percent

Auto-compounding reward percent was set for a delegation.

Compounded

Fields

candidate: T::AccountId

delegator: T::AccountId

amount: BalanceOf<T>

Compounded a portion of rewards towards the delegation.

Trait Implementations

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

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

Formats the value using the given formatter.

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

where BlockNumberFor<T>: Decode, BalanceOf<T>: Decode, T::AccountId: Decode, CancelledScheduledRequest<BalanceOf<T>>: Decode, DelegatorAdded<BalanceOf<T>>: Decode, InflationDistributionConfig<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 BlockNumberFor<T>: Encode, BalanceOf<T>: Encode, T::AccountId: Encode, CancelledScheduledRequest<BalanceOf<T>>: Encode, DelegatorAdded<BalanceOf<T>>: Encode, InflationDistributionConfig<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

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

where BlockNumberFor<T>: TypeInfo + 'static, BalanceOf<T>: TypeInfo + 'static, T::AccountId: TypeInfo + 'static, CancelledScheduledRequest<BalanceOf<T>>: TypeInfo + 'static, DelegatorAdded<BalanceOf<T>>: TypeInfo + 'static, InflationDistributionConfig<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> EncodeLike for Event<T>

where BlockNumberFor<T>: Encode, BalanceOf<T>: Encode, T::AccountId: Encode, CancelledScheduledRequest<BalanceOf<T>>: Encode, DelegatorAdded<BalanceOf<T>>: Encode, InflationDistributionConfig<T::AccountId>: Encode,

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