runtime/wasm: Implement new event processing in RuntimeHost

Jannis Pohlmann · Jannis Pohlmann · commit efae4e9a92c4 · 2018-09-25T12:31:33.000+02:00
diff --git a/runtime/wasm/src/host.rs b/runtime/wasm/src/host.rs
@@ -1,18 +1,19 @@
 use failure::*;
-use futures::sync::mpsc::{channel, Receiver, Sender};
+use futures::sync::mpsc::{channel, Sender};
 use futures::sync::oneshot;
-use std::str::FromStr;
 use std::thread;
-use uuid::Uuid;
 
 use graph::components::ethereum::*;
 use graph::components::store::Store;
 use graph::data::subgraph::DataSource;
+use graph::ethabi::Contract;
+use graph::ethabi::LogParam;
+use graph::ethabi::RawLog;
 use graph::prelude::{
-    RuntimeHost as RuntimeHostTrait, RuntimeHostBuilder as RuntimeHostBuilderTrait, *,
+    MappingABI, RuntimeHost as RuntimeHostTrait, RuntimeHostBuilder as RuntimeHostBuilderTrait, *,
 };
 use graph::util;
-use graph::web3::types::Address;
+use graph::web3::types::{Log, Transaction};
 
 use module::{WasmiModule, WasmiModuleConfig};
 
@@ -90,11 +91,15 @@ where
 
 type HandleEventResponse = Result<Vec<EntityOperation>, Error>;
 
-type HandleEventRequest = (
-    EthereumEvent,
-    MappingEventHandler,
-    oneshot::Sender<HandleEventResponse>,
-);
+struct HandleEventRequest {
+    handler: MappingEventHandler,
+    block: Arc<EthereumBlock>,
+    transaction: Arc<Transaction>,
+    log: Arc<Log>,
+    params: Vec<LogParam>,
+    entity_operations: Vec<EntityOperation>,
+    result_sender: oneshot::Sender<HandleEventResponse>,
+}
 
 pub struct RuntimeHost {
     config: RuntimeHostConfig,
@@ -164,14 +169,29 @@ impl RuntimeHost {
                 .select(cancel_receiver.into_stream().map(|_| None).map_err(|_| ()))
                 .for_each(move |request: Option<HandleEventRequest>| {
                     if let Some(request) = request {
-                        let (event, handler, response_sender) = request;
+                        let HandleEventRequest {
+                            handler,
+                            block,
+                            transaction,
+                            log,
+                            params,
+                            entity_operations,
+                            result_sender,
+                        } = request;
 
                         debug!(event_logger, "  Call event handler";
                                "name" => &handler.handler,
                                "signature" => &handler.event);
 
-                        let result = module.handle_ethereum_event(handler.handler.as_str(), event);
-                        future::result(response_sender.send(result).map_err(|_| ()))
+                        let result = module.handle_ethereum_event(
+                            handler.handler.as_str(),
+                            block,
+                            transaction,
+                            log,
+                            params,
+                            entity_operations,
+                        );
+                        future::result(result_sender.send(result).map_err(|_| ()))
                     } else {
                         future::err(())
                     }
@@ -186,72 +206,156 @@ impl RuntimeHost {
             _guard: cancel_sender,
         }
     }
-}
 
-impl RuntimeHostTrait for RuntimeHost {
-    fn subgraph_manifest(&self) -> &SubgraphManifest {
-        &self.config.subgraph_manifest
+    fn matches_log_address(&self, log: &Log) -> bool {
+        self.config.data_source.source.address == log.address
     }
 
-    fn matches_event(&self, event: &EthereumEvent) -> bool {
+    fn matches_log_signature(&self, log: &Log) -> bool {
+        let signature = if log.topics.len() > 0 {
+            log.topics[0]
+        } else {
+            return false;
+        };
+
         self.config
             .data_source
             .mapping
             .event_handlers
             .iter()
             .find(|event_handler| {
-                event.event_signature
-                    == util::ethereum::string_to_h256(event_handler.event.as_str())
+                signature == util::ethereum::string_to_h256(event_handler.event.as_str())
             }).is_some()
     }
 
-    fn process_event(
-        &self,
-        event: EthereumEvent,
-    ) -> Box<Future<Item = Vec<EntityOperation>, Error = Error> + Send> {
-        let handler = self
-            .config
+    fn source_contract(&self) -> Result<&MappingABI, Error> {
+        self.config
+            .data_source
+            .mapping
+            .abis
+            .iter()
+            .find(|abi| abi.name == self.config.data_source.source.abi)
+            .ok_or(format_err!(
+                "No ABI entry found for the main contract of data source \"{}\": {}",
+                self.config.data_source.name,
+                self.config.data_source.source.abi,
+            ))
+    }
+
+    fn event_handler_for_log(&self, log: &Arc<Log>) -> Result<&MappingEventHandler, Error> {
+        // Get signature from the log
+        let signature = if log.topics.len() > 0 {
+            log.topics[0]
+        } else {
+            return Err(format_err!("Ethereum event has no topics"));
+        };
+
+        self.config
             .data_source
             .mapping
             .event_handlers
             .iter()
-            .find(|event_handler| {
-                event.event_signature
-                    == util::ethereum::string_to_h256(event_handler.event.as_str())
-            });
-
-        match handler {
-            Some(handler) => {
-                debug!(self.logger, "Process Ethereum event"; "signature" => &handler.event);
-
-                let (result_sender, result_receiver) = oneshot::channel();
-
-                let before_event_signature = handler.event.clone();
-                let event_signature = handler.event.clone();
-
-                Box::new(
-                    self.handle_event_sender
-                        .clone()
-                        .send((event, handler.clone(), result_sender))
-                        .map_err(move |_| {
-                            format_err!(
-                                "Mapping terminated before passing in Ethereum event: {}",
-                                before_event_signature
-                            )
-                        }).and_then(|_| {
-                            result_receiver.map_err(move |_| {
-                                format_err!(
-                                    "Mapping terminated before finishing to handle \
-                                     Ethereum event: {}",
-                                    event_signature,
-                                )
-                            })
-                        }).and_then(|result| result),
-                )
+            .find(|handler| signature == util::ethereum::string_to_h256(handler.event.as_str()))
+            .ok_or(format_err!(
+                "No event handler found for event in data source \"{}\"",
+                self.config.data_source.name,
+            ))
+    }
+}
+
+impl RuntimeHostTrait for RuntimeHost {
+    fn subgraph_manifest(&self) -> &SubgraphManifest {
+        &self.config.subgraph_manifest
+    }
+
+    fn matches_log(&self, log: &Log) -> bool {
+        self.matches_log_address(log) && self.matches_log_signature(log)
+    }
+
+    fn process_log(
+        &self,
+        block: Arc<EthereumBlock>,
+        transaction: Arc<Transaction>,
+        log: Arc<Log>,
+        entity_operations: Vec<EntityOperation>,
+    ) -> Box<Future<Item = Vec<EntityOperation>, Error = Error> + Send> {
+        // Identify the contract that the log belongs to
+        let abi = match self.source_contract() {
+            Ok(abi) => abi,
+            Err(e) => return Box::new(future::err(e)),
+        };
+
+        // Identify event handler for this log
+        let event_handler = match self.event_handler_for_log(&log) {
+            Ok(handler) => handler,
+            Err(e) => return Box::new(future::err(e)),
+        };
+
+        // Identify the event ABI in the contract
+        let event_abi = match util::ethereum::contract_event_with_signature(
+            &abi.contract,
+            event_handler.event.as_str(),
+        ) {
+            Some(event_abi) => event_abi,
+            None => {
+                return Box::new(future::err(format_err!(
+                    "Event with the signature \"{}\" not found in \
+                     contract \"{}\" of data source \"{}\"",
+                    event_handler.event,
+                    abi.name,
+                    self.config.data_source.name
+                )))
             }
-            None => Box::new(future::err(format_err!(
-                "Ethereum event not mentioned in the data source"
-            ))),
-        }
+        };
+
+        // Parse the log into an event
+        let params = match event_abi.parse_log(RawLog {
+            topics: log.topics.clone(),
+            data: log.data.clone().0,
+        }) {
+            Ok(log) => log.params,
+            Err(e) => {
+                return Box::new(future::err(format_err!(
+                    "Failed to parse parameters of event: {}: {}",
+                    event_handler.event,
+                    e
+                )))
+            }
+        };
+
+        debug!(self.logger, "Process Ethereum event"; "signature" => &event_handler.event);
+
+        // Call the event handler and asynchronously wait for the result
+        let (result_sender, result_receiver) = oneshot::channel();
+
+        let before_event_signature = event_handler.event.clone();
+        let event_signature = event_handler.event.clone();
+
+        Box::new(
+            self.handle_event_sender
+                .clone()
+                .send(HandleEventRequest {
+                    handler: event_handler.clone(),
+                    block: block.clone(),
+                    transaction: transaction.clone(),
+                    log: log.clone(),
+                    params,
+                    entity_operations,
+                    result_sender,
+                }).map_err(move |_| {
+                    format_err!(
+                        "Mapping terminated before passing in Ethereum event: {}",
+                        before_event_signature
+                    )
+                }).and_then(|_| {
+                    result_receiver.map_err(move |_| {
+                        format_err!(
+                            "Mapping terminated before finishing to handle \
+                             Ethereum event: {}",
+                            event_signature,
+                        )
+                    })
+                }).and_then(|result| result),
+        )
     }
 }
