Protocol combinators

CHANGELOG.md

@@ -14,7 +14,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `SessionId::new()` renamed to `from_seed()`. ([#41])
 - `FirstRound::new()` takes a `&[u8]` instead of a `SessionId` object. ([#41])
 - The signatures of `Round::make_echo_broadcast()`, `Round::make_direct_message()`, and `Round::receive_message()`, take messages without `Option`s. ([#46])
-- `Round::make_direct_message_with_artifact()` is the method returning an artifact now; `Round::make_direct_message()` is a shortcut for cases where no artifact is returned. ([#46])
 - `Artifact::empty()` removed, the user should return `None` instead. ([#46])
 - `EchoBroadcast` and `DirectMessage` now use `ProtocolMessagePart` trait for their methods. ([#47])
 - Added normal broadcasts support in addition to echo ones; signatures of `Round` methods changed accordingly; added `Round::make_normal_broadcast()`. ([#47])

examples/src/lib.rs

@@ -1,6 +1,7 @@
 extern crate alloc;
 
 pub mod simple;
+mod simple_chain;
 
 #[cfg(test)]
 mod simple_malicious;

examples/src/simple.rs

@@ -228,14 +228,15 @@ impl<Id: PartyId> Round<Id> for Round1<Id> {
         _rng: &mut impl CryptoRngCore,
         serializer: &Serializer,
         destination: &Id,
-    ) -> Result<DirectMessage, LocalError> {
+    ) -> Result<(DirectMessage, Option<Artifact>), LocalError> {
         debug!("{:?}: making direct message for {:?}", self.context.id, destination);
 
         let message = Round1Message {
             my_position: self.context.ids_to_positions[&self.context.id],
             your_position: self.context.ids_to_positions[destination],
         };
-        DirectMessage::new(serializer, message)
+        let dm = DirectMessage::new(serializer, message)?;
+        Ok((dm, None))
     }
 
     fn receive_message(
@@ -325,14 +326,15 @@ impl<Id: PartyId> Round<Id> for Round2<Id> {
         _rng: &mut impl CryptoRngCore,
         serializer: &Serializer,
         destination: &Id,
-    ) -> Result<DirectMessage, LocalError> {
+    ) -> Result<(DirectMessage, Option<Artifact>), LocalError> {
         debug!("{:?}: making direct message for {:?}", self.context.id, destination);
 
         let message = Round2Message {
             my_position: self.context.ids_to_positions[&self.context.id],
             your_position: self.context.ids_to_positions[destination],
         };
-        DirectMessage::new(serializer, message)
+        let dm = DirectMessage::new(serializer, message)?;
+        Ok((dm, None))
     }
 
     fn receive_message(

examples/src/simple_chain.rs

@@ -0,0 +1,86 @@
+use core::fmt::Debug;
+use core::marker::PhantomData;
+
+use manul::{combinators::*, protocol::PartyId};
+
+use super::simple::{Inputs, Round1, SimpleProtocol};
+
+pub struct ChainedSimple<Id>(PhantomData<Id>);
+
+#[derive(Debug)]
+pub struct NewInputs<Id>(Inputs<Id>);
+
+impl<'a, Id: PartyId> From<&'a NewInputs<Id>> for Inputs<Id> {
+    fn from(source: &'a NewInputs<Id>) -> Self {
+        source.0.clone()
+    }
+}
+
+impl<Id: PartyId> From<(NewInputs<Id>, u8)> for Inputs<Id> {
+    fn from(source: (NewInputs<Id>, u8)) -> Self {
+        source.0 .0
+    }
+}
+
+impl<Id: PartyId> Chained<Id> for ChainedSimple<Id> {
+    type Protocol1 = SimpleProtocol;
+    type Protocol2 = SimpleProtocol;
+    type CorrectnessProof = ();
+    type Inputs = NewInputs<Id>;
+    type EntryPoint1 = Round1<Id>;
+    type EntryPoint2 = Round1<Id>;
+}
+
+#[cfg(test)]
+mod tests {
+    use alloc::collections::BTreeSet;
+
+    use manul::{
+        combinators::Chain,
+        session::{signature::Keypair, SessionOutcome},
+        testing::{run_sync, BinaryFormat, TestSessionParams, TestSigner, TestVerifier},
+    };
+    use rand_core::OsRng;
+    use tracing_subscriber::EnvFilter;
+
+    use super::{ChainedSimple, NewInputs};
+    use crate::simple::Inputs;
+
+    #[test]
+    fn round() {
+        let signers = (0..3).map(TestSigner::new).collect::<Vec<_>>();
+        let all_ids = signers
+            .iter()
+            .map(|signer| signer.verifying_key())
+            .collect::<BTreeSet<_>>();
+        let inputs = signers
+            .into_iter()
+            .map(|signer| {
+                (
+                    signer,
+                    NewInputs(Inputs {
+                        all_ids: all_ids.clone(),
+                    }),
+                )
+            })
+            .collect::<Vec<_>>();
+
+        let my_subscriber = tracing_subscriber::fmt()
+            .with_env_filter(EnvFilter::from_default_env())
+            .finish();
+        let reports = tracing::subscriber::with_default(my_subscriber, || {
+            run_sync::<Chain<TestVerifier, ChainedSimple<TestVerifier>>, TestSessionParams<BinaryFormat>>(
+                &mut OsRng, inputs,
+            )
+            .unwrap()
+        });
+
+        for (_id, report) in reports {
+            if let SessionOutcome::Result(result) = report.outcome {
+                assert_eq!(result, 3); // 0 + 1 + 2
+            } else {
+                panic!("Session did not finish successfully");
+            }
+        }
+    }
+}