chore(node/rpc): Refactor p2p rpc

bin/node/src/commands/net.rs

@@ -2,8 +2,8 @@
 
 use crate::flags::{GlobalArgs, MetricsArgs, P2PArgs, RpcArgs};
 use clap::Parser;
-use kona_p2p::{NetRpcRequest, NetworkBuilder, NetworkRpc};
-use kona_rpc::{OpP2PApiServer, RpcConfig};
+use kona_p2p::{NetworkBuilder, P2pRpcRequest};
+use kona_rpc::{NetworkRpc, OpP2PApiServer, RpcConfig};
 use tracing::{debug, info, warn};
 use url::Url;
 
@@ -86,7 +86,7 @@ impl NetCommand {
                 }
                 _ = interval.tick() => {
                     let (otx, mut orx) = tokio::sync::oneshot::channel();
-                    if let Err(e) = tx.send(NetRpcRequest::PeerCount(otx)).await {
+                    if let Err(e) = tx.send(P2pRpcRequest::PeerCount(otx)).await {
                         warn!(target: "net", "Failed to send network rpc request: {:?}", e);
                         continue;
                     }

crates/node/p2p/Cargo.toml

@@ -19,7 +19,6 @@ workspace = true
 # Kona
 kona-macros.workspace = true
 kona-genesis.workspace = true
-kona-rpc = { workspace = true, features = ["jsonrpsee", "reqwest", "std"] }
 
 # Alloy
 alloy-rlp.workspace = true
@@ -50,10 +49,8 @@ tokio.workspace = true
 tracing.workspace = true
 thiserror.workspace = true
 lazy_static.workspace = true
-async-trait.workspace = true
 unsigned-varint.workspace = true
 rand = { workspace = true, features = ["thread_rng"] }
-jsonrpsee = { workspace = true, features = ["server"] }
 serde_json = { workspace = true, features = ["alloc"] }
 derive_more = { workspace = true, features = ["display", "deref", "debug"] }
 
@@ -80,4 +77,4 @@ op-alloy-consensus = { workspace = true, features = ["arbitrary", "k256"] }
 [features]
 default = []
 metrics = ["dep:metrics", "libp2p/metrics"]
-arbitrary = ["dep:arbitrary", "alloy-primitives/arbitrary"]
+arbitrary = ["dep:arbitrary", "alloy-primitives/arbitrary"]

crates/node/p2p/src/lib.rs

@@ -10,16 +10,17 @@
 #[macro_use]
 extern crate tracing;
 
-#[cfg(feature = "metrics")]
 mod metrics;
-#[cfg(feature = "metrics")]
 pub use metrics::Metrics;
 
 mod net;
 pub use net::{Broadcast, Config, Network, NetworkBuilder, NetworkBuilderError};
 
 mod rpc;
-pub use rpc::{NetRpcRequest, NetworkRpc};
+pub use rpc::{
+    Connectedness, Direction, GossipScores, P2pRpcRequest, PeerCount, PeerDump, PeerInfo,
+    PeerScores, PeerStats, ReqRespScores, TopicScores,
+};
 
 mod gossip;
 pub use gossip::{

crates/node/p2p/src/metrics/mod.rs

@@ -40,12 +40,14 @@ impl Metrics {
     /// This does two things:
     /// * Describes various metrics.
     /// * Initializes metrics to 0 so they can be queried immediately.
+    #[cfg(feature = "metrics")]
     pub fn init() {
         Self::describe();
         Self::zero();
     }
 
     /// Describes metrics used in [`kona_p2p`][crate].
+    #[cfg(feature = "metrics")]
     pub fn describe() {
         metrics::describe_gauge!(Self::RPC_CALLS, "Calls made to the P2P RPC module");
         metrics::describe_gauge!(Self::GOSSIP_EVENT, "Gossip events received by the libp2p Swarm");
@@ -79,6 +81,7 @@ impl Metrics {
 
     /// Initializes metrics to `0` so they can be queried immediately by consumers of prometheus
     /// metrics.
+    #[cfg(feature = "metrics")]
     pub fn zero() {
         // RPC Calls
         kona_macros::set!(gauge, Self::RPC_CALLS, "method", "opp2p_self", 0);

crates/node/p2p/src/net/builder.rs

@@ -9,8 +9,8 @@
 use tokio::sync::broadcast::Sender as BroadcastSender;
 
 use crate::{
-    Broadcast, Config, Discv5Builder, GossipDriverBuilder, NetRpcRequest, Network,
-    NetworkBuilderError, PeerMonitoring, PeerScoreLevel, discv5::LocalNode,
+    Broadcast, Config, Discv5Builder, GossipDriverBuilder, Network, NetworkBuilderError,
+    P2pRpcRequest, PeerMonitoring, PeerScoreLevel, discv5::LocalNode,
 };
 
 /// Constructs a [`Network`] for the OP Stack Consensus Layer.
@@ -25,7 +25,7 @@
     /// The [`RollupConfig`] only used to select which topic to publish blocks to.
     cfg: Option<RollupConfig>,
     /// A receiver for network RPC requests.
-    rpc_recv: Option<tokio::sync::mpsc::Receiver<NetRpcRequest>>,
+    rpc_recv: Option<tokio::sync::mpsc::Receiver<P2pRpcRequest>>,
     /// A broadcast sender for the unsafe block payloads.
     payload_tx: Option<BroadcastSender<OpNetworkPayloadEnvelope>>,
     /// A receiver for unsafe blocks to publish.
@@ -132,7 +132,7 @@
     }
 
     /// Sets the rpc receiver for the [`crate::Network`].
-    pub fn with_rpc_receiver(self, rpc_recv: tokio::sync::mpsc::Receiver<NetRpcRequest>) -> Self {
+    pub fn with_rpc_receiver(self, rpc_recv: tokio::sync::mpsc::Receiver<P2pRpcRequest>) -> Self {
         Self { rpc_recv: Some(rpc_recv), ..self }
     }
 

crates/node/p2p/src/net/driver.rs

@@ -10,7 +10,7 @@ use tokio::{
     time::Duration,
 };
 
-use crate::{Broadcast, Discv5Driver, GossipDriver, HandlerRequest, NetRpcRequest, NetworkBuilder};
+use crate::{Broadcast, Discv5Driver, GossipDriver, HandlerRequest, NetworkBuilder, P2pRpcRequest};
 
 /// Network
 ///
@@ -28,7 +28,7 @@ pub struct Network {
     ///
     /// This is allowed to be optional since it may not be desirable
     /// run a networking stack with RPC access.
-    pub(crate) rpc: Option<tokio::sync::mpsc::Receiver<NetRpcRequest>>,
+    pub(crate) rpc: Option<tokio::sync::mpsc::Receiver<P2pRpcRequest>>,
     /// A channel to publish an unsafe block.
     pub(crate) publish_rx: Option<tokio::sync::mpsc::Receiver<OpNetworkPayloadEnvelope>>,
     /// The swarm instance.

crates/node/p2p/src/rpc/mod.rs

@@ -1,7 +1,10 @@
-//! Contains RPC types specific to Kona's network stack.
+//! Contains RPC types specific to Kona's p2p stack.
 
 mod request;
-pub use request::NetRpcRequest;
+pub use request::P2pRpcRequest;
 
-mod server;
-pub use server::NetworkRpc;
+mod types;
+pub use types::{
+    Connectedness, Direction, GossipScores, PeerCount, PeerDump, PeerInfo, PeerScores, PeerStats,
+    ReqRespScores, TopicScores,
+};

crates/node/p2p/src/rpc/request.rs

@@ -1,13 +1,14 @@
-//! Contains the network RPC request type.
+//! Contains the p2p RPC request type.
 
 use crate::{Discv5Handler, GossipDriver};
 use discv5::multiaddr::Protocol;
-use kona_rpc::PeerInfo;
 use tokio::sync::oneshot::Sender;
 
-/// A network RPC Request.
+use super::types::{Connectedness, Direction, PeerInfo, PeerScores};
+
+/// A p2p RPC Request.
 #[derive(Debug)]
-pub enum NetRpcRequest {
+pub enum P2pRpcRequest {
     /// Returns [`PeerInfo`] for the [`crate::Network`].
     PeerInfo(Sender<PeerInfo>),
     /// Dumps the node's discovery table from the [`crate::Discv5Driver`].
@@ -18,7 +19,7 @@
     PeerCount(Sender<(Option<usize>, usize)>),
 }
 
-impl NetRpcRequest {
+impl P2pRpcRequest {
     /// Handles the peer count request.
     pub fn handle(self, gossip: &GossipDriver, disc: &Discv5Handler) {
         match self {
@@ -71,21 +72,21 @@
             let node_id = enr.node_id().to_string();
 
             // We need to add the local multiaddr to the list of known addresses.
-            let peer_info = kona_rpc::PeerInfo {
+            let peer_info = PeerInfo {
                 peer_id: peer_id.to_string(),
                 node_id,
                 user_agent: "kona".to_string(),
                 protocol_version: "1".to_string(),
                 enr: enr.to_string(),
                 addresses,
                 protocols: None,
-                connectedness: kona_rpc::Connectedness::Connected,
-                direction: kona_rpc::Direction::Inbound,
+                connectedness: Connectedness::Connected,
+                direction: Direction::Inbound,
                 protected: false,
                 chain_id,
                 latency: 0,
                 gossip_blocks: true,
-                peer_scores: kona_rpc::PeerScores::default(),
+                peer_scores: PeerScores::default(),
             };
             if let Err(e) = sender.send(peer_info) {
                 warn!("Failed to send peer info through response channel: {:?}", e);