Enum fuel_tx::PanicReason

#[non_exhaustive]
#[repr(u8)]
pub enum PanicReason {
    UnknownPanicReason = 0,
    Revert = 1,
    OutOfGas = 2,
    TransactionValidity = 3,
    MemoryOverflow = 4,
    ArithmeticOverflow = 5,
    ContractNotFound = 6,
    MemoryOwnership = 7,
    NotEnoughBalance = 8,
    ExpectedInternalContext = 9,
    AssetIdNotFound = 10,
    InputNotFound = 11,
    OutputNotFound = 12,
    WitnessNotFound = 13,
    TransactionMaturity = 14,
    InvalidMetadataIdentifier = 15,
    MalformedCallStructure = 16,
    ReservedRegisterNotWritable = 17,
    InvalidFlags = 18,
    InvalidImmediateValue = 19,
    ExpectedCoinInput = 20,
    EcalError = 21,
    MemoryWriteOverlap = 22,
    ContractNotInInputs = 23,
    InternalBalanceOverflow = 24,
    ContractMaxSize = 25,
    ExpectedUnallocatedStack = 26,
    MaxStaticContractsReached = 27,
    TransferAmountCannotBeZero = 28,
    ExpectedOutputVariable = 29,
    ExpectedParentInternalContext = 30,
    PredicateReturnedNonOne = 31,
    ContractIdAlreadyDeployed = 32,
    ContractMismatch = 33,
    MessageDataTooLong = 34,
    ArithmeticError = 35,
    ContractInstructionNotAllowed = 36,
    TransferZeroCoins = 37,
    InvalidInstruction = 38,
    MemoryNotExecutable = 39,
    PolicyIsNotSet = 40,
    PolicyNotFound = 41,
    TooManyReceipts = 42,
    BalanceOverflow = 43,
    InvalidBlockHeight = 44,
    TooManySlots = 45,
    ExpectedNestedCaller = 46,
    MemoryGrowthOverlap = 47,
    UninitalizedMemoryAccess = 48,
    OverridingConsensusParameters = 49,
    UnknownStateTransactionBytecodeRoot = 50,
    OverridingStateTransactionBytecode = 51,
    BytecodeAlreadyUploaded = 52,
    ThePartIsNotSequentiallyConnected = 53,
}

Panic reason representation for the interpreter.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

UnknownPanicReason = 0

The byte can’t be mapped to any known PanicReason.

Revert = 1

Found RVRT instruction.

OutOfGas = 2

Execution ran out of gas.

TransactionValidity = 3

The transaction validity is violated.

MemoryOverflow = 4

Attempt to write outside interpreter memory boundaries.

ArithmeticOverflow = 5

Overflow while executing arithmetic operation. These errors are ignored using the WRAPPING flag.

ContractNotFound = 6

Designed contract was not found in the storage.

MemoryOwnership = 7

Memory ownership rules are violated.

NotEnoughBalance = 8

The asset ID balance isn’t enough for the instruction.

ExpectedInternalContext = 9

The interpreter is expected to be in internal context.

AssetIdNotFound = 10

The queried asset ID was not found in the state.

InputNotFound = 11

The provided input is not found in the transaction.

OutputNotFound = 12

The provided output is not found in the transaction.

WitnessNotFound = 13

The provided witness is not found in the transaction.

TransactionMaturity = 14

The transaction maturity is not valid for this request.

InvalidMetadataIdentifier = 15

The metadata identifier is invalid.

MalformedCallStructure = 16

The call structure is not valid.

ReservedRegisterNotWritable = 17

The provided register does not allow write operations.

InvalidFlags = 18

The execution resulted in an erroneous state of the interpreter.

InvalidImmediateValue = 19

The provided immediate value is not valid for this instruction.

ExpectedCoinInput = 20

The provided transaction input is not of type Coin.

EcalError = 21

ECAL instruction failed.

MemoryWriteOverlap = 22

Two segments of the interpreter memory should not intersect for write operations.

ContractNotInInputs = 23

The requested contract is not listed in the transaction inputs.

InternalBalanceOverflow = 24

The internal asset ID balance overflowed with the provided instruction.

ContractMaxSize = 25

The maximum allowed contract size is violated.

ExpectedUnallocatedStack = 26

This instruction expects the stack area to be unallocated for this call.

MaxStaticContractsReached = 27

The maximum allowed number of static contracts was reached for this transaction.

TransferAmountCannotBeZero = 28

The requested transfer amount cannot be zero.

ExpectedOutputVariable = 29

The provided transaction output should be of type Variable.

ExpectedParentInternalContext = 30

The expected context of the stack parent is internal.

PredicateReturnedNonOne = 31

The predicate returned non 1. The 1 means successful verification of the predicate, all other values means unsuccessful.

ContractIdAlreadyDeployed = 32

The contract ID is already deployed and can’t be overwritten.

ContractMismatch = 33

The loaded contract mismatch expectations.

MessageDataTooLong = 34

Attempting to send message data longer than MAX_MESSAGE_DATA_LENGTH

ArithmeticError = 35

Mathematically invalid arguments where given to an arithmetic instruction. For instance, division by zero produces this. These errors are ignored using the UNSAFEMATH flag.

ContractInstructionNotAllowed = 36

The contract instruction is not allowed in predicates.

TransferZeroCoins = 37

Transfer of zero coins is not allowed.

InvalidInstruction = 38

Attempted to execute an invalid instruction

MemoryNotExecutable = 39

Memory outside $is..$ssp range is not executable

PolicyIsNotSet = 40

The policy is not set.

PolicyNotFound = 41

The policy is not found across policies.

TooManyReceipts = 42

Receipt context is full

BalanceOverflow = 43

Balance of a contract overflowed

InvalidBlockHeight = 44

Block height value is invalid, typically because it is too large

TooManySlots = 45

Attempt to use sequential memory instructions with too large slot count, typically because it cannot fit into usize

ExpectedNestedCaller = 46

Caller of this internal context is also expected to be internal, i.e. $fp->$fp must be non-zero.

MemoryGrowthOverlap = 47

During memory growth, the stack overlapped with the heap

UninitalizedMemoryAccess = 48

Attempting to read or write uninitialized memory. Also occurs when boundary crosses from stack to heap.

OverridingConsensusParameters = 49

Overriding consensus parameters is not allowed.

UnknownStateTransactionBytecodeRoot = 50

The storage doesn’t know about the hash of the state transition bytecode.

OverridingStateTransactionBytecode = 51

Overriding the state transition bytecode is not allowed.

BytecodeAlreadyUploaded = 52

The bytecode is already uploaded and cannot be uploaded again.

ThePartIsNotSequentiallyConnected = 53

The part of the bytecode is not sequentially connected to the previous parts.

Trait Implementations

impl Clone for PanicReason

fn clone(&self) -> PanicReason

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for PanicReason

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

Formats the value using the given formatter.

impl Deserialize for PanicReason

fn decode_static<I>(buffer: &mut I) -> Result<PanicReason, Error>

where I: Input + ?Sized,

Decodes static part of Self from the buffer.

fn decode_dynamic<I>(&mut self, buffer: &mut I) -> Result<(), Error>

where I: Input + ?Sized,

Decodes dynamic part of the information from the buffer to fill Self. The default implementation does nothing. Dynamically-sized contains should override this.

fn decode<I>(buffer: &mut I) -> Result<Self, Error>

where I: Input + ?Sized,

Decodes Self from the buffer.

fn from_bytes(buffer: &[u8]) -> Result<Self, Error>

Helper method for deserializing Self from bytes.

impl Display for PanicReason

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

Formats the value using the given formatter.

impl From<TryFromSliceError> for PanicReason

fn from(_: TryFromSliceError) -> PanicReason

Converts to this type from the input type.

impl From<u8> for PanicReason

fn from(v: u8) -> PanicReason

Converts to this type from the input type.

impl Hash for PanicReason

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl IntoEnumIterator for PanicReason

type Iterator = PanicReasonIter

fn iter() -> PanicReasonIter

impl PartialEq for PanicReason

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

fn size_static(&self) -> usize

Size of the static part of the serialized object, in bytes. Saturates to usize::MAX on overflow.

fn size_dynamic(&self) -> usize

Size of the dynamic part, in bytes. Saturates to usize::MAX on overflow.

fn encode_static<O>(&self, buffer: &mut O) -> Result<(), Error>

where O: Output + ?Sized,

Encodes staticly-sized part of Self.

fn encode_dynamic<O>(&self, buffer: &mut O) -> Result<(), Error>

where O: Output + ?Sized,

Encodes dynamically-sized part of Self. The default implementation does nothing. Dynamically-sized contains should override this.

fn size(&self) -> usize

Total size of the serialized object, in bytes. Saturates to usize::MAX on overflow.

fn encode<O>(&self, buffer: &mut O) -> Result<(), Error>

where O: Output + ?Sized,

Encodes Self into the buffer.

fn to_bytes(&self) -> Vec<u8>

Encodes Self into bytes vector. Required known size.

impl Copy for PanicReason

impl Eq for PanicReason

impl StructuralPartialEq for PanicReason