feat(rpc): modify rpc to use alloy types

crates/provider/src/alloy/metrics.rs

@@ -0,0 +1,32 @@
+// This file is part of Rundler.
+//
+// Rundler is free software: you can redistribute it and/or modify it under the
+// terms of the GNU Lesser General Public License as published by the Free Software
+// Foundation, either version 3 of the License, or (at your option) any later version.
+//
+// Rundler is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+// without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+// See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with Rundler.
+// If not, see https://www.gnu.org/licenses/.
+
+use alloy_json_rpc::RequestPacket;
+/// Method extractor
+use rundler_types::task::traits::RequestExtractor;
+
+/// Method extractor for Alloy providers
+#[derive(Clone, Copy)]
+pub struct AlloyMethodExtractor;
+
+impl RequestExtractor<RequestPacket> for AlloyMethodExtractor {
+    fn get_method_name(req: &RequestPacket) -> String {
+        match req {
+            RequestPacket::Single(request) => request.method().to_string(),
+            _ => {
+                // can't extract method name for batch.
+                "batch".to_string()
+            }
+        }
+    }
+}

crates/provider/src/alloy/mod.rs

@@ -13,3 +13,4 @@
 
 pub(crate) mod entry_point;
 pub(crate) mod evm;
+pub(crate) mod metrics;

crates/provider/src/lib.rs

@@ -31,6 +31,7 @@ pub use alloy::{
         },
     },
     evm::AlloyEvmProvider,
+    metrics::AlloyMethodExtractor,
 };
 
 mod traits;

crates/rpc/Cargo.toml

@@ -8,15 +8,18 @@ repository.workspace = true
 publish = false
 
 [dependencies]
+rundler-contracts = { path = "../contracts" }
 rundler-provider = { path = "../provider" }
 rundler-sim = { path = "../sim" }
 rundler-task = { path = "../task" }
 rundler-types = { path = "../types" }
 rundler-utils = { path = "../utils" }
 
+alloy-primitives.workspace = true
+alloy-sol-types.workspace = true
+
 anyhow.workspace = true
 async-trait.workspace = true
-ethers.workspace = true
 jsonrpsee = { workspace = true , features = ["client", "macros", "server"] }
 metrics.workspace = true
 thiserror.workspace = true
@@ -32,6 +35,7 @@ futures-util.workspace = true
 
 [dev-dependencies]
 mockall.workspace = true
+alloy-consensus.workspace = true
 rundler-provider = { path = "../provider", features = ["test-utils"]}
 rundler-sim = { path = "../sim", features = ["test-utils"] }
 rundler-types= { path = "../types", features = ["test-utils"]}

crates/rpc/src/admin.rs

@@ -11,9 +11,9 @@
 // You should have received a copy of the GNU General Public License along with Rundler.
 // If not, see https://www.gnu.org/licenses/.
 
+use alloy_primitives::Address;
 use anyhow::Context;
 use async_trait::async_trait;
-use ethers::types::Address;
 use jsonrpsee::{core::RpcResult, proc_macros::rpc};
 use rundler_types::pool::Pool;
 
@@ -51,7 +51,7 @@ impl<P> AdminApi<P> {
 #[async_trait]
 impl<P> AdminApiServer for AdminApi<P>
 where
-    P: Pool,
+    P: Pool + 'static,
 {
     async fn clear_state(&self, clear_params: RpcAdminClearState) -> RpcResult<String> {
         utils::safe_call_rpc_handler(

crates/rpc/src/debug.rs

@@ -11,9 +11,9 @@
 // You should have received a copy of the GNU General Public License along with Rundler.
 // If not, see https://www.gnu.org/licenses/.
 
+use alloy_primitives::{Address, B256, U64};
 use anyhow::Context;
 use async_trait::async_trait;
-use ethers::types::{Address, H256};
 use futures_util::StreamExt;
 use jsonrpsee::{core::RpcResult, proc_macros::rpc};
 use rundler_types::{
@@ -48,7 +48,7 @@ pub trait DebugApi {
     ///
     /// 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>;
+    async fn bundler_send_bundle_now(&self) -> RpcResult<B256>;
 
     /// Sets the bundling mode.
     #[method(name = "bundler_setBundlingMode")]
@@ -103,8 +103,8 @@ impl<P, B> DebugApi<P, B> {
 #[async_trait]
 impl<P, B> DebugApiServer for DebugApi<P, B>
 where
-    P: Pool,
-    B: Builder,
+    P: Pool + 'static,
+    B: Builder + 'static,
 {
     async fn bundler_clear_state(&self) -> RpcResult<String> {
         utils::safe_call_rpc_handler("bundler_clearState", DebugApi::bundler_clear_state(self))
@@ -127,7 +127,7 @@ where
         .await
     }
 
-    async fn bundler_send_bundle_now(&self) -> RpcResult<H256> {
+    async fn bundler_send_bundle_now(&self) -> RpcResult<B256> {
         utils::safe_call_rpc_handler(
             "bundler_sendBundleNow",
             DebugApi::bundler_send_bundle_now(self),
@@ -235,7 +235,7 @@ where
             .collect::<Vec<RpcUserOperation>>())
     }
 
-    async fn bundler_send_bundle_now(&self) -> InternalRpcResult<H256> {
+    async fn bundler_send_bundle_now(&self) -> InternalRpcResult<B256> {
         tracing::debug!("Sending bundle");
 
         let mut new_heads = self
@@ -318,8 +318,8 @@ where
 
             let reputation = RpcReputationOutput {
                 address: r.address,
-                ops_seen: r.ops_seen.into(),
-                ops_included: r.ops_included.into(),
+                ops_seen: U64::from(r.ops_seen),
+                ops_included: U64::from(r.ops_included),
                 status,
             };
 
@@ -344,8 +344,12 @@ where
             is_staked: result.is_staked,
             stake_info: RpcStakeInfo {
                 addr: address,
-                stake: result.stake_info.stake.as_u128(),
-                unstake_delay_sec: result.stake_info.unstake_delay_sec.as_u32(),
+                stake: result
+                    .stake_info
+                    .stake
+                    .try_into()
+                    .context("stake should fit in u128")?,
+                unstake_delay_sec: result.stake_info.unstake_delay_sec,
             },
         })
     }