feat(substreams): add substreams for Uniswap v2 and v3

substreams/crates/substreams-helper/src/event_handler.rs

@@ -0,0 +1,103 @@
+use std::collections::HashMap;
+
+use ethabi::ethereum_types::Address;
+use substreams_ethereum::{
+    pb::eth::v2::{self as eth},
+    Event,
+};
+
+use crate::common::HasAddresser;
+
+/// Utility struct to easily filter events and assign them handlers.
+///
+/// Usage:
+/// ```
+/// let eh = EventHandler::new(&block);
+/// eh.filter_by_address(store); // This is optional, if omitted it will handle all events that match the type, independently of the emitting contract.
+/// eh.on::<Transfer, _>(&mut on_transfer);
+/// eh.on::<Approval, _>(&mut on_approval);
+/// eh.on::<Mint, _>(&mut on_mint);
+/// eh.on::<Burn, _>(&mut on_burn);
+/// eh.handle_events(); // this will run all handlers
+/// ```
+///
+/// You'll likely want to mutate some value from the handlers that is in the current scope.
+/// For that, make your handlers be closures, that close over the variable you want to mutate, and
+/// have the whole EventHandler block of code in its own scope (either by wrapping it in an aux
+/// function or by wrapping it in {...})
+///
+/// Like so:
+/// ```
+/// let mut balances : Vec<Balance> = vec![];
+/// {
+///     let mut on_transfer = |/*...*/| {
+///         // this handler modifies `balances`
+///         balances.push(some_balance);
+///     };
+///     let eh = EventHandler::new(&block);
+///     eh.on::<Transfer, _>(&mut on_transfer);
+///     eh.handle_events();
+/// }
+///
+/// // do whatever else with `balances` here.
+/// ```
+pub struct EventHandler<'a> {
+    block: &'a eth::Block,
+    #[allow(clippy::type_complexity)]
+    handlers: HashMap<&'static str, Box<dyn FnMut(&eth::Log, &eth::TransactionTrace) + 'a>>,
+    addresses: Option<Box<dyn HasAddresser + 'a>>,
+}
+
+impl<'a> EventHandler<'a> {
+    pub fn new(block: &'a eth::Block) -> Self {
+        Self { block, handlers: HashMap::new(), addresses: None }
+    }
+
+    /// Sets the HasAddresser as a filter for which events to handle.
+    /// Only one at a time can be set. Setting it twice will remove the first one.
+    /// Addresses found in the `HasAddresser` will be the ones we'll handle events from.
+    pub fn filter_by_address(&mut self, addresser: impl HasAddresser + 'a) {
+        self.addresses = Some(Box::new(addresser));
+    }
+
+    /// Registers a handler to be run on a given event. The handler should have the signature:
+    /// `|ev: SomeEvent, tx: &pbeth::v2::TransactionTrace, log: &pbeth::v2::Log|`.
+    /// You can only assign one handler to each Event type.
+    /// Handlers are keyed by the name of the event they are handling, so be careful to not assign
+    /// handlers for 2 different events named equal.
+    pub fn on<E: Event, F>(&mut self, mut handler: F)
+    where
+        F: FnMut(E, &eth::TransactionTrace, &eth::Log) + 'a,
+    {
+        self.handlers.insert(
+            E::NAME,
+            Box::new(move |log: &eth::Log, tx: &eth::TransactionTrace| {
+                if let Some(event) = E::match_and_decode(log) {
+                    handler(event, tx, log);
+                }
+            }),
+        );
+    }
+
+    /// Will run all registered handlers for all events present on the block that match the given
+    /// filters. You'll likely want to run this just once.
+    pub fn handle_events(&mut self) {
+        // Here we don't need to filter out failed transactions because logs only exist for
+        // successful ones.
+        for log in self.block.logs() {
+            if self.addresses.is_some() &&
+                !&self
+                    .addresses
+                    .as_ref()
+                    .unwrap()
+                    .has_address(Address::from_slice(log.log.address.as_slice()))
+            {
+                continue;
+            }
+
+            for handler in self.handlers.values_mut() {
+                handler(log.log, log.receipt.transaction);
+            }
+        }
+    }
+}