Enum xcm::v0::Error

pub enum Error {
    Undefined,
    Overflow,
    Unimplemented,
    UnhandledXcmVersion,
    UnhandledXcmMessage,
    UnhandledEffect,
    EscalationOfPrivilege,
    UntrustedReserveLocation,
    UntrustedTeleportLocation,
    DestinationBufferOverflow,
    SendFailed(&'static str),
    CannotReachDestination(MultiLocation, Xcm<()>),
    MultiLocationFull,
    FailedToDecode,
    BadOrigin,
    ExceedsMaxMessageSize,
    FailedToTransactAsset(&'static str),
    WeightLimitReached(u64),
    Wildcard,
    MaxWeightInvalid,
    NotHoldingFees,
    WeightNotComputable,
    Barrier,
    NotWithdrawable,
    LocationCannotHold,
    TooExpensive,
    AssetNotFound,
    RecursionLimitReached,
}

Variants

Undefined

Overflow

An arithmetic overflow happened.

Unimplemented

The operation is intentionally unsupported.

UnhandledXcmVersion

UnhandledXcmMessage

The implementation does not handle a given XCM.

UnhandledEffect

The implementation does not handle an effect present in an XCM.

EscalationOfPrivilege

UntrustedReserveLocation

UntrustedTeleportLocation

DestinationBufferOverflow

SendFailed(&'static str)

The message and destination was recognized as being reachable but the operation could not be completed. A human-readable explanation of the specific issue is provided.

CannotReachDestination(MultiLocation, Xcm<()>)

The message and destination combination was not recognized as being reachable.

MultiLocationFull

FailedToDecode

BadOrigin

ExceedsMaxMessageSize

FailedToTransactAsset(&'static str)

An asset transaction (like withdraw or deposit) failed. See implementers of the TransactAsset trait for sources. Causes can include type conversion failures between id or balance types.

WeightLimitReached(u64)

Execution of the XCM would potentially result in a greater weight used than the pre-specified weight limit. The amount that is potentially required is the parameter.

Wildcard

An asset wildcard was passed where it was not expected (e.g. as the asset to withdraw in a WithdrawAsset XCM).

MaxWeightInvalid

The case where an XCM message has specified a weight limit on an interior call and this limit is too low.

Used by:

• Transact

NotHoldingFees

The fees specified by the XCM message were not found in the holding account.

Used by:

• BuyExecution

WeightNotComputable

The weight of an XCM message is not computable ahead of execution. This generally means at least part of the message is invalid, which could be due to it containing overly nested structures or an invalid nested data segment (e.g. for the call in Transact).

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.

NotWithdrawable

Indicates that it is not possible for a location to have an asset be withdrawn or transferred from its ownership. This probably means it doesn’t own (enough of) it, but may also indicate that it is under a lock, hold, freeze or is otherwise unavailable.

LocationCannotHold

Indicates that the consensus system cannot deposit an asset under the ownership of a particular location.

TooExpensive

The assets given to purchase weight is are insufficient for the weight desired.

AssetNotFound

The given asset is not handled.

RecursionLimitReached

execute_xcm has been called too many times recursively.

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<()> for Error

fn from(_: ()) -> 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 EncodeLike<Error> for Error

impl Eq for Error

impl StructuralEq for Error

impl StructuralPartialEq for Error