|
|
@ -3,8 +3,8 @@ use crate::{
|
|
|
|
bitcoin::EncryptedSignature,
|
|
|
|
bitcoin::EncryptedSignature,
|
|
|
|
network::{transport::SwapTransport, TokioExecutor},
|
|
|
|
network::{transport::SwapTransport, TokioExecutor},
|
|
|
|
protocol::{
|
|
|
|
protocol::{
|
|
|
|
alice::{SwapResponse, TransferProof},
|
|
|
|
alice::{QuoteResponse, TransferProof},
|
|
|
|
bob::{Behaviour, OutEvent, State0, State2, SwapRequest},
|
|
|
|
bob::{Behaviour, OutEvent, QuoteRequest, State0, State2},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
};
|
|
|
|
};
|
|
|
|
use anyhow::{anyhow, Result};
|
|
|
|
use anyhow::{anyhow, Result};
|
|
|
@ -35,22 +35,22 @@ impl<T> Default for Channels<T> {
|
|
|
|
|
|
|
|
|
|
|
|
#[derive(Debug)]
|
|
|
|
#[derive(Debug)]
|
|
|
|
pub struct EventLoopHandle {
|
|
|
|
pub struct EventLoopHandle {
|
|
|
|
recv_swap_response: Receiver<SwapResponse>,
|
|
|
|
recv_quote_response: Receiver<QuoteResponse>,
|
|
|
|
start_execution_setup: Sender<State0>,
|
|
|
|
start_execution_setup: Sender<State0>,
|
|
|
|
done_execution_setup: Receiver<Result<State2>>,
|
|
|
|
done_execution_setup: Receiver<Result<State2>>,
|
|
|
|
recv_transfer_proof: Receiver<TransferProof>,
|
|
|
|
recv_transfer_proof: Receiver<TransferProof>,
|
|
|
|
conn_established: Receiver<PeerId>,
|
|
|
|
conn_established: Receiver<PeerId>,
|
|
|
|
dial_alice: Sender<()>,
|
|
|
|
dial_alice: Sender<()>,
|
|
|
|
send_swap_request: Sender<SwapRequest>,
|
|
|
|
send_quote_request: Sender<QuoteRequest>,
|
|
|
|
send_encrypted_signature: Sender<EncryptedSignature>,
|
|
|
|
send_encrypted_signature: Sender<EncryptedSignature>,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
impl EventLoopHandle {
|
|
|
|
impl EventLoopHandle {
|
|
|
|
pub async fn recv_swap_response(&mut self) -> Result<SwapResponse> {
|
|
|
|
pub async fn recv_quote_response(&mut self) -> Result<QuoteResponse> {
|
|
|
|
self.recv_swap_response
|
|
|
|
self.recv_quote_response
|
|
|
|
.recv()
|
|
|
|
.recv()
|
|
|
|
.await
|
|
|
|
.await
|
|
|
|
.ok_or_else(|| anyhow!("Failed to receive swap response from Alice"))
|
|
|
|
.ok_or_else(|| anyhow!("Failed to receive quote response from Alice"))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
pub async fn execution_setup(&mut self, state0: State0) -> Result<State2> {
|
|
|
|
pub async fn execution_setup(&mut self, state0: State0) -> Result<State2> {
|
|
|
@ -83,8 +83,8 @@ impl EventLoopHandle {
|
|
|
|
Ok(())
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
pub async fn send_swap_request(&mut self, swap_request: SwapRequest) -> Result<()> {
|
|
|
|
pub async fn send_quote_request(&mut self, quote_request: QuoteRequest) -> Result<()> {
|
|
|
|
let _ = self.send_swap_request.send(swap_request).await?;
|
|
|
|
let _ = self.send_quote_request.send(quote_request).await?;
|
|
|
|
Ok(())
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
@ -103,13 +103,13 @@ pub struct EventLoop {
|
|
|
|
swarm: libp2p::Swarm<Behaviour>,
|
|
|
|
swarm: libp2p::Swarm<Behaviour>,
|
|
|
|
bitcoin_wallet: Arc<bitcoin::Wallet>,
|
|
|
|
bitcoin_wallet: Arc<bitcoin::Wallet>,
|
|
|
|
alice_peer_id: PeerId,
|
|
|
|
alice_peer_id: PeerId,
|
|
|
|
recv_swap_response: Sender<SwapResponse>,
|
|
|
|
recv_quote_response: Sender<QuoteResponse>,
|
|
|
|
start_execution_setup: Receiver<State0>,
|
|
|
|
start_execution_setup: Receiver<State0>,
|
|
|
|
done_execution_setup: Sender<Result<State2>>,
|
|
|
|
done_execution_setup: Sender<Result<State2>>,
|
|
|
|
recv_transfer_proof: Sender<TransferProof>,
|
|
|
|
recv_transfer_proof: Sender<TransferProof>,
|
|
|
|
dial_alice: Receiver<()>,
|
|
|
|
dial_alice: Receiver<()>,
|
|
|
|
conn_established: Sender<PeerId>,
|
|
|
|
conn_established: Sender<PeerId>,
|
|
|
|
send_swap_request: Receiver<SwapRequest>,
|
|
|
|
send_quote_request: Receiver<QuoteRequest>,
|
|
|
|
send_encrypted_signature: Receiver<EncryptedSignature>,
|
|
|
|
send_encrypted_signature: Receiver<EncryptedSignature>,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
@ -130,37 +130,37 @@ impl EventLoop {
|
|
|
|
|
|
|
|
|
|
|
|
swarm.add_address(alice_peer_id, alice_addr);
|
|
|
|
swarm.add_address(alice_peer_id, alice_addr);
|
|
|
|
|
|
|
|
|
|
|
|
let swap_response = Channels::new();
|
|
|
|
let quote_response = Channels::new();
|
|
|
|
let start_execution_setup = Channels::new();
|
|
|
|
let start_execution_setup = Channels::new();
|
|
|
|
let done_execution_setup = Channels::new();
|
|
|
|
let done_execution_setup = Channels::new();
|
|
|
|
let recv_transfer_proof = Channels::new();
|
|
|
|
let recv_transfer_proof = Channels::new();
|
|
|
|
let dial_alice = Channels::new();
|
|
|
|
let dial_alice = Channels::new();
|
|
|
|
let conn_established = Channels::new();
|
|
|
|
let conn_established = Channels::new();
|
|
|
|
let send_swap_request = Channels::new();
|
|
|
|
let send_quote_request = Channels::new();
|
|
|
|
let send_encrypted_signature = Channels::new();
|
|
|
|
let send_encrypted_signature = Channels::new();
|
|
|
|
|
|
|
|
|
|
|
|
let event_loop = EventLoop {
|
|
|
|
let event_loop = EventLoop {
|
|
|
|
swarm,
|
|
|
|
swarm,
|
|
|
|
alice_peer_id,
|
|
|
|
alice_peer_id,
|
|
|
|
bitcoin_wallet,
|
|
|
|
bitcoin_wallet,
|
|
|
|
recv_swap_response: swap_response.sender,
|
|
|
|
recv_quote_response: quote_response.sender,
|
|
|
|
start_execution_setup: start_execution_setup.receiver,
|
|
|
|
start_execution_setup: start_execution_setup.receiver,
|
|
|
|
done_execution_setup: done_execution_setup.sender,
|
|
|
|
done_execution_setup: done_execution_setup.sender,
|
|
|
|
recv_transfer_proof: recv_transfer_proof.sender,
|
|
|
|
recv_transfer_proof: recv_transfer_proof.sender,
|
|
|
|
conn_established: conn_established.sender,
|
|
|
|
conn_established: conn_established.sender,
|
|
|
|
dial_alice: dial_alice.receiver,
|
|
|
|
dial_alice: dial_alice.receiver,
|
|
|
|
send_swap_request: send_swap_request.receiver,
|
|
|
|
send_quote_request: send_quote_request.receiver,
|
|
|
|
send_encrypted_signature: send_encrypted_signature.receiver,
|
|
|
|
send_encrypted_signature: send_encrypted_signature.receiver,
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
let handle = EventLoopHandle {
|
|
|
|
let handle = EventLoopHandle {
|
|
|
|
recv_swap_response: swap_response.receiver,
|
|
|
|
recv_quote_response: quote_response.receiver,
|
|
|
|
start_execution_setup: start_execution_setup.sender,
|
|
|
|
start_execution_setup: start_execution_setup.sender,
|
|
|
|
done_execution_setup: done_execution_setup.receiver,
|
|
|
|
done_execution_setup: done_execution_setup.receiver,
|
|
|
|
recv_transfer_proof: recv_transfer_proof.receiver,
|
|
|
|
recv_transfer_proof: recv_transfer_proof.receiver,
|
|
|
|
conn_established: conn_established.receiver,
|
|
|
|
conn_established: conn_established.receiver,
|
|
|
|
dial_alice: dial_alice.sender,
|
|
|
|
dial_alice: dial_alice.sender,
|
|
|
|
send_swap_request: send_swap_request.sender,
|
|
|
|
send_quote_request: send_quote_request.sender,
|
|
|
|
send_encrypted_signature: send_encrypted_signature.sender,
|
|
|
|
send_encrypted_signature: send_encrypted_signature.sender,
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
@ -175,8 +175,8 @@ impl EventLoop {
|
|
|
|
OutEvent::ConnectionEstablished(peer_id) => {
|
|
|
|
OutEvent::ConnectionEstablished(peer_id) => {
|
|
|
|
let _ = self.conn_established.send(peer_id).await;
|
|
|
|
let _ = self.conn_established.send(peer_id).await;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
OutEvent::SwapResponse(msg) => {
|
|
|
|
OutEvent::QuoteResponse(msg) => {
|
|
|
|
let _ = self.recv_swap_response.send(msg).await;
|
|
|
|
let _ = self.recv_quote_response.send(msg).await;
|
|
|
|
},
|
|
|
|
},
|
|
|
|
OutEvent::ExecutionSetupDone(res) => {
|
|
|
|
OutEvent::ExecutionSetupDone(res) => {
|
|
|
|
let _ = self.done_execution_setup.send(res.map(|state|*state)).await;
|
|
|
|
let _ = self.done_execution_setup.send(res.map(|state|*state)).await;
|
|
|
@ -213,9 +213,9 @@ impl EventLoop {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
},
|
|
|
|
},
|
|
|
|
swap_request = self.send_swap_request.recv().fuse() => {
|
|
|
|
quote_request = self.send_quote_request.recv().fuse() => {
|
|
|
|
if let Some(swap_request) = swap_request {
|
|
|
|
if let Some(quote_request) = quote_request {
|
|
|
|
self.swarm.send_swap_request(self.alice_peer_id, swap_request);
|
|
|
|
self.swarm.send_quote_request(self.alice_peer_id, quote_request);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
},
|
|
|
|
},
|
|
|
|
option = self.start_execution_setup.recv().fuse() => {
|
|
|
|
option = self.start_execution_setup.recv().fuse() => {
|
|
|
|