Struct EventsMethods 

pub struct EventsMethods { /* private fields */ }

Methods for fetching Circles events over HTTP or websocket.

WS helpers subscribe to eth_subscribe("circles", filter), drop heartbeat frames ([]), flatten batches, and parse into CirclesEvent when desired.

Implementations

impl EventsMethods

pub fn new(client: RpcClient) -> Self

Create a new accessor for event-related RPCs.

pub async fn circles_events( &self, address: Option<Address>, from_block: u64, to_block: Option<u64>, filter: Option<Vec<Filter>>, ) -> Result<Vec<CirclesEvent>>

HTTP: circles_events(address, fromBlock, toBlock?, filter?)

pub async fn subscribe_circles_events<F>( &self, filter: F, ) -> Result<CirclesSubscription<RpcSubscriptionEvent>>

where F: RpcSend + 'static,

Subscribe via eth_subscribe("circles", filter) and yield raw RpcSubscriptionEvents.

pub async fn subscribe_parsed_events<F>( &self, filter: F, ) -> Result<CirclesSubscription<CirclesEvent>>

where F: RpcSend + 'static,

Subscribe and parse into CirclesEvent using the canonical parser.

Examples found in repository

examples/paged_and_ws.rs (line 85)

async fn stream_events(rpc: &CirclesRpc, address: Address) -> Result<()> {
    use tokio::time::timeout;

    println!("Subscribing to Circles events for address {address}");
    // Empty filter = firehose; add {"address": <addr>} to narrow. Some public WS
    // endpoints currently emit empty [] heartbeats and no payloads.
    let filter = serde_json::json!({});
    let mut sub = match rpc.events().subscribe_parsed_events(filter).await {
        Ok(sub) => sub,
        Err(e) => {
            eprintln!("subscription failed: {e}");
            return Ok(());
        }
    };

    let mut seen = 0u32;
    loop {
        match timeout(Duration::from_secs(15), sub.next()).await {
            Ok(Some(Ok(evt))) => {
                println!(
                    "event: {:?} @ block {}",
                    evt.event_type, evt.base.block_number
                );
                seen += 1;
                if seen >= 3 {
                    break;
                }
            }
            Ok(Some(Err(e))) => {
                println!("event stream error: {e}");
                break;
            }
            Ok(None) => {
                println!("subscription closed");
                break;
            }
            Err(_) => {
                println!("no events within timeout, stopping");
                break;
            }
        }
    }

    println!("Unsubscribing after {seen} events");
    // Drop will best-effort eth_unsubscribe, but explicit is fine too.
    let _ = sub.unsubscribe();

    // Debug helper: also try a raw Value subscription to inspect payloads when parsing fails.
    debug_raw_ws(address).await;
    Ok(())
}

Trait Implementations

impl Clone for EventsMethods

fn clone(&self) -> EventsMethods

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EventsMethods

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

Formats the value using the given formatter.