make the server handle fields private

crates/dojo/test-utils/Cargo.toml

@@ -10,11 +10,11 @@ anyhow.workspace = true
 assert_fs.workspace = true
 async-trait.workspace = true
 camino.workspace = true
-jsonrpsee = { workspace = true, features = [ "server" ] }
 katana-core = { workspace = true }
 katana-executor = { workspace = true, features = [ "blockifier" ] }
 katana-node.workspace = true
 katana-primitives = { workspace = true }
+katana-rpc.workspace = true
 scarb.workspace = true
 scarb-ui.workspace = true
 serde.workspace = true

crates/dojo/test-utils/src/sequencer.rs

@@ -1,7 +1,6 @@
 use std::collections::HashSet;
 use std::sync::Arc;
 
-use jsonrpsee::core::Error;
 use katana_core::backend::Backend;
 use katana_core::constants::DEFAULT_SEQUENCER_ADDRESS;
 use katana_executor::implementation::blockifier::BlockifierFactory;
@@ -11,6 +10,7 @@ pub use katana_node::config::*;
 use katana_node::LaunchedNode;
 use katana_primitives::chain::ChainId;
 use katana_primitives::chain_spec::ChainSpec;
+use katana_rpc::Error;
 use starknet::accounts::{ExecutionEncoding, SingleOwnerAccount};
 use starknet::core::chain_id;
 use starknet::core::types::{BlockId, BlockTag, Felt};
@@ -42,7 +42,8 @@ impl TestSequencer {
             .await
             .expect("Failed to launch node");
 
-        let url = Url::parse(&format!("http://{}", handle.rpc.addr)).expect("Failed to parse URL");
+        let url =
+            Url::parse(&format!("http://{}", handle.rpc.addr())).expect("Failed to parse URL");
 
         let account = handle.node.backend.chain_spec.genesis.accounts().next().unwrap();
         let account = TestAccount {
@@ -104,7 +105,7 @@ impl TestSequencer {
     }
 
     pub fn stop(self) -> Result<(), Error> {
-        self.handle.rpc.handle.stop()
+        self.handle.rpc.stop()
     }
 
     pub fn url(&self) -> Url {

crates/katana/node/src/exit.rs

@@ -18,7 +18,7 @@ impl<'a> NodeStoppedFuture<'a> {
     pub(crate) fn new(handle: &'a LaunchedNode) -> Self {
         let fut = Box::pin(async {
             handle.node.task_manager.wait_for_shutdown().await;
-            handle.rpc.handle.clone().stopped().await;
+            handle.rpc.clone().stopped().await;
             Ok(())
         });
         Self { fut }

crates/katana/node/src/lib.rs

@@ -64,7 +64,7 @@ impl LaunchedNode {
     /// This will instruct the node to stop and wait until it has actually stop.
     pub async fn stop(&self) -> Result<()> {
         // TODO: wait for the rpc server to stop instead of just stopping it.
-        self.rpc.handle.stop()?;
+        self.rpc.stop()?;
         self.node.task_manager.shutdown().await;
         Ok(())
     }

crates/katana/rpc/rpc/src/lib.rs

@@ -33,13 +33,17 @@ pub enum Error {
     AlreadyStopped,
 }
 
-#[derive(Debug)]
+/// The RPC server handle.
+#[derive(Debug, Clone)]
 pub struct RpcServerHandle {
-    pub addr: SocketAddr,
-    pub handle: ServerHandle,
+    /// The actual address that the server is binded to.
+    addr: SocketAddr,
+    /// The handle to the spawned [`jsonrpsee::server::Server`].
+    handle: ServerHandle,
 }
 
 impl RpcServerHandle {
+    /// Tell the server to stop without waiting for the server to stop.
     pub fn stop(&self) -> Result<(), Error> {
         self.handle.stop().map_err(|_| Error::AlreadyStopped)
     }
@@ -48,6 +52,11 @@ impl RpcServerHandle {
     pub async fn stopped(self) {
         self.handle.stopped().await
     }
+
+    /// Returns the socket address the server is listening on.
+    pub fn addr(&self) -> &SocketAddr {
+        &self.addr
+    }
 }
 
 #[derive(Debug)]