Enum TempoInvalidTransaction 

pub enum TempoInvalidTransaction {
    EthInvalidTransaction(InvalidTransaction),
    SystemTransactionMustBeCall,
    SystemTransactionFailed(Box<ExecutionResult<TempoHaltReason>>),
    InvalidFeePayerSignature,
    SelfSponsoredFeePayer,
    ValidAfter {
        current: u64,
        valid_after: u64,
    },
    ValidBefore {
        current: u64,
        valid_before: u64,
    },
    InvalidP256Signature,
    InvalidWebAuthnSignature {
        reason: String,
    },
    InsufficientGasForIntrinsicCost {
        gas_limit: u64,
        intrinsic_gas: u64,
    },
    NonceManagerError(String),
    ExpiringNonceMissingTxEnv,
    ExpiringNonceMissingValidBefore,
    ExpiringNonceNonceNotZero,
    SubblockTransactionMustHaveZeroFee,
    InvalidFeeToken(Address),
    ValueTransferNotAllowed,
    ValueTransferNotAllowedInAATx,
    AccessKeyRecoveryFailed,
    AccessKeyCannotAuthorizeOtherKeys,
    KeyAuthorizationSignatureRecoveryFailed,
    KeyAuthorizationNotSignedByRoot {
        expected: Address,
        actual: Address,
    },
    AccessKeyExpiryInPast {
        expiry: u64,
        current_timestamp: u64,
    },
    KeychainPrecompileError {
        reason: String,
    },
    KeychainUserAddressMismatch {
        user_address: Address,
        caller: Address,
    },
    KeychainValidationFailed {
        reason: String,
    },
    KeyAuthorizationChainIdMismatch {
        expected: u64,
        got: u64,
    },
    LegacyKeychainSignature,
    V2KeychainBeforeActivation,
    KeychainOpInSubblockTransaction,
    CollectFeePreTx(FeePaymentError),
    CallsValidation(&'static str),
}

Tempo-specific invalid transaction errors.

This enum extends the standard Ethereum [InvalidTransaction] with Tempo-specific validation errors that occur during transaction processing.

Variants

EthInvalidTransaction(InvalidTransaction)

Standard Ethereum transaction validation error.

SystemTransactionMustBeCall

System transaction must be a call (not a create).

SystemTransactionFailed(Box<ExecutionResult<TempoHaltReason>>)

System transaction execution failed.

InvalidFeePayerSignature

Fee payer signature recovery failed.

This error occurs when a transaction specifies a fee payer but the signature recovery for the fee payer fails.

SelfSponsoredFeePayer

Fee payer cannot resolve to the sender address.

ValidAfter

Transaction cannot be included before validAfter timestamp.

Tempo transactions can specify a validAfter field to restrict when they can be included.

Fields

current: u64

The current block timestamp.

valid_after: u64

The validAfter constraint from the transaction.

ValidBefore

Transaction cannot be included after validBefore timestamp.

Tempo transactions can specify a validBefore field to restrict when they can be included.

Fields

current: u64

The current block timestamp.

valid_before: u64

The validBefore constraint from the transaction.

InvalidP256Signature

P256 signature verification failed.

The P256 signature could not be verified against the transaction hash.

InvalidWebAuthnSignature

WebAuthn signature verification failed.

The WebAuthn signature validation failed (could be authenticatorData, clientDataJSON, or P256 verification).

Fields

reason: String

Specific reason for failure.

InsufficientGasForIntrinsicCost

Insufficient gas for intrinsic cost.

Tempo transactions have variable intrinsic gas costs based on signature type and nonce usage. This error occurs when the gas_limit is less than the calculated intrinsic gas.

Fields

gas_limit: u64

The transaction’s gas limit.

intrinsic_gas: u64

The calculated intrinsic gas required.

NonceManagerError(String)

Nonce manager error.

ExpiringNonceMissingTxEnv

Expiring nonce transaction missing tempo_tx_env.

ExpiringNonceMissingValidBefore

Expiring nonce transaction missing valid_before.

ExpiringNonceNonceNotZero

Expiring nonce transaction must have nonce == 0.

SubblockTransactionMustHaveZeroFee

Subblock transaction must have zero fee.

InvalidFeeToken(Address)

Invalid fee token.

ValueTransferNotAllowed

Value transfer not allowed.

ValueTransferNotAllowedInAATx

Value transfer in Tempo Transaction not allowed.

AccessKeyRecoveryFailed

Failed to recover access key address from signature.

This error occurs when attempting to recover the access key address from a Keychain signature fails.

AccessKeyCannotAuthorizeOtherKeys

Access keys cannot authorize other keys.

Only the root key can authorize new access keys. An access key can only authorize itself in a same-transaction authorization flow.

KeyAuthorizationSignatureRecoveryFailed

Failed to recover signer from KeyAuthorization signature.

This error occurs when signature recovery from the KeyAuthorization fails.

KeyAuthorizationNotSignedByRoot

KeyAuthorization not signed by root account.

The KeyAuthorization must be signed by the root account (transaction caller), but was signed by a different address.

Fields

expected: Address

The expected signer (root account).

actual: Address

The actual signer recovered from the signature.

AccessKeyExpiryInPast

Access key expiry is in the past.

An access key cannot be authorized with an expiry timestamp that has already passed.

Fields

expiry: u64

The expiry timestamp from the KeyAuthorization.

current_timestamp: u64

The current block timestamp.

KeychainPrecompileError

AccountKeychain precompile error during key authorization.

This error occurs when the AccountKeychain precompile rejects the key authorization (e.g., key already exists, invalid parameters).

Fields

reason: String

The error message from the precompile.

KeychainUserAddressMismatch

Keychain user address does not match transaction caller.

For Keychain signatures, the user_address field must match the transaction caller.

Fields

user_address: Address

The user_address from the Keychain signature.

caller: Address

The transaction caller.

KeychainValidationFailed

Keychain validation failed.

The access key is not authorized in the AccountKeychain precompile for this user, or the key has expired, or spending limits are exceeded.

Fields

reason: String

The validation error details.

KeyAuthorizationChainIdMismatch

KeyAuthorization chain_id does not match the current chain.

Fields

expected: u64

The expected chain ID (current chain).

got: u64

The chain ID from the KeyAuthorization.

LegacyKeychainSignature

Legacy V1 keychain signature is no longer accepted (deprecated at T1C).

V1 keychain signatures do not bind the user address into the signature hash. Use V2 keychain signatures instead.

V2KeychainBeforeActivation

V2 keychain signature used before T1C activation.

V2 signatures (type 0x04) are only valid after the T1C hardfork activates. Rejecting them before activation prevents chain splits between upgraded and non-upgraded nodes.

TODO(tanishk): This variant can be removed after T1C activation on all networks.

KeychainOpInSubblockTransaction

Keychain operations are not supported in subblock transactions.

CollectFeePreTx(FeePaymentError)

Fee payment error.

CallsValidation(&'static str)

Tempo transaction validation error from validate_calls().

This wraps validation errors from the shared validate_calls function.

Trait Implementations

impl Clone for TempoInvalidTransaction

fn clone(&self) -> TempoInvalidTransaction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TempoInvalidTransaction

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

Formats the value using the given formatter.

impl Display for TempoInvalidTransaction

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

Formats the value using the given formatter.

impl Error for TempoInvalidTransaction

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<&'static str> for TempoInvalidTransaction

fn from(err: &'static str) -> Self

Converts to this type from the input type.

impl From<FeePaymentError> for TempoInvalidTransaction

fn from(source: FeePaymentError) -> Self

Converts to this type from the input type.

impl From<InvalidTransaction> for TempoInvalidTransaction

fn from(source: InvalidTransaction) -> Self

Converts to this type from the input type.

impl From<KeyAuthorizationChainIdError> for TempoInvalidTransaction

fn from(err: KeyAuthorizationChainIdError) -> Self

Converts to this type from the input type.

impl From<KeychainVersionError> for TempoInvalidTransaction

fn from(err: KeychainVersionError) -> Self

Converts to this type from the input type.

impl<DBError> From<TempoInvalidTransaction> for EVMError<DBError, TempoInvalidTransaction>

fn from(err: TempoInvalidTransaction) -> Self

Converts to this type from the input type.

impl Hash for TempoInvalidTransaction

fn hash<__H: Hasher>(&self, state: &mut __H)

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 InvalidTxError for TempoInvalidTransaction

fn is_nonce_too_low(&self) -> bool

Returns whether the error cause by transaction having a nonce lower than expected.

fn as_invalid_tx_err(&self) -> Option<&InvalidTransaction>

Returns the underlying [InvalidTransaction] if any.

fn is_gas_limit_too_high(&self) -> bool

Returns whether the error is due to the transaction gas limit being higher than allowed.

fn is_gas_limit_too_low(&self) -> bool

Returns whether the error is due to the transaction gas limit being lower than required.

impl PartialEq for TempoInvalidTransaction

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

impl StructuralPartialEq for TempoInvalidTransaction

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: 80 bytes

Size for each variant:

• EthInvalidTransaction: 64 bytes
• SystemTransactionMustBeCall: 0 bytes
• SystemTransactionFailed: 16 bytes
• InvalidFeePayerSignature: 0 bytes
• SelfSponsoredFeePayer: 0 bytes
• ValidAfter: 24 bytes
• ValidBefore: 24 bytes
• InvalidP256Signature: 0 bytes
• InvalidWebAuthnSignature: 32 bytes
• InsufficientGasForIntrinsicCost: 24 bytes
• NonceManagerError: 32 bytes
• ExpiringNonceMissingTxEnv: 0 bytes
• ExpiringNonceMissingValidBefore: 0 bytes
• ExpiringNonceNonceNotZero: 0 bytes
• SubblockTransactionMustHaveZeroFee: 0 bytes
• InvalidFeeToken: 28 bytes
• ValueTransferNotAllowed: 0 bytes
• ValueTransferNotAllowedInAATx: 0 bytes
• AccessKeyRecoveryFailed: 0 bytes
• AccessKeyCannotAuthorizeOtherKeys: 0 bytes
• KeyAuthorizationSignatureRecoveryFailed: 0 bytes
• KeyAuthorizationNotSignedByRoot: 48 bytes
• AccessKeyExpiryInPast: 24 bytes
• KeychainPrecompileError: 32 bytes
• KeychainUserAddressMismatch: 48 bytes
• KeychainValidationFailed: 32 bytes
• KeyAuthorizationChainIdMismatch: 24 bytes
• LegacyKeychainSignature: 0 bytes
• V2KeychainBeforeActivation: 0 bytes
• KeychainOpInSubblockTransaction: 0 bytes
• CollectFeePreTx: 72 bytes
• CallsValidation: 24 bytes