Enum ExecutionError

pub enum ExecutionError {
    InsufficientGas,
    InvalidGasObject,
    InvariantViolation,
    FeatureNotYetSupported,
    ObjectTooBig {
        object_size: u64,
        max_object_size: u64,
    },
    PackageTooBig {
        object_size: u64,
        max_object_size: u64,
    },
    CircularObjectOwnership {
        object: ObjectId,
    },
    InsufficientCoinBalance,
    CoinBalanceOverflow,
    PublishErrorNonZeroAddress,
    SuiMoveVerificationError,
    MovePrimitiveRuntimeError {
        location: Option<MoveLocation>,
    },
    MoveAbort {
        location: MoveLocation,
        code: u64,
    },
    VmVerificationOrDeserializationError,
    VmInvariantViolation,
    FunctionNotFound,
    ArityMismatch,
    TypeArityMismatch,
    NonEntryFunctionInvoked,
    CommandArgumentError {
        argument: u16,
        kind: CommandArgumentError,
    },
    TypeArgumentError {
        type_argument: u16,
        kind: TypeArgumentError,
    },
    UnusedValueWithoutDrop {
        result: u16,
        subresult: u16,
    },
    InvalidPublicFunctionReturnType {
        index: u16,
    },
    InvalidTransferObject,
    EffectsTooLarge {
        current_size: u64,
        max_size: u64,
    },
    PublishUpgradeMissingDependency,
    PublishUpgradeDependencyDowngrade,
    PackageUpgradeError {
        kind: PackageUpgradeError,
    },
    WrittenObjectsTooLarge {
        object_size: u64,
        max_object_size: u64,
    },
    CertificateDenied,
    SuiMoveVerificationTimedout,
    SharedObjectOperationNotAllowed,
    InputObjectDeleted,
    ExecutionCancelledDueToSharedObjectCongestion {
        congested_objects: Vec<ObjectId>,
    },
    AddressDeniedForCoin {
        address: Address,
        coin_type: String,
    },
    CoinTypeGlobalPause {
        coin_type: String,
    },
    ExecutionCancelledDueToRandomnessUnavailable,
}

An error that can occur during the execution of a transaction

BCS

The BCS serialized form for this type is defined by the following ABNF:

 
execution-error =  insufficient-gas
                =/ invalid-gas-object
                =/ invariant-violation
                =/ feature-not-yet-supported
                =/ object-too-big
                =/ package-too-big
                =/ circular-object-ownership
                =/ insufficient-coin-balance
                =/ coin-balance-overflow
                =/ publish-error-non-zero-address
                =/ sui-move-verification-error
                =/ move-primitive-runtime-error
                =/ move-abort
                =/ vm-verification-or-deserialization-error
                =/ vm-invariant-violation
                =/ function-not-found
                =/ arity-mismatch
                =/ type-arity-mismatch
                =/ non-entry-function-invoked
                =/ command-argument-error
                =/ type-argument-error
                =/ unused-value-without-drop
                =/ invalid-public-function-return-type
                =/ invalid-transfer-object
                =/ effects-too-large
                =/ publish-upgrade-missing-dependency
                =/ publish-upgrade-dependency-downgrade
                =/ package-upgrade-error
                =/ written-objects-too-large
                =/ certificate-denied
                =/ sui-move-verification-timedout
                =/ shared-object-operation-not-allowed
                =/ input-object-deleted
                =/ execution-cancelled-due-to-shared-object-congestion
                =/ address-denied-for-coin
                =/ coin-type-global-pause
                =/ execution-cancelled-due-to-randomness-unavailable

insufficient-gas                                    = %x00
invalid-gas-object                                  = %x01
invariant-violation                                 = %x02
feature-not-yet-supported                           = %x03
object-too-big                                      = %x04 u64 u64
package-too-big                                     = %x05 u64 u64
circular-object-ownership                           = %x06 object-id
insufficient-coin-balance                           = %x07
coin-balance-overflow                               = %x08
publish-error-non-zero-address                      = %x09
sui-move-verification-error                         = %x0a
move-primitive-runtime-error                        = %x0b (option move-location)
move-abort                                          = %x0c move-location u64
vm-verification-or-deserialization-error            = %x0d
vm-invariant-violation                              = %x0e
function-not-found                                  = %x0f
arity-mismatch                                      = %x10
type-arity-mismatch                                 = %x11
non-entry-function-invoked                          = %x12
command-argument-error                              = %x13 u16 command-argument-error
type-argument-error                                 = %x14 u16 type-argument-error
unused-value-without-drop                           = %x15 u16 u16
invalid-public-function-return-type                 = %x16 u16
invalid-transfer-object                             = %x17
effects-too-large                                   = %x18 u64 u64
publish-upgrade-missing-dependency                  = %x19
publish-upgrade-dependency-downgrade                = %x1a
package-upgrade-error                               = %x1b package-upgrade-error
written-objects-too-large                           = %x1c u64 u64
certificate-denied                                  = %x1d
sui-move-verification-timedout                      = %x1e
shared-object-operation-not-allowed                 = %x1f
input-object-deleted                                = %x20
execution-cancelled-due-to-shared-object-congestion = %x21 (vector object-id)
address-denied-for-coin                             = %x22 address string
coin-type-global-pause                              = %x23 string
execution-cancelled-due-to-randomness-unavailable   = %x24

Variants

InsufficientGas

Insufficient Gas

InvalidGasObject

Invalid Gas Object.

InvariantViolation

Invariant Violation

FeatureNotYetSupported

Attempted to used feature that is not supported yet

ObjectTooBig

Move object is larger than the maximum allowed size

Fields

object_size: u64

max_object_size: u64

PackageTooBig

Package is larger than the maximum allowed size

Fields

object_size: u64

max_object_size: u64

CircularObjectOwnership

Circular Object Ownership

Fields

object: ObjectId

InsufficientCoinBalance

Insufficient coin balance for requested operation

CoinBalanceOverflow

Coin balance overflowed an u64

PublishErrorNonZeroAddress

Publish Error, Non-zero Address. The modules in the package must have their self-addresses set to zero.

SuiMoveVerificationError

Sui Move Bytecode Verification Error.

MovePrimitiveRuntimeError

Error from a non-abort instruction. Possible causes: Arithmetic error, stack overflow, max value depth, etc.“

Fields

location: Option<MoveLocation>

MoveAbort

Move runtime abort

Fields

location: MoveLocation

code: u64

VmVerificationOrDeserializationError

Bytecode verification error.

VmInvariantViolation

MoveVm invariant violation

FunctionNotFound

Function not found

ArityMismatch

Arity mismatch for Move function. The number of arguments does not match the number of parameters

TypeArityMismatch

Type arity mismatch for Move function. Mismatch between the number of actual versus expected type arguments.

NonEntryFunctionInvoked

Non Entry Function Invoked. Move Call must start with an entry function.

CommandArgumentError

Invalid command argument

Fields

argument: u16

kind: CommandArgumentError

TypeArgumentError

Type argument error

Fields

type_argument: u16

Index of the problematic type argument

kind: TypeArgumentError

UnusedValueWithoutDrop

Unused result without the drop ability.

Fields

result: u16

subresult: u16

InvalidPublicFunctionReturnType

Invalid public Move function signature. Unsupported return type for return value

Fields

index: u16

InvalidTransferObject

Invalid Transfer Object, object does not have public transfer.

EffectsTooLarge

Effects from the transaction are too large

Fields

current_size: u64

max_size: u64

PublishUpgradeMissingDependency

Publish or Upgrade is missing dependency

PublishUpgradeDependencyDowngrade

Publish or Upgrade dependency downgrade.

Indirect (transitive) dependency of published or upgraded package has been assigned an on-chain version that is less than the version required by one of the package’s transitive dependencies.

PackageUpgradeError

Invalid package upgrade

Fields

kind: PackageUpgradeError

WrittenObjectsTooLarge

Indicates the transaction tried to write objects too large to storage

Fields

object_size: u64

max_object_size: u64

CertificateDenied

Certificate is on the deny list

SuiMoveVerificationTimedout

Sui Move Bytecode verification timed out.

SharedObjectOperationNotAllowed

The requested shared object operation is not allowed

InputObjectDeleted

Requested shared object has been deleted

ExecutionCancelledDueToSharedObjectCongestion

Certificate is cancelled due to congestion on shared objects

Fields

congested_objects: Vec<ObjectId>

AddressDeniedForCoin

Address is denied for this coin type

Fields

address: Address

coin_type: String

CoinTypeGlobalPause

Coin type is globally paused for use

Fields

coin_type: String

ExecutionCancelledDueToRandomnessUnavailable

Certificate is cancelled because randomness could not be generated this epoch

Trait Implementations

impl Arbitrary for ExecutionError

type Parameters = ()

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

type Strategy = BoxedStrategy<ExecutionError>

The type of Strategy used to generate values of type Self.

fn arbitrary_with(args: <Self as Arbitrary>::Parameters) -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self).

impl Clone for ExecutionError

fn clone(&self) -> ExecutionError

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ExecutionError

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ExecutionError

Available on crate feature serde only.

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ExecutionError

fn eq(&self, other: &ExecutionError) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ExecutionError

Available on crate feature serde only.

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for ExecutionError

impl StructuralPartialEq for ExecutionError