Add StaticRound to eliminate some boilerplate when writing protocols

Make Round2 static as well

Make payloads and artifacts typed

Don't use postcard to create NoMessage

Author: fjarri

examples/src/simple.rs

@@ -2,10 +2,10 @@ use alloc::collections::{BTreeMap, BTreeSet};
 use core::fmt::Debug;
 
 use manul::protocol::{
-    Artifact, BoxedFormat, BoxedRound, CommunicationInfo, DirectMessage, EchoBroadcast, EntryPoint, FinalizeOutcome,
-    LocalError, MessageValidationError, NormalBroadcast, PartyId, Payload, Protocol, ProtocolError, ProtocolMessage,
-    ProtocolMessagePart, ProtocolValidationError, ReceiveError, RequiredMessageParts, RequiredMessages, Round, RoundId,
-    TransitionInfo,
+    BoxedFormat, BoxedRound, CommunicationInfo, DirectMessage, EchoBroadcast, EntryPoint, FinalizeOutcome, LocalError,
+    MessageValidationError, NoMessage, NormalBroadcast, PartyId, Protocol, ProtocolError, ProtocolMessage,
+    ProtocolMessagePart, ProtocolValidationError, ReceiveError, RequiredMessageParts, RequiredMessages, RoundId,
+    StaticProtocolMessage, StaticRound, TransitionInfo,
 };
 use rand_core::CryptoRngCore;
 use serde::{Deserialize, Serialize};
@@ -121,7 +121,7 @@ pub(crate) struct Context<Id> {
 }
 
 #[derive(Debug)]
-pub struct Round1<Id> {
+pub(crate) struct Round1<Id> {
     pub(crate) context: Context<Id>,
 }
 
@@ -132,17 +132,17 @@ pub(crate) struct Round1Message {
 }
 
 #[derive(Serialize, Deserialize)]
-struct Round1Echo {
+pub(crate) struct Round1Echo {
     my_position: u8,
 }
 
 #[derive(Serialize, Deserialize)]
-struct Round1Broadcast {
+pub(crate) struct Round1Broadcast {
     x: u8,
     my_position: u8,
 }
 
-struct Round1Payload {
+pub(crate) struct Round1Payload {
     x: u8,
 }
 
@@ -182,7 +182,7 @@ impl<Id: PartyId> EntryPoint<Id> for SimpleProtocolEntryPoint<Id> {
         let mut ids = self.all_ids;
         ids.remove(id);
 
-        Ok(BoxedRound::new_dynamic(Round1 {
+        Ok(BoxedRound::new_static(Round1 {
             context: Context {
                 id: id.clone(),
                 other_ids: ids,
@@ -192,7 +192,7 @@ impl<Id: PartyId> EntryPoint<Id> for SimpleProtocolEntryPoint<Id> {
     }
 }
 
-impl<Id: PartyId> Round<Id> for Round1<Id> {
+impl<Id: PartyId> StaticRound<Id> for Round1<Id> {
     type Protocol = SimpleProtocol;
 
     fn transition_info(&self) -> TransitionInfo {
@@ -203,92 +203,71 @@ impl<Id: PartyId> Round<Id> for Round1<Id> {
         CommunicationInfo::regular(&self.context.other_ids)
     }
 
-    fn make_normal_broadcast(
-        &self,
-        _rng: &mut dyn CryptoRngCore,
-        format: &BoxedFormat,
-    ) -> Result<NormalBroadcast, LocalError> {
-        debug!("{:?}: making normal broadcast", self.context.id);
+    type NormalBroadcast = Round1Broadcast;
+    type EchoBroadcast = Round1Echo;
+    type DirectMessage = Round1Message;
 
-        let message = Round1Broadcast {
+    type Payload = Round1Payload;
+    type Artifact = ();
+
+    fn make_normal_broadcast(&self, _rng: &mut dyn CryptoRngCore) -> Result<Self::NormalBroadcast, LocalError> {
+        debug!("{:?}: making normal broadcast", self.context.id);
+        Ok(Round1Broadcast {
             x: 0,
             my_position: self.context.ids_to_positions[&self.context.id],
-        };
-
-        NormalBroadcast::new(format, message)
+        })
     }
 
-    fn make_echo_broadcast(
-        &self,
-        _rng: &mut dyn CryptoRngCore,
-        format: &BoxedFormat,
-    ) -> Result<EchoBroadcast, LocalError> {
+    fn make_echo_broadcast(&self, _rng: &mut dyn CryptoRngCore) -> Result<Self::EchoBroadcast, LocalError> {
         debug!("{:?}: making echo broadcast", self.context.id);
-
-        let message = Round1Echo {
+        Ok(Round1Echo {
             my_position: self.context.ids_to_positions[&self.context.id],
-        };
-
-        EchoBroadcast::new(format, message)
+        })
     }
 
     fn make_direct_message(
         &self,
         _rng: &mut dyn CryptoRngCore,
-        format: &BoxedFormat,
         destination: &Id,
-    ) -> Result<(DirectMessage, Option<Artifact>), LocalError> {
+    ) -> Result<(Self::DirectMessage, Option<Self::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],
         };
-        let dm = DirectMessage::new(format, message)?;
-        Ok((dm, None))
+        Ok((message, Some(())))
     }
 
     fn receive_message(
         &self,
-        format: &BoxedFormat,
         from: &Id,
-        message: ProtocolMessage,
-    ) -> Result<Payload, ReceiveError<Id, Self::Protocol>> {
+        message: StaticProtocolMessage<Id, Self>,
+    ) -> Result<Self::Payload, ReceiveError<Id, Self::Protocol>> {
         debug!("{:?}: receiving message from {:?}", self.context.id, from);
-
-        let _echo = message.echo_broadcast.deserialize::<Round1Echo>(format)?;
-        let _normal = message.normal_broadcast.deserialize::<Round1Broadcast>(format)?;
-        let message = message.direct_message.deserialize::<Round1Message>(format)?;
-
-        debug!("{:?}: received message: {:?}", self.context.id, message);
+        let message = message.direct_message;
 
         if self.context.ids_to_positions[&self.context.id] != message.your_position {
             return Err(ReceiveError::protocol(SimpleProtocolError::Round1InvalidPosition));
         }
-
-        Ok(Payload::new(Round1Payload { x: message.my_position }))
+        Ok(Round1Payload { x: message.my_position })
     }
 
     fn finalize(
-        self: Box<Self>,
+        self,
         _rng: &mut dyn CryptoRngCore,
-        payloads: BTreeMap<Id, Payload>,
-        _artifacts: BTreeMap<Id, Artifact>,
+        payloads: BTreeMap<Id, Self::Payload>,
+        _artifacts: BTreeMap<Id, Self::Artifact>,
     ) -> Result<FinalizeOutcome<Id, Self::Protocol>, LocalError> {
         debug!(
             "{:?}: finalizing with messages from {:?}",
             self.context.id,
             payloads.keys().cloned().collect::<Vec<_>>()
         );
 
-        let typed_payloads = payloads
-            .into_values()
-            .map(|payload| payload.downcast::<Round1Payload>())
-            .collect::<Result<Vec<_>, _>>()?;
-        let sum = self.context.ids_to_positions[&self.context.id]
-            + typed_payloads.iter().map(|payload| payload.x).sum::<u8>();
+        let sum =
+            self.context.ids_to_positions[&self.context.id] + payloads.values().map(|payload| payload.x).sum::<u8>();
 
-        let round2 = BoxedRound::new_dynamic(Round2 {
+        let round2 = BoxedRound::new_static(Round2 {
             round1_sum: sum,
             context: self.context,
         });
@@ -308,7 +287,7 @@ pub(crate) struct Round2Message {
     pub(crate) your_position: u8,
 }
 
-impl<Id: PartyId> Round<Id> for Round2<Id> {
+impl<Id: PartyId> StaticRound<Id> for Round2<Id> {
     type Protocol = SimpleProtocol;
 
     fn transition_info(&self) -> TransitionInfo {
@@ -319,62 +298,59 @@ impl<Id: PartyId> Round<Id> for Round2<Id> {
         CommunicationInfo::regular(&self.context.other_ids)
     }
 
+    type DirectMessage = Round2Message;
+    type EchoBroadcast = NoMessage;
+    type NormalBroadcast = NoMessage;
+
+    type Payload = Round1Payload;
+    type Artifact = ();
+
     fn make_direct_message(
         &self,
         _rng: &mut dyn CryptoRngCore,
-        format: &BoxedFormat,
         destination: &Id,
-    ) -> Result<(DirectMessage, Option<Artifact>), LocalError> {
+    ) -> Result<(Self::DirectMessage, Option<Self::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],
         };
-        let dm = DirectMessage::new(format, message)?;
-        Ok((dm, None))
+        Ok((message, Some(())))
     }
 
     fn receive_message(
         &self,
-        format: &BoxedFormat,
         from: &Id,
-        message: ProtocolMessage,
-    ) -> Result<Payload, ReceiveError<Id, Self::Protocol>> {
+        message: StaticProtocolMessage<Id, Self>,
+    ) -> Result<Self::Payload, ReceiveError<Id, Self::Protocol>> {
         debug!("{:?}: receiving message from {:?}", self.context.id, from);
 
-        message.echo_broadcast.assert_is_none()?;
-        message.normal_broadcast.assert_is_none()?;
-
-        let message = message.direct_message.deserialize::<Round1Message>(format)?;
+        let message = message.direct_message;
 
         debug!("{:?}: received message: {:?}", self.context.id, message);
 
         if self.context.ids_to_positions[&self.context.id] != message.your_position {
             return Err(ReceiveError::protocol(SimpleProtocolError::Round2InvalidPosition));
         }
 
-        Ok(Payload::new(Round1Payload { x: message.my_position }))
+        Ok(Round1Payload { x: message.my_position })
     }
 
     fn finalize(
-        self: Box<Self>,
+        self: Self,
         _rng: &mut dyn CryptoRngCore,
-        payloads: BTreeMap<Id, Payload>,
-        _artifacts: BTreeMap<Id, Artifact>,
+        payloads: BTreeMap<Id, Self::Payload>,
+        _artifacts: BTreeMap<Id, Self::Artifact>,
     ) -> Result<FinalizeOutcome<Id, Self::Protocol>, LocalError> {
         debug!(
             "{:?}: finalizing with messages from {:?}",
             self.context.id,
             payloads.keys().cloned().collect::<Vec<_>>()
         );
 
-        let typed_payloads = payloads
-            .into_values()
-            .map(|payload| payload.downcast::<Round1Payload>())
-            .collect::<Result<Vec<_>, _>>()?;
-        let sum = self.context.ids_to_positions[&self.context.id]
-            + typed_payloads.iter().map(|payload| payload.x).sum::<u8>();
+        let sum =
+            self.context.ids_to_positions[&self.context.id] + payloads.values().map(|payload| payload.x).sum::<u8>();
 
         Ok(FinalizeOutcome::Result(sum + self.round1_sum))
     }

examples/src/simple_malicious.rs

@@ -39,7 +39,7 @@ impl<Id: PartyId> Misbehaving<Id, Behavior> for MaliciousLogic {
             match behavior {
                 Behavior::SerializedGarbage => DirectMessage::new(format, [99u8])?,
                 Behavior::AttributableFailure => {
-                    let round1 = round.downcast_ref::<Round1<Id>>()?;
+                    let round1 = round.downcast_static_ref::<Round1<Id>>()?;
                     let message = Round1Message {
                         my_position: round1.context.ids_to_positions[&round1.context.id],
                         your_position: round1.context.ids_to_positions[&round1.context.id],
@@ -51,7 +51,7 @@ impl<Id: PartyId> Misbehaving<Id, Behavior> for MaliciousLogic {
         } else if round.id() == 2 {
             match behavior {
                 Behavior::AttributableFailureRound2 => {
-                    let round2 = round.downcast_ref::<Round2<Id>>()?;
+                    let round2 = round.downcast_static_ref::<Round2<Id>>()?;
                     let message = Round2Message {
                         my_position: round2.context.ids_to_positions[&round2.context.id],
                         your_position: round2.context.ids_to_positions[&round2.context.id],

manul/src/protocol.rs

@@ -17,6 +17,7 @@ mod errors;
 mod message;
 mod round;
 mod round_id;
+mod static_round;
 
 pub use boxed_format::BoxedFormat;
 pub use boxed_round::BoxedRound;
@@ -30,6 +31,7 @@ pub use round::{
     Payload, Protocol, ProtocolError, RequiredMessageParts, RequiredMessages, Round,
 };
 pub use round_id::{RoundId, TransitionInfo};
+pub use static_round::{NoMessage, StaticProtocolMessage, StaticRound};
 
 pub(crate) use errors::ReceiveErrorType;
 pub(crate) use message::ProtocolMessagePartHashable;

manul/src/protocol/boxed_round.rs

@@ -4,6 +4,7 @@ use super::{
     errors::LocalError,
     round::{PartyId, Protocol, Round},
     round_id::RoundId,
+    static_round::{StaticRound, StaticRoundAdapter},
 };
 
 /// A wrapped new round that may be returned by [`Round::finalize`]
@@ -17,6 +18,11 @@ impl<Id: PartyId, P: Protocol<Id>> BoxedRound<Id, P> {
         Self(Box::new(round))
     }
 
+    /// Wraps an object implementing the dynamic round trait ([`StaticRound`](`crate::protocol::StaticRound`)).
+    pub fn new_static<R: StaticRound<Id, Protocol = P>>(round: R) -> Self {
+        Self(Box::new(StaticRoundAdapter::new(round)))
+    }
+
     pub(crate) fn as_ref(&self) -> &dyn Round<Id, Protocol = P> {
         self.0.as_ref()
     }
@@ -64,6 +70,22 @@ impl<Id: PartyId, P: Protocol<Id>> BoxedRound<Id, P> {
         }
     }
 
+    /// Attempts to provide a reference to an object of a concrete type.
+    ///
+    /// Fails if the wrapped type is not `T`.
+    pub fn downcast_static_ref<T: StaticRound<Id>>(&self) -> Result<&T, LocalError> {
+        if self.boxed_type_is::<StaticRoundAdapter<T>>() {
+            let ptr: *const dyn Round<Id, Protocol = P> = self.0.as_ref();
+            // Safety: This is safe since we just checked that we are casting to the correct type.
+            Ok(unsafe { &*(ptr as *const StaticRoundAdapter<T>) }.as_inner())
+        } else {
+            Err(LocalError::new(format!(
+                "Failed to downcast into type {}",
+                core::any::type_name::<T>()
+            )))
+        }
+    }
+
     /// Returns the round's ID.
     pub fn id(&self) -> RoundId {
         // This constructs a new `TransitionInfo` object, so calling this method inside `Session`

manul/src/protocol/round.rs

@@ -384,7 +384,7 @@ mod sealed {
     impl<T: 'static> DynTypeId for T {}
 }
 
-use sealed::DynTypeId;
+pub(crate) use sealed::DynTypeId;
 
 /**
 A type representing a single round of a protocol.