2020-10-15 22:14:39 +00:00
|
|
|
#![warn(
|
|
|
|
unused_extern_crates,
|
|
|
|
missing_copy_implementations,
|
|
|
|
rust_2018_idioms,
|
|
|
|
clippy::cast_possible_truncation,
|
|
|
|
clippy::cast_sign_loss,
|
|
|
|
clippy::fallible_impl_from,
|
|
|
|
clippy::cast_precision_loss,
|
|
|
|
clippy::cast_possible_wrap,
|
|
|
|
clippy::dbg_macro
|
|
|
|
)]
|
|
|
|
#![forbid(unsafe_code)]
|
2020-12-23 03:33:29 +00:00
|
|
|
#![allow(non_snake_case)]
|
2020-10-15 22:14:39 +00:00
|
|
|
|
2021-03-03 23:46:12 +00:00
|
|
|
use anyhow::{bail, Context, Result};
|
2021-02-04 05:42:14 +00:00
|
|
|
use prettytable::{row, Table};
|
2021-05-30 11:53:43 +00:00
|
|
|
use qrcode::render::unicode;
|
|
|
|
use qrcode::QrCode;
|
2021-03-03 05:54:47 +00:00
|
|
|
use std::cmp::min;
|
2021-05-11 06:52:40 +00:00
|
|
|
use std::env;
|
2021-03-04 02:43:06 +00:00
|
|
|
use std::future::Future;
|
2021-03-15 01:02:42 +00:00
|
|
|
use std::path::PathBuf;
|
2021-03-04 00:28:58 +00:00
|
|
|
use std::sync::Arc;
|
|
|
|
use std::time::Duration;
|
2021-05-07 09:06:58 +00:00
|
|
|
use swap::bitcoin::TxLock;
|
2021-05-21 02:35:22 +00:00
|
|
|
use swap::cli::command::{parse_args_and_apply_defaults, Arguments, Command, ParseResult};
|
2021-03-04 00:28:58 +00:00
|
|
|
use swap::database::Database;
|
2021-05-11 06:52:40 +00:00
|
|
|
use swap::env::Config;
|
2021-03-04 02:43:06 +00:00
|
|
|
use swap::network::quote::BidQuote;
|
2021-03-23 05:56:04 +00:00
|
|
|
use swap::network::swarm;
|
2021-03-04 00:28:58 +00:00
|
|
|
use swap::protocol::bob;
|
2021-04-16 02:00:11 +00:00
|
|
|
use swap::protocol::bob::{EventLoop, Swap};
|
2021-03-04 00:28:58 +00:00
|
|
|
use swap::seed::Seed;
|
2021-05-11 06:52:40 +00:00
|
|
|
use swap::{bitcoin, cli, monero};
|
2021-04-02 07:22:51 +00:00
|
|
|
use tracing::{debug, error, info, warn};
|
2021-03-15 01:02:42 +00:00
|
|
|
use url::Url;
|
2021-01-21 02:43:25 +00:00
|
|
|
use uuid::Uuid;
|
|
|
|
|
2020-12-04 05:27:17 +00:00
|
|
|
#[macro_use]
|
|
|
|
extern crate prettytable;
|
2020-10-15 22:14:39 +00:00
|
|
|
|
|
|
|
#[tokio::main]
|
|
|
|
async fn main() -> Result<()> {
|
2021-05-11 06:52:40 +00:00
|
|
|
let Arguments {
|
|
|
|
env_config,
|
|
|
|
data_dir,
|
|
|
|
debug,
|
2021-05-20 06:36:01 +00:00
|
|
|
json,
|
2021-05-11 06:52:40 +00:00
|
|
|
cmd,
|
2021-05-21 02:35:22 +00:00
|
|
|
} = match parse_args_and_apply_defaults(env::args_os())? {
|
|
|
|
ParseResult::Arguments(args) => args,
|
|
|
|
ParseResult::PrintAndExitZero { message } => {
|
|
|
|
println!("{}", message);
|
|
|
|
std::process::exit(0);
|
2021-05-21 01:46:11 +00:00
|
|
|
}
|
|
|
|
};
|
2020-12-04 05:27:17 +00:00
|
|
|
|
2021-04-02 07:22:51 +00:00
|
|
|
match cmd {
|
2021-02-28 23:53:43 +00:00
|
|
|
Command::BuyXmr {
|
2021-05-11 02:00:11 +00:00
|
|
|
seller_peer_id,
|
2021-05-11 06:52:40 +00:00
|
|
|
seller_addr,
|
|
|
|
bitcoin_electrum_rpc_url,
|
|
|
|
bitcoin_target_block,
|
|
|
|
monero_receive_address,
|
|
|
|
monero_daemon_address,
|
|
|
|
tor_socks5_port,
|
2021-02-28 23:53:43 +00:00
|
|
|
} => {
|
2021-04-02 07:22:51 +00:00
|
|
|
let swap_id = Uuid::new_v4();
|
|
|
|
|
2021-05-20 06:36:01 +00:00
|
|
|
cli::tracing::init(debug, json, data_dir.join("logs"), swap_id)?;
|
2021-04-02 07:22:51 +00:00
|
|
|
let db = Database::open(data_dir.join("database").as_path())
|
|
|
|
.context("Failed to open database")?;
|
|
|
|
let seed = Seed::from_file_or_generate(data_dir.as_path())
|
|
|
|
.context("Failed to read in seed file")?;
|
2021-03-03 23:46:12 +00:00
|
|
|
|
2021-05-02 23:48:40 +00:00
|
|
|
let bitcoin_wallet = init_bitcoin_wallet(
|
2021-05-11 06:52:40 +00:00
|
|
|
bitcoin_electrum_rpc_url,
|
2021-05-02 23:48:40 +00:00
|
|
|
&seed,
|
|
|
|
data_dir.clone(),
|
|
|
|
env_config,
|
|
|
|
bitcoin_target_block,
|
|
|
|
)
|
|
|
|
.await?;
|
2021-03-17 02:36:43 +00:00
|
|
|
let (monero_wallet, _process) =
|
2021-05-11 02:37:13 +00:00
|
|
|
init_monero_wallet(data_dir, monero_daemon_address, env_config).await?;
|
2021-03-03 02:56:25 +00:00
|
|
|
let bitcoin_wallet = Arc::new(bitcoin_wallet);
|
2021-03-23 05:56:04 +00:00
|
|
|
|
2021-06-09 02:03:06 +00:00
|
|
|
let mut swarm = swarm::cli(&seed, seller_peer_id, tor_socks5_port).await?;
|
2021-04-15 07:44:21 +00:00
|
|
|
swarm
|
|
|
|
.behaviour_mut()
|
2021-05-11 02:00:11 +00:00
|
|
|
.add_address(seller_peer_id, seller_addr);
|
2021-03-23 05:56:04 +00:00
|
|
|
|
2021-06-09 04:13:04 +00:00
|
|
|
tracing::debug!(peer_id = %swarm.local_peer_id(), "Network layer initialized");
|
|
|
|
|
2021-05-11 12:22:59 +00:00
|
|
|
let (event_loop, mut event_loop_handle) = EventLoop::new(
|
|
|
|
swap_id,
|
|
|
|
swarm,
|
|
|
|
seller_peer_id,
|
|
|
|
bitcoin_wallet.clone(),
|
|
|
|
env_config,
|
|
|
|
)?;
|
2021-03-18 06:48:54 +00:00
|
|
|
let event_loop = tokio::spawn(event_loop.run());
|
2021-03-03 05:54:47 +00:00
|
|
|
|
2021-05-07 09:06:58 +00:00
|
|
|
let max_givable = || bitcoin_wallet.max_giveable(TxLock::script_size());
|
2021-05-20 23:53:06 +00:00
|
|
|
let (amount, fees) = determine_btc_to_swap(
|
2021-05-30 11:53:43 +00:00
|
|
|
json,
|
2021-03-04 02:43:06 +00:00
|
|
|
event_loop_handle.request_quote(),
|
|
|
|
bitcoin_wallet.new_address(),
|
2021-05-07 09:06:58 +00:00
|
|
|
|| bitcoin_wallet.balance(),
|
|
|
|
max_givable,
|
|
|
|
|| bitcoin_wallet.sync(),
|
2021-03-04 02:43:06 +00:00
|
|
|
)
|
|
|
|
.await?;
|
2021-03-03 02:56:25 +00:00
|
|
|
|
2021-05-20 23:53:06 +00:00
|
|
|
info!(%amount, %fees, %swap_id, "Swapping");
|
2021-05-07 09:06:58 +00:00
|
|
|
|
2021-05-11 02:00:11 +00:00
|
|
|
db.insert_peer_id(swap_id, seller_peer_id).await?;
|
2021-03-30 04:40:59 +00:00
|
|
|
|
2021-04-16 02:00:11 +00:00
|
|
|
let swap = Swap::new(
|
2021-02-11 04:21:34 +00:00
|
|
|
db,
|
2021-03-30 04:40:59 +00:00
|
|
|
swap_id,
|
2021-04-16 02:00:11 +00:00
|
|
|
bitcoin_wallet,
|
2021-02-28 23:53:43 +00:00
|
|
|
Arc::new(monero_wallet),
|
2021-03-17 03:55:42 +00:00
|
|
|
env_config,
|
2021-03-03 02:56:25 +00:00
|
|
|
event_loop_handle,
|
2021-05-11 06:52:40 +00:00
|
|
|
monero_receive_address,
|
2021-05-20 23:53:06 +00:00
|
|
|
amount,
|
2021-04-16 02:00:11 +00:00
|
|
|
);
|
2021-02-28 23:53:43 +00:00
|
|
|
|
2021-02-26 05:11:14 +00:00
|
|
|
tokio::select! {
|
2021-03-18 06:48:54 +00:00
|
|
|
result = event_loop => {
|
|
|
|
result
|
2021-03-18 07:00:02 +00:00
|
|
|
.context("EventLoop panicked")?;
|
2021-02-26 05:11:14 +00:00
|
|
|
},
|
2021-03-18 06:48:54 +00:00
|
|
|
result = bob::run(swap) => {
|
|
|
|
result.context("Failed to complete swap")?;
|
2021-02-26 05:11:14 +00:00
|
|
|
}
|
|
|
|
}
|
2020-12-04 05:27:17 +00:00
|
|
|
}
|
2021-02-28 23:53:43 +00:00
|
|
|
Command::History => {
|
2021-04-02 07:22:51 +00:00
|
|
|
let db = Database::open(data_dir.join("database").as_path())
|
|
|
|
.context("Failed to open database")?;
|
|
|
|
|
2020-12-04 05:27:17 +00:00
|
|
|
let mut table = Table::new();
|
|
|
|
|
|
|
|
table.add_row(row!["SWAP ID", "STATE"]);
|
|
|
|
|
2021-03-26 04:16:19 +00:00
|
|
|
for (swap_id, state) in db.all_bob()? {
|
2020-12-04 05:27:17 +00:00
|
|
|
table.add_row(row![swap_id, state]);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Print the table to stdout
|
|
|
|
table.printstd();
|
|
|
|
}
|
2021-02-28 23:53:43 +00:00
|
|
|
Command::Resume {
|
2021-05-11 06:52:40 +00:00
|
|
|
swap_id,
|
|
|
|
seller_addr,
|
|
|
|
bitcoin_electrum_rpc_url,
|
|
|
|
bitcoin_target_block,
|
|
|
|
monero_receive_address,
|
|
|
|
monero_daemon_address,
|
|
|
|
tor_socks5_port,
|
2021-02-28 23:53:43 +00:00
|
|
|
} => {
|
2021-05-20 06:36:01 +00:00
|
|
|
cli::tracing::init(debug, json, data_dir.join("logs"), swap_id)?;
|
2021-04-02 07:22:51 +00:00
|
|
|
let db = Database::open(data_dir.join("database").as_path())
|
|
|
|
.context("Failed to open database")?;
|
|
|
|
let seed = Seed::from_file_or_generate(data_dir.as_path())
|
|
|
|
.context("Failed to read in seed file")?;
|
|
|
|
|
2021-05-11 12:22:59 +00:00
|
|
|
if monero_receive_address.network != env_config.monero_network {
|
2021-05-11 06:52:40 +00:00
|
|
|
bail!("The given monero address is on network {:?}, expected address of network {:?}.", monero_receive_address.network, env_config.monero_network)
|
2021-03-03 23:46:12 +00:00
|
|
|
}
|
|
|
|
|
2021-05-02 23:48:40 +00:00
|
|
|
let bitcoin_wallet = init_bitcoin_wallet(
|
2021-05-11 06:52:40 +00:00
|
|
|
bitcoin_electrum_rpc_url,
|
2021-05-02 23:48:40 +00:00
|
|
|
&seed,
|
|
|
|
data_dir.clone(),
|
|
|
|
env_config,
|
|
|
|
bitcoin_target_block,
|
|
|
|
)
|
|
|
|
.await?;
|
2021-03-17 02:36:43 +00:00
|
|
|
let (monero_wallet, _process) =
|
2021-05-11 02:37:13 +00:00
|
|
|
init_monero_wallet(data_dir, monero_daemon_address, env_config).await?;
|
2021-03-03 02:56:25 +00:00
|
|
|
let bitcoin_wallet = Arc::new(bitcoin_wallet);
|
2021-01-18 10:57:17 +00:00
|
|
|
|
2021-05-11 02:00:11 +00:00
|
|
|
let seller_peer_id = db.get_peer_id(swap_id)?;
|
2021-04-22 01:33:36 +00:00
|
|
|
|
2021-06-09 02:03:06 +00:00
|
|
|
let mut swarm = swarm::cli(&seed, seller_peer_id, tor_socks5_port).await?;
|
2021-05-20 23:53:06 +00:00
|
|
|
let our_peer_id = swarm.local_peer_id();
|
|
|
|
tracing::debug!(peer_id = %our_peer_id, "Initializing network module");
|
2021-04-15 07:44:21 +00:00
|
|
|
swarm
|
|
|
|
.behaviour_mut()
|
2021-05-11 02:00:11 +00:00
|
|
|
.add_address(seller_peer_id, seller_addr);
|
2021-03-23 05:56:04 +00:00
|
|
|
|
2021-05-11 12:22:59 +00:00
|
|
|
let (event_loop, event_loop_handle) = EventLoop::new(
|
|
|
|
swap_id,
|
|
|
|
swarm,
|
|
|
|
seller_peer_id,
|
|
|
|
bitcoin_wallet.clone(),
|
|
|
|
env_config,
|
|
|
|
)?;
|
2021-03-03 02:56:25 +00:00
|
|
|
let handle = tokio::spawn(event_loop.run());
|
|
|
|
|
2021-04-16 02:00:11 +00:00
|
|
|
let swap = Swap::from_db(
|
2021-02-11 04:21:34 +00:00
|
|
|
db,
|
2020-12-21 03:43:44 +00:00
|
|
|
swap_id,
|
2021-04-16 02:00:11 +00:00
|
|
|
bitcoin_wallet,
|
2021-01-20 02:36:38 +00:00
|
|
|
Arc::new(monero_wallet),
|
2021-03-17 03:55:42 +00:00
|
|
|
env_config,
|
2021-03-03 02:56:25 +00:00
|
|
|
event_loop_handle,
|
2021-05-11 06:52:40 +00:00
|
|
|
monero_receive_address,
|
2021-04-16 02:00:11 +00:00
|
|
|
)?;
|
2021-03-03 02:56:25 +00:00
|
|
|
|
2021-02-26 05:11:14 +00:00
|
|
|
tokio::select! {
|
|
|
|
event_loop_result = handle => {
|
2021-03-18 07:00:02 +00:00
|
|
|
event_loop_result?;
|
2021-02-26 05:11:14 +00:00
|
|
|
},
|
2021-03-18 06:48:54 +00:00
|
|
|
swap_result = bob::run(swap) => {
|
2021-02-26 05:11:14 +00:00
|
|
|
swap_result?;
|
|
|
|
}
|
|
|
|
}
|
2020-12-15 10:26:02 +00:00
|
|
|
}
|
2021-03-15 01:02:42 +00:00
|
|
|
Command::Cancel {
|
2021-05-11 06:52:40 +00:00
|
|
|
swap_id,
|
2021-03-15 01:02:42 +00:00
|
|
|
force,
|
2021-05-11 06:52:40 +00:00
|
|
|
bitcoin_electrum_rpc_url,
|
|
|
|
bitcoin_target_block,
|
2021-03-15 01:02:42 +00:00
|
|
|
} => {
|
2021-05-20 06:36:01 +00:00
|
|
|
cli::tracing::init(debug, json, data_dir.join("logs"), swap_id)?;
|
2021-04-02 07:22:51 +00:00
|
|
|
let db = Database::open(data_dir.join("database").as_path())
|
|
|
|
.context("Failed to open database")?;
|
|
|
|
let seed = Seed::from_file_or_generate(data_dir.as_path())
|
|
|
|
.context("Failed to read in seed file")?;
|
|
|
|
|
2021-05-02 23:48:40 +00:00
|
|
|
let bitcoin_wallet = init_bitcoin_wallet(
|
2021-05-11 06:52:40 +00:00
|
|
|
bitcoin_electrum_rpc_url,
|
2021-05-02 23:48:40 +00:00
|
|
|
&seed,
|
|
|
|
data_dir,
|
|
|
|
env_config,
|
|
|
|
bitcoin_target_block,
|
|
|
|
)
|
|
|
|
.await?;
|
2021-02-01 05:10:43 +00:00
|
|
|
|
2021-04-29 01:02:26 +00:00
|
|
|
let cancel = bob::cancel(swap_id, Arc::new(bitcoin_wallet), db, force).await?;
|
2021-02-26 05:11:14 +00:00
|
|
|
|
2021-03-03 02:17:09 +00:00
|
|
|
match cancel {
|
|
|
|
Ok((txid, _)) => {
|
|
|
|
debug!("Cancel transaction successfully published with id {}", txid)
|
|
|
|
}
|
2021-03-04 06:02:03 +00:00
|
|
|
Err(bob::cancel::Error::CancelTimelockNotExpiredYet) => error!(
|
2021-05-05 03:49:11 +00:00
|
|
|
"The Cancel Transaction cannot be published yet, because the timelock has not expired. Please try again later"
|
2021-03-03 02:17:09 +00:00
|
|
|
),
|
2021-02-01 05:10:43 +00:00
|
|
|
}
|
|
|
|
}
|
2021-03-15 01:02:42 +00:00
|
|
|
Command::Refund {
|
2021-05-11 06:52:40 +00:00
|
|
|
swap_id,
|
2021-03-15 01:02:42 +00:00
|
|
|
force,
|
2021-05-11 06:52:40 +00:00
|
|
|
bitcoin_electrum_rpc_url,
|
|
|
|
bitcoin_target_block,
|
2021-03-15 01:02:42 +00:00
|
|
|
} => {
|
2021-05-20 06:36:01 +00:00
|
|
|
cli::tracing::init(debug, json, data_dir.join("logs"), swap_id)?;
|
2021-04-02 07:22:51 +00:00
|
|
|
let db = Database::open(data_dir.join("database").as_path())
|
|
|
|
.context("Failed to open database")?;
|
|
|
|
let seed = Seed::from_file_or_generate(data_dir.as_path())
|
|
|
|
.context("Failed to read in seed file")?;
|
|
|
|
|
2021-05-02 23:48:40 +00:00
|
|
|
let bitcoin_wallet = init_bitcoin_wallet(
|
2021-05-11 06:52:40 +00:00
|
|
|
bitcoin_electrum_rpc_url,
|
2021-05-02 23:48:40 +00:00
|
|
|
&seed,
|
|
|
|
data_dir,
|
|
|
|
env_config,
|
|
|
|
bitcoin_target_block,
|
|
|
|
)
|
|
|
|
.await?;
|
2021-02-01 05:25:33 +00:00
|
|
|
|
2021-04-29 01:02:26 +00:00
|
|
|
bob::refund(swap_id, Arc::new(bitcoin_wallet), db, force).await??;
|
2021-02-01 05:25:33 +00:00
|
|
|
}
|
2020-12-21 03:43:44 +00:00
|
|
|
};
|
2020-12-04 05:27:17 +00:00
|
|
|
Ok(())
|
2020-10-15 22:14:39 +00:00
|
|
|
}
|
2020-12-15 10:26:02 +00:00
|
|
|
|
2021-03-03 02:17:09 +00:00
|
|
|
async fn init_bitcoin_wallet(
|
2021-03-15 01:02:42 +00:00
|
|
|
electrum_rpc_url: Url,
|
2021-03-23 05:53:25 +00:00
|
|
|
seed: &Seed,
|
2021-03-15 01:02:42 +00:00
|
|
|
data_dir: PathBuf,
|
2021-03-17 03:55:42 +00:00
|
|
|
env_config: Config,
|
2021-05-02 23:48:40 +00:00
|
|
|
bitcoin_target_block: usize,
|
2021-03-03 02:17:09 +00:00
|
|
|
) -> Result<bitcoin::Wallet> {
|
2021-03-15 01:02:42 +00:00
|
|
|
let wallet_dir = data_dir.join("wallet");
|
2021-03-04 05:54:26 +00:00
|
|
|
|
|
|
|
let wallet = bitcoin::Wallet::new(
|
2021-03-15 01:02:42 +00:00
|
|
|
electrum_rpc_url.clone(),
|
2021-03-04 05:54:26 +00:00
|
|
|
&wallet_dir,
|
2021-03-17 03:55:42 +00:00
|
|
|
seed.derive_extended_private_key(env_config.bitcoin_network)?,
|
|
|
|
env_config,
|
2021-05-02 23:48:40 +00:00
|
|
|
bitcoin_target_block,
|
2021-01-27 02:33:32 +00:00
|
|
|
)
|
2021-03-04 06:16:18 +00:00
|
|
|
.await
|
|
|
|
.context("Failed to initialize Bitcoin wallet")?;
|
2021-02-01 23:39:34 +00:00
|
|
|
|
2021-03-04 06:07:02 +00:00
|
|
|
wallet.sync().await?;
|
2020-12-15 10:26:02 +00:00
|
|
|
|
2021-03-04 05:54:26 +00:00
|
|
|
Ok(wallet)
|
2021-03-03 02:17:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
async fn init_monero_wallet(
|
2021-03-15 01:02:42 +00:00
|
|
|
data_dir: PathBuf,
|
2021-05-11 02:37:13 +00:00
|
|
|
monero_daemon_address: String,
|
2021-03-17 03:55:42 +00:00
|
|
|
env_config: Config,
|
2021-03-04 05:54:26 +00:00
|
|
|
) -> Result<(monero::Wallet, monero::WalletRpcProcess)> {
|
2021-03-17 03:55:42 +00:00
|
|
|
let network = env_config.monero_network;
|
2021-03-17 02:36:43 +00:00
|
|
|
|
2021-03-04 05:55:40 +00:00
|
|
|
const MONERO_BLOCKCHAIN_MONITORING_WALLET_NAME: &str = "swap-tool-blockchain-monitoring-wallet";
|
|
|
|
|
2021-03-15 01:02:42 +00:00
|
|
|
let monero_wallet_rpc = monero::WalletRpc::new(data_dir.join("monero")).await?;
|
2021-03-04 05:54:26 +00:00
|
|
|
|
|
|
|
let monero_wallet_rpc_process = monero_wallet_rpc
|
2021-05-11 12:22:59 +00:00
|
|
|
.run(network, monero_daemon_address.as_str())
|
2021-03-04 05:54:26 +00:00
|
|
|
.await?;
|
|
|
|
|
2021-03-16 08:24:41 +00:00
|
|
|
let monero_wallet = monero::Wallet::open_or_create(
|
2021-03-04 05:54:26 +00:00
|
|
|
monero_wallet_rpc_process.endpoint(),
|
2021-02-24 07:00:07 +00:00
|
|
|
MONERO_BLOCKCHAIN_MONITORING_WALLET_NAME.to_string(),
|
2021-03-17 03:55:42 +00:00
|
|
|
env_config,
|
2021-03-16 08:24:41 +00:00
|
|
|
)
|
|
|
|
.await?;
|
2020-12-15 10:26:02 +00:00
|
|
|
|
2021-03-04 05:54:26 +00:00
|
|
|
Ok((monero_wallet, monero_wallet_rpc_process))
|
2020-12-15 10:26:02 +00:00
|
|
|
}
|
2021-03-04 02:43:06 +00:00
|
|
|
|
2021-05-30 11:53:43 +00:00
|
|
|
fn qr_code(value: &impl ToString) -> Result<String> {
|
|
|
|
let code = QrCode::new(value.to_string())?;
|
|
|
|
let qr_code = code
|
|
|
|
.render::<unicode::Dense1x2>()
|
|
|
|
.dark_color(unicode::Dense1x2::Light)
|
|
|
|
.light_color(unicode::Dense1x2::Dark)
|
|
|
|
.build();
|
|
|
|
Ok(qr_code)
|
|
|
|
}
|
|
|
|
|
2021-05-07 09:06:58 +00:00
|
|
|
async fn determine_btc_to_swap<FB, TB, FMG, TMG, FS, TS>(
|
2021-05-30 11:53:43 +00:00
|
|
|
json: bool,
|
2021-05-07 09:06:58 +00:00
|
|
|
bid_quote: impl Future<Output = Result<BidQuote>>,
|
2021-03-04 02:43:06 +00:00
|
|
|
get_new_address: impl Future<Output = Result<bitcoin::Address>>,
|
2021-05-07 09:06:58 +00:00
|
|
|
balance: FB,
|
2021-06-21 01:56:04 +00:00
|
|
|
max_giveable_fn: FMG,
|
2021-05-07 09:06:58 +00:00
|
|
|
sync: FS,
|
|
|
|
) -> Result<(bitcoin::Amount, bitcoin::Amount)>
|
|
|
|
where
|
|
|
|
TB: Future<Output = Result<bitcoin::Amount>>,
|
|
|
|
FB: Fn() -> TB,
|
|
|
|
TMG: Future<Output = Result<bitcoin::Amount>>,
|
|
|
|
FMG: Fn() -> TMG,
|
|
|
|
TS: Future<Output = Result<()>>,
|
|
|
|
FS: Fn() -> TS,
|
|
|
|
{
|
2021-03-04 02:43:06 +00:00
|
|
|
debug!("Requesting quote");
|
2021-05-07 09:06:58 +00:00
|
|
|
let bid_quote = bid_quote.await?;
|
2021-05-12 05:50:00 +00:00
|
|
|
info!(
|
2021-05-20 23:53:06 +00:00
|
|
|
price = %bid_quote.price,
|
2021-05-12 05:50:00 +00:00
|
|
|
minimum_amount = %bid_quote.min_quantity,
|
|
|
|
maximum_amount = %bid_quote.max_quantity,
|
2021-05-20 23:53:06 +00:00
|
|
|
"Received quote: 1 XMR ~ ",
|
2021-05-12 05:50:00 +00:00
|
|
|
);
|
2021-03-04 02:43:06 +00:00
|
|
|
|
2021-06-21 01:56:04 +00:00
|
|
|
let mut max_giveable = max_giveable_fn().await?;
|
2021-05-12 05:44:22 +00:00
|
|
|
|
2021-06-21 01:56:04 +00:00
|
|
|
if max_giveable == bitcoin::Amount::ZERO || max_giveable < bid_quote.min_quantity {
|
2021-05-07 09:06:58 +00:00
|
|
|
let deposit_address = get_new_address.await?;
|
|
|
|
let minimum_amount = bid_quote.min_quantity;
|
|
|
|
let maximum_amount = bid_quote.max_quantity;
|
2021-03-04 02:43:06 +00:00
|
|
|
|
2021-05-30 11:53:43 +00:00
|
|
|
if !json {
|
|
|
|
eprintln!("{}", qr_code(&deposit_address)?);
|
|
|
|
}
|
|
|
|
|
2021-03-04 02:43:06 +00:00
|
|
|
info!(
|
2021-05-07 09:06:58 +00:00
|
|
|
%deposit_address,
|
2021-06-21 01:56:04 +00:00
|
|
|
%max_giveable,
|
2021-05-07 09:06:58 +00:00
|
|
|
%minimum_amount,
|
|
|
|
%maximum_amount,
|
|
|
|
"Please deposit BTC you want to swap to",
|
2021-03-04 02:43:06 +00:00
|
|
|
);
|
|
|
|
|
2021-05-07 09:06:58 +00:00
|
|
|
loop {
|
|
|
|
sync().await?;
|
|
|
|
|
2021-06-21 01:56:04 +00:00
|
|
|
let new_max_givable = max_giveable_fn().await?;
|
2021-05-07 09:06:58 +00:00
|
|
|
|
2021-06-21 01:56:04 +00:00
|
|
|
if new_max_givable != max_giveable {
|
|
|
|
max_giveable = new_max_givable;
|
2021-05-07 09:06:58 +00:00
|
|
|
|
|
|
|
let new_balance = balance().await?;
|
|
|
|
tracing::info!(
|
|
|
|
%new_balance,
|
2021-06-21 01:56:04 +00:00
|
|
|
%max_giveable,
|
2021-05-07 09:06:58 +00:00
|
|
|
"Received BTC",
|
|
|
|
);
|
|
|
|
|
2021-06-21 01:56:04 +00:00
|
|
|
if max_giveable >= bid_quote.min_quantity {
|
2021-05-07 09:06:58 +00:00
|
|
|
break;
|
|
|
|
} else {
|
|
|
|
tracing::info!(
|
|
|
|
%minimum_amount,
|
|
|
|
%deposit_address,
|
|
|
|
"Please deposit more, not enough BTC to trigger swap with",
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
tokio::time::sleep(Duration::from_secs(1)).await;
|
|
|
|
}
|
2021-03-19 06:40:14 +00:00
|
|
|
};
|
2021-03-04 02:43:06 +00:00
|
|
|
|
2021-05-07 09:06:58 +00:00
|
|
|
let balance = balance().await?;
|
2021-03-19 06:40:14 +00:00
|
|
|
let fees = balance - max_giveable;
|
|
|
|
|
2021-03-04 02:43:06 +00:00
|
|
|
let max_accepted = bid_quote.max_quantity;
|
|
|
|
|
2021-03-19 06:40:14 +00:00
|
|
|
let btc_swap_amount = min(max_giveable, max_accepted);
|
2021-03-04 02:43:06 +00:00
|
|
|
|
2021-05-07 09:06:58 +00:00
|
|
|
Ok((btc_swap_amount, fees))
|
2021-03-04 02:43:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
|
|
|
use super::*;
|
|
|
|
use crate::determine_btc_to_swap;
|
|
|
|
use ::bitcoin::Amount;
|
2021-05-12 05:44:22 +00:00
|
|
|
use std::sync::Mutex;
|
2021-03-04 02:43:06 +00:00
|
|
|
use tracing::subscriber;
|
|
|
|
|
2021-05-12 05:44:22 +00:00
|
|
|
struct MaxGiveable {
|
|
|
|
amounts: Vec<Amount>,
|
|
|
|
call_counter: usize,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl MaxGiveable {
|
|
|
|
fn new(amounts: Vec<Amount>) -> Self {
|
|
|
|
Self {
|
|
|
|
amounts,
|
|
|
|
call_counter: 0,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
fn give(&mut self) -> Result<Amount> {
|
|
|
|
let amount = self
|
|
|
|
.amounts
|
|
|
|
.get(self.call_counter)
|
|
|
|
.ok_or_else(|| anyhow::anyhow!("No more balances available"))?;
|
|
|
|
self.call_counter += 1;
|
|
|
|
Ok(*amount)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-03-04 02:43:06 +00:00
|
|
|
#[tokio::test]
|
|
|
|
async fn given_no_balance_and_transfers_less_than_max_swaps_max_giveable() {
|
|
|
|
let _guard = subscriber::set_default(tracing_subscriber::fmt().with_test_writer().finish());
|
2021-05-12 05:44:22 +00:00
|
|
|
let givable = Arc::new(Mutex::new(MaxGiveable::new(vec![
|
|
|
|
Amount::ZERO,
|
|
|
|
Amount::from_btc(0.0009).unwrap(),
|
|
|
|
])));
|
2021-03-04 02:43:06 +00:00
|
|
|
|
2021-05-07 09:06:58 +00:00
|
|
|
let (amount, fees) = determine_btc_to_swap(
|
2021-05-30 11:53:43 +00:00
|
|
|
true,
|
2021-03-04 02:43:06 +00:00
|
|
|
async { Ok(quote_with_max(0.01)) },
|
|
|
|
get_dummy_address(),
|
2021-05-07 09:06:58 +00:00
|
|
|
|| async { Ok(Amount::from_btc(0.001)?) },
|
2021-05-12 05:44:22 +00:00
|
|
|
|| async {
|
|
|
|
let mut result = givable.lock().unwrap();
|
|
|
|
result.give()
|
|
|
|
},
|
2021-05-07 09:06:58 +00:00
|
|
|
|| async { Ok(()) },
|
2021-03-04 02:43:06 +00:00
|
|
|
)
|
|
|
|
.await
|
|
|
|
.unwrap();
|
|
|
|
|
2021-05-07 09:06:58 +00:00
|
|
|
let expected_amount = Amount::from_btc(0.0009).unwrap();
|
|
|
|
let expected_fees = Amount::from_btc(0.0001).unwrap();
|
|
|
|
|
|
|
|
assert_eq!((amount, fees), (expected_amount, expected_fees))
|
2021-03-04 02:43:06 +00:00
|
|
|
}
|
|
|
|
#[tokio::test]
|
|
|
|
async fn given_no_balance_and_transfers_more_then_swaps_max_quantity_from_quote() {
|
|
|
|
let _guard = subscriber::set_default(tracing_subscriber::fmt().with_test_writer().finish());
|
2021-05-12 05:44:22 +00:00
|
|
|
let givable = Arc::new(Mutex::new(MaxGiveable::new(vec![
|
|
|
|
Amount::ZERO,
|
|
|
|
Amount::from_btc(0.1).unwrap(),
|
|
|
|
])));
|
2021-03-04 02:43:06 +00:00
|
|
|
|
2021-05-07 09:06:58 +00:00
|
|
|
let (amount, fees) = determine_btc_to_swap(
|
2021-05-30 11:53:43 +00:00
|
|
|
true,
|
2021-03-04 02:43:06 +00:00
|
|
|
async { Ok(quote_with_max(0.01)) },
|
|
|
|
get_dummy_address(),
|
2021-05-07 09:06:58 +00:00
|
|
|
|| async { Ok(Amount::from_btc(0.1001)?) },
|
2021-05-12 05:44:22 +00:00
|
|
|
|| async {
|
|
|
|
let mut result = givable.lock().unwrap();
|
|
|
|
result.give()
|
|
|
|
},
|
2021-05-07 09:06:58 +00:00
|
|
|
|| async { Ok(()) },
|
2021-03-04 02:43:06 +00:00
|
|
|
)
|
|
|
|
.await
|
|
|
|
.unwrap();
|
|
|
|
|
2021-05-07 09:06:58 +00:00
|
|
|
let expected_amount = Amount::from_btc(0.01).unwrap();
|
|
|
|
let expected_fees = Amount::from_btc(0.0001).unwrap();
|
|
|
|
|
|
|
|
assert_eq!((amount, fees), (expected_amount, expected_fees))
|
2021-03-04 02:43:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[tokio::test]
|
|
|
|
async fn given_initial_balance_below_max_quantity_swaps_max_givable() {
|
|
|
|
let _guard = subscriber::set_default(tracing_subscriber::fmt().with_test_writer().finish());
|
2021-05-12 05:44:22 +00:00
|
|
|
let givable = Arc::new(Mutex::new(MaxGiveable::new(vec![
|
|
|
|
Amount::from_btc(0.0049).unwrap(),
|
|
|
|
Amount::from_btc(99.9).unwrap(),
|
|
|
|
])));
|
2021-03-04 02:43:06 +00:00
|
|
|
|
2021-05-07 09:06:58 +00:00
|
|
|
let (amount, fees) = determine_btc_to_swap(
|
2021-05-30 11:53:43 +00:00
|
|
|
true,
|
2021-03-04 02:43:06 +00:00
|
|
|
async { Ok(quote_with_max(0.01)) },
|
2021-05-12 05:44:22 +00:00
|
|
|
async { panic!("should not request new address when initial balance is > 0") },
|
2021-05-07 09:06:58 +00:00
|
|
|
|| async { Ok(Amount::from_btc(0.005)?) },
|
2021-05-12 05:44:22 +00:00
|
|
|
|| async {
|
|
|
|
let mut result = givable.lock().unwrap();
|
|
|
|
result.give()
|
|
|
|
},
|
2021-05-07 09:06:58 +00:00
|
|
|
|| async { Ok(()) },
|
2021-03-04 02:43:06 +00:00
|
|
|
)
|
|
|
|
.await
|
|
|
|
.unwrap();
|
|
|
|
|
2021-05-07 09:06:58 +00:00
|
|
|
let expected_amount = Amount::from_btc(0.0049).unwrap();
|
|
|
|
let expected_fees = Amount::from_btc(0.0001).unwrap();
|
|
|
|
|
|
|
|
assert_eq!((amount, fees), (expected_amount, expected_fees))
|
2021-03-04 02:43:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[tokio::test]
|
|
|
|
async fn given_initial_balance_above_max_quantity_swaps_max_quantity() {
|
|
|
|
let _guard = subscriber::set_default(tracing_subscriber::fmt().with_test_writer().finish());
|
2021-05-12 05:44:22 +00:00
|
|
|
let givable = Arc::new(Mutex::new(MaxGiveable::new(vec![
|
|
|
|
Amount::from_btc(0.1).unwrap(),
|
|
|
|
Amount::from_btc(99.9).unwrap(),
|
|
|
|
])));
|
2021-03-04 02:43:06 +00:00
|
|
|
|
2021-05-07 09:06:58 +00:00
|
|
|
let (amount, fees) = determine_btc_to_swap(
|
2021-05-30 11:53:43 +00:00
|
|
|
true,
|
2021-03-04 02:43:06 +00:00
|
|
|
async { Ok(quote_with_max(0.01)) },
|
|
|
|
async { panic!("should not request new address when initial balance is > 0") },
|
2021-05-07 09:06:58 +00:00
|
|
|
|| async { Ok(Amount::from_btc(0.1001)?) },
|
2021-05-12 05:44:22 +00:00
|
|
|
|| async {
|
|
|
|
let mut result = givable.lock().unwrap();
|
|
|
|
result.give()
|
|
|
|
},
|
2021-05-07 09:06:58 +00:00
|
|
|
|| async { Ok(()) },
|
|
|
|
)
|
|
|
|
.await
|
|
|
|
.unwrap();
|
|
|
|
|
|
|
|
let expected_amount = Amount::from_btc(0.01).unwrap();
|
|
|
|
let expected_fees = Amount::from_btc(0.0001).unwrap();
|
|
|
|
|
|
|
|
assert_eq!((amount, fees), (expected_amount, expected_fees))
|
|
|
|
}
|
|
|
|
|
|
|
|
#[tokio::test]
|
|
|
|
async fn given_no_initial_balance_then_min_wait_for_sufficient_deposit() {
|
|
|
|
let _guard = subscriber::set_default(tracing_subscriber::fmt().with_test_writer().finish());
|
2021-05-12 05:44:22 +00:00
|
|
|
let givable = Arc::new(Mutex::new(MaxGiveable::new(vec![
|
|
|
|
Amount::ZERO,
|
|
|
|
Amount::from_btc(0.01).unwrap(),
|
|
|
|
])));
|
2021-05-07 09:06:58 +00:00
|
|
|
|
|
|
|
let (amount, fees) = determine_btc_to_swap(
|
2021-05-30 11:53:43 +00:00
|
|
|
true,
|
2021-05-07 09:06:58 +00:00
|
|
|
async { Ok(quote_with_min(0.01)) },
|
|
|
|
get_dummy_address(),
|
|
|
|
|| async { Ok(Amount::from_btc(0.0101)?) },
|
2021-05-12 05:44:22 +00:00
|
|
|
|| async {
|
|
|
|
let mut result = givable.lock().unwrap();
|
|
|
|
result.give()
|
|
|
|
},
|
2021-05-07 09:06:58 +00:00
|
|
|
|| async { Ok(()) },
|
2021-03-04 02:43:06 +00:00
|
|
|
)
|
|
|
|
.await
|
|
|
|
.unwrap();
|
|
|
|
|
2021-05-07 09:06:58 +00:00
|
|
|
let expected_amount = Amount::from_btc(0.01).unwrap();
|
|
|
|
let expected_fees = Amount::from_btc(0.0001).unwrap();
|
|
|
|
|
|
|
|
assert_eq!((amount, fees), (expected_amount, expected_fees))
|
|
|
|
}
|
|
|
|
|
|
|
|
#[tokio::test]
|
|
|
|
async fn given_balance_less_then_min_wait_for_sufficient_deposit() {
|
|
|
|
let _guard = subscriber::set_default(tracing_subscriber::fmt().with_test_writer().finish());
|
2021-05-12 05:44:22 +00:00
|
|
|
let givable = Arc::new(Mutex::new(MaxGiveable::new(vec![
|
|
|
|
Amount::from_btc(0.0001).unwrap(),
|
|
|
|
Amount::from_btc(0.01).unwrap(),
|
|
|
|
])));
|
2021-05-07 09:06:58 +00:00
|
|
|
|
|
|
|
let (amount, fees) = determine_btc_to_swap(
|
2021-05-30 11:53:43 +00:00
|
|
|
true,
|
2021-05-07 09:06:58 +00:00
|
|
|
async { Ok(quote_with_min(0.01)) },
|
|
|
|
get_dummy_address(),
|
|
|
|
|| async { Ok(Amount::from_btc(0.0101)?) },
|
2021-05-12 05:44:22 +00:00
|
|
|
|| async {
|
|
|
|
let mut result = givable.lock().unwrap();
|
|
|
|
result.give()
|
|
|
|
},
|
2021-05-07 09:06:58 +00:00
|
|
|
|| async { Ok(()) },
|
|
|
|
)
|
|
|
|
.await
|
|
|
|
.unwrap();
|
|
|
|
|
|
|
|
let expected_amount = Amount::from_btc(0.01).unwrap();
|
|
|
|
let expected_fees = Amount::from_btc(0.0001).unwrap();
|
|
|
|
|
|
|
|
assert_eq!((amount, fees), (expected_amount, expected_fees))
|
|
|
|
}
|
|
|
|
|
|
|
|
#[tokio::test]
|
|
|
|
async fn given_no_initial_balance_and_transfers_less_than_min_keep_waiting() {
|
|
|
|
let _guard = subscriber::set_default(tracing_subscriber::fmt().with_test_writer().finish());
|
2021-05-12 05:44:22 +00:00
|
|
|
let givable = Arc::new(Mutex::new(MaxGiveable::new(vec![
|
|
|
|
Amount::ZERO,
|
|
|
|
Amount::from_btc(0.01).unwrap(),
|
|
|
|
Amount::from_btc(0.01).unwrap(),
|
|
|
|
Amount::from_btc(0.01).unwrap(),
|
|
|
|
Amount::from_btc(0.01).unwrap(),
|
|
|
|
])));
|
2021-05-07 09:06:58 +00:00
|
|
|
|
|
|
|
let error = tokio::time::timeout(
|
|
|
|
Duration::from_secs(1),
|
|
|
|
determine_btc_to_swap(
|
2021-05-30 11:53:43 +00:00
|
|
|
true,
|
2021-05-07 09:06:58 +00:00
|
|
|
async { Ok(quote_with_min(0.1)) },
|
|
|
|
get_dummy_address(),
|
|
|
|
|| async { Ok(Amount::from_btc(0.0101)?) },
|
2021-05-12 05:44:22 +00:00
|
|
|
|| async {
|
|
|
|
let mut result = givable.lock().unwrap();
|
|
|
|
result.give()
|
|
|
|
},
|
2021-05-07 09:06:58 +00:00
|
|
|
|| async { Ok(()) },
|
|
|
|
),
|
|
|
|
)
|
|
|
|
.await
|
|
|
|
.unwrap_err();
|
|
|
|
|
|
|
|
assert!(matches!(error, tokio::time::error::Elapsed { .. }))
|
2021-03-04 02:43:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
fn quote_with_max(btc: f64) -> BidQuote {
|
|
|
|
BidQuote {
|
|
|
|
price: Amount::from_btc(0.001).unwrap(),
|
|
|
|
max_quantity: Amount::from_btc(btc).unwrap(),
|
2021-05-07 09:06:58 +00:00
|
|
|
min_quantity: Amount::ZERO,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn quote_with_min(btc: f64) -> BidQuote {
|
|
|
|
BidQuote {
|
|
|
|
price: Amount::from_btc(0.001).unwrap(),
|
|
|
|
max_quantity: Amount::max_value(),
|
|
|
|
min_quantity: Amount::from_btc(btc).unwrap(),
|
2021-03-04 02:43:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
async fn get_dummy_address() -> Result<bitcoin::Address> {
|
|
|
|
Ok("1PdfytjS7C8wwd9Lq5o4x9aXA2YRqaCpH6".parse()?)
|
|
|
|
}
|
|
|
|
}
|