Enum TransactionSource 

pub enum TransactionSource<T = EthereumTxEnvelope<TxEip4844>> {
    Pool(Recovered<T>),
    Block {
        transaction: Recovered<T>,
        index: u64,
        block_hash: FixedBytes<32>,
        block_number: u64,
        base_fee: Option<u64>,
    },
}

Represents from where a transaction was fetched.

Variants

Pool(Recovered<T>)

Transaction exists in the pool (Pending)

Block

Transaction already included in a block

This can be a historical block or a pending block (received from the CL)

Fields

transaction: Recovered<T>

Transaction fetched via provider

index: u64

Index of the transaction in the block

block_hash: FixedBytes<32>

Hash of the block.

block_number: u64

Number of the block.

base_fee: Option<u64>

base fee of the block.

Implementations

impl<T> TransactionSource<T>

where T: SignedTransaction,

pub fn into_recovered(self) -> Recovered<T>

Consumes the type and returns the wrapped transaction.

pub fn into_transaction<Builder>( self, resp_builder: &Builder, ) -> Result<<Builder as TransactionCompat<T>>::Transaction, <Builder as TransactionCompat<T>>::Error>

where Builder: TransactionCompat<T>,

Conversion into network specific transaction type.

pub fn split(self) -> (Recovered<T>, TransactionInfo)

Returns the transaction and block related info, if not pending

Trait Implementations

impl<T> Clone for TransactionSource<T>

where T: Clone,

fn clone(&self) -> TransactionSource<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for TransactionSource<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> From<TransactionSource<T>> for Recovered<T>

fn from(value: TransactionSource<T>) -> Recovered<T>

Converts to this type from the input type.

impl<T> PartialEq for TransactionSource<T>

where T: PartialEq,

fn eq(&self, other: &TransactionSource<T>) -> 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<T> Eq for TransactionSource<T>

where T: Eq,

impl<T> StructuralPartialEq for TransactionSource<T>

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.