Enum PooledTransaction

pub enum PooledTransaction {
    Legacy(Signed<TxLegacy>),
    Eip2930(Signed<TxEip2930>),
    Eip1559(Signed<TxEip1559>),
    Eip4844(Signed<TxEip4844WithSidecar>),
    Eip7702(Signed<TxEip7702>),
}

All possible transactions that can be included in a response to GetPooledTransactions. A response to GetPooledTransactions. This can include either a blob transaction, or a non-4844 signed transaction.

The difference between this and the [TxEnvelope] is that this type always requires the [TxEip4844WithSidecar] variant, because EIP-4844 transaction can only be propagated with the sidecar over p2p.

Variants

Legacy(Signed<TxLegacy>)

An untagged [TxLegacy].

Eip2930(Signed<TxEip2930>)

A [TxEip2930] tagged with type 1.

Eip1559(Signed<TxEip1559>)

A [TxEip1559] tagged with type 2.

Eip4844(Signed<TxEip4844WithSidecar>)

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

Eip7702(Signed<TxEip7702>)

A [TxEip7702] tagged with type 4.

Implementations

impl PooledTransaction

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 fn encode_for_signing(&self, out: &mut dyn BufMut)

This encodes the transaction without the signature, and is only suitable for creating a hash intended for signing.

pub fn into_envelope(self) -> TxEnvelope

Converts the transaction into [TxEnvelope].

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_with_sidecar(&self) -> Option<&TxEip4844WithSidecar>

Returns the [TxEip4844WithSidecar] variant if the transaction is an EIP-4844 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 try_into_legacy(self) -> Result<Signed<TxLegacy>, PooledTransaction>

Attempts to unwrap the transaction into a legacy transaction variant. If the transaction is not a legacy transaction, it will return Err(self).

pub fn try_into_eip2930(self) -> Result<Signed<TxEip2930>, PooledTransaction>

Attempts to unwrap the transaction into an EIP-2930 transaction variant. If the transaction is not an EIP-2930 transaction, it will return Err(self).

pub fn try_into_eip1559(self) -> Result<Signed<TxEip1559>, PooledTransaction>

Attempts to unwrap the transaction into an EIP-1559 transaction variant. If the transaction is not an EIP-1559 transaction, it will return Err(self).

pub fn try_into_eip4844( self, ) -> Result<Signed<TxEip4844WithSidecar>, PooledTransaction>

Attempts to unwrap the transaction into an EIP-4844 transaction variant. If the transaction is not an EIP-4844 transaction, it will return Err(self).

pub fn try_into_eip7702(self) -> Result<Signed<TxEip7702>, PooledTransaction>

Attempts to unwrap the transaction into an EIP-7702 transaction variant. If the transaction is not an EIP-7702 transaction, it will return Err(self).

Trait Implementations

impl Clone for PooledTransaction

fn clone(&self) -> PooledTransaction

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for PooledTransaction

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

Formats the value using the given formatter.

impl Decodable for PooledTransaction

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

Decodes an enveloped post EIP-4844 PooledTransaction.

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

impl Decodable2718 for PooledTransaction

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

Decode the appropriate variant, based on the type flag.

fn fallback_decode(buf: &mut &[u8]) -> Result<PooledTransaction, 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 PooledTransaction

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encodable for PooledTransaction

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 PooledTransaction

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 From<PooledTransaction> for TransactionSigned

fn from(tx: PooledTransaction) -> Self

Converts to this type from the input type.

impl From<Signed<TxEip1559>> for PooledTransaction

fn from(v: Signed<TxEip1559>) -> PooledTransaction

Converts to this type from the input type.

impl From<Signed<TxEip2930>> for PooledTransaction

fn from(v: Signed<TxEip2930>) -> PooledTransaction

Converts to this type from the input type.

impl From<Signed<TxEip4844WithSidecar>> for PooledTransaction

fn from(v: Signed<TxEip4844WithSidecar>) -> PooledTransaction

Converts to this type from the input type.

impl From<Signed<TxEip7702>> for PooledTransaction

fn from(v: Signed<TxEip7702>) -> PooledTransaction

Converts to this type from the input type.

impl From<Signed<TxLegacy>> for PooledTransaction

fn from(v: Signed<TxLegacy>) -> PooledTransaction

Converts to this type from the input type.

impl Hash for PooledTransaction

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 PooledTransaction

fn size(&self) -> usize

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

impl PartialEq for PooledTransaction

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

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 SignedTransaction for PooledTransaction

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

Returns reference to transaction hash.

fn signature(&self) -> &PrimitiveSignature

Returns reference to signature.

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

Recover signer from signature and hash.

fn recover_signer_unchecked_with_buf( &self, buf: &mut Vec<u8>, ) -> Option<Address>

Same as [Self::recover_signer_unchecked] but receives a buffer to operate on. This is used during batch recovery to avoid allocating a new buffer for each transaction.

fn is_broadcastable_in_full(&self) -> bool

Returns whether this transaction type can be broadcasted as full transaction over the network.

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

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

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

Calculate transaction hash, eip2728 transaction does not contain rlp header and start with tx type.

impl Transaction for PooledTransaction

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

Returns the EIP-1559 the maximum fee per gas the caller is willing to pay.

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

Returns the EIP-1559 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 an EIP-1559 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 blob_gas_used(&self) -> Option<u64>

Returns the total gas for all blobs in this transaction.

impl TryFrom<TransactionSigned> for PooledTransaction

type Error = TransactionConversionError

The type returned in the event of a conversion error.

fn try_from(tx: TransactionSigned) -> Result<Self, Self::Error>

Performs the conversion.

impl Typed2718 for PooledTransaction

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 PooledTransaction

impl StructuralPartialEq for PooledTransaction

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: 256 bytes
• Eip2930: 272 bytes
• Eip1559: 288 bytes
• Eip4844: 400 bytes
• Eip7702: 304 bytes