Enum pallet_balances::RawEvent

pub enum RawEvent<AccountId, Balance, I> {
    Endowed(AccountId, Balance),
    DustLost(AccountId, Balance),
    Transfer(AccountId, AccountId, Balance),
    BalanceSet(AccountId, Balance, Balance),
    Deposit(AccountId, Balance),
    Reserved(AccountId, Balance),
    Unreserved(AccountId, Balance),
    ReserveRepatriated(AccountId, AccountId, Balance, Status),
    // some variants omitted
}

Events for this module.

Variants

Endowed(AccountId, Balance)

An account was created with some free balance.

DustLost(AccountId, Balance)

An account was removed whose balance was non-zero but below ExistentialDeposit, resulting in an outright loss.

Transfer(AccountId, AccountId, Balance)

Transfer succeeded (from, to, value).

BalanceSet(AccountId, Balance, Balance)

A balance was set by root (who, free, reserved).

Deposit(AccountId, Balance)

Some amount was deposited (e.g. for transaction fees).

Reserved(AccountId, Balance)

Some balance was reserved (moved from free to reserved).

Unreserved(AccountId, Balance)

Some balance was unreserved (moved from reserved to free).

ReserveRepatriated(AccountId, AccountId, Balance, Status)

Some balance was moved from the reserve of the first account to the second account. Final argument indicates the destination balance type.

Trait Implementations

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

impl<AccountId, Balance, I> Decode for RawEvent<AccountId, Balance, I> where
    AccountId: Decode,
    AccountId: Decode,
    Balance: Decode,
    Balance: Decode,
    AccountId: Decode,
    AccountId: Decode,
    Balance: Decode,
    Balance: Decode,
    AccountId: Decode,
    AccountId: Decode,
    AccountId: Decode,
    AccountId: Decode,
    Balance: Decode,
    Balance: Decode,
    AccountId: Decode,
    AccountId: Decode,
    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,
    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<AccountId, Balance, I> Encode for RawEvent<AccountId, Balance, I> where
    AccountId: Encode,
    AccountId: Encode,
    Balance: Encode,
    Balance: Encode,
    AccountId: Encode,
    AccountId: Encode,
    Balance: Encode,
    Balance: Encode,
    AccountId: Encode,
    AccountId: Encode,
    AccountId: Encode,
    AccountId: Encode,
    Balance: Encode,
    Balance: Encode,
    AccountId: Encode,
    AccountId: Encode,
    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,
    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<AccountId, Balance, I> EncodeLike<RawEvent<AccountId, Balance, I>> for RawEvent<AccountId, Balance, I> where
    AccountId: Encode,
    AccountId: Encode,
    Balance: Encode,
    Balance: Encode,
    AccountId: Encode,
    AccountId: Encode,
    Balance: Encode,
    Balance: Encode,
    AccountId: Encode,
    AccountId: Encode,
    AccountId: Encode,
    AccountId: Encode,
    Balance: Encode,
    Balance: Encode,
    AccountId: Encode,
    AccountId: Encode,
    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,
    AccountId: Encode,
    AccountId: Encode,
    Balance: Encode,
    Balance: Encode, 

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

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

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

Performs the conversion.

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

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

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

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

This method tests for !=.

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

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