Enum order_book::pallet::Error

pub enum Error<T> {
    UnknownOrderBook,
    InvalidOrderBookId,
    OrderBookAlreadyExists,
    UnknownLimitOrder,
    LimitOrderAlreadyExists,
    LimitOrderStorageOverflow,
    UpdateLimitOrderError,
    DeleteLimitOrderError,
    BlockScheduleFull,
    ExpirationNotFound,
    NoDataForPrice,
    NoAggregatedData,
    NotEnoughLiquidityInOrderBook,
    ForbiddenToCreateOrderBookWithSameAssets,
    NotAllowedQuoteAsset,
    NotAllowedDEXId,
    SyntheticAssetIsForbidden,
    UserHasNoNft,
    InvalidLifespan,
    InvalidOrderAmount,
    InvalidLimitOrderPrice,
    LimitOrderPriceIsTooFarFromSpread,
    TradingIsForbidden,
    PlacementOfLimitOrdersIsForbidden,
    CancellationOfLimitOrdersIsForbidden,
    UserHasMaxCountOfOpenedOrders,
    PriceReachedMaxCountOfLimitOrders,
    OrderBookReachedMaxCountOfPricesForSide,
    AmountCalculationFailed,
    PriceCalculationFailed,
    Unauthorized,
    InvalidAsset,
    InvalidTickSize,
    InvalidStepLotSize,
    InvalidMinLotSize,
    InvalidMaxLotSize,
    TickSizeAndStepLotSizeAreTooBig,
    TickSizeAndStepLotSizeLosePrecision,
    MaxLotSizeIsMoreThanTotalSupply,
    SlippageLimitExceeded,
    MarketOrdersAllowedOnlyForIndivisibleAssets,
    // some variants omitted
}

Custom dispatch errors of this pallet.

Variants

UnknownOrderBook

Order book does not exist for this trading pair

InvalidOrderBookId

Invalid order book id

OrderBookAlreadyExists

Order book already exists for this trading pair

UnknownLimitOrder

Limit order does not exist for this trading pair and order id

LimitOrderAlreadyExists

Limit order already exists for this trading pair and order id

LimitOrderStorageOverflow

It is impossible to insert the limit order because the bounds have been reached

UpdateLimitOrderError

It is impossible to update the limit order

DeleteLimitOrderError

It is impossible to delete the limit order

BlockScheduleFull

Expiration schedule for expiration block is full

ExpirationNotFound

Could not find expiration in given block schedule

NoDataForPrice

There are no bids/asks for the price

NoAggregatedData

There are no aggregated bids/asks for the order book

NotEnoughLiquidityInOrderBook

There is not enough liquidity in the order book to cover the deal

ForbiddenToCreateOrderBookWithSameAssets

Cannot create order book with equal base and target assets

NotAllowedQuoteAsset

The asset is not allowed to be quote. Only the dex base asset can be a quote asset for order book

NotAllowedDEXId

Orderbooks cannot be created with given dex id.

SyntheticAssetIsForbidden

Synthetic assets are forbidden for order book.

UserHasNoNft

User cannot create an order book with NFT if they don’t have NFT

InvalidLifespan

Lifespan exceeds defined limits

InvalidOrderAmount

The order amount (limit or market) does not meet the requirements

InvalidLimitOrderPrice

The limit order price does not meet the requirements

LimitOrderPriceIsTooFarFromSpread

User cannot set the price of limit order too far from actual market price

TradingIsForbidden

At the moment, Trading is forbidden in the current order book

PlacementOfLimitOrdersIsForbidden

At the moment, Users cannot place new limit orders in the current order book

CancellationOfLimitOrdersIsForbidden

At the moment, Users cannot cancel their limit orders in the current order book

UserHasMaxCountOfOpenedOrders

User has the max available count of open limit orders in the current order book

PriceReachedMaxCountOfLimitOrders

It is impossible to place the limit order because bounds of the max count of orders at the current price have been reached

OrderBookReachedMaxCountOfPricesForSide

It is impossible to place the limit order because bounds of the max count of prices for the side have been reached

AmountCalculationFailed

An error occurred while calculating the amount

PriceCalculationFailed

An error occurred while calculating the price

Unauthorized

Unauthorized action

InvalidAsset

Invalid asset

InvalidTickSize

Invalid tick size

InvalidStepLotSize

Invalid step lot size

InvalidMinLotSize

Invalid min lot size

InvalidMaxLotSize

Invalid max lot size

TickSizeAndStepLotSizeAreTooBig

Tick size & step lot size are too big and their multiplication overflows Balance

TickSizeAndStepLotSizeLosePrecision

Product of tick and step lot sizes goes out of precision. It must be accurately represented by fixed-precision float to prevent rounding errors. I.e. the product should not have more than 18 digits after the comma.

MaxLotSizeIsMoreThanTotalSupply

Max lot size cannot be more that total supply of base asset

SlippageLimitExceeded

Indicated limit for slippage has not been met during transaction execution.

MarketOrdersAllowedOnlyForIndivisibleAssets

Market orders are allowed only for indivisible assets

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