gnd: replace eth_call cache with mock transport layer

Replace the pre-populated eth_call cache approach with a mock Alloy
transport that intercepts RPC calls at the transport level. This makes
tests exercise the real production code path end-to-end.

- Add MockTransport serving eth_call, eth_getBalance, eth_getCode
- Add TestRuntimeAdapterBuilder to convert PossibleReorg → Deterministic
- Add getBalanceCalls/hasCodeCalls to test JSON schema
- Unmocked RPC calls now fail immediately with descriptive errors
- Disable RPC retries in test mode for fast failure

Author: dimitrovmaksim

Cargo.lock

@@ -31,6 +31,7 @@ graph-store-postgres = { path = "../store/postgres" }
 # Test command dependencies
 hex = "0.4"
 async-trait = { workspace = true }
+tower = { workspace = true }
 
 # Direct dependencies from current dev.rs
 anyhow = { workspace = true }

gnd/Cargo.toml

@@ -1,26 +1,16 @@
-//! Populates the eth_call cache with mock responses for `gnd test`.
-//!
-//! Signatures use graph-node's `name(inputs):(outputs)` convention.
-//! Encoding matches production graph-node so cache IDs align with the runtime.
+//! ABI encoding helpers for mock Ethereum call data.
 
-use super::schema::{MockEthCall, TestFile};
 use super::trigger::json_to_sol_value;
 use anyhow::{anyhow, Context, Result};
 use graph::abi::FunctionExt as GraphFunctionExt;
-use graph::blockchain::block_stream::BlockWithTriggers;
-use graph::blockchain::BlockPtr;
-use graph::components::store::EthereumCallCache;
-use graph::data::store::ethereum::call;
 use graph::prelude::alloy::dyn_abi::{DynSolType, FunctionExt as AlloyFunctionExt};
 use graph::prelude::alloy::json_abi::Function;
-use graph::prelude::alloy::primitives::Address;
-use graph::slog::Logger;
-use graph_chain_ethereum::Chain;
-use graph_store_postgres::ChainStore;
-use std::sync::Arc;
 
 /// ABI-encode a function call (selector + params) using graph-node's encoding path.
-fn encode_function_call(function_sig: &str, params: &[serde_json::Value]) -> Result<Vec<u8>> {
+pub(super) fn encode_function_call(
+    function_sig: &str,
+    params: &[serde_json::Value],
+) -> Result<Vec<u8>> {
     let alloy_sig = to_alloy_signature(function_sig);
     let function = Function::parse(&alloy_sig).map_err(|e| {
         anyhow!(
@@ -55,7 +45,10 @@ fn encode_function_call(function_sig: &str, params: &[serde_json::Value]) -> Res
 }
 
 /// ABI-encode function return values (no selector prefix).
-fn encode_return_value(function_sig: &str, returns: &[serde_json::Value]) -> Result<Vec<u8>> {
+pub(super) fn encode_return_value(
+    function_sig: &str,
+    returns: &[serde_json::Value],
+) -> Result<Vec<u8>> {
     let alloy_sig = to_alloy_signature(function_sig);
     let function = Function::parse(&alloy_sig).map_err(|e| {
         anyhow!(
@@ -92,7 +85,7 @@ fn encode_return_value(function_sig: &str, returns: &[serde_json::Value]) -> Res
 
 /// Convert graph-node `name(inputs):(outputs)` to alloy `name(inputs) returns (outputs)`.
 /// Passes through signatures already in alloy format or without outputs.
-fn to_alloy_signature(sig: &str) -> String {
+pub(super) fn to_alloy_signature(sig: &str) -> String {
     // If it already contains "returns", assume alloy format.
     if sig.contains(" returns ") {
         return sig.to_string();
@@ -108,49 +101,6 @@ fn to_alloy_signature(sig: &str) -> String {
     }
 }
 
-/// Populate the eth_call cache from test block mock calls before indexing starts.
-pub async fn populate_eth_call_cache(
-    logger: &Logger,
-    chain_store: Arc<ChainStore>,
-    blocks: &[BlockWithTriggers<Chain>],
-    test_file: &TestFile,
-) -> Result<()> {
-    for (block_data, test_block) in blocks.iter().zip(&test_file.blocks) {
-        let block_ptr = block_data.ptr();
-
-        for eth_call in &test_block.eth_calls {
-            populate_single_call(logger, chain_store.clone(), &block_ptr, eth_call).await?;
-        }
-    }
-    Ok(())
-}
-
-async fn populate_single_call(
-    logger: &Logger,
-    chain_store: Arc<ChainStore>,
-    block_ptr: &BlockPtr,
-    eth_call: &MockEthCall,
-) -> Result<()> {
-    let address: Address = eth_call.address.parse()?;
-
-    let encoded_call = encode_function_call(&eth_call.function, &eth_call.params)?;
-
-    let request = call::Request::new(address, encoded_call, 0);
-
-    let retval = if eth_call.reverts {
-        call::Retval::Null
-    } else {
-        let encoded_return = encode_return_value(&eth_call.function, &eth_call.returns)?;
-        call::Retval::Value(encoded_return.into())
-    };
-
-    chain_store
-        .set_call(logger, request, block_ptr.clone(), retval)
-        .await?;
-
-    Ok(())
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

gnd/src/commands/test/eth_calls.rs

@@ -0,0 +1,77 @@
+//! Wraps Ethereum host functions to convert `PossibleReorg` errors into
+//! `Deterministic` ones so they surface immediately instead of causing
+//! infinite restart loops.
+
+use anyhow::anyhow;
+use graph::blockchain::{self, ChainIdentifier, HostFn, HostFnCtx};
+use graph::data_source;
+use graph::futures03::FutureExt;
+use graph::prelude::EthereumCallCache;
+use graph::runtime::HostExportError;
+use graph_chain_ethereum::chain::{EthereumRuntimeAdapterBuilder, RuntimeAdapterBuilder};
+use graph_chain_ethereum::network::EthereumNetworkAdapters;
+use graph_chain_ethereum::Chain;
+use std::sync::Arc;
+
+const WRAPPED_HOST_FNS: &[&str] = &["ethereum.call", "ethereum.getBalance", "ethereum.hasCode"];
+
+pub struct TestRuntimeAdapterBuilder;
+
+impl RuntimeAdapterBuilder for TestRuntimeAdapterBuilder {
+    fn build(
+        &self,
+        eth_adapters: Arc<EthereumNetworkAdapters>,
+        call_cache: Arc<dyn EthereumCallCache>,
+        chain_identifier: Arc<ChainIdentifier>,
+    ) -> Arc<dyn blockchain::RuntimeAdapter<Chain>> {
+        let real_adapter =
+            EthereumRuntimeAdapterBuilder {}.build(eth_adapters, call_cache, chain_identifier);
+        Arc::new(TestRuntimeAdapter { real_adapter })
+    }
+}
+
+struct TestRuntimeAdapter {
+    real_adapter: Arc<dyn blockchain::RuntimeAdapter<Chain>>,
+}
+
+impl TestRuntimeAdapter {
+    /// Convert `PossibleReorg` → `Deterministic` for a single host function.
+    fn wrap_possible_reorg(real: HostFn) -> HostFn {
+        let real_func = real.func.clone();
+        let name = real.name;
+        HostFn {
+            name,
+            func: Arc::new(move |ctx: HostFnCtx<'_>, wasm_ptr: u32| {
+                let real_func = real_func.clone();
+                async move {
+                    match real_func(ctx, wasm_ptr).await {
+                        Ok(result) => Ok(result),
+                        Err(HostExportError::PossibleReorg(e)) => {
+                            Err(HostExportError::Deterministic(anyhow!(
+                                "{}. Add mock data to your test JSON.",
+                                e
+                            )))
+                        }
+                        Err(other) => Err(other),
+                    }
+                }
+                .boxed()
+            }),
+        }
+    }
+}
+
+impl blockchain::RuntimeAdapter<Chain> for TestRuntimeAdapter {
+    fn host_fns(&self, ds: &data_source::DataSource<Chain>) -> Result<Vec<HostFn>, anyhow::Error> {
+        let mut fns = self.real_adapter.host_fns(ds)?;
+
+        // PossibleReorg → Deterministic for mock-backed host functions.
+        for hf in &mut fns {
+            if WRAPPED_HOST_FNS.contains(&hf.name) {
+                *hf = Self::wrap_possible_reorg(hf.clone());
+            }
+        }
+
+        Ok(fns)
+    }
+}