Struct TransactionReceipt

pub struct TransactionReceipt<T = ReceiptEnvelope<Log>> {
    pub inner: T,
    pub transaction_hash: TxHash,
    pub transaction_index: Option<u64>,
    pub block_hash: Option<BlockHash>,
    pub block_number: Option<u64>,
    pub gas_used: u64,
    pub effective_gas_price: u128,
    pub blob_gas_used: Option<u64>,
    pub blob_gas_price: Option<u128>,
    pub from: Address,
    pub to: Option<Address>,
    pub contract_address: Option<Address>,
}

Transaction receipt

This type is generic over an inner ReceiptEnvelope which contains consensus data and metadata.

Fields

inner: T

The receipt envelope, which contains the consensus receipt data.

transaction_hash: TxHash

Transaction Hash.

transaction_index: Option<u64>

Index within the block.

block_hash: Option<BlockHash>

Hash of the block this transaction was included within.

block_number: Option<u64>

Number of the block this transaction was included within.

gas_used: u64

Gas used by this transaction alone.

effective_gas_price: u128

The price paid post-execution by the transaction (i.e. base fee + priority fee). Both fields in 1559-style transactions are maximums (max fee + max priority fee), the amount that’s actually paid by users can only be determined post-execution

blob_gas_used: Option<u64>

Blob gas used by the eip-4844 transaction

This is None for non eip-4844 transactions

blob_gas_price: Option<u128>

The price paid by the eip-4844 transaction per blob gas.

from: Address

Address of the sender

to: Option<Address>

Address of the receiver. None when its a contract creation transaction.

contract_address: Option<Address>

Contract address created, or None if not a deployment.

Implementations

impl TransactionReceipt

pub const fn status(&self) -> bool

Returns the status of the transaction.

pub const fn transaction_type(&self) -> TxType

Returns the transaction type.

impl<T> TransactionReceipt<T>

pub fn map_inner<U, F>(self, f: F) -> TransactionReceipt<U>

where F: FnOnce(T) -> U,

Maps the inner receipt value of this receipt.

pub fn into_inner(self) -> T

Consumes the type and returns the wrapped receipt.

pub fn calculate_create_address(&self, nonce: u64) -> Option<Address>

Calculates the address that will be created by the transaction, if any.

Returns None if the transaction is not a contract creation (the to field is set).

impl<L> TransactionReceipt<ReceiptEnvelope<L>>

pub fn map_logs<U>( self, f: impl FnMut(L) -> U, ) -> TransactionReceipt<ReceiptEnvelope<U>>

Converts the receipt’s log type by applying a function to each log.

Returns the receipt with the new log type.

pub fn into_primitives_receipt(self) -> TransactionReceipt<ReceiptEnvelope<Log>>

where L: Into<Log>,

Converts the transaction receipt’s ReceiptEnvelope with a custom log type into a ReceiptEnvelope with the primitives alloy_primitives::Log type by converting the logs.

impl<T: TxReceipt> TransactionReceipt<T>

pub fn logs(&self) -> &[T::Log]

Get the receipt logs.

impl<T: TxReceipt<Log: AsRef<Log>>> TransactionReceipt<T>

pub fn decoded_log<E: SolEvent>(&self) -> Option<Log<E>>

Attempts to decode the logs to the provided log type.

Returns the first log that decodes successfully.

Returns None, if none of the logs could be decoded to the provided log type or if there are no logs.

pub fn decode_first_log<E: SolEvent>(&self) -> Option<Log<E>>

Attempts to decode the first log in the receipt to the provided log type. Returns None if there are no logs or if decoding fails.

pub fn decode_nth_log<E: SolEvent>(&self, idx: usize) -> Option<Log<E>>

Decode the log at the given index as the given SolEvent type.

pub fn decode_last_log<E: SolEvent>(&self) -> Option<Log<E>>

Decode the last log in the receipt.

Trait Implementations

impl AsRef<ReceiptEnvelope<Log>> for TransactionReceipt

fn as_ref(&self) -> &ReceiptEnvelope<Log>

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

impl<T: Clone> Clone for TransactionReceipt<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for TransactionReceipt<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for TransactionReceipt<T>

where T: Deserialize<'de>,

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<TransactionReceipt> for TransactionReceipt<ReceiptEnvelope<Log>>

fn from(value: TransactionReceipt) -> Self

Converts to this type from the input type.

impl<T: PartialEq> PartialEq for TransactionReceipt<T>

fn eq(&self, other: &TransactionReceipt<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: TxReceipt<Log = Log>> ReceiptResponse for TransactionReceipt<T>

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

Address of the created contract, or None if the transaction was not a deployment.

fn status(&self) -> bool

Status of the transaction.

fn block_hash(&self) -> Option<BlockHash>

Hash of the block this transaction was included within.

fn block_number(&self) -> Option<u64>

Number of the block this transaction was included within.

fn transaction_hash(&self) -> TxHash

Transaction Hash.

fn transaction_index(&self) -> Option<u64>

Index within the block.

fn gas_used(&self) -> u64

Gas used by this transaction alone.

fn effective_gas_price(&self) -> u128

Effective gas price.

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

Blob gas used by the eip-4844 transaction.

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

Blob gas price paid by the eip-4844 transaction.

fn from(&self) -> Address

Address of the sender.

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

Address of the receiver.

fn cumulative_gas_used(&self) -> u64

Returns the cumulative gas used at this receipt.

fn state_root(&self) -> Option<B256>

The post-transaction state root (pre Byzantium)

fn cost(&self) -> u128

Total cost of this transaction = gas_used * effective_gas_price.

impl<T> Serialize for TransactionReceipt<T>

where T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Eq> Eq for TransactionReceipt<T>

impl<T> StructuralPartialEq for TransactionReceipt<T>