feat(rpc): wire Parity trace namespace into router

Creates trace/mod.rs with the router constructor and wires it into
the combined router. Fixes HashSet type mismatch (std to alloy) and
removes erroneous accept_state() call on already-needs-tx state.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: prestwich

crates/rpc/src/lib.rs

@@ -25,6 +25,9 @@ pub use interest::{ChainEvent, NewBlockNotification, RemovedBlock, ReorgNotifica
 mod debug;
 pub use debug::DebugError;
 
+mod trace;
+pub use trace::TraceError;
+
 mod signet;
 pub use signet::error::SignetError;
 
@@ -34,8 +37,8 @@ mod web3;
 pub mod serve;
 pub use serve::{RpcServerGuard, ServeConfig, ServeConfigEnv, ServeError};
 
-/// Instantiate a combined router with `eth`, `debug`, `signet`, `web3`, and
-/// `net` namespaces.
+/// Instantiate a combined router with `eth`, `debug`, `trace`, `signet`,
+/// `web3`, and `net` namespaces.
 pub fn router<H>() -> ajj::Router<StorageRpcCtx<H>>
 where
     H: signet_hot::HotKv + Send + Sync + 'static,
@@ -44,6 +47,7 @@ where
     ajj::Router::new()
         .nest("eth", eth::eth())
         .nest("debug", debug::debug())
+        .nest("trace", trace::trace())
         .nest("signet", signet::signet())
         .nest("web3", web3::web3())
         .nest("net", net::net())

crates/rpc/src/trace/endpoints.rs

@@ -16,7 +16,7 @@ use ajj::HandlerCtx;
 use alloy::{
     consensus::BlockHeader,
     eips::BlockId,
-    primitives::{B256, Bytes, map::HashSet},
+    primitives::{B256, map::HashSet},
     rpc::types::trace::parity::{
         LocalizedTransactionTrace, TraceResults, TraceResultsWithTransactionHash, TraceType,
     },
@@ -286,9 +286,8 @@ where
             TraceError::Resolve(e)
         })?;
 
-        let sealed = ctx
-            .resolve_header(BlockId::Number(block_num.into()))
-            .map_err(|e| TraceError::Resolve(e))?;
+        let sealed =
+            ctx.resolve_header(BlockId::Number(block_num.into())).map_err(TraceError::Resolve)?;
 
         let Some(sealed) = sealed else {
             return Ok(None);
@@ -349,7 +348,7 @@ where
         let block_num = meta.block_number();
 
         let block_id = BlockId::Number(block_num.into());
-        let sealed = ctx.resolve_header(block_id).map_err(|e| TraceError::Resolve(e))?;
+        let sealed = ctx.resolve_header(block_id).map_err(TraceError::Resolve)?;
         let header = sealed.ok_or(TraceError::BlockNotFound(block_id))?.into_inner();
 
         let txs = cold.get_transactions_in_block(block_num).await.map_err(TraceError::from)?;
@@ -467,12 +466,11 @@ where
 
         for (request, trace_types) in calls {
             let filled = trevm.fill_tx(&request);
-            let (trace_res, next) =
-                crate::debug::tracer::trace_parity_replay(filled, &trace_types)
-                    .map_err(|e| TraceError::EvmHalt { reason: e.to_string() })?;
+            let (trace_res, next) = crate::debug::tracer::trace_parity_replay(filled, &trace_types)
+                .map_err(|e| TraceError::EvmHalt { reason: e.to_string() })?;
 
             results.push(trace_res);
-            trevm = next.accept_state();
+            trevm = next;
         }
 
         Ok(results)
@@ -506,8 +504,7 @@ where
         let tx: signet_storage_types::TransactionSigned =
             alloy::rlp::Decodable::decode(&mut rlp_bytes.as_ref())
                 .map_err(|e| TraceError::RlpDecode(e.to_string()))?;
-        let recovered =
-            tx.try_into_recovered().map_err(|_| TraceError::SenderRecovery)?;
+        let recovered = tx.try_into_recovered().map_err(|_| TraceError::SenderRecovery)?;
 
         let EvmBlockContext { header, db, spec_id } =
             ctx.resolve_evm_block(id).map_err(|e| match e {
@@ -517,10 +514,8 @@ where
 
         let mut evm = signet_evm::signet_evm(db, ctx.constants().clone());
         evm.set_spec_id(spec_id);
-        let trevm = evm
-            .fill_cfg(&CfgFiller(ctx.chain_id()))
-            .fill_block(&header)
-            .fill_tx(&recovered);
+        let trevm =
+            evm.fill_cfg(&CfgFiller(ctx.chain_id())).fill_block(&header).fill_tx(&recovered);
 
         let (results, _) = crate::debug::tracer::trace_parity_replay(trevm, &trace_types)
             .map_err(|e| TraceError::EvmHalt { reason: e.to_string() })?;
@@ -600,9 +595,7 @@ where
             let cold = ctx.cold();
             let block_id = BlockId::Number(block_num.into());
 
-            let sealed = ctx
-                .resolve_header(block_id)
-                .map_err(TraceError::Resolve)?;
+            let sealed = ctx.resolve_header(block_id).map_err(TraceError::Resolve)?;
 
             let Some(sealed) = sealed else {
                 continue;
@@ -611,10 +604,7 @@ where
             let block_hash = sealed.hash();
             let header = sealed.into_inner();
 
-            let txs = cold
-                .get_transactions_in_block(block_num)
-                .await
-                .map_err(TraceError::from)?;
+            let txs = cold.get_transactions_in_block(block_num).await.map_err(TraceError::from)?;
 
             let db = ctx
                 .revm_state_at_height(header.number.saturating_sub(1))

crates/rpc/src/trace/mod.rs

@@ -0,0 +1,32 @@
+//! Parity `trace` namespace RPC router backed by storage.
+
+mod endpoints;
+use endpoints::{
+    replay_block_transactions, replay_transaction, trace_block, trace_call, trace_call_many,
+    trace_filter, trace_get, trace_raw_transaction, trace_transaction,
+};
+mod error;
+pub use error::TraceError;
+mod types;
+
+use crate::config::StorageRpcCtx;
+use signet_hot::{HotKv, model::HotKvRead};
+use trevm::revm::database::DBErrorMarker;
+
+/// Instantiate a `trace` API router backed by storage.
+pub(crate) fn trace<H>() -> ajj::Router<StorageRpcCtx<H>>
+where
+    H: HotKv + Send + Sync + 'static,
+    <H::RoTx as HotKvRead>::Error: DBErrorMarker,
+{
+    ajj::Router::new()
+        .route("block", trace_block::<H>)
+        .route("transaction", trace_transaction::<H>)
+        .route("replayBlockTransactions", replay_block_transactions::<H>)
+        .route("replayTransaction", replay_transaction::<H>)
+        .route("call", trace_call::<H>)
+        .route("callMany", trace_call_many::<H>)
+        .route("rawTransaction", trace_raw_transaction::<H>)
+        .route("get", trace_get::<H>)
+        .route("filter", trace_filter::<H>)
+}

crates/rpc/src/trace/types.rs

@@ -2,14 +2,13 @@
 
 use alloy::{
     eips::BlockId,
-    primitives::{Bytes, B256},
+    primitives::{B256, Bytes, map::HashSet},
     rpc::types::{
-        state::StateOverride, BlockNumberOrTag, BlockOverrides,
-        TransactionRequest,
+        BlockNumberOrTag, BlockOverrides, TransactionRequest,
+        state::StateOverride,
         trace::{filter::TraceFilter, parity::TraceType},
     },
 };
-use std::collections::HashSet;
 
 /// Params for `trace_block`.
 #[derive(Debug, serde::Deserialize)]
@@ -21,54 +20,40 @@ pub(crate) struct TraceTransactionParams(pub(crate) B256);
 
 /// Params for `trace_replayBlockTransactions`.
 #[derive(Debug, serde::Deserialize)]
-pub(crate) struct ReplayBlockParams(
-    pub(crate) BlockNumberOrTag,
-    pub(crate) HashSet<TraceType>,
-);
+pub(crate) struct ReplayBlockParams(pub(crate) BlockNumberOrTag, pub(crate) HashSet<TraceType>);
 
 /// Params for `trace_replayTransaction`.
 #[derive(Debug, serde::Deserialize)]
-pub(crate) struct ReplayTransactionParams(
-    pub(crate) B256,
-    pub(crate) HashSet<TraceType>,
-);
+pub(crate) struct ReplayTransactionParams(pub(crate) B256, pub(crate) HashSet<TraceType>);
 
 /// Params for `trace_call`.
 #[derive(Debug, serde::Deserialize)]
 pub(crate) struct TraceCallParams(
     pub(crate) TransactionRequest,
     pub(crate) HashSet<TraceType>,
-    #[serde(default)]
-    pub(crate) Option<BlockId>,
-    #[serde(default)]
-    pub(crate) Option<StateOverride>,
-    #[serde(default)]
-    pub(crate) Option<Box<BlockOverrides>>,
+    #[serde(default)] pub(crate) Option<BlockId>,
+    #[serde(default)] pub(crate) Option<StateOverride>,
+    #[serde(default)] pub(crate) Option<Box<BlockOverrides>>,
 );
 
 /// Params for `trace_callMany`.
 #[derive(Debug, serde::Deserialize)]
 pub(crate) struct TraceCallManyParams(
     pub(crate) Vec<(TransactionRequest, HashSet<TraceType>)>,
-    #[serde(default)]
-    pub(crate) Option<BlockId>,
+    #[serde(default)] pub(crate) Option<BlockId>,
 );
 
 /// Params for `trace_rawTransaction`.
 #[derive(Debug, serde::Deserialize)]
 pub(crate) struct TraceRawTransactionParams(
     pub(crate) Bytes,
     pub(crate) HashSet<TraceType>,
-    #[serde(default)]
-    pub(crate) Option<BlockId>,
+    #[serde(default)] pub(crate) Option<BlockId>,
 );
 
 /// Params for `trace_get`.
 #[derive(Debug, serde::Deserialize)]
-pub(crate) struct TraceGetParams(
-    pub(crate) B256,
-    pub(crate) Vec<usize>,
-);
+pub(crate) struct TraceGetParams(pub(crate) B256, pub(crate) Vec<usize>);
 
 /// Params for `trace_filter`.
 #[derive(Debug, serde::Deserialize)]