Struct TempoTransaction 

pub struct TempoTransaction {

    pub chain_id: ChainId,
    pub fee_token: Option<Address>,
    pub max_priority_fee_per_gas: u128,
    pub max_fee_per_gas: u128,
    pub gas_limit: u64,
    pub calls: Vec<Call>,
    pub access_list: AccessList,
    pub nonce_key: U256,
    pub nonce: u64,
    pub fee_payer_signature: Option<Signature>,
    pub valid_before: Option<u64>,
    pub valid_after: Option<u64>,
    pub key_authorization: Option<SignedKeyAuthorization>,
    pub tempo_authorization_list: Vec<TempoSignedAuthorization>,
}

Tempo transaction following the Tempo spec.

This transaction type supports:

• Multiple signature types (secp256k1, P256, WebAuthn)
• Parallelizable nonces via 2D nonce system (nonce_key + nonce)
• Gas sponsorship via fee payer
• Scheduled transactions (validBefore/validAfter)
• EIP-7702 authorization lists

Fields

chain_id: ChainId

EIP-155: Simple replay attack protection

fee_token: Option<Address>

Optional fee token preference (None means no preference)

max_priority_fee_per_gas: u128

Max Priority fee per gas (EIP-1559)

max_fee_per_gas: u128

Max fee per gas (EIP-1559)

gas_limit: u64

Gas limit

calls: Vec<Call>

Calls to be executed atomically

access_list: AccessList

Access list (EIP-2930)

nonce_key: U256

TT-specific fields Nonce key for 2D nonce system Key 0 is the protocol nonce, keys 1-N are user nonces for parallelization

nonce: u64

Current nonce value for the nonce key

fee_payer_signature: Option<Signature>

Optional features Optional fee payer signature for sponsored transactions (secp256k1 only)

valid_before: Option<u64>

Transaction can only be included in a block before this timestamp

valid_after: Option<u64>

Transaction can only be included in a block after this timestamp

key_authorization: Option<SignedKeyAuthorization>

Optional key authorization for provisioning a new access key

When present, this transaction will add the specified key to the AccountKeychain precompile, before verifying the transaction signature. The authorization must be signed with the root key, the tx can be signed by the Keychain signature.

tempo_authorization_list: Vec<TempoSignedAuthorization>

Authorization list (EIP-7702 style with Tempo signatures)

Implementations

impl TempoTransaction

pub const fn tx_type() -> u8

Get the transaction type

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

Validates the transaction according to the spec rules

pub fn size(&self) -> usize

Calculates a heuristic for the in-memory size of the transaction

pub fn into_signed(self, signature: TempoSignature) -> AASigned

Convert the transaction into a signed transaction

pub fn signature_hash(&self) -> B256

Calculate the signing hash for this transaction This is the hash that should be signed by the sender

pub fn fee_payer_signature_hash(&self, sender: Address) -> B256

Calculate the fee payer signature hash This hash is signed by the fee payer to sponsor the transaction

fn rlp_encoded_fields_length( &self, signature_length: impl FnOnce(&Option<Signature>) -> usize, skip_fee_token: bool, ) -> usize

Outputs the length of the transaction’s fields, without a RLP header.

This is the internal helper that takes closures for flexible encoding.

fn rlp_encode_fields( &self, out: &mut dyn BufMut, encode_signature: impl FnOnce(&Option<Signature>, &mut dyn BufMut), skip_fee_token: bool, )

pub(crate) fn rlp_encoded_fields_length_default(&self) -> usize

Public version for normal RLP encoding

pub(crate) fn rlp_encode_fields_default(&self, out: &mut dyn BufMut)

Public version for normal RLP encoding

pub(crate) fn rlp_decode_fields(buf: &mut &[u8]) -> Result<Self>

Decodes the inner TempoTransaction fields from RLP bytes

pub fn has_sub_block_nonce_key_prefix(&self) -> bool

Returns true if the nonce key of this transaction has the TEMPO_SUBBLOCK_NONCE_KEY_PREFIX.

pub fn subblock_proposer(&self) -> Option<PartialValidatorKey>

Returns the proposer of the subblock if this is a subblock transaction.

Trait Implementations

impl<'a> Arbitrary<'a> for TempoTransaction

Available on crate features arbitrary only.

fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

impl Clone for TempoTransaction

fn clone(&self) -> TempoTransaction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Compact for TempoTransaction

Available on crate feature reth-codec only.

fn to_compact<B>(&self, buf: &mut B) -> usize

where B: BufMut + AsMut<[u8]>,

Takes a buffer which can be written to. Ideally, it returns the length written to.

fn from_compact(buf: &[u8], len: usize) -> (Self, &[u8])

Takes a buffer which can be read from. Returns the object and buf with its internal cursor advanced (eg..advance(len)).

fn specialized_to_compact<B>(&self, buf: &mut B) -> usize

where B: BufMut + AsMut<[u8]>,

“Optional”: If there’s no good reason to use it, don’t.

fn specialized_from_compact(buf: &[u8], len: usize) -> (Self, &[u8])

“Optional”: If there’s no good reason to use it, don’t.

impl Debug for TempoTransaction

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

Formats the value using the given formatter.

impl Decodable for TempoTransaction

fn decode(buf: &mut &[u8]) -> Result<Self>

Decodes the blob into the appropriate type. buf must be advanced past the decoded object.

impl Default for TempoTransaction

fn default() -> TempoTransaction

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for TempoTransaction

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encodable for TempoTransaction

fn encode(&self, out: &mut dyn BufMut)

Encodes the type into the out buffer.

fn length(&self) -> usize

Returns the length of the encoding of this type in bytes.

impl From<TempoTransaction> for TempoTypedTransaction

fn from(value: TempoTransaction) -> Self

Converts to this type from the input type.

impl Hash for TempoTransaction

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 InMemorySize for TempoTransaction

fn size(&self) -> usize

Returns a heuristic for the in-memory size of a struct.

impl PartialEq for TempoTransaction

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl SignableTransaction<Signature> for TempoTransaction

fn set_chain_id(&mut self, chain_id: ChainId)

Sets chain_id.

fn encode_for_signing(&self, out: &mut dyn BufMut)

RLP-encodes the transaction for signing.

fn payload_len_for_signature(&self) -> usize

Outputs the length of the signature RLP encoding for the transaction.

fn set_chain_id_checked(&mut self, chain_id: u64) -> bool

Set chain_id if it is not already set. Checks that the provided chain_id matches the existing chain_id if it is already set, returning false if they do not match.

fn encoded_for_signing(&self) -> Vec<u8>

RLP-encodes the transaction for signing it. Used to calculate signature_hash.

fn signature_hash(&self) -> FixedBytes<32>

Calculate the signing hash for the transaction.

fn into_signed(self, signature: Signature) -> Signed<Self, Signature>

where Self: Sized,

Convert to a [Signed] object.

impl Transaction for TempoTransaction

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

Get chain_id.

fn nonce(&self) -> u64

Get nonce.

fn gas_limit(&self) -> u64

Get gas_limit.

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

Get gas_price.

fn max_fee_per_gas(&self) -> u128

For dynamic fee transactions returns the maximum fee per gas the caller is willing to pay.

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

For dynamic fee transactions returns the Priority fee the caller is paying to the block author.

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

Max fee per blob gas for EIP-4844 transaction.

fn priority_fee_or_price(&self) -> u128

Return the max priority fee per gas if the transaction is a dynamic fee transaction, and otherwise return the gas price.

fn effective_gas_price(&self, base_fee: Option<u64>) -> u128

Returns the effective gas price for the given base fee.

fn is_dynamic_fee(&self) -> bool

Returns true if the transaction supports dynamic fees.

fn kind(&self) -> TxKind

Returns the transaction kind.

fn is_create(&self) -> bool

Returns true if the transaction is a contract creation. We don’t provide a default implementation via kind as it copies the 21-byte [TxKind] for this simple check. A proper implementation shouldn’t allocate.

fn value(&self) -> U256

Get value.

fn input(&self) -> &Bytes

Get data.

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

Returns the EIP-2930 access_list for the particular transaction type. Returns None for older transaction types.

fn blob_versioned_hashes(&self) -> Option<&[B256]>

Blob versioned hashes for eip4844 transaction. For previous transaction types this is None.

fn authorization_list(&self) -> Option<&[SignedAuthorization]>

Returns the [SignedAuthorization] list of the transaction.

fn effective_tip_per_gas(&self, base_fee: u64) -> Option<u128>

Returns the effective tip for this transaction.

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

Get the transaction’s address of the contract that will be called, or the address that will receive the transfer.

fn function_selector(&self) -> Option<&FixedBytes<4>>

Returns the first 4bytes of the calldata for a function call.

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

Returns the number of blobs of this transaction.

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

Returns the total gas for all blobs in this transaction.

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

Returns the number of blobs of [SignedAuthorization] in this transactions

impl Typed2718 for TempoTransaction

fn ty(&self) -> u8

Returns the EIP-2718 type flag.

fn is_type(&self, ty: u8) -> bool

Returns true if the type matches the given type.

fn is_legacy(&self) -> bool

Returns true if the type is a legacy transaction.

fn is_eip2930(&self) -> bool

Returns true if the type is an EIP-2930 transaction.

fn is_eip1559(&self) -> bool

Returns true if the type is an EIP-1559 transaction.

fn is_eip4844(&self) -> bool

Returns true if the type is an EIP-4844 transaction.

fn is_eip7702(&self) -> bool

Returns true if the type is an EIP-7702 transaction.

impl Eq for TempoTransaction

impl RlpBincode for TempoTransaction

Available on crate feature serde-bincode-compat only.

impl StructuralPartialEq for TempoTransaction

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