Struct Log 

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

Available on crate features rpc and rpc-types only.

Ethereum Log emitted by a transaction

Fields

inner: Log<T>

Consensus log object

block_hash: Option<FixedBytes<32>>

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<FixedBytes<32>>

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

pub fn topics(&self) -> &[FixedBytes<32>]

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

pub fn topic0(&self) -> Option<&FixedBytes<32>>

Getter for the topic0 field.

pub fn topics_mut(&mut self) -> &mut [FixedBytes<32>]

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>(&self) -> Result<Log<T>, Error>

where T: SolEvent,

Decode the log data into a typed log.

pub fn log_decode_validate<T>(&self) -> Result<Log<T>, Error>

where T: SolEvent,

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 &'a T: for<'a> Into<LogData>,

pub fn reserialize_inner(&self) -> Log

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

pub fn reserialize(&self) -> Log

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<'arbitrary, T> Arbitrary<'arbitrary> for Log<T>

where T: Arbitrary<'arbitrary>,

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<Log<T>, Error>

Generate an arbitrary value of Self from the given unstructured data.

fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<Log<T>, 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.

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

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

where T: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Log<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for Log<T>

where T: Default,

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<Log<T>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Encodable for Log<T>

where &'a T: for<'a> 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>) -> Log<L>

Converts to this type from the input type.

impl<T> Hash for Log<T>

where T: Hash,

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

where T: PartialEq,

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 as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Eq for Log<T>

where T: Eq,

impl<T> StructuralPartialEq for Log<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.