Enum cumulus_primitives_core::XcmError

pub enum XcmError {
    Overflow,
    Unimplemented,
    UntrustedReserveLocation,
    UntrustedTeleportLocation,
    LocationFull,
    LocationNotInvertible,
    BadOrigin,
    InvalidLocation,
    AssetNotFound,
    FailedToTransactAsset(&'static str),
    NotWithdrawable,
    LocationCannotHold,
    ExceedsMaxMessageSize,
    DestinationUnsupported,
    Transport(&'static str),
    Unroutable,
    UnknownClaim,
    FailedToDecode,
    MaxWeightInvalid,
    NotHoldingFees,
    TooExpensive,
    Trap(u64),
    ExpectationFalse,
    PalletNotFound,
    NameMismatch,
    VersionIncompatible,
    HoldingWouldOverflow,
    ExportError,
    ReanchorFailed,
    NoDeal,
    FeesNotMet,
    LockError,
    NoPermission,
    Unanchored,
    NotDepositable,
    TooManyAssets,
    UnhandledXcmVersion,
    WeightLimitReached(Weight),
    Barrier,
    WeightNotComputable,
    ExceedsStackLimit,
}

Error codes used in XCM. The first errors codes have explicit indices and are part of the XCM format. Those trailing are merely part of the XCM implementation; there is no expectation that they will retain the same index over time.

Variants

Overflow

An arithmetic overflow happened.

Unimplemented

The instruction is intentionally unsupported.

UntrustedReserveLocation

Origin Register does not contain a value value for a reserve transfer notification.

UntrustedTeleportLocation

Origin Register does not contain a value value for a teleport notification.

LocationFull

MultiLocation value too large to descend further.

LocationNotInvertible

MultiLocation value ascend more parents than known ancestors of local location.

BadOrigin

The Origin Register does not contain a valid value for instruction.

InvalidLocation

The location parameter is not a valid value for the instruction.

AssetNotFound

The given asset is not handled.

FailedToTransactAsset(&'static str)

An asset transaction (like withdraw or deposit) failed (typically due to type conversions).

NotWithdrawable

An asset cannot be withdrawn, potentially due to lack of ownership, availability or rights.

LocationCannotHold

An asset cannot be deposited under the ownership of a particular location.

ExceedsMaxMessageSize

Attempt to send a message greater than the maximum supported by the transport protocol.

DestinationUnsupported

The given message cannot be translated into a format supported by the destination.

Transport(&'static str)

Destination is routable, but there is some issue with the transport mechanism.

Unroutable

Destination is known to be unroutable.

UnknownClaim

Used by ClaimAsset when the given claim could not be recognized/found.

FailedToDecode

Used by Transact when the functor cannot be decoded.

MaxWeightInvalid

Used by Transact to indicate that the given weight limit could be breached by the functor.

NotHoldingFees

Used by BuyExecution when the Holding Register does not contain payable fees.

TooExpensive

Used by BuyExecution when the fees declared to purchase weight are insufficient.

Trap(u64)

Used by the Trap instruction to force an error intentionally. Its code is included.

ExpectationFalse

Used by ExpectAsset, ExpectError and ExpectOrigin when the expectation was not true.

PalletNotFound

The provided pallet index was not found.

NameMismatch

The given pallet’s name is different to that expected.

VersionIncompatible

The given pallet’s version has an incompatible version to that expected.

HoldingWouldOverflow

The given operation would lead to an overflow of the Holding Register.

ExportError

The message was unable to be exported.

ReanchorFailed

MultiLocation value failed to be reanchored.

NoDeal

No deal is possible under the given constraints.

FeesNotMet

Fees were required which the origin could not pay.

LockError

Some other error with locking.

NoPermission

The state was not in a condition where the operation was valid to make.

Unanchored

The universal location of the local consensus is improper.

NotDepositable

An asset cannot be deposited, probably because (too much of) it already exists.

TooManyAssets

Too many assets matched the given asset filter.

UnhandledXcmVersion

XCM version not able to be handled.

WeightLimitReached(Weight)

Execution of the XCM would potentially result in a greater weight used than weight limit.

Barrier

The XCM did not pass the barrier condition for execution.

The barrier condition differs on different chains and in different circumstances, but generally it means that the conditions surrounding the message were not such that the chain considers the message worth spending time executing. Since most chains lift the barrier to execution on appropriate payment, presentation of an NFT voucher, or based on the message origin, it means that none of those were the case.

WeightNotComputable

The weight of an XCM message is not computable ahead of execution.

ExceedsStackLimit

Recursion stack limit reached

Trait Implementations

impl Clone for Error

fn clone(&self) -> Error

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Error

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

Formats the value using the given formatter.

impl Decode for Error

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Error, Error>

where __CodecInputEdqy: Input,

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

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

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 From<Error> for Outcome

fn from(error: Error) -> Outcome

Converts to this type from the input type.

impl From<SendError> for Error

fn from(e: SendError) -> Error

Converts to this type from the input type.

impl JsonSchema for Error

fn schema_name() -> String

The name of the generated JSON Schema.

fn json_schema(gen: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

impl MaxEncodedLen for Error

fn max_encoded_len() -> usize

Upper bound, in bytes, of the maximum encoded size of this item.

impl PartialEq for Error

fn eq(&self, other: &Error) -> 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 TryFrom<Error> for Error

type Error = ()

The type returned in the event of a conversion error.

fn try_from(old_error: Error) -> Result<Error, ()>

Performs the conversion.

impl TypeInfo for Error

type Identity = Error

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl Copy for Error

impl EncodeLike for Error

impl Eq for Error

impl StructuralPartialEq for Error