Struct AASigned 

pub struct AASigned {
    tx: TempoTransaction,
    signature: TempoSignature,
    hash: OnceLock<FixedBytes<32>>,
}

A transaction with an AA signature and hash seal.

This wraps a TempoTransaction transaction with its multi-signature-type signature (secp256k1, P256, Webauthn, Keychain) and provides cached hashes.

Fields

tx: TempoTransaction

signature: TempoSignature

hash: OnceLock<FixedBytes<32>>

Implementations

impl AASigned

pub fn new_unchecked( tx: TempoTransaction, signature: TempoSignature, hash: FixedBytes<32>, ) -> AASigned

Instantiate from a transaction and signature with a known hash. Does not verify the signature.

pub const fn new_unhashed( tx: TempoTransaction, signature: TempoSignature, ) -> AASigned

Instantiate from a transaction and signature without computing the hash. Does not verify the signature.

pub const fn tx(&self) -> &TempoTransaction

Returns a reference to the transaction.

pub const fn tx_mut(&mut self) -> &mut TempoTransaction

Returns a mutable reference to the transaction.

pub const fn signature(&self) -> &TempoSignature

Returns a reference to the signature.

pub fn strip_signature(self) -> TempoTransaction

Returns the transaction without signature.

pub fn hash(&self) -> &FixedBytes<32>

Returns a reference to the transaction hash, computing it if needed.

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

Calculate the signing hash for the transaction.

pub fn expiring_nonce_hash(&self, sender: Address) -> FixedBytes<32>

Calculate the expiring nonce dedup hash for replay protection.

This hash is keccak256(encode_for_signing || sender). It is:

• Invariant to fee payer changes: the fee payer signature and fee token are excluded (since encode_for_signing doesn’t commit to them when a fee payer is present).
• Unique per sender: different signers produce different recovered addresses, so the hash differs even for identical transaction payloads.

This prevents a replay attack where two different fee payers sign the same sender-signed transaction, producing different tx_hash values that would bypass tx_hash-based replay protection.

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

Encode the transaction fields and signature as RLP list (without type byte)

pub fn into_parts(self) -> (TempoTransaction, TempoSignature, FixedBytes<32>)

Splits the transaction into parts.

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

EIP-2718 encode the signed transaction.

pub fn rlp_decode(buf: &mut &[u8]) -> Result<AASigned, Error>

Decode the RLP fields (without type byte).

Trait Implementations

impl<'a> Arbitrary<'a> for AASigned

Available on crate features arbitrary only.

fn arbitrary(u: &mut Unstructured<'a>) -> Result<AASigned, Error>

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 AASigned

fn clone(&self) -> AASigned

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AASigned

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

Formats the value using the given formatter.

impl Decodable2718 for AASigned

fn typed_decode(ty: u8, buf: &mut &[u8]) -> Result<AASigned, Eip2718Error>

Decode the appropriate variant, based on the type flag.

fn fallback_decode(_: &mut &[u8]) -> Result<AASigned, Eip2718Error>

Decode the default variant.

fn extract_type_byte(buf: &mut &[u8]) -> Option<u8>

Extract the type byte from the buffer, if any. The type byte is the first byte, provided that first byte is 0x7f or lower.

fn decode_2718(buf: &mut &[u8]) -> Result<Self, Eip2718Error>

Decode the transaction according to EIP-2718 rules. First a 1-byte type flag in the range 0x0-0x7f, then the body of the transaction.

fn decode_2718_exact(bytes: &[u8]) -> Result<Self, Eip2718Error>

Decode a transaction according to EIP-2718, ensuring no trailing bytes.

fn network_decode(buf: &mut &[u8]) -> Result<Self, Eip2718Error>

Decode an EIP-2718 transaction in the network format. The network format is used ONLY by the Ethereum p2p protocol. Do not call this method unless you are building a p2p protocol client.

impl<'de> Deserialize<'de> for AASigned

fn deserialize<D>( deserializer: D, ) -> Result<AASigned, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encodable2718 for AASigned

fn encode_2718_len(&self) -> usize

The length of the 2718 encoded envelope. This is the length of the type flag + the length of the inner encoding.

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

Encode the transaction according to EIP-2718 rules. First a 1-byte type flag in the range 0x0-0x7f, then the body of the transaction.

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

Compute the hash as committed to in the MPT trie. This hash is used ONLY by the Ethereum merkle-patricia trie and associated proofs. Do not call this method unless you are building a full or light client.

fn type_flag(&self) -> Option<u8>

Return the type flag (if any).

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

Encode the transaction according to [EIP-2718] rules. First a 1-byte type flag in the range 0x0-0x7f, then the body of the transaction.

fn seal(self) -> Sealed<Self>

Seal the encodable, by encoding and hashing it.

fn into_encoded(self) -> WithEncoded<Self>

A convenience function that encodes the value in the 2718 format and wraps it in a [WithEncoded] wrapper.

fn network_len(&self) -> usize

The length of the 2718 encoded envelope in network format. This is the length of the header + the length of the type flag and inner encoding.

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

Encode in the network format. The network format is used ONLY by the Ethereum p2p protocol. Do not call this method unless you are building a p2p protocol client.

impl From<AASigned> for TempoTransactionRequest

fn from(value: AASigned) -> Self

Converts to this type from the input type.

impl From<AASigned> for TempoTxEnvelope

fn from(value: AASigned) -> TempoTxEnvelope

Converts to this type from the input type.

impl Hash for AASigned

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

Available on crate feature reth only.

fn size(&self) -> usize

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

impl PartialEq for AASigned

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

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 SignerRecoverable for AASigned

fn recover_signer(&self) -> Result<Address, RecoveryError>

Recover signer from signature and hash.

fn recover_signer_unchecked(&self) -> Result<Address, RecoveryError>

Recover signer from signature and hash without ensuring that the signature has a low s value.

fn recover_with_buf(&self, buf: &mut Vec<u8>) -> Result<Address, RecoveryError>

Same as [SignerRecoverable::recover_signer] but receives a buffer to operate on for encoding. This is useful during batch recovery of transactions to avoid allocating a new buffer for each transaction.

fn recover_unchecked_with_buf( &self, buf: &mut Vec<u8>, ) -> Result<Address, RecoveryError>

Same as [SignerRecoverable::recover_signer_unchecked] but receives a buffer to operate on for encoding. This is useful during batch recovery of historical transactions to avoid allocating a new buffer for each transaction.

fn try_into_recovered(self) -> Result<Recovered<Self>, RecoveryError>

where Self: Sized,

Recover the signer via [SignerRecoverable::recover_signer] and returns a Recovered<Self>

fn try_into_recovered_unchecked(self) -> Result<Recovered<Self>, RecoveryError>

where Self: Sized,

Recover the signer via [SignerRecoverable::recover_signer_unchecked] and returns a Recovered<&Self>

fn try_into_recovered_with_buf( self, buf: &mut Vec<u8>, ) -> Result<Recovered<Self>, RecoveryError>

where Self: Sized,

Same as [SignerRecoverable::try_into_recovered] but receives a buffer to operate on for encoding. This is useful during batch recovery of transactions to avoid allocating a new buffer for each transaction.

fn try_into_recovered_unchecked_with_buf( self, buf: &mut Vec<u8>, ) -> Result<Recovered<Self>, RecoveryError>

where Self: Sized,

Same as [SignerRecoverable::try_into_recovered_unchecked] but receives a buffer to operate on for encoding. This is useful during batch recovery of historical transactions to avoid allocating a new buffer for each transaction.

fn try_to_recovered_ref(&self) -> Result<Recovered<&Self>, RecoveryError>

Recover the signer via [SignerRecoverable::recover_signer] and returns a Recovered<&Self>

fn try_to_recovered_ref_with_buf( &self, buf: &mut Vec<u8>, ) -> Result<Recovered<&Self>, RecoveryError>

Same as [SignerRecoverable::try_to_recovered_ref] but receives a buffer to operate on for encoding. This is useful during batch recovery of transactions to avoid allocating a new buffer for each transaction.

fn try_to_recovered_ref_unchecked( &self, ) -> Result<Recovered<&Self>, RecoveryError>

Recover the signer via [SignerRecoverable::recover_signer_unchecked] and returns a Recovered<&Self>

fn try_to_recovered_ref_unchecked_with_buf( &self, buf: &mut Vec<u8>, ) -> Result<Recovered<&Self>, RecoveryError>

Same as [SignerRecoverable::try_to_recovered_ref_unchecked] but receives a buffer to operate on for encoding. This is useful during batch recovery of historical transactions to avoid allocating a new buffer for each transaction.

impl Transaction for AASigned

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

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) -> Uint<256, 4>

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<&[FixedBytes<32>]>

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 [SignedAuthorization]s in this transactions

impl TxHashRef for AASigned

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

Returns a reference to the transaction hash.

impl Typed2718 for AASigned

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 AASigned

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