Temporary

Author: fjarri

examples/src/simple.rs

@@ -200,7 +200,7 @@ impl<Id: PartyId> Round<Id> for Round1<Id> {
     }
 
     fn communication_info(&self) -> CommunicationInfo<Id> {
-        CommunicationInfo::regular(&self.context.other_ids)
+        CommunicationInfo::all_to_all(&self.context.other_ids)
     }
 
     fn make_normal_broadcast(

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, 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,41 @@ 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.
+    ///
+    /// If `None`, and there is an echo round, will be set to `main_round`.
+    pub echo_round: Option<RoundCommunicationInfo<Id>>,
+
+    /// The parties whose echoed messages this node expects to receive in the echo round (if any).
+    ///
+    /// If `None`, and there is an echo round, will be set to `echo_round.expecting_messages_from`.
+    pub expected_echos: Option<IdSet<Id>>,
+}
+
+impl<Id: PartyId> CommunicationInfo<Id> {
+    /// A regular round that sends messages to all `other_parties`, and expects messages back from them.
+    pub fn all_to_all(id_set: &IdSet<Id>) -> Self {
+        Self {
+            main_round: RoundCommunicationInfo::all_to_all(id_set),
+            echo_round: None,
+            expected_echos: None,
+        }
+    }
+
+    pub fn set_to_set(senders: &IdSet<Id>, receivers: &IdSet<Id>, my_id: &Id) -> Self {
+        todo!()
+    }
+}
+
+/// 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,27 +101,26 @@ 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(id_set: &IdSet<Id>) -> Self {
+        Self {
+            message_destinations: id_set.all().clone(),
+            expecting_messages_from: id_set.clone(),
+        }
+    }
+
+    pub fn none() -> Self {
         Self {
-            message_destinations: other_parties.clone(),
-            expecting_messages_from: IdSet::new_non_threshold(other_parties.clone()),
-            echo_round_participation: EchoRoundParticipation::Default,
+            message_destinations: BTreeSet::new(),
+            expecting_messages_from: IdSet::empty(),
         }
     }
 }
@@ -376,25 +407,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/echo.rs

@@ -13,12 +13,12 @@ use tracing::debug;
 
 use super::{
     message::{MessageVerificationError, SignedMessageHash, SignedMessagePart},
-    session::{EchoRoundInfo, SessionParameters},
+    session::{SessionParameters},
     LocalError,
 };
 use crate::{
-    protocol::{
-        Artifact, BoxedFormat, BoxedRound, CommunicationInfo, DirectMessage, EchoBroadcast, EchoRoundParticipation,
+    protocol::{RoundCommunicationInfo, IdSet,
+        Artifact, BoxedFormat, BoxedRound, CommunicationInfo, DirectMessage, EchoBroadcast,
         FinalizeOutcome, MessageValidationError, NormalBroadcast, Payload, Protocol, ProtocolMessage,
         ProtocolMessagePart, ReceiveError, Round, TransitionInfo,
     },
@@ -75,8 +75,9 @@ pub(crate) struct EchoRoundMessage<SP: SessionParameters> {
 pub struct EchoRound<P: Protocol<SP::Verifier>, SP: SessionParameters> {
     verifier: SP::Verifier,
     echo_broadcasts: BTreeMap<SP::Verifier, SignedMessagePart<EchoBroadcast>>,
-    echo_round_info: EchoRoundInfo<SP::Verifier>,
     communication_info: CommunicationInfo<SP::Verifier>,
+    expected_echos: IdSet<SP::Verifier>,
+    banned_ids: BTreeSet<SP::Verifier>,
     main_round: BoxedRound<SP::Verifier, P>,
     payloads: BTreeMap<SP::Verifier, Payload>,
     artifacts: BTreeMap<SP::Verifier, Artifact>,
@@ -90,24 +91,25 @@ where
     pub fn new(
         verifier: SP::Verifier,
         echo_broadcasts: BTreeMap<SP::Verifier, SignedMessagePart<EchoBroadcast>>,
-        echo_round_info: EchoRoundInfo<SP::Verifier>,
+        communication_info: RoundCommunicationInfo<SP::Verifier>,
+        expected_echos: IdSet<SP::Verifier>,
+        banned_ids: BTreeSet<SP::Verifier>,
         main_round: BoxedRound<SP::Verifier, P>,
         payloads: BTreeMap<SP::Verifier, Payload>,
         artifacts: BTreeMap<SP::Verifier, Artifact>,
     ) -> Self {
-        debug!("{:?}: initialized echo round with {:?}", verifier, echo_round_info);
-
+        debug!("{:?}: initialized echo round with {:?} {:?}", verifier, communication_info, expected_echos);
         let communication_info = CommunicationInfo {
-            message_destinations: echo_round_info.message_destinations.clone(),
-            expecting_messages_from: echo_round_info.expecting_messages_from.clone(),
-            echo_round_participation: EchoRoundParticipation::Default,
+            main_round: communication_info,
+            echo_round: None,
+            expected_echos: None,
         };
-
         Self {
             verifier,
             echo_broadcasts,
-            echo_round_info,
             communication_info,
+            expected_echos,
+            banned_ids,
             main_round,
             payloads,
             artifacts,
@@ -197,23 +199,16 @@ where
         let message = message.normal_broadcast.deserialize::<EchoRoundMessage<SP>>(format)?;
 
         // Check that the received message contains entries from `expected_echos`.
-        // It is an unprovable fault.
+        // Since we cannot guarantee the communication info for the echo round is in the associated data,
+        // we cannot construct an evidence for this fault.
 
-        let mut expected_keys = self.echo_round_info.expected_echos.clone();
+        let mut expected_keys = self.expected_echos.all().clone();
 
         // We don't expect the node to send its echo the second time.
         expected_keys.remove(from);
 
         let message_keys = message.message_hashes.keys().cloned().collect::<BTreeSet<_>>();
 
-        let missing_keys = expected_keys.difference(&message_keys).collect::<Vec<_>>();
-        if !missing_keys.is_empty() {
-            return Err(ReceiveError::unprovable(format!(
-                "Missing echoed messages from: {:?}",
-                missing_keys
-            )));
-        }
-
         let extra_keys = message_keys.difference(&expected_keys).collect::<Vec<_>>();
         if !extra_keys.is_empty() {
             return Err(ReceiveError::unprovable(format!(
@@ -222,6 +217,14 @@ where
             )));
         }
 
+        // Check that the echos we received, minus the banned IDs, constitute a quorum.
+        // This is also unprovable since the information about the IDs we banned is not available to third parties.
+
+        let expected_keys = message_keys.difference(&self.banned_ids).cloned().collect::<BTreeSet<_>>();
+        if !self.expected_echos.is_quorum(&expected_keys) {
+            return Err(ReceiveError::unprovable("Not enough echos to constitute a quorum"));
+        }
+
         // Check that every entry is equal to what we received previously (in the main round).
         // If there's a difference, it's a provable fault,
         // since we have both messages signed by `from`.

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,
     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: RoundCommunicationInfo<SP::Verifier>,
+    echo_round_cinfo: RoundCommunicationInfo<SP::Verifier>,
+    expected_echos: IdSet<SP::Verifier>,
     echo_broadcast: SignedMessagePart<EchoBroadcast>,
     normal_broadcast: SignedMessagePart<NormalBroadcast>,
     transition_info: TransitionInfo,
@@ -174,41 +168,21 @@ 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,
+            expected_echos,
+        } = round.as_ref().communication_info();
+
+        let echo_round_cinfo = echo_round_cinfo.unwrap_or(main_round_cinfo.clone());
+        let expected_echos = expected_echos.unwrap_or(echo_round_cinfo.expecting_messages_from.clone());
+
+        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,
             signer,
@@ -219,8 +193,9 @@ where
             normal_broadcast,
             transition_info,
             message_destinations,
-            communication_info,
-            echo_round_info,
+            main_round_cinfo,
+            echo_round_cinfo,
+            expected_echos,
             transcript,
         })
     }
@@ -343,7 +318,7 @@ where
 
         let acceptable_round_ids = self
             .transition_info
-            .simultaneous_rounds(self.echo_round_info.is_some())?;
+            .simultaneous_rounds(self.echo_round_cinfo.is_some())?;
 
         let message_for = if message_round_id == self.round_id() {
             if accum.message_is_being_processed(from) {
@@ -431,7 +406,7 @@ where
     /// Makes an accumulator for a new round.
     pub fn make_accumulator(&self) -> RoundAccumulator<P, SP> {
         RoundAccumulator::new(
-            &self.communication_info.expecting_messages_from,
+            &self.main_round_cinfo.expecting_messages_from,
             self.transcript.banned_ids(),
         )
     }
@@ -484,6 +459,8 @@ where
         let verifier = self.verifier().clone();
         let round_id = self.round_id();
 
+        let echo_round = !self.echo_broadcast.payload().is_none();
+
         let transcript = self.transcript.update(
             &round_id,
             (verifier.clone(), self.echo_broadcast),
@@ -495,11 +472,13 @@ where
             accum.still_have_not_sent_messages,
         )?;
 
-        if let Some(echo_round_info) = self.echo_round_info {
+        if echo_round {
             let round = BoxedRound::new_dynamic(EchoRound::<P, SP>::new(
                 verifier,
                 transcript.echo_broadcasts(&round_id)?,
-                echo_round_info,
+                self.echo_round_cinfo,
+                self.expected_echos,
+                transcript.banned_ids().clone(),
                 self.round,
                 accum.payloads,
                 accum.artifacts,