Struct alloy_rpc_client::PollerBuilder

pub struct PollerBuilder<Conn, Params, Resp> { /* private fields */ }

A poller task builder.

This builder is used to create a poller task that repeatedly polls a method on a client and sends the responses to a channel. By default, this is done every 10 seconds, with a channel size of 16, and no limit on the number of successful polls. This is all configurable.

The builder is consumed using the spawn method, which returns a channel to receive the responses. The task will continue to poll until either the client or the channel is dropped.

The channel can be converted into a stream using the into_stream method.

Alternatively, into_stream can be used to directly return a stream of responses on the current thread. This is currently equivalent to spawn().into_stream(), but this may change in the future.

Examples

Poll eth_blockNumber every 5 seconds:

use alloy_primitives::U64;
use alloy_rpc_client::PollerBuilder;
use futures_util::StreamExt;

let poller: PollerBuilder<_, (), U64> = client
    .prepare_static_poller("eth_blockNumber", ())
    .with_poll_interval(std::time::Duration::from_secs(5));
let mut stream = poller.into_stream();
while let Some(block_number) = stream.next().await {
   println!("polled block number: {block_number}");
}

Implementations

impl<Conn, Params, Resp> PollerBuilder<Conn, Params, Resp>

where Conn: Transport + Clone, Params: RpcParam + 'static, Resp: RpcReturn + Clone,

pub fn new( client: WeakClient<Conn>, method: impl Into<Cow<'static, str>>, params: Params, ) -> Self

Create a new poller task.

pub const fn channel_size(&self) -> usize

Returns the channel size for the poller task.

pub fn set_channel_size(&mut self, channel_size: usize)

Sets the channel size for the poller task.

pub fn with_channel_size(self, channel_size: usize) -> Self

Sets the channel size for the poller task.

pub const fn limit(&self) -> usize

Returns the limit on the number of successful polls.

pub fn set_limit(&mut self, limit: Option<usize>)

Sets a limit on the number of successful polls.

pub fn with_limit(self, limit: Option<usize>) -> Self

Sets a limit on the number of successful polls.

pub const fn poll_interval(&self) -> Duration

Returns the duration between polls.

pub fn set_poll_interval(&mut self, poll_interval: Duration)

Sets the duration between polls.

pub fn with_poll_interval(self, poll_interval: Duration) -> Self

Sets the duration between polls.

pub fn spawn(self) -> PollChannel<Resp>

Starts the poller in a new Tokio task, returning a channel to receive the responses on.

pub fn into_stream(self) -> impl Stream<Item = Resp> + Unpin

Starts the poller and returns the stream of responses.

Note that this is currently equivalent to self.spawn().into_stream(), but this may change in the future.

Trait Implementations

impl<Conn: Debug, Params: Debug, Resp: Debug> Debug for PollerBuilder<Conn, Params, Resp>

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

Formats the value using the given formatter.