Temporary

Author: fjarri

manul/src/protocol.rs

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

manul/src/protocol/round.rs

@@ -57,9 +57,22 @@ impl<Id: Ord> IdSet<Id> {
     }
 }
 
-/// Describes what other parties this rounds sends messages to, and what other parties it expects messages from.
+/// Encapsulates the communication info for the main round and the possible echo round.
 #[derive(Debug, Clone)]
 pub struct CommunicationInfo<Id> {
+    /// Communication info for the main part of the round (that is, not considering the echo round).
+    pub main_round: RoundCommunicationInfo<Id>,
+
+    /// The specific way the node participates in the echo round following this round.
+    ///
+    /// `None` means that, if there is an echo round, the message destinations and expected messages senders
+    /// are the same as in the main round.
+    pub echo_round: EchoRoundCommunicationInfo<Id>,
+}
+
+/// Describes what other parties this rounds sends messages to, and what other parties it expects messages from.
+#[derive(Debug, Clone)]
+pub struct RoundCommunicationInfo<Id> {
     /// The destinations of the messages to be sent out by this round.
     ///
     /// The way it is interpreted by the execution layer is
@@ -69,29 +82,35 @@ pub struct CommunicationInfo<Id> {
     ///   for each element of the returned set.
     pub message_destinations: BTreeSet<Id>,
 
-    /// Returns the set of node IDs from which this round expects messages.
+    /// The set of node IDs from which this round expects messages.
     ///
-    /// 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).
+    /// The execution layer will not call [`finalize`](`Round::finalize`) until enough nodes to constitute the quorum
+    /// have responded (and the corresponding [`receive_message`](`Round::receive_message`) finished successfully).
     pub expecting_messages_from: IdSet<Id>,
-
-    /// Returns the specific way the node participates in the echo round following this round.
-    ///
-    /// Returns [`EchoRoundParticipation::Default`] by default; this works fine when every node
-    /// sends messages to every other one, or do not send or receive any echo broadcasts.
-    /// Otherwise, review the options in [`EchoRoundParticipation`] and pick the appropriate one.
-    pub echo_round_participation: EchoRoundParticipation<Id>,
 }
 
-impl<Id: PartyId> CommunicationInfo<Id> {
+impl<Id: PartyId> RoundCommunicationInfo<Id> {
     /// A regular round that sends messages to all `other_parties`, and expects messages back from them.
-    pub fn regular(other_parties: &BTreeSet<Id>) -> Self {
+    pub fn all_to_all(other_parties: &BTreeSet<Id>) -> Self {
         Self {
             message_destinations: other_parties.clone(),
             expecting_messages_from: IdSet::new_non_threshold(other_parties.clone()),
-            echo_round_participation: EchoRoundParticipation::Default,
         }
     }
+
+    pub fn none() -> Self {
+        Self {
+            message_destinations: BTreeSet::new(),
+            expecting_messages_from: IdSet::empty(),
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum EchoRoundCommunicationInfo<Id> {
+    None,
+    SameAsMainRound,
+    Custom(RoundCommunicationInfo<Id>),
 }
 
 /// Possible successful outcomes of [`Round::finalize`].
@@ -376,25 +395,6 @@ pub trait PartyId: 'static + Debug + Clone + Ord + Send + Sync + Serialize + for
 
 impl<T> PartyId for T where T: 'static + Debug + Clone + Ord + Send + Sync + Serialize + for<'de> Deserialize<'de> {}
 
-/// The specific way the node participates in the echo round (if any).
-#[derive(Debug, Clone)]
-pub enum EchoRoundParticipation<Id> {
-    /// The default behavior: sends broadcasts and receives echoed messages, or does neither.
-    ///
-    /// That is, this node will be a part of the echo round if [`Round::make_echo_broadcast`] generates a message.
-    Default,
-
-    /// This node sends broadcasts that will be echoed, but does not receive any.
-    Send,
-
-    /// This node receives broadcasts that it needs to echo, but does not send any itself.
-    Receive {
-        /// The other participants of the echo round
-        /// (that is, the nodes to which echoed messages will be sent).
-        echo_targets: BTreeSet<Id>,
-    },
-}
-
 mod sealed {
     /// A dyn safe trait to get the type's ID.
     pub trait DynTypeId: 'static {

manul/src/session/session.rs

@@ -23,9 +23,9 @@ use super::{
     LocalError, RemoteError,
 };
 use crate::protocol::{
-    Artifact, BoxedFormat, BoxedRound, CommunicationInfo, DirectMessage, EchoBroadcast, EchoRoundParticipation,
+    Artifact, BoxedFormat, BoxedRound, CommunicationInfo, DirectMessage, EchoBroadcast, EchoRoundCommunicationInfo,
     EntryPoint, FinalizeOutcome, IdSet, NormalBroadcast, PartyId, Payload, Protocol, ProtocolMessage,
-    ProtocolMessagePart, ReceiveError, ReceiveErrorType, RoundId, TransitionInfo,
+    ProtocolMessagePart, ReceiveError, ReceiveErrorType, RoundCommunicationInfo, RoundId, TransitionInfo,
 };
 
 /// A set of types needed to execute a session.
@@ -97,13 +97,6 @@ impl AsRef<[u8]> for SessionId {
     }
 }
 
-#[derive(Debug)]
-pub(crate) struct EchoRoundInfo<Verifier> {
-    pub(crate) message_destinations: BTreeSet<Verifier>,
-    pub(crate) expecting_messages_from: IdSet<Verifier>,
-    pub(crate) expected_echos: BTreeSet<Verifier>,
-}
-
 /// An object encapsulating the currently active round, transport protocol,
 /// and the database of messages and errors from the previous rounds.
 #[derive(Debug)]
@@ -114,8 +107,9 @@ pub struct Session<P: Protocol<SP::Verifier>, SP: SessionParameters> {
     format: BoxedFormat,
     round: BoxedRound<SP::Verifier, P>,
     message_destinations: BTreeSet<SP::Verifier>,
-    communication_info: CommunicationInfo<SP::Verifier>,
-    echo_round_info: Option<EchoRoundInfo<SP::Verifier>>,
+    main_round_cinfo: CommunicationInfo<SP::Verifier>,
+    echo_round_cinfo: CommunicationInfo<SP::Verifier>,
+    expected_echos: BTreeSet<SP::Verifier>,
     echo_broadcast: SignedMessagePart<EchoBroadcast>,
     normal_broadcast: SignedMessagePart<NormalBroadcast>,
     transition_info: TransitionInfo,
@@ -174,40 +168,39 @@ where
         let normal = round.as_ref().make_normal_broadcast(rng, &format)?;
         let normal_broadcast = SignedMessagePart::new::<SP>(rng, &signer, &session_id, &transition_info.id(), normal)?;
 
-        let communication_info = round.as_ref().communication_info();
-        let message_destinations = communication_info
+        let CommunicationInfo {
+            main_round: main_round_cinfo,
+            echo_round: echo_round_cinfo,
+        } = round.as_ref().communication_info();
+
+        let (echo_round_cinfo, expected_echos) = match echo_round_cinfo {
+            EchoRoundCommunicationInfo::None => {
+                let echo_round_cinfo = RoundCommunicationInfo::none();
+                let expected_echos = BTreeSet::new();
+                (echo_round_cinfo, expected_echos)
+            }
+            EchoRoundCommunicationInfo::SameAsMainRound => {
+                let echo_round_cinfo = main_round_cinfo.clone();
+                let mut expected_echos = main_round_cinfo.expecting_messages_from.all().clone();
+                // Add our own echo message to the expected list because we expect it to be sent back from other nodes.
+                expected_echos.insert(verifier.clone());
+                (echo_round_cinfo, expected_echos)
+            }
+            EchoRoundCommunicationInfo::Custom(cinfo) => {
+                let mut expected_echos = main_round_cinfo.expecting_messages_from.all().clone();
+                // Add our own echo message to the expected list because we expect it to be sent back from other nodes.
+                expected_echos.insert(verifier.clone());
+                (cinfo, expected_echos)
+            }
+        };
+
+        let message_destinations = main_round_cinfo
             .message_destinations
             .difference(&transcript.banned_ids())
             .cloned()
             .collect::<BTreeSet<_>>();
 
         let round_sends_echo_broadcast = !echo_broadcast.payload().is_none();
-        let echo_round_info = match &communication_info.echo_round_participation {
-            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.all().clone();
-                    expected_echos.insert(verifier.clone());
-                    Some(EchoRoundInfo {
-                        message_destinations: 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 {
-                    None
-                }
-            }
-            EchoRoundParticipation::Send => None,
-            EchoRoundParticipation::Receive { echo_targets } => Some(EchoRoundInfo {
-                message_destinations: echo_targets.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(),
-            }),
-        };
 
         Ok(Self {
             session_id,