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

WIP: Tried to final state outliving the actor

Browse Source
This commit is contained in:
rishflab 2021-01-14 14:40:49 +11:00
parent 0fe1f7e173
commit 9e6b56564d
6 changed files with 120 additions and 124 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
swap/src/main.rs
View File

@ -30,7 +30,7 @@ use swap::{
alice,
alice::{swap::AliceActor, AliceState},
bob,
bob::BobState,
bob::{swap::BobActor, BobState},
},
seed::Seed,
trace::init_tracing,
@ -332,18 +332,12 @@ async fn bob_swap(
let bob_behaviour = bob::Behaviour::new(network::Seed::new(seed));
let bob_transport = build(bob_behaviour.identity())?;
let (event_loop, handle) =
let (event_loop, event_loop_handle) =
bob::event_loop::EventLoop::new(bob_transport, bob_behaviour, alice_peer_id, alice_addr)?;
let swap = bob::swap::swap(
state,
handle,
db,
bitcoin_wallet.clone(),
monero_wallet.clone(),
OsRng,
swap_id,
);
let mut bob_actor = BobActor::new(event_loop_handle, bitcoin_wallet, monero_wallet, db);
let swap = bob_actor.swap(state, swap_id);
tokio::spawn(event_loop.run());
swap.await

1
swap/src/protocol/alice/swap.rs
View File

@ -59,6 +59,7 @@ impl AliceActor {
}
}
// TODO: Make a swap abstraction that contains the state and swap id
pub async fn swap(self, start_state: AliceState) -> Result<AliceState> {
self.run_until(start_state, is_complete).await
}

138
swap/src/protocol/bob/swap.rs
View File

@ -1,6 +1,6 @@
use anyhow::{bail, Result};
use async_recursion::async_recursion;
use rand::{CryptoRng, RngCore};
use rand::{rngs::OsRng, CryptoRng, RngCore};
use std::sync::Arc;
use tokio::select;
use tracing::info;
@ -8,122 +8,103 @@ use uuid::Uuid;
use crate::{
bitcoin,
config::Config,
database::{Database, Swap},
monero,
protocol::bob::{self, event_loop::EventLoopHandle, state::*},
ExpiredTimelocks, SwapAmounts,
};
pub struct BobActor<R>
where
R: RngCore + CryptoRng + Send,
{
pub struct BobActor {
event_loop_handle: EventLoopHandle,
bitcoin_wallet: Arc<bitcoin::Wallet>,
monero_wallet: Arc<monero::Wallet>,
db: Database,
config: Config,
swap_id: Uuid,
rng: R,
}
impl<R> BobActor<R>
where
R: RngCore + CryptoRng + Send,
{
impl BobActor {
pub fn new(
event_loop_handle: EventLoopHandle,
bitcoin_wallet: Arc<bitcoin::Wallet>,
monero_wallet: Arc<monero::Wallet>,
db: Database,
config: Config,
swap_id: Uuid,
rng: R,
) -> Self {
Self {
event_loop_handle,
bitcoin_wallet,
monero_wallet,
db,
config,
swap_id,
rng,
}
}
pub async fn swap(self, start_state: BobState) -> Result<BobState> {
self.run_until(start_state, is_complete).await
// TODO: Make a swap abstraction that contains the state and swap id
pub async fn swap(&mut self, start_state: BobState, swap_id: Uuid) -> Result<BobState> {
self.run_until(start_state, is_complete, swap_id).await
}
// State machine driver for swap execution
#[allow(clippy::too_many_arguments)]
#[async_recursion]
pub async fn run_until(
mut self,
&mut self,
state: BobState,
is_target_state: fn(&BobState) -> bool,
swap_id: Uuid,
) -> Result<BobState> {
let BobActor {
mut event_loop_handle,
bitcoin_wallet,
monero_wallet,
db,
config,
swap_id,
mut rng,
} = self;
info!("Current state: {}", state);
if is_target_state(&state) {
Ok(state)
} else {
match state {
BobState::Started { state0, amounts } => {
event_loop_handle.dial().await?;
self.event_loop_handle.dial().await?;
let state2 = negotiate(
state0,
amounts,
&mut event_loop_handle,
&mut rng,
bitcoin_wallet.clone(),
&mut self.event_loop_handle,
&mut OsRng,
self.bitcoin_wallet.clone(),
)
.await?;
let state = BobState::Negotiated(state2);
let db_state = state.clone().into();
db.insert_latest_state(swap_id, Swap::Bob(db_state)).await?;
self.run_until(state, is_target_state).await
self.db
.insert_latest_state(swap_id, Swap::Bob(db_state))
.await?;
self.run_until(state, is_target_state, swap_id).await
}
BobState::Negotiated(state2) => {
// Do not lock Bitcoin if not connected to Alice.
event_loop_handle.dial().await?;
self.event_loop_handle.dial().await?;
// Alice and Bob have exchanged info
let state3 = state2.lock_btc(bitcoin_wallet.as_ref()).await?;
let state3 = state2.lock_btc(self.bitcoin_wallet.as_ref()).await?;
let state = BobState::BtcLocked(state3);
let db_state = state.clone().into();
db.insert_latest_state(swap_id, Swap::Bob(db_state)).await?;
self.run_until(state, is_target_state).await
self.db
.insert_latest_state(swap_id, Swap::Bob(db_state))
.await?;
self.run_until(state, is_target_state, swap_id).await
}
// Bob has locked Btc
// Watch for Alice to Lock Xmr or for cancel timelock to elapse
BobState::BtcLocked(state3) => {
let state = if let ExpiredTimelocks::None =
state3.current_epoch(bitcoin_wallet.as_ref()).await?
state3.current_epoch(self.bitcoin_wallet.as_ref()).await?
{
event_loop_handle.dial().await?;
self.event_loop_handle.dial().await?;
let msg2_watcher = event_loop_handle.recv_message2();
let msg2_watcher = self.event_loop_handle.recv_message2();
let cancel_timelock_expires =
state3.wait_for_cancel_timelock_to_expire(bitcoin_wallet.as_ref());
state3.wait_for_cancel_timelock_to_expire(self.bitcoin_wallet.as_ref());
select! {
msg2 = msg2_watcher => {
let xmr_lock_watcher = state3.clone()
.watch_for_lock_xmr(monero_wallet.as_ref(), msg2?);
let cancel_timelock_expires = state3.wait_for_cancel_timelock_to_expire(bitcoin_wallet.as_ref());
.watch_for_lock_xmr(self.monero_wallet.as_ref(), msg2?);
let cancel_timelock_expires = state3.wait_for_cancel_timelock_to_expire(self.bitcoin_wallet.as_ref());
select! {
state4 = xmr_lock_watcher => {
@ -146,14 +127,16 @@ where
BobState::CancelTimelockExpired(state4)
};
let db_state = state.clone().into();
db.insert_latest_state(swap_id, Swap::Bob(db_state)).await?;
self.run_until(state, is_target_state).await
self.db
.insert_latest_state(swap_id, Swap::Bob(db_state))
.await?;
self.run_until(state, is_target_state, swap_id).await
}
BobState::XmrLocked(state) => {
let state = if let ExpiredTimelocks::None =
state.expired_timelock(bitcoin_wallet.as_ref()).await?
state.expired_timelock(self.bitcoin_wallet.as_ref()).await?
{
event_loop_handle.dial().await?;
self.event_loop_handle.dial().await?;
// Alice has locked Xmr
// Bob sends Alice his key
let tx_redeem_encsig = state.tx_redeem_encsig();
@ -161,8 +144,8 @@ where
let state4_clone = state.clone();
// TODO(Franck): Refund if message cannot be sent.
let enc_sig_sent_watcher =
event_loop_handle.send_message3(tx_redeem_encsig);
let bitcoin_wallet = bitcoin_wallet.clone();
self.event_loop_handle.send_message3(tx_redeem_encsig);
let bitcoin_wallet = self.bitcoin_wallet.clone();
let cancel_timelock_expires = state4_clone
.wait_for_cancel_timelock_to_expire(bitcoin_wallet.as_ref());
@ -178,18 +161,20 @@ where
BobState::CancelTimelockExpired(state)
};
let db_state = state.clone().into();
db.insert_latest_state(swap_id, Swap::Bob(db_state)).await?;
self.run_until(state, is_target_state).await
self.db
.insert_latest_state(swap_id, Swap::Bob(db_state))
.await?;
self.run_until(state, is_target_state, swap_id).await
}
BobState::EncSigSent(state) => {
let state = if let ExpiredTimelocks::None =
state.expired_timelock(bitcoin_wallet.as_ref()).await?
state.expired_timelock(self.bitcoin_wallet.as_ref()).await?
{
let state_clone = state.clone();
let redeem_watcher =
state_clone.watch_for_redeem_btc(bitcoin_wallet.as_ref());
let cancel_timelock_expires =
state_clone.wait_for_cancel_timelock_to_expire(bitcoin_wallet.as_ref());
state_clone.watch_for_redeem_btc(self.bitcoin_wallet.as_ref());
let cancel_timelock_expires = state_clone
.wait_for_cancel_timelock_to_expire(self.bitcoin_wallet.as_ref());
select! {
state5 = redeem_watcher => {
@ -204,49 +189,58 @@ where
};
let db_state = state.clone().into();
db.insert_latest_state(swap_id, Swap::Bob(db_state)).await?;
self.run_until(state, is_target_state).await
self.db
.insert_latest_state(swap_id, Swap::Bob(db_state))
.await?;
self.run_until(state, is_target_state, swap_id).await
}
BobState::BtcRedeemed(state) => {
// Bob redeems XMR using revealed s_a
state.claim_xmr(monero_wallet.as_ref()).await?;
state.claim_xmr(self.monero_wallet.as_ref()).await?;
let state = BobState::XmrRedeemed;
let db_state = state.clone().into();
db.insert_latest_state(swap_id, Swap::Bob(db_state)).await?;
self.run_until(state, is_target_state).await
self.db
.insert_latest_state(swap_id, Swap::Bob(db_state))
.await?;
self.run_until(state, is_target_state, swap_id).await
}
BobState::CancelTimelockExpired(state4) => {
if state4
.check_for_tx_cancel(bitcoin_wallet.as_ref())
.check_for_tx_cancel(self.bitcoin_wallet.as_ref())
.await
.is_err()
{
state4.submit_tx_cancel(bitcoin_wallet.as_ref()).await?;
state4
.submit_tx_cancel(self.bitcoin_wallet.as_ref())
.await?;
}
let state = BobState::BtcCancelled(state4);
db.insert_latest_state(swap_id, Swap::Bob(state.clone().into()))
self.db
.insert_latest_state(swap_id, Swap::Bob(state.clone().into()))
.await?;
self.run_until(state, is_target_state).await
self.run_until(state, is_target_state, swap_id).await
}
BobState::BtcCancelled(state) => {
// Bob has cancelled the swap
let state = match state.expired_timelock(bitcoin_wallet.as_ref()).await? {
let state = match state.expired_timelock(self.bitcoin_wallet.as_ref()).await? {
ExpiredTimelocks::None => {
bail!("Internal error: canceled state reached before cancel timelock was expired");
}
ExpiredTimelocks::Cancel => {
state.refund_btc(bitcoin_wallet.as_ref()).await?;
state.refund_btc(self.bitcoin_wallet.as_ref()).await?;
BobState::BtcRefunded(state)
}
ExpiredTimelocks::Punish => BobState::BtcPunished,
};
let db_state = state.clone().into();
db.insert_latest_state(swap_id, Swap::Bob(db_state)).await?;
self.run_until(state, is_target_state).await
self.db
.insert_latest_state(swap_id, Swap::Bob(db_state))
.await?;
self.run_until(state, is_target_state, swap_id).await
}
BobState::BtcRefunded(state4) => Ok(BobState::BtcRefunded(state4)),
BobState::BtcPunished => Ok(BobState::BtcPunished),

15
swap/tests/happy_path.rs
View File

@ -14,3 +14,18 @@ async fn happy_path() {
})
.await;
}
// #[tokio::test]
// async fn happy_path() {
// testutils::test(|alice_node, bob_node| async move {
// let alice_start_state = unimplemented!();
// let bob_start_state = unimplemented!();
//
// let (alice_end_state, bob_end_state) =
// join!(alice_node.swap(alice_start_state), bob_node.swap(bo));
//
// alice_node.assert_btc_redeemed(alice_end_state);
// bob_node.assert_btc_redeemed(bob_end_state);
// })
// .await;
// }

19
swap/tests/testutils/alice.rs
View File

@ -23,7 +23,6 @@ use tokio::select;
use uuid::Uuid;
pub struct Alice {
state: AliceState,
actor: AliceActor,
event_loop: EventLoop,
}
@ -39,7 +38,7 @@ impl Alice {
listen: Multiaddr,
config: Config,
seed: Seed,
) -> Alice {
) -> (Alice, AliceState) {
let (alice_btc_wallet, alice_xmr_wallet) = init_wallets(
"alice",
bitcoind,
@ -66,23 +65,25 @@ impl Alice {
Uuid::new_v4(),
);
Alice {
state: alice_start_state,
actor: alice_actor,
event_loop,
}
(
Alice {
actor: alice_actor,
event_loop,
},
alice_start_state,
)
}
pub fn peer_id(&self) -> PeerId {
self.event_loop.peer_id()
}
pub async fn swap(mut self) -> Result<()> {
pub async fn swap(&mut self) -> Result<()> {
let final_state = select! {
res = self.actor.swap(self.state) => res.unwrap(),
_ = self.event_loop.run() => panic!("The event loop should never finish")
};
self.state = final_state;
self.final_state = Some(final_state);
Ok(())
}

55
swap/tests/testutils/bob.rs
View File

@ -1,31 +1,31 @@
use crate::testutils::init_wallets;
use anyhow::Result;
use bitcoin_harness::Bitcoind;
use futures::future::{select, Select};
use libp2p::{core::Multiaddr, PeerId};
use monero_harness::Monero;
use rand::rngs::OsRng;
use std::{pin::Pin, sync::Arc};
use std::sync::Arc;
use swap::{
bitcoin,
config::Config,
database::Database,
monero, network,
network::transport::build,
protocol::{bob, bob::BobState},
protocol::{
bob,
bob::{swap::BobActor, BobState, EventLoop},
},
seed::Seed,
SwapAmounts,
};
use tempfile::tempdir;
use tokio::select;
use uuid::Uuid;
pub struct Bob {
state: BobState,
event_loop: bob::event_loop::EventLoop,
event_loop_handle: bob::event_loop::EventLoopHandle,
bitcoin_wallet: Arc<swap::bitcoin::Wallet>,
monero_wallet: Arc<swap::monero::Wallet>,
db: Database,
actor: BobActor,
event_loop: EventLoop,
final_state: Option<BobState>,
}
impl Bob {
@ -50,38 +50,29 @@ impl Bob {
)
.await;
let bob_state =
init_bob_state(btc_to_swap, xmr_to_swap, bob_btc_wallet.clone(), config).await;
let (event_loop, event_loop_handle) = init_bob_event_loop(alice_peer_id, alice_multiaddr);
let bob_db_dir = tempdir().unwrap();
let bob_db = Database::open(bob_db_dir.path()).unwrap();
let bob_actor = BobActor::new(event_loop_handle, bob_btc_wallet, bob_xmr_wallet, bob_db);
let bob_state =
init_bob_state(btc_to_swap, xmr_to_swap, bob_btc_wallet.clone(), config).await;
Bob {
state: bob_state,
final_state: Some(bob_state),
actor: bob_actor,
event_loop,
event_loop_handle,
bitcoin_wallet: bob_btc_wallet,
monero_wallet: bob_xmr_wallet,
db: bob_db,
}
}
pub async fn swap(
&self,
) -> Select<Pin<Box<Result<BobState>>>, Pin<Box<Result<bob::EventLoop>>>> {
let bob_swap_fut = bob::swap::swap(
self.state.clone(),
self.event_loop_handle,
self.db,
self.bitcoin_wallet,
self.monero_wallet,
OsRng,
Uuid::new_v4(),
);
let bob_fut = select(Box::pin(bob_swap_fut), Box::pin(self.event_loop.run()));
bob_fut
pub async fn swap(&mut self) -> Result<()> {
let final_state = select! {
res = self.actor.swap(bob_state, Uuid::new_v4()) => res.unwrap(),
_ = self.event_loop.run() => panic!("The event loop should never finish")
};
self.final_state = Some(final_state);
Ok(())
}
pub async fn assert_btc_redeemed(&self) {}