graph: Normalize ABI JSON to handle undefined stateMutability

Some ABIs contain "undefined" as a stateMutability value, which is not
part of the official Solidity ABI specification. The spec only defines
four valid values: pure, view, nonpayable, and payable.

Alloy's StateMutability enum strictly follows the spec and rejects
"undefined" during deserialization, causing subgraph deployment failures
with: unknown variant `undefined`, expected one of `pure`, `view`,
`nonpayable`, `payable`

This adds a normalize_abi_json() function that preprocesses ABI JSON
before deserialization, replacing "undefined" with "nonpayable" (the
default state mutability). This handles non-compliant ABIs gracefully
while maintaining spec compliance.

Also adds a unit test to verify the normalization works correctly.

🤖 Generated with Claude Code
Co-Authored-By: Claude <[email protected]>

Author: incrypto32

graph/src/data_source/common.rs

@@ -24,6 +24,26 @@ use slog::Logger;
 use std::collections::HashMap;
 use std::{str::FromStr, sync::Arc};
 
+fn normalize_abi_json(json_bytes: &[u8]) -> Result<Vec<u8>, anyhow::Error> {
+    let mut value: serde_json::Value = serde_json::from_slice(json_bytes)?;
+
+    if let Some(array) = value.as_array_mut() {
+        for item in array {
+            if let Some(obj) = item.as_object_mut() {
+                if let Some(state_mutability) = obj.get_mut("stateMutability") {
+                    if let Some(s) = state_mutability.as_str() {
+                        if s == "undefined" {
+                            *state_mutability = serde_json::Value::String("nonpayable".to_string());
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    Ok(serde_json::to_vec(&value)?)
+}
+
 #[derive(Clone, Debug, PartialEq)]
 pub struct MappingABI {
     pub name: String,
@@ -364,11 +384,14 @@ impl UnresolvedMappingABI {
                     self.name, self.file.link
                 )
             })?;
-        let contract = serde_json::from_slice(&*contract_bytes)
+        let normalized_bytes = normalize_abi_json(&contract_bytes)
+            .with_context(|| format!("failed to normalize ABI JSON for {}", self.name))?;
+
+        let contract = serde_json::from_slice(&normalized_bytes)
             .with_context(|| format!("failed to load ABI {}", self.name))?;
 
         // Parse ABI JSON for on-demand struct field extraction
-        let abi_json = AbiJson::new(&contract_bytes)
+        let abi_json = AbiJson::new(&normalized_bytes)
             .with_context(|| format!("Failed to parse ABI JSON for {}", self.name))?;
 
         Ok((
@@ -2103,6 +2126,39 @@ mod tests {
         assert!(error_msg.contains("is not a struct"));
     }
 
+    #[test]
+    fn test_normalize_abi_json_with_undefined_state_mutability() {
+        let abi_with_undefined = r#"[
+            {
+                "type": "function",
+                "name": "testFunction",
+                "inputs": [],
+                "outputs": [],
+                "stateMutability": "undefined"
+            },
+            {
+                "type": "function",
+                "name": "normalFunction",
+                "inputs": [],
+                "outputs": [],
+                "stateMutability": "view"
+            }
+        ]"#;
+
+        let normalized = normalize_abi_json(abi_with_undefined.as_bytes()).unwrap();
+        let result: serde_json::Value = serde_json::from_slice(&normalized).unwrap();
+
+        if let Some(array) = result.as_array() {
+            assert_eq!(array[0]["stateMutability"], "nonpayable");
+            assert_eq!(array[1]["stateMutability"], "view");
+        } else {
+            panic!("Expected JSON array");
+        }
+
+        let json_abi: abi::JsonAbi = serde_json::from_slice(&normalized).unwrap();
+        assert_eq!(json_abi.len(), 2);
+    }
+
     // Helper function to create consistent test ABI
     fn create_test_mapping_abi() -> AbiJson {
         const ABI_JSON: &str = r#"[