From 124d6f1ebb7f5947556f1fe8ea039f1686789c44 Mon Sep 17 00:00:00 2001 From: Franck Royer Date: Fri, 22 Jan 2021 11:13:28 +1100 Subject: [PATCH] Introduced Message 4 sent by Alice to replace message 2 response --- swap/src/network/request_response.rs | 17 ++++- swap/src/protocol/alice.rs | 2 + swap/src/protocol/alice/message4.rs | 101 +++++++++++++++++++++++++++ swap/src/protocol/alice/message5.rs | 11 +-- swap/src/protocol/bob/message5.rs | 7 +- 5 files changed, 127 insertions(+), 11 deletions(-) create mode 100644 swap/src/protocol/alice/message4.rs diff --git a/swap/src/network/request_response.rs b/swap/src/network/request_response.rs index 68e9d803..7eeaa08e 100644 --- a/swap/src/network/request_response.rs +++ b/swap/src/network/request_response.rs @@ -1,4 +1,4 @@ -use crate::protocol::{alice, bob, bob::Message5}; +use crate::protocol::{alice, alice::Message4, bob, bob::Message5}; use async_trait::async_trait; use futures::prelude::*; use libp2p::{ @@ -42,12 +42,14 @@ pub enum AliceToBob { /// All responses are empty #[derive(Clone, Debug, Serialize, Deserialize)] pub enum Request { - Message5(Message5), + Message4(Box), + Message5(Box), } -#[derive(Clone, Debug, Serialize, Deserialize)] +#[derive(Clone, Copy, Debug, Serialize, Deserialize)] /// Response are only used for acknowledgement purposes. pub enum Response { + Message4, Message5, } @@ -63,6 +65,9 @@ pub struct Message1Protocol; #[derive(Debug, Clone, Copy, Default)] pub struct Message2Protocol; +#[derive(Debug, Clone, Copy, Default)] +pub struct Message4Protocol; + #[derive(Debug, Clone, Copy, Default)] pub struct Message5Protocol; @@ -90,6 +95,12 @@ impl ProtocolName for Message2Protocol { } } +impl ProtocolName for Message4Protocol { + fn protocol_name(&self) -> &[u8] { + b"/xmr/btc/message4/1.0.0" + } +} + impl ProtocolName for Message5Protocol { fn protocol_name(&self) -> &[u8] { b"/xmr/btc/message5/1.0.0" diff --git a/swap/src/protocol/alice.rs b/swap/src/protocol/alice.rs index a640b854..940aa92b 100644 --- a/swap/src/protocol/alice.rs +++ b/swap/src/protocol/alice.rs @@ -5,6 +5,7 @@ pub use self::{ message0::Message0, message1::Message1, message2::Message2, + message4::Message4, state::*, swap::{run, run_until}, swap_response::*, @@ -37,6 +38,7 @@ pub mod event_loop; mod message0; mod message1; mod message2; +mod message4; mod message5; pub mod state; mod steps; diff --git a/swap/src/protocol/alice/message4.rs b/swap/src/protocol/alice/message4.rs new file mode 100644 index 00000000..040a3f65 --- /dev/null +++ b/swap/src/protocol/alice/message4.rs @@ -0,0 +1,101 @@ +use crate::{ + monero, + network::request_response::{Message4Protocol, OneShotCodec, Request, Response, TIMEOUT}, +}; +use libp2p::{ + request_response::{ + handler::RequestProtocol, ProtocolSupport, RequestResponse, RequestResponseConfig, + RequestResponseEvent, RequestResponseMessage, + }, + swarm::{NetworkBehaviourAction, NetworkBehaviourEventProcess, PollParameters}, + NetworkBehaviour, PeerId, +}; +use serde::{Deserialize, Serialize}; +use std::{ + collections::VecDeque, + task::{Context, Poll}, + time::Duration, +}; +use tracing::error; + +#[derive(Clone, Debug, Serialize, Deserialize)] +pub struct Message4 { + pub tx_lock_proof: monero::TransferProof, +} + +#[derive(Debug, Copy, Clone)] +pub enum OutEvent { + Msg, +} + +/// A `NetworkBehaviour` that represents sending message 4 to Bob. +#[derive(NetworkBehaviour)] +#[behaviour(out_event = "OutEvent", poll_method = "poll")] +#[allow(missing_debug_implementations)] +pub struct Behaviour { + rr: RequestResponse>, + #[behaviour(ignore)] + events: VecDeque, +} + +impl Behaviour { + pub fn send(&mut self, bob: PeerId, msg: Message4) { + let msg = Request::Message4(Box::new(msg)); + let _id = self.rr.send_request(&bob, msg); + } + + fn poll( + &mut self, + _: &mut Context<'_>, + _: &mut impl PollParameters, + ) -> Poll>, OutEvent>> + { + if let Some(event) = self.events.pop_front() { + return Poll::Ready(NetworkBehaviourAction::GenerateEvent(event)); + } + + Poll::Pending + } +} + +impl Default for Behaviour { + fn default() -> Self { + let timeout = Duration::from_secs(TIMEOUT); + let mut config = RequestResponseConfig::default(); + config.set_request_timeout(timeout); + + Self { + rr: RequestResponse::new( + OneShotCodec::default(), + vec![(Message4Protocol, ProtocolSupport::Full)], + config, + ), + events: Default::default(), + } + } +} + +impl NetworkBehaviourEventProcess> for Behaviour { + fn inject_event(&mut self, event: RequestResponseEvent) { + match event { + RequestResponseEvent::Message { + message: RequestResponseMessage::Request { .. }, + .. + } => panic!("Alice should never get a message 4 request from Bob"), + RequestResponseEvent::Message { + message: RequestResponseMessage::Response { response, .. }, + .. + } => { + if let Response::Message4 = response { + self.events.push_back(OutEvent::Msg); + } + } + RequestResponseEvent::InboundFailure { error, .. } => { + error!("Inbound failure: {:?}", error); + } + RequestResponseEvent::OutboundFailure { error, .. } => { + error!("Outbound failure: {:?}", error); + } + } + } +} diff --git a/swap/src/protocol/alice/message5.rs b/swap/src/protocol/alice/message5.rs index 00cc7d8f..f285de7c 100644 --- a/swap/src/protocol/alice/message5.rs +++ b/swap/src/protocol/alice/message5.rs @@ -74,11 +74,12 @@ impl NetworkBehaviourEventProcess> for B }, .. } => { - let Request::Message5(msg) = request; - debug!("Received message 5"); - self.events.push_back(OutEvent::Msg(msg)); - // Send back empty response so that the request/response protocol completes. - let _ = self.rr.send_response(channel, Response::Message5); + if let Request::Message5(msg) = request { + debug!("Received message 5"); + self.events.push_back(OutEvent::Msg(*msg)); + // Send back empty response so that the request/response protocol completes. + let _ = self.rr.send_response(channel, Response::Message5); + } } RequestResponseEvent::Message { message: RequestResponseMessage::Response { .. }, diff --git a/swap/src/protocol/bob/message5.rs b/swap/src/protocol/bob/message5.rs index ee2104da..385fcfae 100644 --- a/swap/src/protocol/bob/message5.rs +++ b/swap/src/protocol/bob/message5.rs @@ -40,7 +40,7 @@ pub struct Behaviour { impl Behaviour { pub fn send(&mut self, alice: PeerId, msg: Message5) { - let msg = Request::Message5(msg); + let msg = Request::Message5(Box::new(msg)); let _id = self.rr.send_request(&alice, msg); } @@ -86,8 +86,9 @@ impl NetworkBehaviourEventProcess> for B message: RequestResponseMessage::Response { response, .. }, .. } => { - let Response::Message5 = response; - self.events.push_back(OutEvent::Msg); + if let Response::Message5 = response { + self.events.push_back(OutEvent::Msg); + } } RequestResponseEvent::InboundFailure { error, .. } => { error!("Inbound failure: {:?}", error);