Implement new behaviour for execution setup

swap/src/protocol/bob/event_loop.rs

@@ -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,6 +249,9 @@ impl EventLoop {
                             let _ = self.recv_message1.send(*msg).await;
                         }
                         OutEvent::Message2 => info!("Alice acknowledged message 2 received"),
+                        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;
                         }
@@ -272,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);