wip

Author: prestwich

crates/rpc/Cargo.toml

@@ -41,6 +41,8 @@ tower-http = { version = "0.6.2", features = ["cors"] }
 tracing.workspace = true
 serde_json.workspace = true
 futures-util = "0.3.31"
+itertools.workspace = true
+revm-inspectors = "0.26.5"
 
 [dev-dependencies]
 signet-zenith.workspace = true

crates/rpc/src/ctx/full.rs

@@ -1,11 +1,10 @@
 use crate::{RuRevmState, SignetCtx};
-use alloy::{
-    consensus::{BlockHeader, Header},
-    eips::BlockId,
-};
+use alloy::{consensus::Header, eips::BlockId};
 use reth::{
     providers::{ProviderFactory, ProviderResult},
+    revm::Inspector,
     rpc::server_types::eth::{EthApiError, EthConfig},
+    rpc::types::BlockNumberOrTag,
     tasks::{TaskExecutor, TaskSpawner},
 };
 use reth_node_api::FullNodeComponents;
@@ -14,6 +13,59 @@ use signet_node_types::Pnt;
 use signet_tx_cache::client::TxCache;
 use signet_types::constants::SignetSystemConstants;
 use std::sync::Arc;
+use trevm::helpers::Ctx;
+
+/// State location when instantiating an EVM instance.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(i8)]
+pub enum LoadState {
+    Before = -1,
+    After = 0,
+}
+
+impl LoadState {
+    /// Adjust the height based on the state location.
+    pub const fn adjust_height(&self, height: u64) -> u64 {
+        match self {
+            LoadState::Before => height.saturating_sub(1),
+            LoadState::After => height,
+        }
+    }
+
+    /// Returns `true` if the state location is before the block.
+    pub const fn is_before_block(&self) -> bool {
+        matches!(self, Self::Before)
+    }
+
+    /// Returns `true` if the state location is after the block.
+    pub const fn is_after_block(&self) -> bool {
+        matches!(self, Self::After)
+    }
+}
+
+impl From<BlockId> for LoadState {
+    fn from(value: BlockId) -> Self {
+        match value {
+            BlockId::Number(no) => no.into(),
+            _ => LoadState::After,
+        }
+    }
+}
+
+impl From<BlockNumberOrTag> for LoadState {
+    fn from(value: BlockNumberOrTag) -> Self {
+        match value {
+            BlockNumberOrTag::Pending => LoadState::Before,
+            _ => LoadState::After,
+        }
+    }
+}
+
+impl From<LoadState> for bool {
+    fn from(value: LoadState) -> Self {
+        matches!(value, LoadState::Before)
+    }
+}
 
 /// RPC context. Contains all necessary host and signet components for serving
 /// RPC requests.
@@ -114,26 +166,45 @@ where
         self.host.task_executor()
     }
 
-    /// Create a trevm instance.
-    pub fn trevm(
+    /// Instantiate a trevm instance with a custom inspector.
+    ///
+    /// The `header` argument is used to fill the block context of the EVM. If
+    /// the `block_id` is `Pending` the EVM state will be the block BEFORE the
+    /// `header`. I.e. if the block number of the `header` is `n`, the state
+    /// will be after block `n-1`, (effectively the state at the start of block
+    /// `n`).
+    ///
+    /// if the `block_id` is `Pending` the state will be based on the
+    /// and `block` arguments
+    pub fn trevm_with_inspector<I: Inspector<Ctx<RuRevmState>>>(
         &self,
-        block_id: BlockId,
-        block: &Header,
-    ) -> Result<EvmNeedsTx<RuRevmState>, EthApiError> {
-        // decrement if the id is pending, so that the state is on the latest block
-        let height = block.number() - block_id.is_pending() as u64;
-        let spec_id = self.signet.evm_spec_id(block);
+        state: LoadState,
+        header: &Header,
+        inspector: I,
+    ) -> Result<EvmNeedsTx<RuRevmState, I>, EthApiError> {
+        let load_height = state.adjust_height(header.number);
+        let spec_id = self.signet.evm_spec_id(header);
 
-        let db = self.signet.state_provider_database(height)?;
+        let db = self.signet.state_provider_database(load_height)?;
 
-        let mut trevm = signet_evm::signet_evm(db, self.signet.constants().clone())
-            .fill_cfg(&self.signet)
-            .fill_block(block);
+        let mut trevm =
+            signet_evm::signet_evm_with_inspector(db, inspector, self.signet.constants().clone())
+                .fill_cfg(&self.signet)
+                .fill_block(header);
 
         trevm.set_spec_id(spec_id);
 
         Ok(trevm)
     }
+
+    /// Create a trevm instance.
+    pub fn trevm(
+        &self,
+        state: LoadState,
+        header: &Header,
+    ) -> Result<EvmNeedsTx<RuRevmState>, EthApiError> {
+        self.trevm_with_inspector(state, header, trevm::revm::inspector::NoOpInspector)
+    }
 }
 
 // Some code in this file has been copied and modified from reth

crates/rpc/src/ctx/mod.rs

@@ -2,7 +2,7 @@ mod signet;
 pub use signet::SignetCtx;
 
 mod full;
-pub use full::RpcCtx;
+pub use full::{LoadState, RpcCtx};
 
 mod fee_hist;
 pub(crate) use fee_hist::strip_signet_system_txns;

crates/rpc/src/debug/endpoints.rs

@@ -1,48 +1,93 @@
 use crate::{
-    RpcCtx, TraceError,
-    utils::{await_jh_option_response, response_tri},
+    DebugError, RpcCtx,
+    utils::{await_handler, response_tri},
 };
 use ajj::{HandlerCtx, ResponsePayload};
-use alloy::eips::BlockId;
+use alloy::primitives::B256;
+use itertools::Itertools;
 use reth::rpc::{
     server_types::eth::EthApiError,
-    types::trace::geth::{GethDebugTracingOptions, TraceResult},
+    types::trace::geth::{GethDebugTracingOptions, GethTrace},
 };
 use reth_node_api::FullNodeComponents;
+use signet_evm::EvmErrored;
 use signet_node_types::Pnt;
 
-/// Params for the `debug_traceBlockByNumber` and `debug_traceBlockByHash`
-/// endpoints.
-#[derive(Debug, serde::Deserialize)]
-pub(super) struct TraceBlockParams<T>(T, #[serde(default)] Option<GethDebugTracingOptions>);
+// /// Params for the `debug_traceBlockByNumber` and `debug_traceBlockByHash`
+// /// endpoints.
+// #[derive(Debug, serde::Deserialize)]
+// pub(super) struct TraceBlockParams<T>(T, #[serde(default)] Option<GethDebugTracingOptions>);
 
-/// `debug_traceBlockByNumber` and `debug_traceBlockByHash` endpoint handler.
-pub(super) async fn trace_block<T, Host, Signet>(
+// /// `debug_traceBlockByNumber` and `debug_traceBlockByHash` endpoint handler.
+// pub(super) async fn trace_block<T, Host, Signet>(
+//     hctx: HandlerCtx,
+//     TraceBlockParams(id, opts): TraceBlockParams<T>,
+//     ctx: RpcCtx<Host, Signet>,
+// ) -> ResponsePayload<Vec<TraceResult>, TraceError>
+// where
+//     T: Into<BlockId>,
+//     Host: FullNodeComponents,
+//     Signet: Pnt,
+// {
+//     let id = id.into();
+
+//     let fut = async move {
+//         // Fetch the block by ID
+//         let Some((hash, block)) = response_tri!(ctx.signet().raw_block(id).await) else {
+//             return ResponsePayload::internal_error_message(
+//                 EthApiError::HeaderNotFound(id).to_string().into(),
+//             );
+//         };
+//         // Instantiate the EVM with the block
+//         let evm = response_tri!(ctx.trevm(id, block.header()));
+
+//         todo!()
+
+//         // ResponsePayload::Success(vec![])
+//     };
+
+//     await_jh_option_response!(hctx.spawn_blocking(fut))
+// }
+
+/// Handle for `debug_traceTransaction`.
+pub(super) async fn trace_transaction<Host, Signet>(
     hctx: HandlerCtx,
-    TraceBlockParams(id, opts): TraceBlockParams<T>,
+    (tx_hash, opts): (B256, Option<GethDebugTracingOptions>),
     ctx: RpcCtx<Host, Signet>,
-) -> ResponsePayload<Vec<TraceResult>, TraceError>
+) -> ResponsePayload<GethTrace, DebugError>
 where
-    T: Into<BlockId>,
     Host: FullNodeComponents,
     Signet: Pnt,
 {
-    let id = id.into();
-
     let fut = async move {
-        // Fetch the block by ID
-        let Some((hash, block)) = response_tri!(ctx.signet().raw_block(id).await) else {
-            return ResponsePayload::internal_error_message(
-                EthApiError::HeaderNotFound(id).to_string().into(),
-            );
-        };
-        // Instantiate the EVM with the block
-        let evm = response_tri!(ctx.trevm(id, block.header()));
-
-        todo!()
-
-        // ResponsePayload::Success(vec![])
+        let (tx, meta) = response_tri!(
+            response_tri!(ctx.signet().raw_transaction_by_hash(tx_hash))
+                .ok_or(EthApiError::TransactionNotFound)
+        );
+
+        let res = response_tri!(ctx.signet().raw_block(meta.block_hash).await);
+        let (_, block) =
+            response_tri!(res.ok_or_else(|| EthApiError::HeaderNotFound(meta.block_hash.into())));
+
+        // Load trevm at the start of the block (i.e. before any transactions are applied)
+        let mut trevm = response_tri!(
+            ctx.trevm(crate::LoadState::Before, block.header()).map_err(EthApiError::from)
+        );
+
+        let mut txns = block.body().transactions().peekable();
+
+        for tx in txns.by_ref().peeking_take_while(|t| t.hash() != tx.hash()) {
+            // Apply all transactions before the target one
+            trevm = response_tri!(trevm.run_tx(tx).map_err(EvmErrored::into_error)).accept_state();
+        }
+
+        let tx = response_tri!(txns.next().ok_or(EthApiError::TransactionNotFound));
+        let trevm = trevm.fill_tx(tx);
+
+        let res = response_tri!(crate::debug::tracer::trace(trevm, &opts.unwrap_or_default()));
+
+        ResponsePayload::Success(res)
     };
 
-    await_jh_option_response!(hctx.spawn_blocking(fut))
+    await_handler!(@response_option hctx.spawn_blocking(fut))
 }

crates/rpc/src/debug/error.rs

@@ -2,42 +2,55 @@ use reth::{
     providers::ProviderError,
     rpc::{eth::filter::EthFilterError, server_types::eth::EthApiError},
 };
+use std::borrow::Cow;
 
 /// Errors that can occur when interacting with the `eth_` namespace.
 #[derive(Debug, thiserror::Error, Clone)]
-pub enum TraceError {
+pub enum DebugError {
     /// Provider error: [`ProviderError`].
     #[error("Provider error: {0}")]
     Provider(#[from] ProviderError),
     /// Filter error [`EthFilterError`].
     #[error("Filter error: {0}")]
-    Filter(String),
+    Filter(Cow<'static, str>),
     /// Eth API error: [`EthApiError`].
     #[error("Eth API error: {0}")]
-    Rpc(String),
+    Rpc(Cow<'static, str>),
 }
 
-impl From<EthFilterError> for TraceError {
+impl DebugError {
+    /// Create a new filter error.
+    pub const fn filter_error(msg: Cow<'static, str>) -> Self {
+        Self::Filter(msg)
+    }
+
+    /// Create a new RPC error.
+    pub const fn rpc_error(msg: Cow<'static, str>) -> Self {
+        Self::Rpc(msg)
+    }
+}
+
+impl From<EthFilterError> for DebugError {
     fn from(err: EthFilterError) -> Self {
-        TraceError::Filter(err.to_string())
+        Self::filter_error(err.to_string().into())
     }
 }
 
-impl From<EthApiError> for TraceError {
+impl From<EthApiError> for DebugError {
     fn from(err: EthApiError) -> Self {
-        TraceError::Rpc(err.to_string())
+        Self::rpc_error(err.to_string().into())
     }
 }
 
-impl TraceError {
+impl DebugError {
     /// Turn into a string by value, allows for `.map_err(EthError::to_string)`
     /// to be used.
     pub fn into_string(self) -> String {
         ToString::to_string(&self)
     }
 }
 
-impl serde::Serialize for TraceError {
+impl serde::Serialize for DebugError {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: serde::Serializer,

crates/rpc/src/debug/mod.rs

@@ -2,7 +2,9 @@ mod endpoints;
 use endpoints::*;
 
 mod error;
-pub use error::TraceError;
+pub use error::DebugError;
+
+mod tracer;
 
 use crate::ctx::RpcCtx;
 use alloy::primitives::{B256, U64};
@@ -16,6 +18,7 @@ where
     Signet: Pnt,
 {
     ajj::Router::new()
-        .route("traceBlockByNumber", trace_block::<U64, _, _>)
-        .route("traceBlockByHash", trace_block::<B256, _, _>)
+        // .route("traceBlockByNumber", trace_block::<U64, _, _>)
+        // .route("traceBlockByHash", trace_block::<B256, _, _>)
+        .route("traceTransaction", trace_transaction)
 }