feat(rpc): signet_* specific methods

crates/rpc/src/ctx.rs

@@ -1,8 +1,8 @@
 use crate::{
-    eth::{EthError, TxCacheForwarder},
+    eth::EthError,
     interest::{ActiveFilter, FilterManager, FilterOutput, SubscriptionManager},
     util::BlockRangeInclusiveIter,
-    Pnt,
+    Pnt, TxCacheForwarder,
 };
 use alloy::{
     consensus::{BlockHeader, Header, Signed, Transaction, TxEnvelope},

crates/rpc/src/eth/endpoints.rs

@@ -2,6 +2,7 @@ use crate::{
     ctx::RpcCtx,
     eth::{CallErrorData, EthError},
     interest::{FilterOutput, InterestKind},
+    util::{await_jh_option, await_jh_option_response, response_tri},
     Pnt,
 };
 use ajj::{HandlerCtx, ResponsePayload};
@@ -31,63 +32,6 @@ use std::borrow::Cow;
 use tracing::{trace_span, Instrument};
 use trevm::revm::context::result::ExecutionResult;
 
-macro_rules! await_jh_option {
-    ($h:expr) => {
-        match $h.await {
-            Ok(Some(res)) => res,
-            _ => return Err("task panicked or cancelled".to_string()),
-        }
-    };
-}
-
-macro_rules! await_jh_option_response {
-    ($h:expr) => {
-        match $h.await {
-            Ok(Some(res)) => res,
-            _ => {
-                return ResponsePayload::internal_error_message(Cow::Borrowed(
-                    "task panicked or cancelled",
-                ))
-            }
-        }
-    };
-}
-
-macro_rules! response_tri {
-    ($h:expr) => {
-        match $h {
-            Ok(res) => res,
-            Err(err) => return ResponsePayload::internal_error_message(err.to_string().into()),
-        }
-    };
-
-    ($h:expr, $msg:literal) => {
-        match $h {
-            Ok(res) => res,
-            Err(_) => return ResponsePayload::internal_error_message($msg.into()),
-        }
-    };
-
-    ($h:expr, $obj:expr) => {
-        match $h {
-            Ok(res) => res,
-            Err(err) => returnResponsePayload::internal_error_with_message_and_obj(
-                err.to_string().into(),
-                $obj,
-            ),
-        }
-    };
-
-    ($h:expr, $msg:literal, $obj:expr) => {
-        match $h {
-            Ok(res) => res,
-            Err(err) => {
-                return ResponsePayload::internal_error_with_message_and_obj($msg.into(), $obj)
-            }
-        }
-    };
-}
-
 /// Args for `eth_estimateGas` and `eth_call`.
 #[derive(Debug, Deserialize)]
 pub(super) struct TxParams(

crates/rpc/src/eth/mod.rs

@@ -4,9 +4,6 @@ use endpoints::*;
 mod error;
 pub use error::EthError;
 
-mod forwarder;
-pub use forwarder::TxCacheForwarder;
-
 mod helpers;
 pub use helpers::CallErrorData;
 

crates/rpc/src/lib.rs

@@ -47,10 +47,16 @@ mod ctx;
 pub use ctx::RpcCtx;
 
 mod eth;
-pub use eth::{eth, CallErrorData, EthError, TxCacheForwarder};
+pub use eth::{eth, CallErrorData, EthError};
+
+mod signet;
+pub use signet::{error::SignetError, signet};
 
 mod interest;
 
+mod forwarder;
+use forwarder::TxCacheForwarder;
+
 pub(crate) mod util;
 pub use util::Pnt;
 
@@ -76,7 +82,7 @@ where
     Host: FullNodeComponents,
     Signet: Pnt,
 {
-    ajj::Router::new().nest("eth", eth::<Host, Signet>())
+    ajj::Router::new().nest("eth", eth::<Host, Signet>()).nest("signet", signet::<Host, Signet>())
 }
 
 /// Serve the router on the given addresses using axum.

crates/rpc/src/signet/error.rs

@@ -0,0 +1,23 @@
+//! Signet RPC errors.
+
+use reth::rpc::server_types::eth::EthApiError;
+
+/// Errors that can occur when interacting with the `signet` namespace.
+#[derive(Debug, thiserror::Error)]
+pub enum SignetError {
+    /// The transaction cache URL was not provided.
+    #[error("transaction cache URL not provided")]
+    TxCacheUrlNotProvided,
+    /// An error coming from interacting with components
+    /// that could emit `EthApiError`s, such as the forwarder.
+    #[error(transparent)]
+    EthApiError(#[from] EthApiError),
+}
+
+impl SignetError {
+    /// Turn into a string by value, allows for `.map_err(SignetError::to_string)`
+    /// to be used.
+    pub fn into_string(self) -> String {
+        ToString::to_string(&self)
+    }
+}

crates/rpc/src/signet/mod.rs

@@ -0,0 +1,73 @@
+//! Signet RPC methods and related code.
+pub(crate) mod error;
+
+use crate::util::await_jh_option;
+use crate::{ctx::RpcCtx, Pnt};
+use ajj::HandlerCtx;
+use error::SignetError;
+use reth_node_api::FullNodeComponents;
+use signet_bundle::SignetEthBundle;
+use signet_zenith::SignedOrder;
+
+/// Instantiate a `signet` API router.
+pub fn signet<Host, Signet>() -> ajj::Router<RpcCtx<Host, Signet>>
+where
+    Host: FullNodeComponents,
+    Signet: Pnt,
+{
+    ajj::Router::new().route("sendBundle", send_bundle).route("sendOrder", send_order)
+}
+
+pub(super) async fn send_bundle<Host, Signet>(
+    hctx: HandlerCtx,
+    bundle: SignetEthBundle,
+    ctx: RpcCtx<Host, Signet>,
+) -> Result<(), String>
+where
+    Host: FullNodeComponents,
+    Signet: Pnt,
+{
+    let task = |hctx: HandlerCtx| async move {
+        let Some(forwarder) = ctx.signet().forwarder() else {
+            return Err(SignetError::TxCacheUrlNotProvided.into_string());
+        };
+
+        hctx.spawn(async move {
+            forwarder
+                .forward_bundle(bundle)
+                .await
+                .map_err(|e| SignetError::EthApiError(e).into_string())
+        });
+
+        Ok(())
+    };
+
+    await_jh_option!(hctx.spawn_blocking_with_ctx(task))
+}
+
+pub(super) async fn send_order<Host, Signet>(
+    hctx: HandlerCtx,
+    order: SignedOrder,
+    ctx: RpcCtx<Host, Signet>,
+) -> Result<(), String>
+where
+    Host: FullNodeComponents,
+    Signet: Pnt,
+{
+    let task = |hctx: HandlerCtx| async move {
+        let Some(forwarder) = ctx.signet().forwarder() else {
+            return Err(SignetError::TxCacheUrlNotProvided.into_string());
+        };
+
+        hctx.spawn(async move {
+            forwarder
+                .forward_order(order)
+                .await
+                .map_err(|e| SignetError::EthApiError(e).into_string())
+        });
+
+        Ok(())
+    };
+
+    await_jh_option!(hctx.spawn_blocking_with_ctx(task))
+}

crates/rpc/src/util.rs

@@ -2,6 +2,66 @@ use reth::{primitives::EthPrimitives, providers::providers::ProviderNodeTypes};
 use reth_chainspec::ChainSpec;
 use std::{iter::StepBy, ops::RangeInclusive};
 
+macro_rules! await_jh_option {
+    ($h:expr) => {
+        match $h.await {
+            Ok(Some(res)) => res,
+            _ => return Err("task panicked or cancelled".to_string()),
+        }
+    };
+}
+pub(crate) use await_jh_option;
+
+macro_rules! await_jh_option_response {
+    ($h:expr) => {
+        match $h.await {
+            Ok(Some(res)) => res,
+            _ => {
+                return ResponsePayload::internal_error_message(Cow::Borrowed(
+                    "task panicked or cancelled",
+                ))
+            }
+        }
+    };
+}
+pub(crate) use await_jh_option_response;
+
+macro_rules! response_tri {
+    ($h:expr) => {
+        match $h {
+            Ok(res) => res,
+            Err(err) => return ResponsePayload::internal_error_message(err.to_string().into()),
+        }
+    };
+
+    ($h:expr, $msg:literal) => {
+        match $h {
+            Ok(res) => res,
+            Err(_) => return ResponsePayload::internal_error_message($msg.into()),
+        }
+    };
+
+    ($h:expr, $obj:expr) => {
+        match $h {
+            Ok(res) => res,
+            Err(err) => returnResponsePayload::internal_error_with_message_and_obj(
+                err.to_string().into(),
+                $obj,
+            ),
+        }
+    };
+
+    ($h:expr, $msg:literal, $obj:expr) => {
+        match $h {
+            Ok(res) => res,
+            Err(err) => {
+                return ResponsePayload::internal_error_with_message_and_obj($msg.into(), $obj)
+            }
+        }
+    };
+}
+pub(crate) use response_tri;
+
 /// Convenience trait for specifying the [`ProviderNodeTypes`] implementation
 /// required for Signet RPC functionality.
 pub trait Pnt: ProviderNodeTypes<ChainSpec = ChainSpec, Primitives = EthPrimitives> {}