Add called api method and swap_id to tracing for context, reduced boilerplate

swap/src/rpc/methods.rs

@@ -1,4 +1,4 @@
-use crate::api::request::{Method, Params, Request, Shutdown};
+use crate::api::request::{Method, Params, Request};
 use crate::api::Context;
 use crate::bitcoin::bitcoin_address;
 use crate::monero::monero_address;
@@ -142,129 +142,78 @@ pub fn register_modules(context: Arc<Context>) -> RpcModule<Arc<Context>> {
     module
 }
 
+async fn execute_request(
+    cmd: Method,
+    params: Params,
+    context: &Arc<Context>,
+) -> Result<serde_json::Value, jsonrpsee_core::Error> {
+    let mut request = Request::new(context.shutdown.subscribe(), cmd, params);
+    request
+        .call(Arc::clone(context))
+        .await
+        .map_err(|err| jsonrpsee_core::Error::Custom(err.to_string()))
+}
+
 async fn get_bitcoin_balance(
     context: &Arc<Context>,
 ) -> Result<serde_json::Value, jsonrpsee_core::Error> {
-    let mut request = Request {
-        params: Params::default(),
-        cmd: Method::Balance,
-        shutdown: Shutdown::new(context.shutdown.subscribe()),
-    };
-    let balance = request
-        .call(Arc::clone(context))
-        .await
-        .map_err(|err| jsonrpsee_core::Error::Custom(err.to_string()))?;
-
-    Ok(balance)
+    execute_request(Method::Balance, Params::default(), context).await
 }
 
 async fn get_history(context: &Arc<Context>) -> Result<serde_json::Value, jsonrpsee_core::Error> {
-    let mut request = Request {
-        params: Params::default(),
-        cmd: Method::History,
-        shutdown: Shutdown::new(context.shutdown.subscribe()),
-    };
-    let history = request
-        .call(Arc::clone(context))
-        .await
-        .map_err(|err| jsonrpsee_core::Error::Custom(err.to_string()))?;
-
-    Ok(history)
+    execute_request(Method::History, Params::default(), context).await
 }
+
 async fn get_raw_history(
     context: &Arc<Context>,
 ) -> Result<serde_json::Value, jsonrpsee_core::Error> {
-    let mut request = Request {
-        params: Params::default(),
-        cmd: Method::RawHistory,
-        shutdown: Shutdown::new(context.shutdown.subscribe()),
-    };
-    let history = request
-        .call(Arc::clone(context))
-        .await
-        .map_err(|err| jsonrpsee_core::Error::Custom(err.to_string()))?;
-
-    Ok(history)
+    execute_request(Method::RawHistory, Params::default(), context).await
 }
 
 async fn get_seller(
     swap_id: Uuid,
     context: &Arc<Context>,
 ) -> Result<serde_json::Value, jsonrpsee_core::Error> {
-    let mut request = Request {
-        params: Params {
-            swap_id: Some(swap_id),
-            ..Default::default()
-        },
-        cmd: Method::GetSeller,
-        shutdown: Shutdown::new(context.shutdown.subscribe()),
+    let params = Params {
+        swap_id: Some(swap_id),
+        ..Default::default()
     };
-    let result = request
-        .call(Arc::clone(context))
-        .await
-        .map_err(|err| jsonrpsee_core::Error::Custom(err.to_string()))?;
-
-    Ok(result)
+    execute_request(Method::GetSeller, params, context).await
 }
 
 async fn get_swap_start_date(
     swap_id: Uuid,
     context: &Arc<Context>,
 ) -> Result<serde_json::Value, jsonrpsee_core::Error> {
-    let mut request = Request {
-        params: Params {
-            swap_id: Some(swap_id),
-            ..Default::default()
-        },
-        cmd: Method::SwapStartDate,
-        shutdown: Shutdown::new(context.shutdown.subscribe()),
+    let params = Params {
+        swap_id: Some(swap_id),
+        ..Default::default()
     };
-    let result = request
-        .call(Arc::clone(context))
-        .await
-        .map_err(|err| jsonrpsee_core::Error::Custom(err.to_string()))?;
-
-    Ok(result)
+    execute_request(Method::SwapStartDate, params, context).await
 }
 
 async fn resume_swap(
     swap_id: Uuid,
     context: &Arc<Context>,
 ) -> Result<serde_json::Value, jsonrpsee_core::Error> {
-    let mut request = Request {
-        params: Params {
-            swap_id: Some(swap_id),
-            ..Default::default()
-        },
-        cmd: Method::Resume,
-        shutdown: Shutdown::new(context.shutdown.subscribe()),
+    let params = Params {
+        swap_id: Some(swap_id),
+        ..Default::default()
     };
-
-    let result = request
-        .call(Arc::clone(context))
-        .await
-        .map_err(|err| jsonrpsee_core::Error::Custom(err.to_string()))?;
-    Ok(result)
+    execute_request(Method::Resume, params, context).await
 }
+
 async fn withdraw_btc(
     withdraw_address: bitcoin::Address,
     amount: Option<bitcoin::Amount>,
     context: &Arc<Context>,
 ) -> Result<serde_json::Value, jsonrpsee_core::Error> {
-    let mut request = Request {
-        params: Params {
-            amount,
-            address: Some(withdraw_address),
-            ..Default::default()
-        },
-        cmd: Method::WithdrawBtc,
-        shutdown: Shutdown::new(context.shutdown.subscribe()),
+    let params = Params {
+        amount,
+        address: Some(withdraw_address),
+        ..Default::default()
     };
-    let result = request
-        .call(Arc::clone(context))
-        .await
-        .map_err(|err| jsonrpsee_core::Error::Custom(err.to_string()))?;
-    Ok(result)
+    execute_request(Method::WithdrawBtc, params, context).await
 }
 
 async fn buy_xmr(
@@ -273,38 +222,24 @@ async fn buy_xmr(
     seller: Multiaddr,
     context: &Arc<Context>,
 ) -> Result<serde_json::Value, jsonrpsee_core::Error> {
-    let mut request = Request {
-        params: Params {
-            bitcoin_change_address: Some(bitcoin_change_address),
-            monero_receive_address: Some(monero_receive_address),
-            seller: Some(seller),
-            ..Default::default()
-        },
-        cmd: Method::BuyXmr,
-        shutdown: Shutdown::new(context.shutdown.subscribe()),
+    let params = Params {
+        bitcoin_change_address: Some(bitcoin_change_address),
+        monero_receive_address: Some(monero_receive_address),
+        seller: Some(seller),
+        swap_id: Some(Uuid::new_v4()),
+        ..Default::default()
     };
-    let swap = request
-        .call(Arc::clone(context))
-        .await
-        .map_err(|err| jsonrpsee_core::Error::Custom(err.to_string()))?;
-    Ok(swap)
+
+    execute_request(Method::BuyXmr, params, context).await
 }
 
 async fn list_sellers(
     rendezvous_point: Multiaddr,
     context: &Arc<Context>,
 ) -> Result<serde_json::Value, jsonrpsee_core::Error> {
-    let mut request = Request {
-        params: Params {
-            rendezvous_point: Some(rendezvous_point),
-            ..Default::default()
-        },
-        cmd: Method::ListSellers,
-        shutdown: Shutdown::new(context.shutdown.subscribe()),
+    let params = Params {
+        rendezvous_point: Some(rendezvous_point),
+        ..Default::default()
     };
-    let result = request
-        .call(Arc::clone(context))
-        .await
-        .map_err(|err| jsonrpsee_core::Error::Custom(err.to_string()))?;
-    Ok(result)
+    execute_request(Method::ListSellers, params, context).await
 }