Enum pallet_asset_conversion::pallet::Error

pub enum Error<T> {
    EqualAssets,
    UnsupportedAsset,
    PoolExists,
    WrongDesiredAmount,
    AmountOneLessThanMinimal,
    AmountTwoLessThanMinimal,
    ReserveLeftLessThanMinimal,
    AmountOutTooHigh,
    PoolNotFound,
    Overflow,
    AssetOneDepositDidNotMeetMinimum,
    AssetTwoDepositDidNotMeetMinimum,
    AssetOneWithdrawalDidNotMeetMinimum,
    AssetTwoWithdrawalDidNotMeetMinimum,
    OptimalAmountLessThanDesired,
    InsufficientLiquidityMinted,
    ZeroLiquidity,
    ZeroAmount,
    InsufficientLiquidity,
    ProvidedMinimumNotSufficientForSwap,
    ProvidedMaximumNotSufficientForSwap,
    PoolMustContainNativeCurrency,
    InvalidPath,
    PathError,
    NonUniquePath,
    IncorrectPoolAssetId,
    CorrespondenceError,
    // some variants omitted
}

The Error enum of this pallet.

Variants

EqualAssets

Provided assets are equal.

UnsupportedAsset

Provided asset is not supported for pool.

PoolExists

Pool already exists.

WrongDesiredAmount

Desired amount can’t be zero.

AmountOneLessThanMinimal

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

AmountTwoLessThanMinimal

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

ReserveLeftLessThanMinimal

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

AmountOutTooHigh

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

PoolNotFound

The pool doesn’t exist.

Overflow

An overflow happened.

AssetOneDepositDidNotMeetMinimum

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

AssetTwoDepositDidNotMeetMinimum

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

AssetOneWithdrawalDidNotMeetMinimum

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

AssetTwoWithdrawalDidNotMeetMinimum

The minimal 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.

InsufficientLiquidity

Insufficient liquidity in the pool.

ProvidedMinimumNotSufficientForSwap

Calculated amount out is less than provided minimum amount.

ProvidedMaximumNotSufficientForSwap

Provided maximum amount is not sufficient for swap.

PoolMustContainNativeCurrency

Only pools with native on one side are valid.

InvalidPath

The provided path must consists of 2 assets at least.

PathError

It was not possible to calculate path data.

NonUniquePath

The provided path must consists of unique assets.

IncorrectPoolAssetId

It was not possible to get or increment the Id of the pool.

CorrespondenceError

Unable to find an element in an array/vec that should have one-to-one correspondence with another. For example, an array of assets 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 encode_to<__CodecOutputEdqy: Output + ?Sized>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy )

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, Global>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> Rwhere 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<Error<T>> for Error<T>