Enum reth::primitives::transaction::PooledTransactionsElement

pub enum PooledTransactionsElement {
    Legacy {
        transaction: TxLegacy,
        signature: Signature,
        hash: FixedBytes<32>,
    },
    Eip2930 {
        transaction: TxEip2930,
        signature: Signature,
        hash: FixedBytes<32>,
    },
    Eip1559 {
        transaction: TxEip1559,
        signature: Signature,
        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: Signature

The signature

hash: FixedBytes<32>

The hash of the transaction

Eip2930

An EIP-2930 typed transaction

Fields

transaction: TxEip2930

The inner transaction

signature: Signature

The signature

hash: FixedBytes<32>

The hash of the transaction

Eip1559

An EIP-1559 typed transaction

Fields

transaction: TxEip1559

The inner transaction

signature: Signature

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) -> &Signature

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 decode_enveloped( data: &mut &[u8], ) -> Result<PooledTransactionsElement, Error>

Decodes the “raw” format of transaction (e.g. eth_sendRawTransaction).

This should be used for eth_sendRawTransaction, for any transaction type. Blob transactions must include the blob sidecar as part of the raw encoding.

This method can not be used for decoding the transactions field of engine_newPayload, because EIP-4844 transactions for that method do not include the blob sidecar. The blobs are supplied in an argument separate from the payload.

A raw transaction is either a legacy transaction or EIP-2718 typed transaction, with a special case for EIP-4844 transactions.

For legacy transactions, the format is encoded as: rlp(tx). This format will start with a RLP list header.

For EIP-2718 typed transactions, the format is encoded as the type of the transaction followed by the rlp of the transaction: type || rlp(tx).

For EIP-4844 transactions, the format includes a blob sidecar (the blobs, commitments, and proofs) after the transaction: type || rlp([tx_payload_body, blobs, commitments, proofs])

Where tx_payload_body is encoded as a RLP list: [chain_id, nonce, max_priority_fee_per_gas, ..., y_parity, r, s]

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 fn length_without_header(&self) -> usize

Returns the length without an RLP header - this is used for eth/68 sizes.

pub fn envelope_encoded(&self) -> Bytes

Returns the enveloped encoded transactions.

See also TransactionSigned::encode_enveloped

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

Encodes the transaction into the “raw” format (e.g. eth_sendRawTransaction). This format is also referred to as “binary” encoding.

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

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

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

Encodes an enveloped post EIP-4844 PooledTransactionsElement.

For legacy transactions, this encodes the transaction as rlp(tx-data).

For EIP-2718 transactions, this encodes the transaction as rlp(tx_type || rlp(tx-data))), _including the RLP-header for the entire transaction.

fn length(&self) -> usize

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

impl FromIterator<PooledTransactionsElement> for PooledTransactions

fn from_iter<I>(iter: I) -> PooledTransactions

where I: IntoIterator<Item = PooledTransactionsElement>,

Creates a value from an iterator.

impl PartialEq for PooledTransactionsElement

fn eq(&self, other: &PooledTransactionsElement) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method 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: 384 bytes

Size for each variant:

• Legacy: 256 bytes
• Eip2930: 272 bytes
• Eip1559: 288 bytes
• BlobTransaction: 384 bytes