Enum xcm::v2::prelude::XcmError

pub enum XcmError {
    Overflow,
    Unimplemented,
    UntrustedReserveLocation,
    UntrustedTeleportLocation,
    MultiLocationFull,
    MultiLocationNotInvertible,
    BadOrigin,
    InvalidLocation,
    AssetNotFound,
    FailedToTransactAsset(&'static str),
    NotWithdrawable,
    LocationCannotHold,
    ExceedsMaxMessageSize,
    DestinationUnsupported,
    Transport(&'static str),
    Unroutable,
    UnknownClaim,
    FailedToDecode,
    MaxWeightInvalid,
    NotHoldingFees,
    TooExpensive,
    Trap(u64),
    UnhandledXcmVersion,
    WeightLimitReached(Weight),
    Barrier,
    WeightNotComputable,
}

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.

MultiLocationFull

MultiLocation value too large to descend further.

MultiLocationNotInvertible

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.

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.

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

Formats the value using the given formatter.

impl Decode for Error

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

Attempt to deserialise the value from input.

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

fn from(e: SendError) -> Self

Converts to this type from the input type.

impl PartialEq<Error> 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 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<Error> for Error

impl Eq for Error

impl StructuralEq for Error

impl StructuralPartialEq for Error