Enum TransactionError

pub enum TransactionError {
    AccountInUse,
    AccountLoadedTwice,
    AccountNotFound,
    ProgramAccountNotFound,
    InsufficientFundsForFee,
    InvalidAccountForFee,
    AlreadyProcessed,
    BlockhashNotFound,
    InstructionError(u8, InstructionError),
    CallChainTooDeep,
    MissingSignatureForFee,
    InvalidAccountIndex,
    SignatureFailure,
    InvalidProgramForExecution,
    SanitizeFailure,
    ClusterMaintenance,
    AccountBorrowOutstanding,
    WouldExceedMaxBlockCostLimit,
    UnsupportedVersion,
    InvalidWritableAccount,
    WouldExceedMaxAccountCostLimit,
    WouldExceedAccountDataBlockLimit,
    TooManyAccountLocks,
    AddressLookupTableNotFound,
    InvalidAddressLookupTableOwner,
    InvalidAddressLookupTableData,
    InvalidAddressLookupTableIndex,
    InvalidRentPayingAccount,
    WouldExceedMaxVoteCostLimit,
    WouldExceedAccountDataTotalLimit,
    DuplicateInstruction(u8),
    InsufficientFundsForRent {
        account_index: u8,
    },
    MaxLoadedAccountsDataSizeExceeded,
    InvalidLoadedAccountsDataSizeLimit,
    ResanitizationNeeded,
    ProgramExecutionTemporarilyRestricted {
        account_index: u8,
    },
    UnbalancedTransaction,
}

Reasons a transaction might be rejected.

Variants

AccountInUse

An account is already being processed in another transaction in a way that does not support parallelism

AccountLoadedTwice

A Pubkey appears twice in the transaction’s account_keys. Instructions can reference Pubkeys more than once but the message must contain a list with no duplicate keys

AccountNotFound

Attempt to debit an account but found no record of a prior credit.

ProgramAccountNotFound

Attempt to load a program that does not exist

InsufficientFundsForFee

The from Pubkey does not have sufficient balance to pay the fee to schedule the transaction

InvalidAccountForFee

This account may not be used to pay transaction fees

AlreadyProcessed

The bank has seen this transaction before. This can occur under normal operation when a UDP packet is duplicated, as a user error from a client not updating its recent_blockhash, or as a double-spend attack.

BlockhashNotFound

The bank has not seen the given recent_blockhash or the transaction is too old and the recent_blockhash has been discarded.

InstructionError(u8, InstructionError)

An error occurred while processing an instruction. The first element of the tuple indicates the instruction index in which the error occurred.

CallChainTooDeep

Loader call chain is too deep

MissingSignatureForFee

Transaction requires a fee but has no signature present

InvalidAccountIndex

Transaction contains an invalid account reference

SignatureFailure

Transaction did not pass signature verification

InvalidProgramForExecution

This program may not be used for executing instructions

SanitizeFailure

Transaction failed to sanitize accounts offsets correctly implies that account locks are not taken for this TX, and should not be unlocked.

ClusterMaintenance

AccountBorrowOutstanding

Transaction processing left an account with an outstanding borrowed reference

WouldExceedMaxBlockCostLimit

Transaction would exceed max Block Cost Limit

UnsupportedVersion

Transaction version is unsupported

InvalidWritableAccount

Transaction loads a writable account that cannot be written

WouldExceedMaxAccountCostLimit

Transaction would exceed max account limit within the block

WouldExceedAccountDataBlockLimit

Transaction would exceed account data limit within the block

TooManyAccountLocks

Transaction locked too many accounts

AddressLookupTableNotFound

Address lookup table not found

InvalidAddressLookupTableOwner

Attempted to lookup addresses from an account owned by the wrong program

InvalidAddressLookupTableData

Attempted to lookup addresses from an invalid account

InvalidAddressLookupTableIndex

Address table lookup uses an invalid index

InvalidRentPayingAccount

Transaction leaves an account with a lower balance than rent-exempt minimum

WouldExceedMaxVoteCostLimit

Transaction would exceed max Vote Cost Limit

WouldExceedAccountDataTotalLimit

Transaction would exceed total account data limit

DuplicateInstruction(u8)

Transaction contains a duplicate instruction that is not allowed

InsufficientFundsForRent

Transaction results in an account with insufficient funds for rent

Fields

account_index: u8

MaxLoadedAccountsDataSizeExceeded

Transaction exceeded max loaded accounts data size cap

InvalidLoadedAccountsDataSizeLimit

LoadedAccountsDataSizeLimit set for transaction must be greater than 0.

ResanitizationNeeded

Sanitized transaction differed before/after feature activiation. Needs to be resanitized.

ProgramExecutionTemporarilyRestricted

Program execution is temporarily restricted on an account.

Fields

account_index: u8

UnbalancedTransaction

The total balance before the transaction does not equal the total balance after the transaction

Trait Implementations

impl AbiEnumVisitor for TransactionError

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

impl AbiExample for TransactionError

fn example() -> TransactionError

impl Clone for TransactionError

fn clone(&self) -> TransactionError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TransactionError

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TransactionError

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for TransactionError

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

Formats the value using the given formatter.

impl Error for TransactionError

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

Returns 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<AddressLoaderError> for TransactionError

fn from(err: AddressLoaderError) -> TransactionError

Converts to this type from the input type.

impl From<SanitizeError> for TransactionError

fn from(_: SanitizeError) -> TransactionError

Converts to this type from the input type.

impl From<SanitizeMessageError> for TransactionError

fn from(err: SanitizeMessageError) -> TransactionError

Converts to this type from the input type.

impl From<TransactionError> for SignerError

fn from(source: TransactionError) -> SignerError

Converts to this type from the input type.

impl From<TransactionError> for TransportError

fn from(source: TransactionError) -> TransportError

Converts to this type from the input type.

impl PartialEq for TransactionError

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

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 Eq for TransactionError

impl StructuralPartialEq for TransactionError