Enum FoundryTxEnvelope 

pub enum FoundryTxEnvelope {
    Legacy(Signed<TxLegacy>),
    Eip2930(Signed<TxEip2930>),
    Eip1559(Signed<TxEip1559>),
    Eip4844(Signed<TxEip4844Variant>),
    Eip7702(Signed<TxEip7702>),
    Deposit(Sealed<TxDeposit>),
    Tempo(AASigned),
}

Container type for signed, typed transactions.

Variants

Legacy(Signed<TxLegacy>)

Legacy transaction type

Eip2930(Signed<TxEip2930>)

EIP-2930 transaction.

Eip1559(Signed<TxEip1559>)

EIP-1559 transaction.

Eip4844(Signed<TxEip4844Variant>)

EIP-4844 transaction.

Eip7702(Signed<TxEip7702>)

EIP-7702 transaction.

Deposit(Sealed<TxDeposit>)

OP stack deposit transaction.

See https://docs.optimism.io/op-stack/bridging/deposit-flow.

Tempo(AASigned)

Tempo transaction type.

See https://docs.tempo.xyz/protocol/transactions.

Implementations

impl FoundryTxEnvelope

pub fn try_into_eth(self) -> Result<TxEnvelope, Self>

Converts the transaction into an Ethereum [TxEnvelope].

Returns an error if the transaction is not part of the standard Ethereum transaction types.

pub fn sidecar(&self) -> Option<&TxEip4844WithSidecar>

pub fn hash(&self) -> B256

Returns the hash of the transaction.

Note

If this transaction has the Impersonated signature then this returns a modified unique hash. This allows us to treat impersonated transactions as unique.

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

Recovers the Ethereum address which was used to sign the transaction.

Trait Implementations

impl Clone for FoundryTxEnvelope

fn clone(&self) -> FoundryTxEnvelope

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FoundryTxEnvelope

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

Formats the value using the given formatter.

impl Decodable for FoundryTxEnvelope

where Signed<TxLegacy>: Decodable2718, Signed<TxEip2930>: Decodable2718, Signed<TxEip1559>: Decodable2718, Signed<TxEip4844Variant>: Decodable2718, Signed<TxEip7702>: Decodable2718, Sealed<TxDeposit>: Decodable2718, AASigned: Decodable2718,

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

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

impl Decodable2718 for FoundryTxEnvelope

where Signed<TxLegacy>: Decodable2718, Signed<TxEip2930>: Decodable2718, Signed<TxEip1559>: Decodable2718, Signed<TxEip4844Variant>: Decodable2718, Signed<TxEip7702>: Decodable2718, Sealed<TxDeposit>: Decodable2718, AASigned: Decodable2718,

fn typed_decode(ty: u8, buf: &mut &[u8]) -> Eip2718Result<Self>

Decode the appropriate variant, based on the type flag.

fn fallback_decode(buf: &mut &[u8]) -> Eip2718Result<Self>

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 FoundryTxEnvelope

where FoundryTxEnvelope: Clone, Signed<TxLegacy>: Serialize + DeserializeOwned, Signed<TxEip2930>: Serialize + DeserializeOwned, Signed<TxEip1559>: Serialize + DeserializeOwned, Signed<TxEip4844Variant>: Serialize + DeserializeOwned, Signed<TxEip7702>: Serialize + DeserializeOwned, Sealed<TxDeposit>: Serialize + DeserializeOwned, AASigned: Serialize + DeserializeOwned,

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

Deserialize this value from the given Serde deserializer.

impl Encodable for FoundryTxEnvelope

where Signed<TxLegacy>: Encodable2718, Signed<TxEip2930>: Encodable2718, Signed<TxEip1559>: Encodable2718, Signed<TxEip4844Variant>: Encodable2718, Signed<TxEip7702>: Encodable2718, Sealed<TxDeposit>: Encodable2718, AASigned: Encodable2718,

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 Encodable2718 for FoundryTxEnvelope

where Signed<TxLegacy>: Encodable2718, Signed<TxEip2930>: Encodable2718, Signed<TxEip1559>: Encodable2718, Signed<TxEip4844Variant>: Encodable2718, Signed<TxEip7702>: Encodable2718, Sealed<TxDeposit>: Encodable2718, AASigned: Encodable2718,

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

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<FoundryTxEnvelope> for FoundryTransactionRequest

fn from(tx: FoundryTxEnvelope) -> Self

Converts to this type from the input type.

impl From<FoundryTxEnvelope> for FoundryTypedTx

fn from(envelope: FoundryTxEnvelope) -> Self

Converts to this type from the input type.

impl FromRecoveredTx<FoundryTxEnvelope> for OpTransaction<TxEnv>

fn from_recovered_tx(tx: &FoundryTxEnvelope, caller: Address) -> Self

Builds a [TxEnv] from a transaction and a sender address.

impl FromRecoveredTx<FoundryTxEnvelope> for TxEnv

fn from_recovered_tx(tx: &FoundryTxEnvelope, caller: Address) -> Self

Builds a [TxEnv] from a transaction and a sender address.

impl FromTxWithEncoded<FoundryTxEnvelope> for OpTransaction<TxEnv>

fn from_encoded_tx( tx: &FoundryTxEnvelope, caller: Address, encoded: Bytes, ) -> Self

Builds a [TxEnv] from a transaction, its sender, and encoded transaction bytes.

impl FromTxWithEncoded<FoundryTxEnvelope> for TxEnv

fn from_encoded_tx( tx: &FoundryTxEnvelope, sender: Address, _encoded: Bytes, ) -> Self

Builds a [TxEnv] from a transaction, its sender, and encoded transaction bytes.

impl Hash for FoundryTxEnvelope

where Self: Encodable2718,

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 IsTyped2718 for FoundryTxEnvelope

fn is_type(type_id: u8) -> bool

Returns true if the given type ID corresponds to a supported typed transaction.

impl OpTransaction for FoundryTxEnvelope

fn is_deposit(&self) -> bool

Returns true if the transaction is a deposit.

fn as_deposit(&self) -> Option<&Sealed<TxDeposit>>

Returns Some if the transaction is a deposit.

impl PartialEq for FoundryTxEnvelope

where Signed<TxLegacy>: PartialEq, Signed<TxEip2930>: PartialEq, Signed<TxEip1559>: PartialEq, Signed<TxEip4844Variant>: PartialEq, Signed<TxEip7702>: PartialEq, Sealed<TxDeposit>: PartialEq, AASigned: PartialEq,

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

where FoundryTxEnvelope: Clone, Signed<TxLegacy>: Serialize + DeserializeOwned, Signed<TxEip2930>: Serialize + DeserializeOwned, Signed<TxEip1559>: Serialize + DeserializeOwned, Signed<TxEip4844Variant>: Serialize + DeserializeOwned, Signed<TxEip7702>: Serialize + DeserializeOwned, Sealed<TxDeposit>: Serialize + DeserializeOwned, AASigned: Serialize + DeserializeOwned,

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl SignerRecoverable for FoundryTxEnvelope

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 FoundryTxEnvelope

where Self: Debug, Signed<TxLegacy>: Transaction, Signed<TxEip2930>: Transaction, Signed<TxEip1559>: Transaction, Signed<TxEip4844Variant>: Transaction, Signed<TxEip7702>: Transaction, Sealed<TxDeposit>: Transaction, AASigned: Transaction,

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

impl TransactionEnvelope for FoundryTxEnvelope

where Self: Transaction,

type TxType = FoundryTxType

The enum of transaction types.

fn tx_type(&self) -> Self::TxType

Returns the transaction type.

impl TryFrom<AnyRpcTransaction> for FoundryTxEnvelope

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: AnyRpcTransaction) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<FoundryTxEnvelope> for TxEnvelope

type Error = FoundryTxEnvelope

The type returned in the event of a conversion error.

fn try_from(envelope: FoundryTxEnvelope) -> Result<Self, Self::Error>

Performs the conversion.

impl TxHashRef for FoundryTxEnvelope

fn tx_hash(&self) -> &TxHash

Returns a reference to the transaction hash.

impl Typed2718 for FoundryTxEnvelope

where Signed<TxLegacy>: Typed2718, Signed<TxEip2930>: Typed2718, Signed<TxEip1559>: Typed2718, Signed<TxEip4844Variant>: Typed2718, Signed<TxEip7702>: Typed2718, Sealed<TxDeposit>: Typed2718, AASigned: Typed2718,

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 FoundryTxEnvelope

where Signed<TxLegacy>: PartialEq, Signed<TxEip2930>: PartialEq, Signed<TxEip1559>: PartialEq, Signed<TxEip4844Variant>: PartialEq, Signed<TxEip7702>: PartialEq, Sealed<TxDeposit>: PartialEq, AASigned: PartialEq,

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

Size for each variant:

• Legacy: 272 bytes
• Eip2930: 288 bytes
• Eip1559: 304 bytes
• Eip4844: 416 bytes
• Eip7702: 320 bytes
• Deposit: 224 bytes
• Tempo: 736 bytes