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

cargo fmt

Browse source
This commit is contained in:
Lorenzo Tucci 2023-10-07 19:02:11 +03:00
parent c0e759e9f2
commit 4e631759b2
No known key found for this signature in database
GPG key ID: D98C4FA2CDF590A0
4 changed files with 198 additions and 200 deletions
Download patch file Download diff file Expand all files Collapse all files

4
swap/src/api.rs
View file

@ -226,7 +226,9 @@ impl Context {
bitcoin_wallet: Some(bob_bitcoin_wallet),
monero_wallet: Some(bob_monero_wallet),
config,
db: open_db(db_path).await.expect("Could not open sqlite database"),
db: open_db(db_path)
.await
.expect("Could not open sqlite database"),
monero_rpc_process: None,
swap_lock: Arc::new(SwapLock::new()),
}

98
swap/src/api/request.rs
View file

@ -70,7 +70,11 @@ impl Method {
fn get_tracing_span(&self, log_reference_id: Option<String>) -> Span {
let span = match self {
Method::Balance => {
debug_span!("method", method_name = "Balance", log_reference_id = field::Empty)
debug_span!(
"method",
method_name = "Balance",
log_reference_id = field::Empty
)
}
Method::BuyXmr { swap_id, .. } => {
debug_span!("method", method_name="BuyXmr", swap_id=%swap_id, log_reference_id=field::Empty)
@ -82,7 +86,11 @@ impl Method {
debug_span!("method", method_name="Resume", swap_id=%swap_id, log_reference_id=field::Empty)
}
Method::Config => {
debug_span!("method", method_name = "Config", log_reference_id = field::Empty)
debug_span!(
"method",
method_name = "Config",
log_reference_id = field::Empty
)
}
Method::ExportBitcoinWallet => {
debug_span!(
@ -106,7 +114,11 @@ impl Method {
)
}
Method::History => {
debug_span!("method", method_name = "History", log_reference_id = field::Empty)
debug_span!(
"method",
method_name = "History",
log_reference_id = field::Empty
)
}
Method::ListSellers { .. } => {
debug_span!(
@ -179,9 +191,7 @@ impl Request {
if let Some(id_value) = swap_id {
context.swap_lock.send_suspend_signal().await?;
Ok(json!({
"swapId": id_value
}))
Ok(json!({ "swapId": id_value }))
} else {
bail!("No swap is currently running")
}
@ -301,7 +311,12 @@ impl Request {
} => {
context.swap_lock.acquire_swap_lock(swap_id).await?;
let bitcoin_wallet = Arc::clone(&context.bitcoin_wallet.as_ref().expect("Could not find Bitcoin wallet"));
let bitcoin_wallet = Arc::clone(
&context
.bitcoin_wallet
.as_ref()
.expect("Could not find Bitcoin wallet"),
);
let env_config = context.config.env_config;
let seed = context.config.seed.clone().context("Could not get seed")?;
@ -415,9 +430,7 @@ impl Request {
}
tracing::debug!(%swap_id, "Swap completed");
Ok::<_, anyhow::Error>(())
} => {
}
} => { }
};
context
.swap_lock
@ -462,7 +475,7 @@ impl Request {
.context("Could not get Tor SOCKS5 port")?,
behaviour,
)
.await?;
.await?;
let our_peer_id = swarm.local_peer_id();
tracing::debug!(peer_id = %our_peer_id, "Network layer initialized");
@ -494,36 +507,40 @@ impl Request {
context.config.env_config,
event_loop_handle,
monero_receive_address,
).await?;
)
.await?;
tokio::spawn(async move {
tokio::select! {
_ = async {
let handle = tokio::spawn(event_loop.run().in_current_span());
tokio::spawn(
async move {
tokio::select! {
_ = async {
let handle = tokio::spawn(event_loop.run().in_current_span());
tokio::select! {
event_loop_result = handle => {
event_loop_result?;
},
swap_result = bob::run(swap) => {
swap_result?;
}
};
Ok::<(), anyhow::Error>(())
} => {
},
_ = context.swap_lock.listen_for_swap_force_suspension() => {
tracing::debug!("Shutdown signal received, exiting");
}
tokio::select! {
event_loop_result = handle => {
event_loop_result?;
},
swap_result = bob::run(swap) => {
swap_result?;
}
};
Ok::<(), anyhow::Error>(())
} => {
},
_ = context.swap_lock.listen_for_swap_force_suspension() => {
tracing::debug!("Shutdown signal received, exiting");
}
}
context
.swap_lock
.release_swap_lock()
.await
.expect("Could not release swap lock");
}
context
.swap_lock
.release_swap_lock()
.await
.expect("Could not release swap lock");
}.in_current_span());
.in_current_span(),
);
Ok(json!({
"result": "ok",
}))
@ -741,10 +758,7 @@ impl Request {
}
pub async fn call(self, context: Arc<Context>) -> Result<serde_json::Value> {
let method_span = self
.cmd
.get_tracing_span(self.log_reference.clone())
;
let method_span = self.cmd.get_tracing_span(self.log_reference.clone());
self.handle_cmd(context).instrument(method_span).await
}

2
swap/src/bitcoin/wallet.rs
View file

@ -785,7 +785,7 @@ impl Client {
if !self.script_history.contains_key(&script) {
self.script_history.insert(script.clone(), vec![]);
// When we first subscribe to a script we want to immediately fetch its status
// Otherwise we would have to wait for the next sync interval, which can take a minute
// This would result in potentially inaccurate status updates until that next sync interval is hit

294
swap/src/rpc/methods.rs
View file

@ -15,13 +15,65 @@ use uuid::Uuid;
pub fn register_modules(context: Arc<Context>) -> Result<RpcModule<Arc<Context>>> {
let mut module = RpcModule::new(context);
module
.register_async_method("suspend_current_swap", |params, context| async move {
execute_request(params, Method::SuspendCurrentSwap, &context).await
})?;
module.register_async_method("suspend_current_swap", |params, context| async move {
execute_request(params, Method::SuspendCurrentSwap, &context).await
})?;
module
.register_async_method("get_swap_info", |params_raw, context| async move {
module.register_async_method("get_swap_info", |params_raw, context| async move {
let params: HashMap<String, Uuid> = params_raw.parse()?;
let swap_id = params
.get("swap_id")
.ok_or_else(|| jsonrpsee_core::Error::Custom("Does not contain swap_id".to_string()))?;
execute_request(
params_raw,
Method::GetSwapInfo { swap_id: *swap_id },
&context,
)
.await
})?;
module.register_async_method("get_bitcoin_balance", |params, context| async move {
execute_request(params, Method::Balance, &context).await
})?;
module.register_async_method("get_history", |params, context| async move {
execute_request(params, Method::History, &context).await
})?;
module.register_async_method("get_raw_states", |params, context| async move {
execute_request(params, Method::GetRawStates, &context).await
})?;
module.register_async_method("resume_swap", |params_raw, context| async move {
let params: HashMap<String, Uuid> = params_raw.parse()?;
let swap_id = params
.get("swap_id")
.ok_or_else(|| jsonrpsee_core::Error::Custom("Does not contain swap_id".to_string()))?;
execute_request(params_raw, Method::Resume { swap_id: *swap_id }, &context).await
})?;
module.register_async_method("cancel_refund_swap", |params_raw, context| async move {
let params: HashMap<String, Uuid> = params_raw.parse()?;
let swap_id = params
.get("swap_id")
.ok_or_else(|| jsonrpsee_core::Error::Custom("Does not contain swap_id".to_string()))?;
execute_request(
params_raw,
Method::CancelAndRefund { swap_id: *swap_id },
&context,
)
.await
})?;
module.register_async_method(
"get_monero_recovery_info",
|params_raw, context| async move {
let params: HashMap<String, Uuid> = params_raw.parse()?;
let swap_id = params.get("swap_id").ok_or_else(|| {
@ -30,179 +82,109 @@ pub fn register_modules(context: Arc<Context>) -> Result<RpcModule<Arc<Context>>
execute_request(
params_raw,
Method::GetSwapInfo { swap_id: *swap_id },
Method::MoneroRecovery { swap_id: *swap_id },
&context,
)
.await
})?;
},
)?;
module
.register_async_method("get_bitcoin_balance", |params, context| async move {
execute_request(params, Method::Balance, &context).await
})?;
module.register_async_method("withdraw_btc", |params_raw, context| async move {
let params: HashMap<String, String> = params_raw.parse()?;
module
.register_async_method("get_history", |params, context| async move {
execute_request(params, Method::History, &context).await
})?;
module
.register_async_method("get_raw_states", |params, context| async move {
execute_request(params, Method::GetRawStates, &context).await
})?;
module
.register_async_method("resume_swap", |params_raw, context| async move {
let params: HashMap<String, Uuid> = params_raw.parse()?;
let swap_id = params.get("swap_id").ok_or_else(|| {
jsonrpsee_core::Error::Custom("Does not contain swap_id".to_string())
})?;
execute_request(params_raw, Method::Resume { swap_id: *swap_id }, &context).await
})?;
module
.register_async_method("cancel_refund_swap", |params_raw, context| async move {
let params: HashMap<String, Uuid> = params_raw.parse()?;
let swap_id = params.get("swap_id").ok_or_else(|| {
jsonrpsee_core::Error::Custom("Does not contain swap_id".to_string())
})?;
execute_request(
params_raw,
Method::CancelAndRefund { swap_id: *swap_id },
&context,
let amount = if let Some(amount_str) = params.get("amount") {
Some(
::bitcoin::Amount::from_str_in(amount_str, ::bitcoin::Denomination::Bitcoin)
.map_err(|_| {
jsonrpsee_core::Error::Custom("Unable to parse amount".to_string())
})?,
)
.await
})?;
} else {
None
};
module
.register_async_method(
"get_monero_recovery_info",
|params_raw, context| async move {
let params: HashMap<String, Uuid> = params_raw.parse()?;
let withdraw_address =
bitcoin::Address::from_str(params.get("address").ok_or_else(|| {
jsonrpsee_core::Error::Custom("Does not contain address".to_string())
})?)
.map_err(|err| jsonrpsee_core::Error::Custom(err.to_string()))?;
let withdraw_address =
bitcoin_address::validate(withdraw_address, context.config.env_config.bitcoin_network)?;
let swap_id = params.get("swap_id").ok_or_else(|| {
jsonrpsee_core::Error::Custom("Does not contain swap_id".to_string())
})?;
execute_request(
params_raw,
Method::WithdrawBtc {
amount,
address: withdraw_address,
},
&context,
)
.await
})?;
execute_request(
params_raw,
Method::MoneroRecovery { swap_id: *swap_id },
&context,
)
.await
})?;
module.register_async_method("buy_xmr", |params_raw, context| async move {
let params: HashMap<String, String> = params_raw.parse()?;
module
.register_async_method("withdraw_btc", |params_raw, context| async move {
let params: HashMap<String, String> = params_raw.parse()?;
let amount = if let Some(amount_str) = params.get("amount") {
Some(
::bitcoin::Amount::from_str_in(amount_str, ::bitcoin::Denomination::Bitcoin)
.map_err(|_| {
jsonrpsee_core::Error::Custom("Unable to parse amount".to_string())
})?,
)
} else {
None
};
let withdraw_address =
bitcoin::Address::from_str(params.get("address").ok_or_else(|| {
jsonrpsee_core::Error::Custom("Does not contain address".to_string())
})?)
.map_err(|err| jsonrpsee_core::Error::Custom(err.to_string()))?;
let withdraw_address = bitcoin_address::validate(
withdraw_address,
context.config.env_config.bitcoin_network,
)?;
execute_request(
params_raw,
Method::WithdrawBtc {
amount,
address: withdraw_address,
},
&context,
)
.await
})?;
module
.register_async_method("buy_xmr", |params_raw, context| async move {
let params: HashMap<String, String> = params_raw.parse()?;
let bitcoin_change_address = bitcoin::Address::from_str(
params.get("bitcoin_change_address").ok_or_else(|| {
jsonrpsee_core::Error::Custom(
"Does not contain bitcoin_change_address".to_string(),
)
})?,
)
let bitcoin_change_address =
bitcoin::Address::from_str(params.get("bitcoin_change_address").ok_or_else(|| {
jsonrpsee_core::Error::Custom("Does not contain bitcoin_change_address".to_string())
})?)
.map_err(|err| jsonrpsee_core::Error::Custom(err.to_string()))?;
let bitcoin_change_address = bitcoin_address::validate(
bitcoin_change_address,
context.config.env_config.bitcoin_network,
)?;
let bitcoin_change_address = bitcoin_address::validate(
bitcoin_change_address,
context.config.env_config.bitcoin_network,
)?;
let monero_receive_address = monero::Address::from_str(
params.get("monero_receive_address").ok_or_else(|| {
jsonrpsee_core::Error::Custom(
"Does not contain monero_receiveaddress".to_string(),
)
})?,
)
let monero_receive_address =
monero::Address::from_str(params.get("monero_receive_address").ok_or_else(|| {
jsonrpsee_core::Error::Custom("Does not contain monero_receiveaddress".to_string())
})?)
.map_err(|err| jsonrpsee_core::Error::Custom(err.to_string()))?;
let monero_receive_address = monero_address::validate(
monero_receive_address,
context.config.env_config.monero_network,
)?;
let monero_receive_address = monero_address::validate(
monero_receive_address,
context.config.env_config.monero_network,
)?;
let seller = Multiaddr::from_str(params.get("seller").ok_or_else(|| {
let seller =
Multiaddr::from_str(params.get("seller").ok_or_else(|| {
jsonrpsee_core::Error::Custom("Does not contain seller".to_string())
})?)
.map_err(|err| jsonrpsee_core::Error::Custom(err.to_string()))?;
execute_request(
params_raw,
Method::BuyXmr {
bitcoin_change_address,
monero_receive_address,
seller,
swap_id: Uuid::new_v4(),
},
&context,
)
.await
execute_request(
params_raw,
Method::BuyXmr {
bitcoin_change_address,
monero_receive_address,
seller,
swap_id: Uuid::new_v4(),
},
&context,
)
.await
})?;
module.register_async_method("list_sellers", |params_raw, context| async move {
let params: HashMap<String, Multiaddr> = params_raw.parse()?;
let rendezvous_point = params.get("rendezvous_point").ok_or_else(|| {
jsonrpsee_core::Error::Custom("Does not contain rendezvous_point".to_string())
})?;
module
.register_async_method("list_sellers", |params_raw, context| async move {
let params: HashMap<String, Multiaddr> = params_raw.parse()?;
let rendezvous_point = params.get("rendezvous_point").ok_or_else(|| {
jsonrpsee_core::Error::Custom("Does not contain rendezvous_point".to_string())
})?;
execute_request(
params_raw,
Method::ListSellers {
rendezvous_point: rendezvous_point.clone(),
},
&context,
)
.await
})?;
execute_request(
params_raw,
Method::ListSellers {
rendezvous_point: rendezvous_point.clone(),
},
&context,
)
.await
})?;
module
.register_async_method("get_current_swap", |params, context| async move {
execute_request(params, Method::GetCurrentSwap, &context).await
})?;
module.register_async_method("get_current_swap", |params, context| async move {
execute_request(params, Method::GetCurrentSwap, &context).await
})?;
Ok(module)
}