core: Implement two-phase parsing for ABI-aware call resolution

Addresses feedback from Lutter about supporting struct field access in
declarative calls in production. Previously, manifest parsing happened
via serde deserialize which called FromStr without ABI context,
preventing named field resolution outside of tests.

This implements two-phase parsing where:
- Initial deserialization stores calls as raw strings in UnresolvedCallDecls
- Resolution phase parses calls with ABI context using CallExpr::parse()
- Spec version validation happens during parsing with clear error messages

Changes:
- Add UnresolvedCallDecls struct to store raw call strings
- Add UnresolvedMappingEventHandler and UnresolvedEntityHandler
- Move call parsing from deserialization to resolution phase
- Replace eprintln! with proper logger.warn() calls
- Remove obsolete validation functions

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: fubhy

chain/ethereum/src/data_source.rs

@@ -6,7 +6,7 @@ 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, UnresolvedMappingABI,
+    CallDecls, DeclaredCall, FindMappingABI, MappingABI, UnresolvedCallDecls, UnresolvedMappingABI,
 };
 use graph::data_source::{CausalityRegion, MappingTrigger as MappingTriggerType};
 use graph::env::ENV_VARS;
@@ -41,7 +41,7 @@ use graph::{
 
 use graph::data::subgraph::{
     calls_host_fn, DataSourceContext, Source, MIN_SPEC_VERSION, SPEC_VERSION_0_0_8,
-    SPEC_VERSION_1_2_0, SPEC_VERSION_1_4_0,
+    SPEC_VERSION_1_2_0,
 };
 
 use crate::adapter::EthereumAdapter as _;
@@ -74,38 +74,6 @@ pub struct DataSource {
     pub contract_abi: Arc<MappingABI>,
 }
 
-/// Checks if a declarative call uses struct field access that would require spec version 1.4.0+
-/// This detects if the call was parsed with ABI context to resolve named fields
-fn call_uses_named_field_access(call_expr: &graph::data_source::common::CallExpr) -> bool {
-    // Check address for struct field access
-    if has_struct_field_access(&call_expr.address) {
-        return true;
-    }
-
-    // Check all arguments for struct field access
-    for arg in &call_expr.args {
-        if has_struct_field_access(arg) {
-            return true;
-        }
-    }
-
-    false
-}
-
-/// Helper function to check if a CallArg uses struct field access
-fn has_struct_field_access(arg: &graph::data_source::common::CallArg) -> bool {
-    use graph::data_source::common::{CallArg, EthereumArg};
-
-    match arg {
-        CallArg::Ethereum(EthereumArg::StructField(_, indices)) => {
-            // If we have struct field access with indices, it means named fields were resolved
-            // This feature requires spec version 1.4.0+
-            !indices.is_empty()
-        }
-        _ => false,
-    }
-}
-
 impl blockchain::DataSource<Chain> for DataSource {
     fn from_template_info(
         info: InstanceDSTemplateInfo,
@@ -412,19 +380,6 @@ impl blockchain::DataSource<Chain> for DataSource {
             }
         }
 
-        if spec_version < &SPEC_VERSION_1_4_0 {
-            for handler in &self.mapping.event_handlers {
-                for call in handler.calls.decls.as_ref() {
-                    if call_uses_named_field_access(&call.expr) {
-                        errors.push(anyhow!(
-                            "handler {}: struct field access by name in declarative calls is only supported for specVersion >= 1.4.0", handler.event
-                        ));
-                        break;
-                    }
-                }
-            }
-        }
-
         for handler in &self.mapping.event_handlers {
             for call in handler.calls.decls.as_ref() {
                 match self.mapping.find_abi(&call.expr.abi) {
@@ -1266,7 +1221,7 @@ impl blockchain::UnresolvedDataSource<Chain> for UnresolvedDataSource {
     }
 }
 
-#[derive(Clone, Debug, Default, Hash, Eq, PartialEq, Deserialize)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Deserialize)]
 pub struct UnresolvedDataSourceTemplate {
     pub kind: String,
     pub network: Option<String>,
@@ -1339,7 +1294,7 @@ impl blockchain::DataSourceTemplate<Chain> for DataSourceTemplate {
     }
 }
 
-#[derive(Clone, Debug, Default, Hash, Eq, PartialEq, Deserialize)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct UnresolvedMapping {
     pub kind: String,
@@ -1352,7 +1307,7 @@ pub struct UnresolvedMapping {
     #[serde(default)]
     pub call_handlers: Vec<MappingCallHandler>,
     #[serde(default)]
-    pub event_handlers: Vec<MappingEventHandler>,
+    pub event_handlers: Vec<UnresolvedMappingEventHandler>,
     pub file: Link,
 }
 
@@ -1435,6 +1390,30 @@ impl UnresolvedMapping {
         .await
         .with_context(|| format!("failed to resolve mapping {}", link.link))?;
 
+        // Resolve event handlers with ABI context
+        let resolved_event_handlers = event_handlers
+            .into_iter()
+            .map(|unresolved_handler| {
+                // Find the ABI for this event handler
+                let event_abi = abis
+                    .iter()
+                    .find(|abi| {
+                        abi.contract
+                            .events()
+                            .any(|event| event.name == unresolved_handler.event)
+                    })
+                    .ok_or_else(|| {
+                        anyhow!(
+                            "No ABI found for event '{}' in event handler '{}'",
+                            unresolved_handler.event,
+                            unresolved_handler.handler
+                        )
+                    })?;
+
+                unresolved_handler.resolve(event_abi, Some(&api_version))
+            })
+            .collect::<Result<Vec<_>, anyhow::Error>>()?;
+
         Ok(Mapping {
             kind,
             api_version,
@@ -1443,7 +1422,7 @@ impl UnresolvedMapping {
             abis,
             block_handlers: block_handlers.clone(),
             call_handlers: call_handlers.clone(),
-            event_handlers: event_handlers.clone(),
+            event_handlers: resolved_event_handlers,
             runtime,
             link,
         })
@@ -1487,6 +1466,46 @@ pub struct MappingCallHandler {
     pub handler: String,
 }
 
+#[derive(Clone, Debug, Eq, PartialEq, Deserialize)]
+pub struct UnresolvedMappingEventHandler {
+    pub event: String,
+    pub topic0: Option<H256>,
+    #[serde(deserialize_with = "deserialize_h256_vec", default)]
+    pub topic1: Option<Vec<H256>>,
+    #[serde(deserialize_with = "deserialize_h256_vec", default)]
+    pub topic2: Option<Vec<H256>>,
+    #[serde(deserialize_with = "deserialize_h256_vec", default)]
+    pub topic3: Option<Vec<H256>>,
+    pub handler: String,
+    #[serde(default)]
+    pub receipt: bool,
+    #[serde(default)]
+    pub calls: UnresolvedCallDecls,
+}
+
+impl UnresolvedMappingEventHandler {
+    pub fn resolve(
+        &self,
+        mapping: &MappingABI,
+        spec_version: Option<&semver::Version>,
+    ) -> Result<MappingEventHandler, anyhow::Error> {
+        let resolved_calls = self
+            .calls
+            .resolve(mapping, Some(&self.event), spec_version)?;
+
+        Ok(MappingEventHandler {
+            event: self.event.clone(),
+            topic0: self.topic0,
+            topic1: self.topic1.clone(),
+            topic2: self.topic2.clone(),
+            topic3: self.topic3.clone(),
+            handler: self.handler.clone(),
+            receipt: self.receipt,
+            calls: resolved_calls,
+        })
+    }
+}
+
 #[derive(Clone, Debug, Hash, Eq, PartialEq, Deserialize)]
 pub struct MappingEventHandler {
     pub event: String,