xmr-btc-swap/swap/tests/testutils/mod.rs

542 lines
16 KiB
Rust
Raw Normal View History

use crate::testutils;
2020-12-09 22:59:09 -05:00
use bitcoin_harness::Bitcoind;
use futures::Future;
use get_port::get_port;
2021-01-20 05:42:35 -05:00
use libp2p::{core::Multiaddr, PeerId};
2020-12-09 22:59:09 -05:00
use monero_harness::{image, Monero};
2021-01-20 05:42:35 -05:00
use std::{path::PathBuf, sync::Arc};
2020-12-09 22:59:09 -05:00
use swap::{
bitcoin,
bitcoin::Timelock,
2021-01-29 01:27:50 -05:00
execution_params,
execution_params::{ExecutionParams, GetExecutionParams},
2021-01-18 05:57:17 -05:00
monero,
2021-01-20 21:43:25 -05:00
protocol::{alice, alice::AliceState, bob, bob::BobState, SwapAmounts},
seed::Seed,
2020-12-09 22:59:09 -05:00
};
use tempfile::tempdir;
use testcontainers::{clients::Cli, Container};
use tokio::task::JoinHandle;
2020-12-09 22:59:09 -05:00
use tracing_core::dispatcher::DefaultGuard;
use tracing_log::LogTracer;
use uuid::Uuid;
#[derive(Debug, Clone)]
pub struct StartingBalances {
pub xmr: monero::Amount,
pub btc: bitcoin::Amount,
}
2021-01-20 05:42:35 -05:00
struct AliceParams {
seed: Seed,
execution_params: ExecutionParams,
2021-01-20 05:42:35 -05:00
swap_id: Uuid,
bitcoin_wallet: Arc<bitcoin::Wallet>,
monero_wallet: Arc<monero::Wallet>,
db_path: PathBuf,
listen_address: Multiaddr,
}
impl AliceParams {
pub fn builder(&self) -> alice::Builder {
2021-01-20 05:42:35 -05:00
alice::Builder::new(
self.seed,
self.execution_params,
2021-01-20 05:42:35 -05:00
self.swap_id,
self.bitcoin_wallet.clone(),
self.monero_wallet.clone(),
self.db_path.clone(),
self.listen_address.clone(),
)
}
fn peer_id(&self) -> PeerId {
self.builder().peer_id()
2021-01-20 05:42:35 -05:00
}
}
#[derive(Debug, Clone)]
2021-01-20 05:42:35 -05:00
struct BobParams {
seed: Seed,
db_path: PathBuf,
swap_id: Uuid,
bitcoin_wallet: Arc<bitcoin::Wallet>,
monero_wallet: Arc<monero::Wallet>,
alice_address: Multiaddr,
alice_peer_id: PeerId,
execution_params: ExecutionParams,
2021-01-20 05:42:35 -05:00
}
impl BobParams {
pub fn builder(&self) -> bob::Builder {
bob::Builder::new(
self.seed,
self.db_path.clone(),
self.swap_id,
self.bitcoin_wallet.clone(),
self.monero_wallet.clone(),
self.alice_address.clone(),
self.alice_peer_id,
self.execution_params,
2021-01-20 05:42:35 -05:00
)
}
}
pub struct BobEventLoopJoinHandle(JoinHandle<()>);
pub struct AliceEventLoopJoinHandle(JoinHandle<()>);
pub struct TestContext {
swap_amounts: SwapAmounts,
2021-01-20 05:42:35 -05:00
alice_params: AliceParams,
alice_starting_balances: StartingBalances,
alice_bitcoin_wallet: Arc<bitcoin::Wallet>,
alice_monero_wallet: Arc<monero::Wallet>,
2021-01-20 05:42:35 -05:00
bob_params: BobParams,
bob_starting_balances: StartingBalances,
bob_bitcoin_wallet: Arc<bitcoin::Wallet>,
bob_monero_wallet: Arc<monero::Wallet>,
}
impl TestContext {
pub async fn new_swap_as_alice(&mut self) -> (alice::Swap, AliceEventLoopJoinHandle) {
let (swap, mut event_loop) = self
2021-01-20 05:42:35 -05:00
.alice_params
.builder()
.with_init_params(self.swap_amounts)
.build()
2021-01-18 05:24:13 -05:00
.await
.unwrap();
let join_handle = tokio::spawn(async move { event_loop.run().await });
(swap, AliceEventLoopJoinHandle(join_handle))
}
pub async fn new_swap_as_bob(&mut self) -> (bob::Swap, BobEventLoopJoinHandle) {
let (swap, event_loop) = self
2021-01-20 05:42:35 -05:00
.bob_params
.builder()
.with_init_params(self.swap_amounts)
.build()
2021-01-18 05:57:17 -05:00
.await
.unwrap();
let join_handle = tokio::spawn(async move { event_loop.run().await });
(swap, BobEventLoopJoinHandle(join_handle))
}
pub async fn stop_and_resume_alice_from_db(
&mut self,
join_handle: AliceEventLoopJoinHandle,
) -> alice::Swap {
join_handle.0.abort();
let (swap, mut event_loop) = self.alice_params.builder().build().await.unwrap();
tokio::spawn(async move { event_loop.run().await });
swap
}
pub async fn stop_and_resume_bob_from_db(
&mut self,
join_handle: BobEventLoopJoinHandle,
) -> bob::Swap {
join_handle.0.abort();
2021-01-20 05:42:35 -05:00
let (swap, event_loop) = self.bob_params.builder().build().await.unwrap();
tokio::spawn(async move { event_loop.run().await });
swap
}
pub async fn assert_alice_redeemed(&self, state: AliceState) {
assert!(matches!(state, AliceState::BtcRedeemed));
let btc_balance_after_swap = self.alice_bitcoin_wallet.as_ref().balance().await.unwrap();
assert_eq!(
btc_balance_after_swap,
self.alice_starting_balances.btc + self.swap_amounts.btc
- bitcoin::Amount::from_sat(bitcoin::TX_FEE)
);
let xmr_balance_after_swap = self
.alice_monero_wallet
.as_ref()
.get_balance()
.await
.unwrap();
assert!(xmr_balance_after_swap <= self.alice_starting_balances.xmr - self.swap_amounts.xmr);
}
pub async fn assert_alice_refunded(&self, state: AliceState) {
assert!(matches!(state, AliceState::XmrRefunded));
let btc_balance_after_swap = self.alice_bitcoin_wallet.as_ref().balance().await.unwrap();
assert_eq!(btc_balance_after_swap, self.alice_starting_balances.btc);
// Ensure that Alice's balance is refreshed as we use a newly created wallet
self.alice_monero_wallet
.as_ref()
.inner
.refresh()
.await
.unwrap();
let xmr_balance_after_swap = self
.alice_monero_wallet
.as_ref()
.get_balance()
.await
.unwrap();
assert_eq!(xmr_balance_after_swap, self.swap_amounts.xmr);
}
pub async fn assert_alice_punished(&self, state: AliceState) {
assert!(matches!(state, AliceState::BtcPunished));
let btc_balance_after_swap = self.alice_bitcoin_wallet.as_ref().balance().await.unwrap();
assert_eq!(
btc_balance_after_swap,
self.alice_starting_balances.btc + self.swap_amounts.btc
- bitcoin::Amount::from_sat(2 * bitcoin::TX_FEE)
);
let xmr_balance_after_swap = self
.alice_monero_wallet
.as_ref()
.get_balance()
.await
.unwrap();
assert!(xmr_balance_after_swap <= self.alice_starting_balances.xmr - self.swap_amounts.xmr);
}
pub async fn assert_bob_redeemed(&self, state: BobState) {
let lock_tx_id = if let BobState::XmrRedeemed { tx_lock_id } = state {
tx_lock_id
} else {
2021-01-26 21:41:08 -05:00
panic!("Bob in not in xmr redeemed state: {:?}", state);
};
let lock_tx_bitcoin_fee = self
.bob_bitcoin_wallet
.transaction_fee(lock_tx_id)
.await
.unwrap();
let btc_balance_after_swap = self.bob_bitcoin_wallet.as_ref().balance().await.unwrap();
assert_eq!(
btc_balance_after_swap,
self.bob_starting_balances.btc - self.swap_amounts.btc - lock_tx_bitcoin_fee
);
// Ensure that Bob's balance is refreshed as we use a newly created wallet
self.bob_monero_wallet
.as_ref()
.inner
.refresh()
.await
.unwrap();
let xmr_balance_after_swap = self.bob_monero_wallet.as_ref().get_balance().await.unwrap();
assert_eq!(
xmr_balance_after_swap,
self.bob_starting_balances.xmr + self.swap_amounts.xmr
);
}
pub async fn assert_bob_refunded(&self, state: BobState) {
let lock_tx_id = if let BobState::BtcRefunded(state4) = state {
state4.tx_lock_id()
} else {
2021-01-26 21:41:08 -05:00
panic!("Bob in not in btc refunded state: {:?}", state);
};
let lock_tx_bitcoin_fee = self
.bob_bitcoin_wallet
.transaction_fee(lock_tx_id)
.await
.unwrap();
let btc_balance_after_swap = self.bob_bitcoin_wallet.as_ref().balance().await.unwrap();
let alice_submitted_cancel = btc_balance_after_swap
== self.bob_starting_balances.btc
- lock_tx_bitcoin_fee
- bitcoin::Amount::from_sat(bitcoin::TX_FEE);
let bob_submitted_cancel = btc_balance_after_swap
== self.bob_starting_balances.btc
- lock_tx_bitcoin_fee
- bitcoin::Amount::from_sat(2 * bitcoin::TX_FEE);
// The cancel tx can be submitted by both Alice and Bob.
// Since we cannot be sure who submitted it we have to assert accordingly
assert!(alice_submitted_cancel || bob_submitted_cancel);
let xmr_balance_after_swap = self.bob_monero_wallet.as_ref().get_balance().await.unwrap();
assert_eq!(xmr_balance_after_swap, self.bob_starting_balances.xmr);
}
pub async fn assert_bob_punished(&self, state: BobState) {
let lock_tx_id = if let BobState::BtcPunished { tx_lock_id } = state {
tx_lock_id
} else {
2021-01-26 21:41:08 -05:00
panic!("Bob in not in btc punished state: {:?}", state);
};
let lock_tx_bitcoin_fee = self
.bob_bitcoin_wallet
.transaction_fee(lock_tx_id)
.await
.unwrap();
let btc_balance_after_swap = self.bob_bitcoin_wallet.as_ref().balance().await.unwrap();
assert_eq!(
btc_balance_after_swap,
self.bob_starting_balances.btc - self.swap_amounts.btc - lock_tx_bitcoin_fee
);
let xmr_balance_after_swap = self.bob_monero_wallet.as_ref().get_balance().await.unwrap();
assert_eq!(xmr_balance_after_swap, self.bob_starting_balances.xmr);
}
}
2021-01-28 21:52:05 -05:00
pub async fn setup_test<T, F, C>(_config: C, testfn: T)
where
T: Fn(TestContext) -> F,
F: Future<Output = ()>,
C: GetExecutionParams,
{
let cli = Cli::default();
let _guard = init_tracing();
let execution_params = C::get_execution_params();
2021-01-28 21:52:05 -05:00
let (monero, containers) = testutils::init_containers(&cli).await;
let swap_amounts = SwapAmounts {
btc: bitcoin::Amount::from_sat(1_000_000),
xmr: monero::Amount::from_piconero(1_000_000_000_000),
};
let alice_starting_balances = StartingBalances {
xmr: swap_amounts.xmr * 10,
btc: bitcoin::Amount::ZERO,
};
2021-01-18 05:24:13 -05:00
let port = get_port().expect("Failed to find a free port");
let listen_address: Multiaddr = format!("/ip4/127.0.0.1/tcp/{}", port)
.parse()
.expect("failed to parse Alice's address");
let (alice_bitcoin_wallet, alice_monero_wallet) = init_test_wallets(
2021-01-18 05:24:13 -05:00
"alice",
&containers.bitcoind,
&monero,
alice_starting_balances.clone(),
)
.await;
2021-01-20 05:42:35 -05:00
let alice_params = AliceParams {
seed: Seed::random().unwrap(),
execution_params,
2021-01-20 05:42:35 -05:00
swap_id: Uuid::new_v4(),
bitcoin_wallet: alice_bitcoin_wallet.clone(),
monero_wallet: alice_monero_wallet.clone(),
db_path: tempdir().unwrap().path().to_path_buf(),
2021-01-18 05:24:13 -05:00
listen_address,
2021-01-20 05:42:35 -05:00
};
let bob_starting_balances = StartingBalances {
xmr: monero::Amount::ZERO,
btc: swap_amounts.btc * 10,
};
let (bob_bitcoin_wallet, bob_monero_wallet) = init_test_wallets(
2021-01-18 05:57:17 -05:00
"bob",
&containers.bitcoind,
&monero,
bob_starting_balances.clone(),
)
.await;
2021-01-20 05:42:35 -05:00
let bob_params = BobParams {
seed: Seed::random().unwrap(),
db_path: tempdir().unwrap().path().to_path_buf(),
swap_id: Uuid::new_v4(),
bitcoin_wallet: bob_bitcoin_wallet.clone(),
monero_wallet: bob_monero_wallet.clone(),
alice_address: alice_params.listen_address.clone(),
alice_peer_id: alice_params.peer_id(),
execution_params,
2021-01-20 05:42:35 -05:00
};
let test = TestContext {
swap_amounts,
2021-01-20 05:42:35 -05:00
alice_params,
alice_starting_balances,
alice_bitcoin_wallet,
alice_monero_wallet,
2021-01-20 05:42:35 -05:00
bob_params,
bob_starting_balances,
bob_bitcoin_wallet,
bob_monero_wallet,
};
testfn(test).await
}
async fn init_containers(cli: &Cli) -> (Monero, Containers<'_>) {
let bitcoind = Bitcoind::new(&cli, "0.19.1").unwrap();
let _ = bitcoind.init(5).await;
let (monero, monerods) = Monero::new(&cli, None, vec!["alice".to_string(), "bob".to_string()])
.await
.unwrap();
(monero, Containers { bitcoind, monerods })
}
async fn init_test_wallets(
name: &str,
2020-12-09 22:59:09 -05:00
bitcoind: &Bitcoind<'_>,
monero: &Monero,
starting_balances: StartingBalances,
) -> (Arc<bitcoin::Wallet>, Arc<monero::Wallet>) {
monero
.init(vec![(name, starting_balances.xmr.as_piconero())])
.await
.unwrap();
2020-12-09 22:59:09 -05:00
2021-01-04 04:29:11 -05:00
let xmr_wallet = Arc::new(swap::monero::Wallet {
inner: monero.wallet(name).unwrap().client(),
network: monero::Network::default(),
2021-01-04 04:29:11 -05:00
});
2020-12-09 22:59:09 -05:00
let btc_wallet = Arc::new(
swap::bitcoin::Wallet::new(name, bitcoind.node_url.clone(), bitcoin::Network::Regtest)
.await
.unwrap(),
2020-12-09 22:59:09 -05:00
);
if starting_balances.btc != bitcoin::Amount::ZERO {
bitcoind
.mint(
btc_wallet.inner.new_address().await.unwrap(),
starting_balances.btc,
)
.await
.unwrap();
}
2020-12-09 22:59:09 -05:00
(btc_wallet, xmr_wallet)
2020-12-09 22:59:09 -05:00
}
// This is just to keep the containers alive
#[allow(dead_code)]
struct Containers<'a> {
bitcoind: Bitcoind<'a>,
monerods: Vec<Container<'a, Cli, image::Monero>>,
2020-12-09 22:59:09 -05:00
}
/// Utility function to initialize logging in the test environment.
/// Note that you have to keep the `_guard` in scope after calling in test:
///
/// ```rust
/// let _guard = init_tracing();
/// ```
fn init_tracing() -> DefaultGuard {
2020-12-09 22:59:09 -05:00
// converts all log records into tracing events
// Note: Make sure to initialize without unwrapping, otherwise this causes
// trouble when running multiple tests.
let _ = LogTracer::init();
let global_filter = tracing::Level::WARN;
let swap_filter = tracing::Level::DEBUG;
let xmr_btc_filter = tracing::Level::DEBUG;
let monero_harness_filter = tracing::Level::INFO;
let bitcoin_harness_filter = tracing::Level::INFO;
use tracing_subscriber::util::SubscriberInitExt as _;
tracing_subscriber::fmt()
.with_env_filter(format!(
"{},swap={},xmr_btc={},monero_harness={},bitcoin_harness={}",
2020-12-09 22:59:09 -05:00
global_filter,
swap_filter,
xmr_btc_filter,
monero_harness_filter,
bitcoin_harness_filter,
))
.set_default()
}
pub mod alice_run_until {
use swap::protocol::alice::AliceState;
pub fn is_xmr_locked(state: &AliceState) -> bool {
matches!(state, AliceState::XmrLocked { .. })
}
pub fn is_encsig_learned(state: &AliceState) -> bool {
matches!(state, AliceState::EncSigLearned { .. })
}
}
pub mod bob_run_until {
use swap::protocol::bob::BobState;
pub fn is_btc_locked(state: &BobState) -> bool {
matches!(state, BobState::BtcLocked(..))
}
pub fn is_lock_proof_received(state: &BobState) -> bool {
matches!(state, BobState::XmrLockProofReceived { .. })
}
pub fn is_xmr_locked(state: &BobState) -> bool {
matches!(state, BobState::XmrLocked(..))
}
pub fn is_encsig_sent(state: &BobState) -> bool {
matches!(state, BobState::EncSigSent(..))
}
}
pub struct SlowCancelConfig;
impl GetExecutionParams for SlowCancelConfig {
fn get_execution_params() -> ExecutionParams {
ExecutionParams {
bitcoin_cancel_timelock: Timelock::new(180),
2021-01-29 01:27:50 -05:00
..execution_params::Regtest::get_execution_params()
}
}
}
pub struct FastCancelConfig;
impl GetExecutionParams for FastCancelConfig {
fn get_execution_params() -> ExecutionParams {
ExecutionParams {
bitcoin_cancel_timelock: Timelock::new(1),
2021-01-29 01:27:50 -05:00
..execution_params::Regtest::get_execution_params()
}
}
}
pub struct FastPunishConfig;
impl GetExecutionParams for FastPunishConfig {
fn get_execution_params() -> ExecutionParams {
ExecutionParams {
bitcoin_cancel_timelock: Timelock::new(1),
bitcoin_punish_timelock: Timelock::new(1),
2021-01-29 01:27:50 -05:00
..execution_params::Regtest::get_execution_params()
}
}
}