Enum Error

pub enum Error<T> {
    InvalidChain,
    MissingChannel,
    InvalidChannelState,
    NoOpenChannel,
    NoMessageHandler,
    OutboxFull,
    InvalidMessagePayload,
    InvalidMessageDestination,
    MessageVerification(VerificationError),
    MissingMessage,
    WeightTagNotMatch,
    BalanceOverflow,
    BalanceUnderflow,
    InvalidAllowedChain,
    OperationNotAllowed,
    NotDomainOwner,
    ChainNotAllowed,
    InsufficientBalance,
    BalanceHold,
    ChannelOwner,
    BalanceUnlock,
    InvalidChannelReserveFee,
    InvalidMaxOutgoingMessages,
    MessageCountOverflow,
    MessageCountUnderflow,
    MessageVersionMismatch,
    FailedToNoteTransferIn,
    FailedToNoteTransferOut,
    // some variants omitted
}

pallet-messenger errors

Variants

InvalidChain

Emits when the chain is neither consensus not chain.

MissingChannel

Emits when there is no channel for a given Channel ID.

InvalidChannelState

Emits when the said channel is not in an open state.

NoOpenChannel

Emits when there are no open channels for a chain

NoMessageHandler

Emits when there are not message handler with given endpoint ID.

OutboxFull

Emits when the outbox is full for a channel.

InvalidMessagePayload

Emits when the message payload is invalid.

InvalidMessageDestination

Emits when the message destination is not valid.

MessageVerification(VerificationError)

Emits when the message verification failed.

MissingMessage

Emits when there is no message available for the given nonce.

WeightTagNotMatch

Emits when there is mismatch between the message’s weight tag and the message’s actual processing path

BalanceOverflow

Emits when the there is balance overflow.

BalanceUnderflow

Emits when the there is balance underflow.

InvalidAllowedChain

Invalid allowed chain.

OperationNotAllowed

Operation not allowed.

NotDomainOwner

Account is not a Domain owner.

ChainNotAllowed

Chain not allowed to open channel

InsufficientBalance

Not enough balance to do the operation

BalanceHold

Failed to hold balance

ChannelOwner

Not a channel owner

BalanceUnlock

Failed to unlock the balance

InvalidChannelReserveFee

Invalid channel reserve fee

InvalidMaxOutgoingMessages

Invalid max outgoing messages

MessageCountOverflow

Message count overflow

MessageCountUnderflow

Message count underflow

MessageVersionMismatch

Incorrect message version

FailedToNoteTransferIn

Failed to note transfer in

FailedToNoteTransferOut

Failed to note transfer out

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>

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<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 = 2usize

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