Enum xcm_simulator::SendError

pub enum SendError {
    NotApplicable,
    Transport(&'static str),
    Unroutable,
    DestinationUnsupported,
    ExceedsMaxMessageSize,
    MissingArgument,
    Fees,
}

Error result value when attempting to send an XCM message.

Variants

NotApplicable

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

This is not considered fatal: if there are alternative transport routes available, then they may be attempted.

Transport(&'static str)

Destination is routable, but there is some issue with the transport mechanism. This is considered fatal. A human-readable explanation of the specific issue is provided.

Unroutable

Destination is known to be unroutable. This is considered fatal.

DestinationUnsupported

The given message cannot be translated into a format that the destination can be expected to interpret.

ExceedsMaxMessageSize

Message could not be sent due to its size exceeding the maximum allowed by the transport layer.

MissingArgument

A needed argument is None when it should be Some.

Fees

Fees needed to be paid in order to send the message and they were unavailable.

Trait Implementations

impl Clone for SendError

fn clone(&self) -> SendError

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SendError

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

Formats the value using the given formatter.

impl Decode for SendError

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<SendError, 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 SendError

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<HaulBlobError> for SendError

fn from(err: HaulBlobError) -> SendError

Converts to this type from the input type.

impl From<QueueDownwardMessageError> for SendError

fn from(err: QueueDownwardMessageError) -> SendError

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 PartialEq for SendError

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

type Identity = SendError

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl EncodeLike for SendError

impl Eq for SendError

impl StructuralPartialEq for SendError