Enum Event

pub enum Event<T: Config<I>, I: 'static = ()> {
    CommitPlaced {
        who: Proprietor<T>,
        reason: CommitReason<T, I>,
        digest: Digest<T>,
        value: AssetOf<T, I>,
        variant: T::Position,
    },
    CommitRaised {
        who: Proprietor<T>,
        reason: CommitReason<T, I>,
        digest: Digest<T>,
        value: AssetOf<T, I>,
    },
    CommitResolved {
        who: Proprietor<T>,
        reason: CommitReason<T, I>,
        digest: Digest<T>,
        value: AssetOf<T, I>,
    },
    CommitValue {
        digest: Digest<T>,
        reason: CommitReason<T, I>,
        value: AssetOf<T, I>,
    },
    DigestInfo {
        digest: Digest<T>,
        reason: CommitReason<T, I>,
        value: AssetOf<T, I>,
        variant: T::Position,
    },
    DigestReaped {
        digest: Digest<T>,
        reason: CommitReason<T, I>,
        dust: AssetOf<T, I>,
    },
    IndexInitialized {
        index_of: IndexDigest<T>,
        reason: CommitReason<T, I>,
    },
    IndexValue {
        index_of: IndexDigest<T>,
        reason: CommitReason<T, I>,
        value: AssetOf<T, I>,
    },
    IndexEntryValue {
        index_of: IndexDigest<T>,
        reason: CommitReason<T, I>,
        entry_of: Digest<T>,
        value: AssetOf<T, I>,
    },
    IndexEntriesValue {
        index_of: IndexDigest<T>,
        reason: CommitReason<T, I>,
        entries: Vec<(EntryDigest<T>, AssetOf<T, I>)>,
    },
    IndexReaped {
        index_of: IndexDigest<T>,
        reason: CommitReason<T, I>,
    },
    PoolManager {
        pool_of: PoolDigest<T>,
        reason: CommitReason<T, I>,
        manager: Proprietor<T>,
    },
    PoolInitialized {
        pool_of: PoolDigest<T>,
        reason: CommitReason<T, I>,
        commission: T::Commission,
    },
    PoolSlot {
        pool_of: PoolDigest<T>,
        reason: CommitReason<T, I>,
        slot_of: SlotDigest<T>,
        variant: T::Position,
        shares: T::Shares,
    },
    PoolValue {
        pool_of: PoolDigest<T>,
        reason: CommitReason<T, I>,
        value: AssetOf<T, I>,
    },
    PoolSlotValue {
        pool_of: PoolDigest<T>,
        reason: CommitReason<T, I>,
        slot_of: SlotDigest<T>,
        value: AssetOf<T, I>,
    },
    PoolSlotsValue {
        pool_of: PoolDigest<T>,
        reason: CommitReason<T, I>,
        slots: Vec<(SlotDigest<T>, AssetOf<T, I>)>,
    },
    PoolCommission {
        pool_of: PoolDigest<T>,
        reason: CommitReason<T, I>,
        commission: T::Commission,
    },
    ReserveDeposited {
        amount: AssetOf<T, I>,
        total_on_hold: AssetOf<T, I>,
    },
    ReserveWithdrawn {
        amount: AssetOf<T, I>,
        total_on_hold: AssetOf<T, I>,
    },
    PoolReaped {
        pool_of: PoolDigest<T>,
        reason: CommitReason<T, I>,
    },
    PoolSlotRemoved {
        pool_of: PoolDigest<T>,
        reason: CommitReason<T, I>,
        slot_of: SlotDigest<T>,
        variant: T::Position,
    },
    DigestModel {
        digest: DigestVariant<T, I>,
    },
    AssetIssuable {
        asset: AssetOf<T, I>,
    },
    AssetReapable {
        asset: AssetOf<T, I>,
    },
    ReasonValuation {
        reason: CommitReason<T, I>,
        value: AssetOf<T, I>,
    },
    // some variants omitted
}

The Event enum of this pallet

Variants

CommitPlaced

Emitted when a proprietor places a new commit on a digest with a specific variant.

Fields

who: Proprietor<T>

reason: CommitReason<T, I>

digest: Digest<T>

value: AssetOf<T, I>

variant: T::Position

CommitRaised

Emitted when an existing commit for a digest is increased or raised.

Fields

who: Proprietor<T>

reason: CommitReason<T, I>

digest: Digest<T>

value: AssetOf<T, I>

CommitResolved

Emitted when a commit is resolved (finalized/withdrawn) for a digest.

Fields

who: Proprietor<T>

reason: CommitReason<T, I>

digest: Digest<T>

value: AssetOf<T, I>

CommitValue

Emitted when querying the current committed value for a specific digest and reason.

Fields

digest: Digest<T>

reason: CommitReason<T, I>

value: AssetOf<T, I>

DigestInfo

Emitted when the effective value of the digest variant is updated.

Fields

digest: Digest<T>

reason: CommitReason<T, I>

value: AssetOf<T, I>

variant: T::Position

DigestReaped

Emitted when a direct-digest is reaped (removed) after all commitments are cleared from it.

dust represents unclaimable dead asset value.

Fields

digest: Digest<T>

reason: CommitReason<T, I>

dust: AssetOf<T, I>

IndexInitialized

Emitted when a new index of variants is initialized. Contains all entries (digests, sharesa and variant) of the index.

Fields

index_of: IndexDigest<T>

reason: CommitReason<T, I>

IndexValue

Emitted when querying the total value of an index for a specific proprietor.

Fields

index_of: IndexDigest<T>

reason: CommitReason<T, I>

value: AssetOf<T, I>

IndexEntryValue

Emitted when querying the value of a specific entry within an index.

Fields

index_of: IndexDigest<T>

reason: CommitReason<T, I>

entry_of: Digest<T>

value: AssetOf<T, I>

IndexEntriesValue

Emitted when querying the values of all entries within an index.

Fields

index_of: IndexDigest<T>

reason: CommitReason<T, I>

entries: Vec<(EntryDigest<T>, AssetOf<T, I>)>

IndexReaped

Emitted when a index is reaped (removed) after all entry commitments are cleared from it.

Fields

index_of: IndexDigest<T>

reason: CommitReason<T, I>

PoolManager

Emitted when a pool’s manager is set or updated. The manager is responsible for managing slots and internal pool operations.

Fields

pool_of: PoolDigest<T>

reason: CommitReason<T, I>

manager: Proprietor<T>

PoolInitialized

Emitted when a new pool is initialized from an index. Includes the commission rate and initial slots with their associated shares and variants.

Fields

pool_of: PoolDigest<T>

reason: CommitReason<T, I>

commission: T::Commission

PoolSlot

Emitted when a slot within a pool has its variant updated or a new slot is added.

Fields

pool_of: PoolDigest<T>

reason: CommitReason<T, I>

slot_of: SlotDigest<T>

variant: T::Position

shares: T::Shares

PoolValue

Emitted when querying the total value of a pool for a specific proprietor.

Fields

pool_of: PoolDigest<T>

reason: CommitReason<T, I>

value: AssetOf<T, I>

PoolSlotValue

Emitted when querying the value of a specific slot within a pool.

Fields

pool_of: PoolDigest<T>

reason: CommitReason<T, I>

slot_of: SlotDigest<T>

value: AssetOf<T, I>

PoolSlotsValue

Emitted when querying the values of all slots within a pool.

Fields

pool_of: PoolDigest<T>

reason: CommitReason<T, I>

slots: Vec<(SlotDigest<T>, AssetOf<T, I>)>

PoolCommission

Emitted when querying or updating the commission rate of a pool.

Fields

pool_of: PoolDigest<T>

reason: CommitReason<T, I>

commission: T::Commission

ReserveDeposited

Emitted when funds are deposited into reserve (held balance) under the prepare-for-commit reason.

Fields

amount: AssetOf<T, I>

total_on_hold: AssetOf<T, I>

ReserveWithdrawn

Emitted when reserved funds are withdrawn back to free balance.

Fields

amount: AssetOf<T, I>

total_on_hold: AssetOf<T, I>

PoolReaped

Emitted when a pool is reaped (removed) after all slot commitments are cleared from it.

Fields

pool_of: PoolDigest<T>

reason: CommitReason<T, I>

PoolSlotRemoved

Emitted when a pool slot is removed due to its shares being zero.

Fields

pool_of: PoolDigest<T>

reason: CommitReason<T, I>

slot_of: SlotDigest<T>

variant: T::Position

DigestModel

Emitted when determining the digest model (Direct, Index, or Pool) for a given digest.

Fields

digest: DigestVariant<T, I>

AssetIssuable

Emitted when the total assets pending issuance are queried.

Fields

asset: AssetOf<T, I>

AssetReapable

Emitted when the total assets pending reaping are queried.

Fields

asset: AssetOf<T, I>

ReasonValuation

Emitted when the total committed value for a reason is queried.

Fields

reason: CommitReason<T, I>

value: AssetOf<T, I>

Trait Implementations

impl<T: Config<I>, I: 'static> Clone for Event<T, I>

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<I>, I: 'static> Debug for Event<T, I>

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

Formats the value using the given formatter.

impl<T: Config<I>, I: 'static> Decode for Event<T, I>

where Proprietor<T>: Decode, CommitReason<T, I>: Decode, Digest<T>: Decode, AssetOf<T, I>: Decode, T::Position: Decode, IndexDigest<T>: Decode, Vec<(EntryDigest<T>, AssetOf<T, I>)>: Decode, PoolDigest<T>: Decode, T::Commission: Decode, SlotDigest<T>: Decode, T::Shares: Decode, Vec<(SlotDigest<T>, AssetOf<T, I>)>: Decode, DigestVariant<T, I>: 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<I>, I: 'static> Encode for Event<T, I>

where Proprietor<T>: Encode, CommitReason<T, I>: Encode, Digest<T>: Encode, AssetOf<T, I>: Encode, T::Position: Encode, IndexDigest<T>: Encode, Vec<(EntryDigest<T>, AssetOf<T, I>)>: Encode, PoolDigest<T>: Encode, T::Commission: Encode, SlotDigest<T>: Encode, T::Shares: Encode, Vec<(SlotDigest<T>, AssetOf<T, I>)>: Encode, DigestVariant<T, I>: 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<I>, I: 'static> From<Event<T, I>> for ()

fn from(_: Event<T, I>)

Converts to this type from the input type.

impl<T: Config<I>, I: 'static> PartialEq for Event<T, I>

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, I> TypeInfo for Event<T, I>

where Proprietor<T>: TypeInfo + 'static, CommitReason<T, I>: TypeInfo + 'static, Digest<T>: TypeInfo + 'static, AssetOf<T, I>: TypeInfo + 'static, T::Position: TypeInfo + 'static, IndexDigest<T>: TypeInfo + 'static, Vec<(EntryDigest<T>, AssetOf<T, I>)>: TypeInfo + 'static, PoolDigest<T>: TypeInfo + 'static, T::Commission: TypeInfo + 'static, SlotDigest<T>: TypeInfo + 'static, T::Shares: TypeInfo + 'static, Vec<(SlotDigest<T>, AssetOf<T, I>)>: TypeInfo + 'static, DigestVariant<T, I>: TypeInfo + 'static, PhantomData<(T, I)>: TypeInfo + 'static, T: Config<I> + 'static, I: 'static,

type Identity = Event<T, I>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<T: Config<I>, I: 'static> DecodeWithMemTracking for Event<T, I>

where Proprietor<T>: DecodeWithMemTracking, CommitReason<T, I>: DecodeWithMemTracking, Digest<T>: DecodeWithMemTracking, AssetOf<T, I>: DecodeWithMemTracking, T::Position: DecodeWithMemTracking, IndexDigest<T>: DecodeWithMemTracking, Vec<(EntryDigest<T>, AssetOf<T, I>)>: DecodeWithMemTracking, PoolDigest<T>: DecodeWithMemTracking, T::Commission: DecodeWithMemTracking, SlotDigest<T>: DecodeWithMemTracking, T::Shares: DecodeWithMemTracking, Vec<(SlotDigest<T>, AssetOf<T, I>)>: DecodeWithMemTracking, DigestVariant<T, I>: DecodeWithMemTracking,

impl<T: Config<I>, I: 'static> EncodeLike for Event<T, I>

where Proprietor<T>: Encode, CommitReason<T, I>: Encode, Digest<T>: Encode, AssetOf<T, I>: Encode, T::Position: Encode, IndexDigest<T>: Encode, Vec<(EntryDigest<T>, AssetOf<T, I>)>: Encode, PoolDigest<T>: Encode, T::Commission: Encode, SlotDigest<T>: Encode, T::Shares: Encode, Vec<(SlotDigest<T>, AssetOf<T, I>)>: Encode, DigestVariant<T, I>: Encode,

impl<T: Config<I>, I: 'static> Eq for Event<T, I>