Enum reth::revm::revm::interpreter::primitives::result::InvalidTransaction

pub enum InvalidTransaction {
    PriorityFeeGreaterThanMaxFee,
    GasPriceLessThanBasefee,
    CallerGasLimitMoreThanBlock,
    CallGasCostMoreThanGasLimit,
    RejectCallerWithCode,
    LackOfFundForMaxFee {
        fee: Box<Uint<256, 4>>,
        balance: Box<Uint<256, 4>>,
    },
    OverflowPaymentInTransaction,
    NonceOverflowInTransaction,
    NonceTooHigh {
        tx: u64,
        state: u64,
    },
    NonceTooLow {
        tx: u64,
        state: u64,
    },
    CreateInitCodeSizeLimit,
    InvalidChainId,
    AccessListNotSupported,
    MaxFeePerBlobGasNotSupported,
    BlobVersionedHashesNotSupported,
    BlobGasPriceGreaterThanMax,
    EmptyBlobs,
    BlobCreateTransaction,
    TooManyBlobs {
        max: usize,
        have: usize,
    },
    BlobVersionNotSupported,
    EofCrateShouldHaveToAddress,
    AuthorizationListNotSupported,
    AuthorizationListInvalidFields,
    DepositSystemTxPostRegolith,
    HaltedDepositPostRegolith,
}

Transaction validation error.

Variants

PriorityFeeGreaterThanMaxFee

When using the EIP-1559 fee model introduced in the London upgrade, transactions specify two primary fee fields:

• gas_max_fee: The maximum total fee a user is willing to pay, inclusive of both base fee and priority fee.
• gas_priority_fee: The extra amount a user is willing to give directly to the miner, often referred to as the “tip”.

Provided gas_priority_fee exceeds the total gas_max_fee.

GasPriceLessThanBasefee

EIP-1559: gas_price is less than basefee.

CallerGasLimitMoreThanBlock

gas_limit in the tx is bigger than block_gas_limit.

CallGasCostMoreThanGasLimit

Initial gas for a Call is bigger than gas_limit.

Initial gas for a Call contains:

• initial stipend gas
• gas for access list and input data

RejectCallerWithCode

EIP-3607 Reject transactions from senders with deployed code

LackOfFundForMaxFee

Transaction account does not have enough amount of ether to cover transferred value and gas_limit*gas_price.

Fields

fee: Box<Uint<256, 4>>

balance: Box<Uint<256, 4>>

OverflowPaymentInTransaction

Overflow payment in transaction.

NonceOverflowInTransaction

Nonce overflows in transaction.

NonceTooHigh

Fields

tx: u64

state: u64

NonceTooLow

Fields

tx: u64

state: u64

CreateInitCodeSizeLimit

EIP-3860: Limit and meter initcode

InvalidChainId

Transaction chain id does not match the config chain id.

AccessListNotSupported

Access list is not supported for blocks before the Berlin hardfork.

MaxFeePerBlobGasNotSupported

max_fee_per_blob_gas is not supported for blocks before the Cancun hardfork.

BlobVersionedHashesNotSupported

blob_hashes/blob_versioned_hashes is not supported for blocks before the Cancun hardfork.

BlobGasPriceGreaterThanMax

Block blob_gas_price is greater than tx-specified max_fee_per_blob_gas after Cancun.

EmptyBlobs

There should be at least one blob in Blob transaction.

BlobCreateTransaction

Blob transaction can’t be a create transaction. to must be present

TooManyBlobs

Transaction has more then crate::MAX_BLOB_NUMBER_PER_BLOCK blobs

Fields

max: usize

have: usize

BlobVersionNotSupported

Blob transaction contains a versioned hash with an incorrect version

EofCrateShouldHaveToAddress

EOF crate should have to address

AuthorizationListNotSupported

EIP-7702 is not enabled.

AuthorizationListInvalidFields

EIP-7702 transaction has invalid fields set.

DepositSystemTxPostRegolith

Available on crate feature optimism only.

System transactions are not supported post-regolith hardfork.

Before the Regolith hardfork, there was a special field in the Deposit transaction type that differentiated between system and user deposit transactions. This field was deprecated in the Regolith hardfork, and this error is thrown if a Deposit transaction is found with this field set to true after the hardfork activation.

In addition, this error is internal, and bubbles up into a HaltReason::FailedDeposit error in the revm handler for the consumer to easily handle. This is due to a state transition rule on OP Stack chains where, if for any reason a deposit transaction fails, the transaction must still be included in the block, the sender nonce is bumped, the mint value persists, and special gas accounting rules are applied. Normally on L1, EVMError::Transaction errors are cause for non-inclusion, so a special HaltReason variant was introduced to handle this case for failed deposit transactions.

HaltedDepositPostRegolith

Available on crate feature optimism only.

Deposit transaction haults bubble up to the global main return handler, wiping state and only increasing the nonce + persisting the mint value.

This is a catch-all error for any deposit transaction that is results in a HaltReason error post-regolith hardfork. This allows for a consumer to easily handle special cases where a deposit transaction fails during validation, but must still be included in the block.

In addition, this error is internal, and bubbles up into a HaltReason::FailedDeposit error in the revm handler for the consumer to easily handle. This is due to a state transition rule on OP Stack chains where, if for any reason a deposit transaction fails, the transaction must still be included in the block, the sender nonce is bumped, the mint value persists, and special gas accounting rules are applied. Normally on L1, EVMError::Transaction errors are cause for non-inclusion, so a special HaltReason variant was introduced to handle this case for failed deposit transactions.

Trait Implementations

impl Clone for InvalidTransaction

fn clone(&self) -> InvalidTransaction

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for InvalidTransaction

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for InvalidTransaction

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for InvalidTransaction

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

Formats the value using the given formatter.

impl Error for InvalidTransaction

Available on crate feature std only.

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 #99301)

Provides type based access to context intended for error reports.

impl<DBError> From<InvalidTransaction> for EVMError<DBError>

fn from(value: InvalidTransaction) -> EVMError<DBError>

Converts to this type from the input type.

impl From<InvalidTransaction> for RpcInvalidTransactionError

fn from(err: InvalidTransaction) -> RpcInvalidTransactionError

Converts to this type from the input type.

impl Hash for InvalidTransaction

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 PartialEq for InvalidTransaction

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

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 InvalidTransaction

impl StructuralPartialEq for InvalidTransaction

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 24 bytes

Size for each variant:

• PriorityFeeGreaterThanMaxFee: 0 bytes
• GasPriceLessThanBasefee: 0 bytes
• CallerGasLimitMoreThanBlock: 0 bytes
• CallGasCostMoreThanGasLimit: 0 bytes
• RejectCallerWithCode: 0 bytes
• LackOfFundForMaxFee: 16 bytes
• OverflowPaymentInTransaction: 0 bytes
• NonceOverflowInTransaction: 0 bytes
• NonceTooHigh: 16 bytes
• NonceTooLow: 16 bytes
• CreateInitCodeSizeLimit: 0 bytes
• InvalidChainId: 0 bytes
• AccessListNotSupported: 0 bytes
• MaxFeePerBlobGasNotSupported: 0 bytes
• BlobVersionedHashesNotSupported: 0 bytes
• BlobGasPriceGreaterThanMax: 0 bytes
• EmptyBlobs: 0 bytes
• BlobCreateTransaction: 0 bytes
• TooManyBlobs: 16 bytes
• BlobVersionNotSupported: 0 bytes
• EofCrateShouldHaveToAddress: 0 bytes
• AuthorizationListNotSupported: 0 bytes
• AuthorizationListInvalidFields: 0 bytes
• DepositSystemTxPostRegolith: 0 bytes
• HaltedDepositPostRegolith: 0 bytes