refactor(rpc): util for creating HttpClient (#88)

* refactor(rpc): util for creating `HttpClient`

* fix(rpc): add missing client and cors features for jsonrpsee and tower-http

Co-Authored-By: karii@cartridge.gg <evergreenkary@gmail.com>

---------

Co-authored-by: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>

Author: kariy

Cargo.lock

@@ -23,14 +23,14 @@ katana-tasks.workspace = true
 anyhow.workspace = true
 futures.workspace = true
 http.workspace = true
-jsonrpsee = { workspace = true, features = [ "server" ] }
+jsonrpsee = { workspace = true, features = [ "server", "client" ] }
 metrics.workspace = true
 serde_json.workspace = true
 starknet.workspace = true
 thiserror.workspace = true
 tokio.workspace = true
 tower.workspace = true
-tower-http = { workspace = true, features = [ "trace" ] }
+tower-http = { workspace = true, features = [ "trace", "cors" ] }
 tracing.workspace = true
 url.workspace = true
 
@@ -82,3 +82,4 @@ cartridge = [
 	"katana-rpc-api/cartridge",
 ]
 explorer = [ "dep:katana-explorer" ]
+client = [ "jsonrpsee/client", "katana-rpc-api/client" ]

crates/rpc/rpc/Cargo.toml

@@ -29,6 +29,9 @@ mod logger;
 mod utils;
 use cors::Cors;
 use health::HealthCheck;
+#[cfg(feature = "client")]
+pub use jsonrpsee::http_client::HttpClient;
+pub use katana_rpc_api as api;
 use metrics::RpcServerMetricsLayer;
 
 /// The default maximum number of concurrent RPC connections.
@@ -44,9 +47,6 @@ pub const DEFAULT_TIMEOUT: Duration = Duration::from_secs(20);
 
 #[derive(Debug, thiserror::Error)]
 pub enum Error {
-    #[error(transparent)]
-    Jsonrpsee(#[from] jsonrpsee::types::ErrorObjectOwned),
-
     #[error(transparent)]
     Io(#[from] std::io::Error),
 
@@ -55,6 +55,9 @@ pub enum Error {
 
     #[error("RPC server has already been stopped")]
     AlreadyStopped,
+
+    #[error(transparent)]
+    Client(#[from] jsonrpsee::core::ClientError),
 }
 
 /// The RPC server handle.
@@ -81,6 +84,14 @@ impl RpcServerHandle {
     pub fn addr(&self) -> &SocketAddr {
         &self.addr
     }
+
+    /// Returns a HTTP client associated with the server.
+    #[cfg(feature = "client")]
+    pub fn http_client(&self) -> Result<HttpClient, Error> {
+        use jsonrpsee::http_client::HttpClientBuilder;
+        let url = format!("http://{}", self.addr);
+        Ok(HttpClientBuilder::default().build(url)?)
+    }
 }
 
 #[derive(Debug)]

crates/rpc/rpc/src/lib.rs

@@ -1,7 +1,6 @@
-use jsonrpsee::http_client::HttpClientBuilder;
 use katana_provider::traits::block::{BlockNumberProvider, BlockProvider};
 use katana_provider::traits::env::BlockEnvProvider;
-use katana_rpc_api::dev::DevApiClient;
+use katana_rpc::api::dev::DevApiClient;
 use katana_utils::TestNode;
 
 #[tokio::test]
@@ -11,8 +10,7 @@ async fn test_next_block_timestamp_in_past() {
     let provider = backend.blockchain.provider();
 
     // Create a jsonrpsee client for the DevApi
-    let url = format!("http://{}", sequencer.rpc_addr());
-    let client = HttpClientBuilder::default().build(url).unwrap();
+    let client = sequencer.rpc_http_client();
 
     let block_num = provider.latest_number().unwrap();
     let mut block_env = provider.block_env_at(block_num.into()).unwrap().unwrap();
@@ -39,8 +37,7 @@ async fn test_set_next_block_timestamp_in_future() {
     let provider = backend.blockchain.provider();
 
     // Create a jsonrpsee client for the DevApi
-    let url = format!("http://{}", sequencer.rpc_addr());
-    let client = HttpClientBuilder::default().build(url).unwrap();
+    let client = sequencer.rpc_http_client();
 
     let block_num = provider.latest_number().unwrap();
     let mut block_env = provider.block_env_at(block_num.into()).unwrap().unwrap();
@@ -68,8 +65,7 @@ async fn test_increase_next_block_timestamp() {
     let provider = backend.blockchain.provider();
 
     // Create a jsonrpsee client for the DevApi
-    let url = format!("http://{}", sequencer.rpc_addr());
-    let client = HttpClientBuilder::default().build(url).unwrap();
+    let client = sequencer.rpc_http_client();
 
     let block_num = provider.latest_number().unwrap();
     let mut block_env = provider.block_env_at(block_num.into()).unwrap().unwrap();
@@ -101,8 +97,7 @@ async fn test_increase_next_block_timestamp() {
 async fn test_dev_api_enabled() {
     let sequencer = TestNode::new().await;
 
-    let url = format!("http://{}", sequencer.rpc_addr());
-    let client = HttpClientBuilder::default().build(url).unwrap();
+    let client = sequencer.rpc_http_client();
 
     let accounts = client.predeployed_accounts().await.unwrap();
     assert!(!accounts.is_empty(), "predeployed accounts should not be empty");

crates/rpc/rpc/tests/dev.rs

@@ -2,7 +2,6 @@ use std::path::PathBuf;
 
 use assert_matches::assert_matches;
 use jsonrpsee::core::ClientError;
-use jsonrpsee::http_client::HttpClientBuilder;
 use katana_chain_spec::ChainSpec;
 use katana_node::config::rpc::DEFAULT_RPC_MAX_PROOF_KEYS;
 use katana_primitives::block::BlockIdOrTag;
@@ -30,8 +29,7 @@ async fn proofs_limit() {
     let sequencer = TestNode::new().await;
 
     // We need to use the jsonrpsee client because `starknet-rs` doesn't yet support RPC 0
-    let url = format!("http://{}", sequencer.rpc_addr());
-    let client = HttpClientBuilder::default().build(url).unwrap();
+    let client = sequencer.rpc_http_client();
 
     // Because we're using the default configuration for instantiating the node, the RPC limit is
     // set to 100. The total keys is 35 + 35 + 35 = 105.
@@ -83,8 +81,7 @@ async fn genesis_states() {
     let genesis_states = chain_spec.state_updates();
 
     // We need to use the jsonrpsee client because `starknet-rs` doesn't yet support RPC 0.8.0
-    let url = format!("http://{}", sequencer.rpc_addr());
-    let client = HttpClientBuilder::default().build(url).unwrap();
+    let client = sequencer.rpc_http_client();
 
     // Check class declarations
     let genesis_classes =
@@ -198,8 +195,7 @@ async fn classes_proofs() {
         declare(&account, "tests/test_data/test_sierra_contract.json").await;
 
     // We need to use the jsonrpsee client because `starknet-rs` doesn't yet support RPC 0.8.0
-    let url = format!("http://{}", sequencer.rpc_addr());
-    let client = HttpClientBuilder::default().build(url).unwrap();
+    let client = sequencer.rpc_http_client();
 
     {
         let class_hash = class_hash1;

crates/rpc/rpc/tests/proofs.rs

@@ -6,7 +6,6 @@ use assert_matches::assert_matches;
 use cainome::rs::{abigen, abigen_legacy};
 use common::split_felt;
 use indexmap::IndexSet;
-use jsonrpsee::http_client::HttpClientBuilder;
 use katana_primitives::event::ContinuationToken;
 use katana_primitives::genesis::constant::{
     DEFAULT_ACCOUNT_CLASS_HASH, DEFAULT_ETH_FEE_TOKEN_ADDRESS, DEFAULT_PREFUNDED_ACCOUNT_BALANCE,
@@ -638,8 +637,7 @@ async fn get_events_no_pending() -> Result<()> {
     let sequencer = TestNode::new_with_config(config).await;
 
     // create a json rpc client to interact with the dev api.
-    let url = format!("http://{}", sequencer.rpc_addr());
-    let client = HttpClientBuilder::default().build(url).unwrap();
+    let client = sequencer.rpc_http_client();
 
     let provider = sequencer.starknet_provider();
     let account = sequencer.account();
@@ -725,8 +723,7 @@ async fn get_events_with_pending() -> Result<()> {
     let sequencer = TestNode::new_with_config(config).await;
 
     // create a json rpc client to interact with the dev api.
-    let url = format!("http://{}", sequencer.rpc_addr());
-    let client = HttpClientBuilder::default().build(url).unwrap();
+    let client = sequencer.rpc_http_client();
 
     let provider = sequencer.starknet_provider();
     let account = sequencer.account();
@@ -817,8 +814,7 @@ async fn trace() -> Result<()> {
 
     let provider = sequencer.starknet_provider();
     let account = sequencer.account();
-    let url = format!("http://{}", sequencer.rpc_addr());
-    let rpc_client = HttpClientBuilder::default().build(url).unwrap();
+    let rpc_client = sequencer.rpc_http_client();
 
     // setup contract to interact with (can be any existing contract that can be interacted with)
     let contract = Erc20Contract::new(DEFAULT_ETH_FEE_TOKEN_ADDRESS.into(), &account);
@@ -868,9 +864,7 @@ async fn block_traces() -> Result<()> {
 
     let provider = sequencer.starknet_provider();
     let account = sequencer.account();
-
-    let url = format!("http://{}", sequencer.rpc_addr());
-    let rpc_client = HttpClientBuilder::default().build(url)?;
+    let rpc_client = sequencer.rpc_http_client();
 
     // setup contract to interact with (can be any existing contract that can be interacted with)
     let contract = Erc20Contract::new(DEFAULT_ETH_FEE_TOKEN_ADDRESS.into(), &account);
@@ -991,8 +985,7 @@ async fn fetch_pending_blocks() {
     let sequencer = TestNode::new_with_config(config).await;
 
     // create a json rpc client to interact with the dev api.
-    let url = format!("http://{}", sequencer.rpc_addr());
-    let dev_client = HttpClientBuilder::default().build(url).unwrap();
+    let dev_client = sequencer.rpc_http_client();
     let provider = sequencer.starknet_provider();
     let account = sequencer.account();
 
@@ -1094,8 +1087,7 @@ async fn fetch_pending_blocks_in_instant_mode() {
     let sequencer = TestNode::new().await;
 
     // create a json rpc client to interact with the dev api.
-    let url = format!("http://{}", sequencer.rpc_addr());
-    let dev_client = HttpClientBuilder::default().build(url).unwrap();
+    let dev_client = sequencer.rpc_http_client();
     let provider = sequencer.starknet_provider();
     let account = sequencer.account();
 

crates/rpc/rpc/tests/starknet.rs

@@ -12,6 +12,7 @@ katana-executor.workspace = true
 katana-node = { workspace = true, features = [ "explorer" ] }
 katana-primitives.workspace = true
 katana-provider.workspace = true
+katana-rpc = { workspace = true, features = [ "client" ] }
 
 anyhow.workspace = true
 assert_matches.workspace = true

crates/utils/Cargo.toml

@@ -13,6 +13,7 @@ use katana_node::{LaunchedNode, Node};
 use katana_primitives::chain::ChainId;
 use katana_primitives::{address, ContractAddress};
 use katana_provider::BlockchainProvider;
+use katana_rpc::HttpClient;
 use starknet::accounts::{ExecutionEncoding, SingleOwnerAccount};
 use starknet::core::types::BlockTag;
 pub use starknet::core::types::StarknetError;
@@ -90,6 +91,11 @@ impl TestNode {
 
         account
     }
+
+    /// Returns a HTTP client to the JSON-RPC server.
+    pub fn rpc_http_client(&self) -> HttpClient {
+        self.handle().rpc().http_client().expect("failed to get http client for the rpc server")
+    }
 }
 
 pub fn test_config() -> Config {