all: Defer parsing ABI for declared calls to handler resolution

The ahead-of-time parsing was unnecessarily complicated, and the map it
produced was wrong since it was organized by the event name (`Owner`)
rather than the event signature (`Owner(indexed address)`) which made
parameter lookups fail at runtime.

Since the handler has the event signature from the manifest, which is
exactly in the form that is used for lookups, it's much easier to parse at
that point.

Author: lutter

chain/ethereum/src/data_source.rs

@@ -6,7 +6,8 @@ use graph::components::store::{EthereumCallCache, StoredDynamicDataSource};
 use graph::components::subgraph::{HostMetrics, InstanceDSTemplateInfo, MappingError};
 use graph::components::trigger_processor::RunnableTriggers;
 use graph::data_source::common::{
-    CallDecls, DeclaredCall, FindMappingABI, MappingABI, UnresolvedCallDecls, UnresolvedMappingABI,
+    AbiJson, CallDecls, DeclaredCall, FindMappingABI, MappingABI, UnresolvedCallDecls,
+    UnresolvedMappingABI,
 };
 use graph::data_source::{CausalityRegion, MappingTrigger as MappingTriggerType};
 use graph::env::ENV_VARS;
@@ -1379,9 +1380,7 @@ impl UnresolvedMapping {
             // resolve each abi
             abis.into_iter()
                 .map(|unresolved_abi| async {
-                    Result::<_, Error>::Ok(Arc::new(
-                        unresolved_abi.resolve(resolver, logger).await?,
-                    ))
+                    Result::<_, Error>::Ok(unresolved_abi.resolve(resolver, logger).await?)
                 })
                 .collect::<FuturesOrdered<_>>()
                 .try_collect::<Vec<_>>(),
@@ -1398,24 +1397,27 @@ impl UnresolvedMapping {
             .into_iter()
             .map(|unresolved_handler| {
                 // Find the ABI for this event handler
-                let event_abi = abis.first().ok_or_else(|| {
+                let (_, abi_json) = abis.first().ok_or_else(|| {
                     anyhow!(
                         "No ABI found for event '{}' in event handler '{}'",
                         unresolved_handler.event,
                         unresolved_handler.handler
                     )
                 })?;
 
-                unresolved_handler.resolve(event_abi, &spec_version)
+                unresolved_handler.resolve(abi_json, &spec_version)
             })
             .collect::<Result<Vec<_>, anyhow::Error>>()?;
 
+        // Extract just the MappingABIs for the final Mapping struct
+        let mapping_abis = abis.into_iter().map(|(abi, _)| Arc::new(abi)).collect();
+
         Ok(Mapping {
             kind,
             api_version,
             language,
             entities,
-            abis,
+            abis: mapping_abis,
             block_handlers: block_handlers.clone(),
             call_handlers: call_handlers.clone(),
             event_handlers: resolved_event_handlers,
@@ -1482,12 +1484,12 @@ pub struct UnresolvedMappingEventHandler {
 impl UnresolvedMappingEventHandler {
     pub fn resolve(
         self,
-        mapping: &MappingABI,
+        abi_json: &AbiJson,
         spec_version: &semver::Version,
     ) -> Result<MappingEventHandler, anyhow::Error> {
         let resolved_calls = self
             .calls
-            .resolve(mapping, Some(&self.event), spec_version)?;
+            .resolve(abi_json, Some(&self.event), spec_version)?;
 
         Ok(MappingEventHandler {
             event: self.event,