Struct reth::rpc::types::Filter

pub struct Filter {
    pub block_option: FilterBlockOption,
    pub address: FilterSet<Address>,
    pub topics: [FilterSet<FixedBytes<32>>; 4],
}

Filter for logs.

Fields

block_option: FilterBlockOption

Filter block options, specifying on which blocks the filter should match.

address: FilterSet<Address>

Address

topics: [FilterSet<FixedBytes<32>>; 4]

Topics (maximum of 4)

Implementations

impl Filter

pub fn new() -> Filter

Creates a new, empty filter

pub fn select(self, filter: impl Into<FilterBlockOption>) -> Filter

Sets the inner filter object

NOTE: ranges are always inclusive

Examples

Match only a specific block

let filter = Filter::new().select(69u64);

This is the same as Filter::new().from_block(1337u64).to_block(1337u64)

Match the latest block only

let filter = Filter::new().select(BlockNumberOrTag::Latest);

Match a block by its hash

let filter = Filter::new().select(B256::ZERO);

This is the same as at_block_hash

Match a range of blocks

let filter = Filter::new().select(0u64..100u64);

Match all blocks in range (1337..BlockNumberOrTag::Latest)

let filter = Filter::new().select(1337u64..);

Match all blocks in range (BlockNumberOrTag::Earliest..1337)

let filter = Filter::new().select(..1337u64);

pub fn from_block<T>(self, block: T) -> Filter

where T: Into<BlockNumberOrTag>,

Sets the from block number

pub fn to_block<T>(self, block: T) -> Filter

where T: Into<BlockNumberOrTag>,

Sets the to block number

pub fn is_pending_block_filter(&self) -> bool

Return true if filter configured to match pending block. This means that both from_block and to_block are set to the pending tag.

pub fn at_block_hash<T>(self, hash: T) -> Filter

where T: Into<FixedBytes<32>>,

Pins the block hash for the filter

pub fn address<T>(self, address: T) -> Filter

where T: Into<ValueOrArray<Address>>,

Sets the address to query with this filter.

Examples

Match only a specific address ("0xAc4b3DacB91461209Ae9d41EC517c2B9Cb1B7DAF")

let filter = Filter::new()
    .address("0xAc4b3DacB91461209Ae9d41EC517c2B9Cb1B7DAF".parse::<Address>().unwrap());

Match all addresses in array (vec!["0xAc4b3DacB91461209Ae9d41EC517c2B9Cb1B7DAF", "0x8ad599c3A0ff1De082011EFDDc58f1908eb6e6D8"])

let addresses = vec![
    "0xAc4b3DacB91461209Ae9d41EC517c2B9Cb1B7DAF".parse::<Address>().unwrap(),
    "0x8ad599c3A0ff1De082011EFDDc58f1908eb6e6D8".parse::<Address>().unwrap(),
];
let filter = Filter::new().address(addresses);

pub fn event(self, event_name: &str) -> Filter

Given the event signature in string form, it hashes it and adds it to the topics to monitor

pub fn events( self, events: impl IntoIterator<Item = impl AsRef<[u8]>>, ) -> Filter

Hashes all event signatures and sets them as array to event_signature(topic0)

pub fn event_signature<T>(self, topic: T) -> Filter

where T: Into<FilterSet<FixedBytes<32>>>,

Sets event_signature(topic0) (the event name for non-anonymous events)

pub fn topic0<T>(self, topic: T) -> Filter

where T: Into<FilterSet<FixedBytes<32>>>,

👎Deprecated: use event_signature instead

Sets topic0 (the event name for non-anonymous events)

pub fn topic1<T>(self, topic: T) -> Filter

where T: Into<FilterSet<FixedBytes<32>>>,

Sets the 1st indexed topic

pub fn topic2<T>(self, topic: T) -> Filter

where T: Into<FilterSet<FixedBytes<32>>>,

Sets the 2nd indexed topic

pub fn topic3<T>(self, topic: T) -> Filter

where T: Into<FilterSet<FixedBytes<32>>>,

Sets the 3rd indexed topic

pub fn is_paginatable(&self) -> bool

Returns true if this is a range filter and has a from block

pub fn get_to_block(&self) -> Option<u64>

Returns the numeric value of the toBlock field

pub fn get_from_block(&self) -> Option<u64>

Returns the numeric value of the fromBlock field

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

Returns the numeric value of the fromBlock field

pub fn has_topics(&self) -> bool

Returns true if at least one topic is set

Trait Implementations

impl Clone for Filter

fn clone(&self) -> Filter

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Filter

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

Formats the value using the given formatter.

impl Default for Filter

fn default() -> Filter

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Filter

fn deserialize<D>( deserializer: D, ) -> Result<Filter, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for Filter

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 PartialEq for Filter

fn eq(&self, other: &Filter) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Filter

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 Eq for Filter

impl StructuralPartialEq for Filter

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: 280 bytes