refactor(rpc): add rpc crate

Cargo.toml

@@ -6,6 +6,7 @@ members = [
     "crates/builder",
     "crates/pool",
     "crates/provider",
+    "crates/rpc",
     "crates/sim",
     "crates/task",
     "crates/types",

bin/tools/Cargo.toml

@@ -11,6 +11,7 @@ Rundler tools
 
 [dependencies]
 rundler-rundler = { path = "../../crates/rundler" }
+rundler-rpc = { path = "../../crates/rpc" }
 
 anyhow = "1.0.70"
 clap = { version = "4.2.4", features = ["derive", "env"] }

bin/tools/src/bin/get_example_ops.rs

@@ -1,5 +1,6 @@
 use dotenv::dotenv;
-use rundler_rundler::{common::dev::DevClients, rpc::RpcUserOperation};
+use rundler_rpc::RpcUserOperation;
+use rundler_rundler::common::dev::DevClients;
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {

bin/tools/src/bin/send_ops.rs

@@ -1,5 +1,5 @@
 use dotenv::dotenv;
-use rundler_rundler::common::{dev::DevClients, eth};
+use rundler_rundler::common::{dev, dev::DevClients};
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
@@ -17,7 +17,7 @@ async fn main() -> anyhow::Result<()> {
         println!("Sending op {i}");
         let op = clients.new_wallet_op(wallet.nonce(), 0.into()).await?;
         let call = entry_point.handle_ops(vec![op], bundler_client.address());
-        eth::await_mined_tx(call.send(), "send user operation").await?;
+        dev::await_mined_tx(call.send(), "send user operation").await?;
     }
 
     Ok(())

crates/rpc/Cargo.toml

@@ -0,0 +1,31 @@
+[package]
+name = "rundler-rpc"
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+repository.workspace = true
+
+[dependencies]
+rundler-builder = { path = "../builder" }
+rundler-pool = { path = "../pool" }
+rundler-provider = { path = "../provider" }
+rundler-sim = { path = "../sim" }
+rundler-task = { path = "../task" }
+rundler-types = { path = "../types" }
+rundler-utils = { path = "../utils" }
+
+anyhow.workspace = true
+async-trait.workspace = true
+ethers.workspace = true
+jsonrpsee = { version = "0.20.0", features = ["client", "macros", "server"] }
+metrics.workspace = true
+thiserror.workspace = true
+tokio.workspace = true
+tokio-util.workspace = true
+tonic.workspace = true
+tower.workspace = true
+tracing.workspace = true
+serde.workspace = true
+strum.workspace = true
+url.workspace = true

crates/rundler/src/rpc/debug.rs → crates/rpc/src/debug.rs

@@ -1,44 +1,55 @@
+use async_trait::async_trait;
 use ethers::types::{Address, H256};
 use jsonrpsee::{core::RpcResult, proc_macros::rpc, types::error::INTERNAL_ERROR_CODE};
 use rundler_builder::{BuilderServer, BundlingMode};
 use rundler_pool::PoolServer;
-use tonic::async_trait;
 
-use super::{rpc_err, RpcReputation, RpcUserOperation};
+use crate::{
+    error::rpc_err,
+    types::{RpcReputation, RpcUserOperation},
+};
 
 /// Debug API
 #[rpc(client, server, namespace = "debug")]
 pub trait DebugApi {
+    /// Clears the state of the pool.
     #[method(name = "bundler_clearState")]
     async fn bundler_clear_state(&self) -> RpcResult<String>;
 
+    /// Dumps the mempool.
     #[method(name = "bundler_dumpMempool")]
     async fn bundler_dump_mempool(&self, entry_point: Address) -> RpcResult<Vec<RpcUserOperation>>;
 
+    /// Triggers the builder to send a bundle now
+    ///
+    /// Note that the bundling mode must be set to `Manual` else this will fail.
     #[method(name = "bundler_sendBundleNow")]
     async fn bundler_send_bundle_now(&self) -> RpcResult<H256>;
 
+    /// Sets the bundling mode.
     #[method(name = "bundler_setBundlingMode")]
     async fn bundler_set_bundling_mode(&self, mode: BundlingMode) -> RpcResult<String>;
 
+    /// Sets the reputations of entities on the given entry point.
     #[method(name = "bundler_setReputation")]
     async fn bundler_set_reputation(
         &self,
         reputations: Vec<RpcReputation>,
         entry_point: Address,
     ) -> RpcResult<String>;
 
+    /// Dumps the reputations of entities from the given entry point.
     #[method(name = "bundler_dumpReputation")]
     async fn bundler_dump_reputation(&self, entry_point: Address) -> RpcResult<Vec<RpcReputation>>;
 }
 
-pub struct DebugApi<P, B> {
+pub(crate) struct DebugApi<P, B> {
     pool: P,
     builder: B,
 }
 
 impl<P, B> DebugApi<P, B> {
-    pub fn new(pool: P, builder: B) -> Self {
+    pub(crate) fn new(pool: P, builder: B) -> Self {
         Self { pool, builder }
     }
 }

crates/rpc/src/error.rs

@@ -0,0 +1,22 @@
+use jsonrpsee::types::{ErrorObject, ErrorObjectOwned};
+use serde::Serialize;
+
+pub(crate) fn rpc_err(code: i32, msg: impl Into<String>) -> ErrorObjectOwned {
+    create_rpc_err(code, msg, None::<()>)
+}
+
+pub(crate) fn rpc_err_with_data<S: Serialize>(
+    code: i32,
+    msg: impl Into<String>,
+    data: S,
+) -> ErrorObjectOwned {
+    create_rpc_err(code, msg, Some(data))
+}
+
+fn create_rpc_err<S: Serialize>(
+    code: i32,
+    msg: impl Into<String>,
+    data: Option<S>,
+) -> ErrorObjectOwned {
+    ErrorObject::owned(code, msg.into(), data)
+}