Fix chain combinator

Author: fjarri

Cargo.lock

@@ -49,15 +49,16 @@ Usage:
    when verifying evidence from the chained protocol.
 */
 
-use alloc::{boxed::Box, collections::BTreeMap};
+use alloc::{boxed::Box, collections::BTreeMap, format};
 use core::fmt::{self, Debug};
 
 use rand_core::CryptoRngCore;
 
 use crate::protocol::{
     Artifact, BoxedFormat, BoxedRound, BoxedRoundInfo, CommunicationInfo, DirectMessage, EchoBroadcast, EntryPoint,
     FinalizeOutcome, LocalError, MessageValidationError, NormalBroadcast, PartyId, Payload, Protocol, ProtocolError,
-    ProtocolMessage, ProtocolValidationError, ReceiveError, RequiredMessages, Round, RoundId, TransitionInfo,
+    ProtocolMessage, ProtocolValidationError, ReceiveError, RequiredMessages, Round, RoundId, RoundInfo,
+    TransitionInfo,
 };
 
 /// A marker trait that is used to disambiguate blanket trait implementations for [`Protocol`] and [`EntryPoint`].
@@ -197,62 +198,152 @@ where
     }
 }
 
-impl<Id, C> Protocol<Id> for C
+#[derive_where::derive_where(Debug)]
+struct RoundInfoWrapper1<Id: 'static, P: ChainedProtocol<Id> + ChainedMarker>(BoxedRoundInfo<Id, P::Protocol1>);
+
+impl<Id, P> RoundInfo<Id> for RoundInfoWrapper1<Id, P>
 where
-    Id: 'static,
-    C: ChainedProtocol<Id> + ChainedMarker,
+    P: ChainedProtocol<Id> + ChainedMarker,
 {
-    type Result = <C::Protocol2 as Protocol<Id>>::Result;
-    type ProtocolError = ChainedProtocolError<Id, C>;
+    type Protocol = P;
 
-    fn round_info(_round_id: &RoundId) -> Option<BoxedRoundInfo<Id, Self>> {
-        /*let rounds1 = C::Protocol1::rounds()
-            .into_iter()
-            .map(|(round_id, round)| (round_id.group_under(1), round));
-        let rounds2 = C::Protocol2::rounds()
-            .into_iter()
-            .map(|(round_id, round)| (round_id.group_under(2), round));
-        rounds1.chain(rounds2).collect()*/
-        unimplemented!()
+    fn verify_direct_message_is_invalid(
+        &self,
+        round_id: &RoundId,
+        format: &BoxedFormat,
+        message: &DirectMessage,
+        associated_data: &<<Self::Protocol as Protocol<Id>>::ProtocolError as ProtocolError<Id>>::AssociatedData,
+    ) -> Result<(), MessageValidationError> {
+        let (group, round_id) = round_id.split_group()?;
+        if group != 1 {
+            return Err(MessageValidationError::Local(LocalError::new(format!(
+                "Expected round ID from group 1, got {round_id}"
+            ))));
+        }
+        self.0
+            .as_ref()
+            .verify_direct_message_is_invalid(&round_id, format, message, &associated_data.protocol1)
     }
 
-    fn verify_direct_message_is_invalid(
+    fn verify_echo_broadcast_is_invalid(
+        &self,
+        round_id: &RoundId,
         format: &BoxedFormat,
+        message: &EchoBroadcast,
+        associated_data: &<<Self::Protocol as Protocol<Id>>::ProtocolError as ProtocolError<Id>>::AssociatedData,
+    ) -> Result<(), MessageValidationError> {
+        let (group, round_id) = round_id.split_group()?;
+        if group != 1 {
+            return Err(MessageValidationError::Local(LocalError::new(format!(
+                "Expected round ID from group 1, got {round_id}"
+            ))));
+        }
+        self.0
+            .as_ref()
+            .verify_echo_broadcast_is_invalid(&round_id, format, message, &associated_data.protocol1)
+    }
+
+    fn verify_normal_broadcast_is_invalid(
+        &self,
+        round_id: &RoundId,
+        format: &BoxedFormat,
+        message: &NormalBroadcast,
+        associated_data: &<<Self::Protocol as Protocol<Id>>::ProtocolError as ProtocolError<Id>>::AssociatedData,
+    ) -> Result<(), MessageValidationError> {
+        let (group, round_id) = round_id.split_group()?;
+        if group != 1 {
+            return Err(MessageValidationError::Local(LocalError::new(format!(
+                "Expected round ID from group 1, got {round_id}"
+            ))));
+        }
+        self.0
+            .as_ref()
+            .verify_normal_broadcast_is_invalid(&round_id, format, message, &associated_data.protocol1)
+    }
+}
+
+#[derive_where::derive_where(Debug)]
+struct RoundInfoWrapper2<Id: 'static, P: ChainedProtocol<Id> + ChainedMarker>(BoxedRoundInfo<Id, P::Protocol2>);
+
+impl<Id, P> RoundInfo<Id> for RoundInfoWrapper2<Id, P>
+where
+    P: ChainedProtocol<Id> + ChainedMarker,
+{
+    type Protocol = P;
+
+    fn verify_direct_message_is_invalid(
+        &self,
         round_id: &RoundId,
+        format: &BoxedFormat,
         message: &DirectMessage,
-        associated_data: &<Self::ProtocolError as ProtocolError<Id>>::AssociatedData,
+        associated_data: &<<Self::Protocol as Protocol<Id>>::ProtocolError as ProtocolError<Id>>::AssociatedData,
     ) -> Result<(), MessageValidationError> {
         let (group, round_id) = round_id.split_group()?;
-        if group == 1 {
-            C::Protocol1::verify_direct_message_is_invalid(format, &round_id, message, &associated_data.protocol1)
-        } else {
-            C::Protocol2::verify_direct_message_is_invalid(format, &round_id, message, &associated_data.protocol2)
+        if group != 2 {
+            return Err(MessageValidationError::Local(LocalError::new(format!(
+                "Expected round ID from group 2, got {round_id}"
+            ))));
         }
+        self.0
+            .as_ref()
+            .verify_direct_message_is_invalid(&round_id, format, message, &associated_data.protocol2)
     }
 
     fn verify_echo_broadcast_is_invalid(
-        format: &BoxedFormat,
+        &self,
         round_id: &RoundId,
+        format: &BoxedFormat,
         message: &EchoBroadcast,
+        associated_data: &<<Self::Protocol as Protocol<Id>>::ProtocolError as ProtocolError<Id>>::AssociatedData,
     ) -> Result<(), MessageValidationError> {
         let (group, round_id) = round_id.split_group()?;
-        if group == 1 {
-            C::Protocol1::verify_echo_broadcast_is_invalid(format, &round_id, message)
-        } else {
-            C::Protocol2::verify_echo_broadcast_is_invalid(format, &round_id, message)
+        if group != 2 {
+            return Err(MessageValidationError::Local(LocalError::new(format!(
+                "Expected round ID from group 2, got {round_id}"
+            ))));
         }
+        self.0
+            .as_ref()
+            .verify_echo_broadcast_is_invalid(&round_id, format, message, &associated_data.protocol2)
     }
 
     fn verify_normal_broadcast_is_invalid(
-        format: &BoxedFormat,
+        &self,
         round_id: &RoundId,
+        format: &BoxedFormat,
         message: &NormalBroadcast,
+        associated_data: &<<Self::Protocol as Protocol<Id>>::ProtocolError as ProtocolError<Id>>::AssociatedData,
     ) -> Result<(), MessageValidationError> {
         let (group, round_id) = round_id.split_group()?;
+        if group != 2 {
+            return Err(MessageValidationError::Local(LocalError::new(format!(
+                "Expected round ID from group 2, got {round_id}"
+            ))));
+        }
+        self.0
+            .as_ref()
+            .verify_normal_broadcast_is_invalid(&round_id, format, message, &associated_data.protocol2)
+    }
+}
+
+impl<Id, C> Protocol<Id> for C
+where
+    Id: 'static,
+    C: ChainedProtocol<Id> + ChainedMarker,
+{
+    type Result = <C::Protocol2 as Protocol<Id>>::Result;
+    type ProtocolError = ChainedProtocolError<Id, C>;
+
+    fn round_info(round_id: &RoundId) -> Option<BoxedRoundInfo<Id, Self>> {
+        let (group, round_id) = round_id.split_group().ok()?;
         if group == 1 {
-            C::Protocol1::verify_normal_broadcast_is_invalid(format, &round_id, message)
+            let round_info = C::Protocol1::round_info(&round_id)?;
+            Some(BoxedRoundInfo::new_obj(Box::new(RoundInfoWrapper1(round_info))))
+        } else if group == 2 {
+            let round_info = C::Protocol2::round_info(&round_id)?;
+            Some(BoxedRoundInfo::new_obj(Box::new(RoundInfoWrapper2(round_info))))
         } else {
-            C::Protocol2::verify_normal_broadcast_is_invalid(format, &round_id, message)
+            None
         }
     }
 }

manul/src/combinators/chain.rs

@@ -37,3 +37,4 @@ pub use static_round::{NoMessage, StaticProtocolMessage, StaticRound};
 
 pub(crate) use errors::ReceiveErrorType;
 pub(crate) use message::ProtocolMessagePartHashable;
+pub(crate) use round_info::RoundInfo;

manul/src/protocol.rs

@@ -14,7 +14,7 @@ use serde::{Deserialize, Serialize};
 use super::{
     boxed_format::BoxedFormat,
     boxed_round::BoxedRound,
-    errors::{LocalError, MessageValidationError, ProtocolValidationError, ReceiveError},
+    errors::{LocalError, ProtocolValidationError, ReceiveError},
     message::{DirectMessage, EchoBroadcast, NormalBroadcast, ProtocolMessage, ProtocolMessagePart},
     round_id::{RoundId, TransitionInfo},
     round_info::BoxedRoundInfo,
@@ -76,56 +76,6 @@ pub trait Protocol<Id>: 'static + Sized {
 
     /// Returns the wrapped round types for each round mapped to round IDs.
     fn round_info(round_id: &RoundId) -> Option<BoxedRoundInfo<Id, Self>>;
-
-    // TODO: move out of `Protocol`. To `evidence.rs`, perhaps?
-    /// Returns `Ok(())` if the given direct message cannot be deserialized
-    /// assuming it is a direct message from the round `round_id`.
-    ///
-    /// Normally one would use [`ProtocolMessagePart::verify_is_not`] and [`ProtocolMessagePart::verify_is_some`]
-    /// when implementing this.
-    fn verify_direct_message_is_invalid(
-        format: &BoxedFormat,
-        round_id: &RoundId,
-        message: &DirectMessage,
-        associated_data: &<Self::ProtocolError as ProtocolError<Id>>::AssociatedData,
-    ) -> Result<(), MessageValidationError> {
-        let round_info = Self::round_info(round_id).ok_or_else(|| {
-            MessageValidationError::Local(LocalError::new(format!("{round_id} is not in the protocol")))
-        })?;
-        round_info.verify_direct_message_is_invalid(round_id, format, message, associated_data)
-    }
-
-    /// Returns `Ok(())` if the given echo broadcast cannot be deserialized
-    /// assuming it is an echo broadcast from the round `round_id`.
-    ///
-    /// Normally one would use [`ProtocolMessagePart::verify_is_not`] and [`ProtocolMessagePart::verify_is_some`]
-    /// when implementing this.
-    fn verify_echo_broadcast_is_invalid(
-        format: &BoxedFormat,
-        round_id: &RoundId,
-        message: &EchoBroadcast,
-    ) -> Result<(), MessageValidationError> {
-        let round_info = Self::round_info(round_id).ok_or_else(|| {
-            MessageValidationError::Local(LocalError::new(format!("{round_id} is not in the protocol")))
-        })?;
-        round_info.verify_echo_broadcast_is_invalid(format, message)
-    }
-
-    /// Returns `Ok(())` if the given echo broadcast cannot be deserialized
-    /// assuming it is an echo broadcast from the round `round_id`.
-    ///
-    /// Normally one would use [`ProtocolMessagePart::verify_is_not`] and [`ProtocolMessagePart::verify_is_some`]
-    /// when implementing this.
-    fn verify_normal_broadcast_is_invalid(
-        format: &BoxedFormat,
-        round_id: &RoundId,
-        message: &NormalBroadcast,
-    ) -> Result<(), MessageValidationError> {
-        let round_info = Self::round_info(round_id).ok_or_else(|| {
-            MessageValidationError::Local(LocalError::new(format!("{round_id} is not in the protocol")))
-        })?;
-        round_info.verify_normal_broadcast_is_invalid(format, message)
-    }
 }
 
 /// Declares which parts of the message from a round have to be stored to serve as the evidence of malicious behavior.