[deps] update rpc deps

Cargo.toml

@@ -159,7 +159,7 @@ futures = "0.3.28"
 hex = "0.4.3"
 rustc-hex = "2.1"
 itertools = "0.13.0"
-jsonrpsee = { version = "0.16.3", features = ["full"] }
+jsonrpsee = { version = "0.23.2", features = ["full"] }
 jpst = "0.1.1"
 lazy_static = "1.5.0"
 linked-hash-map = "0.5.6"
@@ -226,8 +226,8 @@ nostr = "0.22"
 serde-reflection = "0.3.6"
 serde-generate = "0.25.1"
 bcs-ext = { path = "moveos/moveos-commons/bcs_ext" }
-tower = { version = "0.4.12", features = ["full", "util", "timeout", "load-shed", "limit"] }
-tower-http = { version = "0.4.4", features = ["cors", "full", "trace", "set-header", "propagate-header"] }
+tower = { version = "0.4.13", features = ["full", "util", "timeout", "load-shed", "limit"] }
+tower-http = { version = "0.5.2", features = ["cors", "full", "trace", "set-header", "propagate-header"] }
 mirai-annotations = "1.12.0"
 lru = "0.11.0"
 bs58 = "0.5.1"
@@ -251,8 +251,7 @@ diesel = { version = "2.2.1", features = [
 ] }
 diesel-derive-enum = { version = "2.1.0", features = ["sqlite"] }
 diesel_migrations = { version = "2.2.0" }
-axum = { version = "0.6.6", default-features = false, features = [
-    "headers",
+axum = { version = "0.7.5", default-features = false, features = [
     "tokio",
     "http1",
     "http2",
@@ -263,8 +262,8 @@ axum = { version = "0.6.6", default-features = false, features = [
     "query",
     "ws",
 ] }
-axum-extra = "0.4.2"
-axum-server = { version = "0.5.1", default-features = false, features = [
+axum-extra = "0.9.3"
+axum-server = { version = "0.6.0", default-features = false, features = [
     "tls-rustls",
 ] }
 serenity = { version = "0.12.2", default-features = false, features = [

crates/rooch-faucet/Cargo.toml

@@ -20,6 +20,7 @@ serenity = { features = [
     "model",
 ], workspace = true }
 axum = { workspace = true }
+axum-server = { workspace = true }
 tracing = { workspace = true}
 tower = { workspace = true }
 tower-http = { workspace = true }

crates/rooch-faucet/src/web.rs

@@ -90,7 +90,7 @@ pub async fn serve(app: App, web_config: WebConfig) -> Result<(), anyhow::Error>
 
     let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)), web_config.port);
 
-    axum::Server::bind(&addr)
+    axum_server::bind(addr)
         .serve(router.into_make_service())
         .await?;
 

crates/rooch-rpc-api/src/api/btc_api.rs

@@ -4,7 +4,7 @@
 use crate::jsonrpc_types::btc::ord::InscriptionFilterView;
 use crate::jsonrpc_types::btc::utxo::UTXOFilterView;
 use crate::jsonrpc_types::{InscriptionPageView, StrView, UTXOPageView};
-use jsonrpsee::core::RpcResult;
+use crate::RpcResult;
 use jsonrpsee::proc_macros::rpc;
 use rooch_open_rpc_macros::open_rpc;
 use rooch_types::indexer::state::IndexerStateID;

crates/rooch-rpc-api/src/api/rooch_api.rs

@@ -12,7 +12,7 @@ use crate::jsonrpc_types::{
     ObjectIDView, ObjectStateFilterView, ObjectStateView, QueryOptions, StateOptions,
     StatePageView, StateView, StrView, StructTagView, TransactionWithInfoPageView, TxOptions,
 };
-use jsonrpsee::core::RpcResult;
+use crate::RpcResult;
 use jsonrpsee::proc_macros::rpc;
 use moveos_types::{access_path::AccessPath, state::KeyState};
 use rooch_open_rpc_macros::open_rpc;

crates/rooch-rpc-api/src/lib.rs

@@ -5,3 +5,34 @@
 
 pub mod api;
 pub mod jsonrpc_types;
+
+pub type RpcResult<T> = Result<T, RpcError>;
+use jsonrpsee::types::{ErrorObject, ErrorObjectOwned};
+use rooch_types::error::RoochError;
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum RpcError {
+    #[error(transparent)]
+    RoochError(#[from] RoochError),
+
+    #[error(transparent)]
+    InternalError(#[from] anyhow::Error),
+
+    #[error("Deserialization error: {0}")]
+    BcsError(#[from] bcs::Error),
+
+    #[error("Unexpected error: {0}")]
+    UnexpectedError(String),
+}
+
+impl From<RpcError> for ErrorObjectOwned {
+    fn from(err: RpcError) -> Self {
+        match err {
+            RpcError::RoochError(err) => ErrorObject::owned(1, err.to_string(), None::<()>),
+            RpcError::InternalError(err) => ErrorObject::owned(2, err.to_string(), None::<()>),
+            RpcError::BcsError(err) => ErrorObject::owned(3, err.to_string(), None::<()>),
+            RpcError::UnexpectedError(err) => ErrorObject::owned(4, err.to_string(), None::<()>),
+        }
+    }
+}

crates/rooch-rpc-client/src/client_config.rs

@@ -14,8 +14,8 @@ use std::fmt::{Display, Formatter, Write};
 use std::path::PathBuf;
 
 pub const DEFAULT_EXPIRATION_SECS: u64 = 30;
-pub const ROOCH_DEV_NET_URL: &str = "https://dev-seed.rooch.network:443/";
-pub const ROOCH_TEST_NET_URL: &str = "https://test-seed.rooch.network:443/";
+pub const ROOCH_DEV_NET_URL: &str = "https://dev-seed.rooch.network";
+pub const ROOCH_TEST_NET_URL: &str = "https://test-seed.rooch.network";
 
 #[derive(Serialize, Deserialize, Debug)]
 pub struct ClientConfig {
@@ -77,18 +77,13 @@ impl Env {
     pub async fn create_rpc_client(
         &self,
         request_timeout: std::time::Duration,
-        max_concurrent_requests: Option<u64>,
     ) -> Result<Client, anyhow::Error> {
         let mut builder = ClientBuilder::default();
         builder = builder.request_timeout(request_timeout);
         if let Some(ws_url) = &self.ws {
             builder = builder.ws_url(ws_url);
         }
 
-        if let Some(max_concurrent_requests) = max_concurrent_requests {
-            builder = builder.max_concurrent_requests(max_concurrent_requests as usize);
-        }
-
         builder.build(&self.rpc).await
     }
 

crates/rooch-rpc-client/src/lib.rs

@@ -25,7 +25,6 @@ pub mod wallet_context;
 
 pub struct ClientBuilder {
     request_timeout: Duration,
-    max_concurrent_requests: usize,
     ws_url: Option<String>,
 }
 
@@ -35,11 +34,6 @@ impl ClientBuilder {
         self
     }
 
-    pub fn max_concurrent_requests(mut self, max_concurrent_requests: usize) -> Self {
-        self.max_concurrent_requests = max_concurrent_requests;
-        self
-    }
-
     pub fn ws_url(mut self, url: impl AsRef<str>) -> Self {
         self.ws_url = Some(url.as_ref().to_string());
         self
@@ -50,8 +44,7 @@ impl ClientBuilder {
 
         let http_client = Arc::new(
             HttpClientBuilder::default()
-                .max_request_body_size(2 << 30)
-                .max_concurrent_requests(self.max_concurrent_requests)
+                .max_request_size(2 << 30)
                 .request_timeout(self.request_timeout)
                 .build(http)?,
         );
@@ -67,7 +60,6 @@ impl Default for ClientBuilder {
     fn default() -> Self {
         Self {
             request_timeout: Duration::from_secs(60),
-            max_concurrent_requests: 256,
             ws_url: None,
         }
     }

crates/rooch-rpc-client/src/wallet_context.rs

@@ -118,7 +118,7 @@ impl WalletContext {
             let client = self
                 .client_config
                 .get_active_env()?
-                .create_rpc_client(Duration::from_secs(DEFAULT_EXPIRATION_SECS), None)
+                .create_rpc_client(Duration::from_secs(DEFAULT_EXPIRATION_SECS))
                 .await?;
 
             self.client.write().await.insert(client).clone()

crates/rooch-rpc-server/Cargo.toml

@@ -38,7 +38,7 @@ schemars = { workspace = true }
 serde_with = { workspace = true }
 rand = { workspace = true }
 fastcrypto = { workspace = true, features = ["copy_key"] }
-hyper = { workspace = true }
+axum = { workspace = true }
 log = { workspace = true }
 lazy_static = { workspace = true }
 rpassword = { workspace = true }
@@ -68,4 +68,4 @@ rooch-indexer = { workspace = true }
 rooch-da = { workspace = true }
 rooch-framework = { workspace = true }
 rooch-genesis = { workspace = true }
-rooch-db = { workspace = true }
+rooch-db = { workspace = true }

crates/rooch-rpc-server/src/lib.rs

@@ -7,10 +7,10 @@ use crate::service::aggregate_service::AggregateService;
 use crate::service::rpc_logger::RpcLogger;
 use crate::service::rpc_service::RpcService;
 use anyhow::{ensure, Error, Result};
+use axum::http::{HeaderValue, Method};
 use coerce::actor::scheduler::timer::Timer;
 use coerce::actor::{system::ActorSystem, IntoActor};
-use hyper::header::HeaderValue;
-use hyper::Method;
+use jsonrpsee::server::middleware::rpc::RpcServiceBuilder;
 use jsonrpsee::server::ServerBuilder;
 use jsonrpsee::RpcModule;
 use raw_store::errors::RawStoreError;
@@ -34,6 +34,7 @@ use rooch_proposer::proxy::ProposerProxy;
 use rooch_relayer::actor::messages::RelayTick;
 use rooch_relayer::actor::relayer::RelayerActor;
 use rooch_rpc_api::api::RoochRpcModule;
+use rooch_rpc_api::RpcError;
 use rooch_sequencer::actor::sequencer::SequencerActor;
 use rooch_sequencer::proxy::SequencerProxy;
 use rooch_types::address::RoochAddress;
@@ -327,18 +328,20 @@ pub async fn run_start_server(opt: RoochOpt, server_opt: ServerOpt) -> Result<Se
         .allow_methods([Method::POST])
         // Allow requests from any origin
         .allow_origin(acl)
-        .allow_headers([hyper::header::CONTENT_TYPE]);
+        .allow_headers([axum::http::header::CONTENT_TYPE]);
 
     let middleware = tower::ServiceBuilder::new()
         .layer(TraceLayer::new_for_http())
         .layer(cors);
 
     let addr: SocketAddr = format!("{}:{}", config.host, config.port).parse()?;
 
+    let rpc_middleware = RpcServiceBuilder::new().layer_fn(RpcLogger);
+
     // Build server
     let server = ServerBuilder::default()
-        .set_logger(RpcLogger)
-        .set_middleware(middleware)
+        .set_http_middleware(middleware)
+        .set_rpc_middleware(rpc_middleware)
         .build(&addr)
         .await?;
 
@@ -352,7 +355,7 @@ pub async fn run_start_server(opt: RoochOpt, server_opt: ServerOpt) -> Result<Se
 
     // let rpc_api = build_rpc_api(rpc_api);
     let methods_names = rpc_module_builder.module.method_names().collect::<Vec<_>>();
-    let handle = server.start(rpc_module_builder.module)?;
+    let handle = server.start(rpc_module_builder.module);
 
     info!("JSON-RPC HTTP Server start listening {:?}", addr);
     info!("Available JSON-RPC methods : {:?}", methods_names);
@@ -369,8 +372,8 @@ fn _build_rpc_api<M: Send + Sync + 'static>(mut rpc_module: RpcModule<M>) -> Rpc
     available_methods.sort();
 
     rpc_module
-        .register_method("rpc_methods", move |_, _| {
-            Ok(json!({
+        .register_method("rpc_methods", move |_, _, _| {
+            Ok::<serde_json::Value, RpcError>(json!({
                 "methods": available_methods,
             }))
         })

crates/rooch-rpc-server/src/server/btc_server.rs

@@ -3,16 +3,14 @@
 
 use crate::service::{aggregate_service::AggregateService, rpc_service::RpcService};
 use anyhow::Result;
-use jsonrpsee::{
-    core::{async_trait, RpcResult},
-    RpcModule,
-};
+use jsonrpsee::{core::async_trait, RpcModule};
 use move_core_types::account_address::AccountAddress;
 use rooch_rpc_api::api::btc_api::BtcAPIServer;
 use rooch_rpc_api::api::{RoochRpcModule, DEFAULT_RESULT_LIMIT_USIZE, MAX_RESULT_LIMIT_USIZE};
 use rooch_rpc_api::jsonrpc_types::btc::ord::{InscriptionFilterView, InscriptionStateView};
 use rooch_rpc_api::jsonrpc_types::btc::utxo::{UTXOFilterView, UTXOStateView};
 use rooch_rpc_api::jsonrpc_types::{InscriptionPageView, StrView, UTXOPageView};
+use rooch_rpc_api::RpcResult;
 use rooch_types::indexer::state::IndexerStateID;
 use std::cmp::min;
 

crates/rooch-rpc-server/src/server/rooch_server.rs

@@ -4,10 +4,7 @@
 use crate::service::aggregate_service::AggregateService;
 use crate::service::rpc_service::RpcService;
 use anyhow::Result;
-use jsonrpsee::{
-    core::{async_trait, RpcResult},
-    RpcModule,
-};
+use jsonrpsee::{core::async_trait, RpcModule};
 use moveos_types::{
     access_path::AccessPath,
     h256::H256,
@@ -33,6 +30,8 @@ use rooch_rpc_api::jsonrpc_types::{
     ExecuteTransactionResponseView, FunctionCallView, H256View, StatePageView, StateView, StrView,
     StructTagView, TransactionWithInfoPageView,
 };
+use rooch_rpc_api::RpcError;
+use rooch_rpc_api::RpcResult;
 use rooch_rpc_api::{api::rooch_api::RoochAPIServer, api::DEFAULT_RESULT_LIMIT};
 use rooch_rpc_api::{
     api::{RoochRpcModule, DEFAULT_RESULT_LIMIT_USIZE},
@@ -160,8 +159,7 @@ impl RoochAPIServer for RoochServer {
 
     async fn send_raw_transaction(&self, payload: BytesView) -> RpcResult<H256View> {
         info!("send_raw_transaction payload: {:?}", payload);
-        let mut tx =
-            bcs::from_bytes::<RoochTransaction>(&payload.0).map_err(anyhow::Error::from)?;
+        let mut tx = bcs::from_bytes::<RoochTransaction>(&payload.0)?;
         info!("send_raw_transaction tx: {:?}", tx);
 
         let hash = tx.tx_hash();
@@ -175,7 +173,7 @@ impl RoochAPIServer for RoochServer {
         tx_options: Option<TxOptions>,
     ) -> RpcResult<ExecuteTransactionResponseView> {
         let tx_options = tx_options.unwrap_or_default();
-        let tx = bcs::from_bytes::<RoochTransaction>(&payload.0).map_err(anyhow::Error::from)?;
+        let tx = bcs::from_bytes::<RoochTransaction>(&payload.0)?;
         let tx_response = self.rpc_service.execute_tx(tx).await?;
 
         let result = if tx_options.with_output {
@@ -553,12 +551,11 @@ impl RoochAPIServer for RoochServer {
             (end..start).rev().collect::<Vec<_>>()
         } else {
             let start = cursor.unwrap_or(0);
-            let start_plus =
-                start
-                    .checked_add(limit_of + 1)
-                    .ok_or(jsonrpsee::core::Error::Custom(
-                        "cursor value is overflow".to_string(),
-                    ))?;
+            let start_plus = start
+                .checked_add(limit_of + 1)
+                .ok_or(RpcError::UnexpectedError(
+                    "cursor value is overflow".to_string(),
+                ))?;
             let end = min(start_plus, last_sequencer_order + 1);
 
             (start..end).collect::<Vec<_>>()