Introduce IdSet and use it for normal rounds

Author: fjarri

manul/src/protocol.rs

@@ -26,7 +26,7 @@ pub use errors::{
 };
 pub use message::{DirectMessage, EchoBroadcast, NormalBroadcast, ProtocolMessage, ProtocolMessagePart};
 pub use round::{
-    Artifact, CommunicationInfo, EchoRoundParticipation, EntryPoint, FinalizeOutcome, NoProtocolErrors, PartyId,
+    Artifact, CommunicationInfo, EchoRoundParticipation, EntryPoint, FinalizeOutcome, IdSet, NoProtocolErrors, PartyId,
     Payload, Protocol, ProtocolError, RequiredMessageParts, RequiredMessages, Round,
 };
 pub use round_id::{RoundId, TransitionInfo};

manul/src/protocol/round.rs

@@ -19,6 +19,39 @@ use super::{
     round_id::{RoundId, TransitionInfo},
 };
 
+// TODO: make a trait to implement custom threshold strategies
+/// A set of IDs with an associated quorum condition.
+#[derive(Debug, Clone)]
+pub struct IdSet<Id> {
+    ids: BTreeSet<Id>,
+    threshold: usize,
+}
+
+impl<Id: Ord> IdSet<Id> {
+    /// Creates a non-threshold ID set (that is, messages from all `ids` must be present for the quorum).
+    pub fn new_non_threshold(ids: BTreeSet<Id>) -> Self {
+        let threshold = ids.len();
+        Self { ids, threshold }
+    }
+
+    /// Creates an empty ID set.
+    pub fn empty() -> Self {
+        Self {
+            ids: BTreeSet::new(),
+            threshold: 0,
+        }
+    }
+
+    pub(crate) fn all(&self) -> &BTreeSet<Id> {
+        &self.ids
+    }
+
+    pub(crate) fn is_quorum(&self, ids: &BTreeSet<Id>) -> bool {
+        // TODO: assuming `ids` are a subset of `self.ids`. Can we?
+        ids.len() >= self.threshold
+    }
+}
+
 /// Describes what other parties this rounds sends messages to, and what other parties it expects messages from.
 #[derive(Debug, Clone)]
 pub struct CommunicationInfo<Id> {
@@ -35,7 +68,7 @@ pub struct CommunicationInfo<Id> {
     ///
     /// The execution layer will not call [`finalize`](`Round::finalize`) until all these nodes have responded
     /// (and the corresponding [`receive_message`](`Round::receive_message`) finished successfully).
-    pub expecting_messages_from: BTreeSet<Id>,
+    pub expecting_messages_from: IdSet<Id>,
 
     /// Returns the specific way the node participates in the echo round following this round.
     ///
@@ -50,7 +83,7 @@ impl<Id: PartyId> CommunicationInfo<Id> {
     pub fn regular(other_parties: &BTreeSet<Id>) -> Self {
         Self {
             message_destinations: other_parties.clone(),
-            expecting_messages_from: other_parties.clone(),
+            expecting_messages_from: IdSet::new_non_threshold(other_parties.clone()),
             echo_round_participation: EchoRoundParticipation::Default,
         }
     }

manul/src/session/session.rs

@@ -24,8 +24,8 @@ use super::{
 };
 use crate::protocol::{
     Artifact, BoxedFormat, BoxedRound, CommunicationInfo, DirectMessage, EchoBroadcast, EchoRoundParticipation,
-    EntryPoint, FinalizeOutcome, NormalBroadcast, PartyId, Payload, Protocol, ProtocolMessage, ProtocolMessagePart,
-    ReceiveError, ReceiveErrorType, RoundId, TransitionInfo,
+    EntryPoint, FinalizeOutcome, IdSet, NormalBroadcast, PartyId, Payload, Protocol, ProtocolMessage,
+    ProtocolMessagePart, ReceiveError, ReceiveErrorType, RoundId, TransitionInfo,
 };
 
 /// A set of types needed to execute a session.
@@ -100,7 +100,7 @@ impl AsRef<[u8]> for SessionId {
 #[derive(Debug)]
 pub(crate) struct EchoRoundInfo<Verifier> {
     pub(crate) message_destinations: BTreeSet<Verifier>,
-    pub(crate) expecting_messages_from: BTreeSet<Verifier>,
+    pub(crate) expecting_messages_from: IdSet<Verifier>,
     pub(crate) expected_echos: BTreeSet<Verifier>,
 }
 
@@ -180,11 +180,14 @@ where
             EchoRoundParticipation::Default => {
                 if round_sends_echo_broadcast {
                     // Add our own echo message to the expected list because we expect it to be sent back from other nodes.
-                    let mut expected_echos = communication_info.expecting_messages_from.clone();
+                    let mut expected_echos = communication_info.expecting_messages_from.all().clone();
                     expected_echos.insert(verifier.clone());
                     Some(EchoRoundInfo {
                         message_destinations: communication_info.message_destinations.clone(),
-                        expecting_messages_from: communication_info.message_destinations.clone(),
+                        // TODO: this is not correct in general
+                        expecting_messages_from: IdSet::new_non_threshold(
+                            communication_info.message_destinations.clone(),
+                        ),
                         expected_echos,
                     })
                 } else {
@@ -194,8 +197,9 @@ where
             EchoRoundParticipation::Send => None,
             EchoRoundParticipation::Receive { echo_targets } => Some(EchoRoundInfo {
                 message_destinations: echo_targets.clone(),
-                expecting_messages_from: echo_targets.clone(),
-                expected_echos: communication_info.expecting_messages_from.clone(),
+                // TODO: this is not correct in general
+                expecting_messages_from: IdSet::new_non_threshold(echo_targets.clone()),
+                expected_echos: communication_info.expecting_messages_from.all().clone(),
             }),
         };
 
@@ -546,7 +550,7 @@ pub enum CanFinalize {
 #[derive_where::derive_where(Debug)]
 pub struct RoundAccumulator<P: Protocol<SP::Verifier>, SP: SessionParameters> {
     still_have_not_sent_messages: BTreeSet<SP::Verifier>,
-    expecting_messages_from: BTreeSet<SP::Verifier>,
+    expecting_messages_from: IdSet<SP::Verifier>,
     processing: BTreeSet<SP::Verifier>,
     payloads: BTreeMap<SP::Verifier, Payload>,
     artifacts: BTreeMap<SP::Verifier, Artifact>,
@@ -563,9 +567,9 @@ where
     P: Protocol<SP::Verifier>,
     SP: SessionParameters,
 {
-    fn new(expecting_messages_from: &BTreeSet<SP::Verifier>) -> Self {
+    fn new(expecting_messages_from: &IdSet<SP::Verifier>) -> Self {
         Self {
-            still_have_not_sent_messages: expecting_messages_from.clone(),
+            still_have_not_sent_messages: expecting_messages_from.all().clone(),
             expecting_messages_from: expecting_messages_from.clone(),
             processing: BTreeSet::new(),
             payloads: BTreeMap::new(),
@@ -582,8 +586,7 @@ where
     fn can_finalize(&self) -> CanFinalize {
         if self
             .expecting_messages_from
-            .iter()
-            .all(|key| self.payloads.contains_key(key))
+            .is_quorum(&self.payloads.keys().cloned().collect::<BTreeSet<_>>())
         {
             CanFinalize::Yes
         } else if !self.still_have_not_sent_messages.is_empty() {

manul/src/tests/partial_echo.rs

@@ -13,8 +13,8 @@ use crate::{
     dev::{run_sync, BinaryFormat, TestSessionParams, TestSigner, TestVerifier},
     protocol::{
         Artifact, BoxedFormat, BoxedRound, CommunicationInfo, DirectMessage, EchoBroadcast, EchoRoundParticipation,
-        EntryPoint, FinalizeOutcome, LocalError, MessageValidationError, NoProtocolErrors, NormalBroadcast, PartyId,
-        Payload, Protocol, ProtocolMessage, ProtocolMessagePart, ReceiveError, Round, RoundId, TransitionInfo,
+        EntryPoint, FinalizeOutcome, IdSet, LocalError, MessageValidationError, NoProtocolErrors, NormalBroadcast,
+        PartyId, Payload, Protocol, ProtocolMessage, ProtocolMessagePart, ReceiveError, Round, RoundId, TransitionInfo,
     },
     signature::Keypair,
 };
@@ -55,7 +55,7 @@ impl<Id: PartyId> Protocol<Id> for PartialEchoProtocol<Id> {
 struct Inputs<Id> {
     id: Id,
     message_destinations: BTreeSet<Id>,
-    expecting_messages_from: BTreeSet<Id>,
+    expecting_messages_from: IdSet<Id>,
     echo_round_participation: EchoRoundParticipation<Id>,
 }
 
@@ -127,12 +127,13 @@ impl<Id: PartyId + Serialize + for<'de> Deserialize<'de>> Round<Id> for Round1<I
         message.normal_broadcast.assert_is_none()?;
         message.direct_message.assert_is_none()?;
 
-        if self.inputs.expecting_messages_from.is_empty() {
+        // TODO: or use an Option<>?
+        if self.inputs.expecting_messages_from.all().is_empty() {
             message.echo_broadcast.assert_is_none()?;
         } else {
             let echo = message.echo_broadcast.deserialize::<Round1Echo<Id>>(format)?;
             assert_eq!(&echo.sender, from);
-            assert!(self.inputs.expecting_messages_from.contains(from));
+            assert!(self.inputs.expecting_messages_from.all().contains(from));
         }
 
         Ok(Payload::new(()))
@@ -163,7 +164,7 @@ fn partial_echo() {
         Inputs {
             id: signers[0].verifying_key(),
             message_destinations: BTreeSet::from([ids[1], ids[2], ids[3]]),
-            expecting_messages_from: BTreeSet::new(),
+            expecting_messages_from: IdSet::empty(),
             echo_round_participation: EchoRoundParticipation::Send,
         },
     );
@@ -172,7 +173,7 @@ fn partial_echo() {
         Inputs {
             id: signers[1].verifying_key(),
             message_destinations: BTreeSet::from([ids[2], ids[3]]),
-            expecting_messages_from: BTreeSet::from([ids[0]]),
+            expecting_messages_from: IdSet::new_non_threshold([ids[0]].into()),
             echo_round_participation: EchoRoundParticipation::Default,
         },
     );
@@ -181,7 +182,7 @@ fn partial_echo() {
         Inputs {
             id: signers[2].verifying_key(),
             message_destinations: BTreeSet::new(),
-            expecting_messages_from: BTreeSet::from([ids[0], ids[1]]),
+            expecting_messages_from: IdSet::new_non_threshold([ids[0], ids[1]].into()),
             echo_round_participation: EchoRoundParticipation::Receive {
                 echo_targets: BTreeSet::from([ids[1], ids[3]]),
             },
@@ -192,7 +193,7 @@ fn partial_echo() {
         Inputs {
             id: signers[3].verifying_key(),
             message_destinations: BTreeSet::new(),
-            expecting_messages_from: BTreeSet::from([ids[0], ids[1]]),
+            expecting_messages_from: IdSet::new_non_threshold([ids[0], ids[1]].into()),
             echo_round_participation: EchoRoundParticipation::Receive {
                 echo_targets: BTreeSet::from([ids[1], ids[2]]),
             },
@@ -203,7 +204,7 @@ fn partial_echo() {
         Inputs {
             id: signers[4].verifying_key(),
             message_destinations: BTreeSet::new(),
-            expecting_messages_from: BTreeSet::new(),
+            expecting_messages_from: IdSet::empty(),
             echo_round_participation: EchoRoundParticipation::<TestVerifier>::Default,
         },
     );