Git-Mirrors/xmr-btc-swap
1
0
Fork 0
mirror of https://github.com/comit-network/xmr-btc-swap.git synced 2025-04-20 16:06:00 -04:00
Code Issues Packages Projects Releases Wiki Activity

Use execution setup behaviour

Browse Source
This commit is contained in:
Franck Royer 2021-02-04 11:06:49 +11:00
parent 18c819a1ff
commit 5085361d06
No known key found for this signature in database
GPG Key ID: A82ED75A8DFC50A4
8 changed files with 95 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -339,6 +339,11 @@ impl Behaviour {
Ok(())
}
pub fn start_execution_setup(&mut self, bob_peer_id: PeerId, state0: State0) {
self.execution_setup.run(bob_peer_id, state0);
info!("Start execution setup with {}", bob_peer_id);
}
/// Send Message0 to Bob in response to receiving his Message0.
pub fn send_message0(
&mut self,

35
swap/src/protocol/alice/event_loop.rs
View File

@ -2,7 +2,7 @@ use crate::{
network::{request_response::AliceToBob, transport::SwapTransport, TokioExecutor},
protocol::{
alice,
alice::{Behaviour, OutEvent, SwapResponse, TransferProof},
alice::{Behaviour, OutEvent, State0, State3, SwapResponse, TransferProof},
bob,
bob::EncryptedSignature,
},
@ -38,10 +38,12 @@ pub struct EventLoopHandle {
recv_message0: Receiver<(bob::Message0, ResponseChannel<AliceToBob>)>,
recv_message1: Receiver<(bob::Message1, ResponseChannel<AliceToBob>)>,
recv_message2: Receiver<bob::Message2>,
done_execution_setup: Receiver<Result<State3>>,
recv_encrypted_signature: Receiver<EncryptedSignature>,
request: Receiver<crate::protocol::alice::swap_response::OutEvent>,
conn_established: Receiver<PeerId>,
send_swap_response: Sender<(ResponseChannel<AliceToBob>, SwapResponse)>,
start_execution_setup: Sender<(PeerId, State0)>,
send_message0: Sender<(ResponseChannel<AliceToBob>, alice::Message0)>,
send_message1: Sender<(ResponseChannel<AliceToBob>, alice::Message1)>,
send_transfer_proof: Sender<(PeerId, TransferProof)>,
@ -77,6 +79,18 @@ impl EventLoopHandle {
.ok_or_else(|| anyhow!("Failed to receive message 2 from Bob"))
}
pub async fn execution_setup(&mut self, bob_peer_id: PeerId, state0: State0) -> Result<State3> {
let _ = self
.start_execution_setup
.send((bob_peer_id, state0))
.await?;
self.done_execution_setup
.recv()
.await
.ok_or_else(|| anyhow!("Failed to setup execution with Bob"))?
}
pub async fn recv_encrypted_signature(&mut self) -> Result<EncryptedSignature> {
self.recv_encrypted_signature
.recv()
@ -140,6 +154,8 @@ pub struct EventLoop {
recv_message0: Sender<(bob::Message0, ResponseChannel<AliceToBob>)>,
recv_message1: Sender<(bob::Message1, ResponseChannel<AliceToBob>)>,
recv_message2: Sender<bob::Message2>,
start_execution_setup: Receiver<(PeerId, State0)>,
done_execution_setup: Sender<Result<State3>>,
recv_encrypted_signature: Sender<EncryptedSignature>,
request: Sender<crate::protocol::alice::swap_response::OutEvent>,
conn_established: Sender<PeerId>,
@ -169,6 +185,8 @@ impl EventLoop {
let recv_message0 = Channels::new();
let recv_message1 = Channels::new();
let recv_message2 = Channels::new();
let start_execution_setup = Channels::new();
let done_execution_setup = Channels::new();
let recv_encrypted_signature = Channels::new();
let request = Channels::new();
let conn_established = Channels::new();
@ -183,6 +201,8 @@ impl EventLoop {
recv_message0: recv_message0.sender,
recv_message1: recv_message1.sender,
recv_message2: recv_message2.sender,
start_execution_setup: start_execution_setup.receiver,
done_execution_setup: done_execution_setup.sender,
recv_encrypted_signature: recv_encrypted_signature.sender,
request: request.sender,
conn_established: conn_established.sender,
@ -197,6 +217,8 @@ impl EventLoop {
recv_message0: recv_message0.receiver,
recv_message1: recv_message1.receiver,
recv_message2: recv_message2.receiver,
start_execution_setup: start_execution_setup.sender,
done_execution_setup: done_execution_setup.receiver,
recv_encrypted_signature: recv_encrypted_signature.receiver,
request: request.receiver,
conn_established: conn_established.receiver,
@ -227,8 +249,8 @@ impl EventLoop {
OutEvent::Message2 { msg, bob_peer_id : _} => {
let _ = self.recv_message2.send(*msg).await;
}
OutEvent::ExecutionSetupDone(_res) => {
todo!()
OutEvent::ExecutionSetupDone(res) => {
let _ = self.done_execution_setup.send(res.map(|state|*state)).await;
}
OutEvent::TransferProofAcknowledged => {
trace!("Bob acknowledged transfer proof");
@ -250,6 +272,13 @@ impl EventLoop {
.map_err(|err|error!("Failed to send swap response: {:#}", err));
}
},
option = self.start_execution_setup.recv().fuse() => {
if let Some((bob_peer_id, state0)) = option {
let _ = self
.swarm
.start_execution_setup(bob_peer_id, state0);
}
},
msg0 = self.send_message0.recv().fuse() => {
if let Some((channel, msg)) = msg0 {
let _ = self

2
swap/src/protocol/alice/execution_setup.rs
View File

@ -39,7 +39,7 @@ impl Default for Behaviour {
}
impl Behaviour {
fn run(&mut self, bob: PeerId, state0: State0) {
pub fn run(&mut self, bob: PeerId, state0: State0) {
self.inner
.do_protocol_listener(bob, move |mut substream| async move {
let alice_message0 = state0.next_message();

31
swap/src/protocol/alice/steps.rs
View File

@ -55,39 +55,12 @@ pub async fn negotiate(
.send_swap_response(event.channel, SwapResponse { xmr_amount })
.await?;
let (bob_message0, channel) = timeout(
let state3 = timeout(
execution_params.bob_time_to_act,
event_loop_handle.recv_message0(),
event_loop_handle.execution_setup(bob_peer_id, state0),
)
.await??;
let alice_message0 = state0.next_message();
event_loop_handle
.send_message0(channel, alice_message0)
.await?;
let state1 = state0.receive(bob_message0)?;
let (bob_message1, channel) = timeout(
execution_params.bob_time_to_act,
event_loop_handle.recv_message1(),
)
.await??;
let state2 = state1.receive(bob_message1);
event_loop_handle
.send_message1(channel, state2.next_message())
.await?;
let bob_message2 = timeout(
execution_params.bob_time_to_act,
event_loop_handle.recv_message2(),
)
.await??;
let state3 = state2.receive(bob_message2)?;
Ok((bob_peer_id, state3))
}

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

@ -163,6 +163,7 @@ impl Builder {
}
}
}
fn init_event_loop(
&self,
) -> Result<(bob::event_loop::EventLoop, bob::event_loop::EventLoopHandle)> {
@ -175,6 +176,7 @@ impl Builder {
self.peer_id,
self.alice_peer_id,
self.alice_address.clone(),
self.bitcoin_wallet.clone(),
)
}
@ -302,6 +304,17 @@ impl Behaviour {
info!("Requesting swap from: {}", alice);
}
pub fn start_execution_setup(
&mut self,
alice_peer_id: PeerId,
state0: State0,
bitcoin_wallet: Arc<bitcoin::Wallet>,
) {
self.execution_setup
.run(alice_peer_id, state0, bitcoin_wallet);
info!("Start execution setup with {}", alice_peer_id);
}
/// Sends Bob's first message to Alice.
pub fn send_message0(&mut self, alice: PeerId, msg: bob::Message0) {
self.message0.send(alice, msg);

37
swap/src/protocol/bob/event_loop.rs
View File

@ -1,15 +1,17 @@
use crate::{
bitcoin,
bitcoin::EncryptedSignature,
network::{transport::SwapTransport, TokioExecutor},
protocol::{
alice,
alice::{SwapResponse, TransferProof},
bob::{self, Behaviour, OutEvent, SwapRequest},
bob::{self, Behaviour, OutEvent, State0, State2, SwapRequest},
},
};
use anyhow::{anyhow, Result};
use futures::FutureExt;
use libp2p::{core::Multiaddr, PeerId};
use std::sync::Arc;
use tokio::sync::mpsc::{Receiver, Sender};
use tracing::{debug, error, info};
@ -37,6 +39,8 @@ pub struct EventLoopHandle {
recv_swap_response: Receiver<SwapResponse>,
recv_message0: Receiver<alice::Message0>,
recv_message1: Receiver<alice::Message1>,
start_execution_setup: Sender<State0>,
done_execution_setup: Receiver<Result<State2>>,
recv_transfer_proof: Receiver<TransferProof>,
conn_established: Receiver<PeerId>,
dial_alice: Sender<()>,
@ -70,6 +74,15 @@ impl EventLoopHandle {
.ok_or_else(|| anyhow!("Failed to receive message 1 from Alice"))
}
pub async fn execution_setup(&mut self, state0: State0) -> Result<State2> {
let _ = self.start_execution_setup.send(state0).await?;
self.done_execution_setup
.recv()
.await
.ok_or_else(|| anyhow!("Failed to setup execution with Alice"))?
}
pub async fn recv_transfer_proof(&mut self) -> Result<TransferProof> {
self.recv_transfer_proof
.recv()
@ -128,10 +141,13 @@ impl EventLoopHandle {
#[allow(missing_debug_implementations)]
pub struct EventLoop {
swarm: libp2p::Swarm<Behaviour>,
bitcoin_wallet: Arc<bitcoin::Wallet>,
alice_peer_id: PeerId,
recv_swap_response: Sender<SwapResponse>,
recv_message0: Sender<alice::Message0>,
recv_message1: Sender<alice::Message1>,
start_execution_setup: Receiver<State0>,
done_execution_setup: Sender<Result<State2>>,
recv_transfer_proof: Sender<TransferProof>,
dial_alice: Receiver<()>,
conn_established: Sender<PeerId>,
@ -150,6 +166,7 @@ impl EventLoop {
peer_id: PeerId,
alice_peer_id: PeerId,
alice_addr: Multiaddr,
bitcoin_wallet: Arc<bitcoin::Wallet>,
) -> Result<(Self, EventLoopHandle)> {
let mut swarm = libp2p::swarm::SwarmBuilder::new(transport, behaviour, peer_id)
.executor(Box::new(TokioExecutor {
@ -162,6 +179,8 @@ impl EventLoop {
let swap_response = Channels::new();
let recv_message0 = Channels::new();
let recv_message1 = Channels::new();
let start_execution_setup = Channels::new();
let done_execution_setup = Channels::new();
let recv_transfer_proof = Channels::new();
let dial_alice = Channels::new();
let conn_established = Channels::new();
@ -175,9 +194,12 @@ impl EventLoop {
let event_loop = EventLoop {
swarm,
alice_peer_id,
bitcoin_wallet,
recv_swap_response: swap_response.sender,
recv_message0: recv_message0.sender,
recv_message1: recv_message1.sender,
start_execution_setup: start_execution_setup.receiver,
done_execution_setup: done_execution_setup.sender,
recv_transfer_proof: recv_transfer_proof.sender,
conn_established: conn_established.sender,
dial_alice: dial_alice.receiver,
@ -193,6 +215,8 @@ impl EventLoop {
recv_swap_response: swap_response.receiver,
recv_message0: recv_message0.receiver,
recv_message1: recv_message1.receiver,
start_execution_setup: start_execution_setup.sender,
done_execution_setup: done_execution_setup.receiver,
recv_transfer_proof: recv_transfer_proof.receiver,
conn_established: conn_established.receiver,
dial_alice: dial_alice.sender,
@ -225,8 +249,8 @@ impl EventLoop {
let _ = self.recv_message1.send(*msg).await;
}
OutEvent::Message2 => info!("Alice acknowledged message 2 received"),
OutEvent::ExecutionSetupDone(_res) => {
todo!()
OutEvent::ExecutionSetupDone(res) => {
let _ = self.done_execution_setup.send(res.map(|state|*state)).await;
}
OutEvent::TransferProof(msg) => {
let _ = self.recv_transfer_proof.send(*msg).await;
@ -275,6 +299,13 @@ impl EventLoop {
self.swarm.send_message2(self.alice_peer_id, msg);
}
},
option = self.start_execution_setup.recv().fuse() => {
if let Some(state0) = option {
let _ = self
.swarm
.start_execution_setup(self.alice_peer_id, state0, self.bitcoin_wallet.clone());
}
},
encrypted_signature = self.send_encrypted_signature.recv().fuse() => {
if let Some(tx_redeem_encsig) = encrypted_signature {
self.swarm.send_encrypted_signature(self.alice_peer_id, tx_redeem_encsig);

7
swap/src/protocol/bob/execution_setup.rs
View File

@ -40,7 +40,12 @@ impl Default for Behaviour {
}
impl Behaviour {
fn run(&mut self, alice: PeerId, state0: State0, bitcoin_wallet: Arc<crate::bitcoin::Wallet>) {
pub fn run(
&mut self,
alice: PeerId,
state0: State0,
bitcoin_wallet: Arc<crate::bitcoin::Wallet>,
) {
self.inner
.do_protocol_dialer(alice, move |mut substream| async move {
let bob_message0 = state0.next_message();

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

@ -70,13 +70,7 @@ async fn run_until_internal(
BobState::Started { state0, amounts } => {
event_loop_handle.dial().await?;
let state2 = negotiate(
state0,
amounts,
&mut event_loop_handle,
bitcoin_wallet.clone(),
)
.await?;
let state2 = negotiate(state0, amounts, &mut event_loop_handle).await?;
let state = BobState::Negotiated(state2);
let db_state = state.clone().into();
@ -378,7 +372,6 @@ pub async fn negotiate(
state0: crate::protocol::bob::state::State0,
amounts: SwapAmounts,
event_loop_handle: &mut EventLoopHandle,
bitcoin_wallet: Arc<crate::bitcoin::Wallet>,
) -> Result<bob::state::State2> {
tracing::trace!("Starting negotiate");
event_loop_handle
@ -391,21 +384,7 @@ pub async fn negotiate(
// argument.
let _swap_response = event_loop_handle.recv_swap_response().await?;
event_loop_handle
.send_message0(state0.next_message())
.await?;
let msg0 = event_loop_handle.recv_message0().await?;
let state1 = state0.receive(bitcoin_wallet.as_ref(), msg0).await?;
event_loop_handle
.send_message1(state1.next_message())
.await?;
let msg1 = event_loop_handle.recv_message1().await?;
let state2 = state1.receive(msg1)?;
event_loop_handle
.send_message2(state2.next_message())
.await?;
let state2 = event_loop_handle.execution_setup(state0).await?;
Ok(state2)
}