Verify amounts with user

swap/src/alice.rs

@@ -6,8 +6,8 @@ use libp2p::{
     request_response::ResponseChannel,
     NetworkBehaviour, PeerId,
 };
-use std::{thread, time::Duration};
+use std::time::Duration;
-use tracing::{debug, warn};
+use tracing::debug;
 
 mod messenger;
 
@@ -27,24 +27,22 @@ pub type Swarm = libp2p::Swarm<Alice>;
 pub async fn swap(listen: Multiaddr) -> Result<()> {
     let mut swarm = new_swarm(listen)?;
 
-    match swarm.next().await {
+    loop {
-        BehaviourOutEvent::Request(messenger::BehaviourOutEvent::Btc { btc, channel }) => {
+        match swarm.next().await {
-            debug!("Got request from Bob");
+            BehaviourOutEvent::Request(messenger::BehaviourOutEvent::Btc { btc, channel }) => {
-            let params = SwapParams {
+                debug!("Got request from Bob to swap {}", btc);
-                btc,
+                let params = SwapParams {
-                // TODO: Do a real calculation.
+                    btc,
-                xmr: monero::Amount::from_piconero(10),
+                    // TODO: Do a real calculation.
-            };
+                    xmr: monero::Amount::from_piconero(10),
+                };
 
-            let msg = AliceToBob::Amounts(params);
+                let msg = AliceToBob::Amounts(params);
-            swarm.send(channel, msg);
+                swarm.send(channel, msg);
+            }
+            other => panic!("unexpected event: {:?}", other),
         }
-        other => panic!("unexpected event: {:?}", other),
     }
-
-    warn!("parking thread ...");
-    thread::park();
-    Ok(())
 }
 
 fn new_swarm(listen: Multiaddr) -> Result<Swarm> {

swap/src/bob/messenger.rs

@@ -12,7 +12,7 @@ use std::{
     task::{Context, Poll},
     time::Duration,
 };
-use tracing::{debug, error};
+use tracing::error;
 
 use crate::{
     bitcoin,
@@ -55,10 +55,8 @@ impl Messenger {
         alice: PeerId,
         btc: bitcoin::Amount,
     ) -> Result<RequestId> {
-        debug!("Sending request ...");
         let msg = BobToAlice::AmountsFromBtc(btc);
         let id = self.rr.send_request(&alice, msg);
-        debug!("Sent.");
 
         Ok(id)
     }

swap/src/lib.rs

@@ -1,4 +1,5 @@
 use serde::{Deserialize, Serialize};
+use std::fmt::{self, Display};
 
 pub mod alice;
 pub mod bob;
@@ -9,13 +10,13 @@ pub const ONE_BTC: u64 = 100_000_000;
 pub type Never = std::convert::Infallible;
 
 /// Commands sent from Bob to the main task.
-#[derive(Debug)]
+#[derive(Clone, Copy, Debug)]
 pub enum Cmd {
     VerifyAmounts(SwapParams),
 }
 
 /// Responses send from the main task back to Bob.
-#[derive(Debug, PartialEq)]
+#[derive(Clone, Copy, Debug, PartialEq)]
 pub enum Rsp {
     Verified,
     Abort,
@@ -30,6 +31,12 @@ pub struct SwapParams {
     pub xmr: monero::Amount,
 }
 
+impl Display for SwapParams {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{} for {}", self.btc, self.xmr)
+    }
+}
+
 // FIXME: Amount modules are a quick hack so we can derive serde.
 
 pub mod monero {

swap/src/main.rs

@@ -16,9 +16,9 @@ use anyhow::{bail, Result};
 use futures::{channel::mpsc, StreamExt};
 use libp2p::Multiaddr;
 use log::LevelFilter;
+use std::{io, io::Write, process};
 use structopt::StructOpt;
 use tracing::info;
-
 mod cli;
 mod trace;
 
@@ -77,8 +77,10 @@ async fn swap_as_bob(sats: u64, addr: Multiaddr) -> Result<()> {
         match read {
             Some(cmd) => match cmd {
                 Cmd::VerifyAmounts(p) => {
-                    if verified(p) {
+                    let rsp = verify(p);
-                        rsp_tx.try_send(Rsp::Verified)?;
+                    rsp_tx.try_send(rsp)?;
+                    if rsp == Rsp::Abort {
+                        process::exit(0);
                     }
                 }
             },
@@ -90,7 +92,29 @@ async fn swap_as_bob(sats: u64, addr: Multiaddr) -> Result<()> {
     }
 }
 
-fn verified(_p: SwapParams) -> bool {
+fn verify(p: SwapParams) -> Rsp {
-    // TODO: Read input from the shell.
+    let mut s = String::new();
-    true
+    println!("Got rate from Alice for XMR/BTC swap\n");
+    println!("{}", p);
+    print!("Would you like to continue with this swap [y/N]: ");
+    let _ = io::stdout().flush();
+    io::stdin()
+        .read_line(&mut s)
+        .expect("Did not enter a correct string");
+    if let Some('\n') = s.chars().next_back() {
+        s.pop();
+    }
+    if let Some('\r') = s.chars().next_back() {
+        s.pop();
+    }
+    if !is_yes(&s) {
+        println!("No worries, try again later - Alice updates her rate regularly");
+        return Rsp::Abort;
+    }
+
+    Rsp::Verified
+}
+
+fn is_yes(s: &str) -> bool {
+    matches!(s, "y" | "Y" | "yes" | "YES" | "Yes")
 }