Git-Mirrors/xmr-btc-swap
1
0
Fork 0
mirror of https://github.com/comit-network/xmr-btc-swap.git synced 2025-11-24 09:53:09 -05:00
Code Issues Projects Releases Packages Wiki Activity

The first message is actually a quote or rate request

Browse source
This commit is contained in:
Franck Royer 2021-02-12 17:05:06 +11:00
parent c117885dad
commit 9ded728879
No known key found for this signature in database
GPG key ID: A82ED75A8DFC50A4
9 changed files with 91 additions and 92 deletions
Download patch file Download diff file Expand all files Collapse all files

44
swap/src/protocol/bob/event_loop.rs
View file

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