Struct ethers_contract::stream::EventStream

pub struct EventStream<'a, T, R, E> {
    pub id: U256,
    /* private fields */
}

Generic wrapper around Log streams, mapping their content to a specific deserialized log struct.

We use this wrapper type instead of StreamExt::map in order to preserve information about the filter/subscription’s id.

Fields

id: U256

The stream ID, provided by the RPC server

Implementations

impl<'a, T, R, E> EventStream<'a, T, R, E>

pub fn with_meta(self) -> EventStreamMeta<'a, T, R, E>

Turns this stream of events into a stream that also yields the event’s metadata

impl<'a, T, R, E> EventStream<'a, T, R, E>

pub fn new( id: U256, stream: T, parse: Box<dyn Fn(Log) -> Result<R, E> + Send + Sync + 'a> ) -> Self

Instantiate a new EventStream

Typically users should not call this directly

impl<'a, T, R, E> EventStream<'a, T, R, E>

where T: Stream<Item = Log> + Unpin + 'a, R: 'a, E: 'a,

pub fn select<St>( self, st: St ) -> SelectEvent<SelectEither<'a, Result<R, E>, St::Item>>

where St: Stream + Unpin + 'a,

This function will attempt to pull events from both event streams. Each stream will be polled in a round-robin fashion, and whenever a stream is ready to yield an event that event is yielded.

After one of the two event streams completes, the remaining one will be polled exclusively. The returned stream completes when both input streams have completed.

Note that this function consumes both streams and returns a wrapped version of them. The item of the wrapped stream is an Either, and the items that the self streams yields will be stored in the left-hand variant of that Either and the other stream’s (st) items will be wrapped into the right-hand variant of that Either.

Example

#[derive(Clone, Debug, EthEvent)]
pub struct Approval {
    #[ethevent(indexed)]
    pub token_owner: Address,
    #[ethevent(indexed)]
    pub spender: Address,
    pub tokens: U256,
}

#[derive(Clone, Debug, EthEvent)]
pub struct Transfer {
    #[ethevent(indexed)]
    pub from: Address,
    #[ethevent(indexed)]
    pub to: Address,
    pub tokens: U256,
}


let ev1 = contract.event::<Approval>().from_block(1337).to_block(2000);
let ev2 = contract.event::<Transfer>();

let mut events = ev1.stream().await.unwrap().select(ev2.stream().await.unwrap()).ok();

while let Some(either) = events.next().await {
    match either {
        Either::Left(approval) => { let Approval{token_owner,spender,tokens} = approval; }
        Either::Right(transfer) => { let Transfer{from,to,tokens} = transfer; }
    }
}

Trait Implementations

impl<'a, T, R, E> Stream for EventStream<'a, T, R, E>

where T: Stream<Item = Log> + Unpin,

type Item = Result<R, E>

Values yielded by the stream.

fn poll_next( self: Pin<&mut Self>, ctx: &mut Context<'_> ) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.

impl<'pin, 'a, T, R, E> Unpin for EventStream<'a, T, R, E>

where __EventStream<'pin, 'a, T, R, E>: Unpin,