Only pass btc amount to CLI

The CLI requests a quote to nectar to know how much xmr it can get.
Also align terminology with the sequence diagram.
This commit is contained in:
Franck Royer 2021-02-15 13:01:38 +11:00
parent 144da75270
commit 2dbd43e2c0
No known key found for this signature in database
GPG Key ID: A82ED75A8DFC50A4
8 changed files with 77 additions and 105 deletions

View File

@ -35,7 +35,6 @@ use swap::{
protocol::{
bob,
bob::{cancel::CancelError, Builder},
SwapAmounts,
},
seed::Seed,
trace::init_tracing,
@ -89,21 +88,15 @@ async fn main() -> Result<()> {
alice_peer_id,
alice_addr,
send_bitcoin,
receive_monero,
} => {
let swap_amounts = SwapAmounts {
btc: send_bitcoin,
xmr: receive_monero,
};
let (bitcoin_wallet, monero_wallet) =
init_wallets(config, bitcoin_network, monero_network).await?;
let swap_id = Uuid::new_v4();
info!(
"Swap sending {} and receiving {} started with ID {}",
send_bitcoin, receive_monero, swap_id
"Swap buy XMR with {} started with ID {}",
send_bitcoin, swap_id
);
let bob_factory = Builder::new(
@ -116,7 +109,7 @@ async fn main() -> Result<()> {
alice_peer_id,
execution_params,
);
let (swap, event_loop) = bob_factory.with_init_params(swap_amounts).build().await?;
let (swap, event_loop) = bob_factory.with_init_params(send_bitcoin).build().await?;
tokio::spawn(async move { event_loop.run().await });
bob::run(swap).await?;

View File

@ -1,4 +1,4 @@
use crate::{bitcoin, monero};
use crate::bitcoin;
use libp2p::{core::Multiaddr, PeerId};
use std::path::PathBuf;
use uuid::Uuid;
@ -28,9 +28,6 @@ pub enum Command {
#[structopt(long = "send-btc", help = "Bitcoin amount as floating point nr without denomination (e.g. 1.25)", parse(try_from_str = parse_btc))]
send_bitcoin: bitcoin::Amount,
#[structopt(long = "receive-xmr", help = "Monero amount as floating point nr without denomination (e.g. 125.1)", parse(try_from_str = parse_xmr))]
receive_monero: monero::Amount,
},
History,
Resume(Resume),
@ -92,8 +89,3 @@ fn parse_btc(str: &str) -> anyhow::Result<bitcoin::Amount> {
let amount = bitcoin::Amount::from_str_in(str, ::bitcoin::Denomination::Bitcoin)?;
Ok(amount)
}
fn parse_xmr(str: &str) -> anyhow::Result<monero::Amount> {
let amount = monero::Amount::parse_monero(str)?;
Ok(amount)
}

View File

@ -1,6 +1,6 @@
use crate::{
monero::TransferProof,
protocol::{bob, bob::BobState, SwapAmounts},
protocol::{bob, bob::BobState},
};
use ::bitcoin::hashes::core::fmt::Display;
use monero_harness::rpc::wallet::BlockHeight;
@ -9,10 +9,10 @@ use serde::{Deserialize, Serialize};
#[derive(Clone, Debug, Deserialize, Serialize, PartialEq)]
pub enum Bob {
Started {
state0: bob::State0,
amounts: SwapAmounts,
#[serde(with = "::bitcoin::util::amount::serde::as_sat")]
btc_amount: bitcoin::Amount,
},
Negotiated {
ExecutionSetupDone {
state2: bob::State2,
},
BtcLocked {
@ -46,8 +46,8 @@ pub enum BobEndState {
impl From<BobState> for Bob {
fn from(bob_state: BobState) -> Self {
match bob_state {
BobState::Started { state0, amounts } => Bob::Started { state0, amounts },
BobState::Negotiated(state2) => Bob::Negotiated { state2 },
BobState::Started { btc_amount } => Bob::Started { btc_amount },
BobState::ExecutionSetupDone(state2) => Bob::ExecutionSetupDone { state2 },
BobState::BtcLocked(state3) => Bob::BtcLocked { state3 },
BobState::XmrLockProofReceived {
state,
@ -78,8 +78,8 @@ impl From<BobState> for Bob {
impl From<Bob> for BobState {
fn from(db_state: Bob) -> Self {
match db_state {
Bob::Started { state0, amounts } => BobState::Started { state0, amounts },
Bob::Negotiated { state2 } => BobState::Negotiated(state2),
Bob::Started { btc_amount } => BobState::Started { btc_amount },
Bob::ExecutionSetupDone { state2 } => BobState::ExecutionSetupDone(state2),
Bob::BtcLocked { state3 } => BobState::BtcLocked(state3),
Bob::XmrLockProofReceived {
state,
@ -109,7 +109,7 @@ impl Display for Bob {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Bob::Started { .. } => write!(f, "Started"),
Bob::Negotiated { .. } => f.write_str("Negotiated"),
Bob::ExecutionSetupDone { .. } => f.write_str("Execution setup done"),
Bob::BtcLocked { .. } => f.write_str("Bitcoin locked"),
Bob::XmrLockProofReceived { .. } => {
f.write_str("XMR lock transaction transfer proof received")

View File

@ -25,7 +25,7 @@ use tracing::{debug, error, trace, warn};
use uuid::Uuid;
// TODO: Use dynamic
const RATE: u32 = 100;
pub const RATE: u32 = 100;
#[allow(missing_debug_implementations)]
pub struct MpscChannels<T> {

View File

@ -9,12 +9,11 @@ use crate::{
peer_tracker::{self, PeerTracker},
transport::build,
},
protocol::{alice, alice::TransferProof, bob, SwapAmounts},
protocol::{alice, alice::TransferProof, bob},
seed::Seed,
};
use anyhow::{bail, Error, Result};
use libp2p::{core::Multiaddr, identity::Keypair, NetworkBehaviour, PeerId};
use rand::rngs::OsRng;
use std::sync::Arc;
use tracing::{debug, info};
use uuid::Uuid;
@ -69,7 +68,7 @@ pub struct Builder {
enum InitParams {
None,
New { swap_amounts: SwapAmounts },
New { btc_amount: bitcoin::Amount },
}
impl Builder {
@ -101,19 +100,17 @@ impl Builder {
}
}
pub fn with_init_params(self, swap_amounts: SwapAmounts) -> Self {
pub fn with_init_params(self, btc_amount: bitcoin::Amount) -> Self {
Self {
init_params: InitParams::New { swap_amounts },
init_params: InitParams::New { btc_amount },
..self
}
}
pub async fn build(self) -> Result<(bob::Swap, bob::EventLoop)> {
match self.init_params {
InitParams::New { swap_amounts } => {
let initial_state = self
.make_initial_state(swap_amounts.btc, swap_amounts.xmr, self.execution_params)
.await?;
InitParams::New { btc_amount } => {
let initial_state = BobState::Started { btc_amount };
let (event_loop, event_loop_handle) = self.init_event_loop()?;
@ -175,31 +172,6 @@ impl Builder {
self.bitcoin_wallet.clone(),
)
}
async fn make_initial_state(
&self,
btc_to_swap: bitcoin::Amount,
xmr_to_swap: monero::Amount,
execution_params: ExecutionParams,
) -> Result<BobState> {
let amounts = SwapAmounts {
btc: btc_to_swap,
xmr: xmr_to_swap,
};
let refund_address = self.bitcoin_wallet.new_address().await?;
let state0 = bob::State0::new(
&mut OsRng,
btc_to_swap,
xmr_to_swap,
execution_params.bitcoin_cancel_timelock,
execution_params.bitcoin_punish_timelock,
refund_address,
execution_params.monero_finality_confirmations,
);
Ok(BobState::Started { state0, amounts })
}
}
#[derive(Debug)]

View File

@ -11,7 +11,6 @@ use crate::{
protocol::{
alice::{Message1, Message3},
bob::{EncryptedSignature, Message0, Message2, Message4},
SwapAmounts,
},
};
use anyhow::{anyhow, Result};
@ -25,10 +24,9 @@ use std::fmt;
#[derive(Debug, Clone)]
pub enum BobState {
Started {
state0: State0,
amounts: SwapAmounts,
btc_amount: bitcoin::Amount,
},
Negotiated(State2),
ExecutionSetupDone(State2),
BtcLocked(State3),
XmrLockProofReceived {
state: State3,
@ -53,8 +51,8 @@ pub enum BobState {
impl fmt::Display for BobState {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
BobState::Started { .. } => write!(f, "started"),
BobState::Negotiated(..) => write!(f, "negotiated"),
BobState::Started { .. } => write!(f, "quote has been requested"),
BobState::ExecutionSetupDone(..) => write!(f, "execution setup done"),
BobState::BtcLocked(..) => write!(f, "btc is locked"),
BobState::XmrLockProofReceived { .. } => {
write!(f, "XMR lock transaction transfer proof received")

View File

@ -4,13 +4,11 @@ use crate::{
database::{Database, Swap},
execution_params::ExecutionParams,
monero,
protocol::{
bob::{self, event_loop::EventLoopHandle, state::*, QuoteRequest},
SwapAmounts,
},
protocol::bob::{self, event_loop::EventLoopHandle, state::*, QuoteRequest},
};
use anyhow::{bail, Result};
use async_recursion::async_recursion;
use rand::rngs::OsRng;
use std::sync::Arc;
use tokio::select;
use tracing::info;
@ -67,12 +65,20 @@ async fn run_until_internal(
Ok(state)
} else {
match state {
BobState::Started { state0, amounts } => {
BobState::Started { btc_amount } => {
let bitcoin_refund_address = bitcoin_wallet.new_address().await?;
event_loop_handle.dial().await?;
let state2 = negotiate(state0, amounts, &mut event_loop_handle).await?;
let state2 = request_quote_and_setup(
btc_amount,
&mut event_loop_handle,
execution_params,
bitcoin_refund_address,
)
.await?;
let state = BobState::Negotiated(state2);
let state = BobState::ExecutionSetupDone(state2);
let db_state = state.clone().into();
db.insert_latest_state(swap_id, Swap::Bob(db_state)).await?;
run_until_internal(
@ -87,7 +93,7 @@ async fn run_until_internal(
)
.await
}
BobState::Negotiated(state2) => {
BobState::ExecutionSetupDone(state2) => {
// Do not lock Bitcoin if not connected to Alice.
event_loop_handle.dial().await?;
// Alice and Bob have exchanged info
@ -368,21 +374,27 @@ async fn run_until_internal(
}
}
pub async fn negotiate(
state0: crate::protocol::bob::state::State0,
amounts: SwapAmounts,
pub async fn request_quote_and_setup(
btc_amount: bitcoin::Amount,
event_loop_handle: &mut EventLoopHandle,
execution_params: ExecutionParams,
bitcoin_refund_address: bitcoin::Address,
) -> Result<bob::state::State2> {
tracing::trace!("Starting negotiate");
event_loop_handle
.send_quote_request(QuoteRequest {
btc_amount: amounts.btc,
})
.send_quote_request(QuoteRequest { btc_amount })
.await?;
// TODO: Use this once Bob's CLI is modified to only pass xmr amount in
// argument.
let _quote_response = event_loop_handle.recv_quote_response().await?;
let quote_response = event_loop_handle.recv_quote_response().await?;
let state0 = State0::new(
&mut OsRng,
btc_amount,
quote_response.xmr_amount,
execution_params.bitcoin_cancel_timelock,
execution_params.bitcoin_punish_timelock,
bitcoin_refund_address,
execution_params.monero_finality_confirmations,
);
let state2 = event_loop_handle.execution_setup(state0).await?;

View File

@ -12,7 +12,12 @@ use swap::{
execution_params,
execution_params::{ExecutionParams, GetExecutionParams},
monero,
protocol::{alice, alice::AliceState, bob, bob::BobState, SwapAmounts},
protocol::{
alice,
alice::{event_loop::RATE, AliceState},
bob,
bob::BobState,
},
seed::Seed,
};
use tempfile::tempdir;
@ -66,7 +71,8 @@ impl BobEventLoopJoinHandle {
pub struct AliceEventLoopJoinHandle(JoinHandle<()>);
pub struct TestContext {
swap_amounts: SwapAmounts,
btc_amount: bitcoin::Amount,
xmr_amount: monero::Amount,
alice_starting_balances: StartingBalances,
alice_bitcoin_wallet: Arc<bitcoin::Wallet>,
@ -84,7 +90,7 @@ impl TestContext {
let (swap, event_loop) = self
.bob_params
.builder()
.with_init_params(self.swap_amounts)
.with_init_params(self.btc_amount)
.build()
.await
.unwrap();
@ -116,7 +122,7 @@ impl TestContext {
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
self.alice_starting_balances.btc + self.btc_amount
- bitcoin::Amount::from_sat(bitcoin::TX_FEE)
);
@ -126,7 +132,7 @@ impl TestContext {
.get_balance()
.await
.unwrap();
assert!(xmr_balance_after_swap <= self.alice_starting_balances.xmr - self.swap_amounts.xmr);
assert!(xmr_balance_after_swap <= self.alice_starting_balances.xmr - self.xmr_amount);
}
pub async fn assert_alice_refunded(&mut self) {
@ -155,7 +161,7 @@ impl TestContext {
.get_balance()
.await
.unwrap();
assert_eq!(xmr_balance_after_swap, self.swap_amounts.xmr);
assert_eq!(xmr_balance_after_swap, self.xmr_amount);
}
pub async fn assert_alice_punished(&self, state: AliceState) {
@ -164,7 +170,7 @@ impl TestContext {
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
self.alice_starting_balances.btc + self.btc_amount
- bitcoin::Amount::from_sat(2 * bitcoin::TX_FEE)
);
@ -174,7 +180,7 @@ impl TestContext {
.get_balance()
.await
.unwrap();
assert!(xmr_balance_after_swap <= self.alice_starting_balances.xmr - self.swap_amounts.xmr);
assert!(xmr_balance_after_swap <= self.alice_starting_balances.xmr - self.xmr_amount);
}
pub async fn assert_bob_redeemed(&self, state: BobState) {
@ -193,7 +199,7 @@ impl TestContext {
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
self.bob_starting_balances.btc - self.btc_amount - lock_tx_bitcoin_fee
);
// Ensure that Bob's balance is refreshed as we use a newly created wallet
@ -206,7 +212,7 @@ impl TestContext {
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
self.bob_starting_balances.xmr + self.xmr_amount
);
}
@ -258,7 +264,7 @@ impl TestContext {
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
self.bob_starting_balances.btc - self.btc_amount - lock_tx_bitcoin_fee
);
let xmr_balance_after_swap = self.bob_monero_wallet.as_ref().get_balance().await.unwrap();
@ -280,13 +286,11 @@ where
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 btc_amount = bitcoin::Amount::from_sat(1_000_000);
let xmr_amount = monero::Amount::from_monero(btc_amount.as_btc() * RATE as f64).unwrap();
let alice_starting_balances = StartingBalances {
xmr: swap_amounts.xmr * 10,
xmr: xmr_amount * 10,
btc: bitcoin::Amount::ZERO,
};
@ -311,7 +315,7 @@ where
let bob_starting_balances = StartingBalances {
xmr: monero::Amount::ZERO,
btc: swap_amounts.btc * 10,
btc: btc_amount * 10,
};
let (bob_bitcoin_wallet, bob_monero_wallet) = init_test_wallets(
@ -350,7 +354,8 @@ where
};
let test = TestContext {
swap_amounts,
btc_amount,
xmr_amount,
alice_starting_balances,
alice_bitcoin_wallet,
alice_monero_wallet,