use crate::{base::decode_event, stream::EventStream, ContractError}; use ethers_core::{ abi::{Detokenize, Event as AbiEvent}, types::{BlockNumber, Filter, Log, TxHash, ValueOrArray, H256, U64}, }; use ethers_providers::{FilterWatcher, Middleware, PubsubClient, SubscriptionStream}; use std::borrow::Cow; use std::marker::PhantomData; /// A trait for implementing event bindings pub trait EthEvent: Detokenize { /// The name of the event this type represents fn name() -> Cow<'static, str>; /// Retrieves the signature for the event this data corresponds to. /// This signature is the Keccak-256 hash of the ABI signature of /// this event. fn signature() -> H256; /// Retrieves the ABI signature for the event this data corresponds /// to. fn abi_signature() -> Cow<'static, str>; } /// Helper for managing the event filter before querying or streaming its logs #[derive(Debug)] #[must_use = "event filters do nothing unless you `query` or `stream` them"] pub struct Event<'a: 'b, 'b, M, D> { /// The event filter's state pub filter: Filter, /// The ABI of the event which is being filtered pub event: &'b AbiEvent, pub(crate) provider: &'a M, pub(crate) datatype: PhantomData, } // TODO: Improve these functions impl Event<'_, '_, M, D> { /// Sets the filter's `from` block #[allow(clippy::wrong_self_convention)] pub fn from_block>(mut self, block: T) -> Self { self.filter.from_block = Some(block.into()); self } /// Sets the filter's `to` block #[allow(clippy::wrong_self_convention)] pub fn to_block>(mut self, block: T) -> Self { self.filter.to_block = Some(block.into()); self } /// Sets the filter's 0th topic (typically the event name for non-anonymous events) pub fn topic0>>(mut self, topic: T) -> Self { self.filter.topics[0] = Some(topic.into()); self } /// Sets the filter's 1st topic pub fn topic1>>(mut self, topic: T) -> Self { self.filter.topics[1] = Some(topic.into()); self } /// Sets the filter's 2nd topic pub fn topic2>>(mut self, topic: T) -> Self { self.filter.topics[2] = Some(topic.into()); self } /// Sets the filter's 3rd topic pub fn topic3>>(mut self, topic: T) -> Self { self.filter.topics[3] = Some(topic.into()); self } } impl<'a, 'b, M, D> Event<'a, 'b, M, D> where M: Middleware, D: 'b + Detokenize + Clone, { /// Returns a stream for the event pub async fn stream( &'a self, ) -> Result< // Wraps the FilterWatcher with a mapping to the event EventStream<'a, FilterWatcher<'a, M::Provider, Log>, D, ContractError>, ContractError, > { let filter = self .provider .watch(&self.filter) .await .map_err(ContractError::MiddlewareError)?; Ok(EventStream::new( filter.id, filter, Box::new(move |log| self.parse_log(log)), )) } } impl<'a, 'b, M, D> Event<'a, 'b, M, D> where M: Middleware, ::Provider: PubsubClient, D: 'b + Detokenize + Clone, { /// Returns a subscription for the event pub async fn subscribe( &'a self, ) -> Result< // Wraps the SubscriptionStream with a mapping to the event EventStream<'a, SubscriptionStream<'a, M::Provider, Log>, D, ContractError>, ContractError, > { let filter = self .provider .subscribe_logs(&self.filter) .await .map_err(ContractError::MiddlewareError)?; Ok(EventStream::new( filter.id, filter, Box::new(move |log| self.parse_log(log)), )) } } impl Event<'_, '_, M, D> where M: Middleware, D: Detokenize + Clone, { /// Queries the blockchain for the selected filter and returns a vector of matching /// event logs pub async fn query(&self) -> Result, ContractError> { let logs = self .provider .get_logs(&self.filter) .await .map_err(ContractError::MiddlewareError)?; let events = logs .into_iter() .map(|log| self.parse_log(log)) .collect::, ContractError>>()?; Ok(events) } /// Queries the blockchain for the selected filter and returns a vector of logs /// along with their metadata pub async fn query_with_meta(&self) -> Result, ContractError> { let logs = self .provider .get_logs(&self.filter) .await .map_err(ContractError::MiddlewareError)?; let events = logs .into_iter() .map(|log| { let meta = LogMeta::from(&log); let event = self.parse_log(log)?; Ok((event, meta)) }) .collect::>>()?; Ok(events) } fn parse_log(&self, log: Log) -> Result> { Ok(decode_event(self.event, log.topics, log.data)?) } } /// Metadata inside a log #[derive(Clone, Debug, PartialEq)] pub struct LogMeta { /// The block in which the log was emitted pub block_number: U64, /// The transaction hash in which the log was emitted pub transaction_hash: TxHash, } impl From<&Log> for LogMeta { fn from(src: &Log) -> Self { LogMeta { block_number: src.block_number.expect("should have a block number"), transaction_hash: src.transaction_hash.expect("should have a tx hash"), } } }