feat(anvil): add debug_getRawHeader

Expose canonical RLP-encoded block headers for proof witness construction.

Co-authored-by: Amp <amp@ampcode.com>
Amp-Thread-ID: https://ampcode.com/threads/T-019ff1b0-c07c-77f3-816c-5da33175c7a4

Author: PelleKrab

crates/anvil/core/src/eth/mod.rs

@@ -290,6 +290,10 @@ pub enum EthRequest {
     #[serde(rename = "debug_getRawTransaction", with = "sequence")]
     DebugGetRawTransaction(TxHash),
 
+    /// geth's `debug_getRawHeader` endpoint
+    #[serde(rename = "debug_getRawHeader", with = "sequence")]
+    DebugGetRawHeader(BlockId),
+
     /// geth's `debug_traceTransaction`  endpoint
     #[serde(rename = "debug_traceTransaction")]
     DebugTraceTransaction(B256, #[serde(default)] GethDebugTracingOptions),

crates/anvil/src/eth/api.rs

@@ -330,6 +330,7 @@ impl EthApi {
             EthRequest::DebugGetRawTransaction(hash) => {
                 self.raw_transaction(hash).await.to_rpc_result()
             }
+            EthRequest::DebugGetRawHeader(block) => self.raw_header(block).to_rpc_result(),
             // non eth-standard rpc calls
             EthRequest::DebugTraceTransaction(tx, opts) => {
                 self.debug_trace_transaction(tx, opts).await.to_rpc_result()
@@ -1578,6 +1579,12 @@ impl EthApi {
         self.backend.block_receipts(number).await
     }
 
+    /// Returns the canonical RLP encoding of a block header.
+    pub fn raw_header(&self, block: BlockId) -> Result<Option<Bytes>> {
+        node_info!("debug_getRawHeader");
+        Ok(self.backend.get_block(block).map(|block| alloy_rlp::encode(&block.header).into()))
+    }
+
     /// Returns an uncles at given block and index.
     ///
     /// Handler for ETH RPC call: `eth_getUncleByBlockHashAndIndex`

crates/anvil/tests/it/beacon_api.rs

@@ -1,13 +1,17 @@
 use crate::utils::http_provider;
-use alloy_consensus::{Blob, BlobTransactionSidecar, SidecarBuilder, SimpleCoder, Transaction};
+use alloy_consensus::{
+    Blob, BlobTransactionSidecar, Header, SidecarBuilder, SimpleCoder, Transaction,
+};
 use alloy_network::{TransactionBuilder, TransactionBuilder4844};
-use alloy_primitives::{B256, FixedBytes, U256, b256};
+use alloy_primitives::{B256, Bytes, FixedBytes, U256, b256};
 use alloy_provider::Provider;
-use alloy_rpc_types::TransactionRequest;
+use alloy_rlp::Decodable;
+use alloy_rpc_types::{BlockNumberOrTag, TransactionRequest};
 use alloy_rpc_types_beacon::{genesis::GenesisResponse, sidecar::GetBlobsResponse};
 use alloy_serde::WithOtherFields;
 use anvil::{NodeConfig, spawn};
 use foundry_evm::hardfork::EthereumHardfork;
+use serde_json::json;
 use ssz::Decode;
 
 #[tokio::test(flavor = "multi_thread")]
@@ -258,3 +262,44 @@ async fn test_beacon_api_get_genesis() {
         FixedBytes::from([0x00, 0x00, 0x00, 0x00])
     );
 }
+
+#[tokio::test(flavor = "multi_thread")]
+async fn test_debug_get_raw_header() {
+    let (_api, handle) = spawn(NodeConfig::test()).await;
+    let provider = http_provider(&handle.http_endpoint());
+    let block = provider.get_block_by_number(BlockNumberOrTag::Latest).await.unwrap().unwrap();
+    let raw_header_response: serde_json::Value = reqwest::Client::new()
+        .post(handle.http_endpoint())
+        .json(&json!({
+            "jsonrpc": "2.0",
+            "id": 1,
+            "method": "debug_getRawHeader",
+            "params": ["latest"]
+        }))
+        .send()
+        .await
+        .unwrap()
+        .json()
+        .await
+        .unwrap();
+    let raw_header: Bytes = serde_json::from_value(raw_header_response["result"].clone()).unwrap();
+    let header = Header::decode(&mut raw_header.as_ref()).unwrap();
+
+    assert_eq!(header.hash_slow(), block.header.hash);
+
+    let unavailable_response: serde_json::Value = reqwest::Client::new()
+        .post(handle.http_endpoint())
+        .json(&json!({
+            "jsonrpc": "2.0",
+            "id": 1,
+            "method": "debug_getRawHeader",
+            "params": ["0xffffff"]
+        }))
+        .send()
+        .await
+        .unwrap()
+        .json()
+        .await
+        .unwrap();
+    assert!(unavailable_response["result"].is_null());
+}