Enum 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,
    EmptyAuthorizationList,
    OptimismError(OptimismInvalidTransaction),
}

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.

EmptyAuthorizationList

Empty Authorization List is not allowed.

OptimismError(OptimismInvalidTransaction)

Available on crate feature optimism only.

Optimism-specific transaction validation error.

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

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

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 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: 23 bytes
• OverflowPaymentInTransaction: 0 bytes
• NonceOverflowInTransaction: 0 bytes
• NonceTooHigh: 23 bytes
• NonceTooLow: 23 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: 23 bytes
• BlobVersionNotSupported: 0 bytes
• EofCrateShouldHaveToAddress: 0 bytes
• AuthorizationListNotSupported: 0 bytes
• AuthorizationListInvalidFields: 0 bytes
• EmptyAuthorizationList: 0 bytes
• OptimismError: 1 byte