Struct TempoTransactionRequest 

pub struct TempoTransactionRequest {
    pub inner: TransactionRequest,
    pub fee_token: Option<Address>,
    pub nonce_key: Option<U256>,
    pub calls: Vec<Call>,
    pub key_type: Option<SignatureType>,
    pub key_data: Option<Bytes>,
    pub key_id: Option<Address>,
    pub tempo_authorization_list: Vec<TempoSignedAuthorization>,
    pub key_authorization: Option<SignedKeyAuthorization>,
    pub valid_before: Option<u64>,
    pub valid_after: Option<u64>,
    pub fee_payer_signature: Option<Signature>,
}

An Ethereum [TransactionRequest] with an optional fee_token.

Fields

inner: TransactionRequest

Inner [TransactionRequest]

fee_token: Option<Address>

Optional fee token preference

nonce_key: Option<U256>

Optional nonce key for a 2D TempoTransaction.

calls: Vec<Call>

Optional calls array, for Tempo transactions.

key_type: Option<SignatureType>

Optional key type for gas estimation of Tempo transactions. Specifies the signature verification algorithm to calculate accurate gas costs.

key_data: Option<Bytes>

Optional key-specific data for gas estimation (e.g., webauthn authenticator data). Required when key_type is WebAuthn to calculate calldata gas costs.

key_id: Option<Address>

Optional access key ID for gas estimation. When provided, indicates the transaction uses a Keychain (access key) signature. This enables accurate gas estimation for:

• Keychain signature validation overhead (+3,000 gas)
• Spending limits enforcement during execution

tempo_authorization_list: Vec<TempoSignedAuthorization>

Optional authorization list for Tempo transactions (supports multiple signature types)

key_authorization: Option<SignedKeyAuthorization>

Key authorization for provisioning an access key (for gas estimation). Provide a signed KeyAuthorization when the transaction provisions an access key.

valid_before: Option<u64>

Transaction valid before timestamp in seconds (for expiring nonces, TIP-1009). Transaction can only be included in a block before this timestamp.

valid_after: Option<u64>

Transaction valid after timestamp in seconds (for expiring nonces, TIP-1009). Transaction can only be included in a block after this timestamp.

fee_payer_signature: Option<Signature>

Fee payer signature for sponsored transactions. The sponsor signs fee_payer_signature_hash(sender) to commit to paying gas.

Implementations

impl TempoTransactionRequest

fn can_build_aa(&self) -> bool

fn complete_aa(&self) -> Result<(), Vec<&'static str>>

impl TempoTransactionRequest

pub fn set_fee_token(&mut self, fee_token: Address)

Set the fee token for the TempoTransaction transaction.

pub fn with_fee_token(self, fee_token: Address) -> Self

Builder-pattern method for setting the fee token.

pub fn set_nonce_key(&mut self, nonce_key: U256)

Set the 2D nonce key for the TempoTransaction transaction.

pub fn with_nonce_key(self, nonce_key: U256) -> Self

Builder-pattern method for setting a 2D nonce key for a TempoTransaction.

pub fn set_valid_before(&mut self, valid_before: u64)

Set the valid_before timestamp for expiring nonces (TIP-1009).

pub fn with_valid_before(self, valid_before: u64) -> Self

Builder-pattern method for setting valid_before timestamp.

pub fn set_valid_after(&mut self, valid_after: u64)

Set the valid_after timestamp for expiring nonces (TIP-1009).

pub fn with_valid_after(self, valid_after: u64) -> Self

Builder-pattern method for setting valid_after timestamp.

pub fn set_fee_payer_signature(&mut self, signature: Signature)

Set the fee payer signature for sponsored transactions.

pub fn with_fee_payer_signature(self, signature: Signature) -> Self

Builder-pattern method for setting fee payer signature.

pub fn build_aa(self) -> Result<TempoTransaction, ValueError<Self>>

Attempts to build a TempoTransaction with the configured fields.

Methods from Deref<Target = TransactionRequest>

pub fn normalize_input(&mut self)

Ensures that if either input or data is set, the input field contains the value.

This removes data the data field.

pub fn normalize_data(&mut self)

Ensures that if either data or input is set, the data field contains the value.

This removes input the data field.

pub fn set_input_and_data(&mut self)

If only one field is set, this also sets the other field by with that value.

This is a noop if both fields are already set.

pub fn fee_cap(&self) -> Option<u128>

Returns the configured fee cap, if any.

The returns gas_price (legacy) if set or max_fee_per_gas (EIP1559)

pub fn has_eip4844_fields(&self) -> bool

Returns true if any of the EIP-4844 fields are set:

• blob sidecar
• blob versioned hashes
• max fee per blob gas

pub fn has_eip4844_blob_data(&self) -> bool

Returns true if the EIP-4844 blob data fields are set (sidecar or versioned hashes).

This differs from [Self::has_eip4844_fields] in that it does not consider max_fee_per_blob_gas alone as sufficient to indicate a blob transaction. This matches go-ethereum behavior where only the presence of blob_versioned_hashes determines if a transaction is a blob transaction.

Use this method when determining the transaction type for building/simulation, as just having a blob fee cap without actual blob data should not force the transaction to be EIP-4844.

pub fn has_eip1559_fields(&self) -> bool

Returns true if any of the EIP-1559 fee fields are set:

• max fee per gas
• max priority fee per gas

pub fn populate_blob_hashes(&mut self)

Populate the blob_versioned_hashes key, if a sidecar exists. No effect otherwise.

pub fn get_invalid_common_fields(&self) -> Vec<&'static str>

Gets invalid fields for all transaction types

pub fn get_invalid_1559_fields(&self) -> Vec<&'static str>

Gets invalid fields for EIP-1559 transaction type

pub fn trim_conflicting_keys(&mut self)

Trim field conflicts, based on the preferred type

This is used to ensure that the request will not be rejected by the server due to conflicting keys, and should only be called before submission via rpc.

pub fn minimal_tx_type(&self) -> TxType

Returns the minimal transaction type this request can be converted into based on the fields that are set.

Compared to [Self::preferred_type] which is intended for building and eventually signing transactions and which prefers [TxType::Eip1559] if no conflicting fields are set, this function is intended for deriving the minimal transaction type (legacy).

[Self::minimal_tx_type] is mostly relevant for the server-side, for example executing eth_calls against historic state (pre [TxType::Eip1559]) and is used to configure the EVM’s transaction environment with the minimal settings. Whereas [Self::preferred_type] is recommend for using client-side (filling a [TransactionRequest] and signing the transaction [TransactionRequest::build_typed_tx]).

The type is determined in the following order:

• EIP-7702 if authorization_list is set
• EIP-4844 if blob data fields are set (sidecar or blob hashes)
• EIP-1559 if any EIP-1559 fee fields are set (max fee per gas, max priority fee)
• EIP-2930 if access_list is set
• Legacy otherwise

Note: max_fee_per_blob_gas alone does NOT indicate EIP-4844. This matches go-ethereum behavior where only the presence of blob_versioned_hashes or sidecar determines if a transaction is a blob transaction.

Examples

use alloy_consensus::TxType;
use alloy_eips::eip2930::AccessList;
use alloy_rpc_types_eth::TransactionRequest;

// EIP-7702 (highest priority)
let mut request = TransactionRequest::default();
request.authorization_list = Some(vec![]);
assert_eq!(request.minimal_tx_type(), TxType::Eip7702);

// max_fee_per_blob_gas alone does NOT make it EIP-4844
let request = TransactionRequest::default().max_fee_per_blob_gas(1000000000);
assert_eq!(request.minimal_tx_type(), TxType::Legacy); // NOT Eip4844!

// EIP-4844 with blob_versioned_hashes
let request = TransactionRequest { blob_versioned_hashes: Some(vec![]), ..Default::default() };
assert_eq!(request.minimal_tx_type(), TxType::Eip4844);

// EIP-1559 with max_fee_per_gas
let request = TransactionRequest::default().max_fee_per_gas(2000000000);
assert_eq!(request.minimal_tx_type(), TxType::Eip1559);

// EIP-1559 with max_priority_fee_per_gas
let request = TransactionRequest::default().max_priority_fee_per_gas(1000000000);
assert_eq!(request.minimal_tx_type(), TxType::Eip1559);

// EIP-2930 with access_list
let request = TransactionRequest::default().access_list(AccessList::default());
assert_eq!(request.minimal_tx_type(), TxType::Eip2930);

// Legacy (default fallback)
let request = TransactionRequest::default();
assert_eq!(request.minimal_tx_type(), TxType::Legacy);

// Priority example: EIP-4844 (with blob hashes) overrides EIP-1559
let request = TransactionRequest {
    max_fee_per_gas: Some(2000000000),
    blob_versioned_hashes: Some(vec![]),
    ..Default::default()
};
assert_eq!(request.minimal_tx_type(), TxType::Eip4844);

pub fn preferred_type(&self) -> TxType

Check this builder’s preferred type, based on the fields that are set.

This function is intended for building and eventually signing transactions client-side. Unlike [Self::minimal_tx_type] which returns the minimal required type, this function prefers [TxType::Eip1559] when no conflicting fields are set.

Types are preferred as follows:

• EIP-7702 if authorization_list is set
• EIP-4844 if sidecar or blob_versioned_hashes is set
• EIP-2930 if access_list is set
• Legacy if gas_price is set and access_list is unset
• EIP-1559 in all other cases

Note: max_fee_per_blob_gas alone does NOT indicate EIP-4844. This matches go-ethereum behavior where only the presence of blob_versioned_hashes or sidecar determines if a transaction is a blob transaction.

Examples

use alloy_consensus::TxType;
use alloy_eips::eip2930::AccessList;
use alloy_rpc_types_eth::TransactionRequest;

// EIP-7702 (highest priority)
let mut request = TransactionRequest::default();
request.authorization_list = Some(vec![]);
assert_eq!(request.preferred_type(), TxType::Eip7702);

// EIP-4844 requires blob_versioned_hashes or sidecar, not just max_fee_per_blob_gas
let request = TransactionRequest::default().max_fee_per_blob_gas(1000000000);
assert_eq!(request.preferred_type(), TxType::Eip1559); // NOT Eip4844!

// EIP-4844 with blob_versioned_hashes
let request = TransactionRequest { blob_versioned_hashes: Some(vec![]), ..Default::default() };
assert_eq!(request.preferred_type(), TxType::Eip4844);

// EIP-2930 with both access_list and gas_price
let request =
    TransactionRequest::default().access_list(AccessList::default()).gas_price(20000000000);
assert_eq!(request.preferred_type(), TxType::Eip2930);

// Legacy with only gas_price (no access_list)
let request = TransactionRequest::default().gas_price(20000000000);
assert_eq!(request.preferred_type(), TxType::Legacy);

// EIP-1559 as default for modern transactions
let request = TransactionRequest::default();
assert_eq!(request.preferred_type(), TxType::Eip1559);

// EIP-1559 even with access_list but no gas_price
let request = TransactionRequest::default().access_list(AccessList::default());
assert_eq!(request.preferred_type(), TxType::Eip1559);

Key Differences from [Self::minimal_tx_type]

use alloy_consensus::TxType;
use alloy_eips::eip2930::AccessList;
use alloy_rpc_types_eth::TransactionRequest;

// Empty request - preferred_type prefers EIP-1559, minimal_tx_type falls back to Legacy
let request = TransactionRequest::default();
assert_eq!(request.preferred_type(), TxType::Eip1559); // Preferred for new txs
assert_eq!(request.minimal_tx_type(), TxType::Legacy); // Minimal requirement

// Access list only - different behavior
let request = TransactionRequest::default().access_list(AccessList::default());
assert_eq!(request.preferred_type(), TxType::Eip1559); // Still prefers EIP-1559
assert_eq!(request.minimal_tx_type(), TxType::Eip2930); // Minimal is EIP-2930

// Gas price only - both agree on Legacy
let request = TransactionRequest::default().gas_price(20000000000);
assert_eq!(request.preferred_type(), TxType::Legacy);
assert_eq!(request.minimal_tx_type(), TxType::Legacy);

pub fn missing_keys(&self) -> Result<TxType, (TxType, Vec<&'static str>)>

Check if all necessary keys are present to build a transaction.

Returns

• Ok(type) if all necessary keys are present to build the preferred type.
• Err((type, missing)) if some keys are missing to build the preferred type.

pub fn complete_4844(&self) -> Result<(), Vec<&'static str>>

Check if all necessary keys are present to build a 4844 transaction, returning a list of keys that are missing.

NOTE: sidecar must be present, even if blob_versioned_hashes is set.

pub fn complete_1559(&self) -> Result<(), Vec<&'static str>>

Check if all necessary keys are present to build a 1559 transaction, returning a list of keys that are missing.

pub fn complete_2930(&self) -> Result<(), Vec<&'static str>>

Check if all necessary keys are present to build a 2930 transaction, returning a list of keys that are missing.

pub fn complete_7702(&self) -> Result<(), Vec<&'static str>>

Check if all necessary keys are present to build a 7702 transaction, returning a list of keys that are missing.

pub fn complete_legacy(&self) -> Result<(), Vec<&'static str>>

Check if all necessary keys are present to build a legacy transaction, returning a list of keys that are missing.

pub fn buildable_type(&self) -> Option<TxType>

Return the tx type this request can be built as. Computed by checking the preferred type, and then checking for completeness.

Trait Implementations

impl AsMut<TransactionRequest> for TempoTransactionRequest

fn as_mut(&mut self) -> &mut TransactionRequest

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsRef<TransactionRequest> for TempoTransactionRequest

fn as_ref(&self) -> &TransactionRequest

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for TempoTransactionRequest

fn clone(&self) -> TempoTransactionRequest

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TempoTransactionRequest

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

Formats the value using the given formatter.

impl Default for TempoTransactionRequest

fn default() -> TempoTransactionRequest

Returns the “default value” for a type.

impl Deref for TempoTransactionRequest

type Target = TransactionRequest

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for TempoTransactionRequest

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'de> Deserialize<'de> for TempoTransactionRequest

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<AASigned> for TempoTransactionRequest

fn from(value: AASigned) -> Self

Converts to this type from the input type.

impl<T: TransactionTrait + FeeToken> From<Signed<T>> for TempoTransactionRequest

fn from(value: Signed<T>) -> Self

Converts to this type from the input type.

impl From<TempoTransaction> for TempoTransactionRequest

fn from(tx: TempoTransaction) -> Self

Converts to this type from the input type.

impl From<TempoTransactionRequest> for TransactionRequest

fn from(value: TempoTransactionRequest) -> Self

Converts to this type from the input type.

impl From<TempoTxEnvelope> for TempoTransactionRequest

fn from(value: TempoTxEnvelope) -> Self

Converts to this type from the input type.

impl From<TempoTypedTransaction> for TempoTransactionRequest

fn from(value: TempoTypedTransaction) -> Self

Converts to this type from the input type.

impl From<TransactionRequest> for TempoTransactionRequest

fn from(value: TransactionRequest) -> Self

Converts to this type from the input type.

impl Hash for TempoTransactionRequest

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

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl SignableTxRequest<TempoTxEnvelope> for TempoTransactionRequest

Available on crate feature tempo-compat only.

async fn try_build_and_sign( self, signer: impl TxSigner<Signature> + Send, ) -> Result<TempoTxEnvelope, SignTxRequestError>

Attempts to build a transaction request and sign it with the given signer.

impl TransactionBuilder<TempoNetwork> for TempoTransactionRequest

fn chain_id(&self) -> Option<ChainId>

Get the chain ID for the transaction.

fn set_chain_id(&mut self, chain_id: ChainId)

Set the chain ID for the transaction.

fn nonce(&self) -> Option<u64>

Get the nonce for the transaction.

fn set_nonce(&mut self, nonce: u64)

Set the nonce for the transaction.

fn take_nonce(&mut self) -> Option<u64>

Takes the nonce out of the transaction, clearing it.

fn input(&self) -> Option<&Bytes>

Get the input data for the transaction.

fn set_input<T: Into<Bytes>>(&mut self, input: T)

Set the input data for the transaction.

fn from(&self) -> Option<Address>

Get the sender for the transaction.

fn set_from(&mut self, from: Address)

Set the sender for the transaction.

fn kind(&self) -> Option<TxKind>

Get the kind of transaction.

fn clear_kind(&mut self)

Clear the kind of transaction.

fn set_kind(&mut self, kind: TxKind)

Set the kind of transaction.

fn value(&self) -> Option<U256>

Get the value for the transaction.

fn set_value(&mut self, value: U256)

Set the value for the transaction.

fn gas_price(&self) -> Option<u128>

Get the legacy gas price for the transaction.

fn set_gas_price(&mut self, gas_price: u128)

Set the legacy gas price for the transaction.

fn max_fee_per_gas(&self) -> Option<u128>

Get the max fee per gas for the transaction.

fn set_max_fee_per_gas(&mut self, max_fee_per_gas: u128)

Set the max fee per gas for the transaction.

fn max_priority_fee_per_gas(&self) -> Option<u128>

Get the max priority fee per gas for the transaction.

fn set_max_priority_fee_per_gas(&mut self, max_priority_fee_per_gas: u128)

Set the max priority fee per gas for the transaction.

fn gas_limit(&self) -> Option<u64>

Get the gas limit for the transaction.

fn set_gas_limit(&mut self, gas_limit: u64)

Set the gas limit for the transaction.

fn access_list(&self) -> Option<&AccessList>

Get the EIP-2930 access list for the transaction.

fn set_access_list(&mut self, access_list: AccessList)

Sets the EIP-2930 access list.

fn complete_type(&self, ty: TempoTxType) -> Result<(), Vec<&'static str>>

Check if all necessary keys are present to build the specified type, returning a list of missing keys.

fn can_submit(&self) -> bool

True if the builder contains all necessary information to be submitted to the eth_sendTransaction endpoint.

fn can_build(&self) -> bool

True if the builder contains all necessary information to be built into a valid transaction.

fn output_tx_type(&self) -> TempoTxType

Returns the transaction type that this builder will attempt to build. This does not imply that the builder is ready to build.

fn output_tx_type_checked(&self) -> Option<TempoTxType>

Returns the transaction type that this builder will build. None if the builder is not ready to build.

fn prep_for_submission(&mut self)

Trim any conflicting keys and populate any computed fields (like blob hashes).

fn build_unsigned(self) -> BuildResult<TempoTypedTransaction, TempoNetwork>

Build an unsigned, but typed, transaction.

async fn build<W: NetworkWallet<TempoNetwork>>( self, wallet: &W, ) -> Result<TempoTxEnvelope, TransactionBuilderError<TempoNetwork>>

Build a signed transaction.

fn with_chain_id(self, chain_id: u64) -> Self

Builder-pattern method for setting the chain ID.

fn with_nonce(self, nonce: u64) -> Self

Builder-pattern method for setting the nonce.

fn without_nonce(self) -> Self

Takes the nonce out of the transaction, clearing it.

fn with_input<T>(self, input: T) -> Self

where T: Into<Bytes>,

Builder-pattern method for setting the input data.

fn set_input_kind<T>(&mut self, input: T, _: TransactionInputKind)

where T: Into<Bytes>,

Set the input data for the transaction, respecting the input kind

fn with_input_kind<T>(self, input: T, kind: TransactionInputKind) -> Self

where T: Into<Bytes>,

Builder-pattern method for setting the input data, respecting the input kind

fn with_from(self, from: Address) -> Self

Builder-pattern method for setting the sender.

fn with_kind(self, kind: TxKind) -> Self

Builder-pattern method for setting the kind of transaction.

fn to(&self) -> Option<Address>

Get the recipient for the transaction.

fn set_to(&mut self, to: Address)

Set the recipient for the transaction.

fn with_to(self, to: Address) -> Self

Builder-pattern method for setting the recipient.

fn set_create(&mut self)

Set the to field to a create call.

fn into_create(self) -> Self

Set the to field to a create call.

fn set_deploy_code<T>(&mut self, code: T)

where T: Into<Bytes>,

Deploy the code by making a create call with data. This will set the to field to [TxKind::Create].

fn with_deploy_code<T>(self, code: T) -> Self

where T: Into<Bytes>,

Deploy the code by making a create call with data. This will set the to field to [TxKind::Create].

fn set_call<T>(&mut self, t: &T)

where T: SolCall,

Set the data field to a contract call. This will clear the to field if it is set to [TxKind::Create].

fn with_call<T>(self, t: &T) -> Self

where T: SolCall,

Make a contract call with data.

fn calculate_create_address(&self) -> Option<Address>

Calculates the address that will be created by the transaction, if any.

fn with_value(self, value: Uint<256, 4>) -> Self

Builder-pattern method for setting the value.

fn with_gas_price(self, gas_price: u128) -> Self

Builder-pattern method for setting the legacy gas price.

fn with_max_fee_per_gas(self, max_fee_per_gas: u128) -> Self

Builder-pattern method for setting max fee per gas .

fn with_max_priority_fee_per_gas(self, max_priority_fee_per_gas: u128) -> Self

Builder-pattern method for setting max priority fee per gas.

fn with_gas_limit(self, gas_limit: u64) -> Self

Builder-pattern method for setting the gas limit.

fn with_access_list(self, access_list: AccessList) -> Self

Builder-pattern method for setting the access list.

fn complete_preferred(&self) -> Result<(), Vec<&'static str>>

Check if all necessary keys are present to build the currently-preferred transaction type, returning a list of missing keys.

fn assert_preferred(&self, ty: <N as Network>::TxType)

Assert that the builder prefers a certain transaction type. This does not indicate that the builder is ready to build. This function uses a dbg_assert_eq! to check the builder status, and will have no affect in release builds.

fn assert_preferred_chained(self, ty: <N as Network>::TxType) -> Self

Assert that the builder prefers a certain transaction type. This does not indicate that the builder is ready to build. This function uses a dbg_assert_eq! to check the builder status, and will have no affect in release builds.

fn apply<F>(self, f: F) -> Self

where F: FnOnce(Self) -> Self,

Apply a function to the builder, returning the modified builder.

fn try_apply<F, E>(self, f: F) -> Result<Self, E>

where F: FnOnce(Self) -> Result<Self, E>,

Apply a fallible function to the builder, returning the modified builder or an error.

impl TryIntoSimTx<TempoTxEnvelope> for TempoTransactionRequest

Available on crate feature tempo-compat only.

fn try_into_sim_tx(self) -> Result<TempoTxEnvelope, ValueError<Self>>

Performs the conversion.

impl TryIntoTxEnv<TempoTxEnv, TempoHardfork, TempoBlockEnv> for TempoTransactionRequest

Available on crate feature tempo-compat only.

type Err = EthApiError

An associated error that can occur during the conversion.

fn try_into_tx_env( self, evm_env: &EvmEnv<TempoHardfork, TempoBlockEnv>, ) -> Result<TempoTxEnv, Self::Err>

Performs the conversion.

impl Eq for TempoTransactionRequest

impl StructuralPartialEq for TempoTransactionRequest

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