Enum pallet_revive::pallet::Error

pub enum Error<T> {
    InvalidSchedule,
    InvalidCallFlags,
    OutOfGas,
    TransferFailed,
    MaxCallDepthReached,
    ContractNotFound,
    CodeNotFound,
    CodeInfoNotFound,
    OutOfBounds,
    DecodingFailed,
    ContractTrapped,
    ValueTooLarge,
    TerminatedWhileReentrant,
    InputForwarded,
    TooManyTopics,
    NoChainExtension,
    XCMDecodeFailed,
    DuplicateContract,
    TerminatedInConstructor,
    ReentranceDenied,
    ReenteredPallet,
    StateChangeDenied,
    StorageDepositNotEnoughFunds,
    StorageDepositLimitExhausted,
    CodeInUse,
    ContractReverted,
    CodeRejected,
    BlobTooLarge,
    StaticMemoryTooLarge,
    BasicBlockTooLarge,
    InvalidInstruction,
    MaxDelegateDependenciesReached,
    DelegateDependencyNotFound,
    DelegateDependencyAlreadyExists,
    CannotAddSelfAsDelegateDependency,
    OutOfTransientStorage,
    InvalidSyscall,
    InvalidStorageFlags,
    ExecutionFailed,
    BalanceConversionFailed,
    DecimalPrecisionLoss,
    InvalidImmutableAccess,
    AccountUnmapped,
    AccountAlreadyMapped,
    // some variants omitted
}

The Error enum of this pallet.

Variants

InvalidSchedule

Invalid schedule supplied, e.g. with zero weight of a basic operation.

InvalidCallFlags

Invalid combination of flags supplied to seal_call or seal_delegate_call.

OutOfGas

The executed contract exhausted its gas limit.

TransferFailed

Performing the requested transfer failed. Probably because there isn’t enough free balance in the sender’s account.

MaxCallDepthReached

Performing a call was denied because the calling depth reached the limit of what is specified in the schedule.

ContractNotFound

No contract was found at the specified address.

CodeNotFound

No code could be found at the supplied code hash.

CodeInfoNotFound

No code info could be found at the supplied code hash.

OutOfBounds

A buffer outside of sandbox memory was passed to a contract API function.

DecodingFailed

Input passed to a contract API function failed to decode as expected type.

ContractTrapped

Contract trapped during execution.

ValueTooLarge

The size defined in T::MaxValueSize was exceeded.

TerminatedWhileReentrant

Termination of a contract is not allowed while the contract is already on the call stack. Can be triggered by seal_terminate.

InputForwarded

seal_call forwarded this contracts input. It therefore is no longer available.

TooManyTopics

The amount of topics passed to seal_deposit_events exceeds the limit.

NoChainExtension

The chain does not provide a chain extension. Calling the chain extension results in this error. Note that this usually shouldn’t happen as deploying such contracts is rejected.

XCMDecodeFailed

Failed to decode the XCM program.

DuplicateContract

A contract with the same AccountId already exists.

TerminatedInConstructor

A contract self destructed in its constructor.

This can be triggered by a call to seal_terminate.

ReentranceDenied

A call tried to invoke a contract that is flagged as non-reentrant.

ReenteredPallet

A contract called into the runtime which then called back into this pallet.

StateChangeDenied

A contract attempted to invoke a state modifying API while being in read-only mode.

StorageDepositNotEnoughFunds

Origin doesn’t have enough balance to pay the required storage deposits.

StorageDepositLimitExhausted

More storage was created than allowed by the storage deposit limit.

CodeInUse

Code removal was denied because the code is still in use by at least one contract.

ContractReverted

The contract ran to completion but decided to revert its storage changes. Please note that this error is only returned from extrinsics. When called directly or via RPC an Ok will be returned. In this case the caller needs to inspect the flags to determine whether a reversion has taken place.

CodeRejected

The contract failed to compile or is missing the correct entry points.

A more detailed error can be found on the node console if debug messages are enabled by supplying -lruntime::revive=debug.

BlobTooLarge

The code blob supplied is larger than [limits::code::BLOB_BYTES].

StaticMemoryTooLarge

The static memory consumption of the blob will be larger than [limits::code::STATIC_MEMORY_BYTES].

BasicBlockTooLarge

The program contains a basic block that is larger than allowed.

InvalidInstruction

The program contains an invalid instruction.

MaxDelegateDependenciesReached

The contract has reached its maximum number of delegate dependencies.

DelegateDependencyNotFound

The dependency was not found in the contract’s delegate dependencies.

DelegateDependencyAlreadyExists

The contract already depends on the given delegate dependency.

CannotAddSelfAsDelegateDependency

Can not add a delegate dependency to the code hash of the contract itself.

OutOfTransientStorage

Can not add more data to transient storage.

InvalidSyscall

The contract tried to call a syscall which does not exist (at its current api level).

InvalidStorageFlags

Invalid storage flags were passed to one of the storage syscalls.

ExecutionFailed

PolkaVM failed during code execution. Probably due to a malformed program.

BalanceConversionFailed

Failed to convert a U256 to a Balance.

DecimalPrecisionLoss

Failed to convert an EVM balance to a native balance.

InvalidImmutableAccess

Immutable data can only be set during deploys and only be read during calls. Additionally, it is only valid to set the data once and it must not be empty.

AccountUnmapped

An AccountID32 account tried to interact with the pallet without having a mapping.

Call Pallet::map_account in order to create a mapping for the account.

AccountAlreadyMapped

Tried to map an account that is already mapped.

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

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>