Enum TransactionError 

pub enum TransactionError {
    AccountInUse,
    AccountLoadedTwice,
    AccountNotFound,
    ProgramAccountNotFound,
    InsufficientFundsForFee,
    InvalidAccountForFee,
    AlreadyProcessed,
    TimestampTooStale,
    TimestampInFuture,
    InstructionError(u8, InstructionError),
    InvalidAccountIndex,
    SignatureFailure,
    InvalidProgramForExecution,
    SanitizeFailure,
    AccountBorrowOutstanding,
    WouldExceedMaxBlockCostLimit,
    UnsupportedVersion,
    InvalidWritableAccount,
    WouldExceedMaxAccountCostLimit,
    WouldExceedAccountDataBlockLimit,
    TooManyAccountLocks,
    InvalidRentPayingAccount,
    WouldExceedMaxVoteCostLimit,
    DuplicateInstruction(u8),
    InsufficientFundsForRent {
        account_index: u8,
    },
    MaxLoadedAccountsDataSizeExceeded,
    InvalidLoadedAccountsDataSizeLimit,
    ResanitizationNeeded,
    UnbalancedTransaction,
    ProgramCacheHitMaxLimit,
    SerializationFailure,
}

Reasons a transaction might be rejected.

This enum represents all the possible ways a transaction can fail during processing, validation, or execution.

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.

TimestampTooStale

The transaction is too stale (seconds since UNIX_EPOCH).

TimestampInFuture

The transaction is too far in the future (seconds since UNIX_EPOCH).

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.

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.

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

InvalidRentPayingAccount

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

WouldExceedMaxVoteCostLimit

Transaction would exceed max Vote Cost 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.

UnbalancedTransaction

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

ProgramCacheHitMaxLimit

Program cache hit max limit.

SerializationFailure

Failed to serialize transaction instructions.

Trait Implementations

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

Formats the value using the given formatter.

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

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for TransactionError

impl StructuralPartialEq for TransactionError