Struct Log

pub struct Log<T = LogData> {
    pub inner: Log<T>,
    pub block_hash: Option<BlockHash>,
    pub block_number: Option<u64>,
    pub block_timestamp: Option<u64>,
    pub transaction_hash: Option<TxHash>,
    pub transaction_index: Option<u64>,
    pub log_index: Option<u64>,
    pub removed: bool,
}

Ethereum Log emitted by a transaction

Fields

inner: Log<T>

Consensus log object

block_hash: Option<BlockHash>

Hash of the block the transaction that emitted this log was mined in

block_number: Option<u64>

Number of the block the transaction that emitted this log was mined in

block_timestamp: Option<u64>

The timestamp of the block as proposed in: https://ethereum-magicians.org/t/proposal-for-adding-blocktimestamp-to-logs-object-returned-by-eth-getlogs-and-related-requests https://github.com/ethereum/execution-apis/issues/295

transaction_hash: Option<TxHash>

Transaction Hash

transaction_index: Option<u64>

Index of the Transaction in the block

log_index: Option<u64>

Log Index in Block

removed: bool

Geth Compatibility Field: whether this log was removed

Implementations

impl<T> Log<T>

pub const fn address(&self) -> Address

Getter for the address field. Shortcut for log.inner.address.

pub const fn data(&self) -> &T

Getter for the data field. Shortcut for log.inner.data.

pub fn into_inner(self) -> Log<T>

Consumes the type and returns the wrapped alloy_primitives::Log

impl Log<LogData>

pub fn topics(&self) -> &[B256]

Getter for the topics field. Shortcut for log.inner.topics().

pub fn topic0(&self) -> Option<&B256>

Getter for the topic0 field.

pub fn topics_mut(&mut self) -> &mut [B256]

Get the topic list, mutably. This gives access to the internal array, without allowing extension of that array. Shortcut for LogData::topics_mut

pub fn log_decode<T: SolEvent>(&self) -> Result<Log<T>>

Decode the log data into a typed log.

pub fn log_decode_validate<T: SolEvent>(&self) -> Result<Log<T>>

Decode the log data with validation into a typed log.

pub fn collect_for_receipt<I, T>( previous_log_count: usize, meta: TransactionMeta, logs: I, ) -> Vec<Log<T>>

where I: IntoIterator<Item = Log<T>>,

Creates a collection of RPC logs from transaction receipt logs.

This function takes raw consensus logs and enriches them with RPC metadata needed for API responses, including block information and proper indexing.

Arguments

• previous_log_count - The total number of logs from previous transactions in the same block. Used to calculate the correct log_index for each log.
• meta - Transaction metadata containing block hash, number, timestamp, and transaction information needed to populate the RPC log fields.
• logs - An iterator of consensus logs to be converted into RPC logs.

Returns

A vector of RPC logs with all metadata fields populated, ready to be included in the transaction receipt.

impl<T> Log<T>

where for<'a> &'a T: Into<LogData>,

pub fn reserialize_inner(&self) -> Log

Reserialize the inner data, returning an alloy_primitives::Log.

pub fn reserialize(&self) -> Log<LogData>

Reserialize the data, returning a new Log object wrapping an alloy_primitives::Log. this copies the log metadata, preserving the original object.

Trait Implementations

impl<T> AsMut<Log<T>> for Log<T>

fn as_mut(&mut self) -> &mut Log<T>

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

impl<T> AsMut<T> for Log<T>

fn as_mut(&mut self) -> &mut T

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

impl<T> AsRef<Log<T>> for Log<T>

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

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

impl<T> AsRef<T> for Log<T>

fn as_ref(&self) -> &T

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

impl<T: Clone> Clone for Log<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Log<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Log<T>

fn default() -> Log<T>

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for Log<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<T> Encodable for Log<T>

where for<'a> &'a T: Into<LogData>,

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

Encodes the type into the out buffer.

fn length(&self) -> usize

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

impl<L> From<Log<L>> for Log<L>

fn from(value: Log<L>) -> Self

Converts to this type from the input type.

impl<T: Hash> Hash for Log<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

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<T: PartialEq> PartialEq for Log<T>

fn eq(&self, other: &Log<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> Serialize for Log<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 Log<T>

impl<T> StructuralPartialEq for Log<T>