Enum primitives::transaction::TransactionError

pub enum TransactionError {
    AlreadyImported,
    ChainIdMismatch {
        expected: u32,
        got: u32,
        space: Space,
    },
    EpochHeightOutOfBound {
        block_height: u64,
        set: u64,
        transaction_epoch_bound: u64,
    },
    NotEnoughBaseGas {
        required: U256,
        got: U256,
    },
    Stale,
    TooCheapToReplace,
    LimitReached,
    InsufficientGasPrice {
        minimal: U256,
        got: U256,
    },
    InsufficientGas {
        minimal: U256,
        got: U256,
    },
    InsufficientBalance {
        balance: U256,
        cost: U256,
    },
    GasLimitExceeded {
        limit: U256,
        got: U256,
    },
    InvalidGasLimit(OutOfBounds<U256>),
    InvalidSignature(String),
    TooBig,
    InvalidRlp(String),
    ZeroGasPrice,
    FutureTransactionType,
    InvalidReceiver,
    TooLargeNonce,
}

Errors concerning transaction processing.

Variants

AlreadyImported

Transaction is already imported to the queue

ChainIdMismatch

Fields

expected: u32

got: u32

space: Space

Chain id in the transaction doesn’t match the chain id of the network.

EpochHeightOutOfBound

Fields

block_height: u64

set: u64

transaction_epoch_bound: u64

Epoch height out of bound.

NotEnoughBaseGas

Fields

required: U256

Absolute minimum gas required.

got: U256

Gas provided.

The gas paid for transaction is lower than base gas.

Stale

Transaction is not valid anymore (state already has higher nonce)

TooCheapToReplace

Transaction has too low fee (there is already a transaction with the same sender-nonce but higher gas price)

LimitReached

Transaction was not imported to the queue because limit has been reached.

InsufficientGasPrice

Fields

minimal: U256

Minimal expected gas price

got: U256

Transaction gas price

Transaction’s gas price is below threshold.

InsufficientGas

Fields

minimal: U256

Minimal expected gas

got: U256

Transaction gas

Transaction’s gas is below currently set minimal gas requirement.

InsufficientBalance

Fields

balance: U256

Senders balance

cost: U256

Transaction cost

Sender doesn’t have enough funds to pay for this transaction

GasLimitExceeded

Fields

limit: U256

Current gas limit

got: U256

Declared transaction gas

Transactions gas is higher then current gas limit

InvalidGasLimit(OutOfBounds<U256>)

Transaction’s gas limit (aka gas) is invalid.

InvalidSignature(String)

Signature error

TooBig

Transaction too big

InvalidRlp(String)

Invalid RLP encoding

ZeroGasPrice

FutureTransactionType

Transaction types have not been activated

InvalidReceiver

Receiver with invalid type bit.

TooLargeNonce

Transaction nonce exceeds local limit.

Trait Implementations

impl Clone for TransactionError

fn clone(&self) -> TransactionError

Returns a copy 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 Display for TransactionError

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

Formats the value using the given formatter.

impl Error for TransactionError

fn description(&self) -> &str

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

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

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

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

fn from(err: DecoderError) -> Self

Converts to this type from the input type.

impl From<Error> for TransactionError

fn from(err: Error) -> Self

Converts to this type from the input type.

impl PartialEq for TransactionError

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

impl StructuralPartialEq for TransactionError