refactor ot aio

mpc-aio/examples/ote_ws.rs

@@ -1,5 +1,5 @@
-use mpc_aio::ot::{OtReceive, OtReceiver, OtSend, OtSender};
-use mpc_core::ot::{ChaChaAesOtReceiver, ChaChaAesOtSender, OtMessage};
+use mpc_aio::ot::{ExtOTReceive, ExtOTSend, ExtReceiver, ExtSender, Message};
+use mpc_core::ot::{ExtReceiverCore, ExtSenderCore};
 use mpc_core::proto;
 use mpc_core::Block;
 use tokio;
@@ -24,10 +24,10 @@ async fn ot_receive(stream: UnixStream) {
 
     let stream = Framed::new(
         ws,
-        ProstCodecDelimited::<OtMessage, proto::ot::OtMessage>::default(),
+        ProstCodecDelimited::<Message, proto::ot::Message>::default(),
     );
 
-    let mut receiver = OtReceiver::new(ChaChaAesOtReceiver::default(), stream);
+    let mut receiver = ExtReceiver::new(ExtReceiverCore::default(), stream);
 
     let choice = vec![false, false, true];
 
@@ -52,10 +52,10 @@ async fn ot_send(stream: UnixStream) {
 
     let stream = Framed::new(
         ws,
-        ProstCodecDelimited::<OtMessage, proto::ot::OtMessage>::default(),
+        ProstCodecDelimited::<Message, proto::ot::Message>::default(),
     );
 
-    let mut sender = OtSender::new(ChaChaAesOtSender::default(), stream);
+    let mut sender = ExtSender::new(ExtSenderCore::default(), stream);
 
     let messages = [
         [Block::new(0), Block::new(1)],

mpc-aio/src/garble/errors.rs

@@ -4,7 +4,7 @@ use mpc_core::garble::{
 };
 use thiserror::Error;
 
-use crate::ot::OtError;
+use crate::ot::OTError;
 
 #[derive(Debug, Error)]
 pub enum GarbleError {
@@ -13,7 +13,7 @@ pub enum GarbleError {
     #[error("Encountered error during evaluation: {0}")]
     EvaluatorError(#[from] EvaluatorError),
     #[error("Encountered OT error: {0}")]
-    OtError(#[from] OtError),
+    OTError(#[from] OTError),
     #[error("Received unexpected message: {0:?}")]
     Unexpected(GarbleMessage),
     #[error("Encountered IO error: {0}")]

mpc-aio/src/garble/evaluator.rs

@@ -1,5 +1,5 @@
 use super::GarbleError;
-use crate::ot::receiver::OtReceive;
+use crate::ot::OTReceive;
 use mpc_core::circuit::{Circuit, CircuitInput};
 use mpc_core::garble::circuit::InputLabel;
 use mpc_core::garble::evaluator::GarbledCircuitEvaluator;
@@ -29,7 +29,7 @@ where
 
     pub async fn evaluate<V: GarbledCircuitEvaluator>(
         &mut self,
-        ot: &mut impl OtReceive,
+        ot: &mut impl OTReceive,
         circ: &Circuit,
         ev: &V,
         inputs: &Vec<CircuitInput>,

mpc-aio/src/garble/generator.rs

@@ -1,5 +1,5 @@
 use super::GarbleError;
-use crate::ot::sender::OtSend;
+use crate::ot::OTSend;
 use mpc_core::circuit::{Circuit, CircuitInput};
 use mpc_core::garble::generator::GarbledCircuitGenerator;
 use mpc_core::garble::GarbleMessage;
@@ -29,7 +29,7 @@ where
 
     pub async fn garble<G: GarbledCircuitGenerator>(
         &mut self,
-        ot: &mut impl OtSend,
+        ot: &mut impl OTSend,
         circ: &Circuit,
         gen: &G,
         inputs: &Vec<CircuitInput>,

mpc-aio/src/ot/base/mod.rs

@@ -0,0 +1,6 @@
+pub mod receiver;
+pub mod sender;
+
+pub use super::errors::*;
+pub use receiver::{OTReceive, Receiver};
+pub use sender::{OTSend, Sender};

mpc-aio/src/ot/base/receiver.rs

@@ -0,0 +1,71 @@
+use super::OTError;
+use async_trait::async_trait;
+use futures_util::{Sink, SinkExt, Stream, StreamExt};
+use mpc_core::ot::{Message, ReceiveCore};
+use mpc_core::Block;
+use std::io::Error as IOError;
+use std::io::ErrorKind;
+use tracing::{instrument, trace};
+
+pub struct Receiver<OT, S> {
+    ot: OT,
+    stream: S,
+}
+
+#[async_trait]
+pub trait OTReceive {
+    async fn receive(&mut self, choice: &[bool]) -> Result<Vec<Block>, OTError>;
+}
+
+impl<
+        OT: ReceiveCore + Send,
+        S: Sink<Message> + Stream<Item = Result<Message, E>> + Send + Unpin,
+        E: std::fmt::Debug,
+    > Receiver<OT, S>
+where
+    OTError: From<<S as Sink<Message>>::Error>,
+    OTError: From<E>,
+{
+    pub fn new(ot: OT, stream: S) -> Self {
+        Self { ot, stream }
+    }
+}
+
+#[async_trait]
+impl<
+        OT: ReceiveCore + Send,
+        S: Sink<Message> + Stream<Item = Result<Message, E>> + Send + Unpin,
+        E: std::fmt::Debug,
+    > OTReceive for Receiver<OT, S>
+where
+    OTError: From<<S as Sink<Message>>::Error>,
+    OTError: From<E>,
+{
+    #[instrument(skip(self, choice))]
+    async fn receive(&mut self, choice: &[bool]) -> Result<Vec<Block>, OTError> {
+        let setup = match self.stream.next().await {
+            Some(Ok(Message::SenderSetup(m))) => m,
+            Some(Ok(m)) => return Err(OTError::Unexpected(m)),
+            Some(Err(e)) => return Err(e)?,
+            None => return Err(IOError::new(ErrorKind::UnexpectedEof, ""))?,
+        };
+        trace!("Received SenderSetup");
+
+        let setup = self.ot.setup(choice, setup)?;
+
+        trace!("Sending ReceiverSetup");
+        self.stream.send(Message::ReceiverSetup(setup)).await?;
+
+        let payload = match self.stream.next().await {
+            Some(Ok(Message::SenderPayload(m))) => m,
+            Some(Ok(m)) => return Err(OTError::Unexpected(m)),
+            Some(Err(e)) => return Err(e)?,
+            None => return Err(IOError::new(ErrorKind::UnexpectedEof, ""))?,
+        };
+        trace!("Received SenderPayload");
+
+        let values = self.ot.receive(payload)?;
+
+        Ok(values)
+    }
+}

mpc-aio/src/ot/base/sender.rs

@@ -0,0 +1,66 @@
+use super::OTError;
+use async_trait::async_trait;
+use futures_util::{Sink, SinkExt, Stream, StreamExt};
+use mpc_core::ot::{Message, SendCore};
+use mpc_core::Block;
+use std::io::Error as IOError;
+use std::io::ErrorKind;
+use tracing::{instrument, trace};
+
+pub struct Sender<OT, S> {
+    ot: OT,
+    stream: S,
+}
+
+#[async_trait]
+pub trait OTSend {
+    async fn send(&mut self, payload: &[[Block; 2]]) -> Result<(), OTError>;
+}
+
+impl<
+        OT: SendCore + Send,
+        S: Sink<Message> + Stream<Item = Result<Message, E>> + Send + Unpin,
+        E: std::fmt::Debug,
+    > Sender<OT, S>
+where
+    OTError: From<<S as Sink<Message>>::Error>,
+    OTError: From<E>,
+{
+    pub fn new(ot: OT, stream: S) -> Self {
+        Self { ot, stream }
+    }
+}
+
+#[async_trait]
+impl<
+        OT: SendCore + Send,
+        S: Sink<Message> + Stream<Item = Result<Message, E>> + Send + Unpin,
+        E: std::fmt::Debug,
+    > OTSend for Sender<OT, S>
+where
+    OTError: From<<S as Sink<Message>>::Error>,
+    OTError: From<E>,
+{
+    #[instrument(skip(self, payload))]
+    async fn send(&mut self, payload: &[[Block; 2]]) -> Result<(), OTError> {
+        let setup = self.ot.setup();
+
+        trace!("Sending SenderSetup");
+        self.stream.send(Message::SenderSetup(setup)).await?;
+
+        let setup = match self.stream.next().await {
+            Some(Ok(Message::ReceiverSetup(m))) => m,
+            Some(Ok(m)) => return Err(OTError::Unexpected(m)),
+            Some(Err(e)) => return Err(e)?,
+            None => return Err(IOError::new(ErrorKind::UnexpectedEof, ""))?,
+        };
+        trace!("Received ReceiverSetup");
+
+        let payload = self.ot.send(payload, setup)?;
+
+        self.stream.send(Message::SenderPayload(payload)).await?;
+        trace!("Sending SenderPayload");
+
+        Ok(())
+    }
+}

mpc-aio/src/ot/errors.rs

@@ -1,16 +1,20 @@
-use mpc_core::ot::errors::{OtReceiverCoreError, OtSenderCoreError};
-use mpc_core::ot::OtMessage;
+use mpc_core::ot::Message;
+use mpc_core::ot::{ExtReceiverCoreError, ExtSenderCoreError, ReceiverCoreError, SenderCoreError};
 use thiserror::Error;
 
 /// Errors that may occur when using AsyncOTSender
 #[derive(Debug, Error)]
-pub enum OtError {
+pub enum OTError {
     #[error("OT sender core error: {0}")]
-    OtSenderCoreError(#[from] OtSenderCoreError),
+    SenderCoreError(#[from] SenderCoreError),
     #[error("OT receiver core error: {0}")]
-    OtReceiverCoreError(#[from] OtReceiverCoreError),
+    ReceiverCoreError(#[from] ReceiverCoreError),
+    #[error("OT sender core error: {0}")]
+    ExtSenderCoreError(#[from] ExtSenderCoreError),
+    #[error("OT receiver core error: {0}")]
+    ExtReceiverCoreError(#[from] ExtReceiverCoreError),
     #[error("IO error: {0}")]
     IOError(#[from] std::io::Error),
     #[error("Received unexpected message: {0:?}")]
-    Unexpected(OtMessage),
+    Unexpected(Message),
 }

mpc-aio/src/ot/extension/mod.rs

@@ -0,0 +1,7 @@
+pub mod receiver;
+pub mod sender;
+
+use super::errors::*;
+
+pub use receiver::{ExtOTReceive, ExtReceiver};
+pub use sender::{ExtOTSend, ExtSender};

mpc-aio/src/ot/extension/receiver.rs

@@ -0,0 +1,81 @@
+use super::OTError;
+use async_trait::async_trait;
+use futures_util::{Sink, SinkExt, Stream, StreamExt};
+use mpc_core::ot::{ExtReceiveCore, Message};
+use mpc_core::Block;
+use std::io::Error as IOError;
+use std::io::ErrorKind;
+use tracing::{instrument, trace};
+
+pub struct ExtReceiver<OT, S> {
+    ot: OT,
+    stream: S,
+}
+
+#[async_trait]
+pub trait ExtOTReceive {
+    async fn receive(&mut self, choice: &[bool]) -> Result<Vec<Block>, OTError>;
+}
+
+impl<
+        OT: ExtReceiveCore + Send,
+        S: Sink<Message> + Stream<Item = Result<Message, E>> + Send + Unpin,
+        E: std::fmt::Debug,
+    > ExtReceiver<OT, S>
+where
+    OTError: From<<S as Sink<Message>>::Error>,
+    OTError: From<E>,
+{
+    pub fn new(ot: OT, stream: S) -> Self {
+        Self { ot, stream }
+    }
+}
+
+#[async_trait]
+impl<
+        OT: ExtReceiveCore + Send,
+        S: Sink<Message> + Stream<Item = Result<Message, E>> + Send + Unpin,
+        E: std::fmt::Debug,
+    > ExtOTReceive for ExtReceiver<OT, S>
+where
+    OTError: From<<S as Sink<Message>>::Error>,
+    OTError: From<E>,
+{
+    #[instrument(skip(self, choice))]
+    async fn receive(&mut self, choice: &[bool]) -> Result<Vec<Block>, OTError> {
+        let base_setup = self.ot.base_setup()?;
+
+        trace!("Sending SenderSetup");
+        self.stream.send(Message::SenderSetup(base_setup)).await?;
+
+        let base_receiver_setup = match self.stream.next().await {
+            Some(Ok(Message::ReceiverSetup(m))) => m,
+            Some(Ok(m)) => return Err(OTError::Unexpected(m)),
+            Some(Err(e)) => return Err(e)?,
+            None => return Err(IOError::new(ErrorKind::UnexpectedEof, ""))?,
+        };
+        trace!("Received ReceiverSetup");
+
+        let payload = self.ot.base_send(base_receiver_setup.try_into().unwrap())?;
+
+        trace!("Sending SenderPayload");
+        self.stream.send(Message::SenderPayload(payload)).await?;
+
+        let setup = self.ot.extension_setup(choice)?;
+
+        trace!("Sending ExtReceiverSetup");
+        self.stream.send(Message::ExtReceiverSetup(setup)).await?;
+
+        let payload = match self.stream.next().await {
+            Some(Ok(Message::ExtSenderPayload(m))) => m,
+            Some(Ok(m)) => return Err(OTError::Unexpected(m)),
+            Some(Err(e)) => return Err(e)?,
+            None => return Err(IOError::new(ErrorKind::UnexpectedEof, ""))?,
+        };
+        trace!("Received ExtSenderPayload");
+
+        let values = self.ot.receive(choice, payload.try_into().unwrap())?;
+
+        Ok(values)
+    }
+}

mpc-aio/src/ot/extension/sender.rs

@@ -1,30 +1,30 @@
-use super::errors::OtError;
+use super::OTError;
 use async_trait::async_trait;
 use futures_util::{Sink, SinkExt, Stream, StreamExt};
-use mpc_core::ot::{OtMessage, OtSendCore};
+use mpc_core::ot::{ExtSendCore, Message};
 use mpc_core::Block;
 use std::io::Error as IOError;
 use std::io::ErrorKind;
 use tracing::{instrument, trace};
 
-pub struct OtSender<OT, S> {
+pub struct ExtSender<OT, S> {
     ot: OT,
     stream: S,
 }
 
 #[async_trait]
-pub trait OtSend {
-    async fn send(&mut self, payload: &[[Block; 2]]) -> Result<(), OtError>;
+pub trait ExtOTSend {
+    async fn send(&mut self, payload: &[[Block; 2]]) -> Result<(), OTError>;
 }
 
 impl<
-        OT: OtSendCore + Send,
-        S: Sink<OtMessage> + Stream<Item = Result<OtMessage, E>> + Send + Unpin,
+        OT: ExtSendCore + Send,
+        S: Sink<Message> + Stream<Item = Result<Message, E>> + Send + Unpin,
         E: std::fmt::Debug,
-    > OtSender<OT, S>
+    > ExtSender<OT, S>
 where
-    OtError: From<<S as Sink<OtMessage>>::Error>,
-    OtError: From<E>,
+    OTError: From<<S as Sink<Message>>::Error>,
+    OTError: From<E>,
 {
     pub fn new(ot: OT, stream: S) -> Self {
         Self { ot, stream }
@@ -33,55 +33,53 @@ where
 
 #[async_trait]
 impl<
-        OT: OtSendCore + Send,
-        S: Sink<OtMessage> + Stream<Item = Result<OtMessage, E>> + Send + Unpin,
+        OT: ExtSendCore + Send,
+        S: Sink<Message> + Stream<Item = Result<Message, E>> + Send + Unpin,
         E: std::fmt::Debug,
-    > OtSend for OtSender<OT, S>
+    > ExtOTSend for ExtSender<OT, S>
 where
-    OtError: From<<S as Sink<OtMessage>>::Error>,
-    OtError: From<E>,
+    OTError: From<<S as Sink<Message>>::Error>,
+    OTError: From<E>,
 {
     #[instrument(skip(self, payload))]
-    async fn send(&mut self, payload: &[[Block; 2]]) -> Result<(), OtError> {
+    async fn send(&mut self, payload: &[[Block; 2]]) -> Result<(), OTError> {
         let base_sender_setup = match self.stream.next().await {
-            Some(Ok(OtMessage::BaseSenderSetup(m))) => m,
-            Some(Ok(m)) => return Err(OtError::Unexpected(m)),
+            Some(Ok(Message::SenderSetup(m))) => m,
+            Some(Ok(m)) => return Err(OTError::Unexpected(m)),
             Some(Err(e)) => return Err(e)?,
             None => return Err(IOError::new(ErrorKind::UnexpectedEof, ""))?,
         };
-        trace!("Received BaseOtSenderSetup");
+        trace!("Received SenderSetup");
 
         let base_setup = self.ot.base_setup(base_sender_setup.try_into().unwrap())?;
 
-        trace!("Sending BaseOtReceiverSetup");
-        self.stream
-            .send(OtMessage::BaseReceiverSetup(base_setup))
-            .await?;
+        trace!("Sending ReceiverSetup");
+        self.stream.send(Message::ReceiverSetup(base_setup)).await?;
 
         let base_payload = match self.stream.next().await {
-            Some(Ok(OtMessage::BaseSenderPayload(m))) => m,
-            Some(Ok(m)) => return Err(OtError::Unexpected(m)),
+            Some(Ok(Message::SenderPayload(m))) => m,
+            Some(Ok(m)) => return Err(OTError::Unexpected(m)),
             Some(Err(e)) => return Err(e)?,
             None => return Err(IOError::new(ErrorKind::UnexpectedEof, ""))?,
         };
-        trace!("Received BaseOtSenderPayload");
+        trace!("Received SenderPayload");
 
         self.ot.base_receive(base_payload.try_into().unwrap())?;
 
         let extension_receiver_setup = match self.stream.next().await {
-            Some(Ok(OtMessage::ReceiverSetup(m))) => m,
-            Some(Ok(m)) => return Err(OtError::Unexpected(m)),
+            Some(Ok(Message::ExtReceiverSetup(m))) => m,
+            Some(Ok(m)) => return Err(OTError::Unexpected(m)),
             Some(Err(e)) => return Err(e)?,
             None => return Err(IOError::new(ErrorKind::UnexpectedEof, ""))?,
         };
-        trace!("Received OtReceiverSetup");
+        trace!("Received ExtReceiverSetup");
 
         self.ot
             .extension_setup(extension_receiver_setup.try_into().unwrap())?;
         let payload = self.ot.send(payload)?;
 
-        self.stream.send(OtMessage::SenderPayload(payload)).await?;
-        trace!("Sending OtSenderPayload");
+        self.stream.send(Message::ExtSenderPayload(payload)).await?;
+        trace!("Sending ExtSenderPayload");
 
         Ok(())
     }

mpc-aio/src/ot/mod.rs

@@ -1,7 +1,8 @@
+pub mod base;
 pub mod errors;
-pub mod receiver;
-pub mod sender;
+pub mod extension;
 
-pub use errors::OtError;
-pub use receiver::{OtReceive, OtReceiver};
-pub use sender::{OtSend, OtSender};
+pub use base::{OTReceive, OTSend, Receiver, Sender};
+pub use errors::OTError;
+pub use extension::{ExtOTReceive, ExtOTSend, ExtReceiver, ExtSender};
+pub use mpc_core::ot::Message;

mpc-aio/src/ot/receiver.rs

@@ -1,85 +0,0 @@
-use super::errors::OtError;
-use async_trait::async_trait;
-use futures_util::{Sink, SinkExt, Stream, StreamExt};
-use mpc_core::ot::{OtMessage, OtReceiveCore};
-use mpc_core::Block;
-use std::io::Error as IOError;
-use std::io::ErrorKind;
-use tracing::{instrument, trace};
-
-pub struct OtReceiver<OT, S> {
-    ot: OT,
-    stream: S,
-}
-
-#[async_trait]
-pub trait OtReceive {
-    async fn receive(&mut self, choice: &[bool]) -> Result<Vec<Block>, OtError>;
-}
-
-impl<
-        OT: OtReceiveCore + Send,
-        S: Sink<OtMessage> + Stream<Item = Result<OtMessage, E>> + Send + Unpin,
-        E: std::fmt::Debug,
-    > OtReceiver<OT, S>
-where
-    OtError: From<<S as Sink<OtMessage>>::Error>,
-    OtError: From<E>,
-{
-    pub fn new(ot: OT, stream: S) -> Self {
-        Self { ot, stream }
-    }
-}
-
-#[async_trait]
-impl<
-        OT: OtReceiveCore + Send,
-        S: Sink<OtMessage> + Stream<Item = Result<OtMessage, E>> + Send + Unpin,
-        E: std::fmt::Debug,
-    > OtReceive for OtReceiver<OT, S>
-where
-    OtError: From<<S as Sink<OtMessage>>::Error>,
-    OtError: From<E>,
-{
-    #[instrument(skip(self, choice))]
-    async fn receive(&mut self, choice: &[bool]) -> Result<Vec<Block>, OtError> {
-        let base_setup = self.ot.base_setup()?;
-
-        trace!("Sending BaseOtSenderSetup");
-        self.stream
-            .send(OtMessage::BaseSenderSetup(base_setup))
-            .await?;
-
-        let base_receiver_setup = match self.stream.next().await {
-            Some(Ok(OtMessage::BaseReceiverSetup(m))) => m,
-            Some(Ok(m)) => return Err(OtError::Unexpected(m)),
-            Some(Err(e)) => return Err(e)?,
-            None => return Err(IOError::new(ErrorKind::UnexpectedEof, ""))?,
-        };
-        trace!("Received BaseOtReceiverSetup");
-
-        let payload = self.ot.base_send(base_receiver_setup.try_into().unwrap())?;
-
-        trace!("Sending BaseOtSenderPayload");
-        self.stream
-            .send(OtMessage::BaseSenderPayload(payload))
-            .await?;
-
-        let setup = self.ot.extension_setup(choice)?;
-
-        trace!("Sending OtReceiverSetup");
-        self.stream.send(OtMessage::ReceiverSetup(setup)).await?;
-
-        let payload = match self.stream.next().await {
-            Some(Ok(OtMessage::SenderPayload(m))) => m,
-            Some(Ok(m)) => return Err(OtError::Unexpected(m)),
-            Some(Err(e)) => return Err(e)?,
-            None => return Err(IOError::new(ErrorKind::UnexpectedEof, ""))?,
-        };
-        trace!("Received OtSenderPayload");
-
-        let values = self.ot.receive(choice, payload.try_into().unwrap())?;
-
-        Ok(values)
-    }
-}

mpc-core/benches/ot.rs

@@ -19,7 +19,7 @@ fn criterion_benchmark(c: &mut Criterion) {
 
             let receiver_setup = receiver.setup(&choice, sender_setup).unwrap();
             let send = sender.send(&s_inputs, receiver_setup).unwrap();
-            let receive = receiver.receive(&choice, send).unwrap();
+            let receive = receiver.receive(send).unwrap();
             black_box(receive);
         });
     });

mpc-core/examples/ot.rs

@@ -25,11 +25,11 @@ pub fn main() {
 
     println!("Sender inputs: {:?}", &inputs);
 
-    // First the receiver creates a setup message and passes it to sender
+    // First the sender creates a setup message and passes it to sender
     let mut sender = SenderCore::default();
     let setup = sender.setup();
 
-    // Sender takes receiver's setup and creates its own setup message
+    // Receiver takes sender's setup and creates its own setup message
     let mut receiver = ReceiverCore::default();
     let setup = receiver.setup(&choice, setup).unwrap();
 
@@ -37,7 +37,7 @@ pub fn main() {
     let payload = sender.send(&inputs, setup).unwrap();
 
     // Receiver takes the encrypted inputs and is able to decrypt according to their choice bits
-    let received = receiver.receive(&choice, payload).unwrap();
+    let received = receiver.receive(payload).unwrap();
 
     println!("Transferred messages: {:?}", received);
 }

mpc-core/src/ot/base/mod.rs

@@ -28,11 +28,7 @@ pub trait ReceiveCore {
         sender_setup: SenderSetup,
     ) -> Result<ReceiverSetup, ReceiverCoreError>;
 
-    fn receive(
-        &mut self,
-        choice: &[bool],
-        payload: SenderPayload,
-    ) -> Result<Vec<crate::Block>, ReceiverCoreError>;
+    fn receive(&mut self, payload: SenderPayload) -> Result<Vec<crate::Block>, ReceiverCoreError>;
 }
 
 #[cfg(test)]
@@ -80,7 +76,7 @@ pub mod tests {
             let receiver_setup = receiver.setup(choice, sender_setup.clone()).unwrap();
 
             let sender_payload = sender.send(values, receiver_setup.clone()).unwrap();
-            let receiver_values = receiver.receive(choice, sender_payload.clone()).unwrap();
+            let receiver_values = receiver.receive(sender_payload.clone()).unwrap();
 
             Data {
                 sender_setup,
@@ -113,7 +109,7 @@ pub mod tests {
         let receiver_setup = receiver.setup(&choice, sender_setup).unwrap();
 
         let send = sender.send(&s_inputs, receiver_setup).unwrap();
-        let receive = receiver.receive(&choice, send).unwrap();
+        let receive = receiver.receive(send).unwrap();
         assert_eq!(expected, receive);
     }
 }

mpc-core/src/ot/base/receiver.rs

@@ -19,6 +19,7 @@ pub enum State {
 pub struct ReceiverCore<R> {
     rng: R,
     hashes: Option<Vec<Block>>,
+    choice: Option<Vec<bool>>,
     state: State,
 }
 
@@ -38,6 +39,7 @@ impl<R: Rng + CryptoRng> ReceiverCore<R> {
         Self {
             rng,
             hashes: None,
+            choice: None,
             state: State::Initialized,
         }
     }
@@ -68,23 +70,22 @@ impl<R: Rng + CryptoRng> ReceiveCore for ReceiverCore<R> {
             })
             .unzip();
         self.hashes = Some(hashes);
-
+        self.choice = Some(Vec::from(choice));
         self.state = State::Setup;
 
         Ok(ReceiverSetup { keys })
     }
 
-    fn receive(
-        &mut self,
-        choice: &[bool],
-        payload: SenderPayload,
-    ) -> Result<Vec<Block>, ReceiverCoreError> {
+    fn receive(&mut self, payload: SenderPayload) -> Result<Vec<Block>, ReceiverCoreError> {
         if self.state < State::Setup {
             return Err(ReceiverCoreError::NotSetup);
         }
 
         let hashes = self.hashes.as_ref().unwrap();
-        let values: Vec<Block> = choice
+        let values: Vec<Block> = self
+            .choice
+            .as_ref()
+            .unwrap()
             .iter()
             .zip(hashes)
             .zip(payload.encrypted_values.iter())

mpc-core/src/ot/extension/receiver.rs

@@ -21,11 +21,11 @@ pub enum State {
     Complete,
 }
 
-pub struct ExtReceiverCore<R, C> {
+pub struct ExtReceiverCore<R, C, OT> {
     cipher: C,
     rng: R,
     state: State,
-    base: Box<dyn SendCore>,
+    base: OT,
     seeds: Option<Vec<[Block; 2]>>,
     rngs: Option<Vec<[ChaCha12Rng; 2]>>,
     table: Option<Vec<Vec<u8>>>,
@@ -37,18 +37,20 @@ pub struct ExtReceiverSetup {
     pub table: Vec<Vec<u8>>,
 }
 
-impl Default for ExtReceiverCore<ChaCha12Rng, Aes128> {
+impl Default for ExtReceiverCore<ChaCha12Rng, Aes128, SenderCore<ChaCha12Rng>> {
     fn default() -> Self {
         Self::new(
             ChaCha12Rng::from_entropy(),
             Aes128::new(GenericArray::from_slice(&[0u8; 16])),
-            Box::new(SenderCore::default()),
+            SenderCore::default(),
         )
     }
 }
 
-impl<R: Rng + CryptoRng, C: BlockCipher<BlockSize = U16> + BlockEncrypt> ExtReceiverCore<R, C> {
-    pub fn new(rng: R, cipher: C, ot: Box<dyn SendCore>) -> Self {
+impl<R: Rng + CryptoRng, C: BlockCipher<BlockSize = U16> + BlockEncrypt, OT: SendCore>
+    ExtReceiverCore<R, C, OT>
+{
+    pub fn new(rng: R, cipher: C, ot: OT) -> Self {
         Self {
             rng,
             cipher,
@@ -82,8 +84,11 @@ impl<R: Rng + CryptoRng, C: BlockCipher<BlockSize = U16> + BlockEncrypt> ExtRece
     }
 }
 
-impl<R: Rng + CryptoRng + SeedableRng, C: BlockCipher<BlockSize = U16> + BlockEncrypt>
-    ExtReceiveCore for ExtReceiverCore<R, C>
+impl<
+        R: Rng + CryptoRng + SeedableRng,
+        C: BlockCipher<BlockSize = U16> + BlockEncrypt,
+        OT: SendCore,
+    > ExtReceiveCore for ExtReceiverCore<R, C, OT>
 {
     fn state(&self) -> State {
         self.state

mpc-core/src/ot/extension/sender.rs

@@ -93,7 +93,7 @@ impl<C: BlockCipher<BlockSize = U16> + BlockEncrypt, OT: ReceiveCore> ExtSendCor
     }
 
     fn base_receive(&mut self, payload: BaseSenderPayload) -> Result<(), ExtSenderCoreError> {
-        let receive = self.base.receive(&self.base_choice, payload)?;
+        let receive = self.base.receive(payload)?;
         self.set_seeds(receive);
         self.state = State::BaseSetup;
         Ok(())