Git-Mirrors/xmr-btc-swap
1
0
Fork 0
mirror of https://github.com/comit-network/xmr-btc-swap.git synced 2024-10-01 01:45:40 -04:00
Code Issues Packages Projects Releases Wiki Activity

fixing formatting and cargo clippy warnings

Browse Source
This commit is contained in:
Lorenzo Tucci 2023-01-11 14:52:42 +01:00
parent 925c7bc179
commit 9d1a39b2ff
No known key found for this signature in database
GPG Key ID: D98C4FA2CDF590A0
13 changed files with 374 additions and 209 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
monero-rpc/src/monerod.rs
View File

@ -194,7 +194,7 @@ mod monero_serde_hex_block {
{
let hex = String::deserialize(deserializer)?;
let bytes = hex::decode(&hex).map_err(D::Error::custom)?;
let bytes = hex::decode(hex).map_err(D::Error::custom)?;
let mut cursor = Cursor::new(bytes);
let block = monero::Block::consensus_decode(&mut cursor).map_err(D::Error::custom)?;

4
swap/Cargo.toml
View File

@ -79,17 +79,17 @@ zip = "0.5"
bitcoin-harness = "0.2.2"
get-port = "3"
hyper = "0.14"
monero-harness = { path = "../monero-harness" }
jsonrpsee = { version = "0.16.2", features = [ "ws-client" ] }
jsonrpsee-types = { version = "0.16.2" }
monero-harness = { path = "../monero-harness" }
port_check = "0.1"
proptest = "1"
sequential-test = "0.2.4"
serde_cbor = "0.11"
serial_test = "0.10"
spectral = "0.6"
tempfile = "3"
testcontainers = "0.12"
sequential-test = "0.2.4"
[build-dependencies]
anyhow = "1"

27
swap/src/api.rs
View File

@ -11,10 +11,9 @@ use anyhow::{Context as AnyContext, Result};
use std::fmt;
use std::net::SocketAddr;
use std::path::PathBuf;
use std::sync::{Arc};
use url::Url;
use std::sync::Once;
use std::sync::{Arc, Once};
use tokio::sync::{broadcast, Mutex};
use url::Url;
static START: Once = Once::new();
@ -42,7 +41,6 @@ pub struct Context {
pub shutdown: Arc<broadcast::Sender<()>>,
}
impl Context {
pub async fn build(
bitcoin: Option<Bitcoin>,
@ -91,19 +89,12 @@ impl Context {
}
};
let tor_socks5_port = {
if let Some(tor) = tor {
Some(tor.tor_socks5_port)
} else {
None
}
};
let tor_socks5_port = tor.map(|tor| tor.tor_socks5_port);
START.call_once(|| {
let _ = cli::tracing::init(debug, json, data_dir.join("logs"), None);
});
let init = Context {
db: open_db(data_dir.join("sqlite")).await?,
bitcoin_wallet,
@ -125,16 +116,14 @@ impl Context {
Ok(init)
}
}
impl fmt::Debug for Context {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "Testing {}", true)
write!(f, "")
}
}
async fn init_bitcoin_wallet(
electrum_rpc_url: Url,
seed: &Seed,
@ -159,7 +148,6 @@ async fn init_bitcoin_wallet(
Ok(wallet)
}
async fn init_monero_wallet(
data_dir: PathBuf,
monero_daemon_address: String,
@ -213,12 +201,12 @@ fn env_config_from(testnet: bool) -> EnvConfig {
}
#[cfg(test)]
pub mod api_test {
use crate::api::request::{Method, Params, Request, Shutdown};
use crate::tor::DEFAULT_SOCKS5_PORT;
use std::str::FromStr;
use uuid::Uuid;
use crate::api::request::{Request, Params, Method, Shutdown};
use libp2p::Multiaddr;
use std::str::FromStr;
use tokio::sync::broadcast;
use uuid::Uuid;
pub const MULTI_ADDRESS: &str =
"/ip4/127.0.0.1/tcp/9939/p2p/12D3KooWCdMKjesXMJz1SiZ7HgotrxuqhQJbP5sgBm2BwP1cqThi";
@ -251,7 +239,6 @@ pub mod api_test {
is_testnet,
}
}
}
impl Request {
pub fn buy_xmr(is_testnet: bool, tx: broadcast::Sender<()>) -> Request {

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

@ -1,10 +1,11 @@
use crate::api::Context;
use crate::bitcoin::{Amount, TxLock};
use crate::cli::{list_sellers, EventLoop, SellerStatus};
use crate::libp2p_ext::MultiAddrExt;
use crate::network::quote::{BidQuote, ZeroQuoteReceived};
use crate::network::swarm;
use crate::protocol::bob::{BobState, Swap};
use crate::protocol::bob;
use crate::protocol::bob::{BobState, Swap};
use crate::{bitcoin, cli, monero, rpc};
use anyhow::{bail, Context as AnyContext, Result};
use libp2p::core::Multiaddr;
@ -16,10 +17,8 @@ use std::convert::TryInto;
use std::future::Future;
use std::sync::Arc;
use std::time::Duration;
use uuid::Uuid;
use crate::api::Context;
use tokio::sync::broadcast;
use uuid::Uuid;
#[derive(PartialEq, Debug)]
pub struct Request {
@ -61,11 +60,11 @@ impl Shutdown {
#[derive(Debug)]
pub struct Shutdown {
shutdown: bool,
notify: broadcast::Receiver<()>
notify: broadcast::Receiver<()>,
}
impl PartialEq for Shutdown {
fn eq(&self, other: &Shutdown) -> bool {
fn eq(&self, other: &Shutdown) -> bool {
self.shutdown == other.shutdown
}
}
@ -81,7 +80,6 @@ pub struct Params {
pub address: Option<bitcoin::Address>,
}
#[derive(Debug, PartialEq)]
pub enum Method {
BuyXmr,
@ -93,8 +91,7 @@ pub enum Method {
GetSeller,
SwapStartDate,
Resume,
Cancel,
Refund,
CancelAndRefund,
ListSellers,
ExportBitcoinWallet,
MoneroRecovery,
@ -107,19 +104,29 @@ impl Request {
Method::BuyXmr => {
let swap_id = Uuid::new_v4();
let seed = context.config.seed.as_ref().unwrap();
let seed = context.config.seed.as_ref().context("Could not get seed")?;
let env_config = context.config.env_config;
let btc = context.bitcoin_wallet.as_ref().unwrap();
let seller = self.params.seller.clone().unwrap();
let monero_receive_address = self.params.monero_receive_address.unwrap();
let bitcoin_change_address = self.params.bitcoin_change_address.clone().unwrap();
let bitcoin_wallet = btc;
let seller_peer_id = self
let btc = context
.bitcoin_wallet
.as_ref()
.context("Could not get Bitcoin wallet")?;
let seller = self
.params
.seller
.as_ref()
.unwrap()
.clone()
.context("Parameter seller is missing")?;
let monero_receive_address = self
.params
.monero_receive_address
.context("Parameter monero_receive_address is missing")?;
let bitcoin_change_address = self
.params
.bitcoin_change_address
.clone()
.context("Parameter bitcoin_change_address is missing")?;
let bitcoin_wallet = btc;
let seller_peer_id = seller
.extract_peer_id()
.context("Seller address must contain peer ID")?;
context
@ -135,7 +142,10 @@ impl Request {
);
let mut swarm = swarm::cli(
seed.derive_libp2p_identity(),
context.config.tor_socks5_port.unwrap(),
context
.config
.tor_socks5_port
.context("Could not get Tor SOCKS5 port")?,
behaviour,
)
.await?;
@ -178,13 +188,16 @@ impl Request {
.db
.insert_monero_address(swap_id, monero_receive_address)
.await?;
let monero_wallet = context.monero_wallet.as_ref().unwrap();
let monero_wallet = context
.monero_wallet
.as_ref()
.context("Could not get Monero wallet")?;
let swap = Swap::new(
Arc::clone(&context.db),
swap_id,
Arc::clone(&bitcoin_wallet),
Arc::clone(&monero_wallet),
Arc::clone(bitcoin_wallet),
Arc::clone(monero_wallet),
env_config,
event_loop_handle,
monero_receive_address,
@ -217,15 +230,21 @@ impl Request {
}
Method::RawHistory => {
let raw_history = context.db.raw_all().await?;
json!({
"raw_history": raw_history
})
json!({ "raw_history": raw_history })
}
Method::GetSeller => {
let swap_id = self.params.swap_id.with_context(|| "A swap_id is needed")?;
let peerId = context.db.get_peer_id(swap_id).await.with_context(|| "Could not get PeerID")?;
let swap_id = self.params.swap_id.context("Parameter swap_id is needed")?;
let peerId = context
.db
.get_peer_id(swap_id)
.await
.with_context(|| "Could not get PeerID")?;
let addresses = context.db.get_addresses(peerId).await.with_context(|| "Could not get addressess")?;
let addresses = context
.db
.get_addresses(peerId)
.await
.with_context(|| "Could not get addressess")?;
json!({
"peerId": peerId.to_base58(),
@ -233,12 +252,12 @@ impl Request {
})
}
Method::SwapStartDate => {
let swap_id = self.params.swap_id.with_context(|| "A swap_id is needed")?;
let swap_id = self
.params
.swap_id
.context("Parameter swap_id is missing")?;
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!({
"start_date": start_date,
@ -262,9 +281,16 @@ impl Request {
})
}
Method::WithdrawBtc => {
let bitcoin_wallet = context.bitcoin_wallet.as_ref().unwrap();
let bitcoin_wallet = context
.bitcoin_wallet
.as_ref()
.context("Could not get Bitcoin wallet")?;
let address = self.params.address.clone().unwrap();
let address = self
.params
.address
.clone()
.context("Parameter address is missing")?;
let amount = match self.params.amount {
Some(amount) => amount,
@ -306,7 +332,10 @@ impl Request {
}
}
Method::Balance => {
let bitcoin_wallet = context.bitcoin_wallet.as_ref().unwrap();
let bitcoin_wallet = context
.bitcoin_wallet
.as_ref()
.context("Could not get Bitcoin wallet")?;
bitcoin_wallet.sync().await?;
let bitcoin_balance = bitcoin_wallet.balance().await?;
@ -320,22 +349,38 @@ impl Request {
})
}
Method::Resume => {
let swap_id = self.params.swap_id.unwrap();
let swap_id = self
.params
.swap_id
.context("Parameter swap_id is missing")?;
let seller_peer_id = context.db.get_peer_id(swap_id).await?;
let seller_addresses = context.db.get_addresses(seller_peer_id).await?;
let seed = context.config.seed.as_ref().unwrap().derive_libp2p_identity();
let seed = context
.config
.seed
.as_ref()
.context("Could not get seed")?
.derive_libp2p_identity();
let behaviour = cli::Behaviour::new(
seller_peer_id,
context.config.env_config,
Arc::clone(context.bitcoin_wallet.as_ref().unwrap()),
Arc::clone(
context
.bitcoin_wallet
.as_ref()
.context("Could not get Bitcoin wallet")?,
),
(seed.clone(), context.config.namespace),
);
let mut swarm = swarm::cli(
seed.clone(),
context.config.tor_socks5_port.clone().unwrap(),
context
.config
.tor_socks5_port
.context("Could not get Tor SOCKS5 port")?,
behaviour,
)
.await?;
@ -357,8 +402,18 @@ impl Request {
let swap = Swap::from_db(
Arc::clone(&context.db),
swap_id,
Arc::clone(context.bitcoin_wallet.as_ref().unwrap()),
Arc::clone(context.monero_wallet.as_ref().unwrap()),
Arc::clone(
context
.bitcoin_wallet
.as_ref()
.context("Could not get Bitcoin wallet")?,
),
Arc::clone(
context
.monero_wallet
.as_ref()
.context("Could not get Monero wallet")?,
),
context.config.env_config,
event_loop_handle,
monero_receive_address,
@ -378,39 +433,49 @@ impl Request {
})
}
Method::CancelAndRefund => {
let bitcoin_wallet = context.bitcoin_wallet.as_ref().unwrap();
let bitcoin_wallet = context
.bitcoin_wallet
.as_ref()
.context("Could not get Bitcoin wallet")?;
let (txid, _) = cli::cancel_and_refund(swap_id, Arc::clone(bitcoin_wallet), Arc::clone(&context.db).await?;
json!({
"txid": txid,
})
}
Method::Refund => {
let bitcoin_wallet = context.bitcoin_wallet.as_ref().unwrap();
let state = cli::refund(
self.params.swap_id.unwrap(),
let state = cli::cancel_and_refund(
self.params
.swap_id
.context("Parameter swap_id is missing")?,
Arc::clone(bitcoin_wallet),
Arc::clone(&context.db),
)
.await?;
json!({ "result": state })
json!({
"result": state,
})
}
Method::ListSellers => {
let rendezvous_point = self.params.rendezvous_point.clone().unwrap();
let rendezvous_point = self
.params
.rendezvous_point
.clone()
.context("Parameter rendezvous_point is missing")?;
let rendezvous_node_peer_id = rendezvous_point
.extract_peer_id()
.context("Rendezvous node address must contain peer ID")?;
let identity = context.config.seed.as_ref().unwrap().derive_libp2p_identity();
let identity = context
.config
.seed
.as_ref()
.context("Cannot extract seed")?
.derive_libp2p_identity();
let sellers = list_sellers(
rendezvous_node_peer_id,
rendezvous_point,
context.config.namespace,
context.config.tor_socks5_port.unwrap(),
context
.config
.tor_socks5_port
.context("Could not get Tor SOCKS5 port")?,
identity,
)
.await?;
@ -440,7 +505,10 @@ impl Request {
json!({ "sellers": sellers })
}
Method::ExportBitcoinWallet => {
let bitcoin_wallet = context.bitcoin_wallet.as_ref().unwrap();
let bitcoin_wallet = context
.bitcoin_wallet
.as_ref()
.context("Could not get Bitcoin wallet")?;
let wallet_export = bitcoin_wallet.wallet_export("cli").await?;
tracing::info!(descriptor=%wallet_export.to_string(), "Exported bitcoin wallet");
@ -451,7 +519,11 @@ impl Request {
Method::MoneroRecovery => {
let swap_state: BobState = context
.db
.get_state(self.params.swap_id.clone().unwrap())
.get_state(
self.params
.swap_id
.context("Parameter swap_id is missing")?,
)
.await?
.try_into()?;
@ -495,7 +567,6 @@ impl Request {
}
}
fn qr_code(value: &impl ToString) -> Result<String> {
let code = QrCode::new(value.to_string())?;
let qr_code = code

4
swap/src/bitcoin/wallet.rs
View File

@ -54,7 +54,7 @@ impl Wallet {
) -> Result<Self> {
let data_dir = data_dir.as_ref();
let wallet_dir = data_dir.join(WALLET);
let database = bdk::sled::open(&wallet_dir)?.open_tree(SLED_TREE_NAME)?;
let database = bdk::sled::open(wallet_dir)?.open_tree(SLED_TREE_NAME)?;
let network = env_config.bitcoin_network;
let wallet = match bdk::Wallet::new(
@ -97,7 +97,7 @@ impl Wallet {
std::fs::rename(from, to)?;
let wallet_dir = data_dir.join(WALLET);
let database = bdk::sled::open(&wallet_dir)?.open_tree(SLED_TREE_NAME)?;
let database = bdk::sled::open(wallet_dir)?.open_tree(SLED_TREE_NAME)?;
let wallet = bdk::Wallet::new(
bdk::template::Bip84(xprivkey, KeychainKind::External),

4
swap/src/cli/cancel_and_refund.rs
View File

@ -28,7 +28,7 @@ pub async fn cancel_and_refund(
pub async fn cancel(
swap_id: Uuid,
bitcoin_wallet: Arc<Wallet>,
db: Arc<dyn Database>,
db: Arc<dyn Database + Send + Sync>,
) -> Result<(Txid, Subscription, BobState)> {
let state = db.get_state(swap_id).await?.try_into()?;
@ -80,7 +80,7 @@ pub async fn cancel(
pub async fn refund(
swap_id: Uuid,
bitcoin_wallet: Arc<Wallet>,
db: Arc<dyn Database>,
db: Arc<dyn Database + Send + Sync>,
) -> Result<BobState> {
let state = db.get_state(swap_id).await?.try_into()?;

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

@ -1,8 +1,8 @@
use crate::api::request::{Method, Params, Request, Shutdown};
use crate::api::Context;
use crate::api::request::{Request, Params, Method, Shutdown};
use crate::bitcoin::{Amount, bitcoin_address};
use crate::monero::monero_address;
use crate::bitcoin::{bitcoin_address, Amount};
use crate::monero;
use crate::monero::monero_address;
use anyhow::Result;
use libp2p::core::Multiaddr;
use std::ffi::OsString;
@ -11,9 +11,9 @@ use std::path::PathBuf;
use std::str::FromStr;
use std::sync::Arc;
use structopt::{clap, StructOpt};
use tokio::sync::broadcast;
use url::Url;
use uuid::Uuid;
use tokio::sync::broadcast;
// See: https://moneroworld.com/
pub const DEFAULT_MONERO_DAEMON_ADDRESS: &str = "node.community.rino.io:18081";
@ -42,7 +42,10 @@ pub enum ParseResult {
PrintAndExitZero { message: String },
}
pub async fn parse_args_and_apply_defaults<I, T>(raw_args: I, rx: broadcast::Sender<()>) -> Result<ParseResult>
pub async fn parse_args_and_apply_defaults<I, T>(
raw_args: I,
rx: broadcast::Sender<()>,
) -> Result<ParseResult>
where
I: IntoIterator<Item = T>,
T: Into<OsString> + Clone,
@ -70,8 +73,10 @@ where
monero_receive_address,
tor,
} => {
let monero_receive_address = monero_address::validate(monero_receive_address, is_testnet)?;
let bitcoin_change_address = bitcoin_address::validate(bitcoin_change_address, is_testnet)?;
let monero_receive_address =
monero_address::validate(monero_receive_address, is_testnet)?;
let bitcoin_change_address =
bitcoin_address::validate(bitcoin_change_address, is_testnet)?;
let request = Request {
params: Params {
@ -268,8 +273,18 @@ where
shutdown: Shutdown::new(rx.subscribe()),
};
let context =
Context::build(None, None, Some(tor), data, is_testnet, debug, json, None, rx).await?;
let context = Context::build(
None,
None,
Some(tor),
data,
is_testnet,
debug,
json,
None,
rx,
)
.await?;
(context, request)
}
@ -563,10 +578,10 @@ mod tests {
use crate::tor::DEFAULT_SOCKS5_PORT;
use crate::api::api_test::*;
use sequential_test::sequential;
use crate::monero::monero_address::MoneroAddressNetworkMismatch;
use crate::api::Config;
use crate::fs::system_data_dir;
use crate::monero::monero_address::MoneroAddressNetworkMismatch;
use sequential_test::sequential;
const BINARY_NAME: &str = "swap";
const ARGS_DATA_DIR: &str = "/tmp/dir/";
@ -586,7 +601,9 @@ mod tests {
];
let (tx, _) = broadcast::channel(1);
let args = parse_args_and_apply_defaults(raw_ars, tx.clone()).await.unwrap();
let args = parse_args_and_apply_defaults(raw_ars, tx.clone())
.await
.unwrap();
let (is_testnet, debug, json) = (false, false, false);
let (expected_config, expected_request) = (
@ -619,7 +636,9 @@ mod tests {
];
let (tx, _) = broadcast::channel(1);
let args = parse_args_and_apply_defaults(raw_ars, tx.clone()).await.unwrap();
let args = parse_args_and_apply_defaults(raw_ars, tx.clone())
.await
.unwrap();
let (is_testnet, debug, json) = (true, false, false);
let (expected_config, expected_request) = (
@ -651,7 +670,9 @@ mod tests {
];
let (tx, _) = broadcast::channel(1);
let err = parse_args_and_apply_defaults(raw_ars, tx.clone()).await.unwrap_err();
let err = parse_args_and_apply_defaults(raw_ars, tx.clone())
.await
.unwrap_err();
assert_eq!(
err.downcast_ref::<MoneroAddressNetworkMismatch>().unwrap(),
@ -678,7 +699,9 @@ mod tests {
];
let (tx, _) = broadcast::channel(1);
let err = parse_args_and_apply_defaults(raw_ars, tx.clone()).await.unwrap_err();
let err = parse_args_and_apply_defaults(raw_ars, tx.clone())
.await
.unwrap_err();
assert_eq!(
err.downcast_ref::<MoneroAddressNetworkMismatch>().unwrap(),
@ -695,7 +718,9 @@ mod tests {
let raw_ars = vec![BINARY_NAME, "resume", "--swap-id", SWAP_ID];
let (tx, _) = broadcast::channel(1);
let args = parse_args_and_apply_defaults(raw_ars, tx.clone()).await.unwrap();
let args = parse_args_and_apply_defaults(raw_ars, tx.clone())
.await
.unwrap();
let (is_testnet, debug, json) = (false, false, false);
let (expected_config, expected_request) = (
@ -718,7 +743,9 @@ mod tests {
let raw_ars = vec![BINARY_NAME, "--testnet", "resume", "--swap-id", SWAP_ID];
let (tx, _) = broadcast::channel(1);
let args = parse_args_and_apply_defaults(raw_ars, tx.clone()).await.unwrap();
let args = parse_args_and_apply_defaults(raw_ars, tx.clone())
.await
.unwrap();
let (is_testnet, debug, json) = (true, false, false);
let (expected_config, expected_request) = (
@ -741,7 +768,9 @@ mod tests {
let raw_ars = vec![BINARY_NAME, "cancel", "--swap-id", SWAP_ID];
let (tx, _) = broadcast::channel(1);
let args = parse_args_and_apply_defaults(raw_ars, tx.clone()).await.unwrap();
let args = parse_args_and_apply_defaults(raw_ars, tx.clone())
.await
.unwrap();
let (is_testnet, debug, json) = (false, false, false);
@ -765,7 +794,9 @@ mod tests {
let raw_ars = vec![BINARY_NAME, "--testnet", "cancel", "--swap-id", SWAP_ID];
let (tx, _) = broadcast::channel(1);
let args = parse_args_and_apply_defaults(raw_ars, tx.clone()).await.unwrap();
let args = parse_args_and_apply_defaults(raw_ars, tx.clone())
.await
.unwrap();
let (is_testnet, debug, json) = (true, false, false);
let (expected_config, expected_request) = (
@ -788,7 +819,9 @@ mod tests {
let raw_ars = vec![BINARY_NAME, "refund", "--swap-id", SWAP_ID];
let (tx, _) = broadcast::channel(1);
let args = parse_args_and_apply_defaults(raw_ars, tx.clone()).await.unwrap();
let args = parse_args_and_apply_defaults(raw_ars, tx.clone())
.await
.unwrap();
let (is_testnet, debug, json) = (false, false, false);
let (expected_config, expected_request) = (
@ -811,7 +844,9 @@ mod tests {
let raw_ars = vec![BINARY_NAME, "--testnet", "refund", "--swap-id", SWAP_ID];
let (tx, _) = broadcast::channel(1);
let args = parse_args_and_apply_defaults(raw_ars, tx.clone()).await.unwrap();
let args = parse_args_and_apply_defaults(raw_ars, tx.clone())
.await
.unwrap();
let (is_testnet, debug, json) = (true, false, false);
let (expected_config, expected_request) = (
@ -845,7 +880,9 @@ mod tests {
];
let (tx, _) = broadcast::channel(1);
let args = parse_args_and_apply_defaults(raw_ars, tx.clone()).await.unwrap();
let args = parse_args_and_apply_defaults(raw_ars, tx.clone())
.await
.unwrap();
let (is_testnet, debug, json) = (false, false, false);
let data_dir = PathBuf::from_str(ARGS_DATA_DIR).unwrap();
@ -863,7 +900,6 @@ mod tests {
assert_eq!(actual_request, Box::new(expected_request));
}
#[tokio::test]
#[sequential]
async fn given_buy_xmr_on_testnet_with_data_dir_then_data_dir_set() {
@ -883,7 +919,9 @@ mod tests {
let (tx, _) = broadcast::channel(1);
let data_dir = PathBuf::from_str(ARGS_DATA_DIR).unwrap();
let args = parse_args_and_apply_defaults(raw_ars, tx.clone()).await.unwrap();
let args = parse_args_and_apply_defaults(raw_ars, tx.clone())
.await
.unwrap();
let (is_testnet, debug, json) = (true, false, false);
let (expected_config, expected_request) = (
@ -903,7 +941,6 @@ mod tests {
#[tokio::test]
#[sequential]
async fn given_resume_on_mainnet_with_data_dir_then_data_dir_set() {
let raw_ars = vec![
BINARY_NAME,
"--data-base-dir",
@ -915,7 +952,9 @@ mod tests {
let (tx, _) = broadcast::channel(1);
let data_dir = PathBuf::from_str(ARGS_DATA_DIR).unwrap();
let args = parse_args_and_apply_defaults(raw_ars, tx.clone()).await.unwrap();
let args = parse_args_and_apply_defaults(raw_ars, tx.clone())
.await
.unwrap();
let (is_testnet, debug, json) = (false, false, false);
let (expected_config, expected_request) = (
@ -935,7 +974,6 @@ mod tests {
#[tokio::test]
#[sequential]
async fn given_resume_on_testnet_with_data_dir_then_data_dir_set() {
let raw_ars = vec![
BINARY_NAME,
"--testnet",
@ -948,7 +986,9 @@ mod tests {
let (tx, _) = broadcast::channel(1);
let data_dir = PathBuf::from_str(ARGS_DATA_DIR).unwrap();
let args = parse_args_and_apply_defaults(raw_ars, tx.clone()).await.unwrap();
let args = parse_args_and_apply_defaults(raw_ars, tx.clone())
.await
.unwrap();
let (is_testnet, debug, json) = (true, false, false);
let (expected_config, expected_request) = (
@ -981,7 +1021,9 @@ mod tests {
];
let (tx, _) = broadcast::channel(1);
let args = parse_args_and_apply_defaults(raw_ars, tx.clone()).await.unwrap();
let args = parse_args_and_apply_defaults(raw_ars, tx.clone())
.await
.unwrap();
let (is_testnet, debug, json) = (false, true, false);
let (expected_config, expected_request) = (
@ -1015,7 +1057,9 @@ mod tests {
];
let (tx, _) = broadcast::channel(1);
let args = parse_args_and_apply_defaults(raw_ars, tx.clone()).await.unwrap();
let args = parse_args_and_apply_defaults(raw_ars, tx.clone())
.await
.unwrap();
let (is_testnet, debug, json) = (true, true, false);
let (expected_config, expected_request) = (
@ -1035,11 +1079,12 @@ mod tests {
#[tokio::test]
#[sequential]
async fn given_resume_on_mainnet_with_debug_then_debug_set() {
let raw_ars = vec![BINARY_NAME, "--debug", "resume", "--swap-id", SWAP_ID];
let (tx, _) = broadcast::channel(1);
let args = parse_args_and_apply_defaults(raw_ars, tx.clone()).await.unwrap();
let args = parse_args_and_apply_defaults(raw_ars, tx.clone())
.await
.unwrap();
let (is_testnet, debug, json) = (false, true, false);
let (expected_config, expected_request) = (
@ -1056,7 +1101,6 @@ mod tests {
assert_eq!(actual_request, Box::new(expected_request));
}
#[tokio::test]
#[sequential]
async fn given_resume_on_testnet_with_debug_then_debug_set() {
@ -1070,7 +1114,9 @@ mod tests {
];
let (tx, _) = broadcast::channel(1);
let args = parse_args_and_apply_defaults(raw_ars, tx.clone()).await.unwrap();
let args = parse_args_and_apply_defaults(raw_ars, tx.clone())
.await
.unwrap();
let (is_testnet, debug, json) = (true, true, false);
let (expected_config, expected_request) = (
@ -1103,7 +1149,9 @@ mod tests {
];
let (tx, _) = broadcast::channel(1);
let args = parse_args_and_apply_defaults(raw_ars, tx.clone()).await.unwrap();
let args = parse_args_and_apply_defaults(raw_ars, tx.clone())
.await
.unwrap();
let (is_testnet, debug, json) = (false, false, true);
let data_dir = data_dir_path_cli(is_testnet);
@ -1138,7 +1186,9 @@ mod tests {
];
let (tx, _) = broadcast::channel(1);
let args = parse_args_and_apply_defaults(raw_ars, tx.clone()).await.unwrap();
let args = parse_args_and_apply_defaults(raw_ars, tx.clone())
.await
.unwrap();
let (is_testnet, debug, json) = (true, false, true);
let (expected_config, expected_request) = (
@ -1158,10 +1208,11 @@ mod tests {
#[tokio::test]
#[sequential]
async fn given_resume_on_mainnet_with_json_then_json_set() {
let (tx, _) = broadcast::channel(1);
let raw_ars = vec![BINARY_NAME, "--json", "resume", "--swap-id", SWAP_ID];
let args = parse_args_and_apply_defaults(raw_ars, tx.clone()).await.unwrap();
let args = parse_args_and_apply_defaults(raw_ars, tx.clone())
.await
.unwrap();
let (is_testnet, debug, json) = (false, false, true);
let (expected_config, expected_request) = (
@ -1181,7 +1232,6 @@ mod tests {
#[tokio::test]
#[sequential]
async fn given_resume_on_testnet_with_json_then_json_set() {
let raw_ars = vec![
BINARY_NAME,
"--testnet",
@ -1192,7 +1242,9 @@ mod tests {
];
let (tx, _) = broadcast::channel(1);
let args = parse_args_and_apply_defaults(raw_ars, tx.clone()).await.unwrap();
let args = parse_args_and_apply_defaults(raw_ars, tx.clone())
.await
.unwrap();
let (is_testnet, debug, json) = (true, false, true);
let (expected_config, expected_request) = (
@ -1223,7 +1275,9 @@ mod tests {
MULTI_ADDRESS,
];
let (tx, _) = broadcast::channel(1);
let result = parse_args_and_apply_defaults(raw_ars, tx.clone()).await.unwrap_err();
let result = parse_args_and_apply_defaults(raw_ars, tx.clone())
.await
.unwrap_err();
let raw_ars = vec![
BINARY_NAME,
@ -1235,7 +1289,9 @@ mod tests {
"--seller",
MULTI_ADDRESS,
];
let result = parse_args_and_apply_defaults(raw_ars, tx.clone()).await.unwrap_err();
let result = parse_args_and_apply_defaults(raw_ars, tx.clone())
.await
.unwrap_err();
let raw_ars = vec![
BINARY_NAME,
@ -1247,7 +1303,9 @@ mod tests {
"--seller",
MULTI_ADDRESS,
];
let result = parse_args_and_apply_defaults(raw_ars, tx.clone()).await.unwrap();
let result = parse_args_and_apply_defaults(raw_ars, tx.clone())
.await
.unwrap();
assert!(matches!(result, ParseResult::Context(_, _)));
}
@ -1266,7 +1324,9 @@ mod tests {
"--seller",
MULTI_ADDRESS,
];
let result = parse_args_and_apply_defaults(raw_ars, tx.clone()).await.unwrap_err();
let result = parse_args_and_apply_defaults(raw_ars, tx.clone())
.await
.unwrap_err();
let raw_ars = vec![
BINARY_NAME,
@ -1279,7 +1339,9 @@ mod tests {
"--seller",
MULTI_ADDRESS,
];
let result = parse_args_and_apply_defaults(raw_ars, tx.clone()).await.unwrap_err();
let result = parse_args_and_apply_defaults(raw_ars, tx.clone())
.await
.unwrap_err();
let raw_ars = vec![
BINARY_NAME,
@ -1292,7 +1354,9 @@ mod tests {
"--seller",
MULTI_ADDRESS,
];
let result = parse_args_and_apply_defaults(raw_ars, tx.clone()).await.unwrap();
let result = parse_args_and_apply_defaults(raw_ars, tx.clone())
.await
.unwrap();
assert!(matches!(result, ParseResult::Context(_, _)));
}

18
swap/src/database/sqlite.rs
View File

@ -1,7 +1,7 @@
use crate::database::Swap;
use crate::monero::Address;
use crate::protocol::{Database, State};
use anyhow::{Context, Result};
use anyhow::{anyhow, Context, Result};
use async_trait::async_trait;
use libp2p::{Multiaddr, PeerId};
use sqlx::sqlite::Sqlite;
@ -185,7 +185,8 @@ impl Database for SqliteDatabase {
.fetch_one(&mut conn)
.await?;
return Ok(row.start_date.unwrap());
row.start_date
.ok_or_else(|| anyhow!("Could not get swap start date"))
}
async fn insert_latest_state(&self, swap_id: Uuid, state: State) -> Result<()> {
@ -283,13 +284,16 @@ impl Database for SqliteDatabase {
let mut swaps: HashMap<Uuid, Vec<serde_json::Value>> = HashMap::new();
for row in &rows {
let swap_id = Uuid::from_str(&row.swap_id).unwrap();
let state = serde_json::from_str(&row.state).unwrap();
let swap_id = Uuid::from_str(&row.swap_id)?;
let state = serde_json::from_str(&row.state)?;
if swaps.contains_key(&swap_id) {
swaps.get_mut(&swap_id).unwrap().push(state);
if let std::collections::hash_map::Entry::Vacant(e) = swaps.entry(swap_id) {
e.insert(vec![state]);
} else {
swaps.insert(swap_id, vec![state]);
swaps
.get_mut(&swap_id)
.ok_or_else(|| anyhow!("Error while retrieving the swap"))?
.push(state);
}
}

2
swap/src/monero.rs
View File

@ -321,7 +321,7 @@ pub mod monero_amount {
}
pub mod monero_address {
use anyhow::{bail, Result, Context};
use anyhow::{bail, Context, Result};
use std::str::FromStr;
#[derive(thiserror::Error, Debug, Clone, Copy, PartialEq)]

4
swap/src/rpc.rs
View File

@ -1,5 +1,5 @@
use crate::api::Context;
use jsonrpsee::server::{ServerBuilder, ServerHandle, RpcModule};
use jsonrpsee::server::{RpcModule, ServerBuilder, ServerHandle};
use std::net::SocketAddr;
use std::sync::Arc;
use thiserror::Error;
@ -21,7 +21,7 @@ pub async fn run_server(
{
modules
.merge(methods::register_modules(Arc::clone(&context)))
.unwrap()
.expect("Could not register RPC modules")
}
let addr = server.local_addr()?;

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

@ -1,8 +1,9 @@
use crate::api::{Context};
use crate::api::request::{Params, Request, Method, Shutdown};
use anyhow::Result;
use crate::api::request::{Method, Params, Request, Shutdown};
use crate::api::Context;
use crate::bitcoin::bitcoin_address;
use crate::monero::monero_address;
use crate::{bitcoin, monero};
use crate::{bitcoin::bitcoin_address, monero::monero_address};
use anyhow::Result;
use jsonrpsee::server::RpcModule;
use libp2p::core::Multiaddr;
use std::collections::HashMap;
@ -16,17 +17,17 @@ pub fn register_modules(context: Arc<Context>) -> RpcModule<Arc<Context>> {
.register_async_method("get_bitcoin_balance", |_, context| async move {
get_bitcoin_balance(&context).await
})
.unwrap();
.expect("Could not register RPC method get_bitcoin_balance");
module
.register_async_method("get_history", |_, context| async move {
get_history(&context).await
})
.unwrap();
.expect("Could not register RPC method get_history");
module
.register_async_method("get_raw_history", |_, context| async move {
get_raw_history(&context).await
})
.unwrap();
.expect("Could not register RPC method get_history");
module
.register_async_method("get_seller", |params, context| async move {
let params: HashMap<String, Uuid> = params.parse()?;
@ -37,7 +38,7 @@ pub fn register_modules(context: Arc<Context>) -> RpcModule<Arc<Context>> {
get_seller(*swap_id, &context).await
})
.unwrap();
.expect("Could not register RPC method get_seller");
module
.register_async_method("get_swap_start_date", |params, context| async move {
let params: HashMap<String, Uuid> = params.parse()?;
@ -48,7 +49,7 @@ pub fn register_modules(context: Arc<Context>) -> RpcModule<Arc<Context>> {
get_swap_start_date(*swap_id, &context).await
})
.unwrap();
.expect("Could not register RPC method get_swap_start_date");
module
.register_async_method("resume_swap", |params, context| async move {
let params: HashMap<String, Uuid> = params.parse()?;
@ -59,7 +60,7 @@ pub fn register_modules(context: Arc<Context>) -> RpcModule<Arc<Context>> {
resume_swap(*swap_id, &context).await
})
.unwrap();
.expect("Could not register RPC method resume_swap");
module
.register_async_method("withdraw_btc", |params, context| async move {
let params: HashMap<String, String> = params.parse()?;
@ -80,11 +81,12 @@ pub fn register_modules(context: Arc<Context>) -> RpcModule<Arc<Context>> {
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.is_testnet)?;
let withdraw_address =
bitcoin_address::validate(withdraw_address, context.config.is_testnet)?;
withdraw_btc(withdraw_address, amount, &context).await
})
.unwrap();
.expect("Could not register RPC method withdraw_btc");
module
.register_async_method("buy_xmr", |params, context| async move {
let params: HashMap<String, String> = params.parse()?;
@ -98,7 +100,8 @@ pub fn register_modules(context: Arc<Context>) -> RpcModule<Arc<Context>> {
)
.map_err(|err| jsonrpsee_core::Error::Custom(err.to_string()))?;
let bitcoin_change_address = bitcoin_address::validate(bitcoin_change_address, context.config.is_testnet)?;
let bitcoin_change_address =
bitcoin_address::validate(bitcoin_change_address, context.config.is_testnet)?;
let monero_receive_address = monero::Address::from_str(
params.get("monero_receive_address").ok_or_else(|| {
@ -109,7 +112,8 @@ pub fn register_modules(context: Arc<Context>) -> RpcModule<Arc<Context>> {
)
.map_err(|err| jsonrpsee_core::Error::Custom(err.to_string()))?;
let monero_receive_address = monero_address::validate(monero_receive_address, context.config.is_testnet)?;
let monero_receive_address =
monero_address::validate(monero_receive_address, context.config.is_testnet)?;
let seller = Multiaddr::from_str(params.get("seller").ok_or_else(|| {
jsonrpsee_core::Error::Custom("Does not contain seller".to_string())
@ -121,29 +125,33 @@ pub fn register_modules(context: Arc<Context>) -> RpcModule<Arc<Context>> {
monero_receive_address,
seller,
&context,
).await
)
.await
})
.unwrap();
.expect("Could not register RPC method buy_xmr");
module
.register_async_method("list_sellers", |params, context| async move {
let params: HashMap<String, Multiaddr> = params.parse()?;
let rendezvous_point = params.get("rendezvous_point").ok_or_else(|| {
jsonrpsee_core::Error::Custom("Does not contain rendezvous_point".to_string())
})?;
jsonrpsee_core::Error::Custom("Does not contain rendezvous_point".to_string())
})?;
list_sellers(rendezvous_point.clone(), &context).await
})
.unwrap();
.expect("Could not register RPC method list_sellers");
module
}
async fn get_bitcoin_balance(context: &Arc<Context>) -> Result<serde_json::Value, jsonrpsee_core::Error> {
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))
let balance = request
.call(Arc::clone(context))
.await
.map_err(|err| jsonrpsee_core::Error::Custom(err.to_string()))?;
@ -156,19 +164,23 @@ async fn get_history(context: &Arc<Context>) -> Result<serde_json::Value, jsonrp
cmd: Method::History,
shutdown: Shutdown::new(context.shutdown.subscribe()),
};
let history = request.call(Arc::clone(context))
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(context: &Arc<Context>) -> Result<serde_json::Value, jsonrpsee_core::Error> {
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))
let history = request
.call(Arc::clone(context))
.await
.map_err(|err| jsonrpsee_core::Error::Custom(err.to_string()))?;
@ -177,7 +189,7 @@ async fn get_raw_history(context: &Arc<Context>) -> Result<serde_json::Value, js
async fn get_seller(
swap_id: Uuid,
context: &Arc<Context>
context: &Arc<Context>,
) -> Result<serde_json::Value, jsonrpsee_core::Error> {
let mut request = Request {
params: Params {
@ -187,7 +199,8 @@ async fn get_seller(
cmd: Method::GetSeller,
shutdown: Shutdown::new(context.shutdown.subscribe()),
};
let result = request.call(Arc::clone(context))
let result = request
.call(Arc::clone(context))
.await
.map_err(|err| jsonrpsee_core::Error::Custom(err.to_string()))?;
@ -196,7 +209,7 @@ async fn get_seller(
async fn get_swap_start_date(
swap_id: Uuid,
context: &Arc<Context>
context: &Arc<Context>,
) -> Result<serde_json::Value, jsonrpsee_core::Error> {
let mut request = Request {
params: Params {
@ -206,7 +219,8 @@ async fn get_swap_start_date(
cmd: Method::SwapStartDate,
shutdown: Shutdown::new(context.shutdown.subscribe()),
};
let result = request.call(Arc::clone(context))
let result = request
.call(Arc::clone(context))
.await
.map_err(|err| jsonrpsee_core::Error::Custom(err.to_string()))?;
@ -226,7 +240,8 @@ async fn resume_swap(
shutdown: Shutdown::new(context.shutdown.subscribe()),
};
let result = request.call(Arc::clone(context))
let result = request
.call(Arc::clone(context))
.await
.map_err(|err| jsonrpsee_core::Error::Custom(err.to_string()))?;
Ok(result)
@ -245,7 +260,8 @@ async fn withdraw_btc(
cmd: Method::WithdrawBtc,
shutdown: Shutdown::new(context.shutdown.subscribe()),
};
let result = request.call(Arc::clone(context))
let result = request
.call(Arc::clone(context))
.await
.map_err(|err| jsonrpsee_core::Error::Custom(err.to_string()))?;
Ok(result)
@ -267,7 +283,8 @@ async fn buy_xmr(
cmd: Method::BuyXmr,
shutdown: Shutdown::new(context.shutdown.subscribe()),
};
let swap = request.call(Arc::clone(context))
let swap = request
.call(Arc::clone(context))
.await
.map_err(|err| jsonrpsee_core::Error::Custom(err.to_string()))?;
Ok(swap)
@ -285,7 +302,8 @@ async fn list_sellers(
cmd: Method::ListSellers,
shutdown: Shutdown::new(context.shutdown.subscribe()),
};
let result = request.call(Arc::clone(context))
let result = request
.call(Arc::clone(context))
.await
.map_err(|err| jsonrpsee_core::Error::Custom(err.to_string()))?;
Ok(result)

2
swap/src/seed.rs
View File

@ -61,7 +61,7 @@ impl Seed {
let file_path = Path::new(&file_path_buf);
if file_path.exists() {
return Self::from_file(&file_path);
return Self::from_file(file_path);
}
tracing::debug!("No seed file found, creating at {}", file_path.display());

83
swap/tests/rpc.rs
View File

@ -1,37 +1,39 @@
use testcontainers::clients::Cli;
use testcontainers::{Container, Docker, RunArgs};
use anyhow::{bail, Context as AnyContext, Result};
use futures::Future;
use swap::api::{Context, Config};
use swap::api::request::{Request, Params, Method, Shutdown};
use std::sync::Arc;
use tokio::time::{interval, timeout};
use std::time::Duration;
use jsonrpsee::ws_client::WsClientBuilder;
use jsonrpsee_core::{client::ClientT, params::ObjectParams};
use jsonrpsee::{rpc_params, RpcModule};
use jsonrpsee_core::client::ClientT;
use jsonrpsee_core::params::ObjectParams;
use jsonrpsee_types::error::CallError;
use tokio::sync::broadcast;
use swap::cli::command::{Bitcoin, Monero};
use std::collections::HashMap;
use uuid::Uuid;
use serde_json::{json, Value};
use sequential_test::sequential;
use serde_json::{json, Value};
use std::collections::HashMap;
use std::sync::Arc;
use std::time::Duration;
use swap::api::request::{Method, Params, Request, Shutdown};
use swap::api::{Config, Context};
use swap::cli::command::{Bitcoin, Monero};
use testcontainers::clients::Cli;
use testcontainers::{Container, Docker, RunArgs};
use tokio::sync::broadcast;
use tokio::time::{interval, timeout};
use uuid::Uuid;
#[cfg(test)]
// to be replaced with actual "real" testing values
// need to create some kind of swap database and bitcoin environment with some funds
// need to create some kind of swap database and bitcoin environment with some
// funds
const SERVER_ADDRESS: &str = "127.0.0.1:1234";
const BITCOIN_ADDR: &str = "tb1qr3em6k3gfnyl8r7q0v7t4tlnyxzgxma3lressv";
const MONERO_ADDR: &str = "53gEuGZUhP9JMEBZoGaFNzhwEgiG7hwQdMCqFxiyiTeFPmkbt1mAoNybEUvYBKHcnrSgxnVWgZsTvRBaHBNXPa8tHiCU51a";
const SELLER: &str = "/ip4/127.0.0.1/tcp/9939/p2p/12D3KooWCdMKjesXMJz1SiZ7HgotrxuqhQJbP5sgBm2BwP1cqThi";
const SELLER: &str =
"/ip4/127.0.0.1/tcp/9939/p2p/12D3KooWCdMKjesXMJz1SiZ7HgotrxuqhQJbP5sgBm2BwP1cqThi";
const SWAP_ID: &str = "ea030832-3be9-454f-bb98-5ea9a788406b";
pub async fn initialize_context() -> (Arc<Context>, Request) {
let (is_testnet, debug, json) = (true, false, false);
//let data_dir = data::data_dir_from(None, is_testnet).unwrap();
// let data_dir = data::data_dir_from(None, is_testnet).unwrap();
let server_address = None;
let (tx, _) = broadcast::channel(1);
@ -60,12 +62,13 @@ pub async fn initialize_context() -> (Arc<Context>, Request) {
json,
server_address,
tx,
).await.unwrap();
)
.await
.unwrap();
(Arc::new(context), request)
}
#[tokio::test]
#[sequential]
pub async fn can_start_server() {
@ -92,7 +95,10 @@ pub async fn get_bitcoin_balance() {
tokio::time::sleep(Duration::from_secs(3)).await;
let client = WsClientBuilder::default().build(&url).await.unwrap();
let response: HashMap<String, i32> = client.request("get_bitcoin_balance", rpc_params!["id"]).await.unwrap();
let response: HashMap<String, i32> = client
.request("get_bitcoin_balance", rpc_params!["id"])
.await
.unwrap();
assert_eq!(response, HashMap::from([("balance".to_string(), 0)]));
ctx.shutdown.send(());
@ -113,7 +119,8 @@ pub async fn get_history() {
let client = WsClientBuilder::default().build(&url).await.unwrap();
let mut params = ObjectParams::new();
let response: HashMap<String, Vec<(Uuid, String)>> = client.request("get_history", params).await.unwrap();
let response: HashMap<String, Vec<(Uuid, String)>> =
client.request("get_history", params).await.unwrap();
let swaps: Vec<(Uuid, String)> = Vec::new();
assert_eq!(response, HashMap::from([("swaps".to_string(), swaps)]));
@ -136,9 +143,13 @@ pub async fn get_raw_history() {
let mut params = ObjectParams::new();
let raw_history: HashMap<Uuid, String> = HashMap::new();
let response: HashMap<String, HashMap<Uuid, String>> = client.request("get_raw_history", params).await.unwrap();
let response: HashMap<String, HashMap<Uuid, String>> =
client.request("get_raw_history", params).await.unwrap();
assert_eq!(response, HashMap::from([("raw_history".to_string(), raw_history)]));
assert_eq!(
response,
HashMap::from([("raw_history".to_string(), raw_history)])
);
ctx.shutdown.send(());
}
@ -159,7 +170,8 @@ pub async fn get_seller() {
let response: Result<HashMap<String, String>, _> = client.request("get_seller", params).await;
// We should ideally match the expected error and panic if it's different one, but the request returns a custom error (to investigate)
// We should ideally match the expected error and panic if it's different one,
// but the request returns a custom error (to investigate)
// Err(jsonrpsee_core::Error::Call(CallError::InvalidParams(e))) => (),
// Err(e) => panic!("ErrorType was not ParseError but {e:?}"),
@ -185,7 +197,10 @@ pub async fn get_seller() {
match response {
Ok(hash) => (),
Err(e) => panic!("Expected a HashMap with correct params, got an error: {}", e),
Err(e) => panic!(
"Expected a HashMap with correct params, got an error: {}",
e
),
}
ctx.shutdown.send(());
}
@ -205,7 +220,8 @@ pub async fn get_swap_start_date() {
let client = WsClientBuilder::default().build(&url).await.unwrap();
let mut params = ObjectParams::new();
let response: Result<HashMap<String, String>, _> = client.request("get_swap_start_date", params).await;
let response: Result<HashMap<String, String>, _> =
client.request("get_swap_start_date", params).await;
match response {
Err(e) => (),
@ -215,7 +231,8 @@ pub async fn get_swap_start_date() {
let mut params = ObjectParams::new();
params.insert("swap_id", "invalid_swap");
let response: Result<HashMap<String, String>, _> = client.request("get_swap_start_date", params).await;
let response: Result<HashMap<String, String>, _> =
client.request("get_swap_start_date", params).await;
match response {
Err(e) => (),
@ -225,7 +242,8 @@ pub async fn get_swap_start_date() {
let mut params = ObjectParams::new();
params.insert("swap_id", SWAP_ID);
let response: Result<HashMap<String, String>, _> = client.request("get_swap_start_date", params).await;
let response: Result<HashMap<String, String>, _> =
client.request("get_swap_start_date", params).await;
match response {
Ok(hash) => (),
@ -249,7 +267,8 @@ pub async fn resume_swap() {
let client = WsClientBuilder::default().build(&url).await.unwrap();
let mut params = ObjectParams::new();
let response: Result<HashMap<String, String>, _> = client.request("get_swap_start_date", params).await;
let response: Result<HashMap<String, String>, _> =
client.request("get_swap_start_date", params).await;
match response {
Err(e) => (),
@ -259,7 +278,8 @@ pub async fn resume_swap() {
let mut params = ObjectParams::new();
params.insert("swap_id", "invalid_swap");
let response: Result<HashMap<String, String>, _> = client.request("get_swap_start_date", params).await;
let response: Result<HashMap<String, String>, _> =
client.request("get_swap_start_date", params).await;
match response {
Err(e) => (),
@ -269,7 +289,8 @@ pub async fn resume_swap() {
let mut params = ObjectParams::new();
params.insert("swap_id", SWAP_ID);
let response: Result<HashMap<String, String>, _> = client.request("get_swap_start_date", params).await;
let response: Result<HashMap<String, String>, _> =
client.request("get_swap_start_date", params).await;
match response {
Ok(hash) => (),