Enum ErrorReason 

#[non_exhaustive]
#[repr(i32)]
pub enum ErrorReason {
    Unknown = 0,
    FieldInvalid = 1,
    FieldMissing = 2,
    InsufficientGasBalance = 3,
    TransactionExecutionFailed = 4,
}

Error reasons in the sui.io error domain, used as the reason of a google.rpc.ErrorInfo or of a google.rpc.BadRequest.FieldViolation.

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.

Unknown = 0

FieldInvalid = 1

FieldMissing = 2

InsufficientGasBalance = 3

Gas selection could not find enough SUI to cover the gas budget. SimulateTransaction returns this with INVALID_ARGUMENT. Gas selection runs only when do_gas_selection is set, checks is not DISABLED, and the transaction has no gas payment objects. When the server estimates the budget and the transaction fails in that estimation, SimulateTransaction returns TRANSACTION_EXECUTION_FAILED instead of this error, so with an estimated budget this reason means the transaction executed successfully in simulation.

Example of an ErrorInfo when the gas owner holds a single 2246360 MIST coin, has no address balance, and the transaction needs a budget of 8924024 MIST:

{ "reason": "INSUFFICIENT_GAS_BALANCE",
   "domain": "sui.io",
   "metadata": {
     "owner": "0x0000000000000000000000000000000000000000000000000000000000000123",
     "requiredBudget": "8924024",
     "coinBalance": "2246360",
     "addressBalance": "0"
   }
}

Metadata, with amounts in MIST as decimal strings:

• owner: the gas owner’s address, as “0x” followed by 64 hex digits.
• requiredBudget: the gas budget the transaction needs. When the request leaves the budget unset, this is the server’s estimate plus the cost of loading every coin counted in coinBalance beyond the first; otherwise it is the budget from the request. An estimated requiredBudget depends on how many coins the gas owner holds: when the owner already holds coins, sending it a new coin raises requiredBudget by up to the cost of loading one more coin. A new coin worth requiredBudget covers that increase unless coinBalance is less than the cost of loading one coin; a new coin worth only requiredBudget minus coinBalance can fall short.
• coinBalance: total of the gas owner’s Coin<SUI> objects considered by gas selection: owned, non-consensus coins not already used as transaction inputs, largest first, up to the protocol’s maximum number of gas payment objects.
• addressBalance: the gas owner’s SUI address balance remaining after the transaction’s own explicit SUI withdrawals from the gas owner; “0” if there is none.

The two balances are reported separately because they combine differently. When the transaction uses the gas coin (an Argument of kind GAS), coins and address balance are combined to pay for gas. Otherwise they are never combined: the address balance pays for gas only if it alone covers the budget before coin-loading costs, which is at most requiredBudget; if it does not, the coins alone must cover requiredBudget.

TransactionExecutionFailed = 4

The transaction failed while executing in simulation. SimulateTransaction returns this with INVALID_ARGUMENT when it estimates the budget, the transaction fails in that estimation, and gas selection then cannot cover the budget. It is returned instead of the INSUFFICIENT_GAS_BALANCE reason in that case because the transaction fails even with its gas paid for, so the gas budget is not what stops it; kind says what does. Some kinds can still be fixed by adding funds: for example, INSUFFICIENT_FUNDS_FOR_WITHDRAW means a balance the transaction withdraws from holds too little. INSUFFICIENT_GAS cannot: the estimation runs with the maximum gas budget, so it means the transaction needs more gas than any budget allows. A gas owner that can cover the budget instead gets a successful response whose effects.status.error describes the failure.

The status details also carry the ExecutionError, in the same form as effects.status.error.

Example of an ErrorInfo for a Move abort in the first command:

{ "reason": "TRANSACTION_EXECUTION_FAILED",
   "domain": "sui.io",
   "metadata": {
     "kind": "MOVE_ABORT",
     "command": "0"
   }
}

Metadata:

• kind: the failure’s ExecutionError.ExecutionErrorKind name.
• command: index of the command that failed, as a decimal string, or “” if no single command failed.

Implementations

impl ErrorReason

pub fn is_valid(value: i32) -> bool

Returns true if value is a variant of ErrorReason.

pub fn from_i32(value: i32) -> Option<ErrorReason>

👎Deprecated:

Use the TryFrom<i32> implementation instead

Converts an i32 to a ErrorReason, or None if value is not a valid variant.

impl ErrorReason

pub fn as_str_name(&self) -> &'static str

String value of the enum field names used in the ProtoBuf definition.

The values are not transformed in any way and thus are considered stable (if the ProtoBuf definition does not change) and safe for programmatic use.

pub fn from_str_name(value: &str) -> Option<ErrorReason>

Creates an enum from field names used in the ProtoBuf definition.

impl ErrorReason

pub const DOMAIN: &'static str = "sui.io"

The error domain of every ErrorReason, used as google.rpc.ErrorInfo.domain.

Trait Implementations

impl AsRef<str> for ErrorReason

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for ErrorReason

fn clone(&self) -> ErrorReason

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ErrorReason

impl Debug for ErrorReason

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

Formats the value using the given formatter.

impl Default for ErrorReason

fn default() -> ErrorReason

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ErrorReason

fn deserialize<D>( deserializer: D, ) -> Result<ErrorReason, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ErrorReason

impl From<ErrorReason> for i32

fn from(value: ErrorReason) -> i32

Converts to this type from the input type.

impl Hash for ErrorReason

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 Ord for ErrorReason

fn cmp(&self, other: &ErrorReason) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for ErrorReason

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

fn partial_cmp(&self, other: &ErrorReason) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for ErrorReason

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ErrorReason

impl TryFrom<i32> for ErrorReason

type Error = UnknownEnumValue

The type returned in the event of a conversion error.

fn try_from(value: i32) -> Result<ErrorReason, UnknownEnumValue>

Performs the conversion.