Enum pallet_nomination_pools::pallet::Event

pub enum Event<T: Config> {
    Created {
        depositor: T::AccountId,
        pool_id: PoolId,
    },
    Bonded {
        member: T::AccountId,
        pool_id: PoolId,
        bonded: BalanceOf<T>,
        joined: bool,
    },
    PaidOut {
        member: T::AccountId,
        pool_id: PoolId,
        payout: BalanceOf<T>,
    },
    Unbonded {
        member: T::AccountId,
        pool_id: PoolId,
        balance: BalanceOf<T>,
        points: BalanceOf<T>,
        era: EraIndex,
    },
    Withdrawn {
        member: T::AccountId,
        pool_id: PoolId,
        balance: BalanceOf<T>,
        points: BalanceOf<T>,
    },
    Destroyed {
        pool_id: PoolId,
    },
    StateChanged {
        pool_id: PoolId,
        new_state: PoolState,
    },
    MemberRemoved {
        pool_id: PoolId,
        member: T::AccountId,
    },
    RolesUpdated {
        root: Option<T::AccountId>,
        state_toggler: Option<T::AccountId>,
        nominator: Option<T::AccountId>,
    },
    PoolSlashed {
        pool_id: PoolId,
        balance: BalanceOf<T>,
    },
    UnbondingPoolSlashed {
        pool_id: PoolId,
        era: EraIndex,
        balance: BalanceOf<T>,
    },
    // some variants omitted
}

Events of this pallet.

Variants

Created

Fields

depositor: T::AccountId

pool_id: PoolId

A pool has been created.

Bonded

Fields

member: T::AccountId

pool_id: PoolId

bonded: BalanceOf<T>

joined: bool

A member has became bonded in a pool.

PaidOut

Fields

member: T::AccountId

pool_id: PoolId

payout: BalanceOf<T>

A payout has been made to a member.

Unbonded

Fields

member: T::AccountId

pool_id: PoolId

balance: BalanceOf<T>

points: BalanceOf<T>

era: EraIndex

A member has unbonded from their pool.

• balance is the corresponding balance of the number of points that has been requested to be unbonded (the argument of the unbond transaction) from the bonded pool.
• points is the number of points that are issued as a result of balance being dissolved into the corresponding unbonding pool.
• era is the era in which the balance will be unbonded. In the absence of slashing, these values will match. In the presence of slashing, the number of points that are issued in the unbonding pool will be less than the amount requested to be unbonded.

Withdrawn

Fields

member: T::AccountId

pool_id: PoolId

balance: BalanceOf<T>

points: BalanceOf<T>

A member has withdrawn from their pool.

The given number of points have been dissolved in return of balance.

Similar to Unbonded event, in the absence of slashing, the ratio of point to balance will be 1.

Destroyed

Fields

pool_id: PoolId

A pool has been destroyed.

StateChanged

Fields

pool_id: PoolId

new_state: PoolState

The state of a pool has changed

MemberRemoved

Fields

pool_id: PoolId

member: T::AccountId

A member has been removed from a pool.

The removal can be voluntary (withdrawn all unbonded funds) or involuntary (kicked).

RolesUpdated

Fields

root: Option<T::AccountId>

state_toggler: Option<T::AccountId>

nominator: Option<T::AccountId>

The roles of a pool have been updated to the given new roles. Note that the depositor can never change.

PoolSlashed

Fields

pool_id: PoolId

balance: BalanceOf<T>

The active balance of pool pool_id has been slashed to balance.

UnbondingPoolSlashed

Fields

pool_id: PoolId

era: EraIndex

balance: BalanceOf<T>

The unbond pool at era of pool pool_id has been slashed to balance.

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 T::AccountId: Decode, BalanceOf<T>: Decode, Option<T::AccountId>: Decode,

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 Event<T>where T::AccountId: Encode, BalanceOf<T>: Encode, Option<T::AccountId>: Encode,

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

fn from(_: Event<T>)

Converts to this type from the input type.

impl<T: Config> PartialEq<Event<T>> 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 T::AccountId: TypeInfo + 'static, BalanceOf<T>: TypeInfo + 'static, Option<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<Event<T>> for Event<T>where T::AccountId: Encode, BalanceOf<T>: Encode, Option<T::AccountId>: Encode,

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