Enum 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> WithdrawConsequence<Balance>

where Balance: Zero,

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 for WithdrawConsequence<Balance>

where Balance: Clone,

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<(), Error>

Formats the value using the given formatter.

impl<Balance> PartialEq for WithdrawConsequence<Balance>

where Balance: PartialEq,

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

where Balance: Copy,

impl<Balance> Eq for WithdrawConsequence<Balance>

where Balance: Eq,

impl<Balance> StructuralPartialEq for WithdrawConsequence<Balance>