perf(server): reuse SuiClient across requests

crates/server/src/server.rs:102 Store rpc_url in AppState and use tokio::sync::OnceCell to lazily initialize and reuse
    a single sui_sdk::SuiClient.
  - crates/server/src/server.rs:130 Add AppState::sui_client() and replace per-request SuiClientBuilder::build(...) calls
    with the cached client.
  - crates/server/src/server.rs:225 Simplify Axum state from (Arc<AppState>, Url) to Arc<AppState>, and update status,
    orderbook, deep_supply, and summary to use the cached client.

Author: dongowu

Cargo.lock

@@ -32,6 +32,10 @@ bigdecimal = "0.4.9"
 chrono = "0.4.42"
 thiserror = "1.0"
 
+[dev-dependencies]
+rand = "0.8"
+futures = "0.3"
+
 [[bin]]
 name = "deepbook-server"
 path = "src/main.rs"

crates/server/Cargo.toml

@@ -28,6 +28,7 @@ use std::time::{SystemTime, UNIX_EPOCH};
 use std::{collections::HashMap, net::SocketAddr};
 use sui_pg_db::DbArgs;
 use tokio::net::TcpListener;
+use tokio::sync::OnceCell;
 use tower_http::cors::{AllowMethods, Any, CorsLayer};
 use url::Url;
 
@@ -106,6 +107,8 @@ pub const DEPOSITED_ASSETS_PATH: &str = "/deposited_assets/:balance_manager_ids"
 pub struct AppState {
     reader: Reader,
     metrics: Arc<RpcMetrics>,
+    rpc_url: Url,
+    sui_client: Arc<OnceCell<sui_sdk::SuiClient>>,
     deepbook_package_id: String,
     deep_token_package_id: String,
     deep_treasury_id: String,
@@ -116,6 +119,7 @@ impl AppState {
         database_url: Url,
         args: DbArgs,
         registry: &Registry,
+        rpc_url: Url,
         deepbook_package_id: String,
         deep_token_package_id: String,
         deep_treasury_id: String,
@@ -125,11 +129,27 @@ impl AppState {
         Ok(Self {
             reader,
             metrics,
+            rpc_url,
+            sui_client: Arc::new(OnceCell::new()),
             deepbook_package_id,
             deep_token_package_id,
             deep_treasury_id,
         })
     }
+
+    /// Returns a reference to the shared SuiClient instance.
+    /// Lazily initializes the client on first access and caches it for subsequent calls
+    pub async fn sui_client(&self) -> Result<&sui_sdk::SuiClient, DeepBookError> {
+        self.sui_client
+            .get_or_try_init(|| async {
+                SuiClientBuilder::default()
+                    .build(self.rpc_url.as_str())
+                    .await
+            })
+            .await
+            .map_err(DeepBookError::from)
+    }
+
     pub(crate) fn metrics(&self) -> &RpcMetrics {
         &self.metrics
     }
@@ -178,6 +198,7 @@ pub async fn run_server(
         database_url,
         db_arg,
         metrics.registry(),
+        rpc_url,
         deepbook_package_id,
         deep_token_package_id,
         deep_treasury_id,
@@ -192,15 +213,15 @@ pub async fn run_server(
     });
 
     let listener = TcpListener::bind(socket_address).await?;
-    axum::serve(listener, make_router(Arc::new(state), rpc_url))
+    axum::serve(listener, make_router(Arc::new(state)))
         .with_graceful_shutdown(async move {
             cancellation_token.cancelled().await;
         })
         .await?;
 
     Ok(())
 }
-pub(crate) fn make_router(state: Arc<AppState>, rpc_url: Url) -> Router {
+pub(crate) fn make_router(state: Arc<AppState>) -> Router {
     let cors = CorsLayer::new()
         .allow_methods(AllowMethods::list(vec![Method::GET, Method::OPTIONS]))
         .allow_headers(Any)
@@ -271,7 +292,7 @@ pub(crate) fn make_router(state: Arc<AppState>, rpc_url: Url) -> Router {
         .route(DEEP_SUPPLY_PATH, get(deep_supply))
         .route(SUMMARY_PATH, get(summary))
         .route(STATUS_PATH, get(status))
-        .with_state((state.clone(), rpc_url));
+        .with_state(state.clone());
 
     db_routes
         .merge(rpc_routes)
@@ -286,13 +307,13 @@ async fn health_check() -> StatusCode {
 /// Get indexer status including checkpoint lag
 async fn status(
     Query(params): Query<StatusQueryParams>,
-    State((state, rpc_url)): State<(Arc<AppState>, Url)>,
+    State(state): State<Arc<AppState>>,
 ) -> Result<Json<serde_json::Value>, DeepBookError> {
     // Get watermarks from the database
     let watermarks = state.reader.get_watermarks().await?;
 
     // Get the latest checkpoint from Sui RPC
-    let sui_client = SuiClientBuilder::default().build(rpc_url.as_str()).await?;
+    let sui_client = state.sui_client().await?;
     let latest_checkpoint = sui_client
         .read_api()
         .get_latest_checkpoint_sequence_number()
@@ -680,7 +701,7 @@ async fn fetch_historical_volume(
 
 #[allow(clippy::get_first)]
 async fn summary(
-    State((state, rpc_url)): State<(Arc<AppState>, Url)>,
+    State(state): State<Arc<AppState>>,
 ) -> Result<Json<Vec<HashMap<String, Value>>>, DeepBookError> {
     // Fetch pools metadata first since it's required for other functions
     let pools = state.reader.get_pools().await?;
@@ -722,7 +743,7 @@ async fn summary(
             orderbook(
                 Path(pool_name_clone),
                 Query(HashMap::from([("level".to_string(), "1".to_string())])),
-                State((state.clone(), rpc_url.clone())),
+                State(state.clone()),
             )
         })
         .collect();
@@ -1287,7 +1308,7 @@ pub async fn assets(
 async fn orderbook(
     Path(pool_name): Path<String>,
     Query(params): Query<HashMap<String, String>>,
-    State((state, rpc_url)): State<(Arc<AppState>, Url)>,
+    State(state): State<Arc<AppState>>,
 ) -> Result<Json<HashMap<String, Value>>, DeepBookError> {
     let depth = params
         .get("depth")
@@ -1341,7 +1362,7 @@ async fn orderbook(
 
     let pool_address = ObjectID::from_hex_literal(&pool_id)?;
 
-    let sui_client = SuiClientBuilder::default().build(rpc_url.as_str()).await?;
+    let sui_client = state.sui_client().await?;
     let mut ptb = ProgrammableTransactionBuilder::new();
 
     let pool_object: SuiObjectResponse = sui_client
@@ -1497,10 +1518,8 @@ async fn orderbook(
 }
 
 /// DEEP total supply
-async fn deep_supply(
-    State((state, rpc_url)): State<(Arc<AppState>, Url)>,
-) -> Result<Json<u64>, DeepBookError> {
-    let sui_client = SuiClientBuilder::default().build(rpc_url.as_str()).await?;
+async fn deep_supply(State(state): State<Arc<AppState>>) -> Result<Json<u64>, DeepBookError> {
+    let sui_client = state.sui_client().await?;
     let mut ptb = ProgrammableTransactionBuilder::new();
 
     let deep_treasury_object_id = ObjectID::from_hex_literal(&state.deep_treasury_id)?;