Reduce clones and cleanup in block cache path (#6431)

* node: Migrate check_blocks to use typed blocks()

Use the typed `blocks()` method instead of `blocks_as_json()` so that
block comparisons go through the same alloy serialization on both the
cached and provider sides. This gives a fairer diff by normalizing
both blocks through the same types, and only compares the block data
(without receipts) since `eth_getBlockByHash` does not return receipts.

* graph, store: Remove blocks_as_json from ChainStore trait

All callers now use the typed `blocks()` method. The resolver serializes
the CachedBlock to JSON at the GraphQL boundary. This eliminates the
separate raw-JSON code path from the trait.

* graph: Wrap LightEthereumBlock in Arc inside CachedBlock

Arc-wrap the Light variant to avoid expensive deep clones of AnyBlock.
into_light_block now borrows self and returns Arc via cheap refcount bumps.

* graph: Inline EthereumJsonBlock into CachedBlock::from_json

Remove the single-consumer EthereumJsonBlock wrapper and inline its
deserialization and patching logic directly into CachedBlock::from_json.

* graph: Rename to_light_block, add to_json on CachedBlock

Author: incrypto32

chain/ethereum/src/ethereum_adapter.rs

@@ -1639,8 +1639,8 @@ impl EthereumAdapterTrait for EthereumAdapter {
             .await
             .map_err(|e| error!(&logger, "Error accessing block cache {}", e))
             .unwrap_or_default()
-            .into_iter()
-            .map(CachedBlock::into_light_block)
+            .iter()
+            .map(|b| b.to_light_block())
             .collect();
 
         let missing_blocks = Vec::from_iter(

graph/src/blockchain/mock.rs

@@ -21,7 +21,6 @@ use alloy::primitives::{B256, U256};
 use anyhow::{Error, Result};
 use async_trait::async_trait;
 use serde::Deserialize;
-use serde_json::Value;
 use slog::Logger;
 use std::{
     collections::{BTreeMap, BTreeSet, HashMap, HashSet},
@@ -531,9 +530,6 @@ impl ChainStore for MockChainStore {
     async fn blocks(self: Arc<Self>, _hashes: Vec<BlockHash>) -> Result<Vec<CachedBlock>, Error> {
         unimplemented!()
     }
-    async fn blocks_as_json(self: Arc<Self>, _hashes: Vec<BlockHash>) -> Result<Vec<Value>, Error> {
-        unimplemented!()
-    }
     async fn ancestor_block(
         self: Arc<Self>,
         _block_ptr: BlockPtr,

graph/src/components/ethereum/json_block.rs

@@ -1,9 +1,7 @@
-pub mod json_block;
 pub mod json_patch;
 mod network;
 mod types;
 
-pub use self::json_block::EthereumJsonBlock;
 pub use self::network::AnyNetworkBare;
 pub use self::types::{
     AnyBlock, AnyTransaction, AnyTransactionReceiptBare, CachedBlock, EthereumBlock,

graph/src/components/ethereum/mod.rs

@@ -17,7 +17,7 @@ use crate::{
     prelude::BlockNumber,
 };
 
-use super::json_block::EthereumJsonBlock;
+use super::json_patch;
 
 pub type AnyTransaction = Transaction<AnyTxEnvelope>;
 pub type AnyBlock = Block<AnyTransaction, Header<AnyHeader>>;
@@ -265,10 +265,9 @@ impl<'a> From<&'a EthereumCall> for BlockPtr {
 /// Typed cached block for Ethereum. Stores the deserialized block so that
 /// repeated reads from the in-memory cache avoid `serde_json::from_value()`.
 #[derive(Clone, Debug)]
-#[allow(clippy::large_enum_variant)]
 pub enum CachedBlock {
     Full(EthereumBlock),
-    Light(LightEthereumBlock),
+    Light(Arc<LightEthereumBlock>),
 }
 
 impl CachedBlock {
@@ -279,10 +278,10 @@ impl CachedBlock {
         }
     }
 
-    pub fn into_light_block(self) -> Arc<LightEthereumBlock> {
+    pub fn to_light_block(&self) -> Arc<LightEthereumBlock> {
         match self {
-            CachedBlock::Full(block) => block.block,
-            CachedBlock::Light(block) => Arc::new(block),
+            CachedBlock::Full(block) => block.block.clone(),
+            CachedBlock::Light(block) => block.clone(),
         }
     }
 
@@ -293,12 +292,51 @@ impl CachedBlock {
         }
     }
 
-    pub fn from_json(value: serde_json::Value) -> Option<Self> {
-        let json_block = EthereumJsonBlock::new(value);
-        if json_block.is_shallow() {
+    /// Serializes the block data directly. Note: the output shape differs
+    /// from the store format (which wraps in a `{"block": ..}` envelope).
+    pub fn to_json(&self) -> serde_json::Result<serde_json::Value> {
+        match self {
+            CachedBlock::Full(b) => serde_json::to_value(b),
+            CachedBlock::Light(b) => serde_json::to_value(b),
+        }
+    }
+
+    /// Deserializes a JSON block from the store into a typed `CachedBlock`.
+    /// Returns `None` for shallow (header-only) blocks.
+    ///
+    /// Patches missing `type` fields in transactions/receipts before
+    /// deserialization for compatibility with blocks cached by older
+    /// graph-node versions.
+    pub fn from_json(mut value: serde_json::Value) -> Option<Self> {
+        // Shallow blocks have no body, only a null `data` field.
+        if value.get("data") == Some(&serde_json::Value::Null) {
             return None;
         }
-        json_block.try_into_cached_block()
+
+        let has_receipts = value
+            .get("transaction_receipts")
+            .is_some_and(|v| !v.is_null());
+
+        if has_receipts {
+            // Full block: patch in place then deserialize the entire value.
+            if let Some(block) = value.get_mut("block") {
+                json_patch::patch_block_transactions(block);
+            }
+            if let Some(receipts) = value.get_mut("transaction_receipts") {
+                json_patch::patch_receipts(receipts);
+            }
+            serde_json::from_value(value).ok().map(CachedBlock::Full)
+        } else {
+            // Light block: extract the inner `block` field, patch, and deserialize.
+            let mut inner = value
+                .as_object_mut()
+                .and_then(|obj| obj.remove("block"))
+                .unwrap_or(value);
+            json_patch::patch_block_transactions(&mut inner);
+            serde_json::from_value(inner)
+                .ok()
+                .map(|b| CachedBlock::Light(Arc::new(b)))
+        }
     }
 
     pub fn timestamp(&self) -> Option<u64> {

graph/src/components/ethereum/types.rs

@@ -560,13 +560,6 @@ pub trait ChainStore: ChainHeadStore {
     /// Returns the blocks present in the store as typed cached blocks.
     async fn blocks(self: Arc<Self>, hashes: Vec<BlockHash>) -> Result<Vec<CachedBlock>, Error>;
 
-    /// Returns blocks as raw JSON. Used by callers that need the original
-    /// JSON representation (e.g., GraphQL block queries, CLI tools).
-    async fn blocks_as_json(
-        self: Arc<Self>,
-        hashes: Vec<BlockHash>,
-    ) -> Result<Vec<serde_json::Value>, Error>;
-
     /// Returns the blocks present in the store for the given block numbers.
     async fn block_ptrs_by_numbers(
         self: Arc<Self>,

graph/src/components/store/traits.rs

@@ -2,7 +2,10 @@ use crate::manager::prompt::prompt_for_confirmation;
 use graph::{
     anyhow::{bail, ensure},
     cheap_clone::CheapClone,
-    components::store::ChainStore as ChainStoreTrait,
+    components::{
+        ethereum::{CachedBlock, LightEthereumBlock},
+        store::ChainStore as ChainStoreTrait,
+    },
     prelude::{
         alloy::primitives::B256,
         anyhow::{self, anyhow, Context},
@@ -114,7 +117,7 @@ async fn run(
         steps::fetch_single_cached_block(*block_hash, chain_store.cheap_clone()).await?;
     let provider_block =
         steps::fetch_single_provider_block(block_hash, ethereum_adapter, logger).await?;
-    let diff = steps::diff_block_pair(&cached_block, &provider_block);
+    let diff = steps::diff_block_pair(&cached_block, &provider_block)?;
     steps::report_difference(diff.as_deref(), block_hash);
     if diff.is_some() {
         steps::delete_block(block_hash, &chain_store).await?;
@@ -186,43 +189,55 @@ mod steps {
     pub(super) async fn fetch_single_cached_block(
         block_hash: B256,
         chain_store: Arc<ChainStore>,
-    ) -> anyhow::Result<Value> {
-        let blocks = chain_store.blocks_as_json(vec![block_hash.into()]).await?;
+    ) -> anyhow::Result<CachedBlock> {
+        let mut blocks = chain_store.blocks(vec![block_hash.into()]).await?;
         match blocks.len() {
             0 => bail!("Failed to locate block with hash {} in store", block_hash),
-            1 => {}
+            1 => Ok(blocks.pop().unwrap()),
             _ => bail!("Found multiple blocks with hash {} in store", block_hash),
-        };
-        // Unwrap: We just checked that the vector has a single element
-        Ok(blocks.into_iter().next().unwrap())
+        }
     }
 
-    /// Fetches a block from a JRPC endpoint.
+    /// Fetches a block from an RPC endpoint.
     ///
     /// Errors on provider failure or if the returned block has a different hash than the one
     /// requested.
     pub(super) async fn fetch_single_provider_block(
         block_hash: &B256,
         ethereum_adapter: &EthereumAdapter,
         logger: &Logger,
-    ) -> anyhow::Result<Value> {
+    ) -> anyhow::Result<LightEthereumBlock> {
         let provider_block = ethereum_adapter
             .block_by_hash(logger, *block_hash)
             .await
             .with_context(|| format!("failed to fetch block {block_hash}"))?
-            .ok_or_else(|| anyhow!("JRPC provider found no block with hash {block_hash:?}"))?;
+            .ok_or_else(|| anyhow!("RPC provider found no block with hash {block_hash:?}"))?;
         ensure!(
             provider_block.header.hash == *block_hash,
             "Provider responded with a different block hash"
         );
-        serde_json::to_value(provider_block)
-            .context("failed to parse provider block as a JSON value")
+        Ok(LightEthereumBlock::new(provider_block))
     }
 
-    /// Compares two [`serde_json::Value`] values.
+    /// Compares a cached block against a provider block.
     ///
+    /// Only compares the block data (without receipts) since the provider's
+    /// `eth_getBlockByHash` does not return receipts. Both sides are serialized
+    /// through the same alloy types for a fair comparison.
     /// If they are different, returns a user-friendly string ready to be displayed.
-    pub(super) fn diff_block_pair(a: &Value, b: &Value) -> Option<String> {
+    pub(super) fn diff_block_pair(
+        cached: &CachedBlock,
+        provider: &LightEthereumBlock,
+    ) -> anyhow::Result<Option<String>> {
+        let cached_json = serde_json::to_value(cached.light_block())
+            .context("failed to serialize cached block")?;
+        let provider_json =
+            serde_json::to_value(provider).context("failed to serialize provider block")?;
+
+        Ok(diff_json(&cached_json, &provider_json))
+    }
+
+    fn diff_json(a: &Value, b: &Value) -> Option<String> {
         if a == b {
             None
         } else {

node/src/manager/commands/check_blocks.rs

@@ -222,9 +222,7 @@ where
             return Ok(r::Value::Null);
         };
 
-        let blocks_res = chain_store
-            .blocks_as_json(vec![block_hash.cheap_clone()])
-            .await;
+        let blocks_res = chain_store.blocks(vec![block_hash.cheap_clone()]).await;
         Ok(match blocks_res {
             Ok(blocks) if blocks.is_empty() => {
                 error!(
@@ -237,7 +235,21 @@ where
             }
             Ok(mut blocks) => {
                 assert!(blocks.len() == 1, "Multiple blocks with the same hash");
-                blocks.pop().unwrap().into()
+                let block = blocks.pop().unwrap();
+                let json = block.to_json();
+                match json {
+                    Ok(json) => json.into(),
+                    Err(e) => {
+                        error!(
+                            self.logger,
+                            "Failed to serialize cached block";
+                            "network" => network.as_str(),
+                            "block_hash" => format!("{}", block_hash),
+                            "error" => e.to_string(),
+                        );
+                        r::Value::Null
+                    }
+                }
             }
             Err(e) => {
                 error!(

server/index-node/src/resolver.rs

@@ -2852,19 +2852,6 @@ impl ChainStoreTrait for ChainStore {
         Ok(result)
     }
 
-    async fn blocks_as_json(
-        self: Arc<Self>,
-        hashes: Vec<BlockHash>,
-    ) -> Result<Vec<json::Value>, Error> {
-        let values = self
-            .blocks_from_store(hashes)
-            .await?
-            .into_iter()
-            .filter_map(|block| block.data)
-            .collect();
-        Ok(values)
-    }
-
     async fn ancestor_block(
         self: Arc<Self>,
         block_ptr: BlockPtr,