Enum solana_sdk::instruction::InstructionError

pub enum InstructionError {
    GenericError,
    InvalidArgument,
    InvalidInstructionData,
    InvalidAccountData,
    AccountDataTooSmall,
    InsufficientFunds,
    IncorrectProgramId,
    MissingRequiredSignature,
    AccountAlreadyInitialized,
    UninitializedAccount,
    UnbalancedInstruction,
    ModifiedProgramId,
    ExternalAccountLamportSpend,
    ExternalAccountDataModified,
    ReadonlyLamportChange,
    ReadonlyDataModified,
    DuplicateAccountIndex,
    ExecutableModified,
    RentEpochModified,
    NotEnoughAccountKeys,
    AccountDataSizeChanged,
    AccountNotExecutable,
    AccountBorrowFailed,
    AccountBorrowOutstanding,
    DuplicateAccountOutOfSync,
    Custom(u32),
    InvalidError,
    ExecutableDataModified,
    ExecutableLamportChange,
    ExecutableAccountNotRentExempt,
    UnsupportedProgramId,
    CallDepth,
    MissingAccount,
    ReentrancyNotAllowed,
    MaxSeedLengthExceeded,
    InvalidSeeds,
    InvalidRealloc,
    ComputationalBudgetExceeded,
    PrivilegeEscalation,
    ProgramEnvironmentSetupFailure,
    ProgramFailedToComplete,
    ProgramFailedToCompile,
    Immutable,
    IncorrectAuthority,
    BorshIoError(String),
    AccountNotRentExempt,
    InvalidAccountOwner,
    ArithmeticOverflow,
    UnsupportedSysvar,
    IllegalOwner,
    MaxAccountsDataAllocationsExceeded,
    MaxAccountsExceeded,
    MaxInstructionTraceLengthExceeded,
    BuiltinProgramsMustConsumeComputeUnits,
}

Reasons the runtime might have rejected an instruction.

Members of this enum must not be removed, but new ones can be added. Also, it is crucial that meta-information if any that comes along with an error be consistent across software versions. For example, it is dangerous to include error strings from 3rd party crates because they could change at any time and changes to them are difficult to detect.

Variants

GenericError

Deprecated! Use CustomError instead! The program instruction returned an error

InvalidArgument

The arguments provided to a program were invalid

InvalidInstructionData

An instruction’s data contents were invalid

InvalidAccountData

An account’s data contents was invalid

AccountDataTooSmall

An account’s data was too small

InsufficientFunds

An account’s balance was too small to complete the instruction

IncorrectProgramId

The account did not have the expected program id

MissingRequiredSignature

A signature was required but not found

AccountAlreadyInitialized

An initialize instruction was sent to an account that has already been initialized.

UninitializedAccount

An attempt to operate on an account that hasn’t been initialized.

UnbalancedInstruction

Program’s instruction lamport balance does not equal the balance after the instruction

ModifiedProgramId

Program illegally modified an account’s program id

ExternalAccountLamportSpend

Program spent the lamports of an account that doesn’t belong to it

ExternalAccountDataModified

Program modified the data of an account that doesn’t belong to it

ReadonlyLamportChange

Read-only account’s lamports modified

ReadonlyDataModified

Read-only account’s data was modified

DuplicateAccountIndex

An account was referenced more than once in a single instruction

ExecutableModified

Executable bit on account changed, but shouldn’t have

RentEpochModified

Rent_epoch account changed, but shouldn’t have

NotEnoughAccountKeys

The instruction expected additional account keys

AccountDataSizeChanged

Program other than the account’s owner changed the size of the account data

AccountNotExecutable

The instruction expected an executable account

AccountBorrowFailed

Failed to borrow a reference to account data, already borrowed

AccountBorrowOutstanding

Account data has an outstanding reference after a program’s execution

DuplicateAccountOutOfSync

The same account was multiply passed to an on-chain program’s entrypoint, but the program modified them differently. A program can only modify one instance of the account because the runtime cannot determine which changes to pick or how to merge them if both are modified

Custom(u32)

Allows on-chain programs to implement program-specific error types and see them returned by the Solana runtime. A program-specific error may be any type that is represented as or serialized to a u32 integer.

InvalidError

The return value from the program was invalid. Valid errors are either a defined builtin error value or a user-defined error in the lower 32 bits.

ExecutableDataModified

Executable account’s data was modified

ExecutableLamportChange

Executable account’s lamports modified

ExecutableAccountNotRentExempt

Executable accounts must be rent exempt

UnsupportedProgramId

Unsupported program id

CallDepth

Cross-program invocation call depth too deep

MissingAccount

An account required by the instruction is missing

ReentrancyNotAllowed

Cross-program invocation reentrancy not allowed for this instruction

MaxSeedLengthExceeded

Length of the seed is too long for address generation

InvalidSeeds

Provided seeds do not result in a valid address

InvalidRealloc

Failed to reallocate account data of this length

ComputationalBudgetExceeded

Computational budget exceeded

PrivilegeEscalation

Cross-program invocation with unauthorized signer or writable account

ProgramEnvironmentSetupFailure

Failed to create program execution environment

ProgramFailedToComplete

Program failed to complete

ProgramFailedToCompile

Program failed to compile

Immutable

Account is immutable

IncorrectAuthority

Incorrect authority provided

BorshIoError(String)

Failed to serialize or deserialize account data

Warning: This error should never be emitted by the runtime.

This error includes strings from the underlying 3rd party Borsh crate which can be dangerous because the error strings could change across Borsh versions. Only programs can use this error because they are consistent across Solana software versions.

AccountNotRentExempt

An account does not have enough lamports to be rent-exempt

InvalidAccountOwner

Invalid account owner

ArithmeticOverflow

Program arithmetic overflowed

UnsupportedSysvar

Unsupported sysvar

IllegalOwner

Illegal account owner

MaxAccountsDataAllocationsExceeded

Accounts data allocations exceeded the maximum allowed per transaction

MaxAccountsExceeded

Max accounts exceeded

MaxInstructionTraceLengthExceeded

Max instruction trace length exceeded

BuiltinProgramsMustConsumeComputeUnits

Builtin programs must consume compute units

Trait Implementations

impl AbiEnumVisitor for InstructionError

fn visit_for_abi( &self, digester: &mut AbiDigester ) -> Result<AbiDigester, DigestError>

impl AbiExample for InstructionError

fn example() -> InstructionError

impl Clone for InstructionError

fn clone(&self) -> InstructionError

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for InstructionError

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for InstructionError

fn deserialize<__D>( __deserializer: __D ) -> Result<InstructionError, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for InstructionError

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

Formats the value using the given formatter.

impl Error for InstructionError

fn source(&self) -> Option<&(dyn Error + 'static)>

The lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type based access to context intended for error reports.

impl From<LamportsError> for InstructionError

fn from(error: LamportsError) -> InstructionError

Converts to this type from the input type.

impl<T> From<T> for InstructionError

where T: ToPrimitive,

fn from(error: T) -> InstructionError

Converts to this type from the input type.

impl PartialEq for InstructionError

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

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 TryFrom<InstructionError> for ProgramError

type Error = InstructionError

The type returned in the event of a conversion error.

fn try_from( error: InstructionError ) -> Result<ProgramError, <ProgramError as TryFrom<InstructionError>>::Error>

Performs the conversion.

impl Eq for InstructionError

impl StructuralPartialEq for InstructionError