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,
    IotaMoveVerificationError,
    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,
    IotaMoveVerificationTimeout,
    SharedObjectOperationNotAllowed,
    InputObjectDeleted,
    ExecutionCancelledDueToSharedObjectCongestion {
        congested_objects: Vec<ObjectId>,
    },
    ExecutionCancelledDueToSharedObjectCongestionV2 {
        congested_objects: Vec<ObjectId>,
        suggested_gas_price: u64,
    },
    AddressDeniedForCoin {
        address: Address,
        coin_type: String,
    },
    CoinTypeGlobalPause {
        coin_type: String,
    },
    ExecutionCancelledDueToRandomnessUnavailable,
    InvalidLinkage,
}

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
                =/ iota-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
                =/ iota-move-verification-timeout
                =/ 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
iota-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
iota-move-verification-timeout                      = %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.

IotaMoveVerificationError

IOTA 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

IotaMoveVerificationTimeout

IOTA 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>

ExecutionCancelledDueToSharedObjectCongestionV2

Certificate is cancelled due to congestion on shared objects; suggested gas price can be used to give this certificate more priority.

Fields

congested_objects: Vec<ObjectId>

suggested_gas_price: u64

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

InvalidLinkage

A valid linkage was unable to be determined for the transaction or one of its commands.

Implementations

impl ExecutionError

pub fn is_insufficient_gas(&self) -> bool

pub fn is_invalid_gas_object(&self) -> bool

pub fn is_invariant_violation(&self) -> bool

pub fn is_feature_not_yet_supported(&self) -> bool

pub fn is_object_too_big(&self) -> bool

pub fn is_package_too_big(&self) -> bool

pub fn is_circular_object_ownership(&self) -> bool

pub fn is_insufficient_coin_balance(&self) -> bool

pub fn is_coin_balance_overflow(&self) -> bool

pub fn is_publish_error_non_zero_address(&self) -> bool

pub fn is_iota_move_verification_error(&self) -> bool

pub fn is_move_primitive_runtime_error(&self) -> bool

pub fn is_move_abort(&self) -> bool

pub fn is_vm_verification_or_deserialization_error(&self) -> bool

pub fn is_vm_invariant_violation(&self) -> bool

pub fn is_function_not_found(&self) -> bool

pub fn is_arity_mismatch(&self) -> bool

pub fn is_type_arity_mismatch(&self) -> bool

pub fn is_non_entry_function_invoked(&self) -> bool

pub fn is_command_argument_error(&self) -> bool

pub fn is_type_argument_error(&self) -> bool

pub fn is_unused_value_without_drop(&self) -> bool

pub fn is_invalid_public_function_return_type(&self) -> bool

pub fn is_invalid_transfer_object(&self) -> bool

pub fn is_effects_too_large(&self) -> bool

pub fn is_publish_upgrade_missing_dependency(&self) -> bool

pub fn is_publish_upgrade_dependency_downgrade(&self) -> bool

pub fn is_package_upgrade_error(&self) -> bool

pub fn is_written_objects_too_large(&self) -> bool

pub fn is_certificate_denied(&self) -> bool

pub fn is_iota_move_verification_timeout(&self) -> bool

pub fn is_shared_object_operation_not_allowed(&self) -> bool

pub fn is_input_object_deleted(&self) -> bool

pub fn is_execution_cancelled_due_to_shared_object_congestion(&self) -> bool

pub fn is_execution_cancelled_due_to_shared_object_congestion_v2(&self) -> bool

pub fn is_address_denied_for_coin(&self) -> bool

pub fn is_coin_type_global_pause(&self) -> bool

pub fn is_execution_cancelled_due_to_randomness_unavailable(&self) -> bool

pub fn is_invalid_linkage(&self) -> bool

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 duplicate 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 JsonSchema for ExecutionError

fn schema_name() -> String

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

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