Enum frame_support::traits::tokens::WithdrawConsequence

pub enum WithdrawConsequence<Balance> {
    BalanceLow,
    WouldDie,
    UnknownAsset,
    Underflow,
    Overflow,
    Frozen,
    ReducedToZero(Balance),
    Success,
}

One of a number of consequences of withdrawing a fungible from an account.

Variants

BalanceLow

Withdraw could not happen since the amount to be withdrawn is less than the total funds in the account.

WouldDie

The withdraw would mean the account dying when it needs to exist (usually because it is a provider and there are consumer references on it).

UnknownAsset

The asset is unknown. Usually because an AssetId has been presented which doesn’t exist on the system.

Underflow

There has been an underflow in the system. This is indicative of a corrupt state and likely unrecoverable.

Overflow

There has been an overflow in the system. This is indicative of a corrupt state and likely unrecoverable.

Frozen

Not enough of the funds in the account are available for withdrawal.

ReducedToZero(Balance)

Account balance would reduce to zero, potentially destroying it. The parameter is the amount of balance which is destroyed.

Success

Account continued in existence.

Implementations

impl<Balance: Zero> WithdrawConsequence<Balance>

pub fn into_result(self, keep_nonzero: bool) -> Result<Balance, DispatchError>

Convert the type into a Result with DispatchError as the error or the additional Balance by which the account will be reduced.

Trait Implementations

impl<Balance: Clone> Clone for WithdrawConsequence<Balance>

fn clone(&self) -> WithdrawConsequence<Balance>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Balance> Debug for WithdrawConsequence<Balance>

where Balance: Debug,

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

Formats the value using the given formatter.

impl<Balance: PartialEq> PartialEq for WithdrawConsequence<Balance>

fn eq(&self, other: &WithdrawConsequence<Balance>) -> 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<Balance: Copy> Copy for WithdrawConsequence<Balance>

impl<Balance: Eq> Eq for WithdrawConsequence<Balance>

impl<Balance> StructuralPartialEq for WithdrawConsequence<Balance>