refactor: address PR #75 review — spec_id fix, move serve.rs, load RPC config

Fix EVM spec_id for RPC calls: all EVM execution paths (eth_call,
eth_estimateGas, eth_createAccessList, debug tracing, bundle simulation)
now derive the correct SpecId from chain config + block header instead of
defaulting to PRAGUE.

Move serve.rs from signet-node to signet-rpc: transport infrastructure
(HTTP/WS/IPC) is now reth-free, using tokio::spawn and Handle::current()
instead of reth's TaskExecutor. This removes axum, tower-http, interprocess,
and ajj dependencies from signet-node.

Load StorageRpcConfig from host RpcServerArgs: rpc_gas_cap,
max_tracing_requests, and gas price oracle settings now flow through from
reth's CLI args instead of always using defaults.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: prestwich

FUTURE_WORK.md

@@ -0,0 +1,48 @@
+# Future Work: signet-rpc Architectural Improvements
+
+Deferred from PR #75 review. These should be follow-up PRs after the initial fixes land.
+
+---
+
+## Structured JSON-RPC Error Codes
+
+**Problem**: Most endpoints return `Result<T, String>`, losing structured error info. All errors become `-32603 Internal error`. Clients can't programmatically distinguish error types.
+
+**Approach**:
+- Add error code constants to `eth/error.rs`: `-32000` (server error), `-32001` (resource not found), `3` (execution reverted)
+- Add `Into<ErrorPayload>` impl on `EthError` that maps variants to codes
+- Construct `ErrorPayload` directly with custom codes (all fields are `pub` in ajj 0.6)
+- Progressively migrate endpoints from `Result<T, String>` to `ResponsePayload<T, EthError>`
+- Start with EVM execution endpoints (call/estimate/accessList), then query endpoints
+
+**Files**: `crates/rpc/src/eth/error.rs`, `crates/rpc/src/eth/endpoints.rs`, `crates/rpc/src/debug/error.rs`, `crates/rpc/src/signet/error.rs`
+
+---
+
+## Reorg Tracking in Filter/Subscription Managers
+
+**Problem**: No mechanism to notify RPC layer about reorgs. Filters/subscriptions can't emit `removed: true` logs per Ethereum spec.
+
+**Approach**:
+- Add `ReorgNotification { common_ancestor: u64, removed_hashes: Vec<B256> }` type
+- Create `ChainEvent` enum wrapping `NewBlock` and `Reorg` variants
+- Change `ChainNotifier` broadcast channel from `NewBlockNotification` to `ChainEvent`
+- Node sends `ChainEvent::Reorg` during `on_host_revert()` before updating block tags
+- `SubscriptionTask` handles `ChainEvent::Reorg` by emitting logs with `removed: true`
+- `get_filter_changes` detects `latest < next_start_block` as reorg indicator, resets filter
+
+**Files**: `crates/rpc/src/interest/mod.rs`, `crates/rpc/src/config/chain_notifier.rs`, `crates/rpc/src/interest/subs.rs`, `crates/rpc/src/interest/filters.rs`, `crates/rpc/src/eth/endpoints.rs`, `crates/node/src/node.rs`
+
+---
+
+## Best-Effort Read Consistency
+
+**Problem**: RPC reads can span hot and cold storage at different points in time. Reorgs can make resolved block numbers stale between hot and cold queries.
+
+**Approach**:
+- Document the consistency model in `StorageRpcCtx` rustdoc
+- Verify all cold queries use explicitly-resolved block numbers (already mostly the pattern)
+- Detect reorg-induced staleness in `get_filter_changes` (coupled with reorg tracking above)
+- Consider hash-based verification: resolve number from hot, fetch header hash, pass hash to cold for consistency check
+
+**Files**: `crates/rpc/src/config/ctx.rs` (documentation), `crates/rpc/src/eth/endpoints.rs` (filter changes)

crates/node/Cargo.toml

@@ -23,10 +23,7 @@ signet-blobber.workspace = true
 signet-tx-cache.workspace = true
 signet-types.workspace = true
 
-ajj.workspace = true
 alloy.workspace = true
-axum = "0.8.1"
-interprocess = { version = "2.2.2", features = ["tokio"] }
 
 reth.workspace = true
 reth-exex.workspace = true
@@ -39,5 +36,4 @@ futures-util.workspace = true
 metrics.workspace = true
 reqwest.workspace = true
 tokio.workspace = true
-tower-http = { version = "0.6.2", features = ["cors"] }
 tracing.workspace = true

crates/node/src/lib.rs

@@ -21,7 +21,5 @@ pub use node::SignetNode;
 
 mod rpc;
 
-mod serve;
-
 mod status;
 pub use status::NodeStatus;

crates/node/src/node.rs

@@ -1,4 +1,4 @@
-use crate::{NodeStatus, metrics, serve::RpcServerGuard};
+use crate::{NodeStatus, metrics};
 use alloy::consensus::BlockHeader;
 use eyre::Context;
 use futures_util::StreamExt;
@@ -14,7 +14,7 @@ use signet_block_processor::{AliasOracleFactory, SignetBlockProcessorV1};
 use signet_evm::EthereumHardfork;
 use signet_extract::Extractor;
 use signet_node_config::SignetNodeConfig;
-use signet_rpc::{ChainNotifier, NewBlockNotification};
+use signet_rpc::{ChainNotifier, NewBlockNotification, RpcServerGuard};
 use signet_storage::{HistoryRead, HotKv, HotKvRead, UnifiedStorage};
 use signet_types::{PairedHeights, constants::SignetSystemConstants};
 use std::{fmt, sync::Arc};

crates/node/src/rpc.rs

@@ -1,14 +1,11 @@
-use crate::{
-    SignetNode,
-    serve::{RpcServerGuard, ServeConfig},
-};
-use reth::primitives::EthPrimitives;
+use crate::SignetNode;
+use reth::{args::RpcServerArgs, primitives::EthPrimitives};
 use reth_node_api::{FullNodeComponents, NodeTypes};
 use signet_block_processor::AliasOracleFactory;
-use signet_rpc::{StorageRpcConfig, StorageRpcCtx};
+use signet_rpc::{RpcServerGuard, ServeConfig, StorageRpcConfig, StorageRpcCtx};
 use signet_storage::HotKv;
 use signet_tx_cache::TxCache;
-use std::sync::Arc;
+use std::{net::SocketAddr, sync::Arc};
 use tracing::info;
 
 impl<Host, H, AliasOracle> SignetNode<Host, H, AliasOracle>
@@ -28,18 +25,48 @@ where
     }
 
     async fn launch_rpc(&self) -> eyre::Result<RpcServerGuard> {
-        let tasks = self.host.task_executor();
         let tx_cache =
             self.config.forward_url().map(|url| TxCache::new_with_client(url, self.client.clone()));
+
+        let args = self.config.merge_rpc_configs(&self.host)?;
+        let rpc_config = rpc_config_from_args(&args);
+
         let rpc_ctx = StorageRpcCtx::new(
             Arc::clone(&self.storage),
             self.constants.clone(),
+            self.config.genesis().config.clone(),
             self.chain.clone(),
             tx_cache,
-            StorageRpcConfig::default(),
+            rpc_config,
         );
         let router = signet_rpc::router::<H>().with_state(rpc_ctx);
-        let serve_config: ServeConfig = self.config.merge_rpc_configs(&self.host)?.into();
-        serve_config.serve(tasks, router).await
+
+        let serve_config = serve_config_from_args(args);
+        serve_config.serve(router).await.map_err(Into::into)
     }
 }
+
+/// Extract [`StorageRpcConfig`] values from reth's host RPC settings.
+///
+/// Fields with no reth equivalent retain their defaults.
+fn rpc_config_from_args(args: &RpcServerArgs) -> StorageRpcConfig {
+    let gpo = &args.gas_price_oracle;
+    StorageRpcConfig::builder()
+        .rpc_gas_cap(args.rpc_gas_cap)
+        .max_tracing_requests(args.rpc_max_tracing_requests)
+        .gas_oracle_block_count(gpo.blocks as u64)
+        .gas_oracle_percentile(gpo.percentile as f64)
+        .ignore_price(Some(gpo.ignore_price as u128))
+        .max_price(Some(gpo.max_price as u128))
+        .build()
+}
+
+/// Convert reth [`RpcServerArgs`] into a reth-free [`ServeConfig`].
+fn serve_config_from_args(args: RpcServerArgs) -> ServeConfig {
+    let http =
+        if args.http { vec![SocketAddr::from((args.http_addr, args.http_port))] } else { vec![] };
+    let ws = if args.ws { vec![SocketAddr::from((args.ws_addr, args.ws_port))] } else { vec![] };
+    let ipc = if !args.ipcdisable { Some(args.ipcpath) } else { None };
+
+    ServeConfig { http, http_cors: args.http_corsdomain, ws, ws_cors: args.ws_allowed_origins, ipc }
+}

crates/rpc/Cargo.toml

@@ -30,6 +30,9 @@ serde.workspace = true
 dashmap = "6.1.0"
 revm-inspectors.workspace = true
 itertools.workspace = true
+axum = "0.8.1"
+tower-http = { version = "0.6.2", features = ["cors"] }
+interprocess = { version = "2.2.2", features = ["tokio"] }
 
 [dev-dependencies]
 tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }

crates/rpc/src/config/ctx.rs

@@ -8,8 +8,12 @@ use crate::{
     eth::EthError,
     interest::{FilterManager, SubscriptionManager},
 };
-use alloy::eips::{BlockId, BlockNumberOrTag};
+use alloy::{
+    eips::{BlockId, BlockNumberOrTag},
+    genesis::ChainConfig,
+};
 use signet_cold::ColdStorageReadHandle;
+use signet_evm::EthereumHardfork;
 use signet_hot::{
     HotKv,
     db::HotDbRead,
@@ -20,7 +24,10 @@ use signet_tx_cache::TxCache;
 use signet_types::constants::SignetSystemConstants;
 use std::sync::Arc;
 use tokio::sync::Semaphore;
-use trevm::revm::database::{DBErrorMarker, StateBuilder};
+use trevm::revm::{
+    database::{DBErrorMarker, StateBuilder},
+    primitives::hardfork::SpecId,
+};
 
 /// Resolved block context for EVM execution.
 ///
@@ -38,6 +45,8 @@ pub(crate) struct EvmBlockContext<Db> {
     /// [`State`]: trevm::revm::database::State
     /// [`DatabaseCommit`]: trevm::revm::database::DatabaseCommit
     pub db: trevm::revm::database::State<Db>,
+    /// The EVM hardfork spec active at this block.
+    pub spec_id: SpecId,
 }
 
 /// RPC context backed by [`UnifiedStorage`].
@@ -64,6 +73,7 @@ impl<H: HotKv> Clone for StorageRpcCtx<H> {
 struct StorageRpcCtxInner<H: HotKv> {
     storage: Arc<UnifiedStorage<H>>,
     constants: SignetSystemConstants,
+    chain_config: ChainConfig,
     chain: ChainNotifier,
     tx_cache: Option<TxCache>,
     config: StorageRpcConfig,
@@ -79,9 +89,13 @@ impl<H: HotKv> StorageRpcCtx<H> {
     /// The [`ChainNotifier`] provides block tag tracking and a broadcast
     /// sender for new block notifications. The subscription manager
     /// subscribes to this channel to push updates to WebSocket clients.
+    ///
+    /// The `chain_config` is the rollup genesis chain configuration, used
+    /// to determine the active EVM hardfork (spec ID) for each block.
     pub fn new(
         storage: Arc<UnifiedStorage<H>>,
         constants: SignetSystemConstants,
+        chain_config: ChainConfig,
         chain: ChainNotifier,
         tx_cache: Option<TxCache>,
         config: StorageRpcConfig,
@@ -94,6 +108,7 @@ impl<H: HotKv> StorageRpcCtx<H> {
             inner: Arc::new(StorageRpcCtxInner {
                 storage,
                 constants,
+                chain_config,
                 chain,
                 tx_cache,
                 config,
@@ -130,6 +145,16 @@ impl<H: HotKv> StorageRpcCtx<H> {
         &self.inner.constants
     }
 
+    /// Access the chain configuration (rollup genesis forks).
+    pub(crate) fn chain_config(&self) -> &ChainConfig {
+        &self.inner.chain_config
+    }
+
+    /// Determine the EVM [`SpecId`] for a given block header.
+    pub(crate) fn spec_id_for_header(&self, header: &alloy::consensus::Header) -> SpecId {
+        EthereumHardfork::active_hardforks_at_header(self.chain_config(), header).spec_id()
+    }
+
     /// Get the chain ID.
     pub fn chain_id(&self) -> u64 {
         self.inner.constants.ru_chain_id()
@@ -289,6 +314,8 @@ impl<H: HotKv> StorageRpcCtx<H> {
             header.gas_limit = self.config().rpc_gas_cap;
         }
 
-        Ok(EvmBlockContext { header, db })
+        let spec_id = self.spec_id_for_header(&header);
+
+        Ok(EvmBlockContext { header, db, spec_id })
     }
 }

crates/rpc/src/config/rpc_config.rs

@@ -210,6 +210,24 @@ impl StorageRpcConfigBuilder {
         self
     }
 
+    /// Set the default gas price returned when no recent transactions exist.
+    pub const fn default_gas_price(mut self, price: Option<u128>) -> Self {
+        self.inner.default_gas_price = price;
+        self
+    }
+
+    /// Set the minimum effective tip to include in the oracle sample.
+    pub const fn ignore_price(mut self, price: Option<u128>) -> Self {
+        self.inner.ignore_price = price;
+        self
+    }
+
+    /// Set the maximum gas price the oracle will ever suggest.
+    pub const fn max_price(mut self, price: Option<u128>) -> Self {
+        self.inner.max_price = price;
+        self
+    }
+
     /// Set the default bundle simulation timeout in milliseconds.
     pub const fn default_bundle_timeout_ms(mut self, ms: u64) -> Self {
         self.inner.default_bundle_timeout_ms = ms;

crates/rpc/src/debug/endpoints.rs

@@ -80,9 +80,10 @@ where
                 DebugError::from(e)
             }));
 
-        let mut trevm = signet_evm::signet_evm(db, ctx.constants().clone())
-            .fill_cfg(&CfgFiller(ctx.chain_id()))
-            .fill_block(&header);
+        let spec_id = ctx.spec_id_for_header(&header);
+        let mut evm = signet_evm::signet_evm(db, ctx.constants().clone());
+        evm.set_spec_id(spec_id);
+        let mut trevm = evm.fill_cfg(&CfgFiller(ctx.chain_id())).fill_block(&header);
 
         let mut txns = txs.iter().enumerate().peekable();
         for (idx, tx) in txns
@@ -165,9 +166,10 @@ where
                 DebugError::from(e)
             }));
 
-        let mut trevm = signet_evm::signet_evm(db, ctx.constants().clone())
-            .fill_cfg(&CfgFiller(ctx.chain_id()))
-            .fill_block(&header);
+        let spec_id = ctx.spec_id_for_header(&header);
+        let mut evm = signet_evm::signet_evm(db, ctx.constants().clone());
+        evm.set_spec_id(spec_id);
+        let mut trevm = evm.fill_cfg(&CfgFiller(ctx.chain_id())).fill_block(&header);
 
         // Replay all transactions up to (but not including) the target
         let mut txns = txs.iter().enumerate().peekable();

crates/rpc/src/eth/endpoints.rs

@@ -730,11 +730,11 @@ where
     let span = trace_span!("run_call", block_id = %id);
 
     let task = async move {
-        let EvmBlockContext { header, db } = response_tri!(ctx.resolve_evm_block(id));
+        let EvmBlockContext { header, db, spec_id } = response_tri!(ctx.resolve_evm_block(id));
 
-        let trevm = signet_evm::signet_evm(db, ctx.constants().clone())
-            .fill_cfg(&CfgFiller(ctx.chain_id()))
-            .fill_block(&header);
+        let mut trevm = signet_evm::signet_evm(db, ctx.constants().clone());
+        trevm.set_spec_id(spec_id);
+        let trevm = trevm.fill_cfg(&CfgFiller(ctx.chain_id())).fill_block(&header);
 
         let trevm = response_tri!(trevm.maybe_apply_state_overrides(state_overrides.as_ref()))
             .maybe_apply_block_overrides(block_overrides.as_deref())
@@ -813,11 +813,11 @@ where
     let span = trace_span!("eth_estimateGas", block_id = %id);
 
     let task = async move {
-        let EvmBlockContext { header, db } = response_tri!(ctx.resolve_evm_block(id));
+        let EvmBlockContext { header, db, spec_id } = response_tri!(ctx.resolve_evm_block(id));
 
-        let trevm = signet_evm::signet_evm(db, ctx.constants().clone())
-            .fill_cfg(&CfgFiller(ctx.chain_id()))
-            .fill_block(&header);
+        let mut trevm = signet_evm::signet_evm(db, ctx.constants().clone());
+        trevm.set_spec_id(spec_id);
+        let trevm = trevm.fill_cfg(&CfgFiller(ctx.chain_id())).fill_block(&header);
 
         let trevm = response_tri!(trevm.maybe_apply_state_overrides(state_overrides.as_ref()))
             .maybe_apply_block_overrides(block_overrides.as_deref())
@@ -864,11 +864,11 @@ where
     let span = trace_span!("eth_createAccessList", block_id = %id);
 
     let task = async move {
-        let EvmBlockContext { header, db } = response_tri!(ctx.resolve_evm_block(id));
+        let EvmBlockContext { header, db, spec_id } = response_tri!(ctx.resolve_evm_block(id));
 
-        let trevm = signet_evm::signet_evm(db, ctx.constants().clone())
-            .fill_cfg(&CfgFiller(ctx.chain_id()))
-            .fill_block(&header);
+        let mut trevm = signet_evm::signet_evm(db, ctx.constants().clone());
+        trevm.set_spec_id(spec_id);
+        let trevm = trevm.fill_cfg(&CfgFiller(ctx.chain_id())).fill_block(&header);
 
         let trevm = response_tri!(trevm.maybe_apply_state_overrides(state_overrides.as_ref()))
             .maybe_apply_block_overrides(block_overrides.as_deref())