Git-Mirrors/xmr-btc-swap
1
0
Fork 0
mirror of https://github.com/comit-network/xmr-btc-swap.git synced 2025-03-02 11:39:15 -05:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
binarybaron 2023-08-09 21:56:18 +02:00
parent 41399ab015
commit 186b242db5
5 changed files with 189 additions and 280 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
swap/src/api.rs
View File

@ -203,13 +203,13 @@ fn env_config_from(testnet: bool) -> EnvConfig {
} }
#[cfg(test)] #[cfg(test)]
pub mod api_test { pub mod api_test {
use crate::api::request::{Method, Params, Request, Shutdown}; use super::*;
use crate::tor::DEFAULT_SOCKS5_PORT; use crate::api::request::{Method, Params, Request};
use libp2p::Multiaddr; use libp2p::Multiaddr;
use std::str::FromStr; use std::str::FromStr;
use tokio::sync::broadcast; use tokio::sync::broadcast;
use uuid::Uuid; use uuid::Uuid;
use super::*;
pub const MULTI_ADDRESS: &str = pub const MULTI_ADDRESS: &str =
"/ip4/127.0.0.1/tcp/9939/p2p/12D3KooWCdMKjesXMJz1SiZ7HgotrxuqhQJbP5sgBm2BwP1cqThi"; "/ip4/127.0.0.1/tcp/9939/p2p/12D3KooWCdMKjesXMJz1SiZ7HgotrxuqhQJbP5sgBm2BwP1cqThi";
@ -240,10 +240,11 @@ pub mod api_test {
debug, debug,
json, json,
is_testnet, is_testnet,
data_dir data_dir,
} }
} }
} }
impl Request { impl Request {
pub fn buy_xmr(is_testnet: bool, tx: broadcast::Sender<()>) -> Request { pub fn buy_xmr(is_testnet: bool, tx: broadcast::Sender<()>) -> Request {
let seller = Multiaddr::from_str(MULTI_ADDRESS).unwrap(); let seller = Multiaddr::from_str(MULTI_ADDRESS).unwrap();
@ -263,49 +264,34 @@ pub mod api_test {
} }
}; };
Request { Request::new(tx.subscribe(), Method::BuyXmr, Params {
params: Params {
seller: Some(seller), seller: Some(seller),
bitcoin_change_address: Some(bitcoin_change_address), bitcoin_change_address: Some(bitcoin_change_address),
monero_receive_address: Some(monero_receive_address), monero_receive_address: Some(monero_receive_address),
swap_id: Some(Uuid::new_v4()),
..Default::default() ..Default::default()
}, })
cmd: Method::BuyXmr,
shutdown: Shutdown::new(tx.subscribe()),
}
} }
pub fn resume(tx: broadcast::Sender<()>) -> Request { pub fn resume(tx: broadcast::Sender<()>) -> Request {
Request { Request::new(tx.subscribe(), Method::Resume, Params {
params: Params {
swap_id: Some(Uuid::from_str(SWAP_ID).unwrap()), swap_id: Some(Uuid::from_str(SWAP_ID).unwrap()),
..Default::default() ..Default::default()
}, })
cmd: Method::Resume,
shutdown: Shutdown::new(tx.subscribe()),
}
} }
pub fn cancel(tx: broadcast::Sender<()>) -> Request { pub fn cancel(tx: broadcast::Sender<()>) -> Request {
Request { Request::new(tx.subscribe(), Method::CancelAndRefund, Params {
params: Params {
swap_id: Some(Uuid::from_str(SWAP_ID).unwrap()), swap_id: Some(Uuid::from_str(SWAP_ID).unwrap()),
..Default::default() ..Default::default()
}, })
cmd: Method::CancelAndRefund,
shutdown: Shutdown::new(tx.subscribe()),
}
} }
pub fn refund(tx: broadcast::Sender<()>) -> Request { pub fn refund(tx: broadcast::Sender<()>) -> Request {
Request { Request::new(tx.subscribe(), Method::CancelAndRefund, Params {
params: Params {
swap_id: Some(Uuid::from_str(SWAP_ID).unwrap()), swap_id: Some(Uuid::from_str(SWAP_ID).unwrap()),
..Default::default() ..Default::default()
}, })
cmd: Method::CancelAndRefund,
shutdown: Shutdown::new(tx.subscribe()),
}
} }
} }
} }

102
swap/src/api/request.rs
View File

@ -15,10 +15,12 @@ use serde_json::json;
use std::cmp::min; use std::cmp::min;
use std::convert::TryInto; use std::convert::TryInto;
use std::future::Future; use std::future::Future;
use std::net::SocketAddr;
use std::sync::Arc; use std::sync::Arc;
use std::time::Duration; use std::time::Duration;
use std::net::SocketAddr;
use tokio::sync::broadcast; use tokio::sync::broadcast;
use tokio::sync::broadcast::Receiver;
use tracing::{debug_span, Instrument};
use uuid::Uuid; use uuid::Uuid;
#[derive(PartialEq, Debug)] #[derive(PartialEq, Debug)]
@ -29,7 +31,7 @@ pub struct Request {
} }
impl Shutdown { impl Shutdown {
pub fn new(notify: broadcast::Receiver<()>) -> Shutdown { pub fn new(notify: Receiver<()>) -> Shutdown {
Shutdown { Shutdown {
shutdown: false, shutdown: false,
notify, notify,
@ -101,11 +103,21 @@ pub enum Method {
} }
impl Request { impl Request {
pub async fn call(&mut self, context: Arc<Context>) -> Result<serde_json::Value> { pub fn new(shutdownReceiver: Receiver<()>, cmd: Method, params: Params) -> Request {
let result = match self.cmd { Request {
Method::BuyXmr => { params,
let swap_id = Uuid::new_v4(); cmd,
shutdown: Shutdown::new(shutdownReceiver),
}
}
async fn handle_cmd(&mut self, context: Arc<Context>) -> Result<serde_json::Value> {
match self.cmd {
Method::BuyXmr => {
let swap_id = self
.params
.swap_id
.context("Parameter swap_id is missing")?;
let seed = context.config.seed.as_ref().context("Could not get seed")?; let seed = context.config.seed.as_ref().context("Could not get seed")?;
let env_config = context.config.env_config; let env_config = context.config.env_config;
let btc = context let btc = context
@ -217,9 +229,9 @@ impl Request {
.context("Failed to complete swap")?; .context("Failed to complete swap")?;
} }
} }
json!({ Ok(json!({
"empty": "true" "empty": "true"
}) }))
} }
Method::History => { Method::History => {
let swaps = context.db.all().await?; let swaps = context.db.all().await?;
@ -229,11 +241,11 @@ impl Request {
vec.push((swap_id, state.to_string())); vec.push((swap_id, state.to_string()));
} }
json!({ "swaps": vec }) Ok(json!({ "swaps": vec }))
} }
Method::RawHistory => { Method::RawHistory => {
let raw_history = context.db.raw_all().await?; let raw_history = context.db.raw_all().await?;
json!({ "raw_history": raw_history }) Ok(json!({ "raw_history": raw_history }))
} }
Method::GetSeller => { Method::GetSeller => {
let swap_id = self.params.swap_id.context("Parameter swap_id is needed")?; let swap_id = self.params.swap_id.context("Parameter swap_id is needed")?;
@ -249,10 +261,10 @@ impl Request {
.await .await
.with_context(|| "Could not get addressess")?; .with_context(|| "Could not get addressess")?;
json!({ Ok(json!({
"peerId": peerId.to_base58(), "peerId": peerId.to_base58(),
"addresses": addresses "addresses": addresses
}) }))
} }
Method::SwapStartDate => { Method::SwapStartDate => {
let swap_id = self let swap_id = self
@ -262,9 +274,9 @@ impl Request {
let start_date = context.db.get_swap_start_date(swap_id).await?; let start_date = context.db.get_swap_start_date(swap_id).await?;
json!({ Ok(json!({
"start_date": start_date, "start_date": start_date,
}) }))
} }
Method::Config => { Method::Config => {
let data_dir_display = context.config.data_dir.display(); let data_dir_display = context.config.data_dir.display();
@ -275,13 +287,13 @@ impl Request {
tracing::info!(path=%format!("{}/monero", data_dir_display), "Monero-wallet-rpc directory"); tracing::info!(path=%format!("{}/monero", data_dir_display), "Monero-wallet-rpc directory");
tracing::info!(path=%format!("{}/wallet", data_dir_display), "Internal bitcoin wallet directory"); tracing::info!(path=%format!("{}/wallet", data_dir_display), "Internal bitcoin wallet directory");
json!({ Ok(json!({
"log_files": format!("{}/logs", data_dir_display), "log_files": format!("{}/logs", data_dir_display),
"sqlite": format!("{}/sqlite", data_dir_display), "sqlite": format!("{}/sqlite", data_dir_display),
"seed": format!("{}/seed.pem", data_dir_display), "seed": format!("{}/seed.pem", data_dir_display),
"monero-wallet-rpc": format!("{}/monero", data_dir_display), "monero-wallet-rpc": format!("{}/monero", data_dir_display),
"bitcoin_wallet": format!("{}/wallet", data_dir_display), "bitcoin_wallet": format!("{}/wallet", data_dir_display),
}) }))
} }
Method::WithdrawBtc => { Method::WithdrawBtc => {
let bitcoin_wallet = context let bitcoin_wallet = context
@ -312,22 +324,20 @@ impl Request {
.broadcast(signed_tx.clone(), "withdraw") .broadcast(signed_tx.clone(), "withdraw")
.await?; .await?;
json!({ Ok(json!({
"signed_tx": signed_tx, "signed_tx": signed_tx,
"amount": amount.to_sat(), "amount": amount.to_sat(),
"txid": signed_tx.txid(), "txid": signed_tx.txid(),
}) }))
} }
Method::StartDaemon => { Method::StartDaemon => {
let server_address = match self.params.server_address { let server_address = match self.params.server_address {
Some(address) => address, Some(address) => address,
None => { None => "127.0.0.1:3456".parse()?,
"127.0.0.1:3456".parse()?
}
}; };
let (_, server_handle) =
let (_, server_handle) = rpc::run_server(server_address, Arc::clone(&context)).await?; rpc::run_server(server_address, Arc::clone(&context)).await?;
loop { loop {
tokio::select! { tokio::select! {
@ -353,9 +363,9 @@ impl Request {
"Checked Bitcoin balance", "Checked Bitcoin balance",
); );
json!({ Ok(json!({
"balance": bitcoin_balance.to_sat() "balance": bitcoin_balance.to_sat()
}) }))
} }
Method::Resume => { Method::Resume => {
let swap_id = self let swap_id = self
@ -437,9 +447,9 @@ impl Request {
swap_result?; swap_result?;
} }
} }
json!({ Ok(json!({
"result": [] "result": []
}) }))
} }
Method::CancelAndRefund => { Method::CancelAndRefund => {
let bitcoin_wallet = context let bitcoin_wallet = context
@ -456,9 +466,9 @@ impl Request {
) )
.await?; .await?;
json!({ Ok(json!({
"result": state, "result": state,
}) }))
} }
Method::ListSellers => { Method::ListSellers => {
let rendezvous_point = self let rendezvous_point = self
@ -511,7 +521,7 @@ impl Request {
} }
} }
json!({ "sellers": sellers }) Ok(json!({ "sellers": sellers }))
} }
Method::ExportBitcoinWallet => { Method::ExportBitcoinWallet => {
let bitcoin_wallet = context let bitcoin_wallet = context
@ -521,9 +531,9 @@ impl Request {
let wallet_export = bitcoin_wallet.wallet_export("cli").await?; let wallet_export = bitcoin_wallet.wallet_export("cli").await?;
tracing::info!(descriptor=%wallet_export.to_string(), "Exported bitcoin wallet"); tracing::info!(descriptor=%wallet_export.to_string(), "Exported bitcoin wallet");
json!({ Ok(json!({
"result": [] "result": []
}) }))
} }
Method::MoneroRecovery => { Method::MoneroRecovery => {
let swap_state: BobState = context let swap_state: BobState = context
@ -567,12 +577,32 @@ impl Request {
println!("Spend key: {}", spend_key); println!("Spend key: {}", spend_key);
} }
} }
json!({ Ok(json!({
"result": [] "result": []
}) }))
} }
}; }
Ok(result) }
pub async fn call(&mut self, context: Arc<Context>) -> Result<serde_json::Value> {
// If the swap ID is set, we add it to the span
let call_span = self.params.swap_id.map_or_else(
|| {
debug_span!(
"call",
method = ?self.cmd,
)
},
|swap_id| {
debug_span!(
"call",
method = ?self.cmd,
swap_id = swap_id.to_string(),
)
},
);
self.handle_cmd(context).instrument(call_span).await
} }
} }

92
swap/src/cli/command.rs
View File

@ -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::api::Context;
use crate::bitcoin::{bitcoin_address, Amount}; use crate::bitcoin::{bitcoin_address, Amount};
use crate::monero; use crate::monero;
@ -78,16 +78,12 @@ where
let bitcoin_change_address = let bitcoin_change_address =
bitcoin_address::validate(bitcoin_change_address, is_testnet)?; bitcoin_address::validate(bitcoin_change_address, is_testnet)?;
let request = Request { let request = Request::new(rx.subscribe(), Method::BuyXmr, Params {
params: Params {
bitcoin_change_address: Some(bitcoin_change_address), bitcoin_change_address: Some(bitcoin_change_address),
monero_receive_address: Some(monero_receive_address), monero_receive_address: Some(monero_receive_address),
seller: Some(seller), seller: Some(seller),
..Default::default() ..Default::default()
}, });
cmd: Method::BuyXmr,
shutdown: Shutdown::new(rx.subscribe()),
};
let context = Context::build( let context = Context::build(
Some(bitcoin), Some(bitcoin),
@ -104,33 +100,21 @@ where
(context, request) (context, request)
} }
CliCommand::History => { CliCommand::History => {
let request = Request { let request = Request::new(rx.subscribe(), Method::History, Params::default());
params: Params::default(),
cmd: Method::History,
shutdown: Shutdown::new(rx.subscribe()),
};
let context = let context =
Context::build(None, None, None, data, is_testnet, debug, json, None, rx).await?; Context::build(None, None, None, data, is_testnet, debug, json, None, rx).await?;
(context, request) (context, request)
} }
CliCommand::Config => { CliCommand::Config => {
let request = Request { let request = Request::new(rx.subscribe(), Method::Config, Params::default());
params: Params::default(),
cmd: Method::Config,
shutdown: Shutdown::new(rx.subscribe()),
};
let context = let context =
Context::build(None, None, None, data, is_testnet, debug, json, None, rx).await?; Context::build(None, None, None, data, is_testnet, debug, json, None, rx).await?;
(context, request) (context, request)
} }
CliCommand::Balance { bitcoin } => { CliCommand::Balance { bitcoin } => {
let request = Request { let request = Request::new(rx.subscribe(), Method::Balance, Params::default());
params: Params::default(),
cmd: Method::Balance,
shutdown: Shutdown::new(rx.subscribe()),
};
let context = Context::build( let context = Context::build(
Some(bitcoin), Some(bitcoin),
@ -152,11 +136,7 @@ where
monero, monero,
tor, tor,
} => { } => {
let request = Request { let request = Request::new(rx.subscribe(), Method::StartDaemon, Params::default());
params: Params::default(),
cmd: Method::StartDaemon,
shutdown: Shutdown::new(rx.subscribe()),
};
let context = Context::build( let context = Context::build(
Some(bitcoin), Some(bitcoin),
@ -179,15 +159,11 @@ where
} => { } => {
let address = bitcoin_address::validate(address, is_testnet)?; let address = bitcoin_address::validate(address, is_testnet)?;
let request = Request { let request = Request::new(rx.subscribe(), Method::WithdrawBtc, Params {
params: Params {
amount, amount,
address: Some(address), address: Some(address),
..Default::default() ..Default::default()
}, });
cmd: Method::WithdrawBtc,
shutdown: Shutdown::new(rx.subscribe()),
};
let context = Context::build( let context = Context::build(
Some(bitcoin), Some(bitcoin),
@ -209,14 +185,10 @@ where
monero, monero,
tor, tor,
} => { } => {
let request = Request { let request = Request::new(rx.subscribe(), Method::Resume, Params {
params: Params {
swap_id: Some(swap_id), swap_id: Some(swap_id),
..Default::default() ..Default::default()
}, });
cmd: Method::Resume,
shutdown: Shutdown::new(rx.subscribe()),
};
let context = Context::build( let context = Context::build(
Some(bitcoin), Some(bitcoin),
@ -237,14 +209,10 @@ where
bitcoin, bitcoin,
tor, tor,
} => { } => {
let request = Request { let request = Request::new(rx.subscribe(), Method::CancelAndRefund, Params {
params: Params {
swap_id: Some(swap_id), swap_id: Some(swap_id),
..Default::default() ..Default::default()
}, });
cmd: Method::CancelAndRefund,
shutdown: Shutdown::new(rx.subscribe()),
};
let context = Context::build( let context = Context::build(
Some(bitcoin), Some(bitcoin),
@ -264,14 +232,10 @@ where
rendezvous_point, rendezvous_point,
tor, tor,
} => { } => {
let request = Request { let request = Request::new(rx.subscribe(), Method::ListSellers, Params {
params: Params {
rendezvous_point: Some(rendezvous_point), rendezvous_point: Some(rendezvous_point),
..Default::default() ..Default::default()
}, });
cmd: Method::ListSellers,
shutdown: Shutdown::new(rx.subscribe()),
};
let context = Context::build( let context = Context::build(
None, None,
@ -289,11 +253,11 @@ where
(context, request) (context, request)
} }
CliCommand::ExportBitcoinWallet { bitcoin } => { CliCommand::ExportBitcoinWallet { bitcoin } => {
let request = Request { let request = Request::new(
params: Params::default(), rx.subscribe(),
cmd: Method::ExportBitcoinWallet, Method::ExportBitcoinWallet,
shutdown: Shutdown::new(rx.subscribe()), Params::default(),
}; );
let context = Context::build( let context = Context::build(
Some(bitcoin), Some(bitcoin),
@ -309,15 +273,13 @@ where
.await?; .await?;
(context, request) (context, request)
} }
CliCommand::MoneroRecovery { swap_id } => { CliCommand::MoneroRecovery {
let request = Request { swap_id: SwapId { swap_id },
params: Params { } => {
swap_id: Some(swap_id.swap_id), let request = Request::new(rx.subscribe(), Method::MoneroRecovery, Params {
swap_id: Some(swap_id),
..Default::default() ..Default::default()
}, });
cmd: Method::MoneroRecovery,
shutdown: Shutdown::new(rx.subscribe()),
};
let context = let context =
Context::build(None, None, None, data, is_testnet, debug, json, None, rx).await?; Context::build(None, None, None, data, is_testnet, debug, json, None, rx).await?;
@ -575,7 +537,7 @@ struct Seller {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
use crate::tor::DEFAULT_SOCKS5_PORT;
use crate::api::api_test::*; use crate::api::api_test::*;
use crate::api::Config; use crate::api::Config;

129
swap/src/rpc/methods.rs
View File

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

26
swap/tests/rpc.rs
View File

@ -1,22 +1,22 @@
use anyhow::{bail, Context as AnyContext, Result}; use anyhow::{Result};
use futures::Future;
use jsonrpsee::ws_client::WsClientBuilder; use jsonrpsee::ws_client::WsClientBuilder;
use jsonrpsee::{rpc_params, RpcModule}; use jsonrpsee::{rpc_params};
use jsonrpsee_core::client::ClientT; use jsonrpsee_core::client::ClientT;
use jsonrpsee_core::params::ObjectParams; use jsonrpsee_core::params::ObjectParams;
use jsonrpsee_types::error::CallError;
use sequential_test::sequential; use sequential_test::sequential;
use serde_json::{json, Value};
use std::collections::HashMap; use std::collections::HashMap;
use std::sync::Arc; use std::sync::Arc;
use std::time::Duration; use std::time::Duration;
use swap::api::request::{Method, Params, Request, Shutdown}; use swap::api::request::{Method, Params, Request, Shutdown};
use swap::api::{Config, Context}; use swap::api::{Context};
use swap::cli::command::{Bitcoin, Monero}; use swap::cli::command::{Bitcoin, Monero};
use testcontainers::clients::Cli;
use testcontainers::{Container, Docker, RunArgs};
use tokio::sync::broadcast; use tokio::sync::broadcast;
use tokio::time::{interval, timeout};
use uuid::Uuid; use uuid::Uuid;
#[cfg(test)] #[cfg(test)]
@ -42,15 +42,11 @@ pub async fn initialize_context() -> (Arc<Context>, Request) {
bitcoin_target_block: None, bitcoin_target_block: None,
}; };
let monero = Monero { let _monero = Monero {
monero_daemon_address: None, monero_daemon_address: None,
}; };
let mut request = Request { let request = Request::new(tx.subscribe(), Method::StartDaemon, Params::default());
params: Params::default(),
cmd: Method::StartDaemon,
shutdown: Shutdown::new(tx.subscribe()),
};
let context = Context::build( let context = Context::build(
Some(bitcoin), Some(bitcoin),