Enum PooledTransactionsElement

pub enum PooledTransactionsElement {
    Legacy {
        transaction: TxLegacy,
        signature: PrimitiveSignature,
        hash: FixedBytes<32>,
    },
    Eip2930 {
        transaction: TxEip2930,
        signature: PrimitiveSignature,
        hash: FixedBytes<32>,
    },
    Eip1559 {
        transaction: TxEip1559,
        signature: PrimitiveSignature,
        hash: FixedBytes<32>,
    },
    Eip7702 {
        transaction: TxEip7702,
        signature: PrimitiveSignature,
        hash: FixedBytes<32>,
    },
    BlobTransaction(BlobTransaction),
}

A response to GetPooledTransactions. This can include either a blob transaction, or a non-4844 signed transaction.

Variants

Legacy

A legacy transaction

Fields

transaction: TxLegacy

The inner transaction

signature: PrimitiveSignature

The signature

hash: FixedBytes<32>

The hash of the transaction

Eip2930

An EIP-2930 typed transaction

Fields

transaction: TxEip2930

The inner transaction

signature: PrimitiveSignature

The signature

hash: FixedBytes<32>

The hash of the transaction

Eip1559

An EIP-1559 typed transaction

Fields

transaction: TxEip1559

The inner transaction

signature: PrimitiveSignature

The signature

hash: FixedBytes<32>

The hash of the transaction

Eip7702

An EIP-7702 typed transaction

Fields

transaction: TxEip7702

The inner transaction

signature: PrimitiveSignature

The signature

hash: FixedBytes<32>

The hash of the transaction

BlobTransaction(BlobTransaction)

A blob transaction, which includes the transaction, blob data, commitments, and proofs.

Implementations

impl PooledTransactionsElement

pub fn try_from_broadcast( tx: TransactionSigned, ) -> Result<PooledTransactionsElement, TransactionSigned>

Tries to convert a TransactionSigned into a PooledTransactionsElement.

This function used as a helper to convert from a decoded p2p broadcast message to PooledTransactionsElement. Since BlobTransaction is disallowed to be broadcasted on p2p, return an err if tx is Transaction::Eip4844.

pub fn try_from_blob_transaction( tx: TransactionSigned, sidecar: BlobTransactionSidecar, ) -> Result<PooledTransactionsElement, TransactionSigned>

Converts from an EIP-4844 TransactionSignedEcRecovered to a PooledTransactionsElementEcRecovered with the given sidecar.

Returns an Err containing the original TransactionSigned if the transaction is not EIP-4844.

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

Heavy operation that return signature hash over rlp encoded transaction. It is only for signature signing or signer recovery.

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

Reference to transaction hash. Used to identify transaction.

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

Returns the signature of the transaction.

pub const fn nonce(&self) -> u64

Returns the transaction nonce.

pub fn recover_signer(&self) -> Option<Address>

Recover signer from signature and hash.

Returns None if the transaction’s signature is invalid, see also Self::recover_signer.

pub fn try_into_ecrecovered( self, ) -> Result<PooledTransactionsElementEcRecovered, PooledTransactionsElement>

Tries to recover signer and return PooledTransactionsElementEcRecovered.

Returns Err(Self) if the transaction’s signature is invalid, see also Self::recover_signer.

pub fn into_ecrecovered_transaction( self, signer: Address, ) -> TransactionSignedEcRecovered

Create TransactionSignedEcRecovered by converting this transaction into TransactionSigned and Address of the signer.

pub fn into_transaction(self) -> TransactionSigned

Returns the inner TransactionSigned.

pub const fn is_eip4844(&self) -> bool

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

pub const fn as_legacy(&self) -> Option<&TxLegacy>

Returns the [TxLegacy] variant if the transaction is a legacy transaction.

pub const fn as_eip2930(&self) -> Option<&TxEip2930>

Returns the [TxEip2930] variant if the transaction is an EIP-2930 transaction.

pub const fn as_eip1559(&self) -> Option<&TxEip1559>

Returns the [TxEip1559] variant if the transaction is an EIP-1559 transaction.

pub const fn as_eip4844(&self) -> Option<&TxEip4844>

Returns the [TxEip4844] variant if the transaction is an EIP-4844 transaction.

pub const fn as_eip7702(&self) -> Option<&TxEip7702>

Returns the [TxEip7702] variant if the transaction is an EIP-7702 transaction.

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

Returns the blob gas used for all blobs of the EIP-4844 transaction if it is an EIP-4844 transaction.

This is the number of blobs times the DATA_GAS_PER_BLOB a single blob consumes.

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

Max fee per blob gas for eip4844 transaction [TxEip4844].

Returns None for non-eip4844 transactions.

This is also commonly referred to as the “Blob Gas Fee Cap” (BlobGasFeeCap).

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

Max priority fee per gas for eip1559 transaction, for legacy and eip2930 transactions this is None

This is also commonly referred to as the “Gas Tip Cap” (GasTipCap).

pub const fn max_fee_per_gas(&self) -> u128

Max fee per gas for eip1559 transaction, for legacy transactions this is gas_price.

This is also commonly referred to as the “Gas Fee Cap” (GasFeeCap).

Trait Implementations

impl<'a> Arbitrary<'a> for PooledTransactionsElement

Available on crate feature arbitrary only.

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

Generates an arbitrary PooledTransactionsElement.

This function generates an arbitrary PooledTransactionsElement by creating a transaction and, if applicable, generating a sidecar for blob transactions.

It handles the generation of sidecars and constructs the resulting PooledTransactionsElement.

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 AsRef<PooledTransactionsElement> for PooledTransactionsElementEcRecovered

fn as_ref(&self) -> &PooledTransactionsElement

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

impl Clone for PooledTransactionsElement

fn clone(&self) -> PooledTransactionsElement

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for PooledTransactionsElement

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

Formats the value using the given formatter.

impl Decodable for PooledTransactionsElement

fn decode(buf: &mut &[u8]) -> Result<PooledTransactionsElement, Error>

Decodes an enveloped post EIP-4844 PooledTransactionsElement.

CAUTION: this expects that buf is rlp(tx_type || rlp(tx-data))

impl Decodable2718 for PooledTransactionsElement

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

Decode the appropriate variant, based on the type flag.

fn fallback_decode( buf: &mut &[u8], ) -> Result<PooledTransactionsElement, 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 that first byte is 0x7f or lower.

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

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 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 PooledTransactionsElement

fn deserialize<__D>( __deserializer: __D, ) -> Result<PooledTransactionsElement, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encodable for PooledTransactionsElement

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

This encodes the transaction with the signature, and an rlp header.

For legacy transactions, it encodes the transaction data: rlp(tx-data)

For EIP-2718 typed transactions, it encodes the transaction type followed by the rlp of the transaction: rlp(tx-type || rlp(tx-data))

fn length(&self) -> usize

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

impl Encodable2718 for PooledTransactionsElement

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

Return the type flag (if any).

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 is_legacy(&self) -> bool

True if the envelope is the legacy variant.

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

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

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 TryFrom<TransactionSigned> for PooledTransactionsElement

type Error = TransactionConversionError

The type returned in the event of a conversion error.

fn try_from( tx: TransactionSigned, ) -> Result<PooledTransactionsElement, <PooledTransactionsElement as TryFrom<TransactionSigned>>::Error>

Performs the conversion.

impl Eq for PooledTransactionsElement

impl StructuralPartialEq for PooledTransactionsElement

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

Size for each variant:

• Legacy: 248 bytes
• Eip2930: 264 bytes
• Eip1559: 280 bytes
• Eip7702: 296 bytes
• BlobTransaction: 408 bytes