Enum serai_dex_pallet::pallet::Error

pub enum Error<T> {
    EqualCoins,
    PoolExists,
    WrongDesiredAmount,
    CoinAmountLessThanMinimum,
    SriAmountLessThanMinimum,
    ReserveLeftLessThanMinimum,
    AmountOutTooHigh,
    PoolNotFound,
    Overflow,
    CoinOneDepositDidNotMeetMinimum,
    CoinTwoDepositDidNotMeetMinimum,
    CoinOneWithdrawalDidNotMeetMinimum,
    CoinTwoWithdrawalDidNotMeetMinimum,
    OptimalAmountLessThanDesired,
    InsufficientLiquidityMinted,
    ZeroLiquidity,
    ZeroAmount,
    ProvidedMinimumNotSufficientForSwap,
    ProvidedMaximumNotSufficientForSwap,
    InvalidPath,
    PathError,
    NonUniquePath,
    CorrespondenceError,
    // some variants omitted
}

The Error enum of this pallet.

Variants

EqualCoins

Provided coins are equal.

PoolExists

Pool already exists.

WrongDesiredAmount

Desired amount can’t be zero.

CoinAmountLessThanMinimum

Provided amount should be greater than or equal to the existential deposit/coin’s minimum amount.

SriAmountLessThanMinimum

Provided amount should be greater than or equal to the existential deposit/coin’s minimum amount.

ReserveLeftLessThanMinimum

Reserve needs to always be greater than or equal to the existential deposit/coin’s minimum amount.

AmountOutTooHigh

Desired amount can’t be equal to the pool reserve.

PoolNotFound

The pool doesn’t exist.

Overflow

An overflow happened.

CoinOneDepositDidNotMeetMinimum

The minimum amount requirement for the first token in the pair wasn’t met.

CoinTwoDepositDidNotMeetMinimum

The minimum amount requirement for the second token in the pair wasn’t met.

CoinOneWithdrawalDidNotMeetMinimum

The minimum amount requirement for the first token in the pair wasn’t met.

CoinTwoWithdrawalDidNotMeetMinimum

The minimum amount requirement for the second token in the pair wasn’t met.

OptimalAmountLessThanDesired

Optimal calculated amount is less than desired.

InsufficientLiquidityMinted

Insufficient liquidity minted.

ZeroLiquidity

Requested liquidity can’t be zero.

ZeroAmount

Amount can’t be zero.

ProvidedMinimumNotSufficientForSwap

Calculated amount out is less than provided minimum amount.

ProvidedMaximumNotSufficientForSwap

Provided maximum amount is not sufficient for swap.

InvalidPath

The provided path must consists of 2 coins at least.

PathError

It was not possible to calculate path data.

NonUniquePath

The provided path must consists of unique coins.

CorrespondenceError

Unable to find an element in an array/vec that should have one-to-one correspondence with another. For example, an array of coins constituting a path should have a corresponding array of amounts along the path.

Trait Implementations

impl<T: Config> Debug for Error<T>

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

Formats the value using the given formatter.

impl<T> Decode for Error<T>

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> Encode for Error<T>

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> From<Error<T>> for &'static str

fn from(err: Error<T>) -> &'static str

Converts to this type from the input type.

impl<T: Config> From<Error<T>> for DispatchError

fn from(err: Error<T>) -> Self

Converts to this type from the input type.

impl<T> PalletError for Error<T>

const MAX_ENCODED_SIZE: usize = 1usize

The maximum encoded size for the implementing type.

impl<T> TypeInfo for Error<T>

where PhantomData<T>: TypeInfo + 'static, T: 'static,

type Identity = Error<T>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<T> EncodeLike for Error<T>