Struct QuicTwoPartyNet 

pub struct QuicTwoPartyNet { /* private fields */ }

Implements an MpcNetwork on top of QUIC

Implementations

impl<'a> QuicTwoPartyNet

pub fn new( party_id: PartyId, local_addr: SocketAddr, peer_addr: SocketAddr, ) -> Self

pub async fn connect(&mut self) -> Result<(), MpcNetworkError>

Establishes connections to the peer

Trait Implementations

impl Debug for QuicTwoPartyNet

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl MpcNetwork for QuicTwoPartyNet

fn party_id(&self) -> u64

Returns the ID of the given party in the MPC computation

fn send_bytes<'life0, 'life1, 'async_trait>( &'life0 mut self, bytes: &'life1 [u8], ) -> Pin<Box<dyn Future<Output = Result<(), MpcNetworkError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

The local party sends a byte buffer to the peer with an additional u64 prepended specifying the length of the payload

fn receive_bytes<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>, MpcNetworkError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

The local party awaits bytes from a peer; receiver expects that the payload is prepended with a length indicating the message size

fn send_scalars<'life0, 'life1, 'async_trait>( &'life0 mut self, scalars: &'life1 [Scalar], ) -> Pin<Box<dyn Future<Output = Result<(), MpcNetworkError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

The local party sends a vector of scalars to the peer

fn receive_scalars<'life0, 'async_trait>( &'life0 mut self, num_scalars: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<Scalar>, MpcNetworkError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

The local party receives exactly n scalars from the peer

fn broadcast_scalars<'life0, 'life1, 'async_trait>( &'life0 mut self, scalars: &'life1 [Scalar], ) -> Pin<Box<dyn Future<Output = Result<Vec<Scalar>, MpcNetworkError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Both parties broadcast a vector of scalars to one another

fn send_points<'life0, 'life1, 'async_trait>( &'life0 mut self, points: &'life1 [RistrettoPoint], ) -> Pin<Box<dyn Future<Output = Result<(), MpcNetworkError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

The local party sends a vector of Ristretto points to the peer

fn receive_points<'life0, 'async_trait>( &'life0 mut self, num_points: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<RistrettoPoint>, MpcNetworkError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

The local party awaits a vector of Ristretto points from the peer

fn broadcast_points<'life0, 'life1, 'async_trait>( &'life0 mut self, points: &'life1 [RistrettoPoint], ) -> Pin<Box<dyn Future<Output = Result<Vec<RistrettoPoint>, MpcNetworkError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Both parties broadcast a vector of points to one another

fn close<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<(), MpcNetworkError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Closes the connections opened in the handshake phase

fn am_king(&self) -> bool

Returns whether the local party is the king of the MPC (party 0)

fn send_single_scalar<'life0, 'async_trait>( &'life0 mut self, scalar: Scalar, ) -> Pin<Box<dyn Future<Output = Result<(), MpcNetworkError>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait,

The local party sends a single scalar to the peer

fn receive_single_scalar<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<Scalar, MpcNetworkError>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait,

The local party receives a single scalar from the peer

fn broadcast_single_scalar<'life0, 'async_trait>( &'life0 mut self, scalar: Scalar, ) -> Pin<Box<dyn Future<Output = Result<Scalar, MpcNetworkError>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait,

Both parties broadcast a single scalar to one another

fn send_single_point<'life0, 'async_trait>( &'life0 mut self, point: RistrettoPoint, ) -> Pin<Box<dyn Future<Output = Result<(), MpcNetworkError>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait,

The local party sends a single Ristretto point to the peer

fn receive_single_point<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<RistrettoPoint, MpcNetworkError>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait,

The local party awaits a single Ristretto point from the peer

fn broadcast_single_point<'life0, 'async_trait>( &'life0 mut self, point: RistrettoPoint, ) -> Pin<Box<dyn Future<Output = Result<RistrettoPoint, MpcNetworkError>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait,

Both parties broadcast a single point to one another