Struct zappot::ot_ext::Sender

pub struct Sender<BaseOT = Receiver> { /* private fields */ }

Implementations

impl<BaseOT> Sender<BaseOT>

where BaseOT: BaseROTReceiver + Send, BaseOT::Msg: RemoteSend + Debug,

pub async fn perform_base_ots<RNG: RngCore + CryptoRng + Send>( &mut self, rng: &mut RNG, sender: &Sender<<Self as ExtROTSender>::Msg>, receiver: &mut Receiver<<Self as ExtROTSender>::Msg> ) -> Result<(), Error<<Self as ExtROTSender>::Msg>>

impl<BaseOt> Sender<BaseOt>

pub fn new(base_ot_receiver: BaseOt) -> Self

Examples found in repository

crates/zappot/examples/alsz_ot_extension.rs (line 34)

async fn sender(args: Args) -> (Vec<[Block; 2]>, usize, usize) {
    // Create a secure RNG to use in the protocol
    let mut rng = OsRng;
    // Create the ot extension sender. A base OT **receiver** is passed as an argument and used
    // to create the base_ots
    let mut sender = Sender::new(base_ot::Receiver);
    // Create a channel by listening on a socket address. Once another party connect, this
    // returns the channel
    let (mut base_sender, send_cnt, mut base_receiver, recv_cnt) =
        seec_channel::tcp::listen::<seec_channel::Sender<_>>(("127.0.0.1", args.port))
            .await
            .expect("Error listening for channel connection");
    let (ch_sender, mut ch_receiver) = sub_channel(&mut base_sender, &mut base_receiver, 128)
        .await
        .expect("Establishing sub channel");

    // Perform the random ots
    let ots = sender
        .send_random(args.num_ots, &mut rng, &ch_sender, &mut ch_receiver)
        .await
        .expect("Failed to generate ROTs");
    (ots, send_cnt.get(), recv_cnt.get())
}

Trait Implementations

impl Default for Sender

fn default() -> Self

Returns the “default value” for a type.

impl<BaseOT> ExtROTSender for Sender<BaseOT>

where BaseOT: BaseROTReceiver + Send, BaseOT::Msg: RemoteSend + Debug,

type Msg = ExtOTMsg<<BaseOT as BaseROTReceiver>::Msg>

fn send_random<'life0, 'life1, 'life2, 'life3, 'async_trait, RNG>( &'life0 mut self, count: usize, rng: &'life1 mut RNG, sender: &'life2 Sender<Self::Msg>, receiver: &'life3 mut Receiver<Self::Msg> ) -> Pin<Box<dyn Future<Output = Result<Vec<[Block; 2]>, Error<Self::Msg>>> + Send + 'async_trait>>

where RNG: RngCore + CryptoRng + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

fn send_correlated<'life0, 'life1, 'life2, 'life3, 'async_trait, RNG>( &'life0 mut self, count: usize, correlation: impl 'async_trait + Fn(usize, Block) -> Block + Send, rng: &'life1 mut RNG, sender: &'life2 Sender<Self::Msg>, receiver: &'life3 mut Receiver<Self::Msg> ) -> Pin<Box<dyn Future<Output = Result<Vec<Block>, Error<Self::Msg>>> + Send + 'async_trait>>

where RNG: RngCore + CryptoRng + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

fn send_correlated_bytes<'life0, 'life1, 'life2, 'life3, 'async_trait, const LEN: usize, RNG>( &'life0 mut self, count: usize, correlation: impl 'async_trait + Fn(usize, [u8; LEN]) -> [u8; LEN] + Send, rng: &'life1 mut RNG, sender: &'life2 Sender<Self::Msg>, receiver: &'life3 mut Receiver<Self::Msg> ) -> Pin<Box<dyn Future<Output = Result<Vec<[u8; LEN]>, Error<Self::Msg>>> + Send + 'async_trait>>

where RNG: RngCore + CryptoRng + Send + 'async_trait, [u8; LEN]: Pod, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,