Fix a bug in the echo round where the guilty party was assigned incorrectly

Author: fjarri

manul/src/session/echo.rs

@@ -34,7 +34,12 @@ pub(crate) enum EchoRoundError<Id> {
     ///
     /// The attached identifier points out the sender for whom the echoed message was invalid,
     /// to speed up the verification process.
-    InvalidEcho(Id),
+    InvalidEcho {
+        // Even though this will be the same as the message sender, it is convenient to record it here
+        // because of the way this error will be processed.
+        guilty_party: Id,
+        failed_for: Id,
+    },
     /// The originally received message and the one received in the echo pack were both valid,
     /// but different.
     ///
@@ -49,7 +54,7 @@ pub(crate) enum EchoRoundError<Id> {
 impl<Id> EchoRoundError<Id> {
     pub(crate) fn description(&self) -> String {
         match self {
-            Self::InvalidEcho(_) => "Invalid message received among the ones echoed".into(),
+            Self::InvalidEcho { .. } => "Invalid message received among the ones echoed".into(),
             Self::MismatchedBroadcasts { .. } => {
                 "The echoed message is different from the originally received one".into()
             }
@@ -236,17 +241,29 @@ where
                 // This means `from` sent us an incorrectly signed message.
                 // Provable fault of `from`.
                 Err(MessageVerificationError::InvalidSignature) => {
-                    return Err(EchoRoundError::InvalidEcho(sender.clone()).into())
+                    return Err(EchoRoundError::InvalidEcho {
+                        guilty_party: from.clone(),
+                        failed_for: sender.clone(),
+                    }
+                    .into())
                 }
                 Err(MessageVerificationError::SignatureMismatch) => {
-                    return Err(EchoRoundError::InvalidEcho(sender.clone()).into())
+                    return Err(EchoRoundError::InvalidEcho {
+                        guilty_party: from.clone(),
+                        failed_for: sender.clone(),
+                    }
+                    .into())
                 }
             };
 
             // `from` sent us a correctly signed message but from another round or another session.
             // Provable fault of `from`.
             if verified_echo.metadata() != previously_received_echo.metadata() {
-                return Err(EchoRoundError::InvalidEcho(sender.clone()).into());
+                return Err(EchoRoundError::InvalidEcho {
+                    guilty_party: from.clone(),
+                    failed_for: sender.clone(),
+                }
+                .into());
             }
 
             // `sender` sent us and `from` messages with different payloads,

manul/src/session/evidence.rs

@@ -164,18 +164,20 @@ where
     }
 
     pub(crate) fn new_echo_round_error(
-        verifier: &SP::Verifier,
         normal_broadcast: SignedMessagePart<NormalBroadcast>,
         error: EchoRoundError<SP::Verifier>,
     ) -> Result<Self, LocalError> {
         let description = format!("Echo round error: {}", error.description());
         match error {
-            EchoRoundError::InvalidEcho(from) => Ok(Self {
-                guilty_party: verifier.clone(),
+            EchoRoundError::InvalidEcho {
+                guilty_party,
+                failed_for,
+            } => Ok(Self {
+                guilty_party,
                 description,
                 evidence: EvidenceEnum::InvalidEchoPack(InvalidEchoPackEvidence {
                     normal_broadcast,
-                    invalid_echo_sender: from,
+                    invalid_echo_sender: failed_for,
                 }),
             }),
             EchoRoundError::MismatchedBroadcasts {

manul/src/session/session.rs

@@ -738,7 +738,7 @@ where
             ReceiveErrorType::Unprovable(error) => self.register_unprovable_error(&from, error),
             ReceiveErrorType::Echo(error) => {
                 let (_echo_broadcast, normal_broadcast, _direct_message) = processed.message.into_parts();
-                let evidence = Evidence::new_echo_round_error(&from, normal_broadcast, *error)?;
+                let evidence = Evidence::new_echo_round_error(normal_broadcast, *error)?;
                 self.register_provable_error(&from, evidence)
             }
             ReceiveErrorType::Local(error) => Err(error),