Remove RecvInfo and SendInfo and keep only phase instead

Author: kisakishy

docs/src/examples/channel.md

@@ -3,7 +3,7 @@
 The `Channel` trait in our MPC engine provides a flexible and extensible abstraction for message-passing between parties. It allows communication to be implemented in various ways, enabling users to choose between platform-specific implementations. Polytune is deliberately communication-agnostic, while remaining quite flexible, offering the following features:
 
 - **Customizable Transport**: Implement the `Channel` trait using any transport mechanism — HTTP, WebSockets, in-memory queues, or custom networking protocols.
-- **Serialization-Aware**: The trait ensures that messages can be efficiently serialized and chunked when necessary, making it ideal for large payloads.
+- **Serialization-Aware**: The trait ensures that messages can be efficiently serialized.
 
 We provide example implementations for:
 
@@ -37,13 +37,13 @@ trait Channel {
         &self,
         p: usize,
         msg: Vec<u8>,
-        info: SendInfo,
+        phase: &str,
     ) -> Result<(), Self::SendError>;
 
     async fn recv_bytes_from(
         &self,
         p: usize,
-        info: RecvInfo,
+        phase: &str,
     ) -> Result<Vec<u8>, Self::RecvError>;
 }
 ```
@@ -53,7 +53,7 @@ trait Channel {
 1. **Channel Parameters**:
 
    - `p`: Index of the target party for send/receive
-   - `info`: Various information useful for logging
+   - `phase`: Phase of the protocol where the message is sent
    - `msg`: Message sent to the target party (only in `send_bytes_to`)
 
 2. **Connection Management**:

examples/api-integration/src/main.rs

@@ -8,7 +8,7 @@ use axum::{
 };
 use clap::Parser;
 use polytune::{
-    channel::{Channel, RecvInfo, SendInfo},
+    channel::Channel,
     garble_lang::{compile_with_constants, literal::Literal},
     mpc,
 };
@@ -373,13 +373,12 @@ impl Channel for HttpChannel {
         &self,
         p: usize,
         msg: Vec<u8>,
-        info: SendInfo,
+        phase: &str,
     ) -> Result<(), Self::SendError> {
         let simulated_delay_in_ms = 300;
         let client = reqwest::Client::new();
         let url = format!("{}msg/{}", self.urls[p], self.party);
         let mb = msg.len() as f64 / 1024.0 / 1024.0;
-        let phase = info.phase();
         info!("Sending msg {phase} to party {p} ({mb:.2}MB)...");
         loop {
             sleep(Duration::from_millis(simulated_delay_in_ms)).await;
@@ -402,7 +401,7 @@ impl Channel for HttpChannel {
         }
     }
 
-    async fn recv_bytes_from(&self, p: usize, _info: RecvInfo) -> Result<Vec<u8>, Self::RecvError> {
+    async fn recv_bytes_from(&self, p: usize, _phase: &str) -> Result<Vec<u8>, Self::RecvError> {
         let mut r = self.recv[p].lock().await;
         timeout(Duration::from_secs(30 * 60), r.recv())
             .await

examples/http-multi-server-channels/src/main.rs

@@ -7,7 +7,7 @@ use axum::{
 };
 use clap::Parser;
 use polytune::{
-    channel::{Channel, RecvInfo, SendInfo},
+    channel::Channel,
     garble_lang::compile,
     mpc,
 };
@@ -112,7 +112,7 @@ impl Channel for HttpChannel {
         &self,
         p: usize,
         msg: Vec<u8>,
-        _info: SendInfo,
+        _phase: &str,
     ) -> Result<(), Self::SendError> {
         let client = reqwest::Client::new();
         let url = format!("{}msg/{}", self.urls[p], self.party);
@@ -133,7 +133,7 @@ impl Channel for HttpChannel {
         }
     }
 
-    async fn recv_bytes_from(&self, p: usize, _info: RecvInfo) -> Result<Vec<u8>, Self::RecvError> {
+    async fn recv_bytes_from(&self, p: usize, _phase: &str) -> Result<Vec<u8>, Self::RecvError> {
         let mut r = self.recv[p].lock().await;
         Ok(timeout(Duration::from_secs(1), r.recv())
             .await

examples/http-single-server-channels/src/http_channel.rs

@@ -1,6 +1,6 @@
 use std::time::Duration;
 
-use polytune::channel::{Channel, RecvInfo, SendInfo};
+use polytune::channel::Channel;
 use reqwest::StatusCode;
 use tokio::time::sleep;
 
@@ -62,7 +62,7 @@ impl Channel for PollingHttpChannel {
         &self,
         p: usize,
         msg: Vec<u8>,
-        _info: SendInfo,
+        _phase: &str,
     ) -> Result<(), HttpChannelError> {
         let url = format!("{}/send/{}/{}/{}", self.url, self.session, self.party, p);
         let resp: reqwest::Response = self.client.post(url).body(msg).send().await?;
@@ -76,7 +76,7 @@ impl Channel for PollingHttpChannel {
     async fn recv_bytes_from(
         &self,
         p: usize,
-        _info: RecvInfo,
+        _phase: &str,
     ) -> Result<Vec<u8>, HttpChannelError> {
         let url = format!("{}/recv/{}/{}/{}", self.url, self.session, p, self.party);
         let mut attempts = 0;

examples/sql-integration/src/main.rs

@@ -8,7 +8,7 @@ use axum::{
 };
 use clap::Parser;
 use polytune::{
-    channel::{Channel, RecvInfo, SendInfo},
+    channel::Channel,
     garble_lang::{
         ast::{Type, Variant},
         compile_with_constants,
@@ -689,13 +689,12 @@ impl Channel for HttpChannel {
         &self,
         p: usize,
         msg: Vec<u8>,
-        info: SendInfo,
+        phase: &str,
     ) -> Result<(), Self::SendError> {
         let simulated_delay_in_ms = 300;
         let client = reqwest::Client::new();
         let url = format!("{}msg/{}", self.urls[p], self.party);
         let mb = msg.len() as f64 / 1024.0 / 1024.0;
-        let phase = info.phase();
         info!("Sending msg {phase} to party {p} ({mb:.2}MB)...");
         loop {
             sleep(Duration::from_millis(simulated_delay_in_ms)).await;
@@ -718,7 +717,7 @@ impl Channel for HttpChannel {
         }
     }
 
-    async fn recv_bytes_from(&self, p: usize, _info: RecvInfo) -> Result<Vec<u8>, Self::RecvError> {
+    async fn recv_bytes_from(&self, p: usize, _phase: &str) -> Result<Vec<u8>, Self::RecvError> {
         let mut r = self.recv[p].lock().await;
         timeout(Duration::from_secs(30 * 60), r.recv())
             .await

examples/wasm-http-channels/src/lib.rs

@@ -2,7 +2,7 @@ use std::str::FromStr;
 
 use gloo_timers::future::TimeoutFuture;
 use polytune::{
-    channel::{Channel, RecvInfo, SendInfo},
+    channel::Channel,
     garble_lang::{compile, literal::Literal, token::SignedNumType},
     mpc,
 };
@@ -64,7 +64,7 @@ impl Channel for HttpChannel {
         &self,
         p: usize,
         msg: Vec<u8>,
-        _info: SendInfo,
+        _phase: &str,
     ) -> Result<(), Self::SendError> {
         let client = reqwest::Client::new();
         let url = format!("{}send/{}/{}", self.url, self.party, p);
@@ -83,7 +83,7 @@ impl Channel for HttpChannel {
         return Err(format!("Could not reach {url}"));
     }
 
-    async fn recv_bytes_from(&self, p: usize, _info: RecvInfo) -> Result<Vec<u8>, Self::RecvError> {
+    async fn recv_bytes_from(&self, p: usize, _phase: &str) -> Result<Vec<u8>, Self::RecvError> {
         let client = reqwest::Client::new();
         let url = format!("{}recv/{}/{}", self.url, self.party, p);
         for _ in 0..50 {

src/channel.rs

@@ -57,32 +57,6 @@ pub enum ErrorKind {
     InvalidLength,
 }
 
-/// Information about a sent message that can be useful for logging.
-#[derive(Debug, Clone)]
-pub struct SendInfo {
-    phase: String,
-}
-
-impl SendInfo {
-    /// The name of the protocol phase that sent the message.
-    pub fn phase(&self) -> &str {
-        &self.phase
-    }
-}
-
-/// Information about a received message that can be useful for logging.
-#[derive(Debug, Clone)]
-pub struct RecvInfo {
-    phase: String,
-}
-
-impl RecvInfo {
-    /// The name of the protocol phase that sent the message.
-    pub fn phase(&self) -> &str {
-        &self.phase
-    }
-}
-
 /// A communication channel used to send/receive messages to/from another party.
 ///
 /// This trait defines the core interface for message transport in the protocol.
@@ -102,16 +76,16 @@ pub trait Channel {
     async fn send_bytes_to(
         &self,
         party: usize,
-        chunk: Vec<u8>,
-        info: SendInfo,
+        data: Vec<u8>,
+        phase: &str,
     ) -> Result<(), Self::SendError>;
 
     /// Awaits a response from the party with the given index (must be between `0..participants`).
     #[allow(async_fn_in_trait)]
     async fn recv_bytes_from(
         &self,
         party: usize,
-        info: RecvInfo,
+        phase: &str,
     ) -> Result<Vec<u8>, Self::RecvError>;
 }
 
@@ -126,11 +100,8 @@ pub(crate) async fn send_to<S: Serialize + std::fmt::Debug>(
         phase: format!("sending {phase}"),
         reason: ErrorKind::SerdeError(format!("{e:?}")),
     })?;
-    let info = SendInfo {
-        phase: phase.to_string(),
-    };
     channel
-        .send_bytes_to(party, data, info)
+        .send_bytes_to(party, data, phase)
         .await
         .map_err(|e| Error {
             phase: phase.to_string(),
@@ -145,11 +116,8 @@ pub(crate) async fn recv_from<T: DeserializeOwned + std::fmt::Debug>(
     party: usize,
     phase: &str,
 ) -> Result<Vec<T>, Error> {
-    let info = RecvInfo {
-        phase: phase.to_string(),
-    };
     let data = channel
-        .recv_bytes_from(party, info)
+        .recv_bytes_from(party, phase)
         .await
         .map_err(|e| Error {
             phase: phase.to_string(),
@@ -370,7 +338,7 @@ impl Channel for SimpleChannel {
         &self,
         p: usize,
         msg: Vec<u8>,
-        info: SendInfo,
+        phase: &str,
     ) -> Result<(), tokio::sync::mpsc::error::SendError<Vec<u8>>> {
         self.bytes_sent
             .fetch_add(msg.len() as u64, Ordering::Relaxed);
@@ -383,19 +351,19 @@ impl Channel for SimpleChannel {
             .await
     }
 
-    #[tracing::instrument(level = Level::TRACE, skip(self), fields(info = ?_info))]
-    async fn recv_bytes_from(&self, p: usize, _info: RecvInfo) -> Result<Vec<u8>, AsyncRecvError> {
+    #[tracing::instrument(level = Level::TRACE, skip(self), fields(phase = ?_phase))]
+    async fn recv_bytes_from(&self, p: usize, _phase: &str) -> Result<Vec<u8>, AsyncRecvError> {
         let mut r = self.r[p]
             .as_ref()
             .unwrap_or_else(|| panic!("No receiver for party {p}"))
             .lock()
             .await;
-        let chunk = r.recv();
-        match tokio::time::timeout(std::time::Duration::from_secs(10 * 60), chunk).await {
-            Ok(Some(chunk)) => {
-                let mb = chunk.len() as f64 / 1024.0 / 1024.0;
-                trace!(size = mb, "Received chunk");
-                Ok(chunk)
+        let data = r.recv();
+        match tokio::time::timeout(std::time::Duration::from_secs(10 * 60), data).await {
+            Ok(Some(data)) => {
+                let mb = data.len() as f64 / 1024.0 / 1024.0;
+                trace!(size = mb, "Received data");
+                Ok(data)
             }
             Ok(None) => Err(AsyncRecvError::Closed),
             Err(_) => Err(AsyncRecvError::TimeoutElapsed),